protected override async Task <IList <Message> > 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 <Message> messages = new List <Message>();
AmqpResponseMessage response = await this.ExecuteRequestResponseAsync(requestMessage).ConfigureAwait(false);
if (response.StatusCode == AmqpResponseStatusCode.OK)
{
Message message = 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);
message = AmqpMessageConverter.AmqpMessageToSBMessage(amqpMessage);
messages.Add(message);
}
if (message != null)
{
this.LastPeekedSequenceNumber = message.SystemProperties.SequenceNumber;
}
return(messages);
}
else if (response.StatusCode == AmqpResponseStatusCode.NoContent ||
(response.StatusCode == AmqpResponseStatusCode.NotFound && Equals(AmqpClientConstants.MessageNotFoundError, response.GetResponseErrorCondition())))
{
return(messages);
}
else
{
throw response.ToMessagingContractException();
}
}
catch (Exception exception)
{
throw AmqpExceptionHelper.GetClientException(exception);
}
}
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> > 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);
}
}
else
{
throw response.ToMessagingContractException();
}
}
catch (Exception exception)
{
throw AmqpExceptionHelper.GetClientException(exception);
}
return(messages);
}
internal static IList <AmqpMessage> ExpandBatchedMessage(AmqpMessage message)
{
var outputMessages = new List <AmqpMessage>();
if (message.DataBody != null)
{
foreach (Data data in message.DataBody)
{
var payload = (ArraySegment <byte>)data.Value;
AmqpMessage debatchedMessage = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(new List <ArraySegment <byte> >()
{
payload
}));
outputMessages.Add(debatchedMessage);
}
}
return(outputMessages);
}
public void AmqpMessageReceiveResendTest()
{
var message = AmqpMessage.Create(new AmqpValue {
Value = "Hello, AMQP!"
});
message.MessageAnnotations.Map["key"] = "old";
// send the message and receive it on remote side
var payload = message.GetPayload();
var streamMessage = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(payload));
//new OutputMessage for resending with modified sections
var stream = BufferListStream.Create(streamMessage.ToStream(), AmqpConstants.SegmentSize, streamMessage.Settled);
stream.Seek(0, System.IO.SeekOrigin.Begin);
var outMessage = AmqpMessage.CreateOutputMessage(stream, false);
outMessage.Settled = streamMessage.Settled;
//explicitly assign
outMessage.Header.Priority = 99;
outMessage.DeliveryAnnotations.Map["key"] = "da-update";
outMessage.MessageAnnotations.Map["key"] = "update";
// send
var payload2 = outMessage.GetPayload();
var value = (string)outMessage.MessageAnnotations.Map["key"];
Assert.Equal("update", value);
// receive
var streamMessage2 = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(payload2));
Assert.Equal(99, streamMessage2.Header.Priority.Value);
value = (string)outMessage.DeliveryAnnotations.Map["key"];
Assert.Equal("da-update", value);
value = (string)outMessage.MessageAnnotations.Map["key"];
Assert.Equal("update", value);
}
public void AmqpMessageSerializationTest()
{
// empty message
AmqpMessage message = AmqpMessage.Create();
AddSection(message, SectionFlag.Properties);
RunSerializationTest(message);
// data message
message = AmqpMessage.Create(new Data()
{
Value = new ArraySegment <byte>(new byte[60])
});
RunSerializationTest(message);
message = AmqpMessage.Create(new Data[] { new Data()
{
Value = new ArraySegment <byte>(new byte[60])
}, new Data()
{
Value = new ArraySegment <byte>(new byte[44])
} });
AddSection(message, SectionFlag.Header | SectionFlag.ApplicationProperties);
RunSerializationTest(message);
// value message
message = AmqpMessage.Create(new AmqpValue()
{
Value = new AmqpSymbol("symbol value")
});
AddSection(message, SectionFlag.Header | SectionFlag.DeliveryAnnotations | SectionFlag.ApplicationProperties);
RunSerializationTest(message);
// sequence message
message = AmqpMessage.Create(new AmqpSequence[] { new AmqpSequence(new List <object>()
{
"string1", 1234
}), new AmqpSequence(new List <object>()
{
DateTime.Parse("2012-01-01 12:00:00").ToUniversalTime()
}) });
AddSection(message, SectionFlag.MessageAnnotations | SectionFlag.Properties | SectionFlag.ApplicationProperties | SectionFlag.Footer);
RunSerializationTest(message);
// data message - binary
message = AmqpUtils.CreateMessage(new byte[888]);
AddSection(message, SectionFlag.DeliveryAnnotations | SectionFlag.ApplicationProperties | SectionFlag.Footer);
RunSerializationTest(message);
// body stream message
message = AmqpMessage.Create(new MemoryStream(new byte[679]), true);
AddSection(message, SectionFlag.Header | SectionFlag.MessageAnnotations | SectionFlag.Footer);
RunSerializationTest(message);
// the following simulates a message's round trip from client to broker to client
// message -serialize-> buffers -> input stream message -> output stream message -deserialize> message
message = AmqpMessage.Create(new AmqpValue()
{
Value = new AmqpSymbol("symbol value")
});
AddSection(message, SectionFlag.MessageAnnotations | SectionFlag.Properties | SectionFlag.ApplicationProperties);
// serialize - send the message on client side
ArraySegment <byte>[] buffers = ReadMessagePayLoad(message, 71);
// input stream message - received on broker side
AmqpMessage message2 = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(buffers));
// output stream message - send out on broker side
message2 = AmqpMessage.CreateOutputMessage((BufferListStream)message2.ToStream(), true);
AddSection(message2, SectionFlag.Header | SectionFlag.DeliveryAnnotations);
message2.MessageAnnotations.Map["delivery-count"] = 5;
// input stream message - received on client side
buffers = ReadMessagePayLoad(message2, 71);
message2 = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(buffers));
// update the original message to match the updated message
AddSection(message, SectionFlag.Header | SectionFlag.DeliveryAnnotations);
message.MessageAnnotations.Map["delivery-count"] = 5;
ValidateMessage(message, message2);
}
static void RunSerializationTest(AmqpMessage message)
{
AmqpMessage deserialized = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(ReadMessagePayLoad(message, 89)));
ValidateMessage(message, deserialized);
}
/// <summary>
///
/// </summary>
/// <param name="retryPolicy"></param>
/// <param name="fromSequenceNumber"></param>
/// <param name="messageCount"></param>
/// <param name="sessionId"></param>
/// <param name="receiveLinkName"></param>
/// <param name="timeout"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
internal async Task <IEnumerable <ServiceBusMessage> > PeekInternal(
ServiceBusRetryPolicy retryPolicy,
long?fromSequenceNumber,
int messageCount,
string sessionId,
string receiveLinkName,
TimeSpan timeout,
CancellationToken cancellationToken = default)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
AmqpRequestMessage amqpRequestMessage = AmqpRequestMessage.CreateRequest(
ManagementConstants.Operations.PeekMessageOperation,
timeout,
null);
await AquireAccessTokenAsync(cancellationToken).ConfigureAwait(false);
if (receiveLinkName != null)
{
// include associated link for service optimization
amqpRequestMessage.AmqpMessage.ApplicationProperties.Map[ManagementConstants.Request.AssociatedLinkName] = receiveLinkName;
}
amqpRequestMessage.Map[ManagementConstants.Properties.FromSequenceNumber] = fromSequenceNumber ?? LastPeekedSequenceNumber + 1;
amqpRequestMessage.Map[ManagementConstants.Properties.MessageCount] = messageCount;
if (!string.IsNullOrWhiteSpace(sessionId))
{
amqpRequestMessage.Map[ManagementConstants.Properties.SessionId] = sessionId;
}
RequestResponseAmqpLink link = await ManagementLink.GetOrCreateAsync(
UseMinimum(ConnectionScope.SessionTimeout,
timeout.CalculateRemaining(stopWatch.Elapsed)))
.ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
using AmqpMessage responseAmqpMessage = await link.RequestAsync(
amqpRequestMessage.AmqpMessage,
timeout.CalculateRemaining(stopWatch.Elapsed))
.ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
AmqpResponseMessage amqpResponseMessage = AmqpResponseMessage.CreateResponse(responseAmqpMessage);
var messages = new List <ServiceBusMessage>();
//AmqpError.ThrowIfErrorResponse(responseAmqpMessage, EntityName);
if (amqpResponseMessage.StatusCode == AmqpResponseStatusCode.OK)
{
ServiceBusMessage message = null;
IEnumerable <AmqpMap> messageList = amqpResponseMessage.GetListValue <AmqpMap>(ManagementConstants.Properties.Messages);
foreach (AmqpMap entry in messageList)
{
var payload = (ArraySegment <byte>)entry[ManagementConstants.Properties.Message];
var amqpMessage = AmqpMessage.CreateAmqpStreamMessage(new BufferListStream(new[] { payload }), true);
message = AmqpMessageConverter.AmqpMessageToSBMessage(amqpMessage, true);
messages.Add(message);
}
if (message != null)
{
LastPeekedSequenceNumber = message.SystemProperties.SequenceNumber;
}
return(messages);
}
if (amqpResponseMessage.StatusCode == AmqpResponseStatusCode.NoContent ||
(amqpResponseMessage.StatusCode == AmqpResponseStatusCode.NotFound && Equals(AmqpClientConstants.MessageNotFoundError, amqpResponseMessage.GetResponseErrorCondition())))
{
return(messages);
}
// TODO throw correct exception
throw new Exception();
}
