func status() {
if !util.FileExists(util.PidFilePath()) {
fmt.Println("REX-Ray is stopped")
return
}
pid, _ := util.ReadPidFile()
fmt.Printf("REX-Ray is running at pid %d\n", pid)
}
func restart() {
checkOpPerms("restarted")
if util.FileExists(util.PidFilePath()) {
stop()
}
start()
}
func (c *CLI) restart() {
checkOpPerms("restarted")
if gotil.FileExists(util.PidFilePath()) {
stop()
}
c.start()
}
func stop() {
checkOpPerms("stopped")
if !util.FileExists(util.PidFilePath()) {
fmt.Println("REX-Ray is already stopped")
panic(1)
}
fmt.Print("Shutting down REX-Ray...")
pid, pidErr := util.ReadPidFile()
failOnError(pidErr)
proc, procErr := os.FindProcess(pid)
failOnError(procErr)
killErr := proc.Signal(syscall.SIGHUP)
failOnError(killErr)
fmt.Println("SUCCESS!")
}
func start() {
checkOpPerms("started")
log.WithField("os.Args", os.Args).Debug("invoking service start")
pidFile := util.PidFilePath()
if util.FileExists(pidFile) {
pid, pidErr := util.ReadPidFile()
if pidErr != nil {
fmt.Printf("Error reading REX-Ray PID file at %s\n", pidFile)
} else {
fmt.Printf("REX-Ray already running at PID %d\n", pid)
}
panic(1)
}
if fg || client != "" {
startDaemon()
} else {
tryToStartDaemon()
}
}
func (c *CLI) start() {
checkOpPerms("started")
log.WithField("os.Args", os.Args).Debug("invoking service start")
pidFile := util.PidFilePath()
if gotil.FileExists(pidFile) {
pid, pidErr := util.ReadPidFile()
if pidErr != nil {
fmt.Printf("Error reading REX-Ray PID file at %s\n", pidFile)
panic(1)
}
rrproc, err := findProcess(pid)
if err != nil {
fmt.Printf("Error finding process for PID %d", pid)
panic(1)
}
if rrproc != nil {
fmt.Printf("REX-Ray already running at PID %d\n", pid)
panic(1)
}
if err := os.RemoveAll(pidFile); err != nil {
fmt.Println("Error removing REX-Ray PID file")
panic(1)
}
}
if c.fg || c.client != "" {
c.startDaemon()
} else {
c.tryToStartDaemon()
}
}
func startDaemon() {
var out io.Writer = os.Stdout
if !log.IsTerminal() {
logFile, logFileErr := util.LogFile("rexray.log")
failOnError(logFileErr)
out = io.MultiWriter(os.Stdout, logFile)
}
log.SetOutput(out)
fmt.Fprintf(out, "%s\n", rexRayLogoASCII)
util.PrintVersion(out)
fmt.Fprintln(out)
var success []byte
var failure []byte
var conn net.Conn
if !fg {
success = []byte{0}
failure = []byte{1}
var dialErr error
log.Printf("dialing %s", client)
conn, dialErr = net.Dial("unix", client)
if dialErr != nil {
panic(dialErr)
}
}
writePidErr := util.WritePidFile(-1)
if writePidErr != nil {
if conn != nil {
conn.Write(failure)
}
panic(writePidErr)
}
defer func() {
r := recover()
os.Remove(util.PidFilePath())
if r != nil {
panic(r)
}
}()
log.Printf("created pid file, pid=%d", os.Getpid())
init := make(chan error)
sigc := make(chan os.Signal, 1)
stop := make(chan os.Signal)
signal.Notify(sigc,
syscall.SIGKILL,
syscall.SIGHUP,
syscall.SIGINT,
syscall.SIGTERM,
syscall.SIGQUIT)
go func() {
rrdaemon.Start(r.Config.Host, init, stop)
}()
var initErrors []error
for initErr := range init {
initErrors = append(initErrors, initErr)
log.Println(initErr)
}
if conn != nil {
if len(initErrors) == 0 {
conn.Write(success)
} else {
conn.Write(failure)
}
conn.Close()
}
if len(initErrors) > 0 {
return
}
sigv := <-sigc
log.Printf("received shutdown signal %v", sigv)
stop <- sigv
}
