Update deps

vendor/github.com/kardianos/service/service.go

@@ -75,10 +75,27 @@ const (
 	optionUserServiceDefault   = false
 	optionSessionCreate        = "SessionCreate"
 	optionSessionCreateDefault = false
+	optionLogOutput            = "LogOutput"
+	optionLogOutputDefault     = false
 
 	optionRunWait      = "RunWait"
 	optionReloadSignal = "ReloadSignal"
 	optionPIDFile      = "PIDFile"
+
+	optionSystemdScript = "SystemdScript"
+	optionSysvScript    = "SysvScript"
+	optionUpstartScript = "UpstartScript"
+	optionLaunchdConfig = "LaunchdConfig"
+)
+
+// Status represents service status as an byte value
+type Status byte
+
+// Status of service represented as an byte
+const (
+	StatusUnknown Status = iota // Status is unable to be determined due to an error or it was not installed.
+	StatusRunning
+	StatusStopped
 )
 
 // Config provides the setup for a Service. The Name field is required.
@@ -103,14 +120,19 @@ type Config struct {
 
 	// System specific options.
 	//  * OS X
-	//    - KeepAlive     bool (true)
-	//    - RunAtLoad     bool (false)
-	//    - UserService   bool (false) - Install as a current user service.
-	//    - SessionCreate bool (false) - Create a full user session.
+	//    - LaunchdConfig string ()      - Use custom launchd config
+	//    - KeepAlive     bool   (true)
+	//    - RunAtLoad     bool   (false)
+	//    - UserService   bool   (false) - Install as a current user service.
+	//    - SessionCreate bool   (false) - Create a full user session.
 	//  * POSIX
-	//    - RunWait      func() (wait for SIGNAL) - Do not install signal but wait for this function to return.
-	//    - ReloadSignal string () [USR1, ...] - Signal to send on reaload.
-	//    - PIDFile     string () [/run/prog.pid] - Location of the PID file.
+	//    - SystemdScript string ()                 - Use custom systemd script
+	//    - UpstartScript string ()                 - Use custom upstart script
+	//    - SysvScript    string ()                 - Use custom sysv script
+	//    - RunWait       func() (wait for SIGNAL)  - Do not install signal but wait for this function to return.
+	//    - ReloadSignal  string () [USR1, ...]     - Signal to send on reaload.
+	//    - PIDFile       string () [/run/prog.pid] - Location of the PID file.
+	//    - LogOutput     bool   (false)            - Redirect StdErr & StdOut to files.
 	Option KeyValue
 }
 
@@ -120,10 +142,12 @@ var (
 )
 
 var (
-	// ErrNameFieldRequired is returned when Conifg.Name is empty.
+	// ErrNameFieldRequired is returned when Config.Name is empty.
 	ErrNameFieldRequired = errors.New("Config.Name field is required.")
 	// ErrNoServiceSystemDetected is returned when no system was detected.
 	ErrNoServiceSystemDetected = errors.New("No service system detected.")
+	// ErrNotInstalled is returned when the service is not installed
+	ErrNotInstalled = errors.New("the service is not installed")
 )
 
 // New creates a new service based on a service interface and configuration.
@@ -322,6 +346,9 @@ type Service interface {
 	// String displays the name of the service. The display name if present,
 	// otherwise the name.
 	String() string
+
+	// Status returns the current service status.
+	Status() (Status, error)
 }
 
 // ControlAction list valid string texts to use in Control.

vendor/github.com/kardianos/service/service_darwin.go

