public function init()
 {
     // Only use gearman implementation when WP_GEARS is defined and true
     if (!defined('WP_GEARS') || !WP_GEARS) {
         return false;
     }
     global $gearman_servers;
     if (!class_exists('GearmanClient') || !class_exists('GearmanWorker')) {
         return false;
     }
     if (defined('DOING_ASYNC') && DOING_ASYNC) {
         $this->_worker = new GearmanWorker();
         $this->_client = new GearmanClient();
         if (empty($gearman_servers)) {
             $this->_client->addServer();
             return $this->_worker->addServer();
         } else {
             $this->_client->addServers(implode(',', $gearman_servers));
             return $this->_worker->addServers(implode(',', $gearman_servers));
         }
     } else {
         $this->_client = new GearmanClient();
         if (empty($gearman_servers)) {
             $this->_client->addServer();
         } else {
             $this->_client->addServers(implode(',', $gearman_servers));
         }
         // Supressing errors, because this will return true or false, depending on if we could connect & communicate
         return @$this->_client->ping('test');
     }
 }
 /**
  * Get the GearmanWorker instance
  * 
  * @return GearmanWorker
  */
 public function getWorkerConnection()
 {
     //we have a stored connection
     if (!$this->_gmWorker) {
         //Get the config, start the client object
         $_config = $this->_getConfiguration();
         $this->_gmWorker = new GearmanWorker();
         //add the servers to the client
         foreach ($_config as $_server) {
             $this->_gmWorker->addServer($_server['host'], $_server['port']);
         }
     }
     return $this->_gmWorker;
 }
Beispiel #3
0
 public function work()
 {
     $config = $this->config->item('base_config');
     $host = $config['gearman']['host'];
     $port = $config['gearman']['port'];
     $worker = new GearmanWorker();
     $worker->addServer($host, $port);
     function send_request($job)
     {
         var_dump("scorpio");
         include_once APPPATH . 'third_party/snoopy.php';
         $snoopy = new Snoopy();
         $data = json_decode($job->workload());
         $method = $data->method;
         $url = $data->url;
         $params = $data->params;
         ${$method} = array();
         foreach ($params as $key => $value) {
             ${$method}[$key] = $value;
         }
         $snoopy->submit($url, ${$method});
         $result = $snoopy->results;
         return $result;
     }
     $worker->addFunction("send_request", "send_request");
     while ($worker->work()) {
     }
 }
 /**
  * 实现单例模式
  *
  * @param   array   $config
  * @return  GearmanWorker
  */
 public static function getWorker($config)
 {
     $client = new GearmanWorker();
     foreach ($config as $serverInfo) {
         $client->addServer($serverInfo['host'], $serverInfo['port']);
     }
     return $client;
 }
Beispiel #5
0
 public function indexAction()
 {
     $config = App::instance()->config;
     $worker = new GearmanWorker();
     $worker->addServer($config['gearman']['host'], $config['gearman']['port']);
     $worker->addFunction('delete_keys', array($this, 'deleteKeys'));
     $worker->addFunction('move_keys', array($this, 'moveKeys'));
     while ($worker->work()) {
     }
 }
 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;
 }
 /**
  * Get GearmanWorker object.
  * @param string $queueName Queue name
  * @return \GearmanWorker
  */
 protected function getWorker($queueName)
 {
     if (!isset($this->workers[$queueName])) {
         $worker = new \GearmanWorker();
         foreach ($this->servers as $server) {
             $worker->addServer($server);
         }
         $worker->addFunction($queueName, array($this, 'work'));
         $this->workers[$queueName] = $worker;
     }
     return $this->workers[$queueName];
 }
