/**
* Process a single message and push it to the server URL
*
* @link http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features-managing-env-tiers.html
* @param array $message
* @param string $uri
* @param string $queueName
* @param string $queueUrl
* @param OutputInterface $output
* @return void
*/
private function processMessage(array $message, string $uri, string $queueName, string $queueUrl, OutputInterface $output)
{
$response = $this->httpClient->post($uri, ['headers' => ['User-Agent' => 'aws-sqsd/2.0', 'Content-Type' => 'application/json', 'X-Aws-Sqsd-Msgid' => $message['MessageId'], 'X-Aws-Sqsd-Queue' => $queueName, 'X-Aws-Sqsd-First-Received-At' => $message['Attributes']['ApproximateFirstReceiveTimestamp'], 'X-Aws-Sqsd-Receive-Count' => $message['Attributes']['ApproximateReceiveCount'], 'X-Aws-Sqsd-Sender-Id' => $message['Attributes']['SenderId']], 'json' => json_decode($message['Body'], true)]);
if ($response->getStatusCode() === 200) {
$this->sqsClient->deleteMessage(['QueueUrl' => $queueUrl, 'ReceiptHandle' => $message['ReceiptHandle']]);
$output->writeln(sprintf('<info>Message "%s" has been processed and deleted from the queue "%s".</info>', $message['MessageId'], $queueName));
} else {
$output->writeln(sprintf('<error>Message "%s" could not be processed and back-end returned error %s. Reason: %s</error>', $message['MessageId'], $response->getStatusCode(), $response->getBody()));
}
}
/**
* {@inheritDoc}
*/
public function delete(MessageInterface $message)
{
if (null === $message->getAttribute('ReceiptHandle')) {
throw new QueueException('Message does not contain ReceiptHandle');
}
$result = $this->client->deleteMessage(array('ReceiptHandle' => $message->getAttribute('ReceiptHandle'), 'QueueUrl' => $this->queueUrl));
}
/**
* @inheritDoc
*/
public function ack($queueName, Envelope $envelope)
{
if (!$envelope instanceof SqsEnvelope) {
throw new InvalidEnvelope(sprintf('%s requires that envelopes be instances of "%s", got "%s"', __CLASS__, SqsEnvelope::class, get_class($envelope)));
}
$queueUrl = $this->getQueueUrl($queueName);
$this->client->deleteMessage(['QueueUrl' => $queueUrl, 'ReceiptHandle' => $envelope->getReceiptHandle()]);
}
/**
* @inheritdoc
*
* @throws \InvalidArgumentException
* @throws InvalidMessageException
* @throws QueueAccessException
*/
public function deleteMessage($queueName, $message)
{
if (empty($queueName)) {
throw new \InvalidArgumentException('Queue name empty or not defined.');
}
if (empty($message)) {
throw new InvalidMessageException($message, 'Message empty or not defined.');
}
if (!is_array($message)) {
throw new InvalidMessageException($message, 'Message must be an array.');
}
if (!isset($message['ReceiptHandle'])) {
throw new InvalidMessageException($message, 'ReceiptHandle not found in message.');
}
if (!isset($message['priority'])) {
throw new InvalidMessageException($message, 'Priority not found in message.');
}
$priority = $this->priorityHandler->getPriorityByLevel($message['priority']);
try {
$queueUrl = $this->sqsClient->getQueueUrl(['QueueName' => $this->getQueueNameWithPrioritySuffix($queueName, $priority)])->get('QueueUrl');
$this->sqsClient->deleteMessage(['QueueUrl' => $queueUrl, 'ReceiptHandle' => $message['ReceiptHandle']]);
} catch (SqsException $e) {
throw new QueueAccessException('Cannot delete message from queue.', 0, $e);
}
return $this;
}
/**
* Remove permanently a particular message from the queue
*
* @param MessageInterface $message
* @throws \Qu\Exception\OperationException
* @return void
*/
public function remove(MessageInterface $message)
{
try {
$this->client->deleteMessage(['QueueUrl' => $this->getUrl(), 'ReceiptHandle' => $message->getMetadata(static::RECEIPT_HANDLE_KEY)]);
} catch (\Exception $e) {
throw new OperationException($e->getMessage(), 0, $e);
}
$message->setMetadata(static::RECEIPT_HANDLE_KEY, null);
}
/**
* Delete the job from the queue.
*
* @param Job $job The job to be deleted.
*
* @return boolean whether the operation succeed.
*/
public function deleteJob(Job $job)
{
if (!empty($job->header['ReceiptHandle'])) {
$receiptHandle = $job->header['ReceiptHandle'];
$response = $this->_client->deleteMessage(['QueueUrl' => $this->url, 'ReceiptHandle' => $receiptHandle]);
return $response !== null;
} else {
return false;
}
}
/**
* {@inheritDoc}
*
* @return bool
*/
public function delete($id)
{
if (!$this->queueExists()) {
return false;
}
$this->sqs->deleteMessage(['QueueUrl' => $this->queueUrl, 'ReceiptHandle' => $id]);
$context = ['QueueUrl' => $this->queueUrl, 'ReceiptHandle' => $id];
$this->log(200, "Message deleted from SQS Queue", $context);
return true;
}
/**
* Deletes a message from the queue
*
* @param Message $message
* @return bool returns true if successful, false otherwise
*/
public function delete(Message $message)
{
try {
// Delete the message
$this->sqs_client->deleteMessage(array('QueueUrl' => $this->url, 'ReceiptHandle' => $message->receipt_handle));
return true;
} catch (Exception $e) {
echo 'Error deleting message from queue ' . $e->getMessage();
return false;
}
}
/**
* @param mixed[] $args
* @return Result
* @throws ExceptionInterface
*/
private function deleteSqsMessage(array $args = [])
{
if (array_key_exists('ReceiptHandle', $args) && $this->configuration->getDeleteFromS3()) {
// Split receipt handle into S3 and SQS information.
$decodedReceiptHandle = json_decode($args['ReceiptHandle'], true);
if (json_last_error() === JSON_ERROR_NONE) {
$s3Client = $this->configuration->getS3Client();
// Delete from S3.
$s3Client->deleteObject(array('Bucket' => $decodedReceiptHandle['s3_bucket_name'], 'Key' => $decodedReceiptHandle['s3_key']));
// Adjust SQS args.
$args['ReceiptHandle'] = $decodedReceiptHandle['original_receipt_handle'];
}
}
return $this->sqsClient->deleteMessage($args);
}
/**
* {@inheritdoc}
*/
public function wait(Closure $callback)
{
while (true) {
$result = $this->client->receiveMessage(array('QueueUrl' => $this->queueUrl, 'WaitTimeSeconds' => 20));
$messages = $result['Messages'];
if ($messages) {
foreach ($messages as $message) {
$hermesMessage = $this->serializer->unserialize($message['Body']);
$callback($hermesMessage);
$this->client->deleteMessage(array('QueueUrl' => $this->queueUrl, 'ReceiptHandle' => $message['ReceiptHandle']));
}
}
if ($this->sleepInterval) {
sleep($this->sleepInterval);
}
}
}
/**
* @inheritdoc
*
* @throws SqsException
*/
public function deleteMessage($queueName, $message)
{
if (empty($queueName)) {
throw new InvalidArgumentException('Parameter queueName empty or not defined.');
}
if (empty($message)) {
throw new InvalidArgumentException('Parameter message empty or not defined.');
}
if (!is_array($message)) {
throw new InvalidArgumentException('message must be an array.');
}
if (!isset($message['ReceiptHandle'])) {
throw new InvalidArgumentException('ReceiptHandle not found in message.');
}
if (!isset($message['priority'])) {
throw new InvalidArgumentException('Priority not found in message.');
}
$queueUrl = $this->sqsClient->getQueueUrl(['QueueName' => $this->getQueueNameWithPrioritySuffix($queueName, $message['priority'])])->get('QueueUrl');
$this->sqsClient->deleteMessage(['QueueUrl' => $queueUrl, 'ReceiptHandle' => $message['ReceiptHandle']]);
return $this;
}
/**
* {@inheritDoc}
*/
public function delete(JobInterface $job)
{
$parameters = array('QueueUrl' => $this->queueOptions->getQueueUrl(), 'ReceiptHandle' => $job->getMetadata('receiptHandle'));
$this->sqsClient->deleteMessage($parameters);
}
/**
* {@inheritDoc}
*/
public function completeMessage(QueueMessage $message)
{
$queueUrl = $this->getQueueUrl($message->getQueueId());
$this->queueClient->deleteMessage(["QueueUrl" => $queueUrl, "ReceiptHandle" => $message->getReceiptId()]);
}
require '../vendor/autoload.php';
use Aws\Sqs\SqsClient;
use Aws\S3\S3Client;
$s3 = new S3Client(['version' => S3_VERSION, 'region' => S3_REGION]);
$sqs = new SqsClient(['version' => SQS_VERSION, 'region' => SQS_REGION]);
$messageResult = $sqs->receiveMessage(array('QueueUrl' => SQS_OUTBOX, 'MaxNumberOfMessages' => 10, 'MessageAttributeNames' => array('s3path', 's3bucket', 'filename', 'smallfilename')));
$message = "";
if ($messageResult->getPath('Messages') != '') {
foreach ($messageResult->getPath('Messages') as $messages) {
$attr = array();
$receiptHandle = $messages['ReceiptHandle'];
foreach ($messages['MessageAttributes'] as $key => $value) {
$attr[$key] = $value['StringValue'];
$message = $attr['filename'] . " Resize Done.<br/>";
}
$sqs->deleteMessage(array('QueueUrl' => SQS_OUTBOX, 'ReceiptHandle' => $receiptHandle));
}
}
?>
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>AWS EC2 S3 SQS</title>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
<link rel="stylesheet" href="https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/themes/smoothness/jquery-ui.css">
<script src="https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.js"></script>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
<!-- Optional theme -->
<link rel="stylesheet"
public function deleteMessage(SqsReceivedMessage $msg)
{
$this->client->deleteMessage(["QueueUrl" => $this->getQueueUrl(), "ReceiptHandle" => $msg->getReceiptHandle()]);
}
/**
* Acknowledge a job
*
* @access public
* @param Job $job
* @return $this
*/
public function completed(Job $job)
{
$this->sqsClient->deleteMessage(array('QueueUrl' => $this->sqsUrl, 'ReceiptHandle' => $job->getId()));
return $this;
}
/**
* @param \Aws\Sqs\SqsClient $sqsClient
* @param $queueUrl
* @param $messageReceiptHandle
* @param \Psr\Log\LoggerInterface $logger
*/
function deleteQueueMessage(\Aws\Sqs\SqsClient $sqsClient, $queueUrl, $messageReceiptHandle, \Psr\Log\LoggerInterface $logger)
{
try {
$logger->info("deleting message on queue '{$queueUrl}' using message receipt: '{$messageReceiptHandle}'.");
$result = $sqsClient->deleteMessage(['QueueUrl' => $queueUrl, 'ReceiptHandle' => $messageReceiptHandle]);
} catch (\Aws\Sqs\Exception\SqsException $e) {
$logger->error("SqsException deleting message on queue '{$queueUrl}' using message receipt: " . "'{$messageReceiptHandle}'. Error: {$e->getMessage()}");
shutDown("ERROR deleting message on queue '{$queueUrl}' using message receipt: '{$messageReceiptHandle}'." . "Error: {$e->getMessage()}");
} catch (Exception $e) {
$logger->error("Exception deleting message on queue '{$queueUrl}' using message receipt: " . "'{$messageReceiptHandle}'. Error: {$e->getMessage()}");
shutDown("ERROR deleting message on queue '{$queueUrl}' using message receipt: '{$messageReceiptHandle}'." . "Error: {$e->getMessage()}");
}
}
/**
* @param MessageInterface $message
*
* @return boolean
*/
public function delete(MessageInterface $message)
{
return $this->client->deleteMessage(array('QueueUrl' => $this->getQueueUrl(), 'ReceiptHandle' => $message->getReceiptHandle()));
}
/**
* Delete the job from the queue.
*
* @return void
*/
public function delete()
{
$this->sqs->deleteMessage(array('QueueUrl' => $this->queue, 'ReceiptHandle' => $this->job['ReceiptHandle']));
}
public function deleteMessage(QueueMessage $message)
{
$this->client->deleteMessage(['QueueUrl' => $message->getQueueUrl(), 'ReceiptHandle' => $message->getReceiptHandle()]);
}
/**
* @param MessageReceivedInterface $message
* @param array $options
* @see https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sqs-2012-11-05.html#deletemessage
*/
public function deleteMessage(MessageReceivedInterface $message, array $options = [])
{
$params = $this->mergeParams([self::RECEIPT_HANDLE => $message->getReceptionRequestId()], $options);
$this->awsSqsClient->deleteMessage($params);
}
/**
* @inheritdoc
*/
public function delete(array $message)
{
$this->sqs->deleteMessage(['QueueUrl' => $message['queue'], 'ReceiptHandle' => $message['receipt-handle']]);
}
/**
* {@inheritdoc}
*/
public function delete()
{
parent::delete();
$this->sqs->deleteMessage(['QueueUrl' => $this->queue, 'ReceiptHandle' => $this->job['ReceiptHandle']]);
}
function it_deleteMessage_and_return_true_how_success(\Aws\Sqs\SqsClient $client)
{
$responseMock = unserialize(file_get_contents(__DIR__ . "/../../resources/deleteMessage"));
$client->deleteMessage(["QueueUrl" => "queue", "ReceiptHandle" => "sehrh"])->willReturn($responseMock);
$this->delete("sehrh", "queue")->shouldBe(true);
}
public function ack($identifier, $internals)
{
$this->client->deleteMessage(array('QueueUrl' => $this->queueUrl, 'ReceiptHandle' => $identifier));
}
/**
* {@inheritdoc}
*/
public function delete()
{
return $this->client->deleteMessage(['QueueUrl' => $this->url, 'ReceiptHandle' => $this->handle]);
}
/**
* @see http://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sqs-2012-11-05.html#receivemessage
* Will throw an exception if $amount is > 10.000
*
* @param int $amount
* @param int $timeout seconds
* @return nothing
*/
public function consume($amount, $timeout = 0)
{
$limit = $amount > 0 ? $amount : $this->requestBatchSize;
if ($timeout > 0) {
$startTime = time();
$remaining = $timeout;
}
$receiveParams = array('QueueUrl' => $this->queueUrl, 'MaxNumberOfMessages' => $limit, 'AttributeNames' => array('All'), 'MessageAttributeNames' => array('All'));
while (true) {
$reqTime = microtime(true);
if ($timeout > 0) {
// according to the spec, this is maximum wait time. If messages are available sooner, they get delivered immediately
$receiveParams['WaitTimeSeconds'] = $remaining;
}
$result = $this->client->receiveMessage($receiveParams);
$messages = $result->get('Messages');
if (is_array($messages)) {
foreach ($messages as $message) {
// How we implement routing keys with SQS: since it is not supported natively, we check if the route
// matches after having downloaded the message. If it does not match, we just skip processing it.
// Since we will not call deleteMessage, SQS will requeue the message in a short time.
// This is far from optimal, but it might be better than nothing
if (!$this->matchRoutingKey($message)) {
continue;
}
// removing the message from the queue is manual with SQS
$this->client->deleteMessage(array('QueueUrl' => $this->queueUrl, 'ReceiptHandle' => $message['ReceiptHandle']));
$data = $message['Body'];
unset($message['Body']);
$contentType = isset($message['MessageAttributes'][$this->contentTypeAttribute]['StringValue']) ? $message['MessageAttributes'][$this->contentTypeAttribute]['StringValue'] : '';
if ($contentType != '') {
$this->callback->receive(new Message($data, $message, $contentType, $this->queueName));
} else {
if ($this->logger) {
$this->logger->warning('The SQS Consumer received a message with no content-type attribute. Assuming default');
}
$this->callback->receive(new Message($data, $message, null, $this->queueName));
}
}
}
$this->maybeStopConsumer();
if ($amount > 0) {
return;
}
if ($timeout > 0 && ($remaining = $startTime + $timeout - time()) <= 0) {
return;
}
/// @todo use a parameter to decide the polling interval
// observe MAX 5 requests per sec per queue: sleep for 0.2 secs in between requests
$passedMs = (microtime(true) - $reqTime) * 1000000;
if ($passedMs < 200000) {
usleep(200000 - $passedMs);
}
}
}
