protected override async Task OnSendAsync(IEnumerable <BrokeredMessage> brokeredMessages)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(this.OperationTimeout, true);
using (AmqpMessage amqpMessage = AmqpMessageConverter.BrokeredMessagesToAmqpMessage(brokeredMessages, true))
{
SendingAmqpLink amqpLink = await this.SendLinkManager.GetOrCreateAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
if (amqpLink.Settings.MaxMessageSize.HasValue)
{
ulong size = (ulong)amqpMessage.SerializedMessageSize;
if (size > amqpLink.Settings.MaxMessageSize.Value)
{
// TODO: Add MessageSizeExceededException
throw new NotImplementedException("MessageSizeExceededException: " + Resources.AmqpMessageSizeExceeded.FormatForUser(amqpMessage.DeliveryId.Value, size, amqpLink.Settings.MaxMessageSize.Value));
////throw Fx.Exception.AsError(new MessageSizeExceededException(
////Resources.AmqpMessageSizeExceeded.FormatForUser(amqpMessage.DeliveryId.Value, size, amqpLink.Settings.MaxMessageSize.Value)));
}
}
Outcome outcome = await amqpLink.SendMessageAsync(amqpMessage, this.GetNextDeliveryTag(), AmqpConstants.NullBinary, timeoutHelper.RemainingTime()).ConfigureAwait(false);
if (outcome.DescriptorCode != Accepted.Code)
{
Rejected rejected = (Rejected)outcome;
throw Fx.Exception.AsError(AmqpExceptionHelper.ToMessagingContract(rejected.Error));
}
}
}
protected override async Task OnSetStateAsync(Stream sessionState)
{
try
{
if (sessionState != null && sessionState.CanSeek && sessionState.Position != 0)
{
throw new InvalidOperationException("CannotSerializeSessionStateWithPartiallyConsumedStream");
}
AmqpRequestMessage amqpRequestMessage = AmqpRequestMessage.CreateRequest(ManagementConstants.Operations.SetSessionStateOperation, this.OperationTimeout, null);
amqpRequestMessage.Map[ManagementConstants.Properties.SessionId] = this.SessionId;
if (sessionState != null)
{
BufferListStream buffer = BufferListStream.Create(sessionState, AmqpConstants.SegmentSize);
ArraySegment <byte> value = buffer.ReadBytes((int)buffer.Length);
amqpRequestMessage.Map[ManagementConstants.Properties.SessionState] = value;
}
else
{
amqpRequestMessage.Map[ManagementConstants.Properties.SessionState] = null;
}
await this.InnerMessageReceiver.ExecuteRequestResponseAsync(amqpRequestMessage).ConfigureAwait(false);
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
}
protected override async Task <DateTime> OnRenewLockAsync(Guid lockToken)
{
DateTime lockedUntilUtc = DateTime.MinValue;
try
{
// Create an AmqpRequest Message to renew lock
AmqpRequestMessage requestMessage = AmqpRequestMessage.CreateRequest(ManagementConstants.Operations.RenewLockOperation, this.OperationTimeout, null);
requestMessage.Map[ManagementConstants.Properties.LockTokens] = new Guid[] { lockToken };
AmqpResponseMessage response = await this.ExecuteRequestResponseAsync(requestMessage).ConfigureAwait(false);
if (response.StatusCode == AmqpResponseStatusCode.OK)
{
IEnumerable <DateTime> lockedUntilUtcTimes = response.GetValue <IEnumerable <DateTime> >(ManagementConstants.Properties.Expirations);
lockedUntilUtc = lockedUntilUtcTimes.First();
}
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
return(lockedUntilUtc);
}
protected override async Task <Stream> OnGetStateAsync()
{
try
{
AmqpRequestMessage amqpRequestMessage = AmqpRequestMessage.CreateRequest(ManagementConstants.Operations.GetSessionStateOperation, this.OperationTimeout, null);
amqpRequestMessage.Map[ManagementConstants.Properties.SessionId] = this.SessionId;
AmqpResponseMessage amqpResponseMessage = await this.InnerMessageReceiver.ExecuteRequestResponseAsync(amqpRequestMessage).ConfigureAwait(false);
Stream sessionState = null;
if (amqpResponseMessage.StatusCode == AmqpResponseStatusCode.OK)
{
if (amqpResponseMessage.Map[ManagementConstants.Properties.SessionState] != null)
{
sessionState = new BufferListStream(new[] { amqpResponseMessage.GetValue <ArraySegment <byte> >(ManagementConstants.Properties.SessionState) });
}
}
return(sessionState);
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
}
protected override async Task <IList <BrokeredMessage> > OnPeekAsync(long fromSequenceNumber, int messageCount = 1)
{
try
{
AmqpRequestMessage requestMessage =
AmqpRequestMessage.CreateRequest(
ManagementConstants.Operations.PeekMessageOperation,
this.OperationTimeout,
null);
requestMessage.Map[ManagementConstants.Properties.FromSequenceNumber] = fromSequenceNumber;
requestMessage.Map[ManagementConstants.Properties.MessageCount] = messageCount;
if (!string.IsNullOrWhiteSpace(this.sessionId))
{
requestMessage.Map[ManagementConstants.Properties.SessionId] = this.sessionId;
}
List <BrokeredMessage> messages = new List <BrokeredMessage>();
AmqpResponseMessage response = await this.ExecuteRequestResponseAsync(requestMessage);
if (response.StatusCode == AmqpResponseStatusCode.OK)
{
BrokeredMessage brokeredMessage = null;
var messageList = response.GetListValue <AmqpMap>(ManagementConstants.Properties.Messages);
foreach (AmqpMap entry in messageList)
{
var payload = (ArraySegment <byte>)entry[ManagementConstants.Properties.Message];
AmqpMessage amqpMessage =
AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(new[] { payload }), true);
brokeredMessage = AmqpMessageConverter.ClientGetMessage(amqpMessage);
messages.Add(brokeredMessage);
}
if (brokeredMessage != null)
{
this.LastPeekedSequenceNumber = brokeredMessage.SequenceNumber;
}
return(messages);
}
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
return(null);
}
protected override async Task <IList <BrokeredMessage> > OnReceiveAsync(int maxMessageCount)
{
try
{
TimeoutHelper timeoutHelper = new TimeoutHelper(this.OperationTimeout, true);
ReceivingAmqpLink receiveLink = await this.ReceiveLinkManager.GetOrCreateAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
IEnumerable <AmqpMessage> amqpMessages = null;
bool hasMessages = await Task.Factory.FromAsync(
(c, s) => receiveLink.BeginReceiveRemoteMessages(maxMessageCount, AmqpMessageReceiver.DefaultBatchFlushInterval, timeoutHelper.RemainingTime(), c, s),
a => receiveLink.EndReceiveMessages(a, out amqpMessages),
this).ConfigureAwait(false);
if (receiveLink.TerminalException != null)
{
throw receiveLink.TerminalException;
}
if (hasMessages && amqpMessages != null)
{
IList <BrokeredMessage> brokeredMessages = null;
foreach (var amqpMessage in amqpMessages)
{
if (brokeredMessages == null)
{
brokeredMessages = new List <BrokeredMessage>();
}
if (this.ReceiveMode == ReceiveMode.ReceiveAndDelete)
{
receiveLink.DisposeDelivery(amqpMessage, true, AmqpConstants.AcceptedOutcome);
}
BrokeredMessage brokeredMessage = AmqpMessageConverter.ClientGetMessage(amqpMessage);
brokeredMessage.Receiver = this; // Associate the Message with this Receiver.
brokeredMessages.Add(brokeredMessage);
}
return(brokeredMessages);
}
return(null);
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
}
async Task DisposeMessageRequestResponseAsync(IEnumerable <Guid> lockTokens, DispositionStatus dispositionStatus)
{
try
{
// Create an AmqpRequest Message to update disposition
AmqpRequestMessage requestMessage = AmqpRequestMessage.CreateRequest(ManagementConstants.Operations.UpdateDispositionOperation, this.OperationTimeout, null);
requestMessage.Map[ManagementConstants.Properties.LockTokens] = lockTokens.ToArray();
requestMessage.Map[ManagementConstants.Properties.DispositionStatus] = dispositionStatus.ToString().ToLowerInvariant();
await this.ExecuteRequestResponseAsync(requestMessage);
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
}
protected override async Task <MessageSession> OnAcceptMessageSessionAsync(string sessionId)
{
AmqpMessageReceiver receiver = new AmqpMessageReceiver(this.SubscriptionPath, MessagingEntityType.Subscriber, this.Mode, this.ServiceBusConnection.PrefetchCount, this.ServiceBusConnection, this.CbsTokenProvider, sessionId, true);
try
{
await receiver.GetSessionReceiverLinkAsync().ConfigureAwait(false);
}
catch (AmqpException exception)
{
// ToDo: Abort the Receiver here
AmqpExceptionHelper.ToMessagingContract(exception.Error, false);
}
MessageSession session = new AmqpMessageSession(receiver.SessionId, receiver.LockedUntilUtc, receiver);
return(session);
}
protected override async Task OnDeadLetterAsync(IEnumerable <Guid> lockTokens)
{
try
{
if (lockTokens.Any((lt) => this.requestResponseLockedMessages.Contains(lt)))
{
await this.DisposeMessageRequestResponseAsync(lockTokens, DispositionStatus.Suspended).ConfigureAwait(false);
}
else
{
await this.DisposeMessagesAsync(lockTokens, AmqpConstants.RejectedOutcome).ConfigureAwait(false);
}
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
}
protected override async Task OnAbandonAsync(IEnumerable <Guid> lockTokens)
{
try
{
if (lockTokens.Any((lt) => this.requestResponseLockedMessages.Contains(lt)))
{
await this.DisposeMessageRequestResponseAsync(lockTokens, DispositionStatus.Abandoned).ConfigureAwait(false);
}
else
{
await this.DisposeMessagesAsync(lockTokens, new Modified()).ConfigureAwait(false);
}
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
}
protected override async Task OnRenewLockAsync()
{
try
{
AmqpRequestMessage amqpRequestMessage = AmqpRequestMessage.CreateRequest(ManagementConstants.Operations.RenewSessionLockOperation, this.OperationTimeout, null);
amqpRequestMessage.Map[ManagementConstants.Properties.SessionId] = this.SessionId;
AmqpResponseMessage amqpResponseMessage = await this.InnerMessageReceiver.ExecuteRequestResponseAsync(amqpRequestMessage).ConfigureAwait(false);
if (amqpResponseMessage.StatusCode == AmqpResponseStatusCode.OK)
{
this.LockedUntilUtc = amqpResponseMessage.GetValue <DateTime>(ManagementConstants.Properties.Expiration);
}
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
}
protected override async Task <IList <BrokeredMessage> > OnReceiveBySequenceNumberAsync(IEnumerable <long> sequenceNumbers)
{
List <BrokeredMessage> messages = new List <BrokeredMessage>();
try
{
AmqpRequestMessage requestMessage = AmqpRequestMessage.CreateRequest(ManagementConstants.Operations.ReceiveBySequenceNumberOperation, this.OperationTimeout, null);
requestMessage.Map[ManagementConstants.Properties.SequenceNumbers] = sequenceNumbers.ToArray();
requestMessage.Map[ManagementConstants.Properties.ReceiverSettleMode] = (uint)(this.ReceiveMode == ReceiveMode.ReceiveAndDelete ? 0 : 1);
AmqpResponseMessage response = await this.ExecuteRequestResponseAsync(requestMessage).ConfigureAwait(false);
if (response.StatusCode == AmqpResponseStatusCode.OK)
{
IEnumerable <AmqpMap> amqpMapList = response.GetListValue <AmqpMap>(ManagementConstants.Properties.Messages);
foreach (AmqpMap entry in amqpMapList)
{
ArraySegment <byte> payload = (ArraySegment <byte>)entry[ManagementConstants.Properties.Message];
AmqpMessage amqpMessage = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(new[] { payload }), true);
BrokeredMessage brokeredMessage = AmqpMessageConverter.ClientGetMessage(amqpMessage);
brokeredMessage.Receiver = this; // Associate the Message with this Receiver.
Guid lockToken;
if (entry.TryGetValue(ManagementConstants.Properties.LockToken, out lockToken))
{
brokeredMessage.LockToken = lockToken;
this.requestResponseLockedMessages.AddOrUpdate(lockToken, brokeredMessage.LockedUntilUtc);
}
messages.Add(brokeredMessage);
}
}
}
catch (AmqpException amqpException)
{
throw AmqpExceptionHelper.ToMessagingContract(amqpException.Error);
}
return(messages);
}