Demon UNIXowy w php, Czyli słow kilka o egzorcyzmach ;D Opcje

[Seth]

Pod wplywem tematu , 1);
define('DLOG_NOTICE', 2);
define('DLOG_WARNING', 4);
define('DLOG_ERROR', 8);
define('DLOG_CRITICAL', 16);

/**
 * Daemon base class
 *
 * Requirements:
 * Unix like operating system
 * php 4 >= 4.3.0 or php 5
 * php compiled with:
 * --enable-sigchild
 * --enable-pcntl
 *
 * @package binarychoice.system.unix
 * @author Michal 'Seth' Golebiowski <seth at binarychoice dot pl>
 * @copyright Copyright 2005 Seth
 * @since 1.0.3
 */
class Daemon
{
 /**#@+
* @access public
*/
 /**
* User ID
* 
* @var int
* @since 1.0
*/
 var $userID = 99;

 /**
* Group ID
* 
* @var integer
* @since 1.0
*/
 var $groupID = 99;
 
 /**
* Terminate daemon when set identity failure ?
* 
* @var bool
* @since 1.0.3
*/
 var $requireSetIdentity = false;

 /**
* Path to PID file
* 
* @var string
* @since 1.0.1
*/
 var $pidFileLocation = '/tmp/daemon.pid';

 /**
* Home path
* 
* @var string
* @since 1.0
*/
 var $homePath = '/';
 /**#@-*/


 /**#@+
* @access protected
*/
 /**
* Current process ID
* 
* @var int
* @since 1.0
*/
 var $_pid = 0;

 /**
* Is this process a children
* 
* @var boolean
* @since 1.0
*/
 var $_isChildren = false;

 /**
* Is daemon running
* 
* @var boolean
* @since 1.0
*/
 var $_isRunning = false;
 /**#@-*/


 /**
* Constructor
*
* @access public
* @since 1.0
* @return void
*/
 function Daemon()
 {
error_reporting(0);
set_time_limit(0);
ob_implicit_flush();

register_shutdown_function(array(&$this, 'releaseDaemon'));
 }

 /**
* Starts daemon
*
* @access public
* @since 1.0
* @return bool
*/
 function start()
 {
$this->_logMessage('Starting daemon');

if (!$this->_daemonize())
{
 $this->_logMessage('Could not start daemon', DLOG_ERROR);

 return false;
}


$this->_logMessage('Running...');

$this->_isRunning = true;


while ($this->_isRunning)
{
 $this->_doTask();
}

return true;
 }

 /**
* Stops daemon
*
* @access public
* @since 1.0
* @return void
*/
 function stop()
 {
$this->_logMessage('Stoping daemon');

$this->_isRunning = false;
 }

 /**
* Do task
*
* @access protected
* @since 1.0
* @return void
*/
 function _doTask()
 {
// override this method
 }

 /**
* Logs message
*
* @access protected
* @since 1.0
* @return void
*/
 function _logMessage($msg, $level = DLOG_NOTICE)
 {
 // override this method
 }

 /**
* Daemonize
*
* Several rules or characteristics that most daemons possess:
* 1) Check is daemon already running
* 2) Fork child process
* 3) Sets identity
* 4) Make current process a session laeder
* 5) Write process ID to file
* 6) Change home path
* 7) umask(0)
* 
* @access private
* @since 1.0
* @return void
*/
 function _daemonize()
 {
ob_end_flush();

if ($this->_isDaemonRunning())
{
 // Deamon is already running. Exiting
 return false;
}

if (!$this->_fork())
{
 // Coudn't fork. Exiting.
 return false;
}

if (!$this->_setIdentity() && $this->requireSetIdentity)
{
 // Required identity set failed. Exiting
 return false;
}

if (!posix_setsid())
{
 $this->_logMessage('Could not make the current process a session leader', DLOG_ERROR);

 return false;
}

if (!$fp = @fopen($this->pidFileLocation, 'w'))
{
 $this->_logMessage('Could not write to PID file', DLOG_ERROR);

 return false;
}
else
{
 fputs($fp, $this->_pid);
 fclose($fp);
}

@chdir($this->homePath);
umask(0);

declare(ticks = 1);

pcntl_signal(SIGCHLD, array(&$this, 'sigHandler'));
pcntl_signal(SIGTERM, array(&$this, 'sigHandler'));

return true;
 }

