// On windows this creates a loop that only finishes when // a Stop or Shutdown request is received. On non-windows // platforms, the function does nothing. The stopCallback // function is called when the Stop/Shutdown request is // received. func ProcessWindowsControlEvents(stopCallback func()) { err := svc.Run(os.Args[0], &beatService{}) if err != nil { logp.Err("Error: %v", err) } stopCallback() }
func (ws *windowsService) Run() error { ws.setError(nil) if !interactive { // Return error messages from start and stop routines // that get executed in the Execute method. // Guarded with a mutex as it may run a different thread // (callback from windows). runErr := svc.Run(ws.Name, ws) startStopErr := ws.getError() if startStopErr != nil { return startStopErr } if runErr != nil { return runErr } return nil } err := ws.i.Start(ws) if err != nil { return err } sigChan := make(chan os.Signal) signal.Notify(sigChan, os.Interrupt, os.Kill) <-sigChan return ws.i.Stop(ws) }
func main() { var logDir = "" flag.StringVar(&logDir, "logDir", "", "The directory where the logs will be stored") var serviceName = flag.String("serviceName", "mssql_broker", "The name of the service as installed in Windows SCM") if !flag.Parsed() { flag.Parse() } interactiveMode, err := svc.IsAnInteractiveSession() if err != nil { panic(err.Error()) } if interactiveMode { runMain(os.Stdout) } else { var err error if logDir == "" { //will default to %windir%\System32\ workingDir, err := os.Getwd() if err != nil { panic(err.Error()) } logDir = path.Join(workingDir, "logs") } if _, err := os.Stat(logDir); os.IsNotExist(err) { err := os.Mkdir(logDir, 0666) if err != nil { panic(err.Error()) } } logFilePath := path.Join(logDir, "mssql_broker.log") logFile, err := os.OpenFile(logFilePath, os.O_WRONLY|os.O_CREATE|os.O_APPEND|os.O_SYNC, 0660) if err != nil { panic(err.Error()) } defer logFile.Close() //setting stderr & stdout os.Stdout = logFile os.Stderr = logFile fileWriter := NewWinFileWriter(logFile) ws := WindowsService{ writer: fileWriter, } err = svc.Run(*serviceName, &ws) if err != nil { panic(err.Error()) } } }
func initService(daemonCli *DaemonCli) (bool, error) { if *flUnregisterService { if *flRegisterService { return true, errors.New("--register-service and --unregister-service cannot be used together") } return true, unregisterService() } if *flRegisterService { return true, registerService() } if !*flRunService { return false, nil } interactive, err := svc.IsAnInteractiveSession() if err != nil { return false, err } h := &handler{ tosvc: make(chan bool), fromsvc: make(chan error), daemonCli: daemonCli, } var log *eventlog.Log if !interactive { log, err = eventlog.Open(*flServiceName) if err != nil { return false, err } } logrus.AddHook(&etwHook{log}) logrus.SetOutput(ioutil.Discard) service = h go func() { if interactive { err = debug.Run(*flServiceName, h) } else { err = svc.Run(*flServiceName, h) } h.fromsvc <- err }() // Wait for the first signal from the service handler. err = <-h.fromsvc if err != nil { return false, err } return false, nil }
func Run() error { log.Infof("starting %s service", serviceName) err := svc.Run(serviceName, &myservice{}) if err != nil { log.Infof("%s service failed: %v", serviceName, err) return err } log.Infof("service stopped") return nil }
func runService(name string, isDebug bool) { var err error log.Printf("starting %s service\n", name) err = svc.Run(name, &tetherservice{}) if err != nil { log.Printf("%s service failed: %v\n", name, err) return } log.Printf("%s service stopped\n", name) }
// If the application is running in an interactive session, run until // terminated. Otherwise, run the application as a Windows service. func Exec() error { isInteractive, err := svc.IsAnInteractiveSession() if err != nil { return err } if !isInteractive { return svc.Run(ServiceName, &service{}) } else { execSignal() return nil } }
func (ws *windowsService) Run(onStart, onStop func() error) error { elog, err := eventlog.Open(ws.name) if err != nil { return err } defer elog.Close() ws.logger = elog ws.onStart = onStart ws.onStop = onStop return svc.Run(ws.name, ws) }
func runService(context *cli.Context) error { interactive, err := svc.IsAnInteractiveSession() if err != nil { return fmt.Errorf("Failed to detect interactive session: %s", err) } s := service{context, interactive} if interactive { return debug.Run(lib.ConnectorName, &s) } else { return svc.Run(lib.ConnectorName, &s) } }
func runAsService(name string) { elog, err := eventlog.Open(name) if err != nil { return } defer elog.Close() elog.Info(1, fmt.Sprintf("etcd: starting %s service", name)) if err = svc.Run(name, &etcdService{elog: elog}); err != nil { elog.Error(1, fmt.Sprintf("etcd: %s service failed: %v", name, err)) return } elog.Info(1, fmt.Sprintf("etcd: %s service stopped", name)) }
func main() { elog, err := eventlog.Open(name) if err != nil { log.Fatal(err.Error()) } defer elog.Close() // `svc.Run` blocks until windows service will stopped. // ref. https://msdn.microsoft.com/library/cc429362.aspx err = svc.Run(name, &handler{elog: elog}) if err != nil { log.Fatal(err.Error()) } }
func RunService(context *cli.Context) { interactive, err := svc.IsAnInteractiveSession() if err != nil { fmt.Fprintf(os.Stderr, "Failed to detect interactive session: %s\n", err) os.Exit(1) } s := service{context, interactive} if interactive { debug.Run(lib.ConnectorName, &s) } else { svc.Run(lib.ConnectorName, &s) } }
func HandleService() chan int { res := make(chan int) go func() { isIntSess, err := svc.IsAnInteractiveSession() if err != nil { log.Fatalf("failed to determine if we are running in an interactive session: %v", err) } if !isIntSess { log.Println("runService(svcName, false)") svc.Run("Concordis", &myservice{res}) } else { log.Println("A standard consle session") } }() return res }
// Returns true if we detected that we are not running in a non-interactive session, and so // launched the service. This function will not return until the service exits. func RunAsService(handler func()) bool { interactive, err := svc.IsAnInteractiveSession() if err != nil { log.Fatalf("failed to determine if we are running in an interactive session: %v", err) return false } if interactive { return false } serviceName := "" // this doesn't matter when we are a "single-process" service service := &myservice{ handler: handler, } svc.Run(serviceName, service) return true }
func init() { interactive, err := svc.IsAnInteractiveSession() if err != nil { panic(err) } if interactive { return } go func() { _ = svc.Run("", runner{}) guard.Lock() f := onExit guard.Unlock() // Don't hold this lock in user code. if f != nil { f() } // Make sure we exit. os.Exit(0) }() }
func main() { // initialize logger log := logger.Logger() defer log.Close() defer log.Flush() // parse input parameters parseFlags(log) // check whether this is an interactive session isIntSess, err := svc.IsAnInteractiveSession() if err != nil { log.Warnf("Failed to determine if we are running in an interactive session: %v", err) } // isIntSess is false by default (after declaration), this fits the use // case that agent is running as Windows service most of times switch isIntSess { case true: run(log) case false: svc.Run(serviceName, &amazonSSMAgentService{log: log}) } }
func runService(name string) { if err := svc.Run(name, &GodocService{}); err != nil { return } }