Spekkionu\PMG\Queue\Iron\Driver\IronDriver

Complexity

Total Complexity

8

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	enqueue()	0	10	1
A	dequeue()	0	13	2
A	retry()	0	4	1
A	fail()	0	4	1
A	ack()	0	13	2

<?php
namespace Spekkionu\PMG\Queue\Iron\Driver;

use Spekkionu\PMG\Queue\Iron\Envelope\IronEnvelope;
use IronMQ\IronMQ;
use PMG\Queue\Driver\AbstractPersistanceDriver;
use PMG\Queue\Exception;
use PMG\Queue\Serializer\Serializer;
use PMG\Queue\DefaultEnvelope;
use PMG\Queue\Envelope;
use PMG\Queue\Message;
use PMG\Queue\Exception\InvalidEnvelope;

class IronDriver extends AbstractPersistanceDriver
{
    /**
     * @var IronMQ
     */
    private $iron;
    /**
     * @var array
     */
    private $options;

    /**
     * @param IronMQ $iron
     * @param Serializer $serializer
     * @param array $options Properties to pass with the message
     */
    public function __construct(IronMQ $iron, Serializer $serializer = null, array $options = [])
    {
        parent::__construct($serializer);

It seems like $serializer defined by parameter $serializer on line 30 can be null; however, PMG\Queue\Driver\AbstractPersistanceDriver::__construct() does not accept null, maybe add an additional type check?

        $this->iron = $iron;
        $this->options = $options;
    }

    /**
     * @inheritDoc
     */
    public function enqueue($queueName, Message $message)
    {
        $env = new DefaultEnvelope($message);
        $data = $this->serialize($env);

        $job = $this->iron->postMessage($queueName, $data, $this->options);

        return new IronEnvelope($job->id, $env);

    }

    /**
     * @inheritDoc
     */
    public function dequeue($queueName)
    {
        $job = $this->iron->reserveMessage($queueName);

        if ($job) {
            $wrapped = $this->unserialize($job->body);
            $message = new DefaultEnvelope($wrapped->unwrap(), $job->reserved_count);
            $env = new IronEnvelope($job->id, $message, $job->reservation_id);

            return $env;
        }
        return null;
    }

    /**
     * @inheritDoc
     */
    public function ack($queueName, Envelope $envelope)
    {
        if (!$envelope instanceof IronEnvelope) {
            throw new InvalidEnvelope(sprintf(
                '%s requires that envelopes be instances of "%s", got "%s"',
                __CLASS__,
                IronEnvelope::class,
                get_class($envelope)
            ));
        }

        $this->iron->deleteMessage($queueName, $envelope->getId(), $envelope->getReservationId());
    }

    /**
     * @inheritDoc
     */
    public function retry($queueName, Envelope $envelope)
    {
        return $envelope->retry();
    }

    /**
     * @inheritDoc
     */
    public function fail($queueName, Envelope $envelope)
    {
        return $this->ack($queueName, $envelope);
    }
}