 /**
* Cheks is daemon already running
*
* @access private
* @since 1.0.3
* @return bool
*/
 function _isDaemonRunning()
 {
$oldPid = @file_get_contents($this->pidFileLocation);

if ($oldPid !== false && posix_kill(trim($oldPid),0))
{
 $this->_logMessage('Daemon already running with PID: '.$oldPid, (DLOG_TO_CONSOLE | DLOG_ERROR));

 return true;
}
else
{
 return false;
}
 }

 /**
* Forks process
*
* @access private
* @since 1.0
* @return bool
*/
 function _fork()
 {
$this->_logMessage('Forking...');

$pid = pcntl_fork();

if ($pid == -1) // error
{
 $this->_logMessage('Could not fork', DLOG_ERROR);

 return false;
}
else if ($pid) // parent
{
 $this->_logMessage('Killing parent');

 exit();
}
else // children
{
 $this->_isChildren = true;
 $this->_pid = posix_getpid();

 return true;
}
 }

 /**
* Sets identity of a daemon and returns result
*
* @access private
* @since 1.0
* @return bool
*/
 function _setIdentity()
 {
if (!posix_setgid($this->groupID) || !posix_setuid($this->userID))
{
 $this->_logMessage('Could not set identity', DLOG_WARNING);

 return false;
}
else
{
 return true;
}
 }

 /**
* Signals handler
*
* @access public
* @since 1.0
* @return void
*/
 function sigHandler($sigNo)
 {
switch ($sigNo)
{
 case SIGTERM:  // Shutdown
$this->_logMessage('Shutdown signal');
exit();
break;

 case SIGCHLD:  // Halt
$this->_logMessage('Halt signal');
while (pcntl_waitpid(-1, $status, WNOHANG) > 0);
break;
}
 }

 /**
* Releases daemon pid file
* This method is called on exit (destructor like)
*
* @access public
* @since 1.0
* @return void
*/
 function releaseDaemon()
 {
if ($this->_isChildren && file_exists($this->pidFileLocation))
{
 $this->_logMessage('Releasing daemon');

 unlink($this->pidFileLocation);
}
 }
}
?>

[ActivePlayer]

ja odnosnie etapów.

    * Rozwidlic procesy - utworzyc proces dziecka (fork), a proces rodzica zamknac. A przed tym zamknac jakiekolwiek polaczenia do pliku gdyz moze to prowadzic co nadpisania danych procesu rodzica lub dziecka.

Nigdy nie zajmowalem sie tym wczesniej, wiec zastanawiam sie po co ? demon nie moglby dzialac w petli i poprostu sprawdzac czy jest cos 'todo' ? no chyba ze to jest jakas forma zapewnienia wielowątkowosci? dlaczego wiec zamykac proces rodzica?

Co do wykozystania... pierwsze na mysl przyszlo mi 'cron', na podstawie tej klasy mozna by napisac alternatywe crona. drugie o czym pomyslalem to implementacja pod windowsami.

[Seth]

Jak najbardziej mogl by dzialac w petli (zreszta i tak i tak dziala ) ale tworzenie kopi rodzica ma nieco inny sens. Otoz jedna kopia (rodzic) jest jakby przypisana do konsoli - dopoki ona dziala nie moze "uwolnic" konsoli. Tworzac jej kopie (dziecko) automatycznie przechodzi ona w tlo i nie ma powiazania z konsola (nie mozna nic wypisac z poziomu dzicka na konsole).
Teraz zamykamy proces rodzica, przez co odlaczamy sie od konsoli i mozemy - my jako user - korzystac z konsoli.
Tymczasem nadal dziala sobie kopia (dziecko) naszego demona - w tle.

