/**
* @return Queue[]
*/
public function queues()
{
$queues = \array_map(function ($queue) {
return new Queue($queue);
}, $this->worker->queues());
return $queues;
}
private function work()
{
$worker = new \Resque_Worker(explode(',', $this->queue));
$worker->logLevel = $this->loglevel();
$worker->work($this->checker_interval);
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
}
/**
* @test
*/
public function it_sends_remove_file_command_to_file_remover_via_php_resque()
{
$this->assertTrue(file_exists($this->testFile));
$commandBus = new CommandBus();
$commandRouter = new CommandRouter();
$messageDispatcher = new MessageDispatcher(['track_job_status' => true, 'queue' => 'php-resque-test-queue']);
$commandRouter->route('Prooph\\ServiceBusTest\\Mock\\RemoveFileCommand')->to($messageDispatcher);
$commandBus->utilize($commandRouter);
$commandBus->utilize(new ForwardToRemoteMessageDispatcherStrategy(new ProophDomainMessageToRemoteMessageTranslator()));
$jobId = null;
$messageDispatcher->events()->attach('dispatch.post', function (EventInterface $e) use(&$jobId) {
$jobId = $e->getParam('jobId');
});
$removeFile = RemoveFileCommand::fromPayload($this->testFile);
$commandBus->dispatch($removeFile);
$this->assertNotNull($jobId);
$status = new \Resque_Job_Status($jobId);
$this->assertEquals(\Resque_Job_Status::STATUS_WAITING, $status->get());
$worker = new \Resque_Worker(array('php-resque-test-queue'));
$worker->logLevel = 1;
$worker->work(0);
$worker->shutdown();
$this->assertEquals(\Resque_Job_Status::STATUS_COMPLETE, $status->get());
$this->assertFalse(file_exists($this->testFile));
}
function startWorker($QUEUE, $logLevel, $logger, $interval)
{
$queues = explode(',', $QUEUE);
$worker = new Resque_Worker($queues);
$worker->registerLogger($logger);
$worker->logLevel = $logLevel;
$worker->work($interval);
}
/**
* 启动消息列队处理器
* @return void
*/
public function actionStart()
{
$mypidFilePath = Yii::getAlias('@runtime/resque/mypid');
FileHelper::createDirectory(dirname($mypidFilePath));
file_put_contents($mypidFilePath, getmypid()) or die('Could not write PID information to ' . $PIDFILE);
$worker = new \Resque_Worker('default');
$worker->logLevel = \Resque_Worker::LOG_VERBOSE;
$worker->work(5);
}
public function getCurrentJob()
{
$job = $this->worker->job();
if (!$job) {
return null;
}
$job = new \Resque_Job($job['queue'], $job['payload']);
return $job->getInstance();
}
private function work()
{
$worker = new \Resque_Worker(explode(',', $this->queue));
if ($this->logger instanceof LoggerInterface) {
$worker->setLogger($this->logger);
}
if (method_exists($worker, 'setStayAlive')) {
$worker->setStayAlive($this->stayAlive);
}
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
$worker->work($this->checker_interval, $this->blocking);
}
public function testRecreatedJobWithTrackingStillTracksStatus()
{
$originalToken = Resque::enqueue('jobs', 'Test_Job', null, true);
$job = $this->worker->reserve();
// Mark this job as being worked on to ensure that the new status is still
// waiting.
$this->worker->workingOn($job);
// Now recreate it
$newToken = $job->recreate();
// Make sure we've got a new job returned
$this->assertNotEquals($originalToken, $newToken);
// Now check the status of the new job
$newJob = Resque_Job::reserve('jobs');
$this->assertEquals(Resque_Job_Status::STATUS_WAITING, $newJob->getStatus());
}
protected function execute(InputInterface $input, OutputInterface $output)
{
if ($input->getOption('all')) {
$workers = \Resque_Worker::all();
} else {
$worker = \Resque_Worker::find($input->getArgument('id'));
if (!$worker) {
$availableWorkers = \Resque_Worker::all();
if (!empty($availableWorkers)) {
throw new \RuntimeException('A running worker must be specified');
}
}
$workers = $worker ? array($worker) : array();
}
if (count($workers) <= 0) {
$output->writeln(array('No workers running', ''));
return;
}
$signal = $input->getOption('force') ? SIGTERM : SIGQUIT;
foreach ($workers as $worker) {
$output->writeln(sprintf('%s %s...', $signal === SIGTERM ? 'Force stopping' : 'Stopping', $worker));
list(, $pid) = explode(':', (string) $worker);
posix_kill($pid, $signal);
}
$output->writeln('');
}
/**
* @param array|string $options
* @param LoopInterface $loop
*
*/
public function __construct($options, LoopInterface $loop = null)
{
$this->options = $options;
if ($loop !== null) {
$this->loop = $loop;
Resque::setEventLoop($loop);
}
parent::__construct($options['queue']);
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$workers = \Resque_Worker::all();
if (count($workers) <= 0) {
$output->writeln(array('No workers running', ''));
return 0;
}
$queueFilter = $input->getArgument('queue');
if ('*' === $queueFilter) {
$queueFilter = false;
}
$workerOutput = array();
$longestName = 0;
foreach ($workers as $worker) {
$queues = $worker->queues(true) ?: array('*');
if ($queueFilter) {
if (!in_array('*', $queues) && !in_array($queueFilter, $queues)) {
continue;
}
}
$name = (string) $worker;
$job = ($job = $worker->job()) ? 'Processing ' . json_encode($job) : 'Waiting for job';
if (strlen($job) > 20) {
$job = substr($job, 0, 20) . '...';
}
$workerOutput[] = array($name, $job);
if (($thisLength = strlen($name)) > $longestName) {
$longestName = $thisLength;
}
}
$output->writeln(sprintf('%-' . $longestName . "s\t%s", 'Worker ID', 'Current Job'));
$loopFormat = '%-' . $longestName . "s\t<info>%s</info>";
foreach ($workerOutput as $worker) {
$output->writeln(sprintf($loopFormat, $worker[0], $worker[1]));
}
$output->writeln('');
}
public function doneWorking()
{
$job = $this->job();
sfResque::remove_track_queue($job['queue'], sfResque::tokenize($job['payload']['class'], $job['payload']['args']));
return parent::doneWorking();
}
// pcntl_fork — 在当前进程当前位置产生分支（子进程）
// fork是创建了一个子进程，父进程和子进程 都从fork的位置开始向下继续执行，不同的是父进程执行过程中，得到的fork返回值为子进程号，而子进程得到的是0。
$pid = pcntl_fork();
if ($pid == -1) {
die("Could not fork worker " . $i . "\n");
} else {
if (!$pid) {
// 如果是子进程，$pid为0
$queues = explode(',', $QUEUE);
$worker = new Resque_Worker($queues);
$worker->logLevel = $logLevel;
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
$worker->work($interval);
break;
}
}
}
} else {
$queues = explode(',', $QUEUE);
$worker = new Resque_Worker($queues);
$worker->logLevel = $logLevel;
// PIDFILE表示要存放PHP进程ID的文件
$PIDFILE = getenv('PIDFILE');
if ($PIDFILE) {
// getmypid — 获取 PHP 进程的 ID
// 将进程的ID写入PIDFILE中
file_put_contents($PIDFILE, getmypid()) or die('Could not write PID information to ' . $PIDFILE);
}
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
$worker->work($interval);
}
public function testBlockingListPop()
{
$worker = new Resque_Worker('jobs');
$worker->setLogger(new Resque_Log());
$worker->registerWorker();
Resque::enqueue('jobs', 'Test_Job_1');
Resque::enqueue('jobs', 'Test_Job_2');
$i = 1;
while ($job = $worker->reserve(true, 1)) {
$this->assertEquals('Test_Job_' . $i, $job->payload['class']);
if ($i == 2) {
break;
}
$i++;
}
$this->assertEquals(2, $i);
}
<?php
/**
* file TestWorker-resque.php
* ------------------------------------------ +
* @abstract 示例 for 测试队列Workers
* use to 监听接收QUEUE-Test
* @date 2015/12
* @Usage:
* ------------------------------------------ +
*/
require realpath(dirname(__FILE__) . "/../MsgQueue.php");
# 改为要监听的队列名
$QueueName = "QUEUE-Test";
$interval = 1;
$INTERVAL = getenv('INTERVAL');
if (!empty($INTERVAL)) {
$interval = $INTERVAL;
}
$worker = new \Resque_Worker($QueueName);
fwrite(STDOUT, 'Starting worker Listening ' . $worker . "\n");
$worker->work($interval, FALSE);
public function pruneDeadWorkers()
{
// HACK, prune dead workers, just in case
$worker = new \Resque_Worker('temp');
$worker->setLogger(new NullLogger());
$worker->pruneDeadWorkers();
}
/**
* Returns the number of connected Redis workers
*
* @return int
*/
public static function RedisWorkersCount()
{
return count(Resque_Worker::all());
}
/**
* Constructor.
*/
public function __construct($queues, $workerPid, $hostname = 'host')
{
parent::__construct($queues);
$this->hostname = $hostname;
$this->id = $hostname . ':' . (string) $workerPid . ':' . implode(',', $this->queues);
}
/**
* Print some stats about the workers
*/
protected function stats()
{
$this->outputTitle('Workers statistics');
$this->output->outputLine();
$this->output->outputLine('Jobs Stats', 'subtitle');
$this->output->outputLine(" Processed Jobs : " . \Resque_Stat::get('processed'));
$this->output->outputLine(" Failed Jobs : " . \Resque_Stat::get('failed'), 'failure');
$this->output->outputLine();
$this->output->outputLine('Workers Stats', 'subtitle');
$workers = \Resque_Worker::all();
$this->output->outputLine(" Active Workers : " . count($workers));
if (!empty($workers)) {
foreach ($workers as $worker) {
$this->output->outputLine(" Worker : " . $worker, 'bold');
$this->output->outputLine(" - Started on : " . \Resque::Redis()->get('worker:' . $worker . ':started'));
$this->output->outputLine(" - Uptime : " . $this->formatDateDiff(new \DateTime(\Resque::Redis()->get('worker:' . $worker . ':started'))));
$this->output->outputLine(" - Processed Jobs : " . $worker->getStat('processed'));
$worker->getStat('failed') == 0 ? $this->output->outputLine(" - Failed Jobs : " . $worker->getStat('failed')) : $this->output->outputLine(" - Failed Jobs : " . $worker->getStat('failed'), 'failure');
}
}
$this->output->outputLine("\n");
}
if ($count > 1) {
for ($i = 0; $i < $count; ++$i) {
$pid = pcntl_fork();
if ($pid == -1) {
die("Could not fork worker " . $i . "\n");
} else {
if (!$pid) {
$queues = explode(',', $QUEUE);
$worker = new Resque_Worker($queues);
$worker->logLevel = $logLevel;
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
$worker->work($interval);
break;
}
}
}
} else {
$queues = explode(',', $QUEUE);
$worker = new Resque_Worker($queues);
$worker->logLevel = $logLevel;
$PIDFILE = getenv('PIDFILE');
if ($PIDFILE) {
file_put_contents($PIDFILE, getmypid()) or die('Could not write PID information to ' . $PIDFILE);
}
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
if ($MULTI == "true") {
$worker->work($interval, TRUE);
} else {
$worker->work($interval);
}
}
public function testWorkerFailsUncompletedJobsOnExit()
{
$worker = new Resque_Worker('jobs');
$worker->registerWorker();
$payload = array('class' => 'Test_Job');
$job = new Resque_Job('jobs', $payload);
$worker->workingOn($job);
$worker->unregisterWorker();
$this->assertEquals(1, Resque_Stat::get('failed'));
}
/**
* Start a single worker
*
* @param bool $isForked - is this worker forked
*/
protected function startWorker($isForked = false)
{
$queues = explode(',', $this->queue);
$worker = new Resque_Worker($queues);
$worker->setLogger($this->logger);
if (!$isForked) {
$PIDFILE = getenv('PIDFILE');
if ($PIDFILE) {
file_put_contents($PIDFILE, getmypid()) or die('Could not write PID information to ' . $PIDFILE);
}
}
fwrite(STDOUT, '[+] Starting worker ' . $worker . " " . $this->interval . PHP_EOL);
$worker->work($this->interval);
}
public function workers(Request $request, Response $response, array $args)
{
$data = [];
$settings = loadsettings();
$REDIS_BACKEND = $settings['resque']['REDIS_BACKEND'];
if (!empty($REDIS_BACKEND)) {
\Resque::setBackend($REDIS_BACKEND);
}
$workerlist = \Resque_Worker::all();
$workers = [];
foreach ($workerlist as $worker) {
$job = $worker->job();
if (empty($job)) {
$job = "Idle";
}
$workers[] = ['name' => (string) $worker, 'job' => $job];
}
$data['workers'] = $workers;
$this->view->render($response, 'workers.twig', $data);
return $response;
}
/**
* Return a list of workers
*
* @return array of workers
*/
public function getWorkers()
{
return (array) \Resque_Worker::all();
}
/**
* @todo - Clean this up, for now, prune dead workers, just in case
*/
public function pruneDeadWorkers()
{
$worker = new \Resque_Worker('temp');
$worker->setLogger(new NullLogger());
$worker->pruneDeadWorkers();
}
public function actionRun()
{
$QUEUE = getenv('QUEUE');
if (empty($QUEUE)) {
die("Set QUEUE env var containing the list of queues to work.\n");
}
$REDIS_BACKEND = getenv('REDIS_BACKEND');
if (!empty($REDIS_BACKEND)) {
\Resque::setBackend($REDIS_BACKEND);
}
$logLevel = 0;
$LOGGING = getenv('LOGGING');
$VERBOSE = getenv('VERBOSE');
$VVERBOSE = getenv('VVERBOSE');
if (!empty($LOGGING) || !empty($VERBOSE)) {
$logLevel = \Resque_Worker::LOG_NORMAL;
} else {
if (!empty($VVERBOSE)) {
$logLevel = \Resque_Worker::LOG_VERBOSE;
}
}
$APP_INCLUDE = getenv('APP_INCLUDE');
if ($APP_INCLUDE) {
if (!file_exists($APP_INCLUDE)) {
die('APP_INCLUDE (' . $APP_INCLUDE . ") does not exist.\n");
}
require_once $APP_INCLUDE;
}
$interval = 5;
$INTERVAL = getenv('INTERVAL');
if (!empty($INTERVAL)) {
$interval = $INTERVAL;
}
$count = 1;
$COUNT = getenv('COUNT');
if (!empty($COUNT) && $COUNT > 1) {
$count = $COUNT;
}
if ($count > 1) {
for ($i = 0; $i < $count; ++$i) {
$pid = pcntl_fork();
if ($pid == -1) {
die("Could not fork worker " . $i . "\n");
} else {
if (!$pid) {
$queues = explode(',', $QUEUE);
$worker = new \Resque_Worker($queues);
$worker->logLevel = $logLevel;
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
$worker->work($interval);
break;
}
}
}
} else {
$queues = explode(',', $QUEUE);
$worker = new \Resque_Worker($queues);
$worker->logLevel = $logLevel;
$PIDFILE = getenv('PIDFILE');
if ($PIDFILE) {
file_put_contents($PIDFILE, getmypid()) or die('Could not write PID information to ' . $PIDFILE);
}
fwrite(STDOUT, '*** Starting worker ' . $worker . "\n");
$worker->work($interval);
}
}
public function testWorkerLogWithISOTime()
{
$worker = new Resque_Worker('jobs');
$worker->logLevel = Resque_Worker::LOG_NORMAL;
$worker->logOutput = fopen('php://memory', 'r+');
$message = array('message' => 'x', 'data' => '');
$now = date('c');
$this->assertEquals(true, $worker->log($message, Resque_Worker::LOG_TYPE_INFO));
rewind($worker->logOutput);
$output = stream_get_contents($worker->logOutput);
$lines = explode("\n", $output);
$this->assertEquals(1, count($lines) - 1);
$this->assertEquals('[' . $now . '] x', $lines[0]);
}
/**
* Schedule a worker for shutdown. Will finish processing the current job
* and when the timeout interval is reached, the worker will shut down.
*/
public function shutdown()
{
parent::shutdown();
$this->getEventManager()->trigger('Zf2Resque.shutdown', null, array());
}
