Beispiel #1
0
func main() {
	flag.StringVar(&addr, "a", addr, "listen address")
	flag.StringVar(&dir, "d", dir, "manifest directory")
	flag.StringVar(&name, "n", name, "govisor name")
	flag.BoolVar(&enable, "e", enable, "enable all services")
	flag.Parse()

	m := govisor.NewManager(name)
	m.StartMonitoring()

	svcDir := path.Join(dir, "services")

	if d, e := os.Open(svcDir); e != nil {
		log.Fatalf("Failed to open services directory %s: %v",
			svcDir, e)
	} else if files, e := d.Readdirnames(-1); e != nil {
		log.Fatalf("Failed to scan scan services: %v", e)
	} else {
		for _, f := range files {
			fname := path.Join(svcDir, f)
			if mf, e := os.Open(fname); e != nil {
				log.Printf("Failed to open manifest %s: %v",
					fname, e)
				mf.Close()
				continue
			} else if p, e := govisor.NewProcessFromJson(mf); e != nil {
				log.Printf("Failed to load manifest %s: %v",
					fname, e)
				mf.Close()
				continue
			} else {
				m.AddService(p)
				mf.Close()
			}
		}
	}
	if enable {
		for _, s := range m.Services() {
			s.Enable()
		}
	}
	sigs := make(chan os.Signal, 1)
	done := make(chan bool, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

	go func() {
		log.Fatal(http.ListenAndServe(addr, rpc.NewHandler(m)))
	}()

	// Set up a handler, so that we shutdown cleanly if possible.
	go func() {
		<-sigs
		done <- true
	}()

	// Wait for a termination signal, and shutdown cleanly if we get it.
	<-done
	m.Shutdown()
	os.Exit(1)
}
Beispiel #2
0
func main() {
	dir := "."
	name := "govisord"
	enable := true
	passFile := ""
	genpass := ""
	certFile := ""
	keyFile := ""
	m := govisor.NewManager(name)

	flag.StringVar(&certFile, "certfile", certFile, "certificate file (for TLS)")
	flag.StringVar(&keyFile, "keyfile", keyFile, "key file (for TLS)")
	flag.StringVar(&addr, "addr", addr, "listen address")
	flag.StringVar(&dir, "dir", dir, "configuration directory")
	flag.StringVar(&name, "name", name, "govisor name")
	flag.BoolVar(&enable, "enable", enable, "enable all services")
	flag.StringVar(&passFile, "passfile", passFile, "password file")
	flag.StringVar(&genpass, "passwd", genpass, "generate password")
	flag.StringVar(&logFile, "logfile", logFile, "log file")
	flag.Parse()

	var lf *os.File
	var e error
	if logFile != "" {
		lf, e = os.OpenFile(logFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
		if e != nil {
			die("Failed to open log file: %v", e)
		}
		log.SetOutput(lf)
		m.SetLogger(log.New(lf, "", log.LstdFlags))
	}

	sigs := make(chan os.Signal, 1)
	done := make(chan bool, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

	h := &MyHandler{
		h:      server.NewHandler(m),
		name:   name,
		auth:   false,
		passwd: make(map[string]string),
	}
	if genpass != "" {
		h.auth = true
		rec := strings.SplitN(genpass, ":", 2)
		if len(rec) != 2 {
			die("Missing user:password")
		}
		enc, e := bcrypt.GenerateFromPassword([]byte(rec[1]), 0)
		if e != nil {
			die("bcrypt: %v", e)
		}
		h.passwd[rec[0]] = string(enc)
		log.Printf("Encrypted password is '%s'", string(enc))
	}
	if passFile != "" {
		if e := h.loadPasswdFile(passFile); e != nil {
			die("Unable to load passwd file: %v", e)
		}
	} else if _, err := os.Stat(path.Join(dir, "passwd")); err == nil {
		if e := h.loadPasswdFile(path.Join(dir, "passwd")); e != nil {
			die("Unable to load passwd file: %v", e)
		}
	}

	if certFile == "" {
		certFile = path.Join(dir, "cert.pem")
	}
	if keyFile == "" {
		keyFile = path.Join(dir, "key.pem")
	}

	go func() {
		var e error
		if strings.HasPrefix(addr, "https://") {
			e = http.ListenAndServeTLS(addr[len("https://"):],
				certFile, keyFile, h)
		} else if strings.HasPrefix(addr, "http://") {
			e = http.ListenAndServe(addr[len("http://"):], h)
		} else {
			e = http.ListenAndServe(addr, h)
		}
		if e != nil {
			die("HTTP/HTTPS failed: %v", e)
		}
	}()

	/* This sleep is long enough to verify that our HTTP service started */
	time.Sleep(time.Millisecond * 100)

	svcDir := path.Join(dir, "services")
	if d, e := os.Open(svcDir); e != nil {
		die("Failed to open services directory %s: %v", svcDir, e)
	} else if files, e := d.Readdirnames(-1); e != nil {
		die("Failed to scan scan services: %v", e)
	} else {
		for _, f := range files {
			fname := path.Join(svcDir, f)
			if mf, e := os.Open(fname); e != nil {
				log.Printf("Failed to open manifest %s: %v",
					fname, e)
				mf.Close()
				continue
			} else if p, e := govisor.NewProcessFromJson(mf); e != nil {
				log.Printf("Failed to load manifest %s: %v",
					fname, e)
				mf.Close()
				continue
			} else {
				m.AddService(p)
				mf.Close()
			}
		}
	}

	m.StartMonitoring()
	if enable {
		svcs, _, _ := m.Services()
		for _, s := range svcs {
			s.Enable()
		}
	}

	// Set up a handler, so that we shutdown cleanly if possible.
	go func() {
		<-sigs
		done <- true
	}()

	// Wait for a termination signal, and shutdown cleanly if we get it.
	<-done
	m.Shutdown()
	os.Exit(1)
}