/**
  * @return int exit code
  */
 public function listen()
 {
     $this->initConnection();
     /** @var Job $job */
     $job = $this->connection->watch($this->tube)->reserveFromTube($this->tube, $this->timeout);
     return $job;
 }
Пример #2
0
 /**
  * Start the worker.
  */
 public function startWorker()
 {
     $this->pheanstalk->watch($this->queue);
     $this->pheanstalk->ignore('default');
     $buildStore = Factory::getStore('Build');
     while ($this->run) {
         // Get a job from the queue:
         $job = $this->pheanstalk->reserve();
         $this->checkJobLimit();
         // Get the job data and run the job:
         $jobData = json_decode($job->getData(), true);
         if (!$this->verifyJob($job, $jobData)) {
             continue;
         }
         $this->logger->addInfo('Received build #' . $jobData['build_id'] . ' from Beanstalkd');
         // If the job comes with config data, reset our config and database connections
         // and then make sure we kill the worker afterwards:
         if (!empty($jobData['config'])) {
             $this->logger->addDebug('Using job-specific config.');
             $currentConfig = Config::getInstance()->getArray();
             $config = new Config($jobData['config']);
             Database::reset($config);
         }
         try {
             $build = BuildFactory::getBuildById($jobData['build_id']);
         } catch (\Exception $ex) {
             $this->logger->addWarning('Build #' . $jobData['build_id'] . ' does not exist in the database.');
             $this->pheanstalk->delete($job);
         }
         try {
             // Logging relevant to this build should be stored
             // against the build itself.
             $buildDbLog = new BuildDBLogHandler($build, Logger::INFO);
             $this->logger->pushHandler($buildDbLog);
             $builder = new Builder($build, $this->logger);
             $builder->execute();
             // After execution we no longer want to record the information
             // back to this specific build so the handler should be removed.
             $this->logger->popHandler($buildDbLog);
         } catch (\PDOException $ex) {
             // If we've caught a PDO Exception, it is probably not the fault of the build, but of a failed
             // connection or similar. Release the job and kill the worker.
             $this->run = false;
             $this->pheanstalk->release($job);
         } catch (\Exception $ex) {
             $build->setStatus(Build::STATUS_FAILED);
             $build->setFinished(new \DateTime());
             $build->setLog($build->getLog() . PHP_EOL . PHP_EOL . $ex->getMessage());
             $buildStore->save($build);
             $build->sendStatusPostback();
         }
         // Reset the config back to how it was prior to running this job:
         if (!empty($currentConfig)) {
             $config = new Config($currentConfig);
             Database::reset($config);
         }
         // Delete the job when we're done:
         $this->pheanstalk->delete($job);
     }
 }
Пример #3
0
 /**
  * Esegue il worker ad libitum
  *
  * @param string $tube
  * @return void
  */
 public function execute($tube)
 {
     $queue = new Pheanstalk($this->host);
     declare (ticks=1);
     $tube = !is_null($tube) ? QueueManager::resolveChannelName($tube) : null;
     $queue->watch($tube);
     pcntl_signal(SIGTERM, function ($signal) use($tube) {
         $this->shouldClose = true;
         if ((int) QueueManager::getTubeStats($tube, 'current-jobs-ready') === 0) {
             exit;
         }
     });
     while ($job = $queue->reserve()) {
         try {
             $this->log($job, "Starting Job...");
             $this->jobRunner->execute($job, $this->logger);
         } catch (\Exception $e) {
             $this->log($job, "Job Failed and Buried: " . $e->getMessage(), LoggerInterface::SEVERITY_ERROR);
             $queue->bury($job);
             continue;
         }
         $this->log($job, "Job Finished Succesfully");
         $queue->delete($job);
         $this->closeIfPossible();
     }
 }
 /**
  * @inheritdoc
  */
 public function purge($queue)
 {
     $stat = $this->beanstalk->statsTube($queue);
     $this->beanstalk->watch($queue);
     for ($i = 0; $i < $stat->current_jobs_ready; $i++) {
         $job = $this->beanstalk->peekReady();
         $this->beanstalk->delete($job);
     }
     for ($i = 0; $i < $stat->current_jobs_delayed; $i++) {
         $job = $this->beanstalk->peekDelayed();
         $this->beanstalk->delete($job);
     }
     for ($i = 0; $i < $stat->current_jobs_buried; $i++) {
         $job = $this->beanstalk->peekBuried();
         $this->beanstalk->delete($job);
     }
 }
Пример #5
0
 /**
  * Start the worker.
  */
 public function run()
 {
     // Set up pheanstalk:
     $this->pheanstalk->watch($this->queue);
     $this->pheanstalk->ignore('default');
     while ($this->run) {
         $beanstalkJob = $this->pheanstalk->reserve(900);
         $jobData = json_decode($beanstalkJob->getData(), true);
         // Delete invalid jobs:
         if (empty($jobData) || !is_array($jobData) || empty($jobData['type'])) {
             $this->pheanstalk->delete($beanstalkJob);
             continue;
         }
         $job = new Job($jobData);
         // Delete jobs we don't have handlers for:
         if (!array_key_exists($job->getType(), $this->handlers)) {
             $this->pheanstalk->delete($beanstalkJob);
             Manager::update($job, Job::STATUS_FAILURE, 'No handler exists for this job type.');
             continue;
         }
         // Try and load the job handler:
         $handlerClass = $this->handlers[$job->getType()]['handler'];
         try {
             $handler = new $handlerClass($job, $this);
             if (!$handler instanceof Handler) {
                 throw new \Exception('Job handler does not extend \\Octo\\Job\\Handler.');
             }
             Manager::update($job, Job::STATUS_RUNNING);
             // Try and run the job:
             $success = $handler->run();
         } catch (\Exception $ex) {
             $this->pheanstalk->delete($beanstalkJob);
             Manager::update($job, Job::STATUS_FAILURE, $ex->getMessage());
             continue;
         }
         Manager::update($job, $success ? Job::STATUS_SUCCESS : Job::STATUS_FAILURE, $handler->getMessage());
         // Remove the job when we're done:
         $this->pheanstalk->delete($beanstalkJob);
     }
 }