Na liscie procesow wygladalo by to mniej wiecej tak:

1) Start programu

Kod

Nr. PID           Nazwa
21432             Demon

2) Rozdzielamy procesy (fork)

Kod

Nr. PID          Nazwa
21432            Demon
|
  \---- 21438     Demon(dziecko)

3) Zamykamy rodzica

Kod

Nr. PID          Nazwa
|
  \---- 21438     Demon(dziecko)

4) Teraz musimy ustawic dziecko na session leadera

Kod

Nr. PID          Nazwa
21438            Demon(dziecko)

Teraz co do konsoli: w pkt. 2 Demon z PIDem 21432 ma dostep do konsoli, a 21438 juz nie. W tym momencie mamy zajeta konsole i nie mozemy wykonywac zadnych polecen.
W pkt 3 mamy juz zwolniona konsole i mozemy z niej korzystac a nadal mamy dzialajacego demona w tle.

Do tego mozemy kontrolowac demona za pomoca sygnalow np:

Kod

kill SIGTERM [nr pid]

--------------------------------------------------[ edit ]

Co do implementacji pod Windowsa to niestety nie jest to mozliwe uzywajac standardowych rozszezen php. Mozna by napisac handlera serwisu Windowsowego w innym jezyku, ktory by korzystal z php ale jest to za duzo zachodu.

Jest jednak nadzieja Dzisiaj znalazlem cos co moze sprawic, ze nawet pod Windowsa bedziemy mogli napisac swoj serwis (demona).
Rozszezenie win32service napisany przez Weza Furlonga, ktore znajduje sie w zbiorze rozszezen PECL php:
http://snaps.php.net/win32/PECL_5_0/
Dziala co prawda tylko pod php 5 ale raczej nie bedzie to wielkim problemem

Patrzac na przyklad uzycia tego rozszezenia mozna smialo powiedziec, ze jest bardzo latwe w uzyciu:

[PHP] pobierz, plaintext 
<?php
/* A sample service:
 *
 * php sample.php install
 * net start dummyphp
 * net stop dummyphp
 * php sample.php uninstall
 */
 
if ($argv[1] == 'install') {
	$x = win32_create_service(array(
		'service' => 'dummyphp',
		'display' => 'sample dummy php service',
		'params' => __FILE__ . ' run',
	));
	debug_zval_dump($x);
	exit;
} else if ($argv[1] == 'uninstall') {
	$x = win32_delete_service('dummyphp');
	debug_zval_dump($x);
	exit;
} else if ($argv[1] != 'run') {
	die("bogus args");
}
 
$x = win32_start_service_ctrl_dispatcher('dummyphp');
 
while (WIN32_SERVICE_CONTROL_STOP != win32_get_last_control_message()) {
	usleep(250000);
}
 
?>
[PHP] pobierz, plaintext 

Ten post edytował Seth 8.02.2006, 13:11:51

[LBO]

hmmm.. a moze kilka słów o zastosowaniach... ?..

bardzo mi sie podoba pomysl by uzyc takiego demona jako XMLsocket dla Flasha.. zreszta, cos takiego juz podobno fukcjonuje i to na polskim rynku... kto bywa na http://flashzone.pl i zna Wizzarda ten wie o czym mowie

[slash.]

co do tematu demona w srodowisku windows, cytujac manula php:

As of php 5, a new php-win.exe file is distributed. This is equal to the CLI version, except that php-win doesn't output anything and thus provides no console (no "dos box" appears on the screen). This behavior is similar to php-gtk. You should configure with --enable-cli-win32.

http://pl2.php.net/features.commandline

Niestety nie testowalem tego do konca, i na chwile obecna nie jestem w stanie powiedziec czy jest mozliwosc uruchomienia tego w obrebie innego uzytkownika aby zrobic z tego faktycznego demona, a wlasciwie usluge, ktora pozostanie aktywan po wylogowaniu usera.