Release a reserved job back onto the queue.

@param  string  $queue
@param  \Illuminate\Queue\Jobs\DatabaseJobRecord  $job
@param  int  $delay
@return mixed
761147
public function release($queue, $job, $delay)
    {
        return $this->pushToDatabase($queue, $job->payload, $delay, $job->attempts);
    }
1237934
public function recreate($payload, $queue, $delay)
    {
        $options = ['delay' => $this->secondsUntil($delay)];

        return $this->pushRaw($payload, $queue, $options);
    }
1095312
public function release($delay = 0)
    {
        parent::release($delay);

        $this->sqs->changeMessageVisibility([
            'QueueUrl' => $this->queue,
            'ReceiptHandle' => $this->job['ReceiptHandle'],
            'VisibilityTimeout' => $delay,
        ]);
    }
1154880
public function queue(Queue $queue)
    {
        if (isset($this->delay)) {
            return $this->later($this->delay, $queue);
        }

        $connection = property_exists($this, 'connection') ? $this->connection : null;

        $queueName = property_exists($this, 'queue') ? $this->queue : null;

        return $queue->connection($connection)->pushOn(
            $queueName ?: null, new SendQueuedMailable($this)
        );
    }
602240
public function release($delay = 0)
    {
        parent::release($delay);

        $this->delete();

        return $this->database->release($this->queue, $this->job, $delay);
    }
111538
public function release($message, $delay = 0)
    {
        if (!$message instanceof QueueMessage) {
            $msg = new QueueMessage();
            $msg->setId($message);
        }

        $message->setDelay($delay);

        $this->driver->release($message);
    }
186908
public function set(string $data, string $queue = 'default', $delay = 0)
    {
        return $this->beanstalkTask->putInTube($queue, $data, null, $delay);
    }
275398
protected function recreateJob($delay)
    {
        $payload = json_decode($this->job->body, true);

        array_set($payload, 'attempts', array_get($payload, 'attempts', 1) + 1);

        $this->iron->recreate(json_encode($payload), $this->getQueue(), $delay);
    }
1043085
protected function markJobAsReserved($job)
    {
        $this->db->name($this->table)->where('id', $job->id)->update([
            'reserved_at' => $job->reserved_at = $this->currentTime(),
            'attempts'    => ++$job->attempts,
        ]);

        return $job;
    }
117460
def job_delayed(self, job, queue):
        
        delayed_until = job.delayed_until.hget()
        if delayed_until:
            try:
                delayed_until = compute_delayed_until(delayed_until=parse(delayed_until))
            except (ValueError, TypeError):
                delayed_until = None

        if not delayed_until:
            # by default delay it for 60 seconds
            delayed_until = compute_delayed_until(delayed_for=60)

        job.enqueue_or_delay(
            queue_name=queue._cached_name,
            delayed_until=delayed_until,
            queue_model=queue.__class__,
        )

        self.log(self.job_delayed_message(job, queue), level='warning')

        if hasattr(job, 'on_delayed'):
            job.on_delayed(queue)
1074745
protected function prepareMessage($queue, Job $job)
    {
        $this->queueDeclare($queue);

        return new AMQPMessage(json_encode($job->createPayload()), $job->getOptions());
    }
565877
public function push($job, array $data = null, $queue = null)
    {
        if (false !== ($delay = \Resque::getConfig('default.jobs.delay', false))) {
            return $this->later($delay, $job, $data, $queue);
        }

        return Job::create($this->getQueue($queue), $job, $data);
    }
145956
public function release( $job ) {
		$data  = array(
			'job'         => serialize( $job ),
			'attempts'    => $job->attempts(),
			'reserved_at' => null,
		);
		$where = array(
			'id' => $job->id(),
		);

		if ( $this->database->update( $this->jobs_table, $data, $where ) ) {
			return true;
		}

		return false;
	}
283820
public function push( $job, $data = '', $queue = null )
	{
		$queueJob = $this->resolveJob( $this->createPayload( $job, $data, $queue ) );

		try
		{
			$this->raiseBeforeJobEvent( $queueJob );

			$queueJob->fire();

			$this->raiseAfterJobEvent( $queueJob );
		}
		catch ( Exception $e )
		{
			$this->raiseExceptionOccurredJobEvent( $queueJob, $e );

			$this->handleFailedJob( $queueJob );

			throw $e;
		}
		catch ( Throwable $e )
		{
			$this->raiseExceptionOccurredJobEvent( $queueJob, $e );

			$this->handleFailedJob( $queueJob );

			throw $e;
		}

		return 0;
	}
1284505
public function release($delay = 0)
    {
        parent::release($delay);

        if (!$this->pushed) {
            $this->delete();
        }

        $this->recreateJob($delay);
    }
767507
public function release($delay = 0)
    {
        $priority = Pheanstalk::DEFAULT_PRIORITY;

        $this->pheanstalk->release($this->job, $priority, $delay);
    }
1268008
public function later($delay, $job, $data = '', $queue = null)
    {
        return $this->push($job, $data, $queue);
    }