/**
* {@inheritdoc}
*/
public function runAndWait(Task $task, $wait = 0, callable $completed = null, callable $timedout = null, callable $errored = null)
{
$waitForResult = $wait > 0;
// Event: before dispatching the task
$this->triggerEvent(self::EVENT_BEFORE_TASK_DISPATCHED, [$task]);
// Event: before serialization
$this->triggerEvent(self::EVENT_BEFORE_TASK_SERIALIZATION, [$task]);
$messageOptions = ['delivery_mode' => 2];
$replyExchange = null;
$replyQueue = null;
if ($waitForResult) {
// Create a temporary exchange (durable, autodelete) for communicating with the worker
$replyExchange = uniqid('tmp');
$this->channel->exchange_declare($replyExchange, 'fanout', false, true, true);
// Create and bind a queue for the dispatcher (our queue) (exclusive queue)
list($replyQueue, , ) = $this->channel->queue_declare('', false, false, true);
$this->channel->queue_bind($replyQueue, $replyExchange);
// Create and bind a queue for the worker (durable non-exclusive queue)
list($workerReplyQueue, , ) = $this->channel->queue_declare('', false, true, false);
$this->channel->queue_bind($workerReplyQueue, $replyExchange);
$messageOptions['reply_to'] = $replyExchange . ';' . $workerReplyQueue;
}
$message = new AMQPMessage(serialize($task), $messageOptions);
$this->channel->basic_publish($message, '', $this->queue);
if ($waitForResult) {
$this->waitForTask($wait, $replyExchange, $replyQueue, $completed, $timedout, $errored);
}
}
/**
* @throws Exception\Configuration
*/
public function setup()
{
$this->connect();
$exchange = $this->getProperty('exchange');
if (empty($exchange)) {
throw new Exception\Configuration('Please check your settings, exchange is not defined.');
}
/*
name: $exchange
type: topic
passive: false
durable: true // the exchange will survive server restarts
auto_delete: false //the exchange won't be deleted once the channel is closed.
*/
$this->channel->exchange_declare($exchange, $this->getProperty('exchange_type'), $this->getProperty('exchange_passive'), $this->getProperty('exchange_durable'), $this->getProperty('exchange_auto_delete'), $this->getProperty('exchange_internal'), $this->getProperty('exchange_nowait'), $this->getProperty('exchange_properties'));
$queue = $this->getProperty('queue');
if (!empty($queue) || $this->getProperty('queue_force_declare')) {
/*
name: $queue
passive: false
durable: true // the queue will survive server restarts
exclusive: false // queue is deleted when connection closes
auto_delete: false //the queue won't be deleted once the channel is closed.
nowait: false // Doesn't wait on replies for certain things.
parameters: array // Extra data, like high availability params
*/
/** @var ['queue name', 'message count',] queueInfo */
$this->queueInfo = $this->channel->queue_declare($queue, $this->getProperty('queue_passive'), $this->getProperty('queue_durable'), $this->getProperty('queue_exclusive'), $this->getProperty('queue_auto_delete'), $this->getProperty('queue_nowait'), $this->getProperty('queue_properties'));
$this->channel->queue_bind($queue ?: $this->queueInfo[0], $exchange, $this->getProperty('routing'));
}
// clear at shutdown
register_shutdown_function([get_class(), 'shutdown'], $this->channel, $this->connection);
}
public function setUp()
{
$this->conn = $this->createConnection();
$this->ch = $this->conn->channel();
$this->ch->exchange_declare($this->exchange_name, 'direct', false, false, false);
list($this->queue_name, , ) = $this->ch->queue_declare();
$this->ch->queue_bind($this->queue_name, $this->exchange_name, $this->queue_name);
}
protected function setUpAmqp()
{
$this->conn = new AMQPSocketConnection($_SERVER['AMQP_HOST'], $_SERVER['AMQP_PORT'], $_SERVER['AMQP_USER'], $_SERVER['AMQP_PASS'], $_SERVER['AMQP_VHOST']);
$this->channel = $this->conn->channel();
$this->channel->exchange_declare('event_band.test.exchange', 'topic');
$this->channel->queue_declare('event_band.test.event');
$this->channel->queue_bind('event_band.test.event', 'event_band.test.exchange', 'event.#');
}
public function setUp()
{
$this->conn = new AMQPConnection(HOST, PORT, USER, PASS, VHOST);
$this->ch = $this->conn->channel();
$this->ch->exchange_declare($this->exchange_name, 'direct', false, false, false);
list($this->queue_name, , ) = $this->ch->queue_declare();
$this->ch->queue_bind($this->queue_name, $this->exchange_name, $this->queue_name);
}
/**
* @return void
*/
public function initialize()
{
if ($this->initialized) {
return;
}
$this->initialized = true;
$this->exchange->initialize();
$this->queue->initialize();
$this->channel->queue_bind($this->queue->name(), $this->exchange->name());
}
/**
* Set up AMQP connection.
*/
public function setUp()
{
$container = $this->getContainer();
$exchangeName = 'general';
$connection = new AMQPConnection($container->getParameter('ongr_task_messenger.publisher.default.amqp.host'), $container->getParameter('ongr_task_messenger.publisher.default.amqp.port'), $container->getParameter('ongr_task_messenger.publisher.default.amqp.user'), $container->getParameter('ongr_task_messenger.publisher.default.amqp.password'));
$this->channel = $connection->channel();
list($queueName, , ) = $this->channel->queue_declare();
$this->channel->queue_bind($queueName, $exchangeName, explode('.', gethostname())[0]);
$this->channel->basic_consume($queueName, getmypid(), false, true, true, true, [$this, 'verifyMessage']);
}
/**
* @param $exchange_name
*/
private function connect($exchange_name)
{
if (null !== $this->channel) {
return;
}
$this->channel = $this->connection->channel();
$this->channel->exchange_declare($exchange_name, 'fanout', false, true, false);
$this->channel->queue_declare($exchange_name, false, true, false, false);
$this->channel->queue_bind($exchange_name, $exchange_name);
}
/**
* Create consumer.
*/
private function initialize()
{
$this->messages = [];
list($queue) = $this->channel->queue_declare('', false, false, true, true);
$this->channel->queue_bind($queue, $this->exchange);
$this->channel->basic_consume($queue, '', false, false, false, false, function (AMQPMessage $message) {
$this->messages[] = $message;
$this->channel->basic_cancel($message->delivery_info['consumer_tag']);
});
}
/**
* @return string
*/
public function initialize()
{
$inbox = 'inbox.' . $this->handler->name();
$queue = $this->handler->name();
$this->channel->exchange_declare($inbox, 'topic', false, true, false);
$this->channel->exchange_bind($inbox, 'inbox', '', false, new AMQPTable(['to' => '*']));
$this->channel->exchange_bind($inbox, 'inbox', '', false, new AMQPTable(['to' => $this->handler->name()]));
$this->channel->queue_declare($queue, false, true, false, false, false);
$this->channel->queue_bind($queue, $inbox, '#');
return $queue;
}
private function declareComponents($routingKey, $exchange, $queue = null)
{
$this->channel->exchange_declare('dead_letters', 'topic', false, true, false);
if ($queue !== null) {
$this->channel->queue_declare('dead_letter:' . $queue, false, true, false, false);
$this->channel->queue_bind('dead_letter:' . $queue, 'dead_letters', $routingKey . '.dead_letter');
}
$this->channel->exchange_declare($exchange, 'topic', false, true, false);
if ($queue !== null) {
$this->channel->queue_declare($queue, false, true, false, false, false, new AMQPTable(['x-dead-letter-exchange' => 'dead_letters', 'x-dead-letter-routing-key' => $routingKey . '.dead_letter']));
$this->channel->queue_bind($queue, $exchange, $routingKey);
}
}
/**
* @param $queue
*
* @return string
*/
protected function getExchange($queue)
{
if (!array_key_exists($queue, $this->exchangeList)) {
/**
* queue and exchange the same
*/
$exchange = $queue;
$this->ch->queue_declare($queue, false, true, false, false);
$this->ch->exchange_declare($exchange, 'direct', false, true, false);
$this->ch->queue_bind($queue, $exchange);
$this->exchangeList[$exchange] = $exchange;
}
return $queue;
}
/**
* Setup the exchanges, and queues and channel
*/
protected function setupChannel()
{
$this->ch = $this->conn->channel();
$this->ch->exchange_declare($this->exchange, 'direct', false, false, false);
$this->ch->queue_declare($this->queue);
$this->ch->queue_bind($this->queue, $this->exchange, $this->queue);
}
protected function declareAndBindQueue($queue)
{
if (!$this->hasQueue($queue)) {
$this->addQueue($queue);
$this->channel->queue_declare($queue, false, true, false, false);
$this->channel->queue_bind($queue, $this->getExchange(), $queue);
$this->logger->info(sprintf("Queue %s declared.", $queue));
}
}
/**
* {@inheritdoc}
*/
public function delayed($queue, $delay, Job $job)
{
$this->exchangeDeclare('delay');
$delay = $delay * 1000;
$tmpQueue = $this->queueDeclare('', array('x-expires' => array('I', $delay + 2000), 'x-message-ttl' => array('I', $delay), 'x-dead-letter-exchange' => array('S', 'delay'), 'x-dead-letter-routing-key' => array('S', $queue)));
$this->channel->queue_bind($queue, 'delay', $queue);
$msg = $this->prepareMessage($queue, $job);
return $this->channel->basic_publish($msg, '', reset($tmpQueue));
}
/**
* Define a queue in the message broker and bind it to an exchange.
*
* If the queue is already declared, the configuration MUST be the same. If the queue has not been
* defined before, a new one will be created.
*
* @param $queue
*
* @return $this
*
* @throws BrokerException
*/
public function declareQueue($queue)
{
if (!$queue instanceof Queue) {
throw new BrokerException("The queue hasn't been defined");
}
$queueConf = $this->channel->queue_declare($queue->getName(), $queue->isPassive(), $queue->isDurable(), $queue->isExclusive(), $queue->isDeclaredAutoDelete(), $queue->isDeclaredAsNoWait(), $queue->getArguments());
// For unnamed queues, set the random name assigned during the declaration
if (!$queue->hasName()) {
$queue->setName($queueConf[0]);
}
$routingKeys = $queue->getRoutingKeys();
// getRoutingKeys() must have at least 1 element, which may be null
if (count($routingKeys) < 1) {
throw new BrokerException('Assert: there must be at least 1 routing key');
}
// This element will be used to bind the queue and the exchange together.
foreach ($queue->getRoutingKeys() as $key) {
$this->channel->queue_bind($queue->getName(), $queue->getExchange()->getName(), $key, $queue->isDeclaredAsNoWait());
}
return $this;
}
/**
* Initializes result objects: creates AMQP objects and binds result queue.
*
* @return void
*/
public function initialize()
{
$this->channel = $this->connection->channel();
// `auto-delete` argument makes sure that queue will be deleted after last queue
// consumer disconnected. (Won't be deleted if there weren't any consumers)
// `x-expires` queue option means that queue will be deleted if it's unused for the
// specified time in milliseconds. Unused means that queue has no consumers,
// the queue has not been redeclared, and basic.get has not been invoked.
Util::declareQueue($this->connection, $this->taskId, ['exclusive' => false, 'durable' => true, 'auto_delete' => true, 'arguments' => ['x-expires' => self::EXPIRE_TIME]]);
Util::declareExchange($this->connection, 'celeryresults', 'direct', ['exclusive' => false]);
$this->channel->queue_bind($this->taskId, 'celeryresults', $this->taskId);
}
private function init()
{
$this->connection = new AMQPStreamConnection($this->host, $this->port, $this->user, $this->pass, '/', false, 'AMQPLAIN', null, 'en_US', 0);
$this->channel = $this->connection->channel();
$this->channel->queue_declare(self::QUEUE_NAME, false, true, false, false, false);
$this->channel->exchange_declare(self::EXCHEAGE_NAME, 'direct');
$this->channel->queue_bind(self::QUEUE_NAME, self::EXCHEAGE_NAME);
$this->channel->queue_declare(self::QUEUE_WITH_DELAY_NAME, false, true, false, false, false, array('x-message-ttl' => array('I', self::DELAY * 1000), 'x-dead-letter-exchange' => array('S', self::EXCHEAGE_NAME)));
$this->channel->exchange_declare(self::EXCHANGE_WITH_DELAY_NAME, 'direct');
$this->channel->queue_bind(self::QUEUE_WITH_DELAY_NAME, self::EXCHANGE_WITH_DELAY_NAME);
$this->channel->basic_qos(null, 1, null);
register_shutdown_function([$this, 'shutdown'], $this->channel, $this->connection);
}
/**
* Setup consumer.
*/
protected function setUpConsumer()
{
if (isset($this->exchangeOptions['name'])) {
$this->channel->exchange_declare($this->exchangeOptions['name'], $this->exchangeOptions['type'], $this->exchangeOptions['passive'], $this->exchangeOptions['durable'], $this->exchangeOptions['auto_delete'], $this->exchangeOptions['internal'], $this->exchangeOptions['nowait'], $this->exchangeOptions['arguments'], $this->exchangeOptions['ticket']);
if (!empty($this->consumerOptions['qos'])) {
$this->channel->basic_qos($this->consumerOptions['qos']['prefetch_size'], $this->consumerOptions['qos']['prefetch_count'], $this->consumerOptions['qos']['global']);
}
}
list($queueName, , ) = $this->channel->queue_declare($this->queueOptions['name'], $this->queueOptions['passive'], $this->queueOptions['durable'], $this->queueOptions['exclusive'], $this->queueOptions['auto_delete'], $this->queueOptions['nowait'], $this->queueOptions['arguments'], $this->queueOptions['ticket']);
if (isset($this->exchangeOptions['name'])) {
$this->channel->queue_bind($queueName, $this->exchangeOptions['name'], $this->routingKey);
}
$this->channel->basic_consume($queueName, $this->getConsumerTag(), false, false, false, false, array($this, 'processMessage'));
}
/**
* @param string $destination
* @param \DateTime|int $delay
*
* @return array
*/
protected function declareDelayedQueue(string $destination, $delay) : array
{
$delay = $this->getSeconds($delay);
$destination = $this->getQueue($destination);
$name = $this->getQueue($destination) . '_deferred_' . $delay;
$destinationExchange = $this->configExchange['name'] ?: $destination;
$exchange = $this->configExchange['name'] ?: $destination;
// declare exchange
$this->channel->exchange_declare($exchange, $this->configExchange['type'], $this->configExchange['passive'], $this->configExchange['durable'], $this->configExchange['auto_delete']);
// declare queue
$this->channel->queue_declare($name, $this->configQueue['passive'], $this->configQueue['durable'], $this->configQueue['exclusive'], $this->configQueue['auto_delete'], false, new AMQPTable(['x-dead-letter-exchange' => $destinationExchange, 'x-dead-letter-routing-key' => $destination, 'x-message-ttl' => $delay * 1000]));
// bind queue to the exchange
$this->channel->queue_bind($name, $exchange, $name);
return [$name, $exchange];
}
public function __construct($name, Exchange $exchange, AMQPChannel $channel, $options)
{
$this->name = $name;
$this->exchange = $exchange;
$this->channel = $channel;
$this->passive = $options["passive"];
$this->durable = $options["durable"];
$this->exclusive = $options["exclusive"];
$this->auto_delete = $options["auto_delete"];
$channel->queue_declare($name, $this->passive, $this->durable, $this->exclusive, $this->auto_delete);
if ($exchange->getName()) {
$routing_key = $exchange->getType() == "fanout" ? null : $name;
$channel->queue_bind($name, $exchange->getName(), $routing_key);
}
}
/**
* @param string $destination
* @param DateTime|int $delay
*
* @return string
*/
protected function declareDelayedQueue($destination, $delay)
{
$delay = $this->getSeconds($delay);
$destination = $this->getQueueName($destination);
$queueName = $destination . '_deferred_' . $delay;
$exchange = $this->configExchange['name'] ?: $queueName;
if (isset(static::$registeredDelayed[$queueName])) {
return;
}
static::$registeredDelayed[$queueName] = true;
$this->declareRabbitMQExchange($exchange);
$this->declareRabbitMQQueue($queueName, new AMQPTable(['x-dead-letter-exchange' => $destination, 'x-dead-letter-routing-key' => $destination, 'x-message-ttl' => $delay * 1000]));
// bind queue to the exchange
$this->channel->queue_bind($queueName, $exchange, $queueName);
return $queueName;
}
/**
* @param ConsumerContainer $consumerContainer
*
* @throws ConsumerException
*/
private function registerConsumerContainer(ConsumerContainer $consumerContainer)
{
$consumerName = $consumerContainer->getConsumerName();
if (isset($this->consumerContainers[$consumerName])) {
$currentConsumer = $this->consumerContainers[$consumerName];
throw new ConsumerException(sprintf('Can not register consumer method [%s] because the consumer method [%s] already uses that name', $consumerContainer->getMethodName(), $currentConsumer->getMethodName()));
}
$this->channel->queue_declare($consumerName, false, true, false, false);
foreach ($consumerContainer->getBindings() as $binding) {
$this->channel->queue_bind($consumerName, $this->exchangeName, $binding);
}
$this->channel->basic_qos($consumerName, $consumerContainer->getPrefetchCount(), false);
$this->channel->basic_consume($consumerName, '', false, false, false, false, function (AMQPMessage $message) use($consumerContainer) {
$this->consume($consumerContainer, $message);
$message->delivery_info['channel']->basic_ack($message->delivery_info['delivery_tag']);
});
$this->consumerContainers[$consumerName] = $consumerContainer;
}
/**
* @test
*/
public function register_consumer_should_bind_queues()
{
$consumer = new stdClass();
$binding2 = 'binding2';
$binding1 = 'binding1';
$consumerName = 'myName';
$bindings = [$binding1, $binding2];
$containerMock = $this->prophesize(ConsumerContainer::class);
$containerMock->getBindings()->willReturn($bindings);
$containerMock->getConsumerName()->willReturn($consumerName);
$containerMock->getPrefetchCount()->willReturn(1);
$this->parser->getConsumerMethods($consumer)->willReturn([$containerMock]);
$this->channel->basic_qos($consumerName, 1, false)->shouldBeCalled();
$this->channel->basic_consume($consumerName, Argument::any(), Argument::any(), Argument::any(), Argument::any(), Argument::any(), Argument::any())->shouldBeCalled();
$this->channel->queue_declare($consumerName, Argument::any(), Argument::any(), Argument::any(), Argument::any())->shouldBeCalled();
$this->channel->queue_bind($consumerName, self::EXCHANGE_NAME, $binding1)->shouldBeCalled();
$this->channel->queue_bind($consumerName, self::EXCHANGE_NAME, $binding2)->shouldBeCalled();
$this->manager->registerConsumer($consumer);
}
/**
* Sit in loop waiting for incoming messages
* Call event handlers to consume events
*/
public function consume()
{
$handlers = $this->event_handlers;
$callback = function ($message) use($handlers) {
$event = json_decode($message->body, true);
if (array_key_exists($event['name'], $handlers)) {
try {
$handlers[$event['name']]($event);
} catch (Exception $ex) {
print "Error handling " . $event['name'] . "\n\n" . $ex->getMessage();
}
}
};
$this->connect();
list($queue_name, , ) = $this->channel->queue_declare("", false, false, true, false);
$this->channel->queue_bind($queue_name, $this->channel_name);
$this->channel->basic_consume($queue_name, '', false, true, false, false, $callback);
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
/**
* Declare and bind result queue
*
* @param \PhpAmqpLib\Channel\AMQPChannel $channel AMQP channel
*/
private function declareResultQueue($channel)
{
Util::declareQueue($this->connection, $this->taskId, ['exclusive' => false, 'auto_delete' => true, 'arguments' => ["x-expires" => 3600000]]);
Util::declareExchange($this->connection, 'celeryresults', 'direct', ['exclusive' => false]);
$channel->queue_bind($this->taskId, 'celeryresults');
}
/**
* @param callable $callback
* @param string $routingKey, default to all ('#')
*/
public function consume(callable $callback, $routingKey = '#')
{
$this->channel->queue_bind($this->queueName, self::CHANNEL_NAME, $routingKey);
$this->channel->basic_consume($this->queueName, '', false, true, false, false, $callback);
}
/**
* Create a queue.
*
* @param string $queueName
*/
public function createQueue($queueName)
{
$this->channel->exchange_declare($this->exchange, 'direct', false, true, false);
$this->channel->queue_declare($queueName, false, true, false, false);
$this->channel->queue_bind($queueName, $this->exchange);
}
/**
* Binds queue to an exchange
*
* @param string $queueName
* @param string $exchangeName
* @param string $routingKey
*
* @return mixed|null
*/
public function bindQueueExchanger($queueName, $exchangeName, $routingKey = '')
{
$this->_channel->queue_bind($queueName, $exchangeName, $routingKey);
}
protected function declareQueue()
{
$this->channel->queue_declare((string) $this->queueName, $passive = false, $durable = true, $exclusive = false, $autoDelete = false);
$this->channel->queue_bind($this->queueName, $this->exchangeName, $routingKey = '#');
}
