/**
* 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();
}
public static function run()
{
$lockAgent = new LockAgentWorker();
$worker = new \GearmanWorker();
$worker->addServer();
$worker->addFunction("findWithLock", array($lockAgent, "findWithLock"));
$worker->addFunction("dqlWithLock", array($lockAgent, "dqlWithLock"));
$worker->addFunction('lock', array($lockAgent, 'lock'));
while ($worker->work()) {
if ($worker->returnCode() != GEARMAN_SUCCESS) {
echo "return_code: " . $worker->returnCode() . "\n";
break;
}
}
}
/**
* 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();
}
/**
* 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();
}
/**
* Set up the GearmanWorker to run in non-blocking mode
*
* This allows you to do work "in between" jobs when its idle
*
* Events emitted:
* - Gearman.beforeWork: Called before GearmanWorker::work()
* - Gearman.afterWork: Called after GearmanWorker::work() actually processed a job
* - Gearman.beforeWait: Called before Gearman::wait() is called
* - Gearman.afterWait: Called after Gearman::wait() is called
*
* N.B: Gearman.beforeWork will be called even if there is no jobs to be processed,
* it's meant as a simple wrapper around GearmanWorker::work() and GearmanWorker::wait()
*
* All events can abort the infinite loop by calling $event->stopPropagation();
*
* @return void
*/
protected function _work()
{
$this->_worker->addOptions(GEARMAN_WORKER_NON_BLOCKING);
// Infinite loop of doom until we die!
while (true) {
if (!$this->_triggerEvent('Gearman.beforeWork')) {
break;
}
$this->_worker->work();
if (!$this->_triggerEvent('Gearman.afterWork')) {
break;
}
// If we processed a job, don't bother to wait
if ($this->_worker->returnCode() == GEARMAN_SUCCESS) {
continue;
}
if (!$this->_triggerEvent('Gearman.beforeWait')) {
break;
}
$this->_worker->wait();
if (!$this->_triggerEvent('Gearman.afterWait')) {
break;
}
}
}
function listen()
{
foreach ($this->getConfiguration()->getFunctions() as $functionName => $callable) {
$this->worker->addFunction($functionName, $this->wrap($callable, $functionName));
}
$this->suppressListen();
$started = time();
while ($this->worker->work()) {
if ($this->worker->returnCode() != GEARMAN_SUCCESS) {
$this->getLogger()->error('Gearman success fail with code:' . $this->worker->returnCode());
$this->terminate(SIGTERM);
}
$this->suppressListen();
$this->checkMatchedConditions();
if (time() - $started < 1) {
sleep(1);
}
}
}
public function work(\GearmanWorker $worker)
{
$worker->addOptions(GEARMAN_WORKER_NON_BLOCKING);
$getWorkAttempts = 0;
do {
$workRes = $worker->work();
$getWorkAttempts++;
$this->logger->debug("Get work attempt res: " . serialize($workRes));
$this->logger->debug("Attempts number: " . serialize($getWorkAttempts));
sleep(1);
if ($workRes) {
$this->taskWasGot = true;
}
} while ($workRes === false && $getWorkAttempts < WorkersConstants::MAX_GET_TASK_ATTEMPTS);
if ($worker->returnCode() != GEARMAN_SUCCESS) {
$this->logger->error("Not correct Gearman worker execution:" . $worker->returnCode());
}
return null;
}
function gearman_worker()
{
$gm = new GearmanWorker();
$gm->addServer();
$gm->addFunction('do_blacklist_checking', 'Monitor::do_blacklist_checking');
$gm->addFunction('process_pending_monitor', 'Monitor::process_pending_monitor');
while ($gm->work()) {
echo $gm->returnCode();
}
exit;
}
/**
* 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();
}
/**
* The Gearman Worker processes requests passed to it from a Gearman
* server. This class should be invoked as a daemon using the CLI
* interface. Multiple instances can be created to handle multiple requests
* asynchronously.
*
* // Initialize the Gearman Worker (in bootstrap)
* Request_Async_Gearman::worker();
* exit(0);
*
* To create a daemon script, run the following command from your command
* line.
*
* php /path/to/index.php
*
* @return void
*/
public static function worker()
{
$worker = new GearmanWorker();
$worker->addServer();
$worker->addFunction('request_async', array('Request_Async_Gearman', 'execute_request'), Request_Async_Gearman::$context);
echo Request_Async_Gearman::$context . ': Starting worker.' . "\n";
while ($worker->work() or $worker->returnCode() == GEARMAN_IO_WAIT or $worker->returnCode() == GEARMAN_NO_JOBS) {
if ($worker->returnCode() == GEARMAN_SUCCESS) {
continue;
}
echo Request_Async_Gearman::$context . ': Waiting for next job...' . "\n";
if (!$worker->wait()) {
if ($worker->returnCode() == GEARMAN_NO_ACTIVE_FDS) {
usleep(100);
continue;
}
}
break;
}
echo Request_Async_Gearman::$context . ': Stopping worker.' . "\n";
echo Request_Async_Gearman::$context . ': Worker error' . $worker->error() . "\n";
}
public function action_index()
{
// Purge and terminate ob
while (ob_get_level()) ob_end_flush();
# Create our worker object.
$gearman_mworker= new GearmanWorker;
# Add default server (localhost).
$gearman_mworker->addServer();
# Register function "reverse" with the server. Change the worker function to
# "reverse_fn_fast" for a faster worker with no output.
$gearman_mworker->addFunction("make_request", array($this, "worker"));
while($gearman_mworker->work())
{
if ($gearman_mworker->returnCode() != GEARMAN_SUCCESS)
{
echo "return_code: " . $gearman_mworker->returnCode() . "\n";
break;
}
}
}
protected function work(\GearmanWorker $worker)
{
// @!?
if (@$worker->work()) {
return true;
}
switch ($worker->returnCode()) {
case GEARMAN_SUCCESS:
case GEARMAN_TIMEOUT:
return true;
case GEARMAN_IO_WAIT:
case GEARMAN_NO_JOBS:
return $this->wait($worker);
default:
break;
}
return false;
}
/**
* 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;
}
}
}
#!/usr/bin/env php
<?php
namespace phinde;
chdir(dirname($argv[0]));
require_once __DIR__ . '/../src/init.php';
$gmworker = new \GearmanWorker();
$gmworker->addServer('127.0.0.1');
$gmworker->addFunction($GLOBALS['phinde']['queuePrefix'] . 'phinde_process', function (\GearmanJob $job) {
$data = unserialize($job->workload());
Log::info("-- Processing " . $data['url'] . ' (' . implode(',', $data['actions']) . ')');
passthru('./process.php ' . escapeshellarg($data['url']) . ' ' . implode(' ', $data['actions']));
});
$gmworker->addFunction($GLOBALS['phinde']['queuePrefix'] . 'phinde_quit', function (\GearmanJob $job) {
Log::info('Got exit job');
$job->sendComplete('');
exit(0);
});
while ($gmworker->work()) {
if ($gmworker->returnCode() != GEARMAN_SUCCESS) {
Log::error('Error running job: ' . $gmworker->returnCode());
break;
}
}
/**
* 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
*
* @return GearmanExecute self Object
*/
private function runJob(\GearmanWorker $gearmanWorker, $objInstance, array $jobs, $iterations)
{
/**
* 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) {
$gearmanWorker->addFunction($job['realCallableName'], array($objInstance, $job['methodName']));
}
/**
* If iterations value is 0, is like worker will never die
*/
$alive = 0 == $iterations;
/**
* Executes GearmanWorker with all jobs defined
*/
while ($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;
}
}
}
*
* Copyright (C) 2008 James M. Luedke (jluedke@jamesluedke.com)
* Eric Day (eday@oddments.org)
* All rights reserved.
*
* Use and distribution licensed under the PHP license. See
* the LICENSE file in this directory for full text.
*/
echo "Starting Thumbnail creator\n";
$gmw = new GearmanWorker();
$gmw->addServer();
# optional config paramsj
$args;
$gmw->addFunction("shrink_image", "resize_image", $args);
while ($gmw->work()) {
switch ($gmw->returnCode()) {
case GEARMAN_SUCCESS:
break;
default:
echo "ERROR RET: " . $gmc->returnCode() . "\n";
exit;
}
}
echo "DONE\n";
/* simple function to resize an image
* Requires the Imagick extension */
function resize_image($job, $args)
{
$wrk = $job->workload();
$data = unserialize($wrk);
if (!$data['src'] || !$data['dest'] || !$data['x']) {
while ($status['running'] === true) {
$result = stream_select($read, $write, $expect, 1);
if ($result) {
$cnt = stream_get_contents($pipes[1]);
$job->sendData($cnt);
writeSocket($cnt, GEARMAN_SERVER_IP, GEARMAN_SERVER_PORT);
print $cnt;
}
$status = proc_get_status($proc);
}
return $status['exitcode'] ?: 0;
});
while (true) {
print 'Waiting for job...' . PHP_EOL;
$ret = $worker->work();
if ($worker->returnCode() != GEARMAN_SUCCESS) {
print 'End of job (Status : ' . $worker->returnCode() . ')' . PHP_EOL;
break;
}
}
function getSocket($address, $port)
{
$socket = socket_create(AF_INET, SOCK_STREAM, 0);
if ($socket === FALSE) {
throw new Exception("socket_create failed: reason: " . socket_strerror(socket_last_error()));
}
$result = socket_connect($socket, $address, $port);
if ($result === false) {
throw new Exception("socket_connect() failed.\nReason: ({$result}) " . socket_strerror(socket_last_error($socket)));
}
return $socket;
// 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.
sleep(5);
continue;
<?php
date_default_timezone_set('Asia/Shanghai');
echo "starting\n";
$gmworker = new GearmanWorker();
$gmworker->addServer("10.0.128.219");
$gmworker->addFunction("hotblood_pack_task", "hotblood_pack_task_callback");
print "Waiting for job...\n";
while ($gmworker->work()) {
if ($gmworker->returnCode() != GEARMAN_SUCCESS) {
echo "return_code: " . $gmworker->returnCode() . "\n";
break;
}
}
function hotblood_pack_task_callback($job)
{
echo "get tast at " . date("Y-m-d H:i:s", time()) . " " . $job->workload() . "\n";
popen("python ios_run.py " . $job->workload(), 'r');
return "task";
}
$FENs = array();
$fp = fopen($pandaCave, 'rb', false);
$data = json_decode(fread($fp, 102400), true);
if (count($data) == 0) {
echo "No servers found in FEN pool from Panda Cave.";
exit;
}
foreach ($data as $server) {
$gm->addServer($server['InternalIP']);
}
$args = null;
$stop = false;
global $stop;
$gm->addFunction("qarcGithubHook", "qarcGithubHook", $args);
echo "Added the function to gearman\n";
while (!$stop && ($gm->work() || $gm->returnCode() == GEARMAN_TIMEOUT)) {
switch ($gm->returnCode()) {
case GEARMAN_SUCCESS:
echo "Gearman Success\n";
break;
case GEARMAN_TIMEOUT:
echo "Gearman Timeout\n";
break;
default:
echo "ERROR RET: " . $gmc->returnCode() . "\n";
exit;
}
}
echo "Quitting\n";
function qarcGithubHook($job, $args)
{
/**
* Read auto-loader
*/
include __DIR__ . '/config/loader.php';
/**
* Read the configuration
*/
$config = (include __DIR__ . '/config/config.php');
/**
* Read the services
*/
$di = new CliDi();
include __DIR__ . '/config/services.php';
/**
* Create a console application
*/
$console = new ConsoleApp($di);
$worker = new GearmanWorker();
$worker->setId(sha1(date("d.m.Y H:i:s")));
$worker->addServer('192.168.77.56', 4730);
$worker->addFunction("send_metrix_calc", function ($job) use(&$console, &$di) {
$di->set('workerJob', new MetrixResponse($di, $job, new FileAdapter(__DIR__ . "/logs/workjob_" . date("d-m-Y") . ".log")));
$arguments = json_decode($job->workload(), true);
$console->setDi($di);
$console->handle($arguments);
});
while ($worker->work()) {
if (GEARMAN_SUCCESS != $worker->returnCode()) {
echo "Worker failed: " . $worker->error() . "\n";
}
}
<?php
require_once __DIR__ . '/../../../vendor/autoload.php';
use upload\model\inmuweb;
## Workers para syncronizar pagina web
$w = new GearmanWorker();
$count = 0;
$w->addServer();
### estsblecer funciones disponibles
$w->addFunction("delete", "delete");
//$w->addFunction("actContractLst","actContractLst",$c);
while ($w->work()) {
if ($w->returnCode() != GEARMAN_SUCCESS) {
echo "return_code: " . $w->returnCode() . "\n";
break;
}
}
function delete($job)
{
$inm = new inmuweb();
$data = json_decode($job->workload());
$result = $inm->delete($data->id);
echo "Inmueble :" . $data->id . " -> {$result} \n";
return 0;
}
<?php
$worker = new GearmanWorker();
$worker->addServer("gearmand", "4730");
$worker->addFunction('getTemp', 'getTemp');
print "Waiting for a job...\n";
while ($worker->work()) {
if ($worker->returnCode() !== GEARMAN_SUCCESS) {
print 'Exiting with return code: ' . $gmworker->returnCode();
break;
}
}
function getTemp($job)
{
$ch = curl_init();
$payload = json_decode($job->workload());
print "Getting current temperature for {$payload->city}...\n";
$city = urlencode($payload->city);
curl_setopt_array($ch, array(CURLOPT_RETURNTRANSFER => 1, CURLOPT_URL => "http://api.openweathermap.org/data/2.5/weather?q={$city},us"));
$result = json_decode(curl_exec($ch));
return round(($result->main->temp - 273.15) * 1.8 + 32);
}
#!/usr/local/momo_album/php/bin/php
<?php
error_reporting(E_ALL ^ E_NOTICE);
date_default_timezone_set("Asia/Shanghai");
define('SCRIPT_BASE', dirname(__FILE__) . DIRECTORY_SEPARATOR);
require SCRIPT_BASE . '../global.php';
$worker = new GearmanWorker();
$worker->addServers(Core::config('job_servers'));
$thumb = new Thumb();
$worker->addFunction("thumbnail", array($thumb, 'resize'));
$worker->addFunction("rotate", array($thumb, 'rotate'));
echo "Waiting for job...\n";
while ($worker->work()) {
if ($worker->returnCode() != GEARMAN_SUCCESS) {
echo "return_code: " . $worker->returnCode() . "\n";
Core::debug('gmworkerlog', "return_code: " . $worker->returnCode());
break;
}
}
set_include_path(implode(PATH_SEPARATOR, $paths));
//Autoloader
require_once 'Zend/Loader/Autoloader.php';
$loader = Zend_Loader_Autoloader::getInstance();
$loader->registerNamespace('App_');
$loader->registerNamespace('Zend_');
$loader->setFallbackAutoloader(TRUE);
//Require the environment file
require ROOT_PATH . '/application/configs/environment.php';
//Start the worker
echo sprintf("%s: internal_upload worker ready and waiting for tasks...\n", date('r'));
$worker = new GearmanWorker();
$worker->addServer();
$worker->addFunction('internal_upload', 'internal_upload');
while ($worker->work()) {
switch ($worker->returnCode()) {
case GEARMAN_SUCCESS:
break;
default:
echo sprintf("%s: Error ocurred: %s\n", date('r'), $worker->returnCode());
exit;
}
}
echo sprintf("%s: internal_upload worker finished\n");
/**
* Functions registered with the worker
*
* @param object $job
* @return void
*/
function internal_upload($job)
if (!array_key_exists('f', $options)) {
help(1);
}
if (!array_key_exists('H', $options)) {
$options['H'] = '127.0.0.1';
}
if (!array_key_exists('p', $options)) {
$options['p'] = 4730;
}
$function = $options['f'];
$dir = $options['d'];
$host = $options['H'];
$port = $options['p'];
if (!array_key_exists('s', $options)) {
$script = "{$function}.php";
} else {
$script = $options['s'];
}
$file = "{$dir}/{$script}";
require $file;
$worker = new \GearmanWorker();
log("Gearman worker running... press Ctrl-c to stop");
$worker->addServer($host, $port);
$worker->addFunction($function, __NAMESPACE__ . '\\work');
log("Listening for function: {$function}");
while ($worker->work()) {
if ($worker->returnCode() != GEARMAN_SUCCESS) {
log("return_code: ", $worker->returnCode());
break;
}
}
