PHP AMQPStreamConnection::channel方法代码示例

 /**
  * Execute the console command.
  *
  * @return mixed
  */
 public function handle()
 {
     //
     $queue = 'cloudstack';
     $conn = new AMQPStreamConnection(Config::get('rabbitmq.host'), Config::get('rabbitmq.port'), Config::get('rabbitmq.user'), Config::get('rabbitmq.pass'), Config::get('rabbitmq.vhost'));
     $channel = $conn->channel();
     while ($message = $channel->basic_get($queue)) {
         $messageData = json_decode($message->body);
         // Don't think we care about messages that have no status or event
         if (empty($messageData->status) || empty($messageData->event)) {
             $channel->basic_ack($message->delivery_info['delivery_tag']);
             continue;
         }
         // For the moment, we don't care about non-Completed messages.
         if (!in_array($messageData->status, ['Completed', 'Created'])) {
             $channel->basic_ack($message->delivery_info['delivery_tag']);
             continue;
         }
         if (in_array($messageData->event, ['SNAPSHOT.CREATE', 'SNAPSHOT.DELETE', 'VM.CREATE', 'VM.DESTROY'])) {
             $messageHandled = $this->parseMessage($messageData);
         } else {
             $messageHandled = true;
         }
         if ($messageHandled == true) {
             $channel->basic_ack($message->delivery_info['delivery_tag']);
         }
     }
     $channel->close();
     $conn->close();
 }

 protected function getChannel()
 {
     if (null === $this->channel) {
         $this->channel = $this->connection->channel();
     }
     return $this->channel;
 }

 /**
  * @return ChannelInterface
  */
 public function getChannel()
 {
     if (is_null($this->channel)) {
         $this->channel = new Channel($this, $this->connection->channel());
     }
     return $this->channel;
 }

 /**
  * @param AMQPStreamConnection $connection
  * @param string $queueName
  */
 public function __construct(AMQPStreamConnection $connection, $queueName)
 {
     $this->connection = $connection;
     $this->channel = $this->connection->channel();
     $this->queueName = $queueName;
     $this->channel->queue_declare($this->queueName, false, true, false, false);
 }

 /**
  *
  */
 private function connect()
 {
     if (!$this->connection) {
         $this->connection = new AMQPStreamConnection($this->host, $this->port, 'guest', 'guest');
         $this->channel = $this->connection->channel();
         $this->channel->exchange_declare($this->channel_name, 'fanout', false, false, false);
     }
 }

 /**
  * Reconnect amqp connection
  */
 public function reconnect()
 {
     if (!$this->amqpConnection->isConnected()) {
         $this->amqpConnection->reconnect();
         $this->channel = $this->amqpConnection->channel();
         $this->declaredQueues = [];
     }
 }

 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);
 }

 /**
  * @param string $exchangeName
  */
 public function open($exchangeName)
 {
     if (null !== $this->channel) {
         return;
     }
     $channel = $this->connection->channel();
     $channel->queue_declare($exchangeName, false, true, false, false);
     $this->channel = $channel;
 }

 /**
  * Create a new RabbitMQ queue instance.
  *
  * @param \PhpAmqpLib\Connection\AMQPStreamConnection $amqpConnection
  * @param array                                       $config
  */
 public function __construct(AMQPStreamConnection $amqpConnection, $config)
 {
     $this->connection = $amqpConnection;
     $this->default = $config['queue'];
     $this->configQueue = $config['queue_params'];
     $this->configExchange = $config['exchange_params'];
     $this->declareExchange = $config['exchange_declare'];
     $this->declareBindQueue = $config['queue_declare_bind'];
     $this->channel = $this->connection->channel();
 }

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

 /**
  * @param AMQPStreamConnection $amqpConnection
  * @param string $queue Queue name
  * @param string $exchange Exchange name
  * @param null $key Routing key
  */
 public function __construct(AMQPStreamConnection $amqpConnection, $queue, $exchange = 'jsonbus', $key = null)
 {
     $this->connection = $amqpConnection;
     $this->channel = $this->connection->channel();
     $this->channel->exchange_declare($exchange, 'direct', false, true);
     $this->channel->queue_declare($queue, false, true);
     if (!$key) {
         $key = $queue;
     }
     $this->channel->queue_bind($queue, $exchange, $key);
     $this->exchange = $exchange;
     $this->queue = $queue;
 }

 /**
  * First tries to create exchange using passive flag.
  * If exchange does not exist, creates new with provided settings.
  * 
  * @param \PhpAmqpLib\Connection\AMQPStreamConnection $connection AMQP connection
  * @param string $name Exchange name
  * @param string $type Exchange type
  * @param array $params optional declare exchange parameters
  * @see self::$defaultDeclareExchangeParams
  */
 public static function declareExchange($connection, $name, $type, $params = [])
 {
     $params = array_replace(self::$defaultDeclareExchangeParams, $params);
     $ch = $connection->channel();
     try {
         $ch->exchange_declare($name, $type, true);
     } catch (AMQPProtocolChannelException $e) {
         $ch = $connection->channel();
         if ($params['arguments'] and is_array($params['arguments'])) {
             $params['arguments'] = new AMQPTable($params['arguments']);
         }
         $ch->exchange_declare($name, $type, false, $params['durable'], $params['auto_delete'], $params['internal'], $params['nowait'], $params['arguments']);
     }
 }

 /**
  * @param AMQPStreamConnection $conn
  */
 public function __construct(AMQPStreamConnection $conn)
 {
     $this->conn = $conn;
     $this->channel = $conn->channel();
     list($this->queueName) = $this->channel->queue_declare('', false, true, true, false);
     $this->channel->exchange_declare(self::TOPIC_NAME, self::MESSAGE_TYPE, false, true, true, false);
 }

 /**
  * @param bool $forceNewChannell
  *
  * @return void
  */
 protected function openChannel($forceNewChannell = false)
 {
     if (true == $forceNewChannell || false == $this->channel instanceof AMQPChannel) {
         $this->channel = $this->connection->channel();
         $this->logger->info('New channel opened!', [$this->channel->getChannelId()]);
     }
 }

 /**
  * Send an activity notice using AMQP
  * @param ActivityNotice $notice
  * @return bool
  */
 public function sendActivityNotice($notice)
 {
     if (!isset($notice)) {
         return false;
     }
     /** @var array $setting */
     $setting = $this->params['amqpSetting'];
     try {
         if ($this->amqpClientLibrary == "PhpAmqpLib") {
             $connection = new AMQPStreamConnection($setting['host'], $setting['port'], $setting['user'], $setting['password']);
             $channel = $connection->channel();
             $msg = new AMQPMessage(JsonHelper::encode($notice));
             $channel->basic_publish($msg, $setting['exchangeName'], $setting['routingKey']);
             $channel->close();
             $connection->close();
         } elseif ($this->amqpClientLibrary == "PECL") {
             $connection = new \AMQPConnection(['host' => $setting['host'], 'port' => $setting['port'], 'login' => $setting['user'], 'password' => $setting['password']]);
             $connection->connect();
             if ($connection->isConnected()) {
                 $channel = new \AMQPChannel($connection);
                 $exchange = new \AMQPExchange($channel);
                 $exchange->setName($setting['exchangeName']);
                 $exchange->publish(JsonHelper::encode($notice), $setting['routingKey']);
                 $connection->disconnect();
             }
         } else {
             return false;
         }
     } catch (\Exception $e) {
         return false;
     }
     return true;
 }