Documentation

Overview

    Package svc provides everything required to build Windows service.

    Index

    Constants

    Variables

    This section is empty.

    Functions

    func IsAnInteractiveSession

    func IsAnInteractiveSession() (bool, error)

      IsAnInteractiveSession determines if calling process is running interactively. It queries the process token for membership in the Interactive group. http://stackoverflow.com/questions/2668851/how-do-i-detect-that-my-application-is-running-as-service-or-in-an-interactive-s

      Deprecated: Use IsWindowsService instead.

      func IsWindowsService

      func IsWindowsService() (bool, error)

        IsWindowsService reports whether the process is currently executing as a Windows service.

        func Run

        func Run(name string, handler Handler) error

          Run executes service name by calling appropriate handler function.

          func StatusHandle

          func StatusHandle() windows.Handle

            StatusHandle returns service status handle. It is safe to call this function from inside the Handler.Execute because then it is guaranteed to be set. This code will have to change once multiple services are possible per process.

            Types

            type Accepted

            type Accepted uint32

              Accepted is used to describe commands accepted by the service. Note that Interrogate is always accepted.

              type ChangeRequest

              type ChangeRequest struct {
              	Cmd           Cmd
              	EventType     uint32
              	EventData     uintptr
              	CurrentStatus Status
              	Context       uintptr
              }

                ChangeRequest is sent to the service Handler to request service status change.

                type Cmd

                type Cmd uint32

                  Cmd represents service state change request. It is sent to a service by the service manager, and should be actioned upon by the service.

                  type Handler

                  type Handler interface {
                  
                  	// Execute will be called by the package code at the start of
                  	// the service, and the service will exit once Execute completes.
                  	// Inside Execute you must read service change requests from r and
                  	// act accordingly. You must keep service control manager up to date
                  	// about state of your service by writing into s as required.
                  	// args contains service name followed by argument strings passed
                  	// to the service.
                  	// You can provide service exit code in exitCode return parameter,
                  	// with 0 being "no error". You can also indicate if exit code,
                  	// if any, is service specific or not by using svcSpecificEC
                  	// parameter.
                  	Execute(args []string, r <-chan ChangeRequest, s chan<- Status) (svcSpecificEC bool, exitCode uint32)
                  }

                    Handler is the interface that must be implemented to build Windows service.

                    type State

                    type State uint32

                      State describes service execution state (Stopped, Running and so on).

                      type Status

                      type Status struct {
                      	State                   State
                      	Accepts                 Accepted
                      	CheckPoint              uint32 // used to report progress during a lengthy operation
                      	WaitHint                uint32 // estimated time required for a pending operation, in milliseconds
                      	ProcessId               uint32 // if the service is running, the process identifier of it, and otherwise zero
                      	Win32ExitCode           uint32 // set if the service has exited with a win32 exit code
                      	ServiceSpecificExitCode uint32 // set if the service has exited with a service-specific exit code
                      }

                        Status combines State and Accepted commands to fully describe running service.

                        Notes

                        Bugs

                          • There is no mechanism to run multiple services inside one single executable. Perhaps, it can be overcome by using RegisterServiceCtrlHandlerEx Windows api.

                          GOOS=windows, GOARCH=amd64

                          Directories

                          Path Synopsis
                          Package debug provides facilities to execute svc.Handler on console.
                          Package debug provides facilities to execute svc.Handler on console.
                          Package eventlog implements access to Windows event log.
                          Package eventlog implements access to Windows event log.
                          Example service program that beeps.
                          Example service program that beeps.
                          Package mgr can be used to manage Windows service programs.
                          Package mgr can be used to manage Windows service programs.