@@ -11,6 +11,8 @@ import (
 	"os/signal"
 	"os/user"
 	"path/filepath"
+	"regexp"
+	"strings"
 	"syscall"
 	"text/template"
 	"time"
@@ -100,6 +102,25 @@ func (s *darwinLaunchdService) getServiceFilePath() (string, error) {
 	return "/Library/LaunchDaemons/" + s.Name + ".plist", nil
 }
 
+func (s *darwinLaunchdService) template() *template.Template {
+	functions := template.FuncMap{
+		"bool": func(v bool) string {
+			if v {
+				return "true"
+			}
+			return "false"
+		},
+	}
+
+	customConfig := s.Option.string(optionLaunchdConfig, "")
+
+	if customConfig != "" {
+		return template.Must(template.New("").Funcs(functions).Parse(customConfig))
+	} else {
+		return template.Must(template.New("").Funcs(functions).Parse(launchdConfig))
+	}
+}
+
 func (s *darwinLaunchdService) Install() error {
 	confPath, err := s.getServiceFilePath()
 	if err != nil {
@@ -143,16 +164,7 @@ func (s *darwinLaunchdService) Install() error {
 		SessionCreate: s.Option.bool(optionSessionCreate, optionSessionCreateDefault),
 	}
 
-	functions := template.FuncMap{
-		"bool": func(v bool) string {
-			if v {
-				return "true"
-			}
-			return "false"
-		},
-	}
-	t := template.Must(template.New("launchdConfig").Funcs(functions).Parse(launchdConfig))
-	return t.Execute(f, to)
+	return s.template().Execute(f, to)
 }
 
 func (s *darwinLaunchdService) Uninstall() error {
@@ -165,6 +177,32 @@ func (s *darwinLaunchdService) Uninstall() error {
 	return os.Remove(confPath)
 }
 
+func (s *darwinLaunchdService) Status() (Status, error) {
+	exitCode, out, err := runWithOutput("launchctl", "list", s.Name)
+	if exitCode == 0 && err != nil {
+		if !strings.Contains(err.Error(), "failed with stderr") {
+			return StatusUnknown, err
+		}
+	}
+
+	re := regexp.MustCompile(`"PID" = ([0-9]+);`)
+	matches := re.FindStringSubmatch(out)
+	if len(matches) == 2 {
+		return StatusRunning, nil
+	}
+
+	confPath, err := s.getServiceFilePath()
+	if err != nil {
+		return StatusUnknown, err
+	}
+
+	if _, err = os.Stat(confPath); err == nil {
+		return StatusStopped, nil
+	}
+
+	return StatusUnknown, ErrNotInstalled
+}
+
 func (s *darwinLaunchdService) Start() error {
 	confPath, err := s.getServiceFilePath()
 	if err != nil {

vendor/github.com/kardianos/service/service_systemd_linux.go

@@ -9,6 +9,9 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
+	"regexp"
+	"strconv"
+	"strings"
 	"syscall"
 	"text/template"
 )
@@ -52,8 +55,49 @@ func (s *systemd) configPath() (cp string, err error) {
 	cp = "/etc/systemd/system/" + s.Config.Name + ".service"
 	return
 }
+
+func (s *systemd) getSystemdVersion() int64 {
+	_, out, err := runWithOutput("systemctl", "--version")
+	if err != nil {
+		return -1
+	}
+
+	re := regexp.MustCompile(`systemd ([0-9]+)`)
+	matches := re.FindStringSubmatch(out)
+	if len(matches) != 2 {
+		return -1
+	}
+
+	v, err := strconv.ParseInt(matches[1], 10, 64)
+	if err != nil {
+		return -1
+	}
+
+	return v
+}
+
+func (s *systemd) hasOutputFileSupport() bool {
+	defaultValue := true
+	version := s.getSystemdVersion()
+	if version == -1 {
+		return defaultValue
+	}
+
+	if version < 236 {
+		return false
+	}
+
+	return defaultValue
+}
+
 func (s *systemd) template() *template.Template {
-	return template.Must(template.New("").Funcs(tf).Parse(systemdScript))
+	customScript := s.Option.string(optionSystemdScript, "")
+
+	if customScript != "" {
+		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+	} else {
+		return template.Must(template.New("").Funcs(tf).Parse(systemdScript))
+	}
 }
 
 func (s *systemd) Install() error {
@@ -79,14 +123,18 @@ func (s *systemd) Install() error {
 
 	var to = &struct {
 		*Config
-		Path         string
-		ReloadSignal string
-		PIDFile      string
+		Path                 string
+		HasOutputFileSupport bool
+		ReloadSignal         string
+		PIDFile              string
+		LogOutput            bool
 	}{
 		s.Config,
 		path,
+		s.hasOutputFileSupport(),
 		s.Option.string(optionReloadSignal, ""),
 		s.Option.string(optionPIDFile, ""),
+		s.Option.bool(optionLogOutput, optionLogOutputDefault),
 	}
 
 	err = s.template().Execute(f, to)
@@ -141,6 +189,24 @@ func (s *systemd) Run() (err error) {
 	return s.i.Stop(s)
 }
 
+func (s *systemd) Status() (Status, error) {
+	exitCode, out, err := runWithOutput("systemctl", "is-active", s.Name)
+	if exitCode == 0 && err != nil {
+		return StatusUnknown, err
+	}
+
+	switch {
+	case strings.HasPrefix(out, "active"):
+		return StatusRunning, nil
+	case strings.HasPrefix(out, "inactive"):
+		return StatusStopped, nil
+	case strings.HasPrefix(out, "failed"):
+		return StatusUnknown, errors.New("service in failed state")
+	default:
+		return StatusUnknown, ErrNotInstalled
+	}
+}
+
 func (s *systemd) Start() error {
 	return run("systemctl", "start", s.Name+".service")
 }
@@ -166,6 +232,10 @@ ExecStart={{.Path|cmdEscape}}{{range .Arguments}} {{.|cmd}}{{end}}
 {{if .UserName}}User={{.UserName}}{{end}}
 {{if .ReloadSignal}}ExecReload=/bin/kill -{{.ReloadSignal}} "$MAINPID"{{end}}
 {{if .PIDFile}}PIDFile={{.PIDFile|cmd}}{{end}}
+{{if and .LogOutput .HasOutputFileSupport -}}
+StandardOutput=file:/var/log/{{.Name}}.out
+StandardError=file:/var/log/{{.Name}}.err
+{{- end}}
 Restart=always
 RestartSec=120
 EnvironmentFile=-/etc/sysconfig/{{.Name}}

vendor/github.com/kardianos/service/service_sysv_linux.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 	"text/template"
 	"time"
@@ -45,8 +46,15 @@ func (s *sysv) configPath() (cp string, err error) {
 	cp = "/etc/init.d/" + s.Config.Name
 	return
 }
+
 func (s *sysv) template() *template.Template {
-	return template.Must(template.New("").Funcs(tf).Parse(sysvScript))
+	customScript := s.Option.string(optionSysvScript, "")
+
+	if customScript != "" {
+		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+	} else {
+		return template.Must(template.New("").Funcs(tf).Parse(sysvScript))
+	}
 }
 
 func (s *sysv) Install() error {
@@ -136,6 +144,22 @@ func (s *sysv) Run() (err error) {
 	return s.i.Stop(s)
 }
 
+func (s *sysv) Status() (Status, error) {
+	_, out, err := runWithOutput("service", s.Name, "status")
+	if err != nil {
+		return StatusUnknown, err
+	}
+
+	switch {
+	case strings.HasPrefix(out, "Running"):
+		return StatusRunning, nil
+	case strings.HasPrefix(out, "Stopped"):
+		return StatusStopped, nil
+	default:
+		return StatusUnknown, ErrNotInstalled
+	}
+}
+
 func (s *sysv) Start() error {
 	return run("service", s.Name, "start")
 }

vendor/github.com/kardianos/service/service_unix.go

@@ -8,9 +8,11 @@ package service
 
 import (
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log/syslog"
 	"os/exec"
+	"syscall"
 )
 
 func newSysLogger(name string, errs chan<- error) (Logger, error) {
@@ -53,20 +55,43 @@ func (s sysLogger) Infof(format string, a ...interface{}) error {
 }
 
 func run(command string, arguments ...string) error {
+	_, _, err := runCommand(command, false, arguments...)
+	return err
+}
+
+func runWithOutput(command string, arguments ...string) (int, string, error) {
+	return runCommand(command, true, arguments...)
+}
+
+func runCommand(command string, readStdout bool, arguments ...string) (int, string, error) {
 	cmd := exec.Command(command, arguments...)
 
+	var output string
+	var stdout io.ReadCloser
+	var err error
+
+	if readStdout {
+		// Connect pipe to read Stdout
+		stdout, err = cmd.StdoutPipe()
+
+		if err != nil {
+			// Failed to connect pipe
+			return 0, "", fmt.Errorf("%q failed to connect stdout pipe: %v", command, err)
+		}
+	}
+
 	// Connect pipe to read Stderr
 	stderr, err := cmd.StderrPipe()
 
 	if err != nil {
 		// Failed to connect pipe
-		return fmt.Errorf("%q failed to connect stderr pipe: %v", command, err)
+		return 0, "", fmt.Errorf("%q failed to connect stderr pipe: %v", command, err)
 	}
 
 	// Do not use cmd.Run()
 	if err := cmd.Start(); err != nil {
 		// Problem while copying stdin, stdout, or stderr
-		return fmt.Errorf("%q failed: %v", command, err)
+		return 0, "", fmt.Errorf("%q failed: %v", command, err)
 	}
 
 	// Zero exit status
@@ -75,14 +100,39 @@ func run(command string, arguments ...string) error {
 	if command == "launchctl" {
 		slurp, _ := ioutil.ReadAll(stderr)
 		if len(slurp) > 0 {
-			return fmt.Errorf("%q failed with stderr: %s", command, slurp)
+			return 0, "", fmt.Errorf("%q failed with stderr: %s", command, slurp)
+		}
+	}
+
+	if readStdout {
+		out, err := ioutil.ReadAll(stdout)
+		if err != nil {
+			return 0, "", fmt.Errorf("%q failed while attempting to read stdout: %v", command, err)
+		} else if len(out) > 0 {
+			output = string(out)
 		}
 	}
 
 	if err := cmd.Wait(); err != nil {
-		// Command didn't exit with a zero exit status.
-		return fmt.Errorf("%q failed: %v", command, err)
+		exitStatus, ok := isExitError(err)
+		if ok {
+			// Command didn't exit with a zero exit status.
+			return exitStatus, output, err
+		}
+
+		// An error occurred and there is no exit status.
+		return 0, output, fmt.Errorf("%q failed: %v", command, err)
 	}
 
-	return nil
+	return 0, output, nil
+}
+
+func isExitError(err error) (int, bool) {
+	if exiterr, ok := err.(*exec.ExitError); ok {
+		if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
+			return status.ExitStatus(), true
+		}
+	}
+
+	return 0, false
 }

vendor/github.com/kardianos/service/service_upstart_linux.go

@@ -8,10 +8,8 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"os/exec"
 	"os/signal"
 	"regexp"
-	"strconv"
 	"strings"
 	"text/template"
 	"time"
@@ -21,6 +19,13 @@ func isUpstart() bool {
 	if _, err := os.Stat("/sbin/upstart-udev-bridge"); err == nil {
 		return true
 	}
+	if _, err := os.Stat("/sbin/initctl"); err == nil {
+		if _, out, err := runWithOutput("/sbin/initctl", "--version"); err == nil {
+			if strings.Contains(out, "initctl (upstart") {
+				return true
+			}
+		}
+	}
 	return false
 }
 
@@ -61,46 +66,57 @@ func (s *upstart) configPath() (cp string, err error) {
 
 func (s *upstart) hasKillStanza() bool {
 	defaultValue := true
-
-	out, err := exec.Command("/sbin/init", "--version").Output()
-	if err != nil {
+	version := s.getUpstartVersion()
+	if version == nil {
 		return defaultValue
 	}
 
-	re := regexp.MustCompile(`init \(upstart (\d+.\d+.\d+)\)`)
-	matches := re.FindStringSubmatch(string(out))
-	if len(matches) != 2 {
-		return defaultValue
-	}
-
-	version := make([]int, 3)
-	for idx, vStr := range strings.Split(matches[1], ".") {
-		version[idx], err = strconv.Atoi(vStr)
-		if err != nil {
-			return defaultValue
-		}
-	}
-
 	maxVersion := []int{0, 6, 5}
-	if versionAtMost(version, maxVersion) {
+	if matches, err := versionAtMost(version, maxVersion); err != nil || matches {
 		return false
 	}
 
 	return defaultValue
 }
 
-func versionAtMost(version, max []int) bool {
-	for idx, m := range max {
-		v := version[idx]
-		if v > m {
-			return false
-		}
+func (s *upstart) hasSetUIDStanza() bool {
+	defaultValue := true
+	version := s.getUpstartVersion()
+	if version == nil {
+		return defaultValue
 	}
-	return true
+
+	maxVersion := []int{1, 4, 0}
+	if matches, err := versionAtMost(version, maxVersion); err != nil || matches {
+		return false
+	}
+
+	return defaultValue
+}
+
+func (s *upstart) getUpstartVersion() []int {
+	_, out, err := runWithOutput("/sbin/initctl", "--version")
+	if err != nil {
+		return nil
+	}
+
+	re := regexp.MustCompile(`initctl \(upstart (\d+.\d+.\d+)\)`)
+	matches := re.FindStringSubmatch(out)
+	if len(matches) != 2 {
+		return nil
+	}
+
+	return parseVersion(matches[1])
 }
 
 func (s *upstart) template() *template.Template {
-	return template.Must(template.New("").Funcs(tf).Parse(upstartScript))
+	customScript := s.Option.string(optionUpstartScript, "")
+
+	if customScript != "" {
+		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+	} else {
+		return template.Must(template.New("").Funcs(tf).Parse(upstartScript))
+	}
 }
 
 func (s *upstart) Install() error {
@@ -126,12 +142,16 @@ func (s *upstart) Install() error {
 
 	var to = &struct {
 		*Config
-		Path          string
-		HasKillStanza bool
+		Path            string
+		HasKillStanza   bool
+		HasSetUIDStanza bool
+		LogOutput       bool
 	}{
 		s.Config,
 		path,
 		s.hasKillStanza(),
+		s.hasSetUIDStanza(),
+		s.Option.bool(optionLogOutput, optionLogOutputDefault),
 	}
 
 	return s.template().Execute(f, to)
@@ -173,6 +193,22 @@ func (s *upstart) Run() (err error) {
 	return s.i.Stop(s)
 }
 
+func (s *upstart) Status() (Status, error) {
+	exitCode, out, err := runWithOutput("initctl", "status", s.Name)
+	if exitCode == 0 && err != nil {
+		return StatusUnknown, err
+	}
+
+	switch {
+	case strings.HasPrefix(out, fmt.Sprintf("%s start/running", s.Name)):
+		return StatusRunning, nil
+	case strings.HasPrefix(out, fmt.Sprintf("%s stop/waiting", s.Name)):
+		return StatusStopped, nil
+	default:
+		return StatusUnknown, ErrNotInstalled
+	}
+}
+
 func (s *upstart) Start() error {
 	return run("initctl", "start", s.Name)
 }
@@ -202,7 +238,7 @@ const upstartScript = `# {{.Description}}
 start on filesystem or runlevel [2345]
 stop on runlevel [!2345]
 
-{{if .UserName}}setuid {{.UserName}}{{end}}
+{{if and .UserName .HasSetUIDStanza}}setuid {{.UserName}}{{end}}
 
 respawn
 respawn limit 10 5
@@ -215,5 +251,18 @@ pre-start script
 end script
 
 # Start
-exec {{.Path}}{{range .Arguments}} {{.|cmd}}{{end}}
+script
+	{{if .LogOutput}}
+	stdout_log="/var/log/{{.Name}}.out"
+	stderr_log="/var/log/{{.Name}}.err"
+	{{end}}
+	
+	if [ -f "/etc/sysconfig/{{.Name}}" ]; then
+		set -a
+		source /etc/sysconfig/{{.Name}}
+		set +a
+	fi
+
+	exec {{if and .UserName (not .HasSetUIDStanza)}}sudo -E -u {{.UserName}} {{end}}{{.Path}}{{range .Arguments}} {{.|cmd}}{{end}}{{if .LogOutput}} >> $stdout_log 2>> $stderr_log{{end}}
+end script
 `

vendor/github.com/kardianos/service/service_windows.go

@@ -275,6 +275,46 @@ func (ws *windowsService) Run() error {
 	return ws.i.Stop(ws)
 }
 
+func (ws *windowsService) Status() (Status, error) {
+	m, err := mgr.Connect()
+	if err != nil {
+		return StatusUnknown, err
+	}
+	defer m.Disconnect()
+
+	s, err := m.OpenService(ws.Name)
+	if err != nil {
+		if err.Error() == "The specified service does not exist as an installed service." {
+			return StatusUnknown, ErrNotInstalled
+		}
+		return StatusUnknown, err
+	}
+
+	status, err := s.Query()
+	if err != nil {
+		return StatusUnknown, err
+	}
+
+	switch status.State {
+	case svc.StartPending:
+		fallthrough
+	case svc.Running:
+		return StatusRunning, nil
+	case svc.PausePending:
+		fallthrough
+	case svc.Paused:
+		fallthrough
+	case svc.ContinuePending:
+		fallthrough
+	case svc.StopPending:
+		fallthrough
+	case svc.Stopped:
+		return StatusStopped, nil
+	default:
+		return StatusUnknown, fmt.Errorf("unknown status %s", status)
+	}
+}
+
 func (ws *windowsService) Start() error {
 	m, err := mgr.Connect()
 	if err != nil {

vendor/github.com/kardianos/service/version.go

@@ -0,0 +1,57 @@
+package service
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+)
+
+// versionAtMost will return true if the provided version is less than or equal to max
+func versionAtMost(version, max []int) (bool, error) {
+	if comp, err := versionCompare(version, max); err != nil {
+		return false, err
+	} else if comp == 1 {
+		return false, nil
+	}
+	return true, nil
+}
+
+// versionCompare take to versions split into integer arrays and attempts to compare them
+// An error will be returned if there is an array length mismatch.
+// Return values are as follows
+// -1 - v1 is less than v2
+// 0  - v1 is equal to v2
+// 1  - v1 is greater than v2
+func versionCompare(v1, v2 []int) (int, error) {
+	if len(v1) != len(v2) {
+		return 0, errors.New("version length mismatch")
+	}
+
+	for idx, v2S := range v2 {
+		v1S := v1[idx]
+		if v1S > v2S {
+			return 1, nil
+		}
+
+		if v1S < v2S {
+			return -1, nil
+		}
+	}
+	return 0, nil
+}
+
+// parseVersion will parse any integer type version seperated by periods.
+// This does not fully support semver style versions.
+func parseVersion(v string) []int {
+	version := make([]int, 3)
+
+	for idx, vStr := range strings.Split(v, ".") {
+		vS, err := strconv.Atoi(vStr)
+		if err != nil {
+			return nil
+		}
+		version[idx] = vS
+	}
+
+	return version
+}