README
¶
go-daemon 
Library for writing system daemons in Go.
Now supported only UNIX-based OS (Windows is not supported). But the library was tested only on Linux and OSX, so that if you have an ability to test the library on other platforms, give me feedback, please (#26).
Please, feel free to send me bug reports and fixes. Many thanks to all contributors.
Features
- Goroutine-safe daemonization;
- Out of box work with pid-files;
- Easy handling of system signals;
- The control of a daemon.
Installation
go get github.com/sevlyar/go-daemon
You can use gopkg.in:
go get gopkg.in/sevlyar/go-daemon.v0
If you want to use the library in production project, please use vendoring, because i can not ensure backward compatibility before release v1.0.
Examples
Documentation
godoc.org/github.com/sevlyar/go-daemon
How it works
We can not use fork syscall in Golang's runtime, because child process doesn't inherit
threads and goroutines in that case. The library uses a simple trick: it runs its own copy with
a mark - a predefined environment variable. Availability of the variable for the process means
an execution in the child's copy. So that if the mark is not setted - the library executes
parent's operations and runs its own copy with mark, and if the mark is setted - the library
executes child's operations:
import "log"
func main() {
Pre()
context := new(Context)
child, _ := context.Reborn()
if child != nil {
PostParent()
} else {
defer func() {
if err := context.Release(); err != nil {
log.Printf("Unable to release pid-file: %s", err.Error())
}
}()
PostChild()
}
}
Documentation
¶
Overview ¶
Example ¶
signal := flag.String("s", "", "send signal to daemon")
handler := func(sig os.Signal) error {
log.Println("signal:", sig)
if sig == syscall.SIGTERM {
return ErrStop
}
return nil
}
// Define command: command-line arg, system signal and handler
AddCommand(StringFlag(signal, "term"), syscall.SIGTERM, handler)
AddCommand(StringFlag(signal, "reload"), syscall.SIGHUP, handler)
flag.Parse()
// Define daemon context
dmn := &Context{
PidFileName: "/var/run/daemon.pid",
PidFilePerm: 0644,
LogFileName: "/var/log/daemon.log",
LogFilePerm: 0640,
WorkDir: "/",
Umask: 027,
}
// Send commands if needed
if len(ActiveFlags()) > 0 {
d, err := dmn.Search()
if err != nil {
log.Fatalln("Unable send signal to the daemon:", err)
}
SendCommands(d)
return
}
// Process daemon operations - send signal if present flag or daemonize
child, err := dmn.Reborn()
if err != nil {
log.Fatalln(err)
}
if child != nil {
return
}
defer dmn.Release()
// Run main operation
go func() {
for {
time.Sleep(0)
}
}()
err = ServeSignals()
if err != nil {
log.Println("Error:", err)
}
Output:
Index ¶
- Constants
- Variables
- func AddCommand(f Flag, sig os.Signal, handler SignalHandlerFunc)
- func AddFlag(f Flag, sig os.Signal)
- func Flags() map[Flag]os.Signal
- func ReadPidFile(name string) (pid int, err error)
- func SendCommands(p *os.Process) (err error)
- func ServeSignals() (err error)
- func SetSigHandler(handler SignalHandlerFunc, signals ...os.Signal)
- func WasReborn() bool
- type Context
- type Flag
- type LockFile
- type SignalHandlerFunc
Examples ¶
Constants ¶
const ( MARK_NAME = "_GO_DAEMON" MARK_VALUE = "1" )
Mark of daemon process - system environment variable _GO_DAEMON=1
const FILE_PERM = os.FileMode(0640)
Default file permissions for log and pid files.
Variables ¶
var ErrStop = errors.New("stop serve signals")
ErrStop should be returned signal handler function for termination of handling signals.
var ( // ErrWouldBlock indicates on locking pid-file by another process. ErrWouldBlock = errors.New("daemon: Resource temporarily unavailable") )
Functions ¶
func AddCommand ¶
func AddCommand(f Flag, sig os.Signal, handler SignalHandlerFunc)
AddCommand is wrapper on AddFlag and SetSigHandler functions.
func ReadPidFile ¶
ReadPidFile reads process id from file with give name and returns pid. If unable read from a file, returns error.
func SendCommands ¶
SendCommands sends active signals to the given process.
func SetSigHandler ¶
func SetSigHandler(handler SignalHandlerFunc, signals ...os.Signal)
SetSigHandler sets handler for the given signals. SIGTERM has the default handler, he returns ErrStop.
Types ¶
type Context ¶
type Context struct {
// If PidFileName is non-empty, parent process will try to create and lock
// pid file with given name. Child process writes process id to file.
PidFileName string
// Permissions for new pid file.
PidFilePerm os.FileMode
// If LogFileName is non-empty, parent process will create file with given name
// and will link to fd 2 (stderr) for child process.
LogFileName string
// Permissions for new log file.
LogFilePerm os.FileMode
// If WorkDir is non-empty, the child changes into the directory before
// creating the process.
WorkDir string
// If Chroot is non-empty, the child changes root directory
Chroot string
// If Env is non-nil, it gives the environment variables for the
// daemon-process in the form returned by os.Environ.
// If it is nil, the result of os.Environ will be used.
Env []string
// If Args is non-nil, it gives the command-line args for the
// daemon-process. If it is nil, the result of os.Args will be used.
Args []string
// Credential holds user and group identities to be assumed by a daemon-process.
Credential *syscall.Credential
// If Umask is non-zero, the daemon-process call Umask() func with given value.
Umask int
// contains filtered or unexported fields
}
A Context describes daemon context.
func (*Context) Reborn ¶
Reborn runs second copy of current process in the given context. function executes separate parts of code in child process and parent process and provides demonization of child process. It look similar as the fork-daemonization, but goroutine-safe. In success returns *os.Process in parent process and nil in child process. Otherwise returns error.
type Flag ¶
type Flag interface {
IsSet() bool
}
Flag is the interface implemented by an object that has two state: 'set' and 'unset'.
func ActiveFlags ¶
func ActiveFlags() (ret []Flag)
ActiveFlags returns flags that has the state 'set'.
func BoolFlag ¶
BoolFlag returns new object that implements interface Flag and has state 'set' when var with the given address is true.
func StringFlag ¶
StringFlag returns new object that implements interface Flag and has state 'set' when var with the given address equals given value of v.
type LockFile ¶
LockFile wraps *os.File and provide functions for locking of files.
func CreatePidFile ¶
CreatePidFile opens the named file, applies exclusive lock and writes current process id to file.
func NewLockFile ¶
NewLockFile returns a new LockFile with the given File.
func OpenLockFile ¶
OpenLockFile opens the named file with flags os.O_RDWR|os.O_CREATE and specified perm. If successful, function returns LockFile for opened file.
func (*LockFile) Lock ¶
Lock apply exclusive lock on an open file. If file already locked, returns error.
func (*LockFile) ReadPid ¶
ReadPid reads process id from file and returns pid. If unable read from a file, returns error.
type SignalHandlerFunc ¶
SignalHandlerFunc is the interface for signal handler functions.
Source Files
Directories