PHP GearmanWorker::setTimeout方法代码示例

 /**
  * Constructor
  * Checks for the required gearman extension,
  * fetches the bootstrap and loads in the gearman worker
  *
  * @return Gearman_Worker
  */
 public function __construct($bootstrap)
 {
     if (!extension_loaded('gearman')) {
         throw new RuntimeException('The PECL::gearman extension is required.');
     }
     $this->_worker = $bootstrap->getWorker();
     if (empty($this->_registerFunction)) {
         throw new InvalidArgumentException(get_class($this) . ' must implement a registerFunction');
     }
     // allow for a small memory gap:
     $memoryLimit = ($this->_memory + 128) * 1024 * 1024;
     ini_set('memory_limit', $memoryLimit);
     $this->_worker->addFunction($this->_registerFunction, array(&$this, 'work'));
     $this->_worker->setTimeout($this->_timeout);
     $this->init();
     while ($this->_worker->work() || $this->_worker->returnCode() == GEARMAN_TIMEOUT) {
         if ($this->_worker->returnCode() == GEARMAN_TIMEOUT) {
             $this->timeout();
             continue;
         }
         if ($this->_worker->returnCode() != GEARMAN_SUCCESS) {
             $this->setError($this->_worker->returnCode() . ': ' . $this->_worker->getErrno() . ': ' . $this->_worker->error());
             break;
         }
     }
     $this->shutdown();
 }

 /**
  * Get GearmanWorker
  *
  * @return \GearmanWorker
  */
 public function getGearmanWorker()
 {
     if (!$this->worker) {
         $this->worker = new \GearmanWorker();
     }
     if ($this->timeout !== null) {
         $this->worker->setTimeout($this->timeout);
     }
     if ($this->functions !== null) {
         foreach ($this->functions as $f) {
             $this->register($f, array($this, 'proxify'));
         }
     }
     return $this->worker;
 }

 /**
  * Constructor
  * Checks for the required gearman extension,
  * fetches the bootstrap and loads in the gearman worker
  *
  * @param Zend_Application_Bootstrap_BootstrapAbstract $bootstrap
  * @return Zend_Gearman_Worker
  */
 public function __construct(Zend_Application_Bootstrap_BootstrapAbstract $bootstrap)
 {
     if (!extension_loaded('gearman')) {
         throw new RuntimeException('The PECL::gearman extension is required.');
     }
     $this->_bootstrap = $bootstrap;
     $this->_worker = $this->_bootstrap->bootstrap('gearmanworker')->getResource('gearmanworker');
     if (empty($this->_registerFunction)) {
         throw new InvalidArgumentException(get_class($this) . ' must implement a registerFunction');
     }
     // allow for a small memory gap:
     $memoryLimit = ($this->_memory + 128) * 1024 * 1024;
     ini_set('memory_limit', $memoryLimit);
     $this->_worker->addFunction($this->_registerFunction, array(&$this, 'work'));
     $this->_worker->setTimeout($this->_timeout);
     $this->init();
     $check = 10;
     $c = 0;
     while (@$this->_worker->work() || $this->_worker->returnCode() == GEARMAN_TIMEOUT) {
         $c++;
         if ($this->_worker->returnCode() == GEARMAN_TIMEOUT) {
             $this->timeout();
             continue;
         }
         if ($this->_worker->returnCode() != GEARMAN_SUCCESS) {
             $this->setError($this->_worker->returnCode() . ': ' . $this->_worker->getErrno() . ': ' . $this->_worker->error());
             break;
         }
         if ($c % $check === 0 && $this->isMemoryOverflow()) {
             break;
             // we've consumed our memory and the worker needs to be restarted
         }
     }
     $this->shutdown();
 }

 /**
  * Starts a worker for the PECL library
  *
  * @param   array   $worker_list    List of worker functions to add
  * @param   array   $timeouts       list of worker timeouts to pass to server
  * @return  void
  *
  */
 protected function start_lib_worker($worker_list, $timeouts = array())
 {
     $thisWorker = new GearmanWorker();
     $thisWorker->addOptions(GEARMAN_WORKER_NON_BLOCKING);
     $thisWorker->setTimeout(5000);
     foreach ($this->servers as $s) {
         $this->log("Adding server {$s}", GearmanManager::LOG_LEVEL_WORKER_INFO);
         // see: https://bugs.php.net/bug.php?id=63041
         try {
             $thisWorker->addServers($s);
         } catch (\GearmanException $e) {
             if ($e->getMessage() !== 'Failed to set exception option') {
                 throw $e;
             }
         }
     }
     foreach ($worker_list as $w) {
         $timeout = isset($timeouts[$w]) ? $timeouts[$w] : null;
         $this->log("Adding job {$w} ; timeout: " . $timeout, GearmanManager::LOG_LEVEL_WORKER_INFO);
         $thisWorker->addFunction($w, array($this, "do_job"), $this, $timeout);
     }
     $start = time();
     while (!$this->stop_work) {
         if (@$thisWorker->work() || $thisWorker->returnCode() == GEARMAN_IO_WAIT || $thisWorker->returnCode() == GEARMAN_NO_JOBS) {
             if ($thisWorker->returnCode() == GEARMAN_SUCCESS) {
                 continue;
             }
             if (!@$thisWorker->wait()) {
                 if ($thisWorker->returnCode() == GEARMAN_NO_ACTIVE_FDS) {
                     sleep(5);
                 }
             }
         }
         /**
          * Check the running time of the current child. If it has
          * been too long, stop working.
          */
         if ($this->max_run_time > 0 && time() - $start > $this->max_run_time) {
             $this->log("Been running too long, exiting", GearmanManager::LOG_LEVEL_WORKER_INFO);
             $this->stop_work = true;
         }
         if (!empty($this->config["max_runs_per_worker"]) && $this->job_execution_count >= $this->config["max_runs_per_worker"]) {
             $this->log("Ran {$this->job_execution_count} jobs which is over the maximum({$this->config['max_runs_per_worker']}), exiting", GearmanManager::LOG_LEVEL_WORKER_INFO);
             $this->stop_work = true;
         }
     }
     $thisWorker->unregisterAll();
 }

 /**
  * Starts a worker for the PECL library
  *
  * @param   array   $worker_list    List of worker functions to add
  * @return  void
  *
  */
 protected function start_lib_worker($worker_list)
 {
     $thisWorker = new GearmanWorker();
     $thisWorker->addOptions(GEARMAN_WORKER_NON_BLOCKING);
     $thisWorker->setTimeout(5000);
     foreach ($this->servers as $s) {
         $this->log("Adding server {$s}", GearmanManager::LOG_LEVEL_WORKER_INFO);
         $thisWorker->addServers($s);
     }
     foreach ($worker_list as $w) {
         $this->log("Adding job {$w}", GearmanManager::LOG_LEVEL_WORKER_INFO);
         $thisWorker->addFunction($w, array($this, "do_job"), $this);
     }
     $start = time();
     while (!$this->stop_work) {
         if (@$thisWorker->work() || $thisWorker->returnCode() == GEARMAN_IO_WAIT || $thisWorker->returnCode() == GEARMAN_NO_JOBS) {
             if ($thisWorker->returnCode() == GEARMAN_SUCCESS) {
                 continue;
             }
             if (!@$thisWorker->wait()) {
                 if ($thisWorker->returnCode() == GEARMAN_NO_ACTIVE_FDS) {
                     sleep(5);
                 }
             }
         }
         /**
          * Check the running time of the current child. If it has
          * been too long, stop working.
          */
         if ($this->max_run_time > 0 && time() - $start > $this->max_run_time) {
             $this->log("Been running too long, exiting", GearmanManager::LOG_LEVEL_WORKER_INFO);
             $this->stop_work = true;
         }
         if (!empty($this->config["max_runs_per_worker"]) && $this->job_execution_count >= $this->config["max_runs_per_worker"]) {
             $this->log("Ran {$this->job_execution_count} jobs which is over the maximum({$this->config['max_runs_per_worker']}), exiting", GearmanManager::LOG_LEVEL_WORKER_INFO);
             $this->stop_work = true;
         }
     }
     $thisWorker->unregisterAll();
 }

 /**
  * Given a GearmanWorker and an instance of Job, run it
  *
  * @param \GearmanWorker $gearmanWorker Gearman Worker
  * @param Object         $objInstance   Job instance
  * @param array          $jobs          Array of jobs to subscribe
  * @param integer        $iterations    Number of iterations
  * @param integer        $timeout       Timeout
  *
  * @return GearmanExecute self Object
  */
 private function runJob(\GearmanWorker $gearmanWorker, $objInstance, array $jobs, $iterations, $timeout = null)
 {
     /**
      * Set the output of this instance, this should allow workers to use the console output.
      */
     if ($objInstance instanceof GearmanOutputAwareInterface) {
         $objInstance->setOutput($this->output ?: new NullOutput());
     }
     /**
      * Every job defined in worker is added into GearmanWorker
      */
     foreach ($jobs as $job) {
         /**
          * worker needs to have it's context into separated memory space;
          * if it's passed as a value, then garbage collector remove the target
          * what causes a segfault
          */
         $this->workersBucket[$job['realCallableName']] = array('job_object_instance' => $objInstance, 'job_method' => $job['methodName'], 'jobs' => $jobs);
         $gearmanWorker->addFunction($job['realCallableName'], array($this, 'handleJob'));
     }
     /**
      * If iterations value is 0, is like worker will never die
      */
     $alive = 0 === $iterations;
     if ($timeout > 0) {
         $gearmanWorker->setTimeout($timeout * 1000);
     }
     /**
      * Executes GearmanWorker with all jobs defined
      */
     while (false === $this->stopWorkSignalReceived && $gearmanWorker->work()) {
         $iterations--;
         $event = new GearmanWorkExecutedEvent($jobs, $iterations, $gearmanWorker->returnCode());
         $this->eventDispatcher->dispatch(GearmanEvents::GEARMAN_WORK_EXECUTED, $event);
         if ($gearmanWorker->returnCode() != GEARMAN_SUCCESS) {
             break;
         }
         /**
          * Only finishes its execution if alive is false and iterations
          * arrives to 0
          */
         if (!$alive && $iterations <= 0) {
             break;
         }
     }
 }

