/**
* Mark a message as explicitly not acknowledged.
* RabbitMQ supports the nack method that provides all the functionality of
* basic.reject whilst also allowing for bulk processing of messages.
* To reject messages in bulk, clients set the multiple flag of the basic.nack method
* to true. The broker will then reject all unacknowledged, delivered messages up to
* and including the message specified in the delivery_tag field of the
* basic.nack method. In this respect, basic.nack complements the bulk acknowledgement
* semantics of basic.ack.
*
* @param integer $flags AMQP_MULTIPLE to nack all previous unacked messages as well.
* AMQP_REQUEUE to requeue the message(s),
*
* @return bool
*/
public function nack($flags = AMQP_REQUEUE)
{
if (!$this->consumed) {
return $this->consumed = $this->queue->nack($this->getDeliveryTag(), $flags);
}
return $this->consumed;
}
private function _initPublisher()
{
if (!$this->open()) {
return false;
}
if ($this->_exchange) {
return true;
}
$channel = new AMQPChannel($this->_conn);
//创建exchange
$this->_exchange = new AMQPExchange($channel);
$this->_exchange->setName($this->_connInfo['exchangeName']);
$this->_exchange->setType(AMQP_EX_TYPE_DIRECT);
$this->_exchange->setFlags(AMQP_DURABLE);
if (!$this->_exchange->declareExchange()) {
$this->close();
return false;
}
//创建队列,生产者和消费者都要创建队列
$queue = new AMQPQueue($channel);
$queue->setName($this->_connInfo['queueName']);
$queue->setFlags(AMQP_DURABLE);
$queue->declareQueue();
$queue->bind($this->_connInfo['exchangeName'], $this->_connInfo['routingKey']);
return true;
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$output->writeln(sprintf('Move messages from queue "%s" (vhost: "%s") to exchange "%s" with routingKey "%s" (vhost: "%s")', $input->getArgument('from_queue'), $input->getArgument('from_vhost'), $input->getArgument('to_exchange'), $input->getArgument('to_routing_key'), $input->getArgument('to_vhost')));
$fromChannel = $this->getChannel($input->getArgument('from_connection'), $input->getArgument('from_vhost'));
if (null === ($toConnectionName = $input->getOption('to_connection'))) {
$toChannel = $this->getChannel($input->getArgument('from_connection'), $input->getArgument('to_vhost'));
} else {
$toChannel = $this->getChannel($input->getOption('to_connection'), $input->getArgument('to_vhost'));
}
$queue = new \AMQPQueue($fromChannel);
$queue->setName($input->getArgument('from_queue'));
$exchange = new \AMQPExchange($toChannel);
$exchange->setName($input->getArgument('to_exchange'));
$messageProvider = new PeclPackageMessageProvider($queue);
$messagePublisher = new PeclPackageMessagePublisher($exchange);
$options = array();
$stack = new \Swarrot\Processor\Stack\Builder();
if (0 !== ($max = (int) $input->getOption('max-messages'))) {
$stack->push('Swarrot\\Processor\\MaxMessages\\MaxMessagesProcessor');
$options['max_messages'] = $max;
}
$stack->push('Swarrot\\Processor\\Insomniac\\InsomniacProcessor');
$stack->push('Swarrot\\Processor\\Ack\\AckProcessor', $messageProvider);
$processor = $stack->resolve(new MoveProcessor($messagePublisher, $input->getArgument('to_routing_key')));
$consumer = new Consumer($messageProvider, $processor);
$consumer->consume($options);
}
/**
* @param \AMQPEnvelope $envelope
* @param \AMQPQueue $queue
* @param PushPipe $pushPipe
* @param string $errorQueue
* @param ReceiveCancellationToken $cancellationToken
* @param EndpointControlToken $endpointControlToken
*
* @return bool
*/
public function process(\AMQPEnvelope $envelope, \AMQPQueue $queue, PushPipe $pushPipe, $errorQueue, ReceiveCancellationToken $cancellationToken, EndpointControlToken $endpointControlToken)
{
try {
$messageId = '';
$headers = [];
$pushMessage = false;
try {
$messageId = $this->messageConverter->retrieveMessageId($envelope);
$headers = $this->messageConverter->retrieveHeaders($envelope);
$pushMessage = true;
} catch (\Exception $e) {
$this->routingTopology->sendToQueue($this->brokerModel, $errorQueue, $envelope->getBody(), ['headers' => $envelope->getHeaders()]);
}
if ($pushMessage) {
$pushPipe->push(new PushContext($messageId, $headers, $envelope->getBody() ?: '', $cancellationToken, $endpointControlToken));
}
if ($cancellationToken->isCancellationRequested()) {
$queue->reject($envelope->getDeliveryTag(), AMQP_REQUEUE);
} else {
$queue->ack($envelope->getDeliveryTag());
}
} catch (CriticalErrorException $e) {
// just ... die
throw $e;
} catch (\Exception $e) {
$queue->reject($envelope->getDeliveryTag(), AMQP_REQUEUE);
}
if ($endpointControlToken->isShutdownRequested()) {
return false;
}
return true;
}
public function Run()
{
// Declare a new exchange
$ex = new AMQPExchange($this->cnn);
$ex->declare('game', AMQP_EX_TYPE_FANOUT);
// Create a new queue
$q1 = new AMQPQueue($this->cnn);
$q1->declare('queue1');
$q2 = new AMQPQueue($this->cnn);
$q2->declare('queue2');
// Bind it on the exchange to routing.key
//$ex->bind('queue1', 'broadcast=true,target=queue1,x-match=any');
$ex->bind('queue1', '');
$ex->bind('queue2', '');
$msgBody = 'hello';
// Publish a message to the exchange with a routing key
$ex->publish($msgBody, 'foo');
// Read from the queue
$msg = $q1->consume();
$this->AssertEquals(count($msg), 1);
$this->AssertEquals($msg[0]['message_body'], $msgBody, 'message not equal');
// Read from the queue
$msg = $q2->consume();
$this->AssertEquals(count($msg), 1);
$this->AssertEquals($msg[0]['message_body'], $msgBody, 'message not equal');
$this->AddMessage(var_export($msg[0], true));
}
/**
* Bind queue to exchange using dispatcher event names as routing keys
*
* @return void
* @throws AMQPExchangeException
*/
public function bind(\AMQPQueue $queue, \AMQPExchange $exchange)
{
$events = preg_grep($this->pattern, array_keys($this->getDispatcher()->getListeners()));
foreach ($events as $eventName) {
$queue->bind($exchange->getName(), $eventName);
}
$this->dispatcher->dispatch(static::BIND_EVENT, new SymfonyEvent($events, ["pattern" => $this->pattern, "exchange" => $exchange->getName(), "queue" => $queue->getName()]));
}
public function declareQueue($name, $flags = AMQP_DURABLE)
{
$queue = new \AMQPQueue($this->channel);
$queue->setName($name);
$queue->setFlags($flags);
$queue->declareQueue();
return $queue;
}
protected function getAMQPQueue($name)
{
$connection = new \AMQPConnection(array('vhost' => 'swarrot'));
$connection->connect();
$channel = new \AMQPChannel($connection);
$queue = new \AMQPQueue($channel);
$queue->setName($name);
return $queue;
}
/**
* @param string $name
*
* @return \AMQPQueue
*/
protected function getQueue($name)
{
if (!isset($this->queues[$name])) {
$queue = new \AMQPQueue($this->getChannel());
$queue->setName($name);
$this->queues[$name] = $queue;
}
return $this->queues[$name];
}
/**
* {@inheritDoc}
*/
public function register(Container $c)
{
$c['amqp.connections.initializer'] = function ($c) {
$config = $c['amqp.options'];
$connections = array();
if (isset($config['connections'])) {
foreach ($config['connections'] as $name => $options) {
$connections[$name] = new \AMQPConnection($options);
}
return $connections;
}
if (isset($config['connection'])) {
return array('default' => new \AMQPConnection($config['connection']));
}
throw new \LogicException('No connection defined');
};
$c['queue.factory'] = function ($c) {
$connections = $c['amqp.connections.initializer'];
return function ($queueName, $connectionName = null) use($connections) {
$names = array_keys($connections);
if (null === $connectionName) {
$connectionName = reset($names);
}
if (!array_key_exists($connectionName, $connections)) {
throw new \InvalidArgumentException(sprintf('Unknown connection "%s". Available: [%s]', $connectionName, implode(', ', $names)));
}
$connection = $connections[$connectionName];
if (!$connection->isConnected()) {
$connection->connect();
}
$channel = new \AMQPChannel($connection);
$queue = new \AMQPQueue($channel);
$queue->setName($queueName);
return $queue;
};
};
$c['exchange.factory'] = function ($c) {
$connections = $c['amqp.connections.initializer'];
return function ($exchangeName, $connectionName = null) use($connections) {
$names = array_keys($connections);
if (null === $connectionName) {
$connectionName = reset($names);
}
if (!array_key_exists($connectionName, $connections)) {
throw new \InvalidArgumentException(sprintf('Unknown connection "%s". Available: [%s]', $connectionName, implode(', ', $names)));
}
$connection = $connections[$connectionName];
if (!$connection->isConnected()) {
$connection->connect();
}
$channel = new \AMQPChannel($connection);
$exchange = new \AMQPExchange($channel);
$exchange->setName($exchangeName);
return $exchange;
};
};
}
public function get($queueName, $timeout = null)
{
if (null === $this->queue) {
$queue = new \AMQPQueue($this->channel);
$queue->setName($queueName);
$queue->declare();
}
return unserialize($queue->consume());
}
/**
* @inheritdoc
*/
public function createQueue(ChannelInterface $channel, $name = null, $flags = null, array $args = [])
{
$delegate = new \AMQPQueue($channel->getDelegate());
$delegate->setFlags(Queue::convertToDelegateFlags($flags));
$delegate->setArguments($args);
if (null !== $name) {
$delegate->setName($name);
}
return new Queue($delegate, $channel);
}
/**
* @param \AMQPQueue $queue
* @return bool|string
*/
public static function read(\AMQPQueue $queue)
{
usleep(10000);
$envelope = $queue->get(\AMQP_NOPARAM);
if ($envelope) {
$message = $envelope->getBody();
$queue->ack($envelope->getDeliveryTag());
return $message;
}
return false;
}
/**
* @test
*/
public function it_should_reject_a_envelope_when_there_is_a_exception()
{
$middleware = new ConsumeMiddleware(false);
$this->queue->shouldNotReceive('ack')->with('tag');
$this->queue->shouldReceive('reject')->once()->with('tag', AMQP_NOPARAM);
$this->envelope->shouldReceive('getDeliveryTag')->withNoArgs()->andReturn('tag');
$this->setExpectedException(\RuntimeException::class, 'The queue should reject the message now');
$middleware->execute($this->command, function () {
throw new \RuntimeException('The queue should reject the message now');
});
}
public function Run()
{
// Declare a new exchange
$ex = new AMQPExchange($this->cnn);
$ex->declare('game', AMQP_EX_TYPE_TOPIC);
// Create a new queue
$q1 = new AMQPQueue($this->cnn);
$q1->declare('queue1');
$q1->purge('queue1');
$q2 = new AMQPQueue($this->cnn);
$q2->declare('queue2');
$q1->purge('queue2');
$q3 = new AMQPQueue($this->cnn);
$q3->declare('queue3');
$q3->purge('queue3');
$options = array('min' => 0, 'max' => 10, 'ack' => true);
// Bind it on the exchange to routing.key
$ex->bind('queue1', 'game1.#');
$ex->bind('queue2', 'game1.#');
$ex->bind('queue3', 'game1.#');
$ex->bind('queue3', 'queue3.#');
$msgbody1 = 'hello';
// Publish a message to the exchange with a routing key
$result = $ex->publish($msgbody1, 'game1.msg');
$this->AssertEquals($result, TRUE, 'publish message failed');
$msgbody2 = 'world';
// Publish a message to the exchange with a routing key
$result = $ex->publish($msgbody2, 'game1.msg');
$this->AssertEquals($result, TRUE, 'publish message failed');
$msgbody3 = 'hello player3';
// Publish a message to the exchange with a routing key
$result = $ex->publish($msgbody3, 'queue3.command');
$this->AssertEquals($result, TRUE, 'publish message failed');
// Read from the queue
$msg = $q1->consume($options);
$this->AddMessage(var_export($msg, true));
$this->AssertEquals(count($msg), 2);
$this->AssertEquals($msg[0]['message_body'], $msgbody1, 'message not equal');
$this->AssertEquals($msg[1]['message_body'], $msgbody2, 'message not equal');
// Read from the queue
$msg = $q2->consume($options);
$this->AssertEquals(count($msg), 2);
$this->AssertEquals($msg[0]['message_body'], $msgbody1, 'message not equal');
$this->AssertEquals($msg[1]['message_body'], $msgbody2, 'message not equal');
// Read from the queue
$msg = $q3->consume($options);
$this->AddMessage(var_export($msg, true));
$this->AssertEquals(count($msg), 3);
$this->AssertEquals($msg[0]['message_body'], $msgbody1, 'message not equal');
$this->AssertEquals($msg[1]['message_body'], $msgbody2, 'message not equal');
$this->AssertEquals($msg[2]['message_body'], $msgbody3, 'message not equal');
$msg = $q3->consume($options);
$this->AssertEquals(count($msg), 0);
}
public function take()
{
$q = new \AMQPQueue($this->amqpChannel);
$q->setName($this->name);
$msg = $q->get();
if (empty($msg)) {
return false;
} else {
return new MessageTakeControl($q, $msg);
}
}
/**
* getQueue.
*
* @param string $name
* @param string $connection
*
* @return \AMQPQueue
*/
public function getQueue($name, $connection)
{
if (!isset($this->queues[$connection][$name])) {
if (!isset($this->queues[$connection])) {
$this->queues[$connection] = array();
}
$queue = new \AMQPQueue($this->getChannel($connection));
$queue->setName($name);
$this->queues[$connection][$name] = $queue;
}
return $this->queues[$connection][$name];
}
public function Run()
{
// Declare a new exchange
$ex = new AMQPExchange($this->cnn);
$ex->declare('game', AMQP_EX_TYPE_HEADER);
// Create a new queue
$q1 = new AMQPQueue($this->cnn);
$q1->declare('queue1');
$q1->purge('queue1');
$q2 = new AMQPQueue($this->cnn);
$q2->declare('queue2');
$q1->purge('queue2');
$q3 = new AMQPQueue($this->cnn);
$q3->declare('queue3');
$q3->purge('queue3');
$options = array('min' => 0, 'max' => 10, 'ack' => true);
// Bind it on the exchange to routing.key
$ex->bind('queue1', 'broadcast=1,target=1,x-match=any');
$ex->bind('queue2', 'broadcast=1,target=2,x-match=any');
$ex->bind('queue3', 'broadcast=1,target=3,x-match=any');
$msgbody1 = 'hello';
// Publish a message to the exchange with a routing key
$result = $ex->publish($msgbody1, NULL, AMQP_IMMEDIATE, array('headers' => array('broadcast' => 1)));
$this->AssertEquals($result, TRUE, 'publish message failed');
$msgbody2 = 'world';
// Publish a message to the exchange with a routing key
$result = $ex->publish($msgbody2, NULL, AMQP_IMMEDIATE, array('headers' => array('broadcast' => 1)));
$this->AssertEquals($result, TRUE, 'publish message failed');
$msgbody3 = 'queue3';
// Publish a message to the exchange with a routing key
$result = $ex->publish($msgbody1, NULL, AMQP_IMMEDIATE, array('headers' => array('target' => 3)));
$this->AssertEquals($result, TRUE, 'publish message failed');
// Read from the queue
$msg = $q1->consume($options);
$this->AddMessage(var_export($msg, true));
$this->AssertEquals(count($msg), 2);
//$this->AssertEquals($msg[0]['message_body'], $msgbody1, 'message not equal');
//$this->AssertEquals($msg[1]['message_body'], $msgbody2, 'message not equal');
// Read from the queue
$msg = $q2->consume($options);
$this->AssertEquals(count($msg), 2);
//$this->AssertEquals($msg[0]['message_body'], $msgbody1, 'message not equal');
//$this->AssertEquals($msg[1]['message_body'], $msgbody2, 'message not equal');
// Read from the queue
$msg = $q3->consume($options);
$this->AssertEquals(count($msg), 3);
//$this->AssertEquals($msg[0]['message_body'], $msgbody1, 'message not equal');
//$this->AssertEquals($msg[1]['message_body'], $msgbody2, 'message not equal');
//$this->AssertEquals($msg[2]['message_body'], $msgbody3, 'message not equal');
}
/**
* {@inheritDoc}
*/
protected function setUpAmqp()
{
$this->conn = new \AMQPConnection(['host' => $_SERVER['AMQP_HOST'], 'port' => $_SERVER['AMQP_PORT'], 'login' => $_SERVER['AMQP_USER'], 'password' => $_SERVER['AMQP_PASS'], 'vhost' => $_SERVER['AMQP_VHOST']]);
$this->conn->connect();
$channel = new \AMQPChannel($this->conn);
$exchange = new \AMQPExchange($channel);
$exchange->setName('event_band.test.exchange');
$exchange->setFlags(AMQP_AUTODELETE);
$exchange->setType(AMQP_EX_TYPE_TOPIC);
$exchange->declareExchange();
$queue = new \AMQPQueue($channel);
$queue->setName('event_band.test.event');
$queue->declareQueue();
$queue->bind('event_band.test.exchange', 'event.#');
}
public function consume($queueName, $callBackFunction)
{
try {
$queue = new AMQPQueue($this->channel);
$queue->setName($queueName);
$queue->setFlags(AMQP_DURABLE);
$queue->declareQueue();
echo ' [*] Waiting for messages on ' . $queueName . '. To exit press CTRL+C ', PHP_EOL;
$queue->consume($callBackFunction);
} catch (AMQPQueueException $ex) {
print_r($ex);
} catch (Exception $ex) {
print_r($ex);
}
}
public static function setupConnection(\AMQPConnection $connection, $config)
{
$channel = new \AMQPChannel($connection);
$exchange = new \AMQPExchange($channel);
$exchange->setName($config['exchange_name']);
$exchange->setType(AMQP_EX_TYPE_DIRECT);
$exchange->setFlags(AMQP_DURABLE);
$exchange->declareExchange();
$queue = new \AMQPQueue($channel);
$queue->setName($config['queue_name']);
$queue->setFlags(AMQP_DURABLE);
$queue->declareQueue();
// $exchange->bind($config['queue_name'], 'gos.websocket.pusher');
return [$channel, $exchange, $queue];
}
public function Run()
{
// Create a new queue
$q1 = new AMQPQueue($this->cnn);
$q1->declare('queue1');
$q1->purge('queue1');
$options = array('min' => 0, 'max' => 10, 'ack' => true);
// Bind it on the exchange to routing.key
$q1->bind(\Constant\AMQPChannelConstant::AMF, \Constant\AMQPCommand::BingoBroadcast);
// Read from the queue
while (TRUE) {
$msg = $q1->consume($options);
var_dump($msg);
}
}
/**
* @param int $flags
*
* @return int
*/
public function delete($flags = Client::NOPARAM)
{
try {
return $this->rawQueue->delete($flags);
} catch (\Exception $e) {
ClientHelper::throwRightException($e);
}
}
/**
* {@inheritDoc}
*/
public function receive(array $eventNames, \Closure $callback)
{
$exchangeName = $this->exchange->getName();
foreach ($eventNames as $eventName) {
$this->queue->bind($exchangeName, $eventName);
}
$this->queue->consume(function (\AMQPEnvelope $envelope, \AMQPQueue $queue) use($callback) {
$message = $envelope->getBody();
$messageTag = $envelope->getDeliveryTag();
$status = call_user_func($callback, $message);
if ($status) {
$queue->ack($messageTag);
} else {
$queue->nack($messageTag);
}
});
}
/**
* @param \AMQPEnvelope $envelope
* @param \AMQPQueue $queue
* @param string $m
*/
public function publish($envelope, $queue, $m)
{
if ($m instanceof AmqpResp) {
$m = Json::encode($m->getData());
} elseif (is_object($m) || is_array($m)) {
$m = Json::encode($m);
}
$chanel = $this->getChanel();
// Точка доступа
// Точка обмена
$exchange = new \AMQPExchange($chanel);
$exchange->setFlags(AMQP_AUTODELETE | AMQP_DURABLE);
$attributes = array('correlation_id' => $envelope->getCorrelationId());
$routingKey = $envelope->getReplyTo();
if ($exchange->publish($m, $routingKey, AMQP_NOPARAM, $attributes)) {
$queue->ack($envelope->getDeliveryTag());
}
}
/**
* @return \AMQPQueue
*/
protected function getQueue()
{
if (!$this->queue) {
$this->queue = new \AMQPQueue($this->getChannel());
$this->queue->setName($this->queueConfig['name']);
$this->queue->setFlags($this->queueConfig['flags']);
$this->queue->declareQueue();
}
return $this->queue;
}
/**
* @param $queueName
* @return AMQPQueue
*/
public function getQueue($queueName)
{
return $this->container->asSingleton(__METHOD__ . $queueName, function () use($queueName) {
QueueEnum::validate($queueName);
$queue = null;
$connection = $this->getConnection(TypeEnum::READ);
if ($connection) {
if (class_exists('AMQPChannel')) {
// AMQP Version 1.0
$channel = new AMQPChannel($connection);
$queue = new AMQPQueue($channel);
$queue->setName($queueName);
} else {
$queue = new AMQPQueue($connection, $queueName);
}
}
return $queue;
});
}
public static function main()
{
self::$pool = new Pool(MAX_CONCURRENCY_JOB, \CALLWorker::class, []);
$conn_args = (require 'mq.config.php');
$e_name = 'e_linvo';
//交换机名
$q_name = 'q_linvo';
//队列名
$k_route = 'key_1';
//路由key
//创建连接和channel
$conn = new AMQPConnection($conn_args);
if (!$conn->connect()) {
write_log('mq.hx9999.com 无法连接上');
return;
}
$channel = new AMQPChannel($conn);
//创建交换机
$ex = new AMQPExchange($channel);
$ex->setName($e_name);
$ex->setType(AMQP_EX_TYPE_DIRECT);
//direct类型
$ex->setFlags(AMQP_DURABLE);
//持久化
//创建队列
$q = new AMQPQueue($channel);
$q->setName($q_name);
$q->setFlags(AMQP_DURABLE);
//持久化
while (True) {
$q->consume(function ($envelope, $queue) {
$msg = $envelope->getBody();
$queue->ack($envelope->getDeliveryTag());
//手动发送ACK应答
self::$pool->submit(new Sendsms($msg));
});
}
self::$pool->shutdown();
$conn->disconnect();
//睡眠
sleep(5);
}
/**
* {@inheritDoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$output->writeln(sprintf('Get %d messages from queue "%s"', $input->getOption('nb-messages'), $input->getArgument('queue')));
$fromChannel = $this->getChannel($input->getArgument('connection'), $input->getArgument('vhost'));
$queue = new \AMQPQueue($fromChannel);
$queue->setName($input->getArgument('queue'));
$noRequeue = $input->getOption('no-requeue');
$nbMessages = $input->getOption('nb-messages');
for ($i = 0; $i < $nbMessages; $i++) {
if ($noRequeue) {
$message = $queue->get(AMQP_AUTOACK);
} else {
$message = $queue->get();
}
if (false === $message) {
$output->writeln('No more messages in queue.');
return;
}
$output->writeln(print_r($message, true));
}
}
public function send($msg)
{
$channel = new \AMQPChannel($this->connection);
$exchange = new \AMQPExchange($channel);
$exchange->setFlags(AMQP_DURABLE);
$exchange->setName('exchange2');
$exchange->setType('direct');
//$exchange->declare();
$exchange->declareExchange();
$queue = new \AMQPQueue($channel);
$queue->setName('series');
$queue->setFlags(AMQP_DURABLE | AMQP_AUTODELETE);
//$queue->declare();
$queue->declareQueue();
$queue->bind('exchange2', 'series');
$channel->startTransaction();
$message = $exchange->publish(json_encode($msg), 'series', AMQP_MANDATORY, array('content_type' => 'application/json', 'delivery_mode' => 2));
$channel->commitTransaction();
if (!$message) {
throw new \SYSTEM\LOG\ERROR("Error: Message '" . $message . "' was not sent to queue.!");
}
}
