public function consume(ConsumerInterface $consumer, $callback)
{
$this->channel->basic_consume($consumer->getName(), '', false, false, false, false, $callback);
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
public function waitingForCall()
{
$this->channel->basic_consume(self::QUEUE_NAME, '', false, false, false, false, array($this, 'receive'));
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
/**
* Infinite loop: Listens for messages from the queue and sends them to the callback.
*
* @param callback $callback
*/
public function listen($callback)
{
$this->channel->basic_qos(null, 1, null);
$this->channel->basic_consume(self::QUEUE_NAME, '', false, true, false, false, $callback);
while ($this->channel->callbacks) {
$this->channel->wait();
}
}
/**
* @param string $exchangeName
* @param callable $callback
*/
public function consume($exchangeName, callable $callback)
{
$this->callback = $callback;
$this->channel->basic_consume($exchangeName, '', false, true, false, false, [$this, 'callback']);
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
public function consume()
{
$queue = $this->initialize();
$tag = $this->handler->name();
$this->channel->basic_consume($queue, $tag, false, false, false, false, [$this, 'handle']);
while (isset($this->channel->callbacks[$tag])) {
$this->channel->wait();
}
}
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();
}
}
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();
}
}
/**
* 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']);
}
/**
* 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']);
});
}
/**
* @param string $queue
* @param string $exchange
* @param string $routingKey
* @param callable $callback
*/
public function consume($queue, $exchange, $routingKey, $callback)
{
$this->declareComponents($routingKey, $exchange, $queue);
$this->channel->basic_consume($queue, '', false, false, false, false, function ($amqpMessage) use($callback) {
$message = new Message($amqpMessage);
$callback($message);
});
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
/**
* @param callable $callback
* @return void
*/
public function consume(callable $callback)
{
$internCallback = function ($msg) use($callback) {
//echo " [x] Received ", $msg->body, "\n";
$callback(unserialize($msg->body));
};
$this->exchange->basic_consume($this->exchangeName, '', false, true, false, false, $internCallback);
while (count($this->exchange->callbacks)) {
$this->exchange->wait();
}
}
/**
* {@inheritdoc}
*/
public function wait(Closure $callback)
{
$this->channel->basic_consume($this->queue, '', false, true, false, false, function ($rabbitMessage) use($callback) {
$message = $this->serializer->unserialize($rabbitMessage->body);
$callback($message);
$rabbitMessage->delivery_info['channel']->basic_ack($rabbitMessage->delivery_info['delivery_tag']);
});
while (count($this->channel->callbacks)) {
$this->channel->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();
}
}
/**
* @Then there should be a message in queue :queue
*
* @param $queue
* @param PyStringNode $string
*/
public function thereShouldBeAMessageInQueue($queue, PyStringNode $string = null)
{
$expected = $string ? $string->getRaw() : null;
if (null === $expected) {
$this->channel->basic_consume($queue);
} else {
$consumer = function (AMQPMessage $message) use($expected) {
$this->channel->basic_ack($message->delivery_info['delivery_tag']);
Assert::that($message->body)->equal($expected);
};
$this->channel->basic_consume($queue, '', false, false, false, false, $consumer);
}
$this->channel->wait(null, false, 4);
}
public function process_msg1($msg)
{
$delivery_info = $msg->delivery_info;
$this->q1msgs++;
if ($this->q1msgs < 2) {
$this->ch2->basic_consume($this->queue_name2, "", false, true, false, false, array($this, 'process_msg2'));
}
while (count($this->ch2->callbacks)) {
$this->ch2->wait();
}
if ($this->q1msgs == 2) {
$delivery_info['channel']->basic_cancel($delivery_info['consumer_tag']);
}
}
/**
*
*/
public function consume()
{
$this->queue->initialize();
$service = $this->service;
$this->channel->basic_consume($this->queue->name(), $this->tag, $this->noLocal, $this->noAck, $this->exclusive, $this->noWait, function (AMQPMessage $message) use($service) {
$ack = $service->execute($message);
if ($ack === null || $ack === true) {
$message->delivery_info['channel']->basic_ack($message->delivery_info['delivery_tag']);
}
});
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
public function work($maxMessages = null, $timeOut = null)
{
$callback = function (AMQPMessage $message) {
$this->handle($message);
};
$this->channel->basic_qos(null, 1, null);
$this->channel->basic_consume($this->queue, '', false, false, false, false, $callback);
// Loop infinitely (or up to $count) to execute tasks
while (count($this->channel->callbacks) && (is_null($maxMessages) || $maxMessages > 0)) {
$this->channel->wait();
if (!is_null($maxMessages)) {
$maxMessages--;
}
}
}
/**
* Starts to listen a queue for incoming messages.
* @param string $queueName The AMQP queue
* @param array $handlers Array of handler class instances
* @return bool
*/
public function listenToQueue($queueName, array $handlers)
{
$this->queueName = $queueName;
/* Look for handlers */
$handlersMap = array();
foreach ($handlers as $handlerClassPath) {
if (!class_exists($handlerClassPath)) {
$handlerClassPath = "RabbitManager\\Handlers\\{$handlerClassPath}";
if (!class_exists($handlerClassPath)) {
$this->logger->addError("Class {$handlerClassPath} was not found!");
return false;
}
}
$handlerOb = new $handlerClassPath();
$classPathParts = explode("\\", $handlerClassPath);
$handlersMap[$classPathParts[count($classPathParts) - 1]] = $handlerOb;
}
/* Create queue */
$this->channel->queue_declare($queueName, false, true, false, false);
/* Start consuming */
$this->channel->basic_qos(null, 1, null);
$this->channel->basic_consume($queueName, '', false, false, false, false, function ($amqpMsg) use($handlersMap) {
$msg = Message::fromAMQPMessage($amqpMsg);
Broker::handleMessage($msg, $handlersMap);
});
$this->logger->addInfo("Starting consumption of queue {$queueName}");
/* Iterate until ctrl+c is received... */
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
/**
* Listener for the queue
* @param string $consumer_url
* @param array $post_vars
*/
public function consume($consumer_url, $post_vars = array())
{
$this->consumer_url = $consumer_url;
$this->consumer_post = $post_vars;
if ($this->consumer_count < $this->consumer_max) {
$this->consumer_start = time();
$callback = function (AMQPMessage $message) {
$post_vars = $this->consumer_post;
$post_vars['url'] = $this->consumer_url;
$post_vars['queue'] = $this->queue;
$post_vars['message'] = $message->body;
$response = $this->httpRequest->post($this->consumer_url, $post_vars);
$code = $this->httpRequest->statusCode();
if ($code == 200) {
$message->delivery_info['channel']->basic_ack($message->delivery_info['delivery_tag']);
} else {
// log the error to a file
$log_message = $code . "\n\n";
$log_message .= $message->body . "\n\n";
$log_message .= print_r($message, true);
$log_message .= "\n\n\n";
$log_message .= print_r($response, true);
Log::error($log_message);
}
if ($this->consumer_start + $this->ttl < time()) {
$this->channel->basic_cancel($message->delivery_info['consumer_tag']);
}
};
$this->channel->basic_consume($this->queue, '', false, false, false, false, $callback);
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
}
public function actionIndex()
{
Yii::info('Started email task', __METHOD__);
$this->setupConnection();
echo '[*] Waiting for messages. To exit press CTRL+C', "\n";
$this->channel->basic_qos(null, 1, null);
$this->channel->basic_consume($this->queue, '', false, false, false, false, [$this, 'processEmail']);
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
echo 'Shutting down...', "\n";
Yii::info('Shutting down...', __METHOD__);
Yii::trace('Disconnecting...', __METHOD__);
$this->channel->close();
$this->connection->close();
return self::EXIT_CODE_NORMAL;
}
/**
* Wait and get job from a queue
*
* @access public
* @return Job|null
*/
public function pull()
{
$message = null;
$this->channel->basic_consume($this->queue, 'test', false, false, false, false, function ($msg) use(&$message) {
$message = $msg;
$message->delivery_info['channel']->basic_cancel($message->delivery_info['consumer_tag']);
});
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
if ($message === null) {
return null;
}
$job = new Job();
$job->setId($message->get('delivery_tag'));
$job->unserialize($message->getBody());
return $job;
}
/**
* @param AMQPConnection $conn
* @param AMQPChannel $generalChannel
* @param string $generalQueueName
* @param AMQPChannel $workerQueueChannel
* @param string $workerExchangeName
* @param string $workerQueueName
* @param null|string $consumerTag
*/
public function __construct(AMQPConnection $conn, AMQPChannel $generalChannel, $generalQueueName, AMQPChannel $workerQueueChannel, $workerExchangeName, $workerQueueName, $consumerTag = null)
{
$consumerTag = $consumerTag ?: uniqid();
$generalChannel->basic_consume($generalQueueName, $consumerTag, false, false, false, false, [$this, 'forwardToWorker']);
$this->generalChannel = $generalChannel;
$this->workerQueueChannel = $workerQueueChannel;
$this->conn = $conn;
$this->workerExchangeName = $workerExchangeName;
}
/**
* @throws \yii\base\InvalidConfigException
*/
protected function initQueue()
{
/** @var Queue */
$this->queue = Instance::ensure($this->queue, Queue::class);
$this->channel = $this->queue->getChannel();
$this->channel->basic_qos($this->prefetchSize, $this->prefetchCount, null);
/**
* Message consume callback wrapper
*
* @param AMQPMessage $message
*
* @throws Exception
*/
$callback = function (AMQPMessage $message) {
$this->messageCallback($message);
};
$this->consumerTag = $this->channel->basic_consume($this->queue->name, '', false, false, $this->noAck, false, $callback);
}
/**
* @param string $queueTitle
* @param callable $callback
* @param string $exchange
* @throws Exception
*/
public function startListening($queueTitle, $callback, $exchange = '', $noAck = false)
{
if (!$this->channel) {
throw new Exception("Channel didn't created");
}
$this->channel->basic_consume($queueTitle, $exchange, false, $noAck, false, false, $callback);
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
public function consume(Queue $queue, $consumerOptions, $action)
{
$this->channel->basic_consume($queue->getName(), $consumerOptions['name'], $consumerOptions['noLocal'], $consumerOptions['noAck'], $consumerOptions['exclusive'], $consumerOptions['noWait'], function ($queueMessage) use($action) {
$action(new Incoming($queueMessage));
});
// Listen to the socket/stream
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
/**
* @param callback $callback
* @param string $tag
* @param array $config
*/
public function consume($callback, $tag = null, array $config = array())
{
$this->initialize();
$this->channel->basic_consume($this->name(), $tag, !empty($config['no_local']), !empty($config['no_ack']), !empty($config['exclusive']), !empty($config['no_wait']), function (AMQPMessage $message) use($callback) {
$ack = call_user_func($callback, $message);
if ($ack === null || $ack === true) {
$message->delivery_info['channel']->basic_ack($message->delivery_info['delivery_tag']);
}
});
while (count($this->channel->callbacks)) {
$this->channel->wait();
}
}
/**
* Wait result message and assign into $this->message.
*
* @param integer $timeout Optional timeout in seconds.
*
* @return void
*
* @throws Errors\ClientException On AMQP result timeout.
*/
private function wait($timeout = null)
{
$this->channel->basic_consume($this->taskId, '', false, true, false, false, function ($message) {
$this->message = $message;
});
// Get message from result queue with timeout
$timeout = $timeout === null ? $this->timeout : $timeout;
try {
$this->channel->wait(null, false, $timeout);
} catch (AMQPTimeoutException $e) {
throw new Errors\ClientException(sprintf("Task '%s' result is not available after %s seconds (taskId: %s)", $this->taskName, $timeout, $this->taskId));
}
}
/**
* @param string $queueName
* @param callable $callback
*
* @throws ConnectorException
* @throws \Exception
*/
public function basicConsume($queueName, $callback)
{
$this->logger->info(sprintf('Comsuming queue "%s"...', $queueName));
try {
$this->channel->basic_consume($queueName, '', false, false, false, false, $callback);
} catch (\Exception $e) {
if ($e instanceof AMQPExceptionInterface) {
throw ConnectorException::internalException($e);
} else {
throw $e;
}
}
}
/**
* 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'));
}
public function __construct()
{
$this->connection = new AMQPStreamConnection('localhost', 5672, 'guest', 'guest');
$this->channel = $this->connection->channel();
list($this->callback_queue, , ) = $this->channel->queue_declare("", false, false, true, false);
$this->channel->basic_consume($this->callback_queue, '', false, false, false, false, [$this, 'on_response']);
}
