Go语言编程练习#2-守护进程

=Start=

缘由：

之前在第一次学习Go 语言的时候其实整理了一篇文章「Linux下守护进程的Golang语言实现」，但因为后续有其他事情，所以就没有继续下去了。最近刚好在复习Go 语言，所以想着再整理实践一下用Go 语言实现守护进程的功能，就有了这篇文章。

正文：

参考解答：

首先，如果你只是想实现类似于守护进程在后台默默运行的功能的话，可以考虑先用 go build 命令构建出可执行程序，然后（二者选其一即可）：

借助 daemonize 或 upstart 将进程以daemon形式运行；
使用 nohup 结合 & 的方式，再加上 supervisor 管理。

如果你还是希望能用Go 语言实现一个daemon进程，可以参考一下这段代码（在Linux环境下测试验证OK，macOS未通过）：

package main

import (
    "fmt"
    "log"
    "os"
    "runtime"
    "syscall"
    "time"
)

func daemon(nochdir, noclose int) int {
    var ret, ret2 uintptr
    var err syscall.Errno
    darwin := runtime.GOOS == "darwin"
    // 如果当前进程的ppid等于1，则表明已经是一个守护进程了，直接返回即可(already a daemon)
    if syscall.Getppid() == 1 {
        return 0
    }
    // 通过 syscall 包调用 fork 派生子进程
    ret, ret2, err = syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0)
    if err != 0 {
        log.Println("syscall.RawSyscall")
        return -1
    }
    // ret2 表示子进程收到的 fork 返回（暂不完全确定？），正常派生情况下 ret2 应该等于0
    if ret2 < 0 {
        os.Exit(-1)
    }
    // 针对 darwin 系统的错误处理（没啥用，在macOS上还是跑不了）
    if darwin && ret2 == 1 {
        log.Printf("OS: %v, ret: %v, ret2: %v\n", darwin, ret, ret2)
        // ret = 0
    }
    // ret 表示fork成功执行后产生的子进程的pid（由父进程接收）
    if ret > 0 {
        os.Exit(0) // 退出当前的父进程
    }

    // create a new SID for the child process
    s_ret, s_errno := syscall.Setsid()
    if s_errno != nil {
        log.Printf("Error: syscall.Setsid errno: %d", s_errno)
    }
    if s_ret < 0 {
        log.Println("syscall.Setsid")
        return -1
    }

    // 调用 fork 派生子进程
    ret, ret2, err = syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0)
    if err != 0 {
        log.Println("syscall.RawSyscall")
        return -1
    }
    // ret2 表示子进程收到的 fork 返回，正常派生情况下 ret2 应该等于0
    if ret2 < 0 {
        os.Exit(-1)
    }
    // ret 表示fork成功执行后产生的子进程的pid（由父进程接收）
    if ret > 0 {
        os.Exit(0) // 退出当前的父进程
    }

    if nochdir == 0 {
        os.Chdir("/")
    }
    /* Change the file mode mask */
    _ = syscall.Umask(0)

    if noclose == 0 {
        f, e := os.OpenFile("/dev/null", os.O_RDWR, 0)
        if e == nil {
            fd := f.Fd()
            syscall.Dup2(int(fd), int(os.Stdin.Fd()))
            syscall.Dup2(int(fd), int(os.Stdout.Fd()))
            syscall.Dup2(int(fd), int(os.Stderr.Fd()))
        }
    }
    return 0
}

func main() {
    daemon(0, 1)
    for {
        fmt.Println("hello")
        time.Sleep(2 * time.Second)
    }
}

如果你用C或是其它编程语言开发过daemon进程的话你就会发现，实现daemon的主要逻辑步骤在各个语言中都是一样的：

1、创建子进程，父进程退出 fork()
2、子进程创建新会话 setsid()
3、再次创建子进程结束当前进程 fork() #通过使进程不再是会话首进程来禁止进程重新打开控制终端
4、改变当前工作目录 chdir()
5、重设文件权限掩码 umask()
6、关闭无关文件描述符 close()

只不过在Go 语言中，对我来说，现在实现起来最大的问题在于——不论是Syscall.RawSyscall()还是Syscall.Syscall()它们的资料都太少了，参数、返回值的功能和作用都只能靠猜……

一个进程是否是守护进程的验证方法（判断是否符合如下要求）：

守护进程不应该有控制终端，所以(TTY = ?)
守护进程的父进程ID为1，即init进程
其中 PID != SID 表明该进程不是会话的leader进程，因为第二个fork()的作用
因为 PID != SID 所以该守护进程无法重新打开/控制一个TTY

参考链接：

=END=

5 11 月, 2018

Docker

KnowledgeBase, Programing, Tools

daemon, golang, syscall