public static async Task Main(string[] args)
{
// Create token provider so that we can use it at both management and runtime clients.
TokenProvider tokenProvider = TokenProvider.CreateAzureActiveDirectoryTokenProvider(
async(audience, authority, state) =>
{
IConfidentialClientApplication app = ConfidentialClientApplicationBuilder.Create(ClientId)
.WithAuthority(authority)
.WithClientSecret(ClientSecret)
.Build();
var authResult = await app.AcquireTokenForClient(new string[] { $"{audience}/.default" }).ExecuteAsync();
return(authResult.AccessToken);
},
ServiceAudience.EventHubsAudience,
$"https://login.microsoftonline.com/{TenantId}");
var eventHubName = "testeh-" + Guid.NewGuid().ToString();
// Create NamespaceManger and EventHubClient with Azure Active Directory token provider.
var ehUri = new Uri($"sb://{EventHubNamespace}/");
var namespaceManager = new NamespaceManager(ehUri, tokenProvider);
var messagingFactory = MessagingFactory.Create(ehUri,
new MessagingFactorySettings()
{
TokenProvider = tokenProvider,
TransportType = TransportType.Amqp
});
var ehClient = messagingFactory.CreateEventHubClient(eventHubName);
// Create a new event hub.
Console.WriteLine($"Creating event hub {eventHubName}");
await namespaceManager.CreateEventHubAsync(eventHubName);
// Send and receive a message.
await SendReceiveAsync(ehClient);
// Delete event hub.
Console.WriteLine($"Deleting event hub {eventHubName}");
await namespaceManager.DeleteEventHubAsync(eventHubName);
Console.WriteLine("Press enter to exit");
Console.ReadLine();
}
private async void btnStart_Click(object sender, EventArgs e)
{
try
{
if (string.Compare(btnStart.Text, Start, StringComparison.OrdinalIgnoreCase) == 0)
{
// Change button text
btnStart.Text = Stop;
// Validate parameters
if (!ValidateParameters())
{
return;
}
// Create namespace manager
var namespaceUri = ServiceBusEnvironment.CreateServiceUri("sb", txtNamespace.Text, string.Empty);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(txtKeyName.Text, txtKeyValue.Text);
var namespaceManager = new NamespaceManager(namespaceUri, tokenProvider);
// Check if the event hub already exists, if not, create the event hub.
var eventHubDescription = await namespaceManager.EventHubExistsAsync(txtEventHub.Text) ?
await namespaceManager.GetEventHubAsync(txtEventHub.Text) :
await namespaceManager.CreateEventHubAsync(new EventHubDescription(txtEventHub.Text)
{
PartitionCount = txtPartitionCount.IntegerValue,
MessageRetentionInDays = txtMessageRetentionInDays.IntegerValue
});
WriteToLog(string.Format(EventHubCreatedOrRetrieved, txtEventHub.Text));
// Check if the SAS authorization rule used by devices to send events to the event hub already exists, if not, create the rule.
var authorizationRule = eventHubDescription.
Authorization.
FirstOrDefault(r => string.Compare(r.KeyName,
SenderSharedAccessKey,
StringComparison.InvariantCultureIgnoreCase)
== 0) as SharedAccessAuthorizationRule;
if (authorizationRule == null)
{
authorizationRule = new SharedAccessAuthorizationRule(SenderSharedAccessKey,
SharedAccessAuthorizationRule.GenerateRandomKey(),
new[]
{
AccessRights.Send
});
eventHubDescription.Authorization.Add(authorizationRule);
await namespaceManager.UpdateEventHubAsync(eventHubDescription);
}
cancellationTokenSource = new CancellationTokenSource();
var serviceBusNamespace = txtNamespace.Text;
var eventHubName = txtEventHub.Text;
var senderKey = authorizationRule.PrimaryKey;
var status = txtStatus.Text;
var eventInterval = txtEventIntervalInMilliseconds.IntegerValue;
var minValue = txtMinValue.IntegerValue;
var maxValue = txtMaxValue.IntegerValue;
var cancellationToken = cancellationTokenSource.Token;
// Create one task for each device
for (var i = 1; i <= txtDeviceCount.IntegerValue; i++)
{
var deviceId = i;
#pragma warning disable 4014
#pragma warning disable 4014
Task.Run(async() =>
#pragma warning restore 4014
{
var deviceName = $"device{deviceId:000}";
var random = new Random((int)DateTime.Now.Ticks);
if (radioButtonAmqp.Checked)
{
// The token has the following format:
// SharedAccessSignature sr={URI}&sig={HMAC_SHA256_SIGNATURE}&se={EXPIRATION_TIME}&skn={KEY_NAME}
var token = CreateSasTokenForAmqpSender(SenderSharedAccessKey,
senderKey,
serviceBusNamespace,
eventHubName,
deviceName,
TimeSpan.FromDays(1));
WriteToLog(string.Format(SasToken, deviceId));
var messagingFactory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, ""), new MessagingFactorySettings
{
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(token),
TransportType = TransportType.Amqp
});
WriteToLog(string.Format(MessagingFactoryCreated, deviceId));
// Each device uses a different publisher endpoint: [EventHub]/publishers/[PublisherName]
var eventHubClient = messagingFactory.CreateEventHubClient($"{eventHubName}/publishers/{deviceName}");
WriteToLog(string.Format(EventHubClientCreated, deviceId, eventHubClient.Path));
while (!cancellationToken.IsCancellationRequested)
{
// Create random value
var value = random.Next(minValue, maxValue + 1);
// Create EventData object with the payload serialized in JSON format
var payload = JsonConvert.SerializeObject(new Payload
{
Id = deviceId,
Name = deviceName,
Status = status,
Value = value
});
using (var eventData = new EventData(Encoding.UTF8.GetBytes(payload))
{
PartitionKey = deviceName
})
{
// Create custom properties
eventData.Properties.Add(DeviceId, deviceId);
eventData.Properties.Add(DeviceName, deviceName);
eventData.Properties.Add(DeviceLocation, status);
eventData.Properties.Add(Value, value);
// Send the event to the event hub
await eventHubClient.SendAsync(eventData);
WriteToLog(string.Format(EventSent, deviceId, deviceName, value));
}
// Wait for the event time interval
Thread.Sleep(eventInterval);
}
}
else
{
// The token has the following format:
// SharedAccessSignature sr={URI}&sig={HMAC_SHA256_SIGNATURE}&se={EXPIRATION_TIME}&skn={KEY_NAME}
var token = CreateSasTokenForHttpsSender(SenderSharedAccessKey,
senderKey,
serviceBusNamespace,
eventHubName,
deviceName,
TimeSpan.FromDays(1));
WriteToLog(string.Format(SasToken, deviceId));
// Create HttpClient object used to send events to the event hub.
var httpClient = new HttpClient
{
BaseAddress = new Uri($"https://{serviceBusNamespace}.servicebus.windows.net/{eventHubName}/publishers/{deviceName}".ToLower())
};
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", token);
httpClient.DefaultRequestHeaders.Add("ContentType", "application/json;type=entry;charset=utf-8");
WriteToLog(string.Format(HttpClientCreated, deviceId, httpClient.BaseAddress));
while (!cancellationToken.IsCancellationRequested)
{
// Create random value
var value = random.Next(minValue, maxValue + 1);
// Create HttpContent
var postContent = new ByteArrayContent(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new Payload
{
Id = deviceId,
Name = deviceName,
Status = status,
Value = value
})));
// Create custom properties
postContent.Headers.Add(DeviceId, deviceId.ToString(CultureInfo.InvariantCulture));
postContent.Headers.Add(DeviceName, deviceName);
//postContent.Headers.Add(DeviceLocation, location);
postContent.Headers.Add(Value, value.ToString(CultureInfo.InvariantCulture));
try
{
var response = await httpClient.PostAsync(httpClient.BaseAddress + "/messages" + "?timeout=60" + ApiVersion, postContent, cancellationToken);
response.EnsureSuccessStatusCode();
WriteToLog(string.Format(EventSent, deviceId, deviceName, value));
}
catch (HttpRequestException ex)
{
WriteToLog(string.Format(SendFailed, deviceId, ex.Message));
}
}
}
},
cancellationToken).ContinueWith(t =>
#pragma warning restore 4014
#pragma warning restore 4014
{
if (t.IsFaulted && t.Exception != null)
{
HandleException(t.Exception);
}
}, cancellationToken);
}
}
else
{
// Change button text
btnStart.Text = Start;
cancellationTokenSource?.Cancel();
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