// Non-blocking
$worker->addOptions(GEARMAN_WORKER_NON_BLOCKING); 

// Add the localhost:4730 as server (default)
$worker->addServer(); 

// Add the functions to the worker
// Fetch all photo Ids of this twitpic user
$worker->addFunction("fetchPhotoIds", "fetchPhotoIds");

// Fetch a photo from twitpic
$worker->addFunction("fetchPhoto", "fetchPhoto");

// This worker will destroy itself in 5 seconds.
$worker->setTimeout(5000);

// Keep worker alive as long as there are jobs
while (@$worker->work() || $worker->returnCode() == GEARMAN_IO_WAIT || 
		$worker->returnCode() == GEARMAN_NO_JOBS){
			
	if ($worker->returnCode() == GEARMAN_SUCCESS){
		echo date('d-m-Y H:i:s') . "| Job Successful \n";
		continue;
	}
	
	if (!@$worker->wait()) { 
		if ($worker->returnCode() == GEARMAN_NO_ACTIVE_FDS) { 
			// We are not connected to the Gearman Server
			// We shall not hammer the Gearman Server
			// We have patience, not much, but some.

    } else {
        die("\nJSON config file is specified but cannot be found: {$jsonConfigFile}\n\n");
    }
}
/*
 * Get the functions to register with Gearman
 */
$gasWorker = new $workerClass();
$arrWorkerFunctions = $gasWorker->getFunctions();
foreach ($arrWorkerFunctions as $functionName) {
    $worker->addFunction($functionName, array($gasWorker, $functionName));
}
$maxJobs = $gasWorker->getMaxJobs();
$workerLifetimeMins = $gasWorker->getWorkerLifetimeMins();
//$worker->setId('worker_' . uniqid(true));
$worker->setTimeout($workerLifetimeMins * 60 * 1000);
error_log(date('c') . " - Starting worker " . $workerClass);
$load = 0;
$i = 0;
while ($i < $maxJobs && $load < 1.9 && ($foo = $worker->work())) {
    //TODO What happens when a worker doesn't process?
    if (!$foo) {
        error_log('$worker->work() returned false');
    }
    $arrAverageLoad = sys_getloadavg();
    $load = $arrAverageLoad[0];
    if ($worker->returnCode() != GEARMAN_SUCCESS) {
        echo "return_code: " . $worker->returnCode() . "\n";
        break;
    }
    $i++;