public async Task SenderCanSendEventsWithCustomProperties()
{
await using (var scope = await EventHubScope.CreateAsync(4))
{
var events = new[]
{
new EventData(new byte[] { 0x22, 0x33 }),
new EventData(Encoding.UTF8.GetBytes("This is a really long string of stuff that I wanted to type because I like to")),
new EventData(Encoding.UTF8.GetBytes("I wanted to type because I like to")),
new EventData(Encoding.UTF8.GetBytes("If you are reading this, you really like test cases"))
};
for (var index = 0; index < events.Length; ++index)
{
events[index].Properties[index.ToString()] = "some value";
events[index].Properties["Type"] = $"com.microsoft.test.Type{ index }";
}
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var client = new EventHubClient(connectionString))
await using (var sender = client.CreateSender())
{
Assert.That(async() => await sender.SendAsync(events), Throws.Nothing);
}
}
}
public void Scenario4_EventHubSendToPublisherWithToken(string sbnamespace, string eventHubEntity, string publisher, string sharedAccessKeyName, string sharedAccessKey)
{
string token = SharedAccessSignatureTokenProvider.GetPublisherSharedAccessSignature(
new Uri(sbnamespace),
eventHubEntity,
publisher,
sharedAccessKeyName,
sharedAccessKey,
new TimeSpan(0, 20, 0));
string connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
new Uri(sbnamespace),
eventHubEntity,
publisher,
token);
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString);
EventHubClient client = factory.CreateEventHubClient(eventHubEntity);
EventHubSender sender = client.CreateSender(publisher);
EventData data = new EventData(Encoding.UTF8.GetBytes("Body"));
data.Properties["time"] = DateTime.UtcNow;
sender.Send(data);
sender.Close();
client.Close();
factory.Close();
}
public async Task SenderWithNoOptionsCanSend()
{
await using (var scope = await EventHubScope.CreateAsync(4))
{
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var client = new EventHubClient(connectionString))
await using (var sender = client.CreateSender())
{
var events = new[] { new EventData(Encoding.UTF8.GetBytes("AWord")) };
Assert.That(async() => await sender.SendAsync(events), Throws.Nothing);
}
}
}
private static async Task CreateSenderAndReceiver()
{
Console.Write("Creating the Sender and Receivers... ");
var partition = (await client.GetPartitionIdsAsync()).First();
var senderOptions = new EventSenderOptions
{
PartitionId = partition
};
var receiverOptions = new EventReceiverOptions
{
BeginReceivingAt = EventPosition.NewEventsOnly
};
sender = client.CreateSender(senderOptions);
receiver = client.CreateReceiver(partition, receiverOptions);
Console.WriteLine("\tdone");
}
public async Task SenderWithOptionsCanSend()
{
await using (var scope = await EventHubScope.CreateAsync(4))
{
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
var senderOptions = new EventSenderOptions {
Retry = new ExponentialRetry(TimeSpan.FromSeconds(0.25), TimeSpan.FromSeconds(45), 5)
};
await using (var client = new EventHubClient(connectionString))
await using (var sender = client.CreateSender(senderOptions))
{
var events = new[] { new EventData(Encoding.UTF8.GetBytes("AWord")) };
Assert.That(async() => await sender.SendAsync(events), Throws.Nothing);
}
}
}
public async Task SenderCanSendEventsUsingAPartitionHashHey()
{
await using (var scope = await EventHubScope.CreateAsync(4))
{
var events = Enumerable
.Range(0, 25)
.Select(index => new EventData(Encoding.UTF8.GetBytes(new String('X', index + 5))));
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var client = new EventHubClient(connectionString))
await using (var sender = client.CreateSender())
{
var batchOptions = new EventBatchingOptions {
PartitionKey = "some123key-!d"
};
Assert.That(async() => await sender.SendAsync(events, batchOptions), Throws.Nothing);
}
}
}
public async Task SenderCanSendToASpecificPartition()
{
await using (var scope = await EventHubScope.CreateAsync(4))
{
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var client = new EventHubClient(connectionString))
{
var partition = (await client.GetPartitionIdsAsync()).First();
var senderOptions = new EventSenderOptions {
PartitionId = partition
};
await using (var sender = client.CreateSender(senderOptions))
{
var events = new[] { new EventData(Encoding.UTF8.GetBytes("AWord")) };
Assert.That(async() => await sender.SendAsync(events), Throws.Nothing);
}
}
}
}
public void Scenario3_EventHubSendToPublisher(string eventHubEntity, string publisher)
{
ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(this.ConnectionString);
builder.TransportType = TransportType.Amqp;
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(this.ConnectionString);
EventHubClient client = factory.CreateEventHubClient(eventHubEntity);
EventHubSender sender = client.CreateSender(publisher);
EventData data = new EventData(Encoding.UTF8.GetBytes("Body"));
data.Properties["time"] = DateTime.UtcNow;
sender.Send(data);
sender.Close();
client.Close();
factory.Close();
}
static private void SendMessage(GDPRMessageWrapper message)
{
//send a message...
//string connectionStringBuilder = "Endpoint=sb://gdprevents.servicebus.windows.net/;SharedAccessKeyName=GDPRPolicy;SharedAccessKey=ecCNa0UQXlCFiAIbAOMCBJLbzlWqOaCI7YQX3DCmSgo=;EntityPath=gdprmessagehub";
string connectionStringBuilder = Util.EventHubConnectionStringWithPath;
eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString());
if (!string.IsNullOrEmpty(message.ApplicationId))
{
EventHubSender sender = eventHubClient.CreateSender("gdprgroup");
//EventHubSender sender = eventHubClient.CreatePartitionedSender("gdprgroup");
string msg = Newtonsoft.Json.JsonConvert.SerializeObject(message);
sender.Send(new EventData(Encoding.UTF8.GetBytes(msg)));
}
else
{
string msg = Newtonsoft.Json.JsonConvert.SerializeObject(message);
eventHubClient.Send(new EventData(Encoding.UTF8.GetBytes(msg)));
}
//eventHubClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(msg)));
//eventHubClient.CloseAsync();
}
public async Task SenderCanSendMultipleBatchesOfEventsUsingAPartitionHashHey()
{
await using (var scope = await EventHubScope.CreateAsync(4))
{
var batchOptions = new EventBatchingOptions {
PartitionKey = "some123key-!d"
};
for (var index = 0; index < 5; ++index)
{
var events = Enumerable
.Range(0, 25)
.Select(index => new EventData(Encoding.UTF8.GetBytes(new String((char)(65 + index), index + 5))));
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var client = new EventHubClient(connectionString))
await using (var sender = client.CreateSender())
{
Assert.That(async() => await sender.SendAsync(events, batchOptions), Throws.Nothing, $"Batch { index } should not have thrown an exception.");
}
}
}
}
public async Task ReceiveCanReadOneEventBatch()
{
await using (var scope = await EventHubScope.CreateAsync(4))
{
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
var eventBatch = new[]
{
new EventData(Encoding.UTF8.GetBytes("One")),
new EventData(Encoding.UTF8.GetBytes("Two")),
new EventData(Encoding.UTF8.GetBytes("Three"))
};
var receiverOptions = new EventReceiverOptions
{
BeginReceivingAt = EventPosition.NewEventsOnly
};
await using (var client = new EventHubClient(connectionString))
{
var partition = (await client.GetPartitionIdsAsync()).First();
await using (var sender = client.CreateSender(new EventSenderOptions {
PartitionId = partition
}))
await using (var receiver = client.CreateReceiver(partition, receiverOptions))
{
// Initiate an operation to force the receiver to connect and set its position at the
// end of the event stream.
Assert.That(async() => await receiver.ReceiveAsync(1, TimeSpan.Zero), Throws.Nothing);
// Send the batch of events.
await sender.SendAsync(eventBatch);
// Recieve and validate the events; because there is some non-determinism in the messaging flow, the
// sent events may not be immediately available. Allow for a small number of attempts to receive, in order
// to account for availability delays.
var receivedEvents = new List <EventData>();
var index = 0;
while ((receivedEvents.Count < eventBatch.Length) && (++index < 3))
{
receivedEvents.AddRange(await receiver.ReceiveAsync(eventBatch.Length + 10, TimeSpan.FromMilliseconds(25)));
}
index = 0;
Assert.That(receivedEvents, Is.Not.Empty, "There should have been a set of events received.");
foreach (var receivedEvent in receivedEvents)
{
Assert.That(receivedEvent.IsEquivalentTo(eventBatch[index]), Is.True, $"The received event at index: { index } did not match the sent batch.");
++index;
}
Assert.That(index, Is.EqualTo(eventBatch.Length), "The number of received events did not match the batch size.");
}
}
}
}
