Golang svc.Run函數代碼示例

// 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)
	}()
}