keystone/queue

Create and process background tasks with any queueing service

0.1.0-alpha1 2017-02-13 01:44 UTC

Requires

• php: >=7.0
• aws/aws-sdk-php: ^3.22
• beberlei/assert: ^2.7
• psr/log: ^1.0

Requires (Dev)

• doctrine/common: ^2.7
• doctrine/dbal: ^2.5
• mockery/mockery: ^0.9.8
• monolog/monolog: ^1.22
• phpstan/phpstan: ^0.6.3
• phpunit/phpunit: ^5.0
• psr/container: dev-master
• symfony/dependency-injection: ^3.2
• symfony/property-access: ^3.2
• symfony/serializer: ^3.2

MIT

• queue
• rabbitmq
• AMQP
• worker
• sqs

README

A PHP library to create and process background tasks with any queueing service.

Supported queue services:

• AWS SQS
• RabbitMQ

Features:

• Compatible with any queueing service via provider/publisher interfaces.
• Middleware to hook into the processing flow (inspired by PSR-15).
• Route task messages to workers registered as services in PSR-11/Symfony containers.

Middleware:

• Automatically close timed out Doctrine DBAL connections.
• Automatically clear the Doctrine ORM managers to free memory.
• Limit the maximum execution time of the consumer.
• Limit the maximum number of messages a consumer will process.
• Limit the maximum amount of memory a consumer is allowed to use.
• Retry failed tasks using an exponential backoff strategy.
• Handle signals to terminate the consumer process safely.

Requirements

PHP 7.0 or above is required.

Getting started

Install the library with Composer.

composer require keystone/queue

Create a message class for the task.

use Keystone\Queue\Message;

class HardMessage implements Message
{
    public $name;
    public $count;

    public function __construct(string $name, int $count)
    {
        $this->name = $name;
        $this->count = $count;
    }

    public function getKey(): string
    {
        // The message key is used to determine which queue to publish to.
        return 'hard';
    }
}

Create a worker class capable of processing the message.

class HardWorker
{
    public function process(HardMessage $message)
    {
        // Do some work to process the message.
    }
}

Publish a message within your application.

use Keystone\Queue\Publisher;

$publisher = new Publisher(...);
// The message is serialized when publishing and unserialized when consuming
$publisher->publish(new HardMessage('Billy', 12));

Consume the messages in a long running process.

use Keystone\Queue\Consumer;
use Keystone\Queue\Provider;

$provider = new Provider(...);
$consumer = new Consumer($provider, ...);
// The consumer will poll the queue for new messages and process them.
$consumer->consume();

Credits

• Tom Graham (maintainer)
• Mike Perham for his work on Sidekiq
• Henrik Bjørnskov for his work on Bernard
• Olivier Dolbeau for his work on Swarrot

License

Released under the MIT Licence. See the bundled LICENSE file for details.