Detecting a timeout for a block of code in PHP

Question

Is there a way you can abort a block of code if it\'s taking too long in PHP? Perhaps something like:

//Set the max time to 2 seconds
$time = new TimeOut(2);
$ti         


        

Answer 1

What about set-time-limit if you are not in the safe mode.

Answer 2

You can't really do that if you script pauses on one command (for example sleep()) besides forking, but there are a lot of work arounds for special cases: like asynchronous queries if you programm pauses on DB query, proc_open if you programm pauses at some external execution etc. Unfortunately they are all different so there is no general solution.

If you script waits for a long loop/many lines of code you can do a dirty trick like this:

declare(ticks=1);

class Timouter {

    private static $start_time = false,
    $timeout;

    public static function start($timeout) {
        self::$start_time = microtime(true);
        self::$timeout = (float) $timeout;
        register_tick_function(array('Timouter', 'tick'));
    }

    public static function end() {
        unregister_tick_function(array('Timouter', 'tick'));
    }

    public static function tick() {
        if ((microtime(true) - self::$start_time) > self::$timeout)
            throw new Exception;
    }

}

//Main code
try {
    //Start timeout
    Timouter::start(3);

    //Some long code to execute that you want to set timeout for.
    while (1);
} catch (Exception $e) {
    Timouter::end();
    echo "Timeouted!";
}

but I don't think it is very good. If you specify the exact case I think we can help you better.

Answer 3

This is an old question, and has probably been solved many times by now, but for people looking for an easy way to solve this problem, there is a library now: PHP Invoker.

Answer 4

I made a script in php using pcntl_fork and lockfile to control the execution of external calls doing the kill after the timeout.

---

#!/usr/bin/env php
<?php

if(count($argv)<4){
    print "\n\n\n";
    print "./fork.php PATH \"COMMAND\" TIMEOUT\n"; // TIMEOUT IN SECS
    print "Example:\n";
    print "./fork.php /root/ \"php run.php\" 20";
    print "\n\n\n";
    die;
}

$PATH = $argv[1];
$LOCKFILE = $argv[1].$argv[2].".lock";
$TIMEOUT = (int)$argv[3];
$RUN = $argv[2];

chdir($PATH);


$fp = fopen($LOCKFILE,"w"); 
    if (!flock($fp, LOCK_EX | LOCK_NB)) {
            print "Already Running\n";
            exit();
    }

$tasks = [
  "kill",
  "run",
];

function killChilds($pid,$signal) { 
    exec("ps -ef| awk '\$3 == '$pid' { print  \$2 }'", $output, $ret); 
    if($ret) return 'you need ps, grep, and awk'; 
    while(list(,$t) = each($output)) { 
            if ( $t != $pid && $t != posix_getpid()) { 
                    posix_kill($t, $signal);
            } 
    }    
} 

$pidmaster = getmypid();
print "Add PID: ".(string)$pidmaster." MASTER\n";

foreach ($tasks as $task) {
    $pid = pcntl_fork();

    $pidslave = posix_getpid();
    if($pidslave != $pidmaster){
        print "Add PID: ".(string)$pidslave." ".strtoupper($task)."\n";
    }

  if ($pid == -1) {
    exit("Error forking...\n");
  }
  else if ($pid == 0) {
    execute_task($task);        
        exit();
  }
}

while(pcntl_waitpid(0, $status) != -1);
echo "Do stuff after all parallel execution is complete.\n";
unlink($LOCKFILE);


function execute_task($task_id) {
    global $pidmaster;
    global $TIMEOUT;
    global $RUN;

    if($task_id=='kill'){
        print("SET TIMEOUT = ". (string)$TIMEOUT."\n");
        sleep($TIMEOUT);
        print("FINISHED BY TIMEOUT: ". (string)$TIMEOUT."\n");
        killChilds($pidmaster,SIGTERM);

        die;
  }elseif($task_id=='run'){
        ###############################################
        ### START EXECUTION CODE OR EXTERNAL SCRIPT ###
        ###############################################

            system($RUN);

        ################################    
        ###             END          ###
        ################################
        killChilds($pidmaster,SIGTERM);
        die;
    }
}

---

Test Script run.php

<?php

$i=0;
while($i<25){
    print "test... $i\n";
    $i++;
    sleep(1);
}

Answer 5

You can use declare function if the execution time exceeds the limits. http://www.php.net/manual/en/control-structures.declare.php

Here a code example of how to use

define("MAX_EXECUTION_TIME", 2); # seconds

$timeline = time() + MAX_EXECUTION_TIME;

function check_timeout()
{
    if( time() < $GLOBALS['timeline'] ) return;
    # timeout reached:
    print "Timeout!".PHP_EOL;
    exit;
}

register_tick_function("check_timeout");
$data = "";

declare( ticks=1 ){
    # here the process that might require long execution time
    sleep(5); // Comment this line to see this data text
    $data = "Long process result".PHP_EOL;
}

# Ok, process completed, output the result:
print $data;

With this code you will see the timeout message. If you want to get the Long process result inside the declare block you can just remove the sleep(5) line or increase the Max Execution Time declared at the start of the script

Answer 6

Here is my way to do that. Thanks to others answers:

<?php
class Timeouter
{
   private static $start_time = FALSE, $timeout;

   /**
    * @param   integer $seconds Time in seconds
    * @param null      $error_msg
    */
   public static function limit($seconds, $error_msg = NULL)
   : void
   {
      self::$start_time = microtime(TRUE);
      self::$timeout    = (float) $seconds;
      register_tick_function([ self::class, 'tick' ], $error_msg);
   }

   public static function end()
   : void
   {
      unregister_tick_function([ self::class, 'tick' ]);
   }

   public static function tick($error)
   : void
   {
      if ((microtime(TRUE) - self::$start_time) > self::$timeout) {
         throw new \RuntimeException($error ?? 'You code took too much time.');
      }
   }

   public static function step()
   : void
   {
      usleep(1);
   }
}

Then you can try like this:

  <?php
  try {
     //Start timeout
     Timeouter::limit(2, 'You code is heavy. Sorry.');

     //Some long code to execute that you want to set timeout for.
     declare(ticks=1) {
        foreach (range(1, 100000) as $x) {
           Timeouter::step(); // Not always necessary
           echo $x . "-";
        }
     }

     Timeouter::end();
  } catch (Exception $e) {
     Timeouter::end();
     echo $e->getMessage(); // 'You code is heavy. Sorry.'
  }