PHP Linux Daemon erstellen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Dieser Wiki Artikel erläutert den Bau eines Linux Daemons, wie er im Betriebssystem eingebunden werden kann.
    == Beispiel ==
    Unser Daemon hört im Beispiel auf den Namen "veryimportant", was übersetzt aus dem Englischen für "sehr wichtig" steht.
    Nach gültigen Konventionen wird der Daemon gestartet über ein Init Script.

    Quellcode

    1. /etc/init.d/veryimportant start


    == Linux Standard Base (LSB) ==
    Die Linux Standard Base definiert eine Binärschnittstelle mit dem Ziel, die Kompatibilität zwischen den verschiedenen Linux-Distributionen zu verbessern.
    Das Script unter /etc/init.d/veryimportant sieht wie folgt aus:

    Quellcode

    1. #!/bin/sh
    2. ### BEGIN INIT INFO
    3. # Provides: php-queue
    4. # Required-Start: $remote_fs mysql
    5. # Required-Stop: $remote_fs mysql
    6. # Should-Start: $network $named $time
    7. # Should-Stop: $network $named $time
    8. # Default-Start: 2 3 4 5
    9. # Default-Stop: 0 1 6
    10. # Short-Description: Starts and stops the veryimportant php daemon.
    11. # Description: Controls the veryimportant PHP script for me, so that
    12. # processing is active in all run-levels in which network
    13. # services are active
    14. ### END INIT INFO
    15. #
    16. # Author: Max Mustermann <max@mustermann.de>
    17. #
    18. # This init script conforms to LSB 3.2.0.
    19. #
    21. PATH=/bin:/usr/bin:/sbin:/usr/sbin
    22. DAEMON=/home/veryimportant/daemon.php
    23. PIDFILE=/var/run/veryimportant.pid
    25. test -x $DAEMON || exit 0
    27. . /lib/lsb/init-functions
    29. case "$1" in
    30. start)
    31. log_daemon_msg "Starting veryimportant processing" "veryimportant.php"
    32. start_daemon -p $PIDFILE $DAEMON
    33. log_end_msg $?
    34. ;;
    35. stop)
    36. log_daemon_msg "Stopping veryimportant processing" "veryimportant.php"
    37. killproc -p $PIDFILE $DAEMON
    38. log_end_msg $?
    39. ;;
    40. force-reload|restart)
    41. $0 stop
    42. $0 start
    43. ;;
    44. *)
    45. echo "Usage: $0 {start|stop|restart|force-reload}" >&2
    46. exit 2
    47. ;;
    48. esac
    Alles anzeigen


    Wir machen das Script nur für root ausführbar, aber für alle lesbar.

    Quellcode

    1. chmod 0755 /etc/init.d/veryimportant


    == Das PHP Script ==
    Das Script des Hauptprogramms legen wir unter /home/veryimportant/daemon.php ab.
    Die Kommandozeilenparameter "d" und "u" sind aktiviert. Mit "d" schalten wir in den Debug Modus und mit "u" nehmen wir unterschiedliche Benutzer an. Das Script soll nicht unter root, sondern einem anderen Benutzer laufen.
    Bei uns "veryimportant".

    Wir legen den Benutzer an mit

    Quellcode

    1. adduser veryimportant


    Das Script enthält einen Logger, der entsprechende Ausgaben an einen Output Stream leitet. Das kann einer Logdatei oder der Standard-Output sein.
    Die Log Datei befindet sich unter /var/log/veryimportant.log.
    Damit der Daemon nicht mehrfach gestartet werden kann verwenden wir eine PID Datei unter /var/run/veryimportant.pid.

    Nun zum Quellcode:

    Quellcode

    1. #!/usr/bin/php
    2. <?php
    3. $options = getopt('du:');
    5. if ($options === FALSE) {
    6. die("Failed to parse command line options\n");
    7. }
    9. $debug = isset($options['d']);
    10. $user = isset($options['u']) ? $options['u'] : "veryimportantdaemon";
    11. $pidfile = "/var/run/veryimportant.pid";
    13. if (getmyuid() != 0) {
    14. die("This script must be started as root (it will revoke its privileges)\n");
    15. }
    17. if (!($passwd = posix_getpwnam($user))) {
    18. die("Failed to get passwd entry for user \"$user\"\n");
    19. }
    21. # Set the default timezone to the system's timezone.
    22. if (function_exists("date_default_timezone_set") and
    23. function_exists("date_default_timezone_get"))
    24. @date_default_timezone_set(@date_default_timezone_get());
    26. if (file_exists($pidfile)) {
    27. $pid = rtrim(file_get_contents($pidfile));
    29. if (posix_kill($pid, 0)) {
    30. die("Failed to create pidfile $pidfile (PID $pid is still running)\n");
    31. }
    33. trigger_error("Removing stale pidfile $pidfile", E_USER_NOTICE);
    34. unlink($pidfile);
    35. }
    37. # if debug ist not set open a child process
    38. if (!$debug) {
    39. $pid = pcntl_fork();
    40. if ($pid == -1) {
    41. die("Could not fork");
    42. } else if ($pid) {
    43. // We are the parent, we may exit now.
    44. exit(0);
    45. }
    46. }
    48. $pid = pcntl_fork();
    49. if ($pid == -1) {
    50. die("Could not fork again");
    51. } else if ($pid) {
    52. pcntl_signal(SIGINT, SIG_IGN);
    53. pcntl_signal(SIGTERM, SIG_IGN);
    55. // We are the parent. Write pidfile and wait until the child exists.
    56. if (!file_put_contents($pidfile, "$pid\n")) {
    57. posix_kill($pid, 15);
    58. die("Failed to create pidfile $pidfile");
    59. }
    61. $child = pcntl_waitpid($pid, $status);
    62. unlink($pidfile);
    63. exit;
    64. }
    66. $uid = $passwd['uid'];
    67. $gid = $passwd['gid'];
    69. if (!posix_setgid($gid) or !posix_setuid($uid)) {
    70. die("Failed revoke privileges to run as user \"$user\"\n");
    71. }
    73. function sig_handler($signo)
    74. {
    75. switch ($signo) {
    76. case SIGINT:
    77. case SIGTERM:
    78. // handle shutdown tasks
    79. Logger::info("Got signal $signo, exiting");
    80. exit(128 + $signo);
    81. }
    82. }
    84. function err_handler($errno, $errstr, $errfile, $errline, $errcontext)
    85. {
    86. switch ($errno) {
    87. case E_USER_ERROR:
    88. // print and exit
    89. Logger::error("Fatal error: $errstr in $errfile on line $errline (exiting)");
    91. case E_USER_WARNING:
    92. Logger::warn("Warning: $errstr in $errfile on line $errline");
    93. break;
    94. case E_USER_NOTICE:
    95. Logger::info("Notice: $errstr in $errfile on line $errline");
    96. break;
    97. default:
    98. Logger::warn("Unknown error type $errno: $errstr in $errfile on line $errline");
    99. break;
    100. }
    102. return TRUE;
    103. }
    105. /**
    106. * basic logger
    107. *
    108. * Example usage:
    109. * @code
    110. * Logger::init(fopen("/var/log/veryimportant.log", "a"));
    111. *
    112. * Logger::info("Small info line");
    113. * Logger::warn("A little warning");
    114. * Logger::debug("Some sweet debug information");
    115. * Logger::error("Houston, we've got a (serious) problem");
    116. * @endcode
    117. */
    118. class Logger {
    119. private static $instance = NULL;
    120. private $handle = null;
    122. protected function __construct($handle) {
    123. $this->handle = $handle;
    124. register_shutdown_function(array(&$this, "__destruct"));
    125. }
    127. public function __destruct() {
    128. if($this->handle) {
    129. fclose($this->handle);
    130. }
    131. return true;
    132. }
    134. public function writeLog($level, $message) {
    135. if($this->handle) {
    136. fwrite($this->handle, sprintf("%s - %s - %s\n", date('r'), $level, $message));
    137. }
    138. }
    140. private final function __clone() {}
    142. private static function getInstance() {
    143. if (self::$instance === NULL) {
    144. throw new Exception('call init before');
    145. }
    146. return self::$instance;
    147. }
    149. public static function init($output) {
    150. self::$instance = new self($output);
    151. }
    153. public static function info($message) {
    154. self::getInstance()->writeLog('INFO', $message);
    155. }
    157. public static function warn($message) {
    158. self::getInstance()->writeLog('WARN', $message);
    159. }
    161. public static function debug($message) {
    162. self::getInstance()->writeLog('DEBUG', $message);
    163. }
    165. public static function error($message) {
    166. self::getInstance()->writeLog('ERROR', $message);
    167. exit;
    168. }
    169. }
    171. set_error_handler("err_handler");
    173. pcntl_signal(SIGINT, "sig_handler");
    174. pcntl_signal(SIGTERM, "sig_handler");
    176. # Enable the signal handle callback mechanism.
    177. declare(ticks = 1);
    179. # Open the output stream which should receive all log messages.
    180. # if debug is set just print the messages - if not, then log to file
    181. Logger::init($debug ? STDOUT : fopen("/var/log/veryimportant.log", "a"));
    183. # program code
    184. # run controller from here
    185. # e.g. Controller::dispatch()
    186. while(true) {
    187. Logger::info("i am running");
    188. sleep(1);
    189. }
    190. ?>
    Alles anzeigen

    11.725 mal gelesen