Beispiel #8
0
 public static function executeBgTasks()
 {
     $files = scandir(self::$uploads_dir);
     unset($files[0]);
     unset($files[1]);
     $jobs = array_values($files);
     foreach ($jobs as $key => $singleJob) {
         $worker = new GearmanWorker();
         $worker->addServer();
         $worker->addFunction('q' . $key, array(new MyClass(new GearmanJob()), 'csvHandler'));
         $worker->work();
     }
 }
 public function actionIndex()
 {
     $worker = new GearmanWorker();
     $worker->addServer("219.232.243.98");
     $worker->addFunction("sendMessage", function (GearmanJob $job) {
         $workload = json_decode($job->workload(), true);
         $phones = $workload['phones'];
         $content = $workload['content'];
         Yii::app()->smsClient->sendMessage($phones, $content);
         return true;
     });
     while ($worker->work()) {
     }
 }
 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;
         }
     }
 }
Beispiel #11
0
 public function run()
 {
     try {
         $gserver = $this->_configuration->gearman->server;
         $gport = $this->_configuration->gearman->port;
         $worker = new GearmanWorker();
         $worker->addServer($gserver, $gport);
         $jobs = $this->_configuration->job;
         $worker->addFunction($jobs->sync_search, array($this, "syncSearch"));
         while ($worker->work()) {
         }
     } catch (Exception $ex) {
         Log::dumpLog("Uncaught exception: " . $ex->getMessage(), Log::ERR);
     }
 }
Beispiel #12
0
 /**
  * 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 actionSendPasswordEmail()
    {
        $worker = new GearmanWorker();
        $worker->addServer();
        $worker->addFunction("sendPasswordEmail", function (GearmanJob $job) {
            $workload = json_decode($job->workload(), true);
            $addresses = $workload['email'];
            $id = $workload['id'];
            $token = $workload['token'];
            Yii::log(json_encode(array('token' => $token)), 'info');
            $host = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : 'union.zhantai.com';
            $link = "http://{$host}/admin/login/setPassword/id/{$id}/token/{$token}";
            $message = <<<EOT
            <p><b>亲爱的用户您好!</b></p>
            <p>这是一封铭智华通广告联盟密码设置邮件,<a target="_blank" href="{$link}">点击设置密码</a></p>
            <p>如果上述文字点击无效,请把下面网页地址复制到浏览器地址栏中打开:</p>
            <p><a target="_blank" href="{$link}">{$link}</a></p>
EOT;
            $subject = '铭智广告联盟密码设置邮件';
            return Yii::app()->mailer->send($addresses, $subject, $message);
        });
        while ($worker->work()) {
        }
    }
Beispiel #14
0
 /**
  * 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->addServer($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;
         }
     }
     $thisWorker->unregisterAll();
 }
Beispiel #15
0
	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;
			}
		}
	}
Beispiel #16
0
<?php

$base = preg_replace('|' . basename(dirname(__FILE__)) . '$|', '', dirname(__FILE__));
include_once $base . 'lib/config.php';
include_once $base . 'App.php';
$worker = new GearmanWorker();
$worker->addServer();
$worker->addFunction("change_theme", "change_theme");
while ($worker->work()) {
}
function change_theme($job)
{
    $json = $job->workload();
    $data = json_decode($json, true);
    $app = new App($data['token']);
    $app->themeWorker($data);
}
?>
 
<?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";
}
#!/usr/bin/env php
<?php 
// Set time limit for run length
$timeStarted = time();
$timeRunLimit = 1200;
// Setup Gearman
$worker = new GearmanWorker();
$worker->addServer('127.0.0.1');
$worker->addFunction("reverse", "reverse_fn");
while (1) {
    print "Waiting for job...\n";
    $ret = $worker->work();
    if ($worker->returnCode() != GEARMAN_SUCCESS) {
        break;
    }
    // Enforce run time limit
    if (time() - $timeStarted > $timeRunLimit) {
        exit;
    }
}
// Functions registered
function reverse_fn($job)
{
    $workload = $job->workload();
    echo "Received job: " . $job->handle() . "\n";
    echo "Workload: {$workload}\n";
    $result = strrev($workload);
    for ($i = 1; $i <= 10; $i++) {
        $job->sendStatus($i, 10);
        sleep(1);
    }
Beispiel #19
0
/**
 * 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";
    }
}
Beispiel #20
0
# Licensed under the Apache License, Version 2.0 (the "License");
#    you may not use this file except in compliance with the License.
#    You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#      distributed under the License is distributed on an "AS IS" BASIS,
#      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#
# Create our worker object.
$worker = new GearmanWorker();
# Add default server (localhost).
$worker->addServer('localhost', 4730);
# Register function "reverse" with the server.
$worker->addFunction("shell_execute", "shell_execute");
$options = getopt("P:");
$pid = getmypid();
file_put_contents($options['P'], $pid);
while (1) {
    #  print "Waiting for job...\n";
    $ret = $worker->work();
    if ($worker->returnCode() != GEARMAN_SUCCESS) {
        break;
    }
}
# A much simple reverse function
function shell_execute($job)
{
Beispiel #21
0
 /**
  * @param string $ip
  * @param int $port
  */
 public function addServer($ip, $port)
 {
     $this->logger->info("Adding Gearman server {$ip}:{$port}.");
     $this->gearman->addServer($ip, $port);
 }
