Really daemonize a command when using exec()?

Question

From PHP pages of my apache server, I run some commands using a line like :

exec("{$command} >> /tmp/test.log 2>&1 & echo -n \$!");

You can see an explaination of the arguments here.

But I don't understand something : if I restart or stop my apache server, my command dies too.

root@web2:/sx/temp# ps ax | grep 0ff | grep -v grep
15957 ?        S      0:38 /usr/bin/php /sx/site_web_php/fr_FR/app/console task:exec /sx/temp/task_inventaire/ 0ff79bf690dcfdf788fff26c259882e2d07426df 10800
root@web2:/sx/temp#  /etc/init.d/apache2 restart
Restarting web server: apache2 ... waiting ..
root@web2:/sx/temp# ps ax | grep 0ff | grep -v grep
root@web2:/sx/temp# 

After some researches, I read some things about parent pids, but using a & inside my command-line, I thought I was really detaching my child process from his parent.

I am using apache2 with libapache2-mod-php5 and apache2-mpm-prefork.

How can I really detach my children programs from apache?

edit

You can reproduce it on a Linux/Mac this way :

a) create a executed_script.php file that contains :

<?php
sleep(10);

b) create a execute_from_http.php file that contains :

<?php
exec("php executed_script.php > /tmp/test.log 2>&1 & echo -n \$!");

c) run http://localhost/path/execute_from_http.php

d) on a terminal, run the command :

ps axjf | grep execute | grep -v grep ; sudo /etc/init.d/apache2 restart ; ps axjf | grep execute | grep -v grep

If you run the command during the 10 secs of the execute_from_http.php script, you'll get the output :

php@beast:/var/www/xxx/$ ps axjf | grep execute | grep -v grep ; sudo /etc/init.d/apache2 restart ; ps axjf | grep execute | grep -v grep
    1  5257  5245  5245 ?           -1 S       33   0:00 php executed_script.php
 * Restarting web server apache2
 ... waiting    ...done.
php@beast:/var/www/xxx/$

As you can see, the ps command outputs only once, this tells you that the executed script died when apache restarted.

Answer 1

The "at" method

I found a working solution but I don't know if that's ok if we speak performance and security. It uses the at command, a kind of cron working only once.

Instead of :

exec("php executed_script.php > /dev/null 2>&1 & echo -n \$!");

Use :

exec("echo 'php executed_script.php > /dev/null 2>&1' | at now -M");

The key is that executed_script.php will be run by an external daemon (atd), so executed_script.php will be a child of atd and not an apache's one.

php@beast:/var/www/xxx$ ps axjf | grep execute | grep -v grep ; sudo /etc/init.d/apache2 restart ; ps axjf | grep execute | grep -v grep
 7032  7033   973   973 ?           -1 SN      33   0:00          \_ php executed_script.php
 * Restarting web server apache2
 ... waiting    ...done.
 7032  7033   973   973 ?           -1 SN      33   0:00          \_ php executed_script.php
php@beast:/var/www/xxx$ ps ax | grep 973
 973 ?        Ss     0:00 atd

Note several things :

• you can't access the pid of your ran app, if you get $! like on my previous pieces of code, you'll get the pid of at.
• you need to remove www-data which is by default in /etc/at.deny (it is probably there with reasons, so take care)
• i have serious doubts about performance : I think that at write on a file read by atd to communicate

---

The fork / setsid method

As @hek2mgl wrote in its own answer, we can use a pcntl_fork(), but that's not as simple as that. First, you can't run pcntl_fork() behind apache, because if we look at the PHP Manual, Introduction of the Process Control, we can see:

Process Control should not be enabled within a web server environment and unexpected results may happen if any Process Control functions are used within a web server environment.

When a fork is made, you get two exact copy of the parent process in memory. And because PHP behind apache is run as a module, at the end of the PHP execution (even after a die()), you come back to the apache's module wrapper, and you can't control what's going on.

So here is the scenario with an intermediate command that will daemonize your execution:

1) From Apache, you run the intermediate command that will create your daemonized command :

$command = escapeshellarg("php executed_script.php");
exec("php run_as_daemon.php {$command} >> /dev/null 2>&1 &");

2) The intermediate command fork and use posix_setsid to really detach your command.

<?php

if (!isset($argv[1]))
{
    exit;
}
$command = $argv[1];

$pid = pcntl_fork();
if ($pid < 0) // error
    exit;
else if ($pid) // parent
    exit;
else // child
{
    $sid = posix_setsid(); // creates a daemon

    if ($sid < 0)
        exit;

    exec("{$command} >> /dev/null 2>&1 &");
}

3) Your executed command, of course, doesn't change :

<?php
sleep(10);

Result :

php@beast:/var/www/xxx/$ wget -qO- http://localhost/xxx/execute_from_http.php && sleep 1 && ps axjf | grep execute | grep -v grep ; sudo /etc/init.d/apache2 restart ; ps axjf | grep execute | grep -v grep
    1 19958 19956 19956 ?           -1 S       33   0:00 php executed_script.php
 * Restarting web server apache2 ......done.
    1 19958 19956 19956 ?           -1 S       33   0:00 php executed_script.php

Answer 2

First note, that the '&' in your example is just a boolean AND that concats the command and the echo. If you want to start the command in background, meaning that exec will return immediately, use the & at the very end of the command line:

exec("{$command} >> /tmp/test.log 2>&1 & echo -n \$! &");

---

If you want the process running after apache has finished you'll have to daemonize the process using pcntl_fork()

Here comes an example:

$pid = pcntl_fork();

switch($pid) {
    case -1 : die ('Error while forking');

    case 0:  // daemon code
         posix_setsid(); // create new process group
         exec("{$command} >> /tmp/test.log 2>&1 & echo -n \$!");
         break;
    default: 
         echo 'daemon started';
         break;

}

Now there is no code in the starting PHP scripts that handles the return value of exec nor its output. So the current process can finish before exec has finished. The worker process will be owned by init after this.

---

Also you can have a look at the PEAR package System_Daemon. This can help to daemonize a script.