Coverage Report

Generated on Sun, 12 Nov 2023 22:22:50 UTC with gocov-html

Package Overview: github.com/KenjiTakahashi/svctl 82.0%

Please select a function to see what's left for testing.

`ctl.Ctl(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`25/25`
`ctlCmdHelp.Run(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`16/16`
`svTime(...)`	`github.com/KenjiTakahashi/svctl/sv.go`	`100.0%`	`16/16`
`ctl.completer(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`15/15`
`newStatus(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`14/14`
`ctl.Status(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`11/11`
`status.String(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`10/10`
`svPid(...)`	`github.com/KenjiTakahashi/svctl/sv.go`	`100.0%`	`8/8`
`ctlCmdStatus.Run(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`7/7`
`cmdMatchName(...)`	`github.com/KenjiTakahashi/svctl/cmds.go`	`100.0%`	`6/6`
`cmdSignal.Match(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`5/5`
`cmdSignal.Action(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`5/5`
`cmdMatch(...)`	`github.com/KenjiTakahashi/svctl/cmds.go`	`100.0%`	`5/5`
`contains(...)`	`github.com/KenjiTakahashi/svctl/cmds.go`	`100.0%`	`4/4`
`cmdSignal.Help(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`2/2`
`cmdRestart.Action(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdSignal.Names(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdAll(...)`	`github.com/KenjiTakahashi/svctl/cmds.go`	`100.0%`	`1/1`
`ctlCmdStatus.Action(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`svCheckControl(...)`	`github.com/KenjiTakahashi/svctl/sv.go`	`100.0%`	`1/1`
`ctlCmdExit.Names(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`svNow(...)`	`github.com/KenjiTakahashi/svctl/sv.go`	`100.0%`	`1/1`
`cmdUp.Action(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdUp.Help(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdUp.Names(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdDown.Action(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdDown.Help(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdDown.Names(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`ctlCmdExit.Help(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`cmdRestart.Help(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdRestart.Names(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdOnce.Action(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdOnce.Help(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`cmdOnce.Names(...)`	`github.com/KenjiTakahashi/svctl/svcmds.go`	`100.0%`	`1/1`
`ctlCmdExit.Action(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`ctlCmdHelp.Names(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`ctl.println(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`1/1`
`ctlCmdHelp.Help(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`ctlCmdHelp.Action(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`ctl.printf(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`1/1`
`ctlCmdStatus.Help(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`status.CheckControl(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`1/1`
`ctlCmdStatus.Names(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`100.0%`	`1/1`
`status.Errored(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`100.0%`	`1/1`
`ctl.Services(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`87.5%`	`14/16`
`svCheck(...)`	`github.com/KenjiTakahashi/svctl/sv.go`	`80.0%`	`16/20`
`ctl.ctl(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`75.0%`	`15/20`
`ctl.control(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`71.4%`	`5/7`
`svStatus(...)`	`github.com/KenjiTakahashi/svctl/sv.go`	`71.4%`	`5/7`
`status.status(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`69.2%`	`9/13`
`ctl.serviceName(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`66.7%`	`2/3`
`status.Check(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`66.7%`	`2/3`
`newCtl(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`0.0%`	`0/11`
`ctl.Close(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`0.0%`	`0/9`
`ctl.Run(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`0.0%`	`0/8`
`main(...)`	`github.com/KenjiTakahashi/svctl/svctl.go`	`0.0%`	`0/4`
`ctlCmdExit.Run(...)`	`github.com/KenjiTakahashi/svctl/ctlcmds.go`	`0.0%`	`0/1`

func ctl.Ctl

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) Ctl(cmdStr string) bool {
        c.line.AppendHistory(cmdStr)
        start := svNow()
        params := strings.Split(strings.TrimSpace(cmdStr), " ")

        cmd := cmdMatch(params[0])
        if ctlCmd, ok := cmd.(ctlCmd); ok {
                return ctlCmd.Run(c, params)
        }
        if cmd == nil {
                c.printf("%s: unable to find action\n", params[0])
                return false
        }
        action := cmd.Action()

        if len(params) == 1 {
                params = append(params, "*")
        }
        var wg sync.WaitGroup
        for _, param := range params[1:] {
                if param == "" {
                        continue
                }
                services := c.Services(param, false)
                if len(services) == 0 {
                        c.printf("%s: unable to find service\n", param)
                        continue
                }
                wg.Add(len(services))
                for _, service := range services {
                        go c.ctl(action, service, start, &wg)
                }
        }
        wg.Wait()

        return false
}

func ctlCmdHelp.Run

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

func (c *ctlCmdHelp) Run(ctl *ctl, params []string) bool {
        if len(params) == 1 {
                for _, cmd := range cmdAll() {
                        match, ok := cmd.(cmdMatcher)
                        if !ok {
                                ctl.println(cmd.Help())
                                continue
                        }
                        for _, name := range cmd.Names() {
                                match.Match(name)
                                ctl.println(cmd.Help())
                        }
                }
                return false
        }
        for _, param := range params[1:] {
                cmd := cmdMatch(param)
                if cmd == nil {
                        ctl.printf("%s: unable to find action\n", param)
                } else {
                        ctl.println(cmd.Help())
                }
        }
        return false
}

func svTime

Back

In /home/runner/work/svctl/svctl/sv.go:

func svTime(status []byte) uint64 {
        time := uint64(status[0])
        time <<= 8
        time += uint64(status[1])
        time <<= 8
        time += uint64(status[2])
        time <<= 8
        time += uint64(status[3])
        time <<= 8
        time += uint64(status[4])
        time <<= 8
        time += uint64(status[5])
        time <<= 8
        time += uint64(status[6])
        time <<= 8
        time += uint64(status[7])
        return time
}

func ctl.completer

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) completer(line string, pos int) (h string, compl []string, t string) {
        s := strings.Split(line, " ")
        if len(s) == 1 {
                return "", cmdMatchName(line), ""
        }
        i := strings.Count(line[:pos], " ")

        if s[0] == "?" || s[0] == "help" {
                compl = cmdMatchName(s[i])
        } else {
                services := c.Services(fmt.Sprintf("%s*", s[i]), true)

                compl = make([]string, len(services))
                for i, service := range services {
                        compl[i] = fmt.Sprintf("%s ", c.serviceName(service))
                }
        }
        h = fmt.Sprintf("%s ", strings.Join(s[:i], " "))
        t = strings.Join(s[i+1:], " ")
        if t != "" {
                t = fmt.Sprintf(" %s", t)
        }
        return
}

func newStatus

Back

In /home/runner/work/svctl/svctl/svctl.go:

func newStatus(dir, name string) *status {
        s := &status{Offsets: make([]int, 2), name: name}
        s.Offsets[0] = len(s.name)

        status, err := s.status(dir)
        if err != nil {
                s.err = err

                s.Offsets[1] = len("ERROR")
        } else {
                s.svPid = svPid(status)
                s.svStatus = svStatus(status, s.svPid)
                s.svTime = svTime(status)

                s.Offsets[1] = len(s.svStatus)
                if s.svStatus == "RUNNING" {
                        s.Offsets[1] += len(fmt.Sprintf(" (pid %d)", s.svPid))
                }
        }
        s.sv = status

        return s
}

func ctl.Status

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) Status(id string, toLog bool) {
        // TODO: normally (up|down) and stuff?
        services := c.Services(id, toLog)
        statuses := make([]*status, len(services))
        for i, dir := range services {
                status := newStatus(dir, c.serviceName(dir))
                statuses[i] = status

                for i, offset := range status.Offsets {
                        if statuses[0].Offsets[i] < offset {
                                statuses[0].Offsets[i] = offset
                        }
                }
        }
        for _, status := range statuses {
                status.Offsets = statuses[0].Offsets
                c.println(status)
        }
}

func status.String

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (s *status) String() string {
        var status bytes.Buffer
        fmt.Fprintf(&status, "%-[1]*s", s.Offsets[0]+3, s.name)
        if s.err != nil {
                fmt.Fprintf(&status, "%-[1]*s%s", s.Offsets[1]+3, "ERROR", s.err)
                return status.String()
        }
        fmt.Fprintf(&status, s.svStatus)
        if s.svStatus == "RUNNING" {
                fmt.Fprintf(&status, " (pid %d)", s.svPid)
        }
        fmt.Fprintf(
                &status, "%-[1]*s%ds",
                s.Offsets[1]+3-status.Len()+s.Offsets[0]+3, "", svNow()-s.svTime,
        )
        return status.String()
}

func svPid

Back

In /home/runner/work/svctl/svctl/sv.go:

func svPid(status []byte) uint {
        pid := uint(status[15])
        pid <<= 8
        pid += uint(status[14])
        pid <<= 8
        pid += uint(status[13])
        pid <<= 8
        pid += uint(status[12])
        return pid
}

func ctlCmdStatus.Run

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

func (c *ctlCmdStatus) Run(ctl *ctl, params []string) bool {
        if len(params) == 1 {
                ctl.Status("*", true)
        } else {
                for _, dir := range params[1:] {
                        if dir == "" {
                                continue
                        }
                        ctl.Status(dir, true)
                }
        }
        return false
}

func cmdMatchName

Back

In /home/runner/work/svctl/svctl/cmds.go:

func cmdMatchName(prefix string) []string {
        res := []string{}
        for _, cmd := range cmdAll() {
                for _, name := range cmd.Names() {
                        if strings.HasPrefix(name, prefix) {
                                res = append(res, fmt.Sprintf("%s ", name))
                        }
                }
        }
        return res
}

func cmdSignal.Match

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdSignal) Match(name string) bool {
        for _, s := range c.Names() {
                if name == s || name == s[0:1] {
                        c.action = s
                        return true
                }
        }
        return false
}

func cmdSignal.Action

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdSignal) Action() []byte {
        if c.action == "" {
                return nil
        }
        if c.action == "reload" {
                return []byte{'h'}
        }
        return []byte{c.action[0]}
}

func cmdMatch

Back

In /home/runner/work/svctl/svctl/cmds.go:

func cmdMatch(name string) cmd {
        for _, cmd := range cmdAll() {
                m, ok := cmd.(cmdMatcher)
                if (ok && m.Match(name)) || contains(cmd.Names(), name) || string(cmd.Action()) == name {
                        return cmd
                }
        }
        return nil
}

func contains

Back

In /home/runner/work/svctl/svctl/cmds.go:

func contains(slice []string, str string) bool {
        for _, elem := range slice {
                if elem == str {
                        return true
                }
        }
        return false
}

func cmdSignal.Help

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdSignal) Help() string {
        m := map[byte]string{
                'p': "STOP", 'c': "CONT", 'h': "HUP", 'r': "HUP", 'a': "ALRM", 'i': "INT",
                'q': "QUIT", '1': "USR1", '2': "USR2", 't': "TERM", 'k': "KILL",
        }
        return fmt.Sprintf(strings.TrimSpace(`
%s NAMES...   Sends signal '%s' to service(s) with matching NAMES.
%-[3]*s            NAMES support globing with '*' and '?'.
        `), c.action, m[c.action[0]], len(c.action), "")
}

func cmdRestart.Action

Back

In /home/runner/work/svctl/svctl/svcmds.go:

68	`func (c *cmdRestart) Action() []byte {`
69	`return []byte("tcu")`
70	`}`

func cmdSignal.Names

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdSignal) Names() []string {
        return []string{
                "pause", "cont", "hup", "reload", "alarm",
                "interrupt", "quit", "1", "2", "term", "kill",
        }
}

func cmdAll

Back

In /home/runner/work/svctl/svctl/cmds.go:

func cmdAll() []cmd {
        return []cmd{
                &cmdUp{},
                &cmdDown{},
                &cmdRestart{},
                &cmdOnce{},
                &cmdSignal{},

                &ctlCmdStatus{},
                &ctlCmdHelp{},
                &ctlCmdExit{},
        }
}

func ctlCmdStatus.Action

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

35	`func (c *ctlCmdStatus) Action() []byte {`
36	`return []byte{'s'}`
37	`}`

func svCheckControl

Back

In /home/runner/work/svctl/svctl/sv.go:

101	`func svCheckControl(action, status []byte) bool {`
102	`return status[17] != action[0] \|\| (action[0] == 'd' && status[18] != 1)`
103	`}`

func ctlCmdExit.Names

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

121	`func (c *ctlCmdExit) Names() []string {`
122	`return []string{"exit"}`
123	`}`

func svNow

Back

In /home/runner/work/svctl/svctl/sv.go:

130	`func svNow() uint64 {`
131	`return uint64(svTimeMod + time.Now().Unix())`
132	`}`

func cmdUp.Action

Back

In /home/runner/work/svctl/svctl/svcmds.go:

32	`func (c *cmdUp) Action() []byte {`
33	`return []byte("u")`
34	`}`

func cmdUp.Help

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdUp) Help() string {
        return strings.TrimSpace(`
up NAMES...   Starts service(s) with matching NAMES.
              NAMES support globing with '*' and '?'.
        `)
}

func cmdUp.Names

Back

In /home/runner/work/svctl/svctl/svcmds.go:

43	`func (c *cmdUp) Names() []string {`
44	`return []string{"up", "start"}`
45	`}`

func cmdDown.Action

Back

In /home/runner/work/svctl/svctl/svcmds.go:

50	`func (c *cmdDown) Action() []byte {`
51	`return []byte("d")`
52	`}`

func cmdDown.Help

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdDown) Help() string {
        return strings.TrimSpace(`
down NAMES...   Stops service(s) with matching NAMES.
                NAMES support globing with '*' and '?'.
        `)
}

func cmdDown.Names

Back

In /home/runner/work/svctl/svctl/svcmds.go:

61	`func (c *cmdDown) Names() []string {`
62	`return []string{"down", "stop"}`
63	`}`

func ctlCmdExit.Help

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

117	`func (c *ctlCmdExit) Help() string {`
118	`return "exit Exists svctl."`
119	`}`

func cmdRestart.Help

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdRestart) Help() string {
        return strings.TrimSpace(`
restart NAMES...   Restarts service(s) with matching NAMES.
                   NAMES support globing with '*' and '?'.
                   Waits up to 7 seconds for the service to get back up, then
                   reports TIMEOUT.
        `)
}

func cmdRestart.Names

Back

In /home/runner/work/svctl/svctl/svcmds.go:

81	`func (c *cmdRestart) Names() []string {`
82	`return []string{"r", "restart"}`
83	`}`

func cmdOnce.Action

Back

In /home/runner/work/svctl/svctl/svcmds.go:

88	`func (c *cmdOnce) Action() []byte {`
89	`return []byte{'o'}`
90	`}`

func cmdOnce.Help

Back

In /home/runner/work/svctl/svctl/svcmds.go:

func (c *cmdOnce) Help() string {
        return strings.TrimSpace(`
once NAMES...   Starts service once and does not try to restart it if it stops.
                NAMES support globing with '*' and '?'.
        `)
}

func cmdOnce.Names

Back

In /home/runner/work/svctl/svctl/svcmds.go:

99	`func (c *cmdOnce) Names() []string {`
100	`return []string{"once"}`
101	`}`

func ctlCmdExit.Action

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

113	`func (c *ctlCmdExit) Action() []byte {`
114	`return []byte{'e'}`
115	`}`

func ctlCmdHelp.Names

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

80	`func (c *ctlCmdHelp) Names() []string {`
81	`return []string{"help"}`
82	`}`

func ctl.println

Back

In /home/runner/work/svctl/svctl/svctl.go:

217	`func (c *ctl) println(a ...interface{}) {`
218	`fmt.Fprintln(c.stdout, a...)`
219	`}`

func ctlCmdHelp.Help

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

func (c *ctlCmdHelp) Help() string {
        return strings.TrimSpace(`
help [CMDS...]   Shows help message(s) about CMDS.
                 When invoked without CMDS, shows available CMDS.
        `)
}

func ctlCmdHelp.Action

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

69	`func (c *ctlCmdHelp) Action() []byte {`
70	`return []byte{'?'}`
71	`}`

func ctl.printf

Back

In /home/runner/work/svctl/svctl/svctl.go:

213	`func (c *ctl) printf(format string, a ...interface{}) {`
214	`fmt.Fprintf(c.stdout, format, a...)`
215	`}`

func ctlCmdStatus.Help

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

func (c *ctlCmdStatus) Help() string {
        return strings.TrimSpace(`
status [NAMES...]   Shows status(es) of service(s) with matching NAMES.
                    When invoked without NAMES, shows statuses of all processes.
                    NAMES support globing with '*' and '?'.
        `)
}

func status.CheckControl

Back

In /home/runner/work/svctl/svctl/svctl.go:

114	`func (s *status) CheckControl(action []byte) bool {`
115	`return svCheckControl(action, s.sv)`
116	`}`

func ctlCmdStatus.Names

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

47	`func (c *ctlCmdStatus) Names() []string {`
48	`return []string{"status"}`
49	`}`

func status.Errored

Back

In /home/runner/work/svctl/svctl/svctl.go:

141	`func (s *status) Errored() bool {`
142	`return s.err != nil`
143	`}`

func ctl.Services

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) Services(pattern string, toLog bool) []string {
        if len(pattern) < len(c.basedir) || pattern[:len(c.basedir)] != c.basedir {
                pattern = path.Join(c.basedir, pattern)
        }
        files, err := filepath.Glob(pattern)
        if err != nil {
                log.Printf("error getting services list: %s\n", err)
        }
        if toLog {
                logs, err := filepath.Glob(path.Join(pattern, "log"))
                if err != nil {
                        log.Printf("error getting logs list: %s\n", err)
                } else {
                        files = append(files, logs...)
                        sort.Strings(files)
                }
        }

        dirs := []string{}
        for _, file := range files {
                if fi, err := os.Stat(file); err == nil && fi.IsDir() {
                        dirs = append(dirs, file)
                }
        }
        return dirs
}

func svCheck

Back

In /home/runner/work/svctl/svctl/sv.go:

func svCheck(action, status []byte, start uint64) bool {
        for _, a := range action {
                pid := svPid(status)
                switch a {
                case 'x':
                        //TODO
                case 'u':
                        if pid == 0 || status[19] != 1 {
                                return false
                        }
                        //TODO: !checkscript():return false
                case 'd':
                        if pid != 0 || status[19] != 0 {
                                return false
                        }
                case 't', 'k', 'h', 'a', '1', '2':
                        if pid == 0 && status[17] == 'd' {
                                break
                        }
                        time := svTime(status)
                        if start > time || pid == 0 || status[18] != 0 { //TODO: ||!checkscript()
                                return false
                        }
                case 'o':
                        time := svTime(status)
                        if (pid == 0 && start > time) || (pid != 0 && status[17] != 'd') {
                                return false
                        }
                case 'p':
                        if pid != 0 && status[16] == 0 {
                                return false
                        }
                case 'c':
                        if pid != 0 && status[16] != 0 {
                                return false
                        }
                }
        }
        return true
}

func ctl.ctl

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) ctl(action []byte, service string, start uint64, wg *sync.WaitGroup) {
        defer wg.Done()

        status := newStatus(service, c.serviceName(service))
        if status.Errored() {
                c.println(status)
                return
        }
        if status.CheckControl(action) {
                if err := c.control(action, service); err != nil {
                        c.println(err)
                        return
                }
        }

        timeout := time.After(7 * time.Second)
        tick := time.Tick(100 * time.Millisecond)
        for {
                select {
                case <-timeout:
                        c.printf("TIMEOUT: ")
                        c.Status(service, false)
                        return
                case <-tick:
                        status := newStatus(service, c.serviceName(service))
                        if status.Check(action, start) {
                                c.println(status)
                                return
                        }
                }
        }
}

func ctl.control

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) control(action []byte, service string) error {
        f, err := os.OpenFile(
                path.Join(service, "supervise/control"), os.O_WRONLY, 0600,
        )
        if err != nil {
                return fmt.Errorf("%s: unable to open supervise/control", path.Base(service))
        }
        defer f.Close()
        if _, err := f.Write(action); err != nil {
                return fmt.Errorf("%s: unable to write to supervise/control", path.Base(service))
        }
        return nil
}

func svStatus

Back

In /home/runner/work/svctl/svctl/sv.go:

func svStatus(status []byte, pid uint) string {
        if pid != 0 && status[16] != 0 {
                return "PAUSED"
        }
        switch status[19] {
        case 0:
                return "STOPPED"
        case 1:
                return "RUNNING"
        case 2:
                return "FINISHING"
        default:
                return "UNKNOWN"
        }
}

func status.status

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (s *status) status(dir string) ([]byte, error) {
        if _, err := os.OpenFile(path.Join(dir, "supervise/ok"), os.O_WRONLY, 0600); err != nil {
                return nil, fmt.Errorf("unable to open supervise/ok")
        }

        fstatus, err := os.Open(path.Join(dir, "supervise/status"))
        if err != nil {
                return nil, fmt.Errorf("unable to open supervise/status")
        }

        b := make([]byte, 20)
        _, err = io.ReadFull(fstatus, b)
        fstatus.Close()
        if err != nil {
                if err == io.ErrUnexpectedEOF {
                        return nil, fmt.Errorf("unable to read supervise/status: wrong format")
                }
                return nil, fmt.Errorf("unable to read supervise/status")
        }
        return b, nil
}

func ctl.serviceName

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) serviceName(dir string) string {
        if name, err := filepath.Rel(c.basedir, dir); err == nil {
                return name
        }
        return dir
}

func status.Check

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (s *status) Check(action []byte, start uint64) bool {
        if s.err != nil {
                return true
        }
        return svCheck(action, s.sv, start)
}

func newCtl

Back

In /home/runner/work/svctl/svctl/svctl.go:

func newCtl(stdout io.Writer) *ctl {
        c := &ctl{line: liner.NewLiner(), stdout: stdout}

        fn, _ := xdg.DataFile("svctl/hist")
        if f, err := os.Open(fn); err == nil {
                c.line.ReadHistory(f)
                f.Close()
        }
        c.basedir = os.Getenv("SVDIR")
        if c.basedir == "" {
                c.basedir = "/service"
        }

        c.line.SetTabCompletionStyle(liner.TabPrints)
        c.line.SetWordCompleter(c.completer)

        return c
}

func ctl.Close

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) Close() {
        fn, _ := xdg.DataFile("svctl/hist")
        f, err := os.Create(fn)
        if err != nil {
                log.Printf("error opening history file: %s\n", err)
                return
        }
        if n, err := c.line.WriteHistory(f); err != nil {
                log.Printf("error writing history file: %s, lines written: %d\n", err, n)
        }
        c.line.Close()
        f.Close()
}

func ctl.Run

Back

In /home/runner/work/svctl/svctl/svctl.go:

func (c *ctl) Run() bool {
        cmd, err := c.line.Prompt("svctl> ")
        if err == io.EOF {
                c.println()
                return true
        } else if err != nil {
                log.Printf("error reading prompt contents: %s\n", err)
                return false
        }
        return c.Ctl(cmd)
}

func main

Back

In /home/runner/work/svctl/svctl/svctl.go:

func main() {
        ctl := newCtl(os.Stdout)
        defer ctl.Close()
        ctl.Status("*", true)
        for !ctl.Run() {
        }
}

func ctlCmdExit.Run

Back

In /home/runner/work/svctl/svctl/ctlcmds.go:

125	`func (c ctlCmdExit) Run(ctl ctl, params []string) bool {`
126	`return true`
127	`}`

github.com/KenjiTakahashi/svctl

82.0%

334	`func (c *ctl) Ctl(cmdStr string) bool {`
335	`c.line.AppendHistory(cmdStr)`
336	`start := svNow()`
337	`params := strings.Split(strings.TrimSpace(cmdStr), " ")`
338
339	`cmd := cmdMatch(params[0])`
340	`if ctlCmd, ok := cmd.(ctlCmd); ok {`
341	`return ctlCmd.Run(c, params)`
342	`}`
343	`if cmd == nil {`
344	`c.printf("%s: unable to find action\n", params[0])`
345	`return false`
346	`}`
347	`action := cmd.Action()`
348
349	`if len(params) == 1 {`
350	`params = append(params, "*")`
351	`}`
352	`var wg sync.WaitGroup`
353	`for _, param := range params[1:] {`
354	`if param == "" {`
355	`continue`
356	`}`
357	`services := c.Services(param, false)`
358	`if len(services) == 0 {`
359	`c.printf("%s: unable to find service\n", param)`
360	`continue`
361	`}`
362	`wg.Add(len(services))`
363	`for _, service := range services {`
364	`go c.ctl(action, service, start, &wg)`
365	`}`
366	`}`
367	`wg.Wait()`
368
369	`return false`
370	`}`

84	`func (c ctlCmdHelp) Run(ctl ctl, params []string) bool {`
85	`if len(params) == 1 {`
86	`for _, cmd := range cmdAll() {`
87	`match, ok := cmd.(cmdMatcher)`
88	`if !ok {`
89	`ctl.println(cmd.Help())`
90	`continue`
91	`}`
92	`for _, name := range cmd.Names() {`
93	`match.Match(name)`
94	`ctl.println(cmd.Help())`
95	`}`
96	`}`
97	`return false`
98	`}`
99	`for _, param := range params[1:] {`
100	`cmd := cmdMatch(param)`
101	`if cmd == nil {`
102	`ctl.printf("%s: unable to find action\n", param)`
103	`} else {`
104	`ctl.println(cmd.Help())`
105	`}`
106	`}`
107	`return false`
108	`}`

110	`func svTime(status []byte) uint64 {`
111	`time := uint64(status[0])`
112	`time <<= 8`
113	`time += uint64(status[1])`
114	`time <<= 8`
115	`time += uint64(status[2])`
116	`time <<= 8`
117	`time += uint64(status[3])`
118	`time <<= 8`
119	`time += uint64(status[4])`
120	`time <<= 8`
121	`time += uint64(status[5])`
122	`time <<= 8`
123	`time += uint64(status[6])`
124	`time <<= 8`
125	`time += uint64(status[7])`
126	`return time`
127	`}`

188	`func (c *ctl) completer(line string, pos int) (h string, compl []string, t string) {`
189	`s := strings.Split(line, " ")`
190	`if len(s) == 1 {`
191	`return "", cmdMatchName(line), ""`
192	`}`
193	`i := strings.Count(line[:pos], " ")`
194
195	`if s[0] == "?" \|\| s[0] == "help" {`
196	`compl = cmdMatchName(s[i])`
197	`} else {`
198	`services := c.Services(fmt.Sprintf("%s*", s[i]), true)`
199
200	`compl = make([]string, len(services))`
201	`for i, service := range services {`
202	`compl[i] = fmt.Sprintf("%s ", c.serviceName(service))`
203	`}`
204	`}`
205	`h = fmt.Sprintf("%s ", strings.Join(s[:i], " "))`
206	`t = strings.Join(s[i+1:], " ")`
207	`if t != "" {`
208	`t = fmt.Sprintf(" %s", t)`
209	`}`
210	`return`
211	`}`

58	`func newStatus(dir, name string) *status {`
59	`s := &status{Offsets: make([]int, 2), name: name}`
60	`s.Offsets[0] = len(s.name)`
61
62	`status, err := s.status(dir)`
63	`if err != nil {`
64	`s.err = err`
65
66	`s.Offsets[1] = len("ERROR")`
67	`} else {`
68	`s.svPid = svPid(status)`
69	`s.svStatus = svStatus(status, s.svPid)`
70	`s.svTime = svTime(status)`
71
72	`s.Offsets[1] = len(s.svStatus)`
73	`if s.svStatus == "RUNNING" {`
74	`s.Offsets[1] += len(fmt.Sprintf(" (pid %d)", s.svPid))`
75	`}`
76	`}`
77	`s.sv = status`
78
79	`return s`
80	`}`

258	`func (c *ctl) Status(id string, toLog bool) {`
259	`// TODO: normally (up\|down) and stuff?`
260	`services := c.Services(id, toLog)`
261	`statuses := make([]*status, len(services))`
262	`for i, dir := range services {`
263	`status := newStatus(dir, c.serviceName(dir))`
264	`statuses[i] = status`
265
266	`for i, offset := range status.Offsets {`
267	`if statuses[0].Offsets[i] < offset {`
268	`statuses[0].Offsets[i] = offset`
269	`}`
270	`}`
271	`}`
272	`for _, status := range statuses {`
273	`status.Offsets = statuses[0].Offsets`
274	`c.println(status)`
275	`}`
276	`}`

122	`func (s *status) String() string {`
123	`var status bytes.Buffer`
124	`fmt.Fprintf(&status, "%-[1]*s", s.Offsets[0]+3, s.name)`
125	`if s.err != nil {`
126	`fmt.Fprintf(&status, "%-[1]*s%s", s.Offsets[1]+3, "ERROR", s.err)`
127	`return status.String()`
128	`}`
129	`fmt.Fprintf(&status, s.svStatus)`
130	`if s.svStatus == "RUNNING" {`
131	`fmt.Fprintf(&status, " (pid %d)", s.svPid)`
132	`}`
133	`fmt.Fprintf(`
134	`&status, "%-[1]*s%ds",`
135	`s.Offsets[1]+3-status.Len()+s.Offsets[0]+3, "", svNow()-s.svTime,`
136	`)`
137	`return status.String()`
138	`}`

28	`func svPid(status []byte) uint {`
29	`pid := uint(status[15])`
30	`pid <<= 8`
31	`pid += uint(status[14])`
32	`pid <<= 8`
33	`pid += uint(status[13])`
34	`pid <<= 8`
35	`pid += uint(status[12])`
36	`return pid`
37	`}`

51	`func (c ctlCmdStatus) Run(ctl ctl, params []string) bool {`
52	`if len(params) == 1 {`
53	`ctl.Status("*", true)`
54	`} else {`
55	`for _, dir := range params[1:] {`
56	`if dir == "" {`
57	`continue`
58	`}`
59	`ctl.Status(dir, true)`
60	`}`
61	`}`
62	`return false`
63	`}`

85	`func cmdMatchName(prefix string) []string {`
86	`res := []string{}`
87	`for _, cmd := range cmdAll() {`
88	`for _, name := range cmd.Names() {`
89	`if strings.HasPrefix(name, prefix) {`
90	`res = append(res, fmt.Sprintf("%s ", name))`
91	`}`
92	`}`
93	`}`
94	`return res`
95	`}`

137	`func (c *cmdSignal) Match(name string) bool {`
138	`for _, s := range c.Names() {`
139	`if name == s \|\| name == s[0:1] {`
140	`c.action = s`
141	`return true`
142	`}`
143	`}`
144	`return false`
145	`}`

109	`func (c *cmdSignal) Action() []byte {`
110	`if c.action == "" {`
111	`return nil`
112	`}`
113	`if c.action == "reload" {`
114	`return []byte{'h'}`
115	`}`
116	`return []byte{c.action[0]}`
117	`}`

74	`func cmdMatch(name string) cmd {`
75	`for _, cmd := range cmdAll() {`
76	`m, ok := cmd.(cmdMatcher)`
77	`if (ok && m.Match(name)) \|\| contains(cmd.Names(), name) \|\| string(cmd.Action()) == name {`
78	`return cmd`
79	`}`
80	`}`
81	`return nil`
82	`}`

30	`func contains(slice []string, str string) bool {`
31	`for _, elem := range slice {`
32	`if elem == str {`
33	`return true`
34	`}`
35	`}`
36	`return false`
37	`}`

119	`func (c *cmdSignal) Help() string {`
120	`m := map[byte]string{`
121	`'p': "STOP", 'c': "CONT", 'h': "HUP", 'r': "HUP", 'a': "ALRM", 'i': "INT",`
122	`'q': "QUIT", '1': "USR1", '2': "USR2", 't': "TERM", 'k': "KILL",`
123	`}`
124	return fmt.Sprintf(strings.TrimSpace(`
125	`%s NAMES... Sends signal '%s' to service(s) with matching NAMES.`
126	`%-[3]s NAMES support globing with '' and '?'.`
127	`), c.action, m[c.action[0]], len(c.action), "")
128	`}`

58	`func cmdAll() []cmd {`
59	`return []cmd{`
60	`&cmdUp{},`
61	`&cmdDown{},`
62	`&cmdRestart{},`
63	`&cmdOnce{},`
64	`&cmdSignal{},`
65
66	`&ctlCmdStatus{},`
67	`&ctlCmdHelp{},`
68	`&ctlCmdExit{},`
69	`}`
70	`}`

130	`func (c *cmdSignal) Names() []string {`
131	`return []string{`
132	`"pause", "cont", "hup", "reload", "alarm",`
133	`"interrupt", "quit", "1", "2", "term", "kill",`
134	`}`
135	`}`

36	`func (c *cmdUp) Help() string {`
37	return strings.TrimSpace(`
38	`up NAMES... Starts service(s) with matching NAMES.`
39	`NAMES support globing with '*' and '?'.`
40	`)
41	`}`

54	`func (c *cmdDown) Help() string {`
55	return strings.TrimSpace(`
56	`down NAMES... Stops service(s) with matching NAMES.`
57	`NAMES support globing with '*' and '?'.`
58	`)
59	`}`

72	`func (c *cmdRestart) Help() string {`
73	return strings.TrimSpace(`
74	`restart NAMES... Restarts service(s) with matching NAMES.`
75	`NAMES support globing with '*' and '?'.`
76	`Waits up to 7 seconds for the service to get back up, then`
77	`reports TIMEOUT.`
78	`)
79	`}`

92	`func (c *cmdOnce) Help() string {`
93	return strings.TrimSpace(`
94	`once NAMES... Starts service once and does not try to restart it if it stops.`
95	`NAMES support globing with '*' and '?'.`
96	`)
97	`}`

73	`func (c *ctlCmdHelp) Help() string {`
74	return strings.TrimSpace(`
75	`help [CMDS...] Shows help message(s) about CMDS.`
76	`When invoked without CMDS, shows available CMDS.`
77	`)
78	`}`

39	`func (c *ctlCmdStatus) Help() string {`
40	return strings.TrimSpace(`
41	`status [NAMES...] Shows status(es) of service(s) with matching NAMES.`
42	`When invoked without NAMES, shows statuses of all processes.`
43	`NAMES support globing with '*' and '?'.`
44	`)
45	`}`

230	`func (c *ctl) Services(pattern string, toLog bool) []string {`
231	`if len(pattern) < len(c.basedir) \|\| pattern[:len(c.basedir)] != c.basedir {`
232	`pattern = path.Join(c.basedir, pattern)`
233	`}`
234	`files, err := filepath.Glob(pattern)`
235	`if err != nil {`
236	`log.Printf("error getting services list: %s\n", err)`
237	`}`
238	`if toLog {`
239	`logs, err := filepath.Glob(path.Join(pattern, "log"))`
240	`if err != nil {`
241	`log.Printf("error getting logs list: %s\n", err)`
242	`} else {`
243	`files = append(files, logs...)`
244	`sort.Strings(files)`
245	`}`
246	`}`
247
248	`dirs := []string{}`
249	`for _, file := range files {`
250	`if fi, err := os.Stat(file); err == nil && fi.IsDir() {`
251	`dirs = append(dirs, file)`
252	`}`
253	`}`
254	`return dirs`
255	`}`

58	`func svCheck(action, status []byte, start uint64) bool {`
59	`for _, a := range action {`
60	`pid := svPid(status)`
61	`switch a {`
62	`case 'x':`
63	`//TODO`
64	`case 'u':`
65	`if pid == 0 \|\| status[19] != 1 {`
66	`return false`
67	`}`
68	`//TODO: !checkscript():return false`
69	`case 'd':`
70	`if pid != 0 \|\| status[19] != 0 {`
71	`return false`
72	`}`
73	`case 't', 'k', 'h', 'a', '1', '2':`
74	`if pid == 0 && status[17] == 'd' {`
75	`break`
76	`}`
77	`time := svTime(status)`
78	`if start > time \|\| pid == 0 \|\| status[18] != 0 { //TODO: \|\|!checkscript()`
79	`return false`
80	`}`
81	`case 'o':`
82	`time := svTime(status)`
83	`if (pid == 0 && start > time) \|\| (pid != 0 && status[17] != 'd') {`
84	`return false`
85	`}`
86	`case 'p':`
87	`if pid != 0 && status[16] == 0 {`
88	`return false`
89	`}`
90	`case 'c':`
91	`if pid != 0 && status[16] != 0 {`
92	`return false`
93	`}`
94	`}`
95	`}`
96	`return true`
97	`}`

294	`func (c ctl) ctl(action []byte, service string, start uint64, wg sync.WaitGroup) {`
295	`defer wg.Done()`
296
297	`status := newStatus(service, c.serviceName(service))`
298	`if status.Errored() {`
299	`c.println(status)`
300	`return`
301	`}`
302	`if status.CheckControl(action) {`
303	`if err := c.control(action, service); err != nil {`
304	`c.println(err)`
305	`return`
306	`}`
307	`}`
308
309	`timeout := time.After(7 * time.Second)`
310	`tick := time.Tick(100 * time.Millisecond)`
311	`for {`
312	`select {`
313	`case <-timeout:`
314	`c.printf("TIMEOUT: ")`
315	`c.Status(service, false)`
316	`return`
317	`case <-tick:`
318	`status := newStatus(service, c.serviceName(service))`
319	`if status.Check(action, start) {`
320	`c.println(status)`
321	`return`
322	`}`
323	`}`
324	`}`
325	`}`

279	`func (c *ctl) control(action []byte, service string) error {`
280	`f, err := os.OpenFile(`
281	`path.Join(service, "supervise/control"), os.O_WRONLY, 0600,`
282	`)`
283	`if err != nil {`
284	`return fmt.Errorf("%s: unable to open supervise/control", path.Base(service))`
285	`}`
286	`defer f.Close()`
287	`if _, err := f.Write(action); err != nil {`
288	`return fmt.Errorf("%s: unable to write to supervise/control", path.Base(service))`
289	`}`
290	`return nil`
291	`}`

40	`func svStatus(status []byte, pid uint) string {`
41	`if pid != 0 && status[16] != 0 {`
42	`return "PAUSED"`
43	`}`
44	`switch status[19] {`
45	`case 0:`
46	`return "STOPPED"`
47	`case 1:`
48	`return "RUNNING"`
49	`case 2:`
50	`return "FINISHING"`
51	`default:`
52	`return "UNKNOWN"`
53	`}`
54	`}`

83	`func (s *status) status(dir string) ([]byte, error) {`
84	`if _, err := os.OpenFile(path.Join(dir, "supervise/ok"), os.O_WRONLY, 0600); err != nil {`
85	`return nil, fmt.Errorf("unable to open supervise/ok")`
86	`}`
87
88	`fstatus, err := os.Open(path.Join(dir, "supervise/status"))`
89	`if err != nil {`
90	`return nil, fmt.Errorf("unable to open supervise/status")`
91	`}`
92
93	`b := make([]byte, 20)`
94	`_, err = io.ReadFull(fstatus, b)`
95	`fstatus.Close()`
96	`if err != nil {`
97	`if err == io.ErrUnexpectedEOF {`
98	`return nil, fmt.Errorf("unable to read supervise/status: wrong format")`
99	`}`
100	`return nil, fmt.Errorf("unable to read supervise/status")`
101	`}`
102	`return b, nil`
103	`}`

222	`func (c *ctl) serviceName(dir string) string {`
223	`if name, err := filepath.Rel(c.basedir, dir); err == nil {`
224	`return name`
225	`}`
226	`return dir`
227	`}`

106	`func (s *status) Check(action []byte, start uint64) bool {`
107	`if s.err != nil {`
108	`return true`
109	`}`
110	`return svCheck(action, s.sv, start)`
111	`}`

154	`func newCtl(stdout io.Writer) *ctl {`
155	`c := &ctl{line: liner.NewLiner(), stdout: stdout}`
156
157	`fn, _ := xdg.DataFile("svctl/hist")`
158	`if f, err := os.Open(fn); err == nil {`
159	`c.line.ReadHistory(f)`
160	`f.Close()`
161	`}`
162	`c.basedir = os.Getenv("SVDIR")`
163	`if c.basedir == "" {`
164	`c.basedir = "/service"`
165	`}`
166
167	`c.line.SetTabCompletionStyle(liner.TabPrints)`
168	`c.line.SetWordCompleter(c.completer)`
169
170	`return c`
171	`}`

174	`func (c *ctl) Close() {`
175	`fn, _ := xdg.DataFile("svctl/hist")`
176	`f, err := os.Create(fn)`
177	`if err != nil {`
178	`log.Printf("error opening history file: %s\n", err)`
179	`return`
180	`}`
181	`if n, err := c.line.WriteHistory(f); err != nil {`
182	`log.Printf("error writing history file: %s, lines written: %d\n", err, n)`
183	`}`
184	`c.line.Close()`
185	`f.Close()`
186	`}`

374	`func (c *ctl) Run() bool {`
375	`cmd, err := c.line.Prompt("svctl> ")`
376	`if err == io.EOF {`
377	`c.println()`
378	`return true`
379	`} else if err != nil {`
380	`log.Printf("error reading prompt contents: %s\n", err)`
381	`return false`
382	`}`
383	`return c.Ctl(cmd)`
384	`}`

387	`func main() {`
388	`ctl := newCtl(os.Stdout)`
389	`defer ctl.Close()`
390	`ctl.Status("*", true)`
391	`for !ctl.Run() {`
392	`}`
393	`}`