testing a daemon tool

daemon.go

package main

import (
        "errors"
        "fmt"
        "github.com/takama/daemon"
        "log"
        "os"
        "os/signal"
        "syscall"
)

type Srv struct {
        daemon.Daemon
}

func (srv *Srv) Init() (string, error) {
        usage := "Usage: daemon | install | remove| start | stop | status"

        if len(os.Args) > 1 {
                cmd := os.Args[1]
                switch cmd {
                case "install":
                        return srv.Install()
                case "remove":
                        return srv.Remove()
                case "start":
                        return srv.Start()
                case "stop":
                        return srv.Stop()
                case "status":
                        return srv.Status()
                default:
                        return "", errors.New(usage)
                }

        }
        interrupt := make(chan os.Signal, 1)
        signal.Notify(interrupt, os.Interrupt, os.Kill, syscall.SIGTERM)

        for {
                select {
                case killSignal := <-interrupt:
                        log.Println("Got signal:", killSignal)
                        log.Println("Stopping execution")
                        if killSignal == os.Interrupt {
                                return "Daemon was interruped by system signal", nil
                        }
                        return "Daemon was killed", nil
                }
        }

        return "", errors.New(usage)
}

func main() {
        srv, err := daemon.New("daemon", "Testing daemon")
        if err != nil {
                fmt.Println("Error: ", err)
                os.Exit(1)
        }

        service := &Srv{srv}
        status, err := service.Init()
        if err != nil {
                fmt.Println(status, "\nError: ", err)
                os.Exit(2)
        }

        fmt.Println(status)
}