Creating a PIDFile to use with init managers

[derekperkins]

This is related to #17 and #12, but wasn't specifically addressed there. Could you add a PIDFile that users could point systemd or other at to deal with spawning off new processes?

[wedow]

I feel like PID file handling would be out of scope for grace when there are existing packages such as https://github.com/facebookgo/pidfile which provide this functionality.

[derekperkins]

The problem with Upstart (and other similar systems) is that they don't expect the PID of the process to change after it has been started. grace breaks this because it starts a new process (while the old one finishes it's work) which has a new PID.

systemd has an option to watch a PID file. I'm just proposing that grace writes out its own PID file when it restarts itself. It's already respawning and at init is getting its own PID.
ppid = os.Getppid()

It would be trivial and essentially 0 performance impact to write out the PID file at that point and saves having to run yet another external process.

systemd => grace
systemd => graceMonitoringProcess => on grace change, notify systemd of PID change

vs

systemd => grace PIDfile

Maybe I'm understanding the situation incorrectly, but that's how I'd like to get things working.

[wedow]

We've been using the pidfile package to provide exactly this functionality for working with upstart. Writing a PID file to be monitored is simply this:

func init() {
    pidfile.SetPidfilePath(PIDFilePath)
    if err := pidfile.Write(); err != nil {
        log.Printf("Failed to write PID file to path: %s - %s", PIDFilePath, err)
    }
}

And then you can just tell systemd to watch the file at PIDFilePath

[derekperkins]

Ok, that makes a lot of sense putting the init in the code calling grace, I was confused as to where it was running. I think that would be very helpful to put into the readme, which I'm happy to create a PR for if you'd like.

[slava-vishnyakov]

@wedow Can you please elaborate a little on that init() ?

So, for example, I do this:

package main

import (
    "fmt"
    "net/http"
    "os"

    "github.com/facebookgo/grace/gracehttp"
    "github.com/facebookgo/pidfile"
    "log"
)

func main() {
    pidfile.SetPidfilePath("server.pid")
    if err := pidfile.Write(); err != nil {
        log.Printf("Failed to write PID file: %s", err)
    }

    gracehttp.Serve(
        &http.Server{Addr: ":48567", Handler: newHandler()},
    )
}

func newHandler() http.Handler {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "From pid %d.\n", os.Getpid())
    })
    return mux
}

This would work as expected if you run the app once and then reload it. But if you accidentally try to run the app second time - pidfile gets overwritten with incorrect pid (which quits immediately, since it can't use the port). Now, you have pidfile with incorrect pid.

$ go run test1.go &; \
sleep 2; echo "server.pid contents: '$(cat server.pid)'"; kill -0 $(cat server.pid)

2016/01/02 00:15:39 Serving [::]:48567 with pid 63399
server.pid contents: '63399'

$ go run test1.go &; \
sleep 2; echo "server.pid contents: '$(cat server.pid)'"; kill -0 $(cat server.pid)

server.pid contents: '63414'
kill: kill 63414 failed: no such process

I understand that I'm not supposed to start the code twice, but still - it would be much safer to be able to actually write only the real pid.

And if I give pid file management to init.d - then I have no idea of new pid file when go app reloads..

Where is the correct place for that pid/init code?

[matthewmueller]

@wedow @derekperkins , could you share some insight in how you got this working?

the situation in which upstart/systemd are needed is if grace crashes and needs to be restarted after the server has been updated (and there's a new pid).