/** * @param DomainMessage $domainMessage */ private function publishWithAMQP(DomainMessage $domainMessage) { $payload = $domainMessage->getPayload(); $eventClass = get_class($payload); $this->logger->info("publishing message with event type {$eventClass} to exchange {$this->exchange}"); $this->channel->basic_publish($this->messageFactory->createAMQPMessage($domainMessage), $this->exchange); }
/** * @param $queue * @param $message * * @return bool */ public function publish($queue, $message) { $exchange = $this->getExchange($queue); $msg = new AMQPMessage($message, array('content_type' => 'text/plain', 'delivery_mode' => 2)); $this->ch->basic_publish($msg, $exchange); return true; }
/** * Send a message. */ public function send() { $this->getChannel()->queue_declare('hello', false, false, false, false); $msg = new AMQPMessage('Hello World!'); $this->channel->basic_publish($msg, '', 'hello'); echo ' [X] Sent "Hello World!"' . PHP_EOL; }
/** * Schedule a job in the future * * @access public * @param Job $job * @param DateTime $dateTime * @return $this */ public function schedule(Job $job, DateTime $dateTime) { $now = new DateTime(); $when = clone $dateTime; $delay = $when->getTimestamp() - $now->getTimestamp(); $message = new AMQPMessage($job->serialize(), array('delivery_mode' => 2)); $message->set('application_headers', new AMQPTable(array('x-delay' => $delay))); $this->channel->basic_publish($message, $this->exchange); return $this; }
public function testPublishConsume() { $this->msg_body = 'foo bar baz äëïöü'; $msg = new AMQPMessage($this->msg_body, array('content_type' => 'text/plain', 'delivery_mode' => 1, 'correlation_id' => 'my_correlation_id', 'reply_to' => 'my_reply_to')); $this->ch->basic_publish($msg, $this->exchange_name, $this->queue_name); $this->ch->basic_consume($this->queue_name, getmypid(), false, false, false, false, array($this, 'process_msg')); while (count($this->ch->callbacks)) { $this->ch->wait(); } }
/** * {@inheritDoc} */ protected function write(array $record) { $data = $record["formatted"]; $routingKey = $this->getRoutingKey($record); if ($this->exchange instanceof AMQPExchange) { $this->exchange->publish($data, $routingKey, 0, array('delivery_mode' => 2, 'content_type' => 'application/json')); } else { $this->exchange->basic_publish($this->createAmqpMessage($data), $this->exchangeName, $routingKey); } }
/** * * {@inheritDoc} * */ protected function write(array $record) { $data = $record["formatted"]; $routingKey = sprintf('%s.%s', substr($record['level_name'], 0, 4), $record['channel']); if ($this->exchange instanceof AMQPExchange) { $this->exchange->publish($data, strtolower($routingKey), 0, array('delivery_mode' => 2, 'Content-type' => 'application/json')); } else { $this->exchange->basic_publish(new AMQPMessage((string) $data, array('delivery_mode' => 2, 'content_type' => 'application/json')), $this->exchangeName, strtolower($routingKey)); } }
public function testSendFile() { $this->msg_body = file_get_contents(__DIR__ . '/fixtures/data_1mb.bin'); $msg = new AMQPMessage($this->msg_body, array('delivery_mode' => 1)); $this->ch->basic_publish($msg, $this->exchange_name, $this->queue_name); $this->ch->basic_consume($this->queue_name, '', false, false, false, false, array($this, 'process_msg')); while (count($this->ch->callbacks)) { $this->ch->wait(); } }
/** * @param AMQPMessage $message * @param string $routingKey * @return bool */ public function publish(AMQPMessage $message, $routingKey = '') { $this->getLogger()->info('amqp.publish', ['route' => $routingKey, 'value' => $message->body]); try { $this->channel->basic_publish($message, self::CHANNEL_NAME, $routingKey); return true; } catch (\Exception $e) { $this->getLogger()->error($e->getMessage()); return false; } }
/** * @param $n * @return int */ public function call($n) { $this->response = null; $this->corr_id = uniqid(); $msg = new AMQPMessage((string) $n, ['correlation_id' => $this->corr_id, 'reply_to' => $this->callback_queue]); $this->channel->basic_publish($msg, '', 'rpc_queue'); while (!$this->response) { $this->channel->wait(); } return intval($this->response); }
public function testPublishPacketSizeLongMessage() { // Connection frame_max; $frame_max = 131072; // Publish 3 messages with sizes: packet size - 1, equal packet size and packet size + 1 for ($length = $frame_max - 9; $length <= $frame_max - 7; $length++) { $this->msg_body = str_repeat('1', $length); $msg = new AMQPMessage($this->msg_body, array('content_type' => 'text/plain', 'delivery_mode' => 1, 'correlation_id' => 'my_correlation_id', 'reply_to' => 'my_reply_to')); $this->ch->basic_publish($msg, $this->exchange_name, $this->queue_name); } }
public function testFrameOrder() { $msg = new AMQPMessage("test message"); $this->ch->basic_publish($msg, $this->exchange_name, $this->queue_name1); $this->ch->basic_publish($msg, $this->exchange_name, $this->queue_name1); $this->ch->basic_publish($msg, $this->exchange_name, $this->queue_name2); $this->ch->basic_consume($this->queue_name1, "", false, true, false, false, array($this, 'process_msg1')); while (count($this->ch->callbacks)) { $this->ch->wait(); } }
public function testFrameOrder() { $msg = new AMQPMessage(''); $hdrs = new AMQPTable(array('x-foo' => 'bar')); $msg->set('application_headers', $hdrs); for ($i = 0; $i < $this->msg_count; $i++) { $this->ch->basic_publish($msg, $this->exchange_name, $this->queue_name); } $this->ch2->basic_consume($this->queue_name, '', false, true, false, false, array($this, 'process_msg')); while (count($this->ch2->callbacks)) { $this->ch2->wait(); } }
/** * @param AMQPMessage $message * @param string $exchange * @param string $routingKey * * @return Invoker\Reply * * @throws \Exception */ public function call(AMQPMessage $message, $exchange = '', $routingKey = '') { $this->enqueue($reply = new Invoker\Reply($this)); try { $message->set('reply_to', $this->getReplyQueue()); $message->set('correlation_id', $reply->id()); $this->channel->basic_publish($message, $exchange, $routingKey); } catch (\Exception $e) { $this->dequeue($reply); throw $e; } return $reply; }
/** * @param AMQPMessage $message * * @throws \Exception */ public function handle(AMQPMessage $message) { $reply = null; try { $reply = $this->handler->handle($message); $this->channel->basic_ack($message->delivery_info['delivery_tag'], false); } catch (RequestNotSupportedException $exception) { $this->channel->basic_ack($message->delivery_info['delivery_tag'], false); } catch (\Exception $e) { $this->channel->basic_reject($message->delivery_info['delivery_tag'], false); throw $e; } if ($reply !== null) { $this->channel->basic_publish($reply, '', $message->get('reply_to')); } }
/** * @param array $event */ private function publishEvent(array $event) { $event['version'] = '1.0.0'; $this->connect(); $msg = new AMQPMessage(json_encode($event, JSON_UNESCAPED_SLASHES), ['content_type' => 'application/json', 'timestamp' => time()]); $this->channel->basic_publish($msg, $this->rabbit_channel); }
private function reSend(TicketEvent $event) { $scheduledDate = clone $event->getDate(); if ($scheduledDate->add(new \DateInterval('P1D')) > new \DateTime()) { $this->channel->basic_publish(new AMQPMessage($this->packMessage($event)), self::EXCHANGE_WITH_DELAY_NAME, ''); // re-parse after } }
/** * @inherit */ public function sendMessage() { $msg = new AMQPMessage($this->data, $this->messageProperties); $this->channel->basic_publish($msg, $this->publishExchange, $this->publishRoutingKey, $this->publishMandatory, $this->publishImmediate, $this->publishTicket); $this->channel->close(); $this->connection->close(); return true; }
/** * @param string $message * @param string $queueTitle * @param string $exchange * @throws Exception */ public function publishMessage($message, $queueTitle, $exchange = '') { if (!$this->channel) { throw new Exception("Channel didn't created"); } $msg = new AMQPMessage($message); $this->channel->basic_publish($msg, $exchange, $queueTitle); }
public function basic_publish($msg, $exchange = '', $routingKey = '', $mandatory = false, $immediate = false, $ticket = NULL) { if ($this->panel) { $this->panel->published(get_defined_vars()); // all args } parent::basic_publish($msg, $exchange, $routingKey, $mandatory, $immediate, $ticket); }
/** * @param Outgoing $message * @param AbstractExchange $exchange * * @return $this */ public function sendMessage(Outgoing $message, AbstractExchange $exchange) { if ($message->hasReturnListener()) { $this->channel->set_return_listener($message->getReturnListener()); } $this->channel->basic_publish($message->getAMQPMessage(), $exchange->getName(), $message->getRoutingKey(), $message->isMandatory(), $message->isImmediate()); return $this; }
/** * @param Message $msg */ public function sendMessage(Message $msg) { /* Create the message */ $amqpMessage = $msg->getAMQPMessage(); /* Create queue */ $this->channel->queue_declare($msg->queueName, false, true, false, false); /* Publish message */ $this->channel->basic_publish($amqpMessage, '', $msg->queueName); }
public function publish($routingKey, $message) { if ($this->isConnected()) { $this->declareAndBindQueue($routingKey); $amqpMessage = new AMQPMessage($message, array('content_type' => 'text/plain', 'delivery_mode' => 2)); $this->channel->basic_publish($amqpMessage, $this->getExchange(), $routingKey); $this->logger->info(sprintf("Message %s published on %s queue", $message, $routingKey)); } }
/** * {@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)); }
/** * @param MessageInterface $message * @param string $exchangeName Destination xchange name. * @param string $routingKeyOrQueueName Routing key (if xchange is set) or the destination * queue name. * * @return void */ public function basicPublish(MessageInterface $message, $exchangeName = '', $routingKeyOrQueueName = '') { /** @var AMQPMessage $amqpMessage */ $amqpMessage = $this->messageAdaptor->fromMessageInterface($message); $currentMessageProperties = $amqpMessage->get_properties(); if (!isset($currentMessageProperties['timestamp'])) { $amqpMessage->set('timestamp', time()); } $this->channel->basic_publish($amqpMessage, $exchangeName, $routingKeyOrQueueName); $this->logger->notice('Message published!', ['body' => $amqpMessage->body, 'properties' => $amqpMessage->get_properties()]); }
/** {@inheritdoc} */ public function publish(Message $message, $key = null) { $properties = $message->getProperties(); if (isset($properties['headers'])) { if (!isset($properties['application_headers'])) { $properties['application_headers'] = []; } foreach ($properties['headers'] as $header => $value) { if (is_array($value)) { $type = 'A'; } elseif (is_int($value)) { $type = 'I'; } else { $type = 'S'; } $properties['application_headers'][$header] = [$type, $value]; } } $amqpMessage = new AMQPMessage($message->getBody(), $properties); $this->channel->basic_publish($amqpMessage, $this->exchange, (string) $key); }
/** * Push a raw payload onto the queue. * * @param string $payload * @param string $queue * @param array $options * * @return mixed */ public function pushRaw($payload, $queue = null, array $options = []) { if (isset($options['delay'])) { $queue = $this->declareDelayedQueue($queue, $options['delay']); } else { $queue = $this->getQueueName($queue); $this->declareQueue($queue); } $exchange = $this->configExchange['name'] ?: $queue; // push job to a queue $message = new AMQPMessage($payload, ['Content-Type' => 'application/json', 'delivery_mode' => 2]); // push task to a queue $this->channel->basic_publish($message, $exchange, $queue); return $message; }
/** * Signal to the emitter of the message that we finished. * * @param string $exchange * @param string $queue * @param string $messageContent Message to send to the dispatcher. * * @return bool */ protected function notifyDispatcher($exchange, $queue, $messageContent) { // We put in the queue that we finished $this->channel->basic_publish(new AMQPMessage($messageContent), $exchange); // Read the first message coming out of the queue $message = $this->waitForMessage($queue, 0.5); if (!$message) { // Shouldn't happen -> error while delivering messages? return false; } // If the first message of the queue is our message, we can die in peace // (else it would be the "timeout" message from the dispatcher) $dispatcherNotified = $message->body == $messageContent; // Delete our queue $this->channel->queue_delete($queue); return $dispatcherNotified; }
/** * {@inheritdoc} */ public function pushRaw(string $payload, string $queue = null, array $options = []) { $queue = $this->getQueue($queue); $this->declareQueue($queue); if (isset($options['delay']) && $options['delay'] > 0) { list($queue, $exchange) = $this->declareDelayedQueue($queue, $options['delay']); } else { list($queue, $exchange) = $this->declareQueue($queue); } $headers = ['Content-Type' => 'application/json', 'delivery_mode' => 2]; if ($this->attempts !== null) { $headers['application_headers'] = ['attempts_count' => ['I', $this->attempts]]; } $message = new AMQPMessage($payload, $headers); // push task to a queue $this->channel->basic_publish($message, $exchange, $queue); return true; }
private function waitForTask($timeout, $exchange, $queue, callable $completed = null, callable $timedout = null, callable $errored = null) { // Wait X seconds for the task to be finished $message = $this->waitForMessage($queue, $timeout); // No response from the worker (the task is not finished) if (!$message) { // We put in the queue that we timed out $this->channel->basic_publish(new AMQPMessage('timeout'), $exchange); // Read the first message coming out of the queue $message = $this->waitForMessage($queue, 0.5); if (!$message) { // Shouldn't happen -> error while delivering messages? return; } } // If the first message of the queue is a "finished" message from the worker if ($message->body == 'finished') { if ($completed !== null) { call_user_func($completed); } // Delete the temporary exchange $this->channel->exchange_delete($exchange); } // If the first message of the queue is a "errored" message from the worker if ($message->body == 'errored') { if ($errored !== null) { $e = new \RuntimeException("An error occured in the background task"); call_user_func($errored, $e); } // Delete the temporary exchange $this->channel->exchange_delete($exchange); } // If the first message of the queue is our "timeout" message if ($message->body == 'timeout') { if ($timedout !== null) { call_user_func($timedout); } // Do not delete the temp exchange: still used by the worker } // Delete the temporary queue $this->channel->queue_delete($queue); }