PHP Resque::redis方法代码示例

	public static function setBackend($server)
	{
		list($host, $port) = explode(':', $server);

		require_once dirname(__FILE__).'/Resque/Redis.php';
		self::$redis = new Resque_Redis($host, $port);
	}

 /**
  * Return an instance of the Resque_Redis class instantiated for Resque.
  *
  * @return Resque_Redis Instance of Resque_Redis.
  */
 public static function redis()
 {
     // Detect when the PID of the current process has changed (from a fork, etc)
     // and force a reconnect to redis.
     $pid = getmypid();
     if (self::$pid !== $pid) {
         self::$redis = null;
         self::$pid = $pid;
     }
     if (!is_null(self::$redis)) {
         return self::$redis;
     }
     $server = self::$redisServer;
     if (empty($server)) {
         $server = 'localhost:6379';
     }
     if (is_array($server)) {
         require_once dirname(__FILE__) . '/Resque/RedisCluster.php';
         self::$redis = new Resque_RedisCluster($server);
     } else {
         if (strpos($server, 'unix:') === false) {
             list($host, $port) = explode(':', $server);
         } else {
             $host = $server;
             $port = null;
         }
         require_once dirname(__FILE__) . '/Resque/Redis.php';
         $redisInstance = new Resque_Redis($host, $port);
         $redisInstance->prefix(self::$namespace);
         self::$redis = $redisInstance;
     }
     self::$redis->select(self::$redisDatabase);
     return self::$redis;
 }

 private function getRedis()
 {
     $redis = \Resque::$redis;
     if ($redis === null) {
         $redis = \Resque::redis();
     }
     return $redis;
 }

 /**
  * @expectedException Resque_RedisException
  */
 public function testRedisExceptionsAreSurfaced()
 {
     $mockCredis = $this->getMockBuilder('Credis_Client')->setMethods(['connect', '__call'])->getMock();
     $mockCredis->expects($this->any())->method('__call')->will($this->throwException(new CredisException('failure')));
     Resque::setBackend(function ($database) use($mockCredis) {
         return new Resque_Redis('localhost:6379', $database, $mockCredis);
     });
     Resque::redis()->ping();
 }

 /**
  * @return Job[]
  */
 public function jobs()
 {
     $result = \Resque::redis()->lrange('queue:' . $this->name, 0, -1);
     $jobs = [];
     foreach ($result as $job) {
         $jobs[] = (new \Resque_Job($this->name, \json_decode($job, true)))->getInstance();
     }
     return $jobs;
 }

 public function getJobs($start = 0, $stop = -1)
 {
     $jobs = \Resque::redis()->lrange('queue:' . $this->name, $start, $stop);
     $result = array();
     foreach ($jobs as $job) {
         $job = new \Resque_Job($this->name, \json_decode($job, true));
         $result[] = $job->getInstance();
     }
     return $result;
 }

 /**
  * Peek
  *
  * @param string $queue The name of the queue
  * @param integer $start
  * @param integer $count
  *
  * @return array List of jobs
  *
  */
 public static function peek($queue, $start = 0, $count = 1000)
 {
     $jobs = \Resque::redis()->lrange('queue:' . $queue, $start, $count);
     $curr_jobs = array();
     if (is_array($jobs)) {
         foreach ($jobs as $job) {
             $curr_jobs[] = json_decode($job, TRUE);
         }
     }
     return $curr_jobs;
 }

 public static function requeue($id)
 {
     //        item = all(id)
     //        item['retried_at'] = Time.now.rfc2822
     //        Resque.redis.lset(:failed, id, Resque.encode(item))
     //        Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
     $item = current(self::all($id, 1));
     $item->retried_at = strftime('%a %b %d %H:%M:%S %Z %Y');
     $data = json_encode($item);
     \Resque::redis()->lset('failed', $id, $data);
     \Resque::enqueue($item->queue, $item->payload->class, (array) $item->payload->args[0]);
 }

 /**
  * Given a host/port combination separated by a colon, set it as
  * the redis server that Resque will talk to.
  *
  * @param mixed $server Host/port combination separated by a colon, or
  * a nested array of servers with host/port pairs.
  */
 public static function setBackend($server, $database = 0)
 {
     if (is_array($server)) {
         require_once dirname(__FILE__) . '/Resque/RedisCluster.php';
         self::$redis = new Resque_RedisCluster($server);
     } else {
         list($host, $port) = explode(':', $server);
         require_once dirname(__FILE__) . '/Resque/Redis.php';
         self::$redis = new Resque_Redis($host, $port);
     }
     self::redis()->select($database);
 }

 /**
  * Initialize a failed job class and save it (where appropriate).
  *
  * @param object $payload Object containing details of the failed job.
  * @param object $exception Instance of the exception that was thrown by the failed job.
  * @param object $worker Instance of Resque_Worker that received the job.
  * @param string $queue The name of the queue the job was fetched from.
  */
 public function __construct($payload, $exception, $worker, $queue)
 {
     $data = new stdClass();
     $data->failed_at = strftime('%a %b %d %H:%M:%S %Z %Y');
     $data->payload = $payload;
     $data->exception = get_class($exception);
     $data->error = $exception->getMessage();
     $data->backtrace = explode("\n", $exception->getTraceAsString());
     $data->worker = (string) $worker;
     $data->queue = $queue;
     $data = json_encode($data);
     Resque::redis()->rpush('failed', $data);
 }

 /**
  * fork() helper method for php-resque that handles issues PHP socket
  * and phpredis have with passing around sockets between child/parent
  * processes.
  *
  * Will close connection to Redis before forking.
  *
  * @return int Return vars as per pcntl_fork()
  */
 public static function fork()
 {
     if (!function_exists('pcntl_fork')) {
         return -1;
     }
     // Close the connection to Redis before forking.
     // This is a workaround for issues phpredis has.
     self::$redis = null;
     $pid = pcntl_fork();
     if ($pid === -1) {
         throw new RuntimeException('Unable to fork child worker.');
     }
     return $pid;
 }

 /**
  * Startup callback.
  *
  * Initializes defaults.
  */
 public function startup()
 {
     $resqueLib = Configure::read('CakeResque.Resque.lib');
     $schedulerLib = Configure::read('CakeResque.Scheduler.lib');
     $pluginVendorPath = CakePlugin::path('CakeResque') . 'vendor' . DS;
     if (substr($resqueLib, 0, 1) !== '/') {
         $resqueLib = $pluginVendorPath . $resqueLib;
     }
     $this->_resqueLibrary = realpath($resqueLib) . DS;
     if (substr($schedulerLib, 0, 1) !== '/') {
         $schedulerLib = $pluginVendorPath . $schedulerLib;
     }
     $this->_resqueSchedulerLibrary = realpath($schedulerLib) . DS;
     $this->ResqueStatus = new ResqueStatus\ResqueStatus(Resque::redis());
     $this->stdout->styles('success', array('text' => 'green'));
     $this->stdout->styles('bold', array('bold' => true));
 }

 protected function getJobs()
 {
     $jobs = new ArrayList();
     $resqueJobs = Resque::redis()->lrange('queue:' . $this->Name, 0, -1);
     if (!$resqueJobs) {
         $jobs->push(new ResqueJob(array('Name' => 'null', 'Value' => 'null')));
         return $jobs;
     }
     foreach ($resqueJobs as $idx => $job) {
         $stdClass = json_decode($job);
         if ($stdClass->class === 'CapistranoDeploy' || $stdClass->class === 'DeployJob') {
             $jobs->push(new ResqueJob(array('Name' => $stdClass->class, 'Value' => $stdClass->args[0]->projectName . ':' . $stdClass->args[0]->environment . ' - ' . $stdClass->args[0]->sha)));
         } else {
             $jobs->push(new ResqueJob(array('Name' => $stdClass->class, 'Value' => var_export($stdClass->args[0], true))));
         }
     }
     return $jobs;
 }

 public static function get_all_workers($queue = NULL)
 {
     $ret = array();
     $workers = Resque::redis()->smembers('workers');
     if (!is_array($workers)) {
         $workers = array();
     }
     foreach ($workers as $workerId) {
         $worker_data = explode(':', $workerId, 4);
         $worker = array();
         $worker['hostname'] = $worker_data[0];
         $worker['queues'] = explode(',', $worker_data[2]);
         $worker['pid'] = $worker_data[1];
         $worker['programname'] = $worker_data[3];
         $worker['workerId'] = $workerId;
         if ($queue && (in_array($queue, $worker['queues']) || in_array("*", $worker['queues'])) || !$queue) {
             $ret[] = $worker;
         }
     }
     return $ret;
 }

 public function workerRemoveDead($user)
 {
     $this->ResqueStatus = new ResqueStatus\ResqueStatus(Resque::redis());
     $workers = $this->ResqueStatus->getWorkers();
     $this->Log = ClassRegistry::init('Log');
     if (function_exists('posix_getpwuid')) {
         $currentUser = posix_getpwuid(posix_geteuid());
         $currentUser = $currentUser['name'];
     } else {
         $currentUser = trim(shell_exec('whoami'));
     }
     foreach ($workers as $pid => $worker) {
         if (!is_numeric($pid)) {
             throw new MethodNotAllowedException('Non numeric PID found!');
         }
         $pidTest = substr_count(trim(shell_exec('ps -p ' . $pid)), PHP_EOL) > 0 ? true : false;
         if ($worker['user'] == $currentUser && !$pidTest) {
             $this->ResqueStatus->removeWorker($pid);
             $this->Log->create();
             $this->Log->save(array('org' => $user['org'], 'model' => 'User', 'model_id' => $user['id'], 'email' => $user['email'], 'action' => 'remove_dead_workers', 'user_id' => $user['id'], 'title' => 'Removing a dead worker.', 'change' => 'Removind dead worker data. Worker was of type ' . $worker['queue'] . ' with pid ' . $pid));
         }
     }
 }