Beispiel #22
0
$basedir = "/comic/bengou/";
$paths = array("115.28.51.131" => "/ts2/comic/bengou/");
$ips = get_network_interface();
foreach ($ips as $net) {
    if (array_key_exists($net["ip"], $paths)) {
        $basedir = $paths[$net["ip"]];
        break;
    }
}
print_r("IP: {$ip}\n");
print_r("DIR: {$basedir}\n");
$failedCount = 0;
$client = new GearmanClient();
$client->addServer("115.28.54.237", 4730);
$worker = new GearmanWorker();
$worker->addServer('115.28.54.237', 4730);
$worker->addFunction('comic-bengou', 'DownloadBengou');
//	$worker->addFunction('comic-imanhua', 'DownloadImanhua');
while ($worker->work()) {
}
function DownloadBengou($job)
{
    $args = $job->workload();
    list($bookid, $chapterid) = explode(",", $args);
    //$bookid = "4182";
    //$chapterid = 0005012703;
    return Action(CBenGou::$siteid, $bookid, intval($chapterid));
}
function Action($siteid, $bookid, $chapterid)
{
    global $basedir;
Beispiel #23
0
<?php

$worker = new GearmanWorker();
$worker->addServer('127.0.0.1', 4730);
$worker->addFunction('test1', 'test1');
$worker->addFunction('test2', 'test2');
// infinite loop
while ($worker->work()) {
}
function test1()
{
}
function test2()
{
}
Beispiel #24
0
#!/usr/bin/env php
<?php 
require_once __DIR__ . '/config.php';
$worker = new GearmanWorker();
$worker->addServer(GEARMAN_SERVER_IP);
$socket = null;
$worker->addFunction('atoum', function (GearmanJob $job) {
    $workload = $job->workload();
    echo 'Received job: ' . $job->handle() . PHP_EOL;
    echo 'Workload: ' . $workload . PHP_EOL;
    $pipes = array();
    $proc = proc_open('vendor/bin/atoum -ft -d ' . 'tests/', array(0 => array("pipe", "r"), 1 => array("pipe", "w"), 2 => array("pipe", "w")), $pipes, __DIR__ . '/../3284862/');
    stream_set_blocking($pipes[1], 0);
    $read = array($pipes[1]);
    $write = array($pipes[1]);
    $expect = array($pipes[1]);
    $status = proc_get_status($proc);
    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;
 /**
  * Adds into worker all defined Servers.
  * If any is defined, performs default method
  *
  * @param \GearmanWorker $gmworker Worker to perform configuration
  * @param array          $servers  Servers array
  *
  * @throws ServerConnectionException if a connection to a server was not possible.
  *
  * @return array         Successfully added servers
  */
 private function addServers(\GearmanWorker $gmworker, array $servers)
 {
     $successes = array();
     if (!empty($servers)) {
         foreach ($servers as $server) {
             //We need to use try/catch here to handle case when the server is down
             try {
                 //before addServer check if server is available
                 if (TCPHelper::tryConnection($server['host'], $server['port'])) {
                     if (@$gmworker->addServer($server['host'], $server['port'])) {
                         $successes[] = $server;
                     }
                 }
             } catch (\GearmanException $e) {
             }
         }
     } else {
         if (@$gmworker->addServer()) {
             $successes[] = array('127.0.0.1', 4730);
         }
     }
     return $successes;
 }
 /**
  * Adds into worker all defined Servers.
  * If any is defined, performs default method
  *
  * @param \GearmanWorker $gmworker Worker to perform configuration
  * @param array          $servers  Servers array
  *
  * @throws ServerConnectionException if a connection to a server was not possible.
  *
  * @return array         Successfully added servers
  */
 private function addServers(\GearmanWorker $gmworker, array $servers)
 {
     $successes = array();
     if (!empty($servers)) {
         foreach ($servers as $server) {
             if (@$gmworker->addServer($server['host'], $server['port'])) {
                 $successes[] = $server;
             }
         }
     } else {
         if (@$gmworker->addServer()) {
             $successes[] = array('127.0.0.1', 4730);
         }
     }
     return $successes;
 }
Beispiel #27
0
 /**
  * Configuration application default DI
  *
  * @return FactoryDefault| CLI
  */
 public function getDI()
 {
     if ($this->di) {
         return $this->di;
     }
     if ($this->appMode == 'cli') {
         $di = new FactoryDefault\CLI();
     } else {
         $di = new FactoryDefault();
     }
     //PHP5.3 not support $this in closure
     $self = $this;
     /**********************************
      * DI initialize for MVC core
      ***********************************/
     //$di->set('application', $this);
     //call loadmodules will overwrite this
     $di->set('moduleManager', function () use($di) {
         $moduleManager = new ModuleManager();
         $moduleManager->setEventsManager($di->getEventsManager());
         return $moduleManager;
     }, true);
     //System global events manager
     $di->set('eventsManager', function () use($di) {
         $eventsManager = new EventsManager();
         $eventsManager->enablePriorities(true);
         // dispatch caching event handler
         $eventsManager->attach("dispatch", new DispatchInterceptor(), -1);
         $eventsManager->enablePriorities(true);
         return $eventsManager;
     }, true);
     $di->set('config', function () use($self) {
         return $self->diConfig();
     }, true);
     $di->set('router', function () use($self) {
         return $self->diRouter();
     }, true);
     $di->set('dispatcher', function () use($di) {
         $dispatcher = new Dispatcher();
         $dispatcher->setEventsManager($di->getEventsManager());
         return $dispatcher;
     }, true);
     $di->set('modelsMetadata', function () use($self) {
         return $self->diModelsMetadata();
     }, true);
     $di->set('modelsManager', function () use($di) {
         $config = $di->getConfig();
         ModelManager::setDefaultPrefix($config->dbAdapter->prefix);
         //for solving db master/slave under static find method
         $modelsManager = new ModelManager();
         return $modelsManager;
     });
     $di->set('view', function () use($di) {
         $view = new View();
         $view->setViewsDir(__DIR__ . '/views/');
         $view->setEventsManager($di->getEventsManager());
         return $view;
     });
     $di->set('session', function () use($self) {
         return $self->diSession();
     });
     $di->set('tokenStorage', function () use($self) {
         return $self->diTokenStorage();
     }, true);
     /**********************************
      * DI initialize for database
      ***********************************/
     $di->set('dbMaster', function () use($self) {
         return $self->diDbMaster();
     }, true);
     $di->set('dbSlave', function () use($self) {
         return $self->diDbSlave();
     }, true);
     $di->set('transactions', function () use($di) {
         $transactions = new \Phalcon\Mvc\Model\Transaction\Manager();
         $transactions->setDbService('dbMaster');
         return $transactions;
     }, true);
     /**********************************
      * DI initialize for cache
      ***********************************/
     $di->set('globalCache', function () use($self) {
         return $self->diGlobalCache();
     }, true);
     $di->set('viewCache', function () use($self) {
         return $self->diViewCache();
     }, true);
     $di->set('modelsCache', function () use($self) {
         return $self->diModelsCache();
     }, true);
     $di->set('apiCache', function () use($self) {
         return $self->diApiCache();
     }, true);
     $di->set('fastCache', function () use($self) {
         return $self->diFastCache();
     }, true);
     /**********************************
      * DI initialize for queue
      ***********************************/
     $di->set('queue', function () use($di) {
         $config = $di->getConfig();
         $client = new \GearmanClient();
         $client->setTimeout(1000);
         foreach ($config->queue->servers as $key => $server) {
             $client->addServer($server->host, $server->port);
         }
         return $client;
     }, true);
     $di->set('worker', function () use($di) {
         $config = $di->getConfig();
         $worker = new \GearmanWorker();
         foreach ($config->queue->servers as $key => $server) {
             $worker->addServer($server->host, $server->port);
         }
         return $worker;
     }, true);
     /**********************************
      * DI initialize for email
      ***********************************/
     $di->set('mailer', function () use($self) {
         return $self->diMailer();
     }, true);
     $di->set('mailMessage', 'Eva\\EvaEngine\\MailMessage');
     $di->set('smsSender', function () use($self) {
         return $self->diSmsSender();
     }, true);
     /**********************************
      * DI initialize for helpers
      ***********************************/
     $di->set('url', function () use($di) {
         $config = $di->getConfig();
         $url = new UrlResolver();
         $url->setVersionFile($config->staticBaseUriVersionFile);
         $url->setBaseUri($config->baseUri);
         $url->setStaticBaseUri($config->staticBaseUri);
         return $url;
     }, true);
     $di->set('escaper', 'Phalcon\\Escaper');
     $di->set('tag', function () use($di, $self) {
         Tag::setDi($di);
         $self->registerViewHelpers();
         return new Tag();
     });
     $di->set('flash', 'Phalcon\\Flash\\Session');
     $di->set('placeholder', 'Eva\\EvaEngine\\View\\Helper\\Placeholder');
     $di->set('cookies', function () {
         $cookies = new \Phalcon\Http\Response\Cookies();
         $cookies->useEncryption(false);
         return $cookies;
     });
     $di->set('translate', function () use($self) {
         return $self->diTranslate();
     });
     $di->set('fileSystem', function () use($self) {
         return $self->diFileSystem();
     });
     $di->set('logException', function () use($di) {
         $config = $di->getConfig();
         return new FileLogger($config->logger->path . 'error.log');
     });
     if ($this->appMode == 'cli') {
         $this->cliDI($di);
     }
     IoC::setDI($di);
     return $this->di = $di;
 }
Beispiel #28
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);
}
Beispiel #29
0
<?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;
}
Beispiel #30
0
<?php

/**
 * This script demonstrates the unintuitive behavior of the Gearman
 * library when it comes to servicing jobs of different priorities.
 *
 * We'll use the same script as both the client and the worker for
 * convenience.
 */
// Create our worker
$worker = new \GearmanWorker();
$worker->addServer('192.168.133.72', 4730);
// Create our client
$client = new \GearmanClient();
$client->addServer('192.168.133.72', 4730);
// Service "foo" jobs by displaying "foo"
$worker->addFunction('foo', function (\GearmanJob $job) {
    echo "foo\n";
});
// Service "bar" jobs by displaying "bar"
$worker->addFunction('bar', function (\GearmanJob $job) {
    echo "bar\n";
});
// Add 25 LOW priority "foo" jobs to the queue.
for ($i = 0; $i < 25; $i++) {
    $client->doLowBackground('foo', '{}');
}
// Add 1 HIGH priority "bar" job to the queue.
$client->doHighBackground('bar', '{}');
/**
 * Running ->work() will service the pending jobs.