Пример #6
0
 /**
  * 获取队列数量
  *
  * @param string tube
  * @param Pheanstalk pheanstalk
  * @return string|boolean 
  */
 public function getJob($tube, Pheanstalk $pheanstalk)
 {
     if (!isset($this->jobs[$tube])) {
         return false;
     }
     $timeout = 3;
     $job = $pheanstalk->watch($tube)->reserve($timeout);
     if (empty($job) || !is_object($job) || $job->getId() == 0 || empty($job->getData())) {
         return false;
     }
     $data = ['job' => $job, 'handle' => $this->jobs[$tube]];
     return serialize($data);
 }
 /**
  * Test if BeanstalkdPublisher works as expected.
  */
 public function testLogging()
 {
     $container = $this->getContainer();
     $publisher = $container->get('ongr_task_messenger.publisher.default.beanstalkd');
     $logger = new NullLogger();
     $publisher->setLogger($logger);
     $task = new SyncTask(SyncTask::SYNC_TASK_PRESERVEHOST);
     $task->setName('task_foo');
     $task->setCommand('command_foo');
     $publisher->publish($task);
     $pheanstalk = new Pheanstalk($container->getParameter('ongr_task_messenger.publisher.default.beanstalkd.host'), $container->getParameter('ongr_task_messenger.publisher.default.beanstalkd.port'));
     $job = $pheanstalk->watch('general')->reserve();
     $jobData = json_decode($job->getData(), true);
     $this->assertEquals($jobData['task'], 'ongr.task.task_foo');
     $this->assertEquals($jobData['args'][0], 'command_foo -e test');
 }
Пример #8
0
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $workerManager = $serviceLocator->get(WorkerManager::class);
     $writer = new CsvStream('data/logs/daemon.' . date('Y-m-d') . '.csv');
     $writer->setFormatter(new Xml(['rootElement' => 'log']));
     $logger = new Logger();
     $logger->addWriter(new Stream(fopen('php://output', 'w')));
     $logger->addWriter($writer);
     $config = $serviceLocator->get('Config');
     $config = $config['zource_daemon'];
     $pheanstalk = new Pheanstalk($config['host'], $config['port'], $config['timeout']);
     foreach ($config['tubes'] as $tube) {
         $pheanstalk->watch($tube);
     }
     $pheanstalk->ignore('default');
     return new Daemon($pheanstalk, $workerManager, $logger, $config['lifetime'], $config['interval']);
 }
Пример #9
0
 /**
  * @inheritdoc
  */
 public function dequeue($queue)
 {
     $job = $this->beanstalk->watch($queue)->ignore('default')->reserve(static::TIMEOUT);
     $data = $job instanceof Job ? $job->getData() : $job;
     return [unserialize($data), $job];
 }
<?php

/**
 * This file describes a Pheanstalk worker
 */
require_once dirname(__FILE__) . "/vendor/autoload.php";
use Pheanstalk\Pheanstalk;
// Create a new connection to pheanstalk.
$pheanstalk = new Pheanstalk('127.0.0.1');
// Watch the test tube.
$pheanstalk->watch('test');
// While we can reserve a job...
while ($job = $pheanstalk->reserve()) {
    sleep(5);
    // Process the data and write it to STDOUT.
    $data = $job->getData();
    echo "{$data} \n";
    // Delete the job from the queue.
    $pheanstalk->delete($job);
    sleep(5);
    // If the message was 'kill', exit this loop.
    if ($data == 'kill') {
        break;
    }
}
Пример #11
0
<?php

require 'vendor/autoload.php';
use Pheanstalk\Pheanstalk;
$stalk = new Pheanstalk('127.0.0.1');
while (1) {
    $job = $stalk->watch('test')->ignore('default')->reserve();
    echo $job->getData();
    $stalk->delete($job);
}
Пример #12
0
 public function purge($queue)
 {
     while ($job = $this->beanstalkd->watch($queue)->ignore("default")->reserve(0)) {
         $this->beanstalkd->delete($job);
     }
 }
Пример #13
0
<?php

use Monolog\Handler\StreamHandler;
use Monolog\Logger;
use Pheanstalk\Pheanstalk;
require 'vendor/autoload.php';
date_default_timezone_set('Europe/Riga');
sleep(10);
$conn = new PDO('mysql:host=db;dbname=todo', 'root', 'root');
$pheanstalk = new Pheanstalk('beanstalkd');
$logger = new Monolog\Logger('worker');
$logger->pushHandler(new StreamHandler('php://stdout', Logger::INFO));
$tubeName = 'todotube';
$pheanstalk->watch($tubeName);
$logger->addInfo('Started to watch tube ' . $tubeName);
$stmt = $conn->prepare('INSERT INTO Todo (text, status, created_at, updated_at) VALUES (?, ?, ?, ?)');
while ($job = $pheanstalk->ignore('default')->reserve()) {
    $data = json_decode($job->getData(), true);
    $logger->addInfo('Got data', $data);
    $stmt->execute([$data['text'], $data['status'], $data['created_at'], '1999-12-12 12:12:12']);
    $logger->addInfo('Successfully inserted!');
    $pheanstalk->delete($job);
}
Пример #14
0
 public function getNext()
 {
     $this->beanStalkdClient->watch($this->sourceQueue);
     return $this->beanStalkdClient->reserve(0);
 }