func newEventlogger(name string, debugAsInfo bool, fmter logrus.Formatter) (*eventlogger, error) { logHandle, err := eventlog.Open(name) if err != nil { return nil, err } return &eventlogger{log: logHandle, debugAsInfo: debugAsInfo, wrap: fmter}, nil }
func (ws *windowsService) SystemLogger(errs chan<- error) (Logger, error) { el, err := eventlog.Open(ws.Name) if err != nil { return nil, err } return WindowsLogger{el, errs}, nil }
func runService(name string, isDebug bool) { errFix := fixEventMessageFile(name) //Temp fix. Remove after a few weeks. if errFix != nil { slog.Errorf("%s fixEventMessageFile failed: %v", name, errFix) return } if isDebug { slog.SetEventLog(debug.New(name), 1) } else { elog, err := eventlog.Open(name) if err != nil { return } slog.SetEventLog(elog, 1) defer elog.Close() } slog.Infof("starting %s service version %v (%v)", name, version.Version, version.VersionSHA) run := svc.Run if isDebug { run = debug.Run } err := run(name, &s{}) if err != nil { slog.Errorf("%s service failed: %v", name, err) return } slog.Infof("%s service stopped", name) os.Exit(0) }
// Create a new hook for the event log. func newEventLogHook() (*eventLogHook, error) { e, err := eventlog.Open(exec.ServiceName) if err != nil { return nil, err } return &eventLogHook{ log: e, }, nil }
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 (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 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 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 Start(logToConsole bool) error { if logToConsole { logger.elog = debug.New(lib.ConnectorName) } else { l, err := eventlog.Open(lib.ConnectorName) if err != nil { return err } logger.elog = l } return nil }
// initEventlog creates a connection to event logs and stores the handler in ctx func initEventlog(orig_logctx Logging, progname string) (logctx Logging, err error) { logctx = orig_logctx defer func() { if e := recover(); e != nil { err = fmt.Errorf("mig.initEventlog() -> %v", e) } }() const name = "mylog" const supports = eventlog.Error | eventlog.Warning | eventlog.Info err = eventlog.InstallAsEventCreate(name, supports) if err != nil { panic(err) } logctx.fd, err = eventlog.Open(progname) if err != nil { panic(err) } return }
func TestLog(t *testing.T) { if testing.Short() { t.Skip("skipping test in short mode - it modifies system logs") } const name = "mylog" const supports = eventlog.Error | eventlog.Warning | eventlog.Info err := eventlog.InstallAsEventCreate(name, supports) if err != nil { t.Fatalf("Install failed: %s", err) } defer func() { err = eventlog.Remove(name) if err != nil { t.Fatalf("Remove failed: %s", err) } }() l, err := eventlog.Open(name) if err != nil { t.Fatalf("Open failed: %s", err) } defer l.Close() err = l.Info(1, "info") if err != nil { t.Fatalf("Info failed: %s", err) } err = l.Warning(2, "warning") if err != nil { t.Fatalf("Warning failed: %s", err) } err = l.Error(3, "error") if err != nil { t.Fatalf("Error failed: %s", err) } }
func RunAsService(name string, start, stop func(), isDebug bool) (err error) { if isDebug { elog = debug.New(name) } else { elog, err = eventlog.Open(name) if err != nil { return } } defer elog.Close() run := svc.Run if isDebug { run = debug.Run } elog.Info(1, fmt.Sprintf("winsvc.RunAsService: starting %s service", name)) if err = run(name, &winService{Start: start, Stop: stop}); err != nil { elog.Error(1, fmt.Sprintf("%s service failed: %v", name, err)) return } elog.Info(1, fmt.Sprintf("winsvc.RunAsService: %s service stopped", name)) return }
func runService(name string, isDebug bool) { var err error if isDebug { elog = debug.New(name) } else { elog, err = eventlog.Open(name) if err != nil { return } } defer elog.Close() elog.Info(1, fmt.Sprintf("starting %s service", name)) run := svc.Run if isDebug { run = debug.Run } err = run(name, &myservice{}) if err != nil { elog.Error(1, fmt.Sprintf("%s service failed: %v", name, err)) return } elog.Info(1, fmt.Sprintf("%s service stopped", name)) }
func runService(name string, isDebug bool) { if isDebug { slog.SetEventLog(debug.New(name), 1) } else { elog, err := eventlog.Open(name) if err != nil { return } slog.SetEventLog(elog, 1) defer elog.Close() } slog.Infof("starting service %s%s", name, version.GetVersionInfo("")) run := svc.Run if isDebug { run = debug.Run } err := run(name, &s{}) if err != nil { slog.Errorf("%s service failed: %v", name, err) return } slog.Infof("%s service stopped", name) os.Exit(0) }
func logInit() (logwriter *eventlog.Log, err error) { logwriter, err = eventlog.Open("jsonmon") return }