PHP SqsClient::sendMessageBatch方法代码示例

 /**
  * @inheritdoc
  *
  * @throws \InvalidArgumentException
  * @throws InvalidMessageException
  * @throws QueueAccessException
  */
 public function addMessages($queueName, $messages, Priority $priority = null)
 {
     if (empty($queueName)) {
         throw new \InvalidArgumentException('Queue name empty or not defined.');
     }
     if (null === $priority) {
         $priority = $this->priorityHandler->getDefault();
     }
     $i = 0;
     $batch = [];
     $totalMessagesCount = count($messages);
     foreach ($messages as $index => $message) {
         if (empty($message)) {
             throw new InvalidMessageException($message, 'Message empty or not defined.');
         }
         $messageData = ['Id' => (string) $index, 'MessageBody' => serialize($message)];
         $batch[] = $messageData;
         if (++$i < $totalMessagesCount && count($batch) < self::SENT_MESSAGES_BATCH_SIZE) {
             continue;
         }
         try {
             $queueUrl = $this->sqsClient->getQueueUrl(['QueueName' => $this->getQueueNameWithPrioritySuffix($queueName, $priority)])->get('QueueUrl');
             $this->sqsClient->sendMessageBatch(['QueueUrl' => $queueUrl, 'Entries' => $batch]);
         } catch (SqsException $e) {
             throw new QueueAccessException('Cannot add messages in queue.', 0, $e);
         }
         $batch = [];
     }
     return $this;
 }

 /**
  * Valid option is:
  *      - delay_seconds: the duration (in seconds) the message has to be delayed
  *
  * Please note that for this to work, the index for the job AND the option must match
  *
  * {@inheritDoc}
  */
 public function batchPush(array $jobs, array $options = array())
 {
     // SQS can only handle up to 10 jobs, so if we have more jobs, we handle them in slices
     if (count($jobs) > 10) {
         do {
             $splicedJobs = array_splice($jobs, 0, 10);
             $this->batchPush($splicedJobs, $options);
         } while (count($splicedJobs) >= 10);
         return;
     }
     // SQS throws an exception if no jobs are inserted, which can happen due to the slicing method
     if (empty($jobs)) {
         return;
     }
     $parameters = array('QueueUrl' => $this->queueOptions->getQueueUrl(), 'Entries' => array());
     /** @var $job JobInterface */
     foreach ($jobs as $key => $job) {
         $jobParameters = array('Id' => $key, 'MessageBody' => $this->serializeJob($job), 'DelaySeconds' => isset($options[$key]['delay_seconds']) ? $options[$key]['delay_seconds'] : null);
         $parameters['Entries'][] = array_filter($jobParameters, function ($value) {
             return $value !== null;
         });
     }
     $result = $this->sqsClient->sendMessageBatch($parameters);
     $messages = $result['Successful'];
     foreach ($messages as $message) {
         $batchId = $message['Id'];
         $jobs[$batchId]->setMetadata(array('__id__' => $message['MessageId'], 'md5' => $message['MD5OfMessageBody']));
     }
 }

 /**
  * This can be used to send up to 10 entries and up to a total of 264kb
  *
  * {@inheritDoc}
  */
 public function sendMessageBatch($messageBodies = [], $queueId = null)
 {
     if (!is_array($messageBodies)) {
         throw new \Exception("MessageBodies must be an array");
     }
     $queueUrl = $this->getQueueUrl($queueId);
     $entries = [];
     foreach ($messageBodies as $key => $body) {
         $entries[] = ["Id" => $key, "MessageBody" => json_encode($body)];
     }
     $this->queueClient->sendMessageBatch(["QueueUrl" => $queueUrl, "Entries" => $entries]);
 }

 /**
  * @see http://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sqs-2012-11-05.html#sendmessagebatch
  * @param array $messages
  */
 public function batchPublish(array $messages)
 {
     $j = 0;
     for ($i = 0; $i < count($messages); $i += 10) {
         $entries = array();
         $toSend = array_slice($messages, $i, 10);
         foreach ($toSend as $message) {
             $entries[] = array_merge(array('MessageBody' => $message['msgBody'], 'Id' => $j++), $this->getClientParams(@$message['routingKey'], @$message['additionalProperties']));
         }
         $result = $this->client->sendMessageBatch(array('QueueUrl' => $this->queueUrl, 'Entries' => $entries));
         if (($ok = count($result->get('Successful'))) != ($tot = count($toSend))) {
             throw new \RuntimeException("Batch sending of messages failed - {$ok} ok out of {$tot}");
         }
     }
 }

 /**
  * Message batch processing
  *
  * @param $messages
  * @return mixed
  */
 public function enqueueAll(MessageCollectionInterface $messages)
 {
     $serializer = $this->getEncoder();
     $request = ['QueueUrl' => $this->getUrl(), 'Entries' => []];
     $messages = $messages->getMessages();
     foreach (array_chunk($messages, $this->config->getBatchSize()) as $chunk) {
         foreach ($chunk as $id => $message) {
             $request['Entries'][$id] = ['Id' => $id, 'DelaySeconds' => $this->getMessageDelay($message), 'QueueUrl' => $this->getUrl(), 'MessageBody' => $serializer->encode($message)];
         }
         $result = $this->client->sendMessageBatch($request);
         $items = $result->getPath('Successful') ?: [];
         foreach ($items as $item) {
             $messages[$item['Id']]->setId($item['MessageId']);
         }
     }
 }

 /**
  * Flush a queue
  *
  * @param  bool $async
  * @return void
  */
 private function doFlush(bool $async)
 {
     // SQS only supports batch of 10, so we need to splice like that
     while (!empty($this->messages)) {
         $messagesToPush = array_splice($this->messages, 0, 10);
         $parameters = ['QueueUrl' => $this->url, 'Entries' => []];
         foreach ($messagesToPush as $key => $message) {
             $messageParameters = ['Id' => $key, 'MessageBody' => json_encode($message['body'], self::DEFAULT_JSON_FLAGS), 'DelaySeconds' => $message['options']['delay_seconds'] ?? null];
             $parameters['Entries'][] = array_filter($messageParameters, function ($value) {
                 return $value !== null;
             });
         }
         if ($async) {
             $this->sqsClient->sendMessageBatchAsync($parameters);
         } else {
             $this->sqsClient->sendMessageBatch($parameters);
         }
     }
 }

 protected function sendMessageBatch(array $payrolls, array $attributes, $delay)
 {
     $entries = [];
     foreach ($payrolls as $idx => $payroll) {
         $entry = ["Id" => "buf_{$idx}", "MessageBody" => $payroll];
         if ($delay) {
             $entry['DelaySeconds'] = $delay;
         }
         if ($attributes) {
             $entry['MessageAttributes'] = $attributes[$idx];
         }
         $entries[] = $entry;
     }
     $args = ["QueueUrl" => $this->getQueueUrl(), "Entries" => $entries];
     $result = $this->client->sendMessageBatch($args);
     if ($result['Failed']) {
         foreach ($result['Failed'] as $failed) {
             mwarning(sprintf("Batch sending message failed, code = %s, id = %s, msg = %s, senderfault = %s", $failed['Code'], $failed['Id'], $failed['Message'], $failed['SenderFault']));
         }
         throw new \RuntimeException("Cannot send some messages, consult log for more info!");
     }
 }