Worker

Determine if the given exception was caused by a lost connection.

Create a new queue worker.

Listen to the given queue in a loop.

Create the waiter used to pop jobs.

Wait for every admitted job coroutine to finish.

Deliver pending signals outside their asynchronous handlers.

Monitor the jobs for timeout.

Allow a full monitor interval plus whole-second alarm granularity.

Recover kill-mode timeouts when PHP code prevents the monitor from running.

Arm an earlier timeout check without scanning jobs on the admission path.

Give the normal timeout handler a bounded chance to recover a blocked loop.

Scan the running jobs and terminate the timeout jobs.

Interrupt an expired body without canceling a completed body's deferred cleanup.

Notify a job before cancellation unwinds its running command.

Determine if there are any timeout jobs.

Handle a timed-out job whose execution has ended or is frozen.

Raise the event for an attempt that exceeded its timeout.

Report a timeout-handling error without abandoning other expired attempts.

Report an exception, writing it to the PHP error log if reporting fails.

Get the appropriate timeout for the given job.

Determine if the daemon should process on this iteration.

Pause the worker for the current loop.

Determine the exit code to stop the process if necessary.

Process the next job on the queue.

Get the next job from the queue connection.

Determine which of the given queues are currently paused.

Raise events for any queues that have been paused or resumed since the last check.

Process the given job.

Run the callback with the worker option context active.

Stop the worker if we have lost connection to a database.

Process the given job from the queue.

Prepare cleanup shared by the job's handoffs and its timeout monitor.

Determine whether the job counts interrupted attempts as exceptions.

Fail a job whose payload cannot be consumed.

Register a coroutine job to running jobs.

Handle an exception that occurred while the job was running.

Mark the given job as failed if it has exceeded the maximum allowed attempts.

This will likely be because the job previously exceeded a timeout.

Mark the given job as failed if it has exceeded the maximum allowed exceptions.

This will likely be because the worker previously died while processing the job.

Mark the given job as failed if it has exceeded the maximum allowed attempts.

Mark the given job as failed if it has exceeded the maximum allowed attempts.

Mark the given job as failed if the exception handler determines it should not be retried.

Mark the given job as failed if it should fail on timeouts.

Mark the given job as failed and raise the relevant event.

Calculate the backoff for the given job.

Raise an event indicating the worker is starting.

Raise the before job has been popped.

Raise the after job has been popped.

Raise the before queue job event.

Raise the after queue job event.

Raise the exception occurred queue job event.

Determine if the queue worker should restart.

Get the last queue restart timestamp, or null.

Enable async signals for the process.

Handle a worker interruption signal.

Handle a worker pause signal.

Handle a worker resume signal.

Pass the signal to the running jobs.

Pass the signal to the given job.

Determine if "async" signals are supported.

Determine if the memory limit has been exceeded.

Get the current memory usage in megabytes.

Get the current monotonic time.

Stop listening and bail out of the script.

Kill the process.

Terminate the current worker process immediately.

Create an instance of MaxAttemptsExceededException.

Create an instance of TimeoutExceededException.

Sleep the script for a given number of seconds.

Set the cache repository implementation.

The repository persists on the singleton worker for the worker lifetime and is read by every subsequent pause or restart check.

Set the name of the worker.

The name persists on the singleton worker for the worker lifetime and selects the static pop callback used by every job pop.

Register a callback to be executed to pick jobs.

The callback persists in a static property for the worker process lifetime and runs on every job pop for the named worker. Passing null removes the callback.

Register a callback to be used to kill the worker process.

The callback persists for the worker lifetime and runs before forced process termination. Passing null clears it.

Get the queue manager instance.

Set the queue manager instance.

Swaps the manager reference on the singleton worker; runtime use races across coroutines and changes every concurrent queue lookup.

Flush all static state.