/**
* @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);
}
