Jobs come in the form of commands. Commands can be either self-handling or not. In the latter case, a corresponding handler class would take the data from the command class and then act upon it.

Command classes reside in the app/Commands directory, and command handler classes can be found in the app/Handlers/Commands directory. Classes for a command and its handler can be generated with an Artisan command as follows:

$ php artisan make:command CommandName --handler --queued

The --handler option tells Artisan to create a handler class (omitting this option would create a self-handling command class only), and the --queued option designates that this should be added to the queue, instead of being handled synchronously.

You can then use the Queue façade to add the command to the queue:

Queue::push(new SendConfirmationEmail($order));

Alternatively, you can dispatch commands using the command bus. The command bus is set up by default in controllers using the DispatchesCommands trait. This means in your controller actions you could use the dispatch method:

public function purchase(Product $product)
{
  // Create order
  $this->dispatch(new SendConfirmationEmail($order));
}

Commands are simple classes that contain the data needed to execute an action—the handler then performs the actual processing at a later stage using the data provided by the command. An example may be sending a confirmation e-mail after an order is placed. The command for this will look like the following:

<?php namespace App\Commands;

use App\Order;
use Illuminate\Contracts\Queue\ShouldBeQueued; 
use Illuminate\Queue\InteractsBeQueued;
use Illuminate\Queue\SerializesModels; 

class SendConfirmationEmail extends Command implements ShouldBeQueued {

  use InteractsWithQueue, SerializesModels;

  public $order;

  public function __construct(Order $order) {
    $this->order = $order;
  }
}

The handler—when executed by the queue—will then perform the actual sending of the e-mail, passing the order to the e-mail template to display the details of the customer's purchase as follows:

<?php namespace App\Handlers\Commands;

use App\Commands\SendConfirmationEmail;
use Illuminate\Contracts\Mail\Mailer;
use Illuminate\Queue\InteractsWithQueue;

class SendConfirmationEmailHandler {

  public function __construct(Mailer $mail) {
    $this->mail = $mail;
  }

  public function handle(SendConfirmationEmail $command) {
    $order = $command->order;
    $data = compact('order');
    $this->mail->send('emails.order.confirmation', $data, function($message) use ($order) {
      $message->subject('Your order confirmation');
      $message->to(
        $order->customer->email,
        $order->customer->name
      );
    });
  }
}

As command handlers are resolved via the service container, we can type-hint dependencies. In the preceding case, we need the mailer service, so we type-hint the contract to get an implementation. We can then use the mailer to send an e-mail to the customer using the order data received from the command class.

The following are the functions used for listening to a queue and executing jobs:

The queue:listen command has to run in the background in order to process the jobs as they arrive from the queue. To make sure that it runs permanently, you have to use a process control system such as forever (https://github.com/nodejitsu/forever) or supervisor (http://supervisord.org/).

To get notified when a job fails, we use the following functions and commands:

Push queues do not require a background process but they only work with the iron.io driver. Push queues will call an endpoint in your application when a job is received, rather than to a queue that is handled by a constantly-running worker process. This is handy if you do not have the ability to define the processes, which run on your application's server (such as is the case on shared hosting packages). After signing up for an account on iron.io and adding your credentials to app/config/queue.php, you use them by defining a POST route that receives all the incoming jobs. This route calls Queue::marshal(), which is the method responsible for firing the correct job handler:

Route::post('queue/receive', function() {
  return Queue::marshal();
});

This route then needs to be registered as a subscriber with the queue:subscribe command:

$ php artisan queue:subscribe queue_name http://yourapp.example.com/queue/receive

Once the URL is subscribed on http://iron.io/, any newly created jobs with Queue::push() will be sent from Iron back to your application via a POST request.