Resque_Job_Status::create() - Code Metrics - resque/php-resque - Measure and Improve Code Quality continuously with Scrutinizer

Resque_Job_Status::create() A
last analyzed 2022-01-27 16:56 UTC

↳ Parent: Resque_Job_Status

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	1
eloc	8
c	2
b	0
f	0
nc	1
nop	2
dl	0
loc	12
ccs	6
cts	6
cp	1
crap	1
rs	10

<?php

/**
 * Status tracker/information for a job.
 *
 * @package		Resque/Job
 * @author		Chris Boulton <[email protected]>
 * @license		http://www.opensource.org/licenses/mit-license.php
 */
class Resque_Job_Status
{
	const STATUS_WAITING = 1;
	const STATUS_RUNNING = 2;
	const STATUS_FAILED = 3;
	const STATUS_COMPLETE = 4;

	/**
	 * @var string The prefix of the job status id.
	 */
	private $prefix;

	/**
	 * @var string The ID of the job this status class refers back to.
	 */
	private $id;

	/**
	 * @var mixed Cache variable if the status of this job is being monitored or not.
	 * 	True/false when checked at least once or null if not checked yet.
	 */
	private $isTracking = null;

	/**
	 * @var array Array of statuses that are considered final/complete.
	 */
	private static $completeStatuses = array(
		self::STATUS_FAILED,
		self::STATUS_COMPLETE
	);

	/**
	 * Setup a new instance of the job monitor class for the supplied job ID.
	 *
	 * @param string $id The ID of the job to manage the status for.
	 */
	public function __construct($id, $prefix = '')
	{
		$this->id = $id;
		$this->prefix = empty($prefix) ? '' : "${prefix}_";
	}

	/**
	 * Create a new status monitor item for the supplied job ID. Will create
	 * all necessary keys in Redis to monitor the status of a job.
	 *
	 * @param string $id The ID of the job to monitor the status of.
	 */
	public static function create($id, $prefix = "")
	{
		$status = new self($id, $prefix);
		$statusPacket = array(
			'status'  => self::STATUS_WAITING,
			'updated' => time(),
			'started' => time(),
			'result'  => null,
		);
		Resque::redis()->set((string) $status, json_encode($statusPacket));
		Resque::redis()->/** @scrutinizer ignore-call */ set((string) $status, json_encode($statusPacket));

		return $status;
	}

	/**
	 * Check if we're actually checking the status of the loaded job status
	 * instance.
	 *
	 * @return boolean True if the status is being monitored, false if not.
	 */
	public function isTracking()
	{
		if ($this->isTracking === false) {
			return false;
		}

		if (!Resque::redis()->exists((string)$this)) {
		if (!Resque::redis()->/** @scrutinizer ignore-call */ exists((string)$this)) {
			$this->isTracking = false;
			return false;
		}

		$this->isTracking = true;
		return true;
	}

	/**
	 * Update the status indicator for the current job with a new status.
	 *
	 * @param int The status of the job (see constants in Resque_Job_Status)
filter:
    dependency_paths: ["lib/*"]
	 */
	public function update($status, $result = null)
	{
		$status = (int) $status;

		if (!$this->isTracking()) {
			return;
		}

		if ($status < self::STATUS_WAITING || $status > self::STATUS_COMPLETE) {
			return;
		}

		$statusPacket = array(
			'status'  => $status,
			'updated' => time(),
			'started' => $this->fetch('started'),
			'result'  => $result,
		);
		Resque::redis()->set((string)$this, json_encode($statusPacket));

		// Expire the status for completed jobs after 24 hours
		if (in_array($status, self::$completeStatuses)) {
			Resque::redis()->expire((string)$this, 86400);
			Resque::redis()->/** @scrutinizer ignore-call */ expire((string)$this, 86400);
		}
	}

	/**
	 * Fetch the status for the job being monitored.
	 *
	 * @return mixed False if the status is not being monitored, otherwise the status
	 * 	as an integer, based on the Resque_Job_Status constants.
	 */
	public function get()
	{
		return $this->status();
	}

	/**
	 * Fetch the status for the job being monitored.
	 *
	 * @return mixed False if the status is not being monitored, otherwise the status
	 * 	as an integer, based on the Resque_Job_Status constants.
	 */
	public function status()
	{
		return $this->fetch('status');
	}

	/**
	 * Fetch the last update timestamp of the job being monitored.
	 *
	 * @return mixed False if the job is not being monitored, otherwise the
	 *  update timestamp.
	 */
	public function updated()
	{
		return $this->fetch('updated');
	}

	/**
	 * Fetch the start timestamp of the job being monitored.
	 *
	 * @return mixed False if the job is not being monitored, otherwise the
	 *  start timestamp.
	 */
	public function started()
	{
		return $this->fetch('started');
	}

	/**
	 * Fetch the result of the job being monitored.
	 *
	 * @return mixed False if the job is not being monitored, otherwise the result
	 * 	as mixed
	 */
	public function result()
	{
		return $this->fetch('result');
	}

	/**
	 * Stop tracking the status of a job.
	 */
	public function stop()
	{
		Resque::redis()->del((string)$this);
		Resque::redis()->/** @scrutinizer ignore-call */ del((string)$this);
	}

	/**
	 * Generate a string representation of this object.
	 *
	 * @return string String representation of the current job status class.
	 */
	public function __toString()
	{
		return 'job:' . $this->prefix . $this->id . ':status';
	}

	/**
	* Fetch a value from the status packet for the job being monitored.
	*
	* @return mixed False if the status is not being monitored, otherwise the
	*  requested value from the status packet.
	*/
	protected function fetch($value = null)
	{
		if (!$this->isTracking()) {
			return false;
		}

		$statusPacket = json_decode(Resque::redis()->get((string)$this), true);
		$statusPacket = json_decode(Resque::redis()->/** @scrutinizer ignore-call */ get((string)$this), true);
		if (!$statusPacket) {
			return false;
		}

		if (empty($value)) {
			return $statusPacket;
		} else {
			if (isset($statusPacket[$value])) {
				return $statusPacket[$value];
			} else {
				return null;
			}
		}
	}
}


resque / php-resque

Resque_Job_Status::create() A last analyzed 2022-01-27 16:56 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Resque_Job_Status::create() A
last analyzed 2022-01-27 16:56 UTC