git.gnu.io has moved to IP address 209.51.188.249 -- please double check where you are logging in.

spawningdaemon.php 7.32 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
<?php
/*
 * StatusNet - the distributed open-source microblogging tool
 * Copyright (C) 2010, StatusNet, Inc.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Base class for daemon that can launch one or more processing threads,
 * respawning them if they exit.
 *
 * This is mainly intended for indefinite workloads such as monitoring
 * a queue or maintaining an IM channel.
 *
 * Child classes should implement the 
 *
 * We can then pass individual items through the QueueHandler subclasses
 * they belong to. We additionally can handle queues for multiple sites.
 *
 * @package QueueHandler
 * @author Brion Vibber <brion@status.net>
 */
abstract class SpawningDaemon extends Daemon
{
    protected $threads=1;

39 40 41 42 43
    const EXIT_OK = 0;
    const EXIT_ERR = 1;
    const EXIT_SHUTDOWN = 100;
    const EXIT_RESTART = 101;

44 45 46 47 48 49 50 51 52 53 54 55 56
    function __construct($id=null, $daemonize=true, $threads=1)
    {
        parent::__construct($daemonize);

        if ($id) {
            $this->set_id($id);
        }
        $this->threads = $threads;
    }

    /**
     * Perform some actual work!
     *
57
     * @return int exit code; use self::EXIT_SHUTDOWN to request not to respawn.
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
     */
    public abstract function runThread();

    /**
     * Spawn one or more background processes and let them start running.
     * Each individual process will execute whatever's in the runThread()
     * method, which should be overridden.
     *
     * Child processes will be automatically respawned when they exit.
     *
     * @todo possibly allow for not respawning on "normal" exits...
     *       though ParallelizingDaemon is probably better for workloads
     *       that have forseeable endpoints.
     */
    function run()
    {
74 75
        $this->initPipes();

76 77 78 79
        $children = array();
        for ($i = 1; $i <= $this->threads; $i++) {
            $pid = pcntl_fork();
            if ($pid < 0) {
mmn's avatar
mmn committed
80
                $this->log(LOG_ERR, "Couldn't fork for thread $i; aborting\n");
81 82 83 84 85 86 87
                exit(1);
            } else if ($pid == 0) {
                $this->initAndRunChild($i);
            } else {
                $this->log(LOG_INFO, "Spawned thread $i as pid $pid");
                $children[$i] = $pid;
            }
88
            sleep(common_config('queue', 'spawndelay'));
89 90 91 92 93 94
        }
        
        $this->log(LOG_INFO, "Waiting for children to complete.");
        while (count($children) > 0) {
            $status = null;
            $pid = pcntl_wait($status);
95
            if ($pid > 0) {
96 97
                $i = array_search($pid, $children);
                if ($i === false) {
98
                    $this->log(LOG_ERR, "Ignoring exit of unrecognized child pid $pid");
99 100
                    continue;
                }
101 102 103 104 105 106 107 108
                if (pcntl_wifexited($status)) {
                    $exitCode = pcntl_wexitstatus($status);
                    $info = "status $exitCode";
                } else if (pcntl_wifsignaled($status)) {
                    $exitCode = self::EXIT_ERR;
                    $signal = pcntl_wtermsig($status);
                    $info = "signal $signal";
                }
109
                unset($children[$i]);
110 111

                if ($this->shouldRespawn($exitCode)) {
112
                    $this->log(LOG_INFO, "Thread $i pid $pid exited with $info; respawing.");
113 114 115

                    $pid = pcntl_fork();
                    if ($pid < 0) {
mmn's avatar
mmn committed
116
                        $this->log(LOG_ERR, "Couldn't fork to respawn thread $i; aborting thread.\n");
117 118 119 120 121 122
                    } else if ($pid == 0) {
                        $this->initAndRunChild($i);
                    } else {
                        $this->log(LOG_INFO, "Respawned thread $i as pid $pid");
                        $children[$i] = $pid;
                    }
123
                    sleep(common_config('queue', 'spawndelay'));
124
                } else {
125
                    $this->log(LOG_INFO, "Thread $i pid $pid exited with status $exitCode; closing out thread.");
126 127 128 129 130 131 132
                }
            }
        }
        $this->log(LOG_INFO, "All child processes complete.");
        return true;
    }

133 134 135 136 137 138 139 140 141 142 143
    /**
     * Create an IPC socket pair which child processes can use to detect
     * if the parent process has been killed.
     */
    function initPipes()
    {
        $sockets = stream_socket_pair(STREAM_PF_UNIX, STREAM_SOCK_STREAM, 0);
        if ($sockets) {
            $this->parentWriter = $sockets[0];
            $this->parentReader = $sockets[1];
        } else {
mmn's avatar
mmn committed
144
            $this->log(LOG_ERR, "Couldn't create inter-process sockets");
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
            exit(1);
        }
    }

    /**
     * Build an IOManager that simply ensures that we have a connection
     * to the parent process open. If it breaks, the child process will
     * die.
     *
     * @return ProcessManager
     */
    public function processManager()
    {
        return new ProcessManager($this->parentReader);
    }

161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
    /**
     * Determine whether to respawn an exited subprocess based on its exit code.
     * Otherwise we'll respawn all exits by default.
     *
     * @param int $exitCode
     * @return boolean true to respawn
     */
    protected function shouldRespawn($exitCode)
    {
        if ($exitCode == self::EXIT_SHUTDOWN) {
            // Thread requested a clean shutdown.
            return false;
        } else {
            // Otherwise we should always respawn!
            return true;
        }
    }

179 180 181 182 183 184
    /**
     * Initialize things for a fresh thread, call runThread(), and
     * exit at completion with appropriate return value.
     */
    protected function initAndRunChild($thread)
    {
185 186
        // Close the writer end of our parent<->children pipe.
        fclose($this->parentWriter);
187 188
        $this->set_id($this->get_id() . "." . $thread);
        $this->resetDb();
189 190
        $exitCode = $this->runThread();
        exit($exitCode);
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
    }

    /**
     * Reconnect to the database for each child process,
     * or they'll get very confused trying to use the
     * same socket.
     */
    protected function resetDb()
    {
        // @fixme do we need to explicitly open the db too
        // or is this implied?
        global $_DB_DATAOBJECT;
        unset($_DB_DATAOBJECT['CONNECTIONS']);

        // Reconnect main memcached, or threads will stomp on
        // each other and corrupt their requests.
207
        $cache = Cache::instance();
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
        if ($cache) {
            $cache->reconnect();
        }

        // Also reconnect memcached for status_network table.
        if (!empty(Status_network::$cache)) {
            Status_network::$cache->close();
            Status_network::$cache = null;
        }
    }

    function log($level, $msg)
    {
        common_log($level, get_class($this) . ' ('. $this->get_id() .'): '.$msg);
    }

    function name()
    {
        return strtolower(get_class($this).'.'.$this->get_id());
    }
}