Browse Source

Windows: start on install. Add stop/start to all.

tags/v0.3.0
AJ ONeal 1 year ago
parent
commit
4c44f70ec3
26 changed files with 1383 additions and 61 deletions
  1. +2
    -0
      .gitignore
  2. +1
    -0
      go.mod
  3. +2
    -0
      go.sum
  4. +18
    -0
      manager/install.go
  5. +52
    -17
      manager/install_darwin.go
  6. +65
    -17
      manager/install_linux.go
  7. +43
    -13
      manager/install_windows.go
  8. +22
    -0
      manager/start.go
  9. +140
    -2
      runner/runner.go
  10. +13
    -1
      runner/runner_notwindows.go
  11. +13
    -0
      runner/runner_windows.go
  12. +6
    -1
      service/service.go
  13. +112
    -10
      serviceman.go
  14. +1
    -0
      vendor/github.com/mitchellh/go-ps/.gitignore
  15. +4
    -0
      vendor/github.com/mitchellh/go-ps/.travis.yml
  16. +21
    -0
      vendor/github.com/mitchellh/go-ps/LICENSE.md
  17. +34
    -0
      vendor/github.com/mitchellh/go-ps/README.md
  18. +43
    -0
      vendor/github.com/mitchellh/go-ps/Vagrantfile
  19. +40
    -0
      vendor/github.com/mitchellh/go-ps/process.go
  20. +138
    -0
      vendor/github.com/mitchellh/go-ps/process_darwin.go
  21. +260
    -0
      vendor/github.com/mitchellh/go-ps/process_freebsd.go
  22. +35
    -0
      vendor/github.com/mitchellh/go-ps/process_linux.go
  23. +96
    -0
      vendor/github.com/mitchellh/go-ps/process_solaris.go
  24. +101
    -0
      vendor/github.com/mitchellh/go-ps/process_unix.go
  25. +119
    -0
      vendor/github.com/mitchellh/go-ps/process_windows.go
  26. +2
    -0
      vendor/modules.txt

+ 2
- 0
.gitignore View File

@@ -1,3 +1,5 @@
*~
.*~
# ---> Go
# Binaries for programs and plugins
*.exe


+ 1
- 0
go.mod View File

@@ -5,6 +5,7 @@ go 1.12
require (
git.rootprojects.org/root/go-gitver v1.1.2
github.com/UnnoTed/fileb0x v1.1.3
github.com/mitchellh/go-ps v0.0.0-20170309133038-4fdf99ab2936
golang.org/x/net v0.0.0-20180921000356-2f5d2388922f
golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb
)

+ 2
- 0
go.sum View File

@@ -26,6 +26,8 @@ github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs
github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-runewidth v0.0.3 h1:a+kO+98RDGEfo6asOGMmpodZq4FNtnGP54yps8BzLR4=
github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
github.com/mitchellh/go-ps v0.0.0-20170309133038-4fdf99ab2936 h1:kw1v0NlnN+GZcU8Ma8CLF2Zzgjfx95gs3/GN3vYAPpo=
github.com/mitchellh/go-ps v0.0.0-20170309133038-4fdf99ab2936/go.mod h1:r1VsdOzOPt1ZSrGZWFoNhsAedKnEd6r9Np1+5blZCWk=
github.com/mitchellh/go-wordwrap v1.0.0 h1:6GlHJ/LTGMrIJbwgdqdl2eEH8o+Exx/0m8ir9Gns0u4=
github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
github.com/nsf/termbox-go v0.0.0-20180819125858-b66b20ab708e h1:fvw0uluMptljaRKSU8459cJ4bmi3qUYyMs5kzpic2fY=


+ 18
- 0
manager/install.go View File

@@ -7,6 +7,7 @@ import (
"os"
"os/exec"
"path/filepath"
"strings"

"git.rootprojects.org/root/go-serviceman/service"
)
@@ -42,6 +43,14 @@ func Install(c *service.Service) error {
return nil
}

func Start(conf *service.Service) error {
return start(conf)
}

func Stop(conf *service.Service) error {
return stop(conf)
}

// IsPrivileged returns true if we suspect that the current user (or process) will be able
// to write to system folders, bind to privileged ports, and otherwise
// successfully run a system service.
@@ -57,3 +66,12 @@ func WhereIs(exe string) (string, error) {
}
return filepath.Abs(filepath.ToSlash(exepath))
}

type ErrDaemonize struct {
DaemonArgs []string
error string
}

func (e *ErrDaemonize) Error() string {
return e.error + "\nYou need to switch on ErrDaemonize, and use .DaemonArgs, which would run this:" + strings.Join(e.DaemonArgs, " ")
}

+ 52
- 17
manager/install_darwin.go View File

@@ -24,25 +24,16 @@ func init() {
srvLen = len(srvExt)
}

func start(system bool, home string, name string) error {
sys, user, err := getMatchingSrvs(home, name)
func start(conf *service.Service) error {
system := conf.System
home := conf.Home
rdns := conf.ReverseDNS

service, err := getService(system, home, rdns)
if nil != err {
return err
}

var service string
if system {
service, err = getOneSysSrv(sys, user, name)
if nil != err {
return err
}
} else {
service, err = getOneUserSrv(home, sys, user, name)
if nil != err {
return err
}
}

cmds := []Runnable{
Runnable{
Exec: "launchctl",
@@ -60,7 +51,51 @@ func start(system bool, home string, name string) error {
cmds = adjustPrivs(system, cmds)

fmt.Println()
fmt.Println("Starting launchd service...")
typ := "USER"
if system {
typ = "SYSTEM"
}
fmt.Printf("Starting launchd %s service...\n", typ)
for i := range cmds {
exe := cmds[i]
fmt.Println("\t" + exe.String())
err := exe.Run()
if nil != err {
return err
}
}
fmt.Println()

return nil
}

func stop(conf *service.Service) error {
system := conf.System
home := conf.Home
rdns := conf.ReverseDNS

service, err := getService(system, home, rdns)
if nil != err {
return err
}

cmds := []Runnable{
Runnable{
Exec: "launchctl",
Args: []string{"unload", service},
Must: false,
Badwords: []string{"No such file or directory", "Cound not find specified service"},
},
}

cmds = adjustPrivs(system, cmds)

fmt.Println()
typ := "USER"
if system {
typ = "SYSTEM"
}
fmt.Printf("Stopping launchd %s service...\n", typ)
for i := range cmds {
exe := cmds[i]
fmt.Println("\t" + exe.String())
@@ -118,7 +153,7 @@ func install(c *service.Service) error {
}

// TODO --no-start
err = start(c.System, c.Home, c.ReverseDNS)
err = start(c)
if nil != err {
fmt.Printf("If things don't go well you should be able to get additional logging from launchctl:\n")
fmt.Printf("\tsudo launchctl log level debug\n")


+ 65
- 17
manager/install_linux.go View File

@@ -29,25 +29,16 @@ func init() {
srvLen = len(srvExt)
}

func start(system bool, home string, name string) error {
sys, user, err := getMatchingSrvs(home, name)
func start(conf *service.Service) error {
system := conf.System
home := conf.Home
name := conf.ReverseDNS

_, err := getService(system, home, name)
if nil != err {
return err
}

// var service string
if system {
_, err = getOneSysSrv(sys, user, name)
if nil != err {
return err
}
} else {
_, err = getOneUserSrv(home, sys, user, name)
if nil != err {
return err
}
}

var cmds []Runnable
if system {
cmds = []Runnable{
@@ -92,7 +83,64 @@ func start(system bool, home string, name string) error {
cmds = adjustPrivs(system, cmds)

fmt.Println()
fmt.Println("Starting systemd service unit...")
typ := "USER MODE"
if system {
typ = "SYSTEM"
}
fmt.Printf("Starting systemd %s service unit...\n", typ)
for i := range cmds {
exe := cmds[i]
fmt.Println("\t" + exe.String())
err := exe.Run()
if nil != err {
return err
}
}
fmt.Println()

return nil
}

func stop(conf *service.Service) error {
system := conf.System
home := conf.Home
name := conf.ReverseDNS

_, err := getService(system, home, name)
if nil != err {
return err
}

var cmds []Runnable
badwords := []string{"Failed to stop"}
if system {
cmds = []Runnable{
Runnable{
Exec: "systemctl",
Args: []string{"stop", name + ".service"},
Must: true,
Badwords: badwords,
},
}
} else {
cmds = []Runnable{
Runnable{
Exec: "systemctl",
Args: []string{"stop", "--user", name + ".service"},
Must: true,
Badwords: badwords,
},
}
}

cmds = adjustPrivs(system, cmds)

fmt.Println()
typ := "USER MODE"
if system {
typ = "SYSTEM"
}
fmt.Printf("Stopping systemd %s service...\n", typ)
for i := range cmds {
exe := cmds[i]
fmt.Println("\t" + exe.String())
@@ -152,7 +200,7 @@ func install(c *service.Service) error {
}

// TODO --no-start
err = start(c.System, c.Home, c.Name)
err = start(c)
if nil != err {
sudo := ""
// --user-unit rather than --user --unit for older systemd


+ 43
- 13
manager/install_windows.go View File

@@ -9,6 +9,7 @@ import (
"path/filepath"
"strings"

"git.rootprojects.org/root/go-serviceman/runner"
"git.rootprojects.org/root/go-serviceman/service"

"golang.org/x/sys/windows/registry"
@@ -67,6 +68,9 @@ func install(c *service.Service) error {
}
defer k.Close()

// Try to stop before trying to copy the file
_ = runner.Stop(c)

args, err := installServiceman(c)
if nil != err {
return err
@@ -104,23 +108,56 @@ func install(c *service.Service) error {
//fmt.Println(autorunKey, c.Title, regSZ)
k.SetStringValue(c.Title, regSZ)

return nil
// to return ErrDaemonize
return start(c)
}

// copies self to install path and returns config path
func installServiceman(c *service.Service) ([]string, error) {
// TODO check version and upgrade or dismiss
func start(conf *service.Service) error {
args := getRunnerArgs(conf)
return &ErrDaemonize{
DaemonArgs: append(args, "--daemon"),
error: "Not as much an error as a bad value...",
}
//return runner.Start(conf)
}

func stop(conf *service.Service) error {
return runner.Stop(conf)
}

func getRunnerArgs(c *service.Service) []string {
self := os.Args[0]
debug := ""
if strings.Contains(self, "debug.exe") {
debug = "debug."
}

smdir := `\opt\serviceman`
// TODO support service level services (which probably wouldn't need serviceman)
smdir = filepath.Join(c.Home, ".local", smdir)
// for now we'll scope the runner to the name of the application
smbin := filepath.Join(smdir, `bin\serviceman.`+debug+c.Name+`.exe`)

confpath := filepath.Join(smdir, `etc`)
conffile := filepath.Join(confpath, c.Name+`.json`)

return []string{
smbin,
"run",
"--config",
conffile,
}
}

// copies self to install path and returns config path
func installServiceman(c *service.Service) ([]string, error) {
// TODO check version and upgrade or dismiss
self := os.Args[0]

args := getRunnerArgs(c)
smbin := args[0]
conffile := args[len(args)-1]

if smbin != self {
err := os.MkdirAll(filepath.Dir(smbin), 0755)
if nil != err {
@@ -141,21 +178,14 @@ func installServiceman(c *service.Service) ([]string, error) {
// this should be impossible, so we'll just panic
panic(err)
}
confpath := filepath.Join(smdir, `etc`)
err = os.MkdirAll(confpath, 0755)
err = os.MkdirAll(filepath.Dir(conffile), 0755)
if nil != err {
return nil, err
}
conffile := filepath.Join(confpath, c.Name+`.json`)
err = ioutil.WriteFile(conffile, b, 0640)
if nil != err {
return nil, err
}

return []string{
smbin,
"run",
"--config",
conffile,
}, nil
return args, nil
}

+ 22
- 0
manager/start.go View File

@@ -8,6 +8,28 @@ import (
"strings"
)

func getService(system bool, home string, name string) (string, error) {
sys, user, err := getMatchingSrvs(home, name)
if nil != err {
return "", err
}

var service string
if system {
service, err = getOneSysSrv(sys, user, name)
if nil != err {
return "", err
}
} else {
service, err = getOneUserSrv(home, sys, user, name)
if nil != err {
return "", err
}
}

return service, nil
}

// Runnable defines a command to run, along with its arguments,
// and whether or not failing to exit successfully matters.
// It also defines whether certains words must exist (or not exist)


+ 140
- 2
runner/runner.go View File

@@ -2,13 +2,17 @@ package runner

import (
"fmt"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"time"

"git.rootprojects.org/root/go-serviceman/service"

ps "github.com/mitchellh/go-ps"
)

// Filled in on init by runner_windows.go
@@ -17,7 +21,9 @@ var shellArgs = []string{}
// Notes on spawning a child process
// https://groups.google.com/forum/#!topic/golang-nuts/shST-SDqIp4

func Run(conf *service.Service) {
// Start will execute the service, and write the PID and logs out to the log directory
func Start(conf *service.Service) error {
pid := os.Getpid()
originalBackoff := 1 * time.Second
maxBackoff := 1 * time.Minute
threshold := 5 * time.Second
@@ -26,6 +32,17 @@ func Run(conf *service.Service) {
failures := 0
logfile := filepath.Join(conf.Logdir, conf.Name+".log")

if oldPid, exename, err := getProcess(conf); nil == err {
return fmt.Errorf("%q may already be running as %q (pid %d)", conf.Name, exename, oldPid)
}

go func() {
for {
maybeWritePidFile(pid, conf)
time.Sleep(1 * time.Second)
}
}()

binpath := conf.Exec
args := []string{}
if "" != conf.Interpreter {
@@ -84,7 +101,7 @@ func Run(conf *service.Service) {
backoff = originalBackoff
failures = 0
} else {
failures += 1
failures++
fmt.Fprintf(lf, "Waiting %s to restart %q (%d consequtive immediate exits)\n", backoff, conf.Name, failures)
time.Sleep(backoff)
backoff *= 2
@@ -93,4 +110,125 @@ func Run(conf *service.Service) {
}
}
}

return nil
}

// Stop will find and stop another serviceman runner instance by it's PID
func Stop(conf *service.Service) error {
i := 0
var err error
for {
if i >= 3 {
return err
}
i++
oldPid, exename, err2 := getProcess(conf)
err = err2
switch err {
case nil:
fmt.Printf("killing old process %q with pid %d\n", exename, oldPid)
err := kill(oldPid)
if nil != err {
return err
}
return waitForProcessToDie(oldPid)
case ErrNoPidFile:
return err
case ErrNoProcess:
return err
case ErrInvalidPidFile:
fallthrough
default:
// waiting a little bit since the PID is written every second
time.Sleep(400 * time.Millisecond)
}
}

return fmt.Errorf("unexpected error: %s", err)
}

// Restart calls Stop, ignoring any failure, and then Start, returning any failure
func Restart(conf *service.Service) error {
_ = Stop(conf)
return Start(conf)
}

var ErrNoPidFile = fmt.Errorf("no pid file")
var ErrInvalidPidFile = fmt.Errorf("malformed pid file")
var ErrNoProcess = fmt.Errorf("process not found by pid")

func waitForProcessToDie(pid int) error {
exename := "unknown"
for i := 0; i < 10; i++ {
px, err := ps.FindProcess(pid)
if nil != err {
return nil
}
if nil == px {
return nil
}
exename = px.Executable()
time.Sleep(1 * time.Second)
}
return fmt.Errorf("process %q (%d) just won't die", exename, pid)
}

func getProcess(conf *service.Service) (int, string, error) {
// TODO make Pidfile() a property of conf?
pidFile := filepath.Join(conf.Logdir, conf.Name+".pid")
b, err := ioutil.ReadFile(pidFile)
if nil != err {
return 0, "", ErrNoPidFile
}

s := strings.TrimSpace(string(b))
oldPid, err := strconv.Atoi(s)
if nil != err {
return 0, "", ErrInvalidPidFile
}

px, err := ps.FindProcess(oldPid)
if nil != err {
return 0, "", err
}
if nil == px {
return 0, "", ErrNoProcess
}

_, err = os.FindProcess(oldPid)
if nil != err {
return 0, "", err
}

exename := px.Executable()
return oldPid, exename, nil
}

// TODO error out if can't write to PID or log
func maybeWritePidFile(pid int, conf *service.Service) bool {
newPid := []byte(strconv.Itoa(pid))

// TODO use a specific PID dir? meh...
pidFile := filepath.Join(conf.Logdir, conf.Name+".pid")
b, err := ioutil.ReadFile(pidFile)
if nil != err {
ioutil.WriteFile(pidFile, newPid, 0644)
return true
}

s := strings.TrimSpace(string(b))
oldPid, err := strconv.Atoi(s)
if nil != err {
ioutil.WriteFile(pidFile, newPid, 0644)
return true
}

if oldPid != pid {
Stop(conf)
ioutil.WriteFile(pidFile, newPid, 0644)
return true
}

return false
}

+ 13
- 1
runner/runner_notwindows.go View File

@@ -2,7 +2,19 @@

package runner

import "os/exec"
import (
"os"
"os/exec"
)

func backgroundCmd(cmd *exec.Cmd) {
}

func kill(pid int) error {
p, err := os.FindProcess(pid)
// already died
if nil != err {
return nil
}
return p.Kill()
}

+ 13
- 0
runner/runner_windows.go View File

@@ -1,10 +1,23 @@
package runner

import (
"fmt"
"os/exec"
"strconv"
"syscall"
)

func backgroundCmd(cmd *exec.Cmd) {
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
}

func kill(pid int) error {
// Kill the whole processes tree (all children and grandchildren)
cmd := exec.Command("taskkill", "/pid", strconv.Itoa(pid), "/T", "/F")
b, err := cmd.CombinedOutput()
if nil != err {
return fmt.Errorf("%s: %s", err.Error(), string(b))
}

return nil
}

+ 6
- 1
service/service.go View File

@@ -71,7 +71,7 @@ type Service struct {
MultiuserProtection bool `json:"multiuser_protection,omitempty"`
}

func (s *Service) Normalize(force bool) {
func (s *Service) NormalizeWithoutPath() {
if "" == s.Name {
ext := filepath.Ext(s.Exec)
base := filepath.Base(s.Exec[:len(s.Exec)-len(ext)])
@@ -93,11 +93,16 @@ func (s *Service) Normalize(force bool) {
os.Exit(4)
return
}
s.Home = home
s.Local = filepath.Join(home, ".local")
s.Logdir = filepath.Join(home, ".local", "share", s.Name, "var", "log")
} else {
s.Logdir = "/var/log/" + s.Name
}
}

func (s *Service) Normalize(force bool) {
s.NormalizeWithoutPath()

// Check to see if Exec exists
// /whatever => must exist exactly


+ 112
- 10
serviceman.go View File

@@ -22,8 +22,12 @@ var GitVersion = "v0.0.0"
var GitTimestamp = time.Now().Format(time.RFC3339)

func usage() {
fmt.Println("Usage: serviceman add ./foo-app -- --foo-arg")
fmt.Println("Usage: serviceman run --config ./foo-app.json")
fmt.Println("Usage:")
fmt.Println("\tserviceman <command> --help")
fmt.Println("\tserviceman add ./foo-app -- --foo-arg")
fmt.Println("\tserviceman run --config ./foo-app.json")
fmt.Println("\tserviceman start <name>")
fmt.Println("\tserviceman stop <name>")
}

func main() {
@@ -38,10 +42,14 @@ func main() {
switch top {
case "version":
fmt.Println(GitVersion, GitTimestamp, GitRev)
case "add":
add()
case "run":
run()
case "add":
add()
case "start":
start()
case "stop":
stop()
default:
fmt.Fprintf(os.Stderr, "Unknown argument %s\n", top)
usage()
@@ -106,7 +114,7 @@ func add() {

execpath, err := manager.WhereIs(args[0])
if nil != err {
fmt.Fprintf(os.Stderr, "Error: '%s' could not be found.\n", args[0])
fmt.Fprintf(os.Stderr, "Error: '%s' could not be found in PATH or working directory.\n", args[0])
if !force {
os.Exit(3)
return
@@ -131,7 +139,12 @@ func add() {
}

err = manager.Install(conf)
if nil != err {
switch e := err.(type) {
case nil:
// do nothing
case *manager.ErrDaemonize:
runAsDaemon(e.DaemonArgs[0], e.DaemonArgs[1:]...)
default:
fmt.Fprintf(os.Stderr, "%s\n", err)
}

@@ -139,6 +152,88 @@ func add() {
fmt.Println()
}

func start() {
forUser := false
forSystem := false
flag.BoolVar(&forSystem, "system", false, "attempt to add system service as an unprivileged/unelevated user")
flag.BoolVar(&forUser, "user", false, "add user space / user mode service even when admin/root/sudo/elevated")
flag.Parse()

args := flag.Args()
if 1 != len(args) {
fmt.Println("Usage: serviceman start <name>")
os.Exit(1)
}

if forUser && forSystem {
fmt.Println("Pfff! You can't --user AND --system! What are you trying to pull?")
os.Exit(1)
return
}

conf := &service.Service{
Name: args[0],
Restart: false,
}
if forUser {
conf.System = false
} else if forSystem {
conf.System = true
} else {
conf.System = manager.IsPrivileged()
}
conf.NormalizeWithoutPath()

err := manager.Start(conf)
switch e := err.(type) {
case nil:
// do nothing
case *manager.ErrDaemonize:
runAsDaemon(e.DaemonArgs[0], e.DaemonArgs[1:]...)
default:
fmt.Println(err)
os.Exit(127)
}
}

func stop() {
forUser := false
forSystem := false
flag.BoolVar(&forSystem, "system", false, "attempt to add system service as an unprivileged/unelevated user")
flag.BoolVar(&forUser, "user", false, "add user space / user mode service even when admin/root/sudo/elevated")
flag.Parse()

args := flag.Args()
if 1 != len(args) {
fmt.Println("Usage: serviceman stop <name>")
os.Exit(1)
}

if forUser && forSystem {
fmt.Println("Pfff! You can't --user AND --system! What are you trying to pull?")
os.Exit(1)
return
}

conf := &service.Service{
Name: args[0],
Restart: false,
}
if forUser {
conf.System = false
} else if forSystem {
conf.System = true
} else {
conf.System = manager.IsPrivileged()
}
conf.NormalizeWithoutPath()

if err := manager.Stop(conf); nil != err {
fmt.Println(err)
os.Exit(127)
}
}

func run() {
var confpath string
var daemonize bool
@@ -183,7 +278,8 @@ func run() {
os.Exit(400)
}

s.Normalize(false)
force := false
s.Normalize(force)
fmt.Printf("All output will be directed to the logs at:\n\t%s\n", s.Logdir)
err = os.MkdirAll(s.Logdir, 0755)
if nil != err {
@@ -193,11 +289,17 @@ func run() {

if !daemonize {
//fmt.Fprintf(os.Stdout, "Running %s %s %s\n", s.Interpreter, s.Exec, strings.Join(s.Argv, " "))
runner.Run(s)
if err := runner.Start(s); nil != err {
fmt.Println("Error:", err)
}
return
}

cmd := exec.Command(os.Args[0], "run", "--config", confpath)
runAsDaemon(os.Args[0], "run", "--config", confpath)
}

func runAsDaemon(bin string, args ...string) {
cmd := exec.Command(bin, args...)
// for debugging
/*
out, err := cmd.CombinedOutput()
@@ -207,7 +309,7 @@ func run() {
fmt.Println(string(out))
*/

err = cmd.Start()
err := cmd.Start()
if nil != err {
fmt.Fprintf(os.Stderr, "%s\n", err)
os.Exit(500)


+ 1
- 0
vendor/github.com/mitchellh/go-ps/.gitignore View File

@@ -0,0 +1 @@
.vagrant/

+ 4
- 0
vendor/github.com/mitchellh/go-ps/.travis.yml View File

@@ -0,0 +1,4 @@
language: go

go:
- 1.2.1

+ 21
- 0
vendor/github.com/mitchellh/go-ps/LICENSE.md View File

@@ -0,0 +1,21 @@
The MIT License (MIT)

Copyright (c) 2014 Mitchell Hashimoto

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

+ 34
- 0
vendor/github.com/mitchellh/go-ps/README.md View File

@@ -0,0 +1,34 @@
# Process List Library for Go

go-ps is a library for Go that implements OS-specific APIs to list and
manipulate processes in a platform-safe way. The library can find and
list processes on Linux, Mac OS X, Solaris, and Windows.

If you're new to Go, this library has a good amount of advanced Go educational
value as well. It uses some advanced features of Go: build tags, accessing
DLL methods for Windows, cgo for Darwin, etc.

How it works:

* **Darwin** uses the `sysctl` syscall to retrieve the process table.
* **Unix** uses the procfs at `/proc` to inspect the process tree.
* **Windows** uses the Windows API, and methods such as
`CreateToolhelp32Snapshot` to get a point-in-time snapshot of
the process table.

## Installation

Install using standard `go get`:

```
$ go get github.com/mitchellh/go-ps
...
```

## TODO

Want to contribute? Here is a short TODO list of things that aren't
implemented for this library that would be nice:

* FreeBSD support
* Plan9 support

+ 43
- 0
vendor/github.com/mitchellh/go-ps/Vagrantfile View File

@@ -0,0 +1,43 @@
# -*- mode: ruby -*-
# vi: set ft=ruby :
# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
config.vm.box = "chef/ubuntu-12.04"
config.vm.provision "shell", inline: $script
["vmware_fusion", "vmware_workstation"].each do |p|
config.vm.provider "p" do |v|
v.vmx["memsize"] = "1024"
v.vmx["numvcpus"] = "2"
v.vmx["cpuid.coresPerSocket"] = "1"
end
end
end
$script = <<SCRIPT
SRCROOT="/opt/go"
# Install Go
sudo apt-get update
sudo apt-get install -y build-essential mercurial
sudo hg clone -u release https://code.google.com/p/go ${SRCROOT}
cd ${SRCROOT}/src
sudo ./all.bash
# Setup the GOPATH
sudo mkdir -p /opt/gopath
cat <<EOF >/tmp/gopath.sh
export GOPATH="/opt/gopath"
export PATH="/opt/go/bin:\$GOPATH/bin:\$PATH"
EOF
sudo mv /tmp/gopath.sh /etc/profile.d/gopath.sh
sudo chmod 0755 /etc/profile.d/gopath.sh
# Make sure the gopath is usable by bamboo
sudo chown -R vagrant:vagrant $SRCROOT
sudo chown -R vagrant:vagrant /opt/gopath
SCRIPT

+ 40
- 0
vendor/github.com/mitchellh/go-ps/process.go View File

@@ -0,0 +1,40 @@
// ps provides an API for finding and listing processes in a platform-agnostic
// way.
//
// NOTE: If you're reading these docs online via GoDocs or some other system,
// you might only see the Unix docs. This project makes heavy use of
// platform-specific implementations. We recommend reading the source if you
// are interested.
package ps

// Process is the generic interface that is implemented on every platform
// and provides common operations for processes.
type Process interface {
// Pid is the process ID for this process.
Pid() int

// PPid is the parent process ID for this process.
PPid() int

// Executable name running this process. This is not a path to the
// executable.
Executable() string
}

// Processes returns all processes.
//
// This of course will be a point-in-time snapshot of when this method was
// called. Some operating systems don't provide snapshot capability of the
// process table, in which case the process table returned might contain
// ephemeral entities that happened to be running when this was called.
func Processes() ([]Process, error) {
return processes()
}

// FindProcess looks up a single process by pid.
//
// Process will be nil and error will be nil if a matching process is
// not found.
func FindProcess(pid int) (Process, error) {
return findProcess(pid)
}

+ 138
- 0
vendor/github.com/mitchellh/go-ps/process_darwin.go View File

@@ -0,0 +1,138 @@
// +build darwin

package ps

import (
"bytes"
"encoding/binary"
"syscall"
"unsafe"
)

type DarwinProcess struct {
pid int
ppid int
binary string
}

func (p *DarwinProcess) Pid() int {
return p.pid
}

func (p *DarwinProcess) PPid() int {
return p.ppid
}

func (p *DarwinProcess) Executable() string {
return p.binary
}

func findProcess(pid int) (Process, error) {
ps, err := processes()
if err != nil {
return nil, err
}

for _, p := range ps {
if p.Pid() == pid {
return p, nil
}
}

return nil, nil
}

func processes() ([]Process, error) {
buf, err := darwinSyscall()
if err != nil {
return nil, err
}

procs := make([]*kinfoProc, 0, 50)
k := 0
for i := _KINFO_STRUCT_SIZE; i < buf.Len(); i += _KINFO_STRUCT_SIZE {
proc := &kinfoProc{}
err = binary.Read(bytes.NewBuffer(buf.Bytes()[k:i]), binary.LittleEndian, proc)
if err != nil {
return nil, err
}

k = i
procs = append(procs, proc)
}

darwinProcs := make([]Process, len(procs))
for i, p := range procs {
darwinProcs[i] = &DarwinProcess{
pid: int(p.Pid),
ppid: int(p.PPid),
binary: darwinCstring(p.Comm),
}
}

return darwinProcs, nil
}

func darwinCstring(s [16]byte) string {
i := 0
for _, b := range s {
if b != 0 {
i++
} else {
break
}
}

return string(s[:i])
}

func darwinSyscall() (*bytes.Buffer, error) {
mib := [4]int32{_CTRL_KERN, _KERN_PROC, _KERN_PROC_ALL, 0}
size := uintptr(0)

_, _, errno := syscall.Syscall6(
syscall.SYS___SYSCTL,
uintptr(unsafe.Pointer(&mib[0])),
4,
0,
uintptr(unsafe.Pointer(&size)),
0,
0)

if errno != 0 {
return nil, errno
}

bs := make([]byte, size)
_, _, errno = syscall.Syscall6(
syscall.SYS___SYSCTL,
uintptr(unsafe.Pointer(&mib[0])),
4,
uintptr(unsafe.Pointer(&bs[0])),
uintptr(unsafe.Pointer(&size)),
0,
0)

if errno != 0 {
return nil, errno
}

return bytes.NewBuffer(bs[0:size]), nil
}

const (
_CTRL_KERN = 1
_KERN_PROC = 14
_KERN_PROC_ALL = 0
_KINFO_STRUCT_SIZE = 648
)

type kinfoProc struct {
_ [40]byte
Pid int32
_ [199]byte
Comm [16]byte
_ [301]byte
PPid int32
_ [84]byte
}

+ 260
- 0
vendor/github.com/mitchellh/go-ps/process_freebsd.go View File

@@ -0,0 +1,260 @@
// +build freebsd,amd64

package ps

import (
"bytes"
"encoding/binary"
"syscall"
"unsafe"
)

// copied from sys/sysctl.h
const (
CTL_KERN = 1 // "high kernel": proc, limits
KERN_PROC = 14 // struct: process entries
KERN_PROC_PID = 1 // by process id
KERN_PROC_PROC = 8 // only return procs
KERN_PROC_PATHNAME = 12 // path to executable
)

// copied from sys/user.h
type Kinfo_proc struct {
Ki_structsize int32
Ki_layout int32
Ki_args int64
Ki_paddr int64
Ki_addr int64
Ki_tracep int64
Ki_textvp int64
Ki_fd int64
Ki_vmspace int64
Ki_wchan int64
Ki_pid int32
Ki_ppid int32
Ki_pgid int32
Ki_tpgid int32
Ki_sid int32
Ki_tsid int32
Ki_jobc [2]byte
Ki_spare_short1 [2]byte
Ki_tdev int32
Ki_siglist [16]byte
Ki_sigmask [16]byte
Ki_sigignore [16]byte
Ki_sigcatch [16]byte
Ki_uid int32
Ki_ruid int32
Ki_svuid int32
Ki_rgid int32
Ki_svgid int32
Ki_ngroups [2]byte
Ki_spare_short2 [2]byte
Ki_groups [64]byte
Ki_size int64
Ki_rssize int64
Ki_swrss int64
Ki_tsize int64
Ki_dsize int64
Ki_ssize int64
Ki_xstat [2]byte
Ki_acflag [2]byte
Ki_pctcpu int32
Ki_estcpu int32
Ki_slptime int32
Ki_swtime int32
Ki_cow int32
Ki_runtime int64
Ki_start [16]byte
Ki_childtime [16]byte
Ki_flag int64
Ki_kiflag int64
Ki_traceflag int32
Ki_stat [1]byte
Ki_nice [1]byte
Ki_lock [1]byte
Ki_rqindex [1]byte
Ki_oncpu [1]byte
Ki_lastcpu [1]byte
Ki_ocomm [17]byte
Ki_wmesg [9]byte
Ki_login [18]byte
Ki_lockname [9]byte
Ki_comm [20]byte
Ki_emul [17]byte
Ki_sparestrings [68]byte
Ki_spareints [36]byte
Ki_cr_flags int32
Ki_jid int32
Ki_numthreads int32
Ki_tid int32
Ki_pri int32
Ki_rusage [144]byte
Ki_rusage_ch [144]byte
Ki_pcb int64
Ki_kstack int64
Ki_udata int64
Ki_tdaddr int64
Ki_spareptrs [48]byte
Ki_spareint64s [96]byte
Ki_sflag int64
Ki_tdflags int64
}

// UnixProcess is an implementation of Process that contains Unix-specific
// fields and information.
type UnixProcess struct {
pid int
ppid int
state rune
pgrp int
sid int

binary string
}

func (p *UnixProcess) Pid() int {
return p.pid
}

func (p *UnixProcess) PPid() int {
return p.ppid
}

func (p *UnixProcess) Executable() string {
return p.binary
}

// Refresh reloads all the data associated with this process.
func (p *UnixProcess) Refresh() error {

mib := []int32{CTL_KERN, KERN_PROC, KERN_PROC_PID, int32(p.pid)}

buf, length, err := call_syscall(mib)
if err != nil {
return err
}
proc_k := Kinfo_proc{}
if length != uint64(unsafe.Sizeof(proc_k)) {
return err
}

k, err := parse_kinfo_proc(buf)
if err != nil {
return err
}

p.ppid, p.pgrp, p.sid, p.binary = copy_params(&k)
return nil
}

func copy_params(k *Kinfo_proc) (int, int, int, string) {
n := -1
for i, b := range k.Ki_comm {
if b == 0 {
break
}
n = i + 1
}
comm := string(k.Ki_comm[:n])

return int(k.Ki_ppid), int(k.Ki_pgid), int(k.Ki_sid), comm
}

func findProcess(pid int) (Process, error) {
mib := []int32{CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, int32(pid)}

_, _, err := call_syscall(mib)
if err != nil {
return nil, err
}

return newUnixProcess(pid)
}

func processes() ([]Process, error) {
results := make([]Process, 0, 50)

mib := []int32{CTL_KERN, KERN_PROC, KERN_PROC_PROC, 0}
buf, length, err := call_syscall(mib)
if err != nil {
return results, err
}

// get kinfo_proc size
k := Kinfo_proc{}
procinfo_len := int(unsafe.Sizeof(k))
count := int(length / uint64(procinfo_len))

// parse buf to procs
for i := 0; i < count; i++ {
b := buf[i*procinfo_len : i*procinfo_len+procinfo_len]
k, err := parse_kinfo_proc(b)
if err != nil {
continue
}
p, err := newUnixProcess(int(k.Ki_pid))
if err != nil {
continue
}
p.ppid, p.pgrp, p.sid, p.binary = copy_params(&k)

results = append(results, p)
}

return results, nil
}

func parse_kinfo_proc(buf []byte) (Kinfo_proc, error) {
var k Kinfo_proc
br := bytes.NewReader(buf)
err := binary.Read(br, binary.LittleEndian, &k)
if err != nil {
return k, err
}

return k, nil
}

func call_syscall(mib []int32) ([]byte, uint64, error) {
miblen := uint64(len(mib))

// get required buffer size
length := uint64(0)
_, _, err := syscall.RawSyscall6(
syscall.SYS___SYSCTL,
uintptr(unsafe.Pointer(&mib[0])),
uintptr(miblen),
0,
uintptr(unsafe.Pointer(&length)),
0,
0)
if err != 0 {
b := make([]byte, 0)
return b, length, err
}
if length == 0 {
b := make([]byte, 0)
return b, length, err
}
// get proc info itself
buf := make([]byte, length)
_, _, err = syscall.RawSyscall6(
syscall.SYS___SYSCTL,
uintptr(unsafe.Pointer(&mib[0])),
uintptr(miblen),
uintptr(unsafe.Pointer(&buf[0])),
uintptr(unsafe.Pointer(&length)),
0,
0)
if err != 0 {
return buf, length, err
}

return buf, length, nil
}

func newUnixProcess(pid int) (*UnixProcess, error) {
p := &UnixProcess{pid: pid}
return p, p.Refresh()
}

+ 35
- 0
vendor/github.com/mitchellh/go-ps/process_linux.go View File

@@ -0,0 +1,35 @@
// +build linux

package ps

import (
"fmt"
"io/ioutil"
"strings"
)

// Refresh reloads all the data associated with this process.
func (p *UnixProcess) Refresh() error {
statPath := fmt.Sprintf("/proc/%d/stat", p.pid)
dataBytes, err := ioutil.ReadFile(statPath)
if err != nil {
return err
}

// First, parse out the image name
data := string(dataBytes)
binStart := strings.IndexRune(data, '(') + 1
binEnd := strings.IndexRune(data[binStart:], ')')
p.binary = data[binStart : binStart+binEnd]

// Move past the image name and start parsing the rest
data = data[binStart+binEnd+2:]
_, err = fmt.Sscanf(data,
"%c %d %d %d",
&p.state,
&p.ppid,
&p.pgrp,
&p.sid)

return err
}

+ 96
- 0
vendor/github.com/mitchellh/go-ps/process_solaris.go View File

@@ -0,0 +1,96 @@
// +build solaris

package ps

import (
"encoding/binary"
"fmt"
"os"
)

type ushort_t uint16

type id_t int32
type pid_t int32
type uid_t int32
type gid_t int32

type dev_t uint64
type size_t uint64
type uintptr_t uint64

type timestruc_t [16]byte

// This is copy from /usr/include/sys/procfs.h
type psinfo_t struct {
Pr_flag int32 /* process flags (DEPRECATED; do not use) */
Pr_nlwp int32 /* number of active lwps in the process */
Pr_pid pid_t /* unique process id */
Pr_ppid pid_t /* process id of parent */
Pr_pgid pid_t /* pid of process group leader */
Pr_sid pid_t /* session id */
Pr_uid uid_t /* real user id */
Pr_euid uid_t /* effective user id */
Pr_gid gid_t /* real group id */
Pr_egid gid_t /* effective group id */
Pr_addr uintptr_t /* address of process */
Pr_size size_t /* size of process image in Kbytes */
Pr_rssize size_t /* resident set size in Kbytes */
Pr_pad1 size_t
Pr_ttydev dev_t /* controlling tty device (or PRNODEV) */

// Guess this following 2 ushort_t values require a padding to properly
// align to the 64bit mark.
Pr_pctcpu ushort_t /* % of recent cpu time used by all lwps */
Pr_pctmem ushort_t /* % of system memory used by process */
Pr_pad64bit [4]byte

Pr_start timestruc_t /* process start time, from the epoch */
Pr_time timestruc_t /* usr+sys cpu time for this process */
Pr_ctime timestruc_t /* usr+sys cpu time for reaped children */
Pr_fname [16]byte /* name of execed file */
Pr_psargs [80]byte /* initial characters of arg list */
Pr_wstat int32 /* if zombie, the wait() status */
Pr_argc int32 /* initial argument count */
Pr_argv uintptr_t /* address of initial argument vector */
Pr_envp uintptr_t /* address of initial environment vector */
Pr_dmodel [1]byte /* data model of the process */
Pr_pad2 [3]byte
Pr_taskid id_t /* task id */
Pr_projid id_t /* project id */
Pr_nzomb int32 /* number of zombie lwps in the process */
Pr_poolid id_t /* pool id */
Pr_zoneid id_t /* zone id */
Pr_contract id_t /* process contract */
Pr_filler int32 /* reserved for future use */
Pr_lwp [128]byte /* information for representative lwp */
}

func (p *UnixProcess) Refresh() error {
var psinfo psinfo_t

path := fmt.Sprintf("/proc/%d/psinfo", p.pid)
fh, err := os.Open(path)
if err != nil {
return err
}
defer fh.Close()

err = binary.Read(fh, binary.LittleEndian, &psinfo)
if err != nil {
return err
}

p.ppid = int(psinfo.Pr_ppid)
p.binary = toString(psinfo.Pr_fname[:], 16)
return nil
}

func toString(array []byte, len int) string {
for i := 0; i < len; i++ {
if array[i] == 0 {
return string(array[:i])
}
}
return string(array[:])
}

+ 101
- 0
vendor/github.com/mitchellh/go-ps/process_unix.go View File

@@ -0,0 +1,101 @@
// +build linux solaris

package ps

import (
"fmt"
"io"
"os"
"strconv"
)

// UnixProcess is an implementation of Process that contains Unix-specific
// fields and information.
type UnixProcess struct {
pid int
ppid int
state rune
pgrp int
sid int

binary string
}

func (p *UnixProcess) Pid() int {
return p.pid
}

func (p *UnixProcess) PPid() int {
return p.ppid
}

func (p *UnixProcess) Executable() string {
return p.binary
}

func findProcess(pid int) (Process, error) {
dir := fmt.Sprintf("/proc/%d", pid)
_, err := os.Stat(dir)
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}

return nil, err
}

return newUnixProcess(pid)
}

func processes() ([]Process, error) {
d, err := os.Open("/proc")
if err != nil {
return nil, err
}
defer d.Close()

results := make([]Process, 0, 50)
for {
fis, err := d.Readdir(10)
if err == io.EOF {
break
}
if err != nil {
return nil, err
}

for _, fi := range fis {
// We only care about directories, since all pids are dirs
if !fi.IsDir() {
continue
}

// We only care if the name starts with a numeric
name := fi.Name()
if name[0] < '0' || name[0] > '9' {
continue
}

// From this point forward, any errors we just ignore, because
// it might simply be that the process doesn't exist anymore.
pid, err := strconv.ParseInt(name, 10, 0)
if err != nil {
continue
}

p, err := newUnixProcess(int(pid))
if err != nil {
continue
}

results = append(results, p)
}
}

return results, nil
}

func newUnixProcess(pid int) (*UnixProcess, error) {
p := &UnixProcess{pid: pid}
return p, p.Refresh()
}

+ 119
- 0
vendor/github.com/mitchellh/go-ps/process_windows.go View File

@@ -0,0 +1,119 @@
// +build windows

package ps

import (
"fmt"
"syscall"
"unsafe"
)

// Windows API functions
var (
modKernel32 = syscall.NewLazyDLL("kernel32.dll")
procCloseHandle = modKernel32.NewProc("CloseHandle")
procCreateToolhelp32Snapshot = modKernel32.NewProc("CreateToolhelp32Snapshot")
procProcess32First = modKernel32.NewProc("Process32FirstW")
procProcess32Next = modKernel32.NewProc("Process32NextW")
)

// Some constants from the Windows API
const (
ERROR_NO_MORE_FILES = 0x12
MAX_PATH = 260
)

// PROCESSENTRY32 is the Windows API structure that contains a process's
// information.
type PROCESSENTRY32 struct {
Size uint32
CntUsage uint32
ProcessID uint32
DefaultHeapID uintptr
ModuleID uint32
CntThreads uint32
ParentProcessID uint32
PriorityClassBase int32
Flags uint32
ExeFile [MAX_PATH]uint16
}

// WindowsProcess is an implementation of Process for Windows.
type WindowsProcess struct {
pid int
ppid int
exe string
}

func (p *WindowsProcess) Pid() int {
return p.pid
}

func (p *WindowsProcess) PPid() int {
return p.ppid
}

func (p *WindowsProcess) Executable() string {
return p.exe
}

func newWindowsProcess(e *PROCESSENTRY32) *WindowsProcess {
// Find when the string ends for decoding
end := 0
for {
if e.ExeFile[end] == 0 {
break
}
end++
}

return &WindowsProcess{
pid: int(e.ProcessID),
ppid: int(e.ParentProcessID),
exe: syscall.UTF16ToString(e.ExeFile[:end]),
}
}

func findProcess(pid int) (Process, error) {
ps, err := processes()
if err != nil {
return nil, err
}

for _, p := range ps {
if p.Pid() == pid {
return p, nil
}
}

return nil, nil
}

func processes() ([]Process, error) {
handle, _, _ := procCreateToolhelp32Snapshot.Call(
0x00000002,
0)
if handle < 0 {
return nil, syscall.GetLastError()
}
defer procCloseHandle.Call(handle)

var entry PROCESSENTRY32
entry.Size = uint32(unsafe.Sizeof(entry))
ret, _, _ := procProcess32First.Call(handle, uintptr(unsafe.Pointer(&entry)))
if ret == 0 {
return nil, fmt.Errorf("Error retrieving process info.")
}

results := make([]Process, 0, 50)
for {
results = append(results, newWindowsProcess(&entry))

ret, _, _ := procProcess32Next.Call(handle, uintptr(unsafe.Pointer(&entry)))
if ret == 0 {
break
}
}

return results, nil
}

+ 2
- 0
vendor/modules.txt View File

@@ -32,6 +32,8 @@ github.com/mattn/go-colorable
github.com/mattn/go-isatty
# github.com/mattn/go-runewidth v0.0.3
github.com/mattn/go-runewidth
# github.com/mitchellh/go-ps v0.0.0-20170309133038-4fdf99ab2936
github.com/mitchellh/go-ps
# github.com/mitchellh/go-wordwrap v1.0.0
github.com/mitchellh/go-wordwrap
# github.com/nsf/termbox-go v0.0.0-20180819125858-b66b20ab708e


Loading…
Cancel
Save