func (ws *windowsService) Install() error {
exepath, err := ws.execPath()
if err != nil {
return err
}
m, err := mgr.Connect()
if err != nil {
return err
}
defer m.Disconnect()
s, err := m.OpenService(ws.Name)
if err == nil {
s.Close()
return fmt.Errorf("service %s already exists", ws.Name)
}
s, err = m.CreateService(ws.Name, exepath, mgr.Config{
DisplayName: ws.DisplayName,
Description: ws.Description,
StartType: mgr.StartAutomatic,
ServiceStartName: ws.UserName,
Password: ws.Option.string("Password", ""),
Dependencies: ws.Dependencies,
}, ws.Arguments...)
if err != nil {
return err
}
defer s.Close()
err = eventlog.InstallAsEventCreate(ws.Name, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
s.Delete()
return fmt.Errorf("InstallAsEventCreate() failed: %s", err)
}
return nil
}
func InstallService(appPath, name, desc string, params ...string) error {
m, err := mgr.Connect()
if err != nil {
return err
}
defer m.Disconnect()
s, err := m.OpenService(name)
if err == nil {
s.Close()
return fmt.Errorf("winsvc.InstallService: service %s already exists", name)
}
s, err = m.CreateService(name, appPath,
mgr.Config{
DisplayName: desc,
StartType: windows.SERVICE_AUTO_START,
},
params...,
)
if err != nil {
return err
}
defer s.Close()
err = eventlog.InstallAsEventCreate(name, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
s.Delete()
return fmt.Errorf("winsvc.InstallService: InstallAsEventCreate failed, err = %v", err)
}
return nil
}
func installService(name, desc string) error {
exepath, err := exePath()
if err != nil {
return err
}
m, err := mgr.Connect()
if err != nil {
return err
}
defer m.Disconnect()
s, err := m.OpenService(name)
if err == nil {
s.Close()
return fmt.Errorf("service %s already exists", name)
}
s, err = m.CreateService(name, exepath, mgr.Config{DisplayName: desc, StartType: 2}, "is", "auto-started")
if err != nil {
return err
}
defer s.Close()
err = eventlog.InstallAsEventCreate(name, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
s.Delete()
return fmt.Errorf("SetupEventLogSource() failed: %s", err)
}
return nil
}
func (ws *windowsService) Install() error {
exepath, err := osext.Executable()
if err != nil {
return err
}
// Used if path contains a space.
exepath = `"` + exepath + `"`
m, err := mgr.Connect()
if err != nil {
return err
}
defer m.Disconnect()
s, err := m.OpenService(ws.name)
if err == nil {
s.Close()
return fmt.Errorf("service %s already exists", ws.name)
}
s, err = m.CreateService(ws.name, exepath, mgr.Config{
DisplayName: ws.displayName,
Description: ws.description,
StartType: mgr.StartAutomatic,
})
if err != nil {
return err
}
defer s.Close()
err = eventlog.InstallAsEventCreate(ws.name, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
s.Delete()
return fmt.Errorf("InstallAsEventCreate() failed: %s", err)
}
return nil
}
func installService(name, desc string, args ...string) error {
exepath, err := exePath()
if err != nil {
return err
}
if len(args) > 0 {
exepath = exepath + " " + strings.Join(args, " ")
}
println("exepath:", exepath)
m, err := mgr.Connect()
if err != nil {
return err
}
defer m.Disconnect()
s, err := m.OpenService(name)
if err == nil {
s.Close()
return fmt.Errorf("service %s already exists", name)
}
s, err = m.CreateService(name, exepath, mgr.Config{
DisplayName: desc,
StartType: windows.SERVICE_AUTO_START,
})
if err != nil {
return err
}
defer s.Close()
err = eventlog.InstallAsEventCreate(name, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
s.Delete()
return fmt.Errorf("SetupEventLogSource() failed: %s", err)
}
return nil
}
func installEventLog(c *cli.Context) {
err := eventlog.InstallAsEventCreate(lib.ConnectorName, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
fmt.Printf("Failed to install event log registry entries: %s\n", err)
os.Exit(1)
}
fmt.Println("Event log registry entries installed successfully")
}
func (r *SvcRunner) ValidateBeforeStart() error {
execPath, err := exec.LookPath(r.exec)
if err != nil {
return backends.SetStatusLogErrorf(r.name, "Failed to find collector executable %s", r.exec)
}
m, err := mgr.Connect()
if err != nil {
return backends.SetStatusLogErrorf(r.name, "Failed to connect to service manager: %v", err)
}
defer m.Disconnect()
serviceConfig := mgr.Config{
DisplayName: "Graylog collector sidecar - " + r.name + " backend",
Description: "Wrapper service for the NXLog backend",
BinaryPathName: "\"" + r.exec + "\" " + strings.Join(r.args, " ")}
s, err := m.OpenService(r.serviceName)
// service exist so we only update the properties
if err == nil {
defer s.Close()
log.Debugf("[%s] service %s already exists, updating properties", r.name)
currentConfig, err := s.Config()
if err == nil {
currentConfig.DisplayName = serviceConfig.DisplayName
currentConfig.Description = serviceConfig.Description
currentConfig.BinaryPathName = serviceConfig.BinaryPathName
}
err = s.UpdateConfig(currentConfig)
if err != nil {
backends.SetStatusLogErrorf(r.name, "Failed to update service: %v", err)
}
// service needs to be created
} else {
s, err = m.CreateService(r.serviceName,
execPath,
serviceConfig)
if err != nil {
backends.SetStatusLogErrorf(r.name, "Failed to install service: %v", err)
}
defer s.Close()
err = eventlog.InstallAsEventCreate(r.serviceName, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
s.Delete()
backends.SetStatusLogErrorf(r.name, "SetupEventLogSource() failed: %v", err)
}
}
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 installService(name, exepath string) error {
log.Info("Installing service")
m, err := mgr.Connect()
if err != nil {
return err
}
defer m.Disconnect()
s, err := m.OpenService(name)
if err == nil {
s.Close()
log.Info("Service already installed")
return ServiceExistsAlready
}
log.Info("Creating service")
s, err = m.CreateService(
name,
exepath,
mgr.Config{
StartType: mgr.StartAutomatic,
DisplayName: name,
},
"service",
)
if err != nil {
return err
}
defer s.Close()
err = eventlog.InstallAsEventCreate(name, eventlog.Error|eventlog.Warning|eventlog.Info)
if err != nil {
s.Delete()
return fmt.Errorf("SetupEventLogSource() failed: %s", err)
}
log.Info("Service created")
return nil
}
return err
}
if err := securePath(config.Queue.Directory); err != nil {
return err
}
}
s, err := m.CreateService(exec.ServiceName, exePath, mgr.Config{
StartType: mgr.StartAutomatic,
DisplayName: displayName,
Description: description,
}, "-config", cfgPath)
if err != nil {
return err
}
defer s.Close()
if err := eventlog.InstallAsEventCreate(exec.ServiceName, eventlog.Error|eventlog.Warning|eventlog.Info); err != nil {
s.Delete()
return err
}
return nil
},
}
// Start the service.
var startCommand = &command{
name: "start",
description: "start the service (Windows only)",
exec: func(config *cfg.Config) error {
return serviceCommand("start")
},
}