Source for file daemon.php

Documentation is available at daemon.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Platform
  4.  * @subpackage  Application
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. jimport('joomla.filesystem.folder');
  13.  
  14. /**
  15.  * Class to turn JCli applications into daemons.  It requires CLI and PCNTL support built into PHP.
  16.  *
  17.  * @package     Joomla.Platform
  18.  * @subpackage  Application
  19.  * @see         http://www.php.net/manual/en/book.pcntl.php
  20.  * @see         http://php.net/manual/en/features.commandline.php
  21.  * @since       11.1
  22.  */
  23. class JApplicationDaemon extends JApplicationCli
  24. {
  25.     /**
  26.      * @var    array  The available POSIX signals to be caught by default.
  27.      * @see    http://php.net/manual/pcntl.constants.php
  28.      * @since  11.1
  29.      */
  30.     protected static $signals = array(
  31.         'SIGHUP',
  32.         'SIGINT',
  33.         'SIGQUIT',
  34.         'SIGILL',
  35.         'SIGTRAP',
  36.         'SIGABRT',
  37.         'SIGIOT',
  38.         'SIGBUS',
  39.         'SIGFPE',
  40.         'SIGUSR1',
  41.         'SIGSEGV',
  42.         'SIGUSR2',
  43.         'SIGPIPE',
  44.         'SIGALRM',
  45.         'SIGTERM',
  46.         'SIGSTKFLT',
  47.         'SIGCLD',
  48.         'SIGCHLD',
  49.         'SIGCONT',
  50.         'SIGTSTP',
  51.         'SIGTTIN',
  52.         'SIGTTOU',
  53.         'SIGURG',
  54.         'SIGXCPU',
  55.         'SIGXFSZ',
  56.         'SIGVTALRM',
  57.         'SIGPROF',
  58.         'SIGWINCH',
  59.         'SIGPOLL',
  60.         'SIGIO',
  61.         'SIGPWR',
  62.         'SIGSYS',
  63.         'SIGBABY',
  64.         'SIG_BLOCK',
  65.         'SIG_UNBLOCK',
  66.         'SIG_SETMASK'
  67.     );
  68.  
  69.     /**
  70.      * @var    boolean  True if the daemon is in the process of exiting.
  71.      * @since  11.1
  72.      */
  73.     protected $exiting = false;
  74.  
  75.     /**
  76.      * @var    integer  The parent process id.
  77.      * @since  12.1
  78.      */
  79.     protected $parentId = 0;
  80.  
  81.     /**
  82.      * @var    integer  The process id of the daemon.
  83.      * @since  11.1
  84.      */
  85.     protected $processId = 0;
  86.  
  87.     /**
  88.      * @var    boolean  True if the daemon is currently running.
  89.      * @since  11.1
  90.      */
  91.     protected $running = false;
  92.  
  93.     /**
  94.      * Class constructor.
  95.      *
  96.      * @param   mixed  $input       An optional argument to provide dependency injection for the application's
  97.      *                               input object.  If the argument is a JInputCli object that object will become
  98.      *                               the application's input object, otherwise a default input object is created.
  99.      * @param   mixed  $config      An optional argument to provide dependency injection for the application's
  100.      *                               config object.  If the argument is a JRegistry object that object will become
  101.      *                               the application's config object, otherwise a default config object is created.
  102.      * @param   mixed  $dispatcher  An optional argument to provide dependency injection for the application's
  103.      *                               event dispatcher.  If the argument is a JEventDispatcher object that object will become
  104.      *                               the application's event dispatcher, if it is null then the default event dispatcher
  105.      *                               will be created based on the application's loadDispatcher() method.
  106.      *
  107.      * @since   11.1
  108.      * @throws  RuntimeException
  109.      */
  110.     public function __construct(JInputCli $input = null, JRegistry $config = null, JEventDispatcher $dispatcher = null)
  111.     {
  112.         // Verify that the process control extension for PHP is available.
  113.         // @codeCoverageIgnoreStart
  114.         if (!defined('SIGHUP'))
  115.         {
  116.             JLog::add('The PCNTL extension for PHP is not available.', JLog::ERROR);
  117.             throw new RuntimeException('The PCNTL extension for PHP is not available.');
  118.         }
  119.  
  120.         // Verify that POSIX support for PHP is available.
  121.         if (!function_exists('posix_getpid'))
  122.         {
  123.             JLog::add('The POSIX extension for PHP is not available.', JLog::ERROR);
  124.             throw new RuntimeException('The POSIX extension for PHP is not available.');
  125.         }
  126.         // @codeCoverageIgnoreEnd
  127.  
  128.         // Call the parent constructor.
  129.         parent::__construct($input, $config, $dispatcher);
  130.  
  131.         // Set some system limits.
  132.         @set_time_limit($this->config->get('max_execution_time', 0));
  133.  
  134.         if ($this->config->get('max_memory_limit') !== null)
  135.         {
  136.             ini_set('memory_limit', $this->config->get('max_memory_limit', '256M'));
  137.         }
  138.  
  139.         // Flush content immediately.
  140.         ob_implicit_flush();
  141.     }
  142.  
  143.     /**
  144.      * Method to handle POSIX signals.
  145.      *
  146.      * @param   integer  $signal  The received POSIX signal.
  147.      *
  148.      * @return  void 
  149.      *
  150.      * @since   11.1
  151.      * @see     pcntl_signal()
  152.      * @throws  RuntimeException
  153.      */
  154.     public static function signal($signal)
  155.     {
  156.         // Log all signals sent to the daemon.
  157.         JLog::add('Received signal: ' . $signal, JLog::DEBUG);
  158.  
  159.         // Let's make sure we have an application instance.
  160.         if (!is_subclass_of(static::$instance, 'JApplicationDaemon'))
  161.         {
  162.             JLog::add('Cannot find the application instance.', JLog::EMERGENCY);
  163.             throw new RuntimeException('Cannot find the application instance.');
  164.         }
  165.  
  166.         // Fire the onReceiveSignal event.
  167.         static::$instance->triggerEvent('onReceiveSignal', array($signal));
  168.  
  169.         switch ($signal)
  170.         {
  171.             case SIGINT:
  172.             case SIGTERM:
  173.                 // Handle shutdown tasks
  174.                 if (static::$instance->running && static::$instance->isActive())
  175.                 {
  176.                     static::$instance->shutdown();
  177.                 }
  178.                 else
  179.                 {
  180.                     static::$instance->close();
  181.                 }
  182.                 break;
  183.             case SIGHUP:
  184.                 // Handle restart tasks
  185.                 if (static::$instance->running && static::$instance->isActive())
  186.                 {
  187.                     static::$instance->shutdown(true);
  188.                 }
  189.                 else
  190.                 {
  191.                     static::$instance->close();
  192.                 }
  193.                 break;
  194.             case SIGCHLD:
  195.                 // A child process has died
  196.                 while (static::$instance->pcntlWait($signal, WNOHANG || WUNTRACED) > 0)
  197.                 {
  198.                     usleep(1000);
  199.                 }
  200.                 break;
  201.             case SIGCLD:
  202.                 while (static::$instance->pcntlWait($signal, WNOHANG) > 0)
  203.                 {
  204.                     $signal = static::$instance->pcntlChildExitStatus($signal);
  205.                 }
  206.                 break;
  207.             default:
  208.                 break;
  209.         }
  210.     }
  211.  
  212.     /**
  213.      * Check to see if the daemon is active.  This does not assume that $this daemon is active, but
  214.      * only if an instance of the application is active as a daemon.
  215.      *
  216.      * @return  boolean  True if daemon is active.
  217.      *
  218.      * @since   11.1
  219.      */
  220.     public function isActive()
  221.     {
  222.         // Get the process id file location for the application.
  223.         $pidFile = $this->config->get('application_pid_file');
  224.  
  225.         // If the process id file doesn't exist then the daemon is obviously not running.
  226.         if (!is_file($pidFile))
  227.         {
  228.             return false;
  229.         }
  230.  
  231.         // Read the contents of the process id file as an integer.
  232.         $fp = fopen($pidFile, 'r');
  233.         $pid = fread($fp, filesize($pidFile));
  234.         $pid = (int) $pid;
  235.         fclose($fp);
  236.  
  237.         // Check to make sure that the process id exists as a positive integer.
  238.         if (!$pid)
  239.         {
  240.             return false;
  241.         }
  242.  
  243.         // Check to make sure the process is active by pinging it and ensure it responds.
  244.         if (!posix_kill($pid, 0))
  245.         {
  246.             // No response so remove the process id file and log the situation.
  247.             @ unlink($pidFile);
  248.             JLog::add('The process found based on PID file was unresponsive.', JLog::WARNING);
  249.  
  250.             return false;
  251.         }
  252.  
  253.         return true;
  254.     }
  255.  
  256.     /**
  257.      * Load an object or array into the application configuration object.
  258.      *
  259.      * @param   mixed  $data  Either an array or object to be loaded into the configuration object.
  260.      *
  261.      * @return  JCli  Instance of $this to allow chaining.
  262.      *
  263.      * @since   11.1
  264.      */
  265.     public function loadConfiguration($data)
  266.     {
  267.         // Execute the parent load method.
  268.         parent::loadConfiguration($data);
  269.  
  270.         /*
  271.          * Setup some application metadata options.  This is useful if we ever want to write out startup scripts
  272.          * or just have some sort of information available to share about things.
  273.          */
  274.  
  275.         // The application author name.  This string is used in generating startup scripts and has
  276.         // a maximum of 50 characters.
  277.         $tmp = (string) $this->config->get('author_name', 'Joomla Platform');
  278.         $this->config->set('author_name', (strlen($tmp) > 50) ? substr($tmp, 0, 50) : $tmp);
  279.  
  280.         // The application author email.  This string is used in generating startup scripts.
  281.         $tmp = (string) $this->config->get('author_email', 'admin@joomla.org');
  282.         $this->config->set('author_email', filter_var($tmp, FILTER_VALIDATE_EMAIL));
  283.  
  284.         // The application name.  This string is used in generating startup scripts.
  285.         $tmp = (string) $this->config->get('application_name', 'JApplicationDaemon');
  286.         $this->config->set('application_name', (string) preg_replace('/[^A-Z0-9_-]/i', '', $tmp));
  287.  
  288.         // The application description.  This string is used in generating startup scripts.
  289.         $tmp = (string) $this->config->get('application_description', 'A generic Joomla Platform application.');
  290.         $this->config->set('application_description', filter_var($tmp, FILTER_SANITIZE_STRING));
  291.  
  292.         /*
  293.          * Setup the application path options.  This defines the default executable name, executable directory,
  294.          * and also the path to the daemon process id file.
  295.          */
  296.  
  297.         // The application executable daemon.  This string is used in generating startup scripts.
  298.         $tmp = (string) $this->config->get('application_executable', basename($this->input->executable));
  299.         $this->config->set('application_executable', $tmp);
  300.  
  301.         // The home directory of the daemon.
  302.         $tmp = (string) $this->config->get('application_directory', dirname($this->input->executable));
  303.         $this->config->set('application_directory', $tmp);
  304.  
  305.         // The pid file location.  This defaults to a path inside the /tmp directory.
  306.         $name = $this->config->get('application_name');
  307.         $tmp = (string) $this->config->get('application_pid_file', strtolower('/tmp/' . $name . '/' . $name . '.pid'));
  308.         $this->config->set('application_pid_file', $tmp);
  309.  
  310.         /*
  311.          * Setup the application identity options.  It is important to remember if the default of 0 is set for
  312.          * either UID or GID then changing that setting will not be attempted as there is no real way to "change"
  313.          * the identity of a process from some user to root.
  314.          */
  315.  
  316.         // The user id under which to run the daemon.
  317.         $tmp = (int) $this->config->get('application_uid', 0);
  318.         $options = array('options' => array('min_range' => 0, 'max_range' => 65000));
  319.         $this->config->set('application_uid', filter_var($tmp, FILTER_VALIDATE_INT, $options));
  320.  
  321.         // The group id under which to run the daemon.
  322.         $tmp = (int) $this->config->get('application_gid', 0);
  323.         $options = array('options' => array('min_range' => 0, 'max_range' => 65000));
  324.         $this->config->set('application_gid', filter_var($tmp, FILTER_VALIDATE_INT, $options));
  325.  
  326.         // Option to kill the daemon if it cannot switch to the chosen identity.
  327.         $tmp = (bool) $this->config->get('application_require_identity', 1);
  328.         $this->config->set('application_require_identity', $tmp);
  329.  
  330.         /*
  331.          * Setup the application runtime options.  By default our execution time limit is infinite obviously
  332.          * because a daemon should be constantly running unless told otherwise.  The default limit for memory
  333.          * usage is 128M, which admittedly is a little high, but remember it is a "limit" and PHP's memory
  334.          * management leaves a bit to be desired :-)
  335.          */
  336.  
  337.         // The maximum execution time of the application in seconds.  Zero is infinite.
  338.         $tmp = $this->config->get('max_execution_time');
  339.  
  340.         if ($tmp !== null)
  341.         {
  342.             $this->config->set('max_execution_time', (int) $tmp);
  343.         }
  344.  
  345.         // The maximum amount of memory the application can use.
  346.         $tmp = $this->config->get('max_memory_limit', '256M');
  347.  
  348.         if ($tmp !== null)
  349.         {
  350.             $this->config->set('max_memory_limit', (string) $tmp);
  351.         }
  352.  
  353.         return $this;
  354.     }
  355.  
  356.     /**
  357.      * Execute the daemon.
  358.      *
  359.      * @return  void 
  360.      *
  361.      * @since   11.1
  362.      */
  363.     public function execute()
  364.     {
  365.         // Trigger the onBeforeExecute event.
  366.         $this->triggerEvent('onBeforeExecute');
  367.  
  368.         // Enable basic garbage collection.
  369.         gc_enable();
  370.  
  371.         JLog::add('Starting ' . $this->name, JLog::INFO);
  372.  
  373.         // Set off the process for becoming a daemon.
  374.         if ($this->daemonize())
  375.         {
  376.             // Declare ticks to start signal monitoring. When you declare ticks, PCNTL will monitor
  377.             // incoming signals after each tick and call the relevant signal handler automatically.
  378.             declare (ticks = 1);
  379.  
  380.             // Start the main execution loop.
  381.             while (true)
  382.             {
  383.                 // Perform basic garbage collection.
  384.                 $this->gc();
  385.  
  386.                 // Don't completely overload the CPU.
  387.                 usleep(1000);
  388.  
  389.                 // Execute the main application logic.
  390.                 $this->doExecute();
  391.             }
  392.         }
  393.         // We were not able to daemonize the application so log the failure and die gracefully.
  394.         else
  395.         {
  396.             JLog::add('Starting ' . $this->name . ' failed', JLog::INFO);
  397.         }
  398.  
  399.         // Trigger the onAfterExecute event.
  400.         $this->triggerEvent('onAfterExecute');
  401.     }
  402.  
  403.     /**
  404.      * Restart daemon process.
  405.      *
  406.      * @return  void 
  407.      *
  408.      * @codeCoverageIgnore
  409.      * @since   11.1
  410.      */
  411.     public function restart()
  412.     {
  413.         JLog::add('Stopping ' . $this->name, JLog::INFO);
  414.         $this->shutdown(true);
  415.     }
  416.  
  417.     /**
  418.      * Stop daemon process.
  419.      *
  420.      * @return  void 
  421.      *
  422.      * @codeCoverageIgnore
  423.      * @since   11.1
  424.      */
  425.     public function stop()
  426.     {
  427.         JLog::add('Stopping ' . $this->name, JLog::INFO);
  428.         $this->shutdown();
  429.     }
  430.  
  431.     /**
  432.      * Method to change the identity of the daemon process and resources.
  433.      *
  434.      * @return  boolean  True if identity successfully changed
  435.      *
  436.      * @since   11.1
  437.      * @see     posix_setuid()
  438.      */
  439.     protected function changeIdentity()
  440.     {
  441.         // Get the group and user ids to set for the daemon.
  442.         $uid = (int) $this->config->get('application_uid', 0);
  443.         $gid = (int) $this->config->get('application_gid', 0);
  444.  
  445.         // Get the application process id file path.
  446.         $file = $this->config->get('application_pid_file');
  447.  
  448.         // Change the user id for the process id file if necessary.
  449.         if ($uid && (fileowner($file) != $uid) && (!@ chown($file, $uid)))
  450.         {
  451.             JLog::add('Unable to change user ownership of the process id file.', JLog::ERROR);
  452.  
  453.             return false;
  454.         }
  455.  
  456.         // Change the group id for the process id file if necessary.
  457.         if ($gid && (filegroup($file) != $gid) && (!@ chgrp($file, $gid)))
  458.         {
  459.             JLog::add('Unable to change group ownership of the process id file.', JLog::ERROR);
  460.  
  461.             return false;
  462.         }
  463.  
  464.         // Set the correct home directory for the process.
  465.         if ($uid && ($info = posix_getpwuid($uid)) && is_dir($info['dir']))
  466.         {
  467.             system('export HOME="' . $info['dir'] . '"');
  468.         }
  469.  
  470.         // Change the user id for the process necessary.
  471.         if ($uid && (posix_getuid($file) != $uid) && (!@ posix_setuid($uid)))
  472.         {
  473.             JLog::add('Unable to change user ownership of the proccess.', JLog::ERROR);
  474.  
  475.             return false;
  476.         }
  477.  
  478.         // Change the group id for the process necessary.
  479.         if ($gid && (posix_getgid($file) != $gid) && (!@ posix_setgid($gid)))
  480.         {
  481.             JLog::add('Unable to change group ownership of the proccess.', JLog::ERROR);
  482.  
  483.             return false;
  484.         }
  485.  
  486.         // Get the user and group information based on uid and gid.
  487.         $user = posix_getpwuid($uid);
  488.         $group = posix_getgrgid($gid);
  489.  
  490.         JLog::add('Changed daemon identity to ' . $user['name'] . ':' . $group['name'], JLog::INFO);
  491.  
  492.         return true;
  493.     }
  494.  
  495.     /**
  496.      * Method to put the application into the background.
  497.      *
  498.      * @return  boolean 
  499.      *
  500.      * @since   11.1
  501.      * @throws  RuntimeException
  502.      */
  503.     protected function daemonize()
  504.     {
  505.         // Is there already an active daemon running?
  506.         if ($this->isActive())
  507.         {
  508.             JLog::add($this->name . ' daemon is still running. Exiting the application.', JLog::EMERGENCY);
  509.  
  510.             return false;
  511.         }
  512.  
  513.         // Reset Process Information
  514.         $this->safeMode = !!@ ini_get('safe_mode');
  515.         $this->processId = 0;
  516.         $this->running = false;
  517.  
  518.         // Detach process!
  519.         try
  520.         {
  521.             // Check if we should run in the foreground.
  522.             if (!$this->input->get('f'))
  523.             {
  524.                 // Detach from the terminal.
  525.                 $this->detach();
  526.             }
  527.             else
  528.             {
  529.                 // Setup running values.
  530.                 $this->exiting = false;
  531.                 $this->running = true;
  532.  
  533.                 // Set the process id.
  534.                 $this->processId = (int) posix_getpid();
  535.                 $this->parentId = $this->processId;
  536.             }
  537.         }
  538.         catch (RuntimeException $e)
  539.         {
  540.             JLog::add('Unable to fork.', JLog::EMERGENCY);
  541.  
  542.             return false;
  543.         }
  544.  
  545.         // Verify the process id is valid.
  546.         if ($this->processId < 1)
  547.         {
  548.             JLog::add('The process id is invalid; the fork failed.', JLog::EMERGENCY);
  549.  
  550.             return false;
  551.         }
  552.  
  553.         // Clear the umask.
  554.         @ umask(0);
  555.  
  556.         // Write out the process id file for concurrency management.
  557.         if (!$this->writeProcessIdFile())
  558.         {
  559.             JLog::add('Unable to write the pid file at: ' . $this->config->get('application_pid_file'), JLog::EMERGENCY);
  560.  
  561.             return false;
  562.         }
  563.  
  564.         // Attempt to change the identity of user running the process.
  565.         if (!$this->changeIdentity())
  566.         {
  567.  
  568.             // If the identity change was required then we need to return false.
  569.             if ($this->config->get('application_require_identity'))
  570.             {
  571.                 JLog::add('Unable to change process owner.', JLog::CRITICAL);
  572.  
  573.                 return false;
  574.             }
  575.             else
  576.             {
  577.                 JLog::add('Unable to change process owner.', JLog::WARNING);
  578.             }
  579.         }
  580.  
  581.         // Setup the signal handlers for the daemon.
  582.         if (!$this->setupSignalHandlers())
  583.         {
  584.             return false;
  585.         }
  586.  
  587.         // Change the current working directory to the application working directory.
  588.         @ chdir($this->config->get('application_directory'));
  589.  
  590.         return true;
  591.     }
  592.  
  593.     /**
  594.      * This is truly where the magic happens.  This is where we fork the process and kill the parent
  595.      * process, which is essentially what turns the application into a daemon.
  596.      *
  597.      * @return  void 
  598.      *
  599.      * @since   12.1
  600.      * @throws  RuntimeException
  601.      */
  602.     protected function detach()
  603.     {
  604.         JLog::add('Detaching the ' . $this->name . ' daemon.', JLog::DEBUG);
  605.  
  606.         // Attempt to fork the process.
  607.         $pid = $this->fork();
  608.  
  609.         // If the pid is positive then we successfully forked, and can close this application.
  610.         if ($pid)
  611.         {
  612.             // Add the log entry for debugging purposes and exit gracefully.
  613.             JLog::add('Ending ' . $this->name . ' parent process', JLog::DEBUG);
  614.             $this->close();
  615.         }
  616.         // We are in the forked child process.
  617.         else
  618.         {
  619.             // Setup some protected values.
  620.             $this->exiting = false;
  621.             $this->running = true;
  622.  
  623.             // Set the parent to self.
  624.             $this->parentId = $this->processId;
  625.         }
  626.     }
  627.  
  628.     /**
  629.      * Method to fork the process.
  630.      *
  631.      * @return  integer  The child process id to the parent process, zero to the child process.
  632.      *
  633.      * @since   11.1
  634.      * @throws  RuntimeException
  635.      */
  636.     protected function fork()
  637.     {
  638.         // Attempt to fork the process.
  639.         $pid = $this->pcntlFork();
  640.  
  641.         // If the fork failed, throw an exception.
  642.         if ($pid === -1)
  643.         {
  644.             throw new RuntimeException('The process could not be forked.');
  645.         }
  646.         // Update the process id for the child.
  647.         elseif ($pid === 0)
  648.         {
  649.             $this->processId = (int) posix_getpid();
  650.         }
  651.         // Log the fork in the parent.
  652.         else
  653.         {
  654.             // Log the fork.
  655.             JLog::add('Process forked ' . $pid, JLog::DEBUG);
  656.         }
  657.  
  658.         // Trigger the onFork event.
  659.         $this->postFork();
  660.  
  661.         return $pid;
  662.     }
  663.  
  664.     /**
  665.      * Method to perform basic garbage collection and memory management in the sense of clearing the
  666.      * stat cache.  We will probably call this method pretty regularly in our main loop.
  667.      *
  668.      * @return  void 
  669.      *
  670.      * @codeCoverageIgnore
  671.      * @since   11.1
  672.      */
  673.     protected function gc()
  674.     {
  675.         // Perform generic garbage collection.
  676.         gc_collect_cycles();
  677.  
  678.         // Clear the stat cache so it doesn't blow up memory.
  679.         clearstatcache();
  680.     }
  681.  
  682.     /**
  683.      * Method to attach the JApplicationDaemon signal handler to the known signals.  Applications
  684.      * can override these handlers by using the pcntl_signal() function and attaching a different
  685.      * callback method.
  686.      *
  687.      * @return  boolean 
  688.      *
  689.      * @since   11.1
  690.      * @see     pcntl_signal()
  691.      */
  692.     protected function setupSignalHandlers()
  693.     {
  694.         // We add the error suppression for the loop because on some platforms some constants are not defined.
  695.         foreach (self::$signals as $signal)
  696.         {
  697.             // Ignore signals that are not defined.
  698.             if (!defined($signal) || !is_int(constant($signal)) || (constant($signal) === 0))
  699.             {
  700.                 // Define the signal to avoid notices.
  701.                 JLog::add('Signal "' . $signal . '" not defined. Defining it as null.', JLog::DEBUG);
  702.                 define($signal, null);
  703.  
  704.                 // Don't listen for signal.
  705.                 continue;
  706.             }
  707.  
  708.             // Attach the signal handler for the signal.
  709.             if (!$this->pcntlSignal(constant($signal), array('JApplicationDaemon', 'signal')))
  710.             {
  711.                 JLog::add(sprintf('Unable to reroute signal handler: %s', $signal), JLog::EMERGENCY);
  712.  
  713.                 return false;
  714.             }
  715.         }
  716.  
  717.         return true;
  718.     }
  719.  
  720.     /**
  721.      * Method to shut down the daemon and optionally restart it.
  722.      *
  723.      * @param   boolean  $restart  True to restart the daemon on exit.
  724.      *
  725.      * @return  void 
  726.      *
  727.      * @since   11.1
  728.      */
  729.     protected function shutdown($restart = false)
  730.     {
  731.         // If we are already exiting, chill.
  732.         if ($this->exiting)
  733.         {
  734.             return;
  735.         }
  736.         // If not, now we are.
  737.         else
  738.         {
  739.             $this->exiting = true;
  740.         }
  741.  
  742.         // If we aren't already daemonized then just kill the application.
  743.         if (!$this->running && !$this->isActive())
  744.         {
  745.             JLog::add('Process was not daemonized yet, just halting current process', JLog::INFO);
  746.             $this->close();
  747.         }
  748.  
  749.         // Only read the pid for the parent file.
  750.         if ($this->parentId == $this->processId)
  751.         {
  752.             // Read the contents of the process id file as an integer.
  753.             $fp = fopen($this->config->get('application_pid_file'), 'r');
  754.             $pid = fread($fp, filesize($this->config->get('application_pid_file')));
  755.             $pid = (int) $pid;
  756.             fclose($fp);
  757.  
  758.             // Remove the process id file.
  759.             @ unlink($this->config->get('application_pid_file'));
  760.  
  761.             // If we are supposed to restart the daemon we need to execute the same command.
  762.             if ($restart)
  763.             {
  764.                 $this->close(exec(implode(' ', $GLOBALS['argv']) . ' > /dev/null &'));
  765.             }
  766.             // If we are not supposed to restart the daemon let's just kill -9.
  767.             else
  768.             {
  769.                 passthru('kill -9 ' . $pid);
  770.                 $this->close();
  771.             }
  772.         }
  773.     }
  774.  
  775.     /**
  776.      * Method to write the process id file out to disk.
  777.      *
  778.      * @return  boolean 
  779.      *
  780.      * @since   11.1
  781.      */
  782.     protected function writeProcessIdFile()
  783.     {
  784.         // Verify the process id is valid.
  785.         if ($this->processId < 1)
  786.         {
  787.             JLog::add('The process id is invalid.', JLog::EMERGENCY);
  788.  
  789.             return false;
  790.         }
  791.  
  792.         // Get the application process id file path.
  793.         $file = $this->config->get('application_pid_file');
  794.  
  795.         if (empty($file))
  796.         {
  797.             JLog::add('The process id file path is empty.', JLog::ERROR);
  798.  
  799.             return false;
  800.         }
  801.  
  802.         // Make sure that the folder where we are writing the process id file exists.
  803.         $folder = dirname($file);
  804.  
  805.         if (!is_dir($folder) && !JFolder::create($folder))
  806.         {
  807.             JLog::add('Unable to create directory: ' . $folder, JLog::ERROR);
  808.  
  809.             return false;
  810.         }
  811.  
  812.         // Write the process id file out to disk.
  813.         if (!file_put_contents($file, $this->processId))
  814.         {
  815.             JLog::add('Unable to write proccess id file: ' . $file, JLog::ERROR);
  816.  
  817.             return false;
  818.         }
  819.  
  820.         // Make sure the permissions for the proccess id file are accurate.
  821.         if (!chmod($file, 0644))
  822.         {
  823.             JLog::add('Unable to adjust permissions for the proccess id file: ' . $file, JLog::ERROR);
  824.  
  825.             return false;
  826.         }
  827.  
  828.         return true;
  829.     }
  830.  
  831.     /**
  832.      * Method to handle post-fork triggering of the onFork event.
  833.      *
  834.      * @return  void 
  835.      *
  836.      * @since   12.1
  837.      */
  838.     protected function postFork()
  839.     {
  840.         // Trigger the onFork event.
  841.         $this->triggerEvent('onFork');
  842.     }
  843.  
  844.     /**
  845.      * Method to return the exit code of a terminated child process.
  846.      *
  847.      * @param   integer  $status  The status parameter is the status parameter supplied to a successful call to pcntl_waitpid().
  848.      *
  849.      * @return  integer  The child process exit code.
  850.      *
  851.      * @codeCoverageIgnore
  852.      * @see     pcntl_wexitstatus()
  853.      * @since   11.3
  854.      */
  855.     protected function pcntlChildExitStatus($status)
  856.     {
  857.         return pcntl_wexitstatus($status);
  858.     }
  859.  
  860.     /**
  861.      * Method to return the exit code of a terminated child process.
  862.      *
  863.      * @return  integer  On success, the PID of the child process is returned in the parent's thread
  864.      *                    of execution, and a 0 is returned in the child's thread of execution. On
  865.      *                    failure, a -1 will be returned in the parent's context, no child process
  866.      *                    will be created, and a PHP error is raised.
  867.      *
  868.      * @codeCoverageIgnore
  869.      * @see     pcntl_fork()
  870.      * @since   11.3
  871.      */
  872.     protected function pcntlFork()
  873.     {
  874.         return pcntl_fork();
  875.     }
  876.  
  877.     /**
  878.      * Method to install a signal handler.
  879.      *
  880.      * @param   integer   $signal   The signal number.
  881.      * @param   callable  $handler  The signal handler which may be the name of a user created function,
  882.      *                               or method, or either of the two global constants SIG_IGN or SIG_DFL.
  883.      * @param   boolean   $restart  Specifies whether system call restarting should be used when this
  884.      *                               signal arrives.
  885.      *
  886.      * @return  boolean  True on success.
  887.      *
  888.      * @codeCoverageIgnore
  889.      * @see     pcntl_signal()
  890.      * @since   11.3
  891.      */
  892.     protected function pcntlSignal($signal , $handler, $restart = true)
  893.     {
  894.         return pcntl_signal($signal, $handler, $restart);
  895.     }
  896.  
  897.     /**
  898.      * Method to wait on or return the status of a forked child.
  899.      *
  900.      * @param   integer  &$status  Status information.
  901.      * @param   integer  $options  If wait3 is available on your system (mostly BSD-style systems),
  902.      *                              you can provide the optional options parameter.
  903.      *
  904.      * @return  integer  The process ID of the child which exited, -1 on error or zero if WNOHANG
  905.      *                    was provided as an option (on wait3-available systems) and no child was available.
  906.      *
  907.      * @codeCoverageIgnore
  908.      * @see     pcntl_wait()
  909.      * @since   11.3
  910.      */
  911.     protected function pcntlWait(&$status, $options = 0)
  912.     {
  913.         return pcntl_wait($status, $options);
  914.     }
  915. }

Documentation generated on Tue, 19 Nov 2013 14:57:44 +0100 by phpDocumentor 1.4.3