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
}