public void CloneProducesACopyWhenPropertyDictionariesAreNotSet()
{
var sourceEvent = new EventData(
new byte[] { 0x21, 0x22 },
null,
null,
33334444,
666777,
DateTimeOffset.Parse("2015-10-27T00:00:00Z"),
"TestKey",
111222,
999888,
DateTimeOffset.Parse("2012-03-04T09:00:00Z"),
DateTimeOffset.Parse("2003-09-27T15:00:00Z"),
787878,
987654);
var clone = sourceEvent.Clone();
Assert.That(clone, Is.Not.Null, "The clone should not be null.");
Assert.That(GetPropertiesBackingStore(clone), Is.Null, "The user properties should be created lazily.");
Assert.That(clone.SystemProperties, Is.SameAs(GetEmptySystemProperties()), "The system properties should be the static empty set.");
Assert.That(clone.IsEquivalentTo(sourceEvent, false), Is.True, "The clone should be equivalent to the source event.");
Assert.That(clone, Is.Not.SameAs(sourceEvent), "The clone should be a distinct reference.");
}
public void CloneProducesACopy()
{
var sourceEvent = new EventData(
new byte[] { 0x21, 0x22 },
new Dictionary <string, object> {
{ "Test", 123 }
},
new Dictionary <string, object> {
{ "System", "Hello" }
},
33334444,
666777,
DateTimeOffset.Parse("2015-10-27T00:00:00Z"),
"TestKey",
111222,
999888,
DateTimeOffset.Parse("2012-03-04T09:00:00Z"),
DateTimeOffset.Parse("2003-09-27T15:00:00Z"));
var clone = sourceEvent.Clone();
Assert.That(clone, Is.Not.Null, "The clone should not be null.");
Assert.That(clone.IsEquivalentTo(sourceEvent, true), Is.True, "The clone should be equivalent to the source event.");
Assert.That(clone, Is.Not.SameAs(sourceEvent), "The clone should be a distinct reference.");
Assert.That(object.ReferenceEquals(clone.Properties, sourceEvent.Properties), Is.False, "The clone's property bag should be a distinct reference.");
}
public void CloneIsolatesPropertyChanges()
{
var sourceEvent = new EventData(
new byte[] { 0x21, 0x22 },
new Dictionary <string, object> {
{ "Test", 123 }
},
new Dictionary <string, object> {
{ "System", "Hello" }
},
33334444,
666777,
DateTimeOffset.Parse("2015-10-27T00:00:00Z"),
"TestKey",
111222,
999888,
DateTimeOffset.Parse("2012-03-04T09:00:00Z"),
DateTimeOffset.Parse("2003-09-27T15:00:00Z"));
var clone = sourceEvent.Clone();
Assert.That(clone, Is.Not.Null, "The clone should not be null.");
Assert.That(clone.IsEquivalentTo(sourceEvent, true), Is.True, "The clone should be equivalent to the source event.");
sourceEvent.Properties["Test"] = 999;
sourceEvent.Properties.Add("New", "thing");
Assert.That(clone.IsEquivalentTo(sourceEvent, true), Is.False, "The clone should no longer be equivalent to the source event; user properties were changed.");
}
public EventData AfterReceiveMessage(EventData eventData, WriteToLogDelegate writeToLog = null)
{
if (eventData == null)
{
return null;
}
var stream = eventData.Clone().GetBody<Stream>();
if (stream == null)
{
return null;
}
if (stream.CanSeek)
{
stream.Seek(0, SeekOrigin.Begin);
}
return eventData.Clone(Decompress(stream));
}
public EventData BeforeSendMessage(EventData eventData, WriteToLogDelegate writeToLog = null)
{
if (eventData == null)
{
return null;
}
var stream = eventData.Clone().GetBodyStream();
if (stream == null)
{
return null;
}
if (stream.CanSeek)
{
stream.Seek(0, SeekOrigin.Begin);
}
return eventData.Clone(Compress(stream));
}
public EventData BeforeSendMessage(EventData eventData, WriteToLogDelegate writeToLog = null)
{
if (eventData == null)
{
return(null);
}
var stream = eventData.Clone().GetBody <Stream>();
if (stream == null)
{
return(null);
}
if (stream.CanSeek)
{
stream.Seek(0, SeekOrigin.Begin);
}
return(eventData.Clone(Compress(stream)));
}
public EventData AfterReceiveMessage(EventData eventData, WriteToLogDelegate writeToLog = null)
{
if (eventData == null)
{
return(null);
}
var stream = eventData.Clone().GetBodyStream();
if (stream == null)
{
return(null);
}
if (stream.CanSeek)
{
stream.Seek(0, SeekOrigin.Begin);
}
return(eventData.Clone(Decompress(stream)));
}
public static EventData Clone(this EventData eventData, string text)
{
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(text);
writer.Flush();
var clone = eventData.Clone();
bodyStreamPropertyInfo.SetValue(clone, stream);
return(clone);
}
public async Task Deserialize_creates_new_MessageId_if_property_not_set()
{
var message = fixture.Create <BlogPostCreated>();
var envelope = new Envelope(message);
EventData eventData = await sut.Serialize(envelope);
eventData.Properties.Remove("Khala.Envelope.MessageId");
Envelope actual = await sut.Deserialize(eventData.Clone());
actual.MessageId.Should().NotBeEmpty();
(await sut.Deserialize(eventData)).MessageId.Should().NotBe(actual.MessageId);
}
public EventData AfterReceiveMessage(EventData eventData)
{
var stream = eventData?.Clone().GetBodyStream();
if (stream == null)
{
return(null);
}
if (stream.CanSeek)
{
stream.Seek(0, SeekOrigin.Begin);
}
return(eventData.Clone(Decompress(stream)));
}
public EventData BeforeSendMessage(EventData eventData)
{
var stream = eventData?.Clone().GetBodyStream();
if (stream == null)
{
return(null);
}
if (stream.CanSeek)
{
stream.Seek(0, SeekOrigin.Begin);
}
return(eventData.Clone(Compress(stream)));
}
public EventData AfterReceiveMessage(EventData eventData)
{
var stream = eventData?.Clone().GetBodyStream();
if (stream == null)
{
return(null);
}
if (!stream.CanSeek)
{
throw new InvalidOperationException("Stream is not seekable");
}
stream.Seek(0, SeekOrigin.Begin);
return(eventData.Clone(Decompress(stream)));
}
/// <summary>
/// Attempts to add an event to the batch, ensuring that the size
/// of the batch does not exceed its maximum.
/// </summary>
///
/// <param name="eventData">The event to attempt to add to the batch.</param>
///
/// <returns><c>true</c> if the event was added; otherwise, <c>false</c>.</returns>
///
/// <remarks>
/// When an event is accepted into the batch, its content and state are frozen; any
/// changes made to the event will not be reflected in the batch nor will any state
/// transitions be reflected to the original instance.
/// </remarks>
///
/// <exception cref="InvalidOperationException">
/// When a batch is published, it will be locked for the duration of that operation. During this time,
/// no events may be added to the batch. Calling <c>TryAdd</c> while the batch is being published will
/// result in an <see cref="InvalidOperationException" /> until publishing has completed.
/// </exception>
///
public bool TryAdd(EventData eventData)
{
lock (SyncGuard)
{
AssertNotLocked();
eventData = eventData.Clone();
EventDataInstrumentation.InstrumentEvent(eventData, FullyQualifiedNamespace, EventHubName);
var added = InnerBatch.TryAdd(eventData);
if ((added) && (EventDataInstrumentation.TryExtractDiagnosticId(eventData, out string diagnosticId)))
{
EventDiagnosticIdentifiers.Add(diagnosticId);
}
return(added);
}
}
public void CloneProducesACopyWhenPropertyDictionariesAreNotSet()
{
var sourceEvent = new EventData(
new BinaryData(new byte[] { 0x21, 0x22 }),
null,
null,
33334444,
666777,
DateTimeOffset.Parse("2015-10-27T00:00:00Z"),
"TestKey",
111222,
999888,
DateTimeOffset.Parse("2012-03-04T09:00:00Z"),
DateTimeOffset.Parse("2003-09-27T15:00:00Z"),
787878,
987654);
var clone = sourceEvent.Clone();
Assert.That(clone, Is.Not.Null, "The clone should not be null.");
Assert.That(clone.IsEquivalentTo(sourceEvent, false), Is.True, "The clone should be equivalent to the source event.");
Assert.That(clone, Is.Not.SameAs(sourceEvent), "The clone should be a distinct reference.");
}
static void Main(string[] args)
{
//Create Event Hub client
var eventhubClient = EventHubClient.CreateFromConnectionString(connectionString, eventhubName);
//Send 100 messages to the Event Hub
var data = new EventData(Encoding.UTF8.GetBytes("Hello World!"));
data.PartitionKey = "FirstPartition";
for (int i = 0; i < 100; i++)
{
eventhubClient.Send(data.Clone());
}
//Display the distribution of messages in each parition
var mgr = NamespaceManager.CreateFromConnectionString(connectionString);
var ehDesc = mgr.GetEventHub(eventhubName);
for (int j = 0; j < ehDesc.PartitionCount; j++)
{
var partInfo = eventhubClient.GetPartitionRuntimeInformation(j.ToString());
Console.WriteLine($"Partition {j} contains {partInfo.LastEnqueuedSequenceNumber} messages");
}
}
/// <summary>
/// Gets the eventData body and properties.
/// </summary>
/// <param name="builder">The string builder object used to accumulate the trace event data.</param>
/// <param name="inboundMessage">The inbound event data.</param>
public void GetMessageAndProperties(StringBuilder builder, EventData inboundMessage)
{
string eventDataText = null;
Stream stream = null;
if (inboundMessage == null)
{
return;
}
try
{
var eventDataClone = inboundMessage.Clone();
stream = eventDataClone.GetBody<Stream>();
if (stream != null)
{
using (var reader = new StreamReader(stream))
{
eventDataText = reader.ReadToEnd();
}
}
}
catch (Exception)
{
try
{
if (stream != null)
{
try
{
stream.Seek(0, SeekOrigin.Begin);
var serializer = new CustomDataContractBinarySerializer(typeof(string));
eventDataText = serializer.ReadObject(stream) as string;
}
catch (Exception)
{
try
{
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(stream))
{
eventDataText = reader.ReadToEnd();
}
}
catch (Exception)
{
eventDataText = UnableToReadMessageBody;
}
}
}
else
{
eventDataText = UnableToReadMessageBody;
}
}
catch (Exception)
{
eventDataText = UnableToReadMessageBody;
}
}
builder.AppendLine();
builder.AppendLine(ReceivedMessagePayloadHeader);
builder.AppendLine(string.Format(MessageTextFormat, eventDataText));
if (inboundMessage.Properties.Any())
{
builder.AppendLine(ReceivedMessagePropertiesHeader);
foreach (var p in inboundMessage.Properties)
{
builder.AppendLine(string.Format(MessagePropertyFormat,
p.Key,
p.Value));
}
}
}
/// <summary>
/// Reads the content of the EventData passed as argument.
/// </summary>
/// <param name="eventDataToRead">The EventData to read.</param>
/// <param name="bodyType">BodyType</param>
/// <returns>The content of the EventData.</returns>
public string GetMessageText(EventData eventDataToRead, out BodyType bodyType)
{
string eventDataText = null;
Stream stream = null;
bodyType = BodyType.Stream;
if (eventDataToRead == null)
{
return null;
}
var inboundMessage = eventDataToRead.Clone();
try
{
stream = inboundMessage.GetBody<Stream>();
if (stream != null)
{
var element = new BinaryMessageEncodingBindingElement
{
ReaderQuotas = new XmlDictionaryReaderQuotas
{
MaxArrayLength = int.MaxValue,
MaxBytesPerRead = int.MaxValue,
MaxDepth = int.MaxValue,
MaxNameTableCharCount = int.MaxValue,
MaxStringContentLength = int.MaxValue
}
};
var encoderFactory = element.CreateMessageEncoderFactory();
var encoder = encoderFactory.Encoder;
var stringBuilder = new StringBuilder();
var eventData = encoder.ReadMessage(stream, MaxBufferSize);
using (var reader = eventData.GetReaderAtBodyContents())
{
// The XmlWriter is used just to indent the XML eventData
var settings = new XmlWriterSettings { Indent = true };
using (var writer = XmlWriter.Create(stringBuilder, settings))
{
writer.WriteNode(reader, true);
}
}
eventDataText = stringBuilder.ToString();
bodyType = BodyType.Wcf;
}
}
catch (Exception)
{
inboundMessage = eventDataToRead.Clone();
try
{
stream = inboundMessage.GetBody<Stream>();
if (stream != null)
{
var element = new BinaryMessageEncodingBindingElement
{
ReaderQuotas = new XmlDictionaryReaderQuotas
{
MaxArrayLength = int.MaxValue,
MaxBytesPerRead = int.MaxValue,
MaxDepth = int.MaxValue,
MaxNameTableCharCount = int.MaxValue,
MaxStringContentLength = int.MaxValue
}
};
var encoderFactory = element.CreateMessageEncoderFactory();
var encoder = encoderFactory.Encoder;
var eventData = encoder.ReadMessage(stream, MaxBufferSize);
using (var reader = eventData.GetReaderAtBodyContents())
{
eventDataText = reader.ReadString();
}
bodyType = BodyType.Wcf;
}
}
catch (Exception)
{
try
{
if (stream != null)
{
try
{
stream.Seek(0, SeekOrigin.Begin);
var serializer = new CustomDataContractBinarySerializer(typeof(string));
eventDataText = serializer.ReadObject(stream) as string;
bodyType = BodyType.String;
}
catch (Exception)
{
try
{
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(stream))
{
eventDataText = reader.ReadToEnd();
if (eventDataText.ToCharArray().GroupBy(c => c).
Where(g => char.IsControl(g.Key) && g.Key != '\t' && g.Key != '\n' && g.Key != '\r').
Select(g => g.First()).Any())
{
stream.Seek(0, SeekOrigin.Begin);
using (var binaryReader = new BinaryReader(stream))
{
var bytes = binaryReader.ReadBytes((int)stream.Length);
eventDataText = BitConverter.ToString(bytes).Replace('-', ' ');
}
}
}
}
catch (Exception)
{
eventDataText = UnableToReadMessageBody;
}
}
}
else
{
eventDataText = UnableToReadMessageBody;
}
}
catch (Exception)
{
eventDataText = UnableToReadMessageBody;
}
}
}
return eventDataText;
}
///// <summary>
///// This method can be used to send an event data to an event hub.
///// </summary>
///// <param name="eventHubClient">A EventHubClient object used to send messages.</param>
///// <param name="eventDataList">The list of messages to send.</param>
///// <param name="messageNumberList">The list of message numbers.</param>
///// <param name="taskId">The sender task id.</param>
///// <param name="logging">Indicates whether logging of message content and properties is enabled.</param>
///// <param name="verbose">Indicates whether verbose logging is enabled.</param>
///// <returns>Elapsed milliseconds.</returns>
//public async Task<long> SendEventDataBatch(EventHubClient eventHubClient,
// List<EventData> eventDataList,
// List<long> messageNumberList,
// int taskId,
// bool logging,
// bool verbose)
//{
// long elapsedMilliseconds = 0;
// if (eventHubClient == null)
// {
// throw new ArgumentNullException(EventHubClientCannotBeNull);
// }
// if (eventDataList == null || eventDataList.Count == 0)
// {
// return elapsedMilliseconds;
// }
// List<Stream> eventDataPayloadList = null;
// var stopwatch = new Stopwatch();
// var builder = new StringBuilder();
// try
// {
// stopwatch.Start();
// if (logging && verbose)
// {
// eventDataPayloadList = eventDataList.Select(e => e.Clone().GetBodyStream()).ToList();
// }
// //await eventHubClient.SendBatchAsync(eventDataList);
// }
// finally
// {
// stopwatch.Stop();
// }
// elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
// if (logging)
// {
// for (var i = 0; i < eventDataList.Count; i++)
// {
// try
// {
// builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
// EventDataSuccessfullySent,
// taskId,
// messageNumberList[i],
// string.IsNullOrWhiteSpace(eventDataList[i].PartitionKey)
// ? NullValue
// : eventDataList[i].PartitionKey));
// if (verbose)
// {
// builder.AppendLine(SentMessagePayloadHeader);
// builder.AppendLine(string.Format(MessageTextFormat, GetMessageText(eventDataPayloadList[i])));
// builder.AppendLine(SentMessagePropertiesHeader);
// foreach (var p in eventDataList[i].Properties)
// {
// builder.AppendLine(string.Format(MessagePropertyFormat,
// p.Key,
// p.Value));
// }
// }
// }
// finally
// {
// eventDataList[i].Dispose();
// }
// }
// var traceMessage = builder.ToString();
// WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
// }
// return elapsedMilliseconds;
//}
/// <summary>
/// This method can be used to send an event data to an event hub.
/// </summary>
/// <param name="eventHubClient">A MessageSender object used to send event datas.</param>
/// <param name="eventData">The event data to send.</param>
/// <param name="messageNumber">The message number.</param>
/// <param name="taskId">The sender task id.</param>
/// <param name="logging">Indicates whether logging of event data content and properties is enabled.</param>
/// <param name="verbose">Indicates whether verbose logging is enabled.</param>
/// <returns>Elapsed milliseconds.</returns>
public async Task<long> SendEventData(EventHubClient eventHubClient,
EventData eventData,
long messageNumber,
int taskId,
bool logging,
bool verbose)
{
long elapsedMilliseconds;
if (eventHubClient == null)
{
throw new ArgumentNullException(MessageSenderCannotBeNull);
}
if (eventData == null)
{
throw new ArgumentNullException(BrokeredMessageCannotBeNull);
}
var stopwatch = new Stopwatch();
Stream bodyStream = null;
try
{
var builder = new StringBuilder();
try
{
if (logging && verbose)
{
bodyStream = eventData.Clone().GetBodyStream();
}
stopwatch.Start();
await eventHubClient.SendAsync(eventData);
}
finally
{
stopwatch.Stop();
}
elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
if (logging)
{
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
EventDataSuccessfullySent,
taskId,
messageNumber,
string.IsNullOrWhiteSpace(eventData.PartitionKey) ? NullValue : eventData.PartitionKey));
if (verbose)
{
builder.AppendLine(SentMessagePayloadHeader);
builder.AppendLine(string.Format(MessageTextFormat, GetMessageText(bodyStream)));
if (eventData.Properties.Any())
{
builder.AppendLine(SentMessagePropertiesHeader);
foreach (var p in eventData.Properties)
{
builder.AppendLine(string.Format(MessagePropertyFormat,
p.Key,
p.Value));
}
}
}
var traceMessage = builder.ToString();
WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
}
finally
{
eventData.Dispose();
}
return elapsedMilliseconds;
}
private EventData LogEventData(EventDataDirection direction, EventData eventData)
{
try
{
if (eventData != null)
{
messageCollection.TryAdd(new Tuple<EventDataDirection, EventData>(direction, eventData.Clone()));
}
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
}
return eventData;
}
private static EventData LogEventData(EventDataDirection direction, EventData eventData)
{
try
{
if (eventData != null)
{
messageCollection.TryAdd(new Tuple <EventDataDirection, EventData>(direction, eventData.Clone()));
}
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
}
return(eventData);
}
/// <summary>
/// Reads the content of the EventData passed as argument.
/// </summary>
/// <param name="eventDataToRead">The EventData to read.</param>
/// <returns>The content of the EventData.</returns>
public static string GetMessageText(EventData eventDataToRead)
{
string eventDataText = null;
Stream stream = null;
if (eventDataToRead == null)
{
return(null);
}
var inboundMessage = eventDataToRead.Clone();
try
{
stream = inboundMessage.GetBodyStream();
if (stream != null)
{
var element = new BinaryMessageEncodingBindingElement
{
ReaderQuotas = new XmlDictionaryReaderQuotas
{
MaxArrayLength = int.MaxValue,
MaxBytesPerRead = int.MaxValue,
MaxDepth = int.MaxValue,
MaxNameTableCharCount = int.MaxValue,
MaxStringContentLength = int.MaxValue
}
};
var encoderFactory = element.CreateMessageEncoderFactory();
var encoder = encoderFactory.Encoder;
var stringBuilder = new StringBuilder();
var eventData = encoder.ReadMessage(stream, MaxBufferSize);
using (var reader = eventData.GetReaderAtBodyContents())
{
// The XmlWriter is used just to indent the XML eventData
var settings = new XmlWriterSettings {
Indent = true
};
using (var xmlWriter = XmlWriter.Create(stringBuilder, settings))
{
xmlWriter.WriteNode(reader, true);
}
}
eventDataText = stringBuilder.ToString();
}
}
catch (Exception)
{
inboundMessage = eventDataToRead.Clone();
try
{
stream = inboundMessage.GetBodyStream();
if (stream != null)
{
var element = new BinaryMessageEncodingBindingElement
{
ReaderQuotas = new XmlDictionaryReaderQuotas
{
MaxArrayLength = int.MaxValue,
MaxBytesPerRead = int.MaxValue,
MaxDepth = int.MaxValue,
MaxNameTableCharCount = int.MaxValue,
MaxStringContentLength = int.MaxValue
}
};
var encoderFactory = element.CreateMessageEncoderFactory();
var encoder = encoderFactory.Encoder;
var eventData = encoder.ReadMessage(stream, MaxBufferSize);
using (var reader = eventData.GetReaderAtBodyContents())
{
eventDataText = reader.ReadString();
}
}
}
catch (Exception)
{
try
{
if (stream != null)
{
try
{
stream.Seek(0, SeekOrigin.Begin);
var serializer = new CustomDataContractBinarySerializer(typeof(string));
eventDataText = serializer.ReadObject(stream) as string;
}
catch (Exception)
{
try
{
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(stream))
{
eventDataText = reader.ReadToEnd();
if (eventDataText.ToCharArray().GroupBy(c => c).
Where(g => char.IsControl(g.Key) && g.Key != '\t' && g.Key != '\n' && g.Key != '\r').
Select(g => g.First()).Any())
{
stream.Seek(0, SeekOrigin.Begin);
using (var binaryReader = new BinaryReader(stream))
{
var bytes = binaryReader.ReadBytes((int)stream.Length);
eventDataText = BitConverter.ToString(bytes).Replace('-', ' ');
}
}
}
}
catch (Exception)
{
eventDataText = UnableToReadMessageBody;
}
}
}
else
{
eventDataText = UnableToReadMessageBody;
}
}
catch (Exception)
{
eventDataText = UnableToReadMessageBody;
}
}
}
return(eventDataText);
}
