public static bool Get_Msg_From_Req_Q(out Amazon.SQS.Model.Message msg, out bool msgFound) { msgFound = false; msg = null; try { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.MaxNumberOfMessages = 1; receiveMessageRequest.QueueUrl = requests_Q_url; ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest); if (receiveMessageResponse.IsSetReceiveMessageResult()) { ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult; List<Amazon.SQS.Model.Message> receivedMsges = receiveMessageResponse.ReceiveMessageResult.Message; if (receivedMsges.Count == 0) { return true; } msgFound = true; msg = receivedMsges[0]; } } catch (AmazonSQSException ex) { Console.WriteLine("Caught Exception: " + ex.Message); Console.WriteLine("Response Status Code: " + ex.StatusCode); Console.WriteLine("Error Code: " + ex.ErrorCode); Console.WriteLine("Error Type: " + ex.ErrorType); Console.WriteLine("Request ID: " + ex.RequestId); Console.WriteLine("XML: " + ex.XML); return false; } return true; }
private void ReceiveMessage() { var receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = _handler.QueueUrl; var receiveMessageResponse = _sqsClient.ReceiveMessage(receiveMessageRequest); if (receiveMessageResponse.IsSetReceiveMessageResult() && receiveMessageResponse.ReceiveMessageResult.Message.Count > 0) { Console.WriteLine("Received message"); var receiveMessageResult = receiveMessageResponse.ReceiveMessageResult; foreach (Message message in receiveMessageResult.Message) { Console.WriteLine("Message body: {0}", message.Body); foreach (var handler in Container.GetAll<IServiceHandler>()) { //TODO - need to refactor this, multiple handlers means multiple deserialization if (handler.QueueName == _handler.QueueName && handler.IsRequestHandled(message)) { Console.WriteLine("Passing request to handler: {0}", handler.GetType().Name); handler.HandleRequest(message); } } } Console.WriteLine("Deleting message"); var messageRecieptHandle = receiveMessageResponse.ReceiveMessageResult.Message[0].ReceiptHandle; var deleteRequest = new DeleteMessageRequest() .WithQueueUrl(_handler.QueueUrl) .WithReceiptHandle(messageRecieptHandle); _sqsClient.DeleteMessage(deleteRequest); } }
public async Task<Amazon.SQS.Model.Message> GetMessage(string queueName, int timeoutInMilliseconds, int numberOfCacheableMessages) { Amazon.SQS.Model.Message message = null; if (_queue.ContainsKey(queueName) && _queue[queueName].TryDequeue(out message)) return message; var request = new ReceiveMessageRequest(queueName) { MaxNumberOfMessages = numberOfCacheableMessages, WaitTimeSeconds = (int)TimeSpan.FromMilliseconds(timeoutInMilliseconds).TotalSeconds }; using (var client = new AmazonSQSClient(_credentials)) { var response = await client.ReceiveMessageAsync(request); if (response.HttpStatusCode != HttpStatusCode.OK) return message; if (response.ContentLength == 0) return message; if (!response.Messages.Any()) return message; AddToQueue(queueName, response.Messages); if(_queue.ContainsKey(queueName)) _queue[queueName].TryDequeue(out message); } return message; }
/// <summary> /// Poll messages from the queue. Given the download process takes many hours there is extra /// long retry logic. /// </summary> /// <returns>The next message in the queue;</returns> Message readNextMessage() { int retryAttempts = 0; var receiveRequest = new ReceiveMessageRequest() { QueueUrl = this.queueUrl, MaxNumberOfMessages = 1 }; while (true) { try { var receiveResponse = this.sqsClient.ReceiveMessage(receiveRequest); retryAttempts = 0; if (receiveResponse.Messages.Count == 0) { Thread.Sleep((int)(this.options.PollingInterval * 1000 * 60)); continue; } return receiveResponse.Messages[0]; } catch (Exception) { retryAttempts++; if (retryAttempts <= MAX_OPERATION_RETRY) Thread.Sleep(60 * 1000); else throw; } } }
/// <summary> /// Poll messages from the queue. Given the download process takes many hours there is extra /// long retry logic. /// </summary> /// <returns>The next message in the queue;</returns> async Task<Message> readNextMessageAsync() { int retryAttempts = 0; var receiveRequest = new ReceiveMessageRequest() { QueueUrl = this.queueUrl, MaxNumberOfMessages = 1 }; while (true) { try { var receiveResponse = await this.sqsClient.ReceiveMessageAsync(receiveRequest).ConfigureAwait(false); retryAttempts = 0; if (receiveResponse.Messages.Count == 0) { await Task.Delay((int)(this.options.PollingInterval * 1000 * 60)).ConfigureAwait(false); continue; } return receiveResponse.Messages[0]; } catch (Exception) { retryAttempts++; if (retryAttempts <= MAX_OPERATION_RETRY) Task.Delay(1000 * 60).Wait(); else throw; } } }
public IMessage Next(int timeout) { try { var request = new ReceiveMessageRequest() { MaxNumberOfMessages = 1, QueueName = Name, VisibilityTimeout = timeout }; var response = _client.ReceiveMessage(request); var message = response.ReceiveMessageResult.Message.SingleOrDefault(); if (message == null) return null; return new AmazonMessage { Content = message.Body, Message = message }; } catch (AmazonSQSException e) { throw new MessageQueueException(string.Format("Failed to get next message for '{0}'.", Name), e); } }
public AlertMessage GetNextMessage() { //Receiving a message ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = queueUrl; ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest); if (receiveMessageResponse.IsSetReceiveMessageResult()) { Console.WriteLine("Printing received message.\n"); ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult; foreach (Message message in receiveMessageResult.Message) { AlertMessage m = new AlertMessage(); Console.WriteLine(" Message"); if (message.IsSetMessageId()) { Console.WriteLine(" MessageId: {0}", message.MessageId); } if (message.IsSetReceiptHandle()) { Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle); } if (message.IsSetMD5OfBody()) { Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody); } if (message.IsSetBody()) { m.Body = message.Body; Console.WriteLine(" Body: {0}", message.Body); } foreach (Amazon.SQS.Model.Attribute attribute in message.Attribute) { Console.WriteLine(" Attribute"); if (attribute.IsSetName() && attribute.Name == "Subject") { if (attribute.IsSetValue()) { m.Subject = attribute.Value; } } if (attribute.IsSetValue()) { Console.WriteLine(" Value: {0}", attribute.Value); } } // Deleting a message Console.WriteLine("Deleting the message.\n"); DeleteMessageRequest deleteRequest = new DeleteMessageRequest(); deleteRequest.QueueUrl = queueUrl; deleteRequest.ReceiptHandle = message.ReceiptHandle; sqs.DeleteMessage(deleteRequest); return m; } } return null; }
public virtual List<CombinedMarketDataRequest> GetRequests() { var client = this.GetClient(); var queueReceiveRequest = new ReceiveMessageRequest { MaxNumberOfMessages = 10, }; var response = client.ReceiveMessage(queueReceiveRequest); return Convert(response); }
public Message Receive(ReceiveMessageRequest request) { if (request == null) return null; request.MaxNumberOfMessages = 1; var response = SqsClient.ReceiveMessage(request); return response == null ? null : response.Messages.SingleOrDefault(); }
static void Main(string[] args) { // AWS: Get instance public address string myId = "localhost"; try { myId = Encoding.ASCII.GetString(new WebClient().DownloadData("http://169.254.169.254/latest/meta-data/public-hostname")); } catch { } // AWS SQS Client var sqsClient = new AmazonSQSClient(); while (true) { // Get the next message ReceiveMessageRequest request = new ReceiveMessageRequest() .WithQueueUrl("https://queue.amazonaws.com/*****/codeCampDemo") .WithMaxNumberOfMessages(1); var response = sqsClient.ReceiveMessage(request); foreach (var retrievedMessage in response.ReceiveMessageResult.Message) { var messageJson = JsonValue.Parse(retrievedMessage.Body); var message = messageJson["message"].ReadAs<string>(); Console.WriteLine(message); message = "Echo: " + message; string address = string.Format("http://{0}", messageJson["sender"].ReadAs<string>()); var connection = new HubConnection(address); connection.Start().Wait(); IHubProxy pongHub = connection.CreateProxy("MvcWebRole1.Hubs.EchoHub"); pongHub.Invoke("DoUpdateMessage", message, myId).Wait(); //Process the message and then delete the message DeleteMessageRequest deleteRequest = new DeleteMessageRequest() .WithQueueUrl("https://queue.amazonaws.com/******/codeCampDemo") .WithReceiptHandle(retrievedMessage.ReceiptHandle); sqsClient.DeleteMessage(deleteRequest); } Thread.Sleep(1000); } }
/// <summary> /// Instantiates the Poller. /// </summary> /// <param name="props"> /// A <see cref="MessageGearsProperties"/> /// </param> /// <param name="listener"> /// A <see cref="MessageGearsListener"/> /// </param> /// <param name="myAwsAccountKey"> /// You AWS Account Key /// </param> /// <param name="myAwsSecretKey"> /// Your AWS Secret Key /// </param> public MessageGearsAwsQueuePoller(MessageGearsAwsProperties props, MessageGearsListener listener) { this.props = props; this.emptyQueueDelayMillis = props.EmptyQueuePollingDelaySecs * 1000; this.listener = listener; AmazonSQSConfig config = new AmazonSQSConfig().WithMaxErrorRetry(props.SQSMaxErrorRetry); this.sqs = AWSClientFactory.CreateAmazonSQSClient (props.MyAWSAccountKey, props.MyAWSSecretKey, config); this.receiveMessageRequest = new ReceiveMessageRequest () .WithQueueUrl (props.MyAWSEventQueueUrl) .WithMaxNumberOfMessages (props.SQSMaxBatchSize) .WithAttributeName("ApproximateReceiveCount") .WithVisibilityTimeout(props.SQSVisibilityTimeoutSecs); this.deleteMessageRequest = new DeleteMessageRequest().WithQueueUrl(props.MyAWSEventQueueUrl); }
static void ReadFromQueue(AWSCredentials credentials) { AmazonSQSClient client = new AmazonSQSClient(credentials, RegionEndpoint.USEast1); string queueUrl = "https://sqs.us-east-1.amazonaws.com/025631894481/aws-talk"; ReceiveMessageRequest request = new ReceiveMessageRequest(queueUrl); request.MaxNumberOfMessages = 1; ReceiveMessageResponse response = client.ReceiveMessage(request); foreach (var message in response.Messages) { // Do something with the message } }
public static Message Get(string queue_url) { AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient(); ReceiveMessageRequest r_msgreq = new ReceiveMessageRequest(); r_msgreq.MaxNumberOfMessages = 1; r_msgreq.QueueUrl = queue_url; Decimal Vis_Timeout = System.Convert.ToDecimal(ConfigurationManager.AppSettings["SQS_Visibility"]); r_msgreq.VisibilityTimeout = Vis_Timeout; ReceiveMessageResponse r_msgres = sqs.ReceiveMessage(r_msgreq); //ChangeMessageVisibilityRequest chg_message_vis = new ChangeMessageVisibilityRequest(); //chg_message_vis.QueueUrl = ConfigurationManager.AppSettings["SQSUrl"]; //chg_message_vis.ReceiptHandle = r_msgres.ResponseMetadata.RequestId ReceiveMessageResult r_msgrst = r_msgres.ReceiveMessageResult; Message msg = r_msgrst.Message.FirstOrDefault(); return msg; }
private static ReceivedMessage Receive() { var request = new ReceiveMessageRequest { QueueUrl = _awsConfig.QueueUrl, MaxNumberOfMessages = 1 }; var response = _client.ReceiveMessage(request); if (response.Messages.Count == 0) return null; var message = response.Messages[0]; var json = message.Body; return new ReceivedMessage { Email = JsonConvert.DeserializeObject<EmailMessage>(json), ReceiptHandle = message.ReceiptHandle }; }
public List<QueueMessage> ListTop10Messages(string queueUrl) { var req = new ReceiveMessageRequest() { MaxNumberOfMessages = 10, QueueUrl = queueUrl }; req.AttributeName.Add("SentTimestamp"); req.AttributeName.Add("ApproximateReceiveCount"); req.AttributeName.Add("ApproximateFirstReceiveTimestamp"); var result = new List<QueueMessage>(10); var response = client.ReceiveMessage(req); if (response.IsSetReceiveMessageResult() && response.ReceiveMessageResult.IsSetMessage()) { DateTime epochDate = new DateTime(1970,1,1,0,0,0,DateTimeKind.Utc); foreach (Message msg in response.ReceiveMessageResult.Message) { var qm = new QueueMessage() { Body = msg.Body, ReceiptHandle = msg.ReceiptHandle }; if (msg.IsSetAttribute()) { foreach (Amazon.SQS.Model.Attribute att in msg.Attribute) { switch (att.Name) { case "SentTimestamp": qm.Sent = epochDate.AddMilliseconds(double.Parse(att.Value)); break; case "ApproximateReceiveCount": qm.ApproximateReceiveCount = Int32.Parse(att.Value); break; case "ApproximateFirstReceiveTimestamp": qm.FirstReceived = epochDate.AddMilliseconds(double.Parse(att.Value)); break; } } } result.Add(qm); } } return result; }
public static void SQSReceiveMessage() { #region SQSReceiveMessage var client = new AmazonSQSClient(); var request = new ReceiveMessageRequest { AttributeNames = new List<string>() { "All" }, MaxNumberOfMessages = 5, QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue", VisibilityTimeout = (int)TimeSpan.FromMinutes(10).TotalSeconds, WaitTimeSeconds = (int)TimeSpan.FromSeconds(5).TotalSeconds }; var response = client.ReceiveMessage(request); if (response.Messages.Count > 0) { foreach (var message in response.Messages) { Console.WriteLine("For message ID '" + message.MessageId + "':"); Console.WriteLine(" Body: " + message.Body); Console.WriteLine(" Receipt handle: " + message.ReceiptHandle); Console.WriteLine(" MD5 of body: " + message.MD5OfBody); Console.WriteLine(" MD5 of message attributes: " + message.MD5OfMessageAttributes); Console.WriteLine(" Attributes:"); foreach (var attr in message.Attributes) { Console.WriteLine(" " + attr.Key + ": " + attr.Value); } } } else { Console.WriteLine("No messages received."); } #endregion Console.ReadLine(); }
private void button2_Click(object sender, EventArgs e) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = myQueueUrl; ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest); if (receiveMessageResponse.IsSetReceiveMessageResult()) { ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult; foreach (Amazon.SQS.Model.Message message in receiveMessageResult.Message) { if (message.IsSetBody()) MessageBox.Show(message.Body); } } String messageRecieptHandle = receiveMessageResponse.ReceiveMessageResult.Message[0].ReceiptHandle; DeleteMessageRequest deleteRequest = new DeleteMessageRequest(); deleteRequest.QueueUrl = myQueueUrl; deleteRequest.ReceiptHandle = messageRecieptHandle; sqs.DeleteMessage(deleteRequest); }
private void ReceiveMessage() { var receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = _queueUrl; var receiveMessageResponse = _sqsClient.ReceiveMessage(receiveMessageRequest); if (receiveMessageResponse.IsSetReceiveMessageResult() && receiveMessageResponse.ReceiveMessageResult.Message.Count > 0) { Console.WriteLine("Received message at: {0}", DateTime.Now.ToLongTimeString()); var receiveMessageResult = receiveMessageResponse.ReceiveMessageResult; foreach (Message message in receiveMessageResult.Message) { Console.WriteLine("Message body: {0}", message.Body); } var response = receiveMessageResponse.FirstMessageAsResponse<QueryServiceResponse>(); if (response != null) { //fetch the data from the response store: Console.WriteLine("Fetching data at: {0}", DateTime.Now.ToLongTimeString()); var responseItems = DataStore.Current.Fetch(response.StoreIdentifier, response.ItemKey); var employees = new List<Employee>(responseItems.Count()); foreach (var responseItem in responseItems) { var employee = Serializer.Current.Deserialize(typeof(Employee), responseItem) as Employee; Console.WriteLine("Adding employee - {0}", employee); employees.Add(employee); } } Console.WriteLine("Deleting message"); var messageRecieptHandle = receiveMessageResponse.ReceiveMessageResult.Message[0].ReceiptHandle; var deleteRequest = new DeleteMessageRequest() .WithQueueUrl(_queueUrl) .WithReceiptHandle(messageRecieptHandle); _sqsClient.DeleteMessage(deleteRequest); Console.WriteLine("Completed at: {0}", DateTime.Now.ToLongTimeString()); } }
public override List<Job> ClaimJobs(string queue, int count) { List<Job> claimedJobs = new List<Job>(); try { ReceiveMessageRequest request = new ReceiveMessageRequest(); request.MaxNumberOfMessages = count; request.QueueUrl = GetQueueUrl(SanitiseQueueName(queue)); ReceiveMessageResponse response = client.ReceiveMessage(request); for (int i = 0; i < response.ReceiveMessageResult.Message.Count; i++) { Message message = response.ReceiveMessageResult.Message[i]; claimedJobs.Add(new Job(queue, message.MessageId, message.ReceiptHandle, message.Body)); } } catch (System.Net.WebException) { } return claimedJobs; }
public static string DequeueByQueueUrl(string queueUrl) { using (var client = new AmazonSQSClient(Settings.AccessKey, Settings.Secret)) { var request = new ReceiveMessageRequest() { QueueUrl = queueUrl }; var response = client.ReceiveMessage(request).Messages.First(); var body = response.Body; var deleteRequest = new DeleteMessageRequest { QueueUrl = queueUrl, ReceiptHandle = response.ReceiptHandle }; client.DeleteMessage(deleteRequest); return body; } }
/// <summary> /// <para>Retrieves one or more messages from the specified queue, including the message body and message ID of each message. Messages returned /// by this action stay in the queue until you delete them. However, once a message is returned to a <c>ReceiveMessage</c> request, it is not /// returned on subsequent <c>ReceiveMessage</c> requests for the duration of the <c>VisibilityTimeout</c> . If you do not specify a /// <c>VisibilityTimeout</c> in the request, the overall visibility timeout for the queue is used for the returned messages.</para> <para>If a /// message is available in the queue, the call will return immediately. Otherwise, it will wait up to <c>WaitTimeSeconds</c> for a message to /// arrive. If you do not specify <c>WaitTimeSeconds</c> in the request, the queue attribute ReceiveMessageWaitTimeSeconds is used to determine /// how long to wait.</para> <para>You could ask for additional information about each message through the attributes. Attributes that can be /// requested are <c>[SenderId, ApproximateFirstReceiveTimestamp, ApproximateReceiveCount, SentTimestamp]</c> .</para> /// </summary> /// /// <param name="receiveMessageRequest">Container for the necessary parameters to execute the ReceiveMessage service method on /// AmazonSQS.</param> /// /// <returns>The response from the ReceiveMessage service method, as returned by AmazonSQS.</returns> /// /// <exception cref="T:Amazon.SQS.Model.OverLimitException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public Task<ReceiveMessageResponse> ReceiveMessageAsync(ReceiveMessageRequest receiveMessageRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new ReceiveMessageRequestMarshaller(); var unmarshaller = ReceiveMessageResponseUnmarshaller.GetInstance(); return Invoke<IRequest, ReceiveMessageRequest, ReceiveMessageResponse>(receiveMessageRequest, marshaller, unmarshaller, signer, cancellationToken); }
/// <summary> /// <para> Retrieves one or more messages from the specified queue. Long poll support is enabled by using the <c>WaitTimeSeconds</c> parameter. /// For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html">Amazon /// SQS Long Poll</a> in the <i>Amazon SQS Developer Guide</i> . /// </para> <para> Short poll is the default behavior where a weighted random set of machines is sampled on a <c>ReceiveMessage</c> call. /// This means only the messages on the sampled machines are returned. If the number of messages in the queue is small (less than 1000), it is /// likely you will get fewer messages than you requested per <c>ReceiveMessage</c> call. If the number of messages in the queue is extremely /// small, you might not receive any messages in a particular <c>ReceiveMessage</c> response; in which case you should repeat the request. /// </para> <para> For each message returned, the response includes the following: </para> /// <ul> /// <li> <para> Message body </para> </li> /// <li> <para> MD5 digest of the message body. For information about MD5, go to <a href="http://www.faqs.org/rfcs/rfc1321.html">http://www.faqs.org/rfcs/rfc1321.html</a> . /// </para> </li> /// <li> <para> Message ID you received when you sent the message to the queue. </para> </li> /// <li> <para> Receipt handle. </para> </li> /// /// </ul> /// <para> The receipt handle is the identifier you must provide when deleting the message. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ImportantIdentifiers.html">Queue and Message /// Identifiers</a> in the <i>Amazon SQS Developer Guide</i> . /// </para> <para> You can provide the <c>VisibilityTimeout</c> parameter in your request, which will be applied to the messages that Amazon /// SQS returns in the response. If you do not include the parameter, the overall visibility timeout for the queue is used for the returned /// messages. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html">Visibility Timeout</a> in the <i>Amazon SQS Developer Guide</i> . /// </para> <para><b>NOTE:</b> Going forward, new attributes might be added. If you are writing code that calls this action, we recommend /// that you structure your code so that it can handle new attributes gracefully. </para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ReceiveMessage service method on /// AmazonSQS.</param> /// /// <returns>The response from the ReceiveMessage service method, as returned by AmazonSQS.</returns> /// /// <exception cref="T:Amazon.SQS.Model.OverLimitException" /> public ReceiveMessageResponse ReceiveMessage(ReceiveMessageRequest request) { var task = ReceiveMessageAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
internal ReceiveMessageResponse ReceiveMessage(ReceiveMessageRequest request) { var task = ReceiveMessageAsync(request); try { return task.Result; } catch(AggregateException e) { throw e.InnerException; } }
/// <summary> /// Retrieves one or more messages, with a maximum limit of 10 messages, from the /// specified queue. Long poll support is enabled by using the <code>WaitTimeSeconds</code> /// parameter. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html">Amazon /// SQS Long Poll</a> in the <i>Amazon SQS Developer Guide</i>. /// /// /// <para> /// Short poll is the default behavior where a weighted random set of machines is /// sampled on a <code>ReceiveMessage</code> call. This means only the messages /// on the sampled machines are returned. If the number of messages in the queue is small /// (less than 1000), it is likely you will get fewer messages than you requested /// per <code>ReceiveMessage</code> call. If the number of messages in the queue /// is extremely small, you might not receive any messages in a particular <code>ReceiveMessage</code> /// response; in which case you should repeat the request. /// </para> /// /// <para> /// For each message returned, the response includes the following: /// </para> /// <ul> <li> /// <para> /// Message body /// </para> /// </li> <li> /// <para> /// MD5 digest of the message body. For information about MD5, go to /// <a href="http://www.faqs.org/rfcs/rfc1321.html">http://www.faqs.org/rfcs/rfc1321.html</a>. /// /// </para> /// </li> <li> /// <para> /// Message ID you received when you sent the message to the queue. /// </para> /// </li> <li> /// <para> /// Receipt handle. /// </para> /// </li> <li> /// <para> /// Message attributes. /// </para> /// </li> <li> /// <para> /// MD5 digest of the message attributes. /// </para> /// </li> </ul> /// <para> /// The receipt handle is the identifier you must provide when deleting the message. /// For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ImportantIdentifiers.html">Queue /// and Message Identifiers</a> in the <i>Amazon SQS Developer Guide</i>. /// </para> /// /// <para> /// You can provide the <code>VisibilityTimeout</code> parameter in your request, /// which will be applied to the messages that Amazon SQS returns in the response. /// If you do not include the parameter, the overall visibility timeout for the queue /// is used for the returned messages. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html">Visibility /// Timeout</a> in the <i>Amazon SQS Developer Guide</i>. /// </para> /// <note> /// <para> /// Going forward, new attributes might be added. If you are writing code that /// calls this action, we recommend that you structure your code so that it can /// handle new attributes gracefully. /// </para> /// </note> /// </summary> /// <param name="queueUrl">The URL of the Amazon SQS queue to take action on.</param> /// /// <returns>The response from the ReceiveMessage service method, as returned by SQS.</returns> /// <exception cref="OverLimitException"> /// The action that you requested would violate a limit. For example, ReceiveMessage /// returns this error if the maximum number of messages inflight has already been /// reached. <a>AddPermission</a> returns this error if the maximum number of permissions /// for the queue has already been reached. /// </exception> public ReceiveMessageResponse ReceiveMessage(string queueUrl) { var request = new ReceiveMessageRequest(); request.QueueUrl = queueUrl; return ReceiveMessage(request); }
/// <summary> /// Initiates the asynchronous execution of the ReceiveMessage operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ReceiveMessage operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<ReceiveMessageResponse> ReceiveMessageAsync(ReceiveMessageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new ReceiveMessageRequestMarshaller(); var unmarshaller = ReceiveMessageResponseUnmarshaller.Instance; return InvokeAsync<ReceiveMessageRequest,ReceiveMessageResponse>(request, marshaller, unmarshaller, cancellationToken); }
public void pull_from_sqs_queue() { GetUserNameAndPassword(); var sqsClient = Amazon.AWSClientFactory.CreateAmazonSQSClient(_key, _secret); var queueUrl = sqsClient.ListQueues(new ListQueuesRequest().WithQueueNamePrefix("elliotts-blog")).ListQueuesResult. QueueUrl[0]; var timeToRunThisTest = new TimeSpan(0, 0, 0, 5); var stopAt = DateTime.Now.Add(timeToRunThisTest); while(DateTime.Now < stopAt) { var recieveMessageRequest = new ReceiveMessageRequest().WithQueueUrl(queueUrl); var recieveMessageResult = sqsClient.ReceiveMessage(recieveMessageRequest); foreach (var message in recieveMessageResult.ReceiveMessageResult.Message) { Trace.WriteLine(message.Body); } } }
public virtual List<Message> ReadMessages(AmazonSQSClient sqsClient, string queueUrl) { // Create the request var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = queueUrl, MaxNumberOfMessages = 10 }; // Submit the request and return the response ReceiveMessageResponse resp = sqsClient.ReceiveMessage(receiveMessageRequest); return resp.Messages; }
/// <summary> /// Initiates the asynchronous execution of the ReceiveMessage operation. /// <seealso cref="Amazon.SQS.IAmazonSQS.ReceiveMessage"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ReceiveMessage operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public async Task<ReceiveMessageResponse> ReceiveMessageAsync(ReceiveMessageRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new ReceiveMessageRequestMarshaller(); var unmarshaller = ReceiveMessageResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, ReceiveMessageRequest, ReceiveMessageResponse>(request, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// Initiates the asynchronous execution of the ReceiveMessage operation. /// <seealso cref="Amazon.SQS.IAmazonSQS"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ReceiveMessage operation on AmazonSQSClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReceiveMessage /// operation.</returns> public IAsyncResult BeginReceiveMessage(ReceiveMessageRequest request, AsyncCallback callback, object state) { var marshaller = new ReceiveMessageRequestMarshaller(); var unmarshaller = ReceiveMessageResponseUnmarshaller.Instance; return BeginInvoke<ReceiveMessageRequest>(request, marshaller, unmarshaller, callback, state); }
/// <summary> /// Retrieves one or more messages, with a maximum limit of 10 messages, from the /// specified queue. Long poll support is enabled by using the <code>WaitTimeSeconds</code> /// parameter. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html">Amazon /// SQS Long Poll</a> in the <i>Amazon SQS Developer Guide</i>. /// /// /// <para> /// Short poll is the default behavior where a weighted random set of machines is /// sampled on a <code>ReceiveMessage</code> call. This means only the messages /// on the sampled machines are returned. If the number of messages in the queue is small /// (less than 1000), it is likely you will get fewer messages than you requested /// per <code>ReceiveMessage</code> call. If the number of messages in the queue /// is extremely small, you might not receive any messages in a particular <code>ReceiveMessage</code> /// response; in which case you should repeat the request. /// </para> /// /// <para> /// For each message returned, the response includes the following: /// </para> /// <ul> <li> /// <para> /// Message body /// </para> /// </li> <li> /// <para> /// MD5 digest of the message body. For information about MD5, go to /// <a href="http://www.faqs.org/rfcs/rfc1321.html">http://www.faqs.org/rfcs/rfc1321.html</a>. /// /// </para> /// </li> <li> /// <para> /// Message ID you received when you sent the message to the queue. /// </para> /// </li> <li> /// <para> /// Receipt handle. /// </para> /// </li> <li> /// <para> /// Message attributes. /// </para> /// </li> <li> /// <para> /// MD5 digest of the message attributes. /// </para> /// </li> </ul> /// <para> /// The receipt handle is the identifier you must provide when deleting the message. /// For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ImportantIdentifiers.html">Queue /// and Message Identifiers</a> in the <i>Amazon SQS Developer Guide</i>. /// </para> /// /// <para> /// You can provide the <code>VisibilityTimeout</code> parameter in your request, /// which will be applied to the messages that Amazon SQS returns in the response. /// If you do not include the parameter, the overall visibility timeout for the queue /// is used for the returned messages. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html">Visibility /// Timeout</a> in the <i>Amazon SQS Developer Guide</i>. /// </para> /// <note> /// <para> /// Going forward, new attributes might be added. If you are writing code that /// calls this action, we recommend that you structure your code so that it can /// handle new attributes gracefully. /// </para> /// </note> /// </summary> /// <param name="request">Container for the necessary parameters to execute the ReceiveMessage service method.</param> /// /// <returns>The response from the ReceiveMessage service method, as returned by SQS.</returns> /// <exception cref="OverLimitException"> /// The action that you requested would violate a limit. For example, ReceiveMessage /// returns this error if the maximum number of messages inflight has already been /// reached. <a>AddPermission</a> returns this error if the maximum number of permissions /// for the queue has already been reached. /// </exception> public ReceiveMessageResponse ReceiveMessage(ReceiveMessageRequest request) { var marshaller = new ReceiveMessageRequestMarshaller(); var unmarshaller = ReceiveMessageResponseUnmarshaller.Instance; return Invoke<ReceiveMessageRequest,ReceiveMessageResponse>(request, marshaller, unmarshaller); }