Пример #1
0
        /// <summary>
        /// Gets the messages impl.
        /// </summary>
        /// <param name="numberOfMessages">The number of messages.</param>
        /// <param name="visibilityTimeout">The visibility timeout.</param>
        /// <param name="setResult">The set result.</param>
        /// <returns>A <see cref="TaskSequence"/> that gets the message.</returns>
        private TaskSequence GetMessagesImpl(int? numberOfMessages, TimeSpan? visibilityTimeout, Action<IEnumerable<CloudQueueMessage>> setResult)
        {
            if (visibilityTimeout.HasValue)
            {
                CommonUtils.AssertInBounds("visibiliyTimeout", visibilityTimeout.Value, TimeSpan.Zero, TimeSpan.MaxValue);
            }

            if (numberOfMessages.HasValue)
            {
                CommonUtils.AssertInBounds("numberOfMessage", numberOfMessages.Value, 0, int.MaxValue);
            }

            int? visibilityTimeoutInSec = visibilityTimeout != null ? visibilityTimeout.RoundUpToSeconds() : (int?)null;

            var webRequest = QueueRequest.GetMessages(this.MessageRequestAddress, this.ServiceClient.Timeout.RoundUpToSeconds(), numberOfMessages, visibilityTimeoutInSec);
            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
            this.ServiceClient.Credentials.SignRequest(webRequest);
            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
            yield return task;

            using (var webResponse = task.Result as HttpWebResponse)
            {
                var parsedResponse = QueueResponse.GetMessages(webResponse);
                setResult(MaterializeAndParseResponse(parsedResponse.Messages, this.SelectGetMessageResponse));
            }
        }
Пример #2
0
        /// <summary>
        /// Implementation for the UpdateMessage method.
        /// </summary>
        /// <param name="message">A queue message.</param>
        /// <param name="visibilityTimeout">The visibility timeout for the message.</param>
        /// <param name="updateFlags">Indicates whether to update the visibility delay, message contents, or both.</param>
        /// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
        /// <returns>A <see cref="RESTCommand{T}"/> that sets the permissions.</returns>
        private RESTCommand<NullType> UpdateMessageImpl(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFlags, QueueRequestOptions options)
        {
            CommonUtils.AssertNotNull("message", message);
            CommonUtils.AssertNotNullOrEmpty("messageId", message.Id);
            CommonUtils.AssertNotNullOrEmpty("popReceipt", message.PopReceipt);
            CommonUtils.AssertInBounds<TimeSpan>("visibilityTimeout", visibilityTimeout, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);

            if ((updateFlags & MessageUpdateFields.Visibility) == 0)
            {
                throw new ArgumentException("Calls to UpdateMessage must include the Visibility flag.", "updateFlags");
            }

            Uri messageUri = this.GetIndividualMessageAddress(message.Id);
            RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, messageUri);

            options.ApplyToStorageCommand(putCmd);
            putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.UpdateMessage(putCmd.Uri, serverTimeout, message.PopReceipt, visibilityTimeout.RoundUpToSeconds(), ctx);

            if ((updateFlags & MessageUpdateFields.Content) != 0)
            {
                MemoryStream memoryStream = new MemoryStream();
                QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage), memoryStream);
                memoryStream.Seek(0, SeekOrigin.Begin);

                putCmd.SendStream = memoryStream;
                putCmd.RecoveryAction = RecoveryActions.RewindStream;
            }
            else
            {
                putCmd.SetHeaders = (r, ctx) =>
                {
                    r.ContentLength = 0;
                };
            }

            putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
            putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
            {
                HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, NullType.Value, cmd, ex, ctx);
                GetPopReceiptAndNextVisibleTimeFromResponse(message, resp);
                return NullType.Value;
            };

            return putCmd;
        }