overflow_probes/main.go
2017-09-28 19:09:33 +09:00

241 lines
6.2 KiB
Go

package main
import (
"context"
"flag"
"fmt"
"os"
"os/signal"
"path"
"syscall"
"time"
lfcc "git.loafle.net/commons_go/config"
"git.loafle.net/commons_go/logging"
"git.loafle.net/overflow/overflow_probes/auth"
"git.loafle.net/overflow/overflow_probes/commons"
"git.loafle.net/overflow/overflow_probes/config"
"git.loafle.net/overflow/overflow_probes/probe"
"github.com/takama/daemon"
)
/*
/bin/
probe.exe
/config/
/sensor/
noauthprobe.json
central.json
probe.json
logging.json
*/
const (
// name of the service
serviceName = "Probe"
serviceDescription = "Probe Service of overFlow"
)
type daemonHandler struct {
daemon.Daemon
}
// Manage by daemon commands or run the daemon
// cmd install -config=./path
// cmd install
// cmd remove
// cmd start
// cmd stop
// cmd status
// cmd -config=./path
// cmd
func (d *daemonHandler) Manage() (isRunning bool, status string, err error) {
isRunning = true
if nil != daemonCommand {
switch *daemonCommand {
case "install":
var runArgs = []string{}
runArgs = append(runArgs, fmt.Sprintf("-configDir=%s", *configDir))
isRunning = false
status, err = d.Install(runArgs...)
case "remove":
isRunning = false
status, err = d.Remove()
case "start":
isRunning = false
status, err = d.Start()
case "stop":
isRunning = false
status, err = d.Stop()
case "status":
isRunning = false
status, err = d.Status()
}
}
return
}
var (
daemonCommand *string
configDir *string
)
func init() {
flag.Usage = func() {
fmt.Printf("Usage of %s\n", os.Args[0])
fmt.Printf(" [install | remove | start | stop | status]\n")
flag.PrintDefaults()
}
if len(os.Args) > 1 {
command := os.Args[1]
switch command {
case "install", "remove", "start", "stop", "status":
*daemonCommand = command
}
}
configDir = flag.String("config-dir", ".", "The directory of config")
flag.Parse()
}
func main() {
var err error
var srv daemon.Daemon
var status string
var handler commons.Handler
isRunning := true
defer logging.Logger.Sync()
printBanner()
if dir, err := lfcc.ABSPathify(*configDir); nil != err {
logging.Logger.Panic(fmt.Sprintf("Probe: config path[%s] is not valid", *configDir))
} else {
logging.Logger.Debug(fmt.Sprintf("Probe: config path[%s]", dir))
config.ConfigDir = &dir
}
cfp := path.Join(*config.ConfigDir, config.ConfigFileName)
config.ConfigFilePath = &cfp
conf := lfcc.New()
config.CFG = &config.Config{}
if err := conf.Load(config.CFG, *config.ConfigFilePath); nil != err {
logging.Logger.Panic(fmt.Sprintf("Probe: config is not valid error[%v]", err))
}
if nil == config.CFG.Central.APIKey {
logging.Logger.Panic("Probe: APIKey is required")
}
if nil == config.CFG.Central.URL {
logging.Logger.Panic("Probe: URL of overFlow Central is required")
}
if srv, err = daemon.New(serviceName, serviceDescription); nil != err {
logging.Logger.Panic(fmt.Sprintf("Probe: %v", err))
}
s := &daemonHandler{srv}
if isRunning, status, err = s.Manage(); nil != err {
logging.Logger.Error(fmt.Sprintf("Probe: status[%s] error: %v", status, err))
os.Exit(1)
}
if !isRunning {
logging.Logger.Info(fmt.Sprintf("Probe: status[%s]", status))
os.Exit(0)
}
go func() {
if handler, err = auth.New(); nil != err {
logging.Logger.Error(fmt.Sprintf("Auth: error: %v", err))
os.Exit(1)
}
if err := handler.Serve(); err != nil {
logging.Logger.Error(fmt.Sprintf("Auth: Stopped[%v]", err))
return
}
if handler, err = probe.New(); nil != err {
logging.Logger.Error(fmt.Sprintf("Probe: error: %v", err))
return
}
if err := handler.Serve(); err != nil {
logging.Logger.Error(fmt.Sprintf("Probe: error: %v", err))
return
}
}()
// // Set up channel on which to send signal notifications.
// // We must use a buffered channel or risk missing the signal
// // if we're not ready to receive when the signal is sent.
interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt,
syscall.SIGKILL,
syscall.SIGSTOP,
syscall.SIGHUP,
syscall.SIGINT,
syscall.SIGTERM,
syscall.SIGQUIT)
<-interrupt
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := handler.Shutdown(ctx); err != nil {
logging.Logger.Error(fmt.Sprintf("Probe: status[%s] error: %v", status, err))
}
// // loop work cycle with accept connections or interrupt
// // by system signal
// ListenLoop:
// for {
// select {
// case s := <-interrupt:
// logging.Logger.Info(fmt.Sprintf("Probe: signal[%v]", s))
// ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
// defer cancel()
// if err := p.Shutdown(ctx); err != nil {
// logging.Logger.Error(fmt.Sprintf("Probe: status[%s] error: %v", status, err))
// }
// if s == os.Interrupt {
// logging.Logger.Info("Probe was interruped by system signal")
// } else {
// logging.Logger.Info("Probe was killed")
// }
// break ListenLoop
// }
// }
}
const (
version = "1.0.0"
website = "https://www.overflow.cloud"
banner = `
██████╗ ██╗ ██╗███████╗██████╗ ███████╗██╗ ██████╗ ██╗ ██╗
██╔═══██╗██║ ██║██╔════╝██╔══██╗██╔════╝██║ ██╔═══██╗██║ ██║
██║ ██║██║ ██║█████╗ ██████╔╝█████╗ ██║ ██║ ██║██║ █╗ ██║
██║ ██║╚██╗ ██╔╝██╔══╝ ██╔══██╗██╔══╝ ██║ ██║ ██║██║███╗██║
╚██████╔╝ ╚████╔╝ ███████╗██║ ██║██║ ███████╗╚██████╔╝╚███╔███╔╝
╚═════╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝ ╚═════╝ ╚══╝╚══╝
`
)
func printBanner() {
fmt.Println(banner)
fmt.Printf("Version: %s\n", version)
fmt.Printf("URL: %s\n", website)
fmt.Println()
}