[Sylar] framework -chapter20- daemon module

Standing on the shoulders of giants

C++ High performance distributed server framework

Rewrite from scratch sylar C++ High performance distributed server framework

summary

• Unbind the process from the terminal , Go to the background and run （ adopt fork The sub process is implemented as the main business process ）.
• sylar Realize the dual process wake-up function , When the parent process acts as a daemon, it will detect whether the child process exits , If the subprocess exits , Will periodically restart the subprocess .

daemon.h

• ProcessInfo
  • The singleton pattern , Store some information about the required process .
• start_daemon
  • External interface .

Other instructions

• The following are the implementation steps of the daemon ：
  1. call daemon(1, 0) Run the current process as a daemon ;
  2. Daemon fork Subprocesses , Run the main business in the sub process ;
  3. Parent process passed waitpid() Check whether the subprocess exits , If the subprocess exits , Then pull up the subprocess again .
• daemon() function

  #include <unistd.h>
  int daemon(int nochdir, int noclose);
  

  • When nochdir by 0 when ,daemon Change the working directory of the process to the root directory root(“/”).
  • When noclose by 0 when ,daemon Will the process of STDIN, STDOUT, STDERR All redirected to /dev/null, That is, no information is output , Otherwise, output . In general , This parameter is set to 0 Of .
  • deamon() Called fork(), If fork success , The parent process is in daemon Kill yourself after the function runs , The subprocess consists of init Process adoption . The subprocess at this time , It's actually a daemon .
  • In general use daemon(1, 0);

Some related codes

/**
 * @filename    daemon.h
 * @brief    Daemon module 
 * @author  L-ge
 * @version 0.1
 * @modify  2022-07-18
 */
#ifndef __SYLAR_DAEMON_H__
#define __SYLAR_DAEMON_H__

#include <unistd.h>
#include <functional>
#include "sylar/singleton.h"

namespace sylar 
{

struct ProcessInfo 
{
    ///  The parent process id
    pid_t parent_id = 0;
    ///  The main process id
    pid_t main_id = 0;
    ///  Parent process start time 
    uint64_t parent_start_time = 0;
    ///  Main process start time 
    uint64_t main_start_time = 0;
    ///  The number of times the main process is restarted 
    uint32_t restart_count = 0;

    std::string toString() const;
};

typedef sylar::Singleton<ProcessInfo> ProcessInfoMgr;

/**
 * @brief  The startup program can choose to use the way of daemon 
 * @param[in] argc  Number of parameters 
 * @param[in] argv  Parameter value array 
 * @param[in] main_cb  Start the function 
 * @param[in] is_daemon  Whether the way of daemon 
 * @return  Return the execution result of the program 
 */
int start_daemon(int argc, char** argv
                 , std::function<int(int argc, char** argv)> main_cb
                 , bool is_daemon);

}

#endif


#include "daemon.h"
#include "sylar/log.h"
#include "sylar/config.h"
#include <time.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

namespace sylar 
{

static sylar::Logger::ptr g_logger = SYLAR_LOG_NAME("system");
static sylar::ConfigVar<uint32_t>::ptr g_daemon_restart_interval
    = sylar::Config::Lookup("daemon.restart_interval", (uint32_t)5, "daemon restart interval");

std::string ProcessInfo::toString() const 
{
    std::stringstream ss;
    ss << "[ProcessInfo parent_id=" << parent_id
       << " main_id=" << main_id
       << " parent_start_time=" << sylar::Time2Str(parent_start_time)
       << " main_start_time=" << sylar::Time2Str(main_start_time)
       << " restart_count=" << restart_count << "]";
    return ss.str();
}

static int real_start(int argc, char** argv,
                     std::function<int(int argc, char** argv)> main_cb)
{
    ProcessInfoMgr::GetInstance()->main_id = getpid();
    ProcessInfoMgr::GetInstance()->main_start_time = time(0);
    return main_cb(argc, argv);
}

static int real_daemon(int argc, char** argv,
                     std::function<int(int argc, char** argv)> main_cb) 
{
    // #include <unistd.h>
    // int daemon(int nochdir, int noclose);
    //  When  nochdir  by 0 when ,daemon  Change the working directory of the process to the root directory root("/").
    //  When noclose by 0 when ,daemon Will the process of STDIN, STDOUT, STDERR All redirected to /dev/null, That is, no information is output , Otherwise, output . In general , This parameter is set to 0 Of .
    // deamon() Called fork(), If fork success , The parent process is in daemon Kill yourself after the function runs , The subprocess consists of init Process adoption . The subprocess at this time , It's actually a daemon .
    daemon(1, 0);   //  Create daemons 
    ProcessInfoMgr::GetInstance()->parent_id = getpid();
    ProcessInfoMgr::GetInstance()->parent_start_time = time(0);
    while(true) 
    {
        pid_t pid = fork();
        if(pid == 0) 
        {
            // Subprocess return 
            ProcessInfoMgr::GetInstance()->main_id = getpid();
            ProcessInfoMgr::GetInstance()->main_start_time  = time(0);
            SYLAR_LOG_INFO(g_logger) << "process start pid=" << getpid();
            return real_start(argc, argv, main_cb);
        } 
        else if(pid < 0) 
        {
            SYLAR_LOG_ERROR(g_logger) << "fork fail return=" << pid
                << " errno=" << errno << " errstr=" << strerror(errno);
            return -1;
        }
        else
        {
            // The parent process returns 
            int status = 0;
            waitpid(pid, &status, 0);
            if(status)
            {
                if(status == 9)
                {
                    SYLAR_LOG_INFO(g_logger) << "killed";
                    break;
                }
                else 
                {
                    SYLAR_LOG_ERROR(g_logger) << "child crash pid=" << pid
                        << " status=" << status;
                }
            } 
            else 
            {
                SYLAR_LOG_INFO(g_logger) << "child finished pid=" << pid;
                break;
            }
            ProcessInfoMgr::GetInstance()->restart_count += 1;
            //  Prevent the resources from being fully recycled after the child process dies ,
            //  At this time and immediately fork There may be problems with child processes .
            sleep(g_daemon_restart_interval->getValue());
        }
    }
    return 0;
}

int start_daemon(int argc, char** argv
                 , std::function<int(int argc, char** argv)> main_cb
                 , bool is_daemon) 
{
    if(!is_daemon) 
    {
        ProcessInfoMgr::GetInstance()->parent_id = getpid();
        ProcessInfoMgr::GetInstance()->parent_start_time = time(0);
        return real_start(argc, argv, main_cb);
    }
    return real_daemon(argc, argv, main_cb);
}

}

Advertising time ： be based on sylar The implementation of the framework is small demo( I hope to give star)

be based on redis Parameter query service