private async Task <string[]> GetPartitionIdsAsync()
{
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(hubSettings.ConnectionString);
EventHubDescription hubDescription = await namespaceManager.GetEventHubAsync(hubSettings.Path);
return(hubDescription.PartitionIds);
}
/// <summary>
/// Get partition Ids from eventhub
/// </summary>
/// <returns></returns>
protected virtual async Task <string[]> GetPartitionIdsAsync()
{
#if NETSTANDARD
EventHubRuntimeInformation runtimeInfo = await client.GetRuntimeInformationAsync();
return(runtimeInfo.PartitionIds);
#else
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(hubSettings.ConnectionString);
EventHubDescription hubDescription = await namespaceManager.GetEventHubAsync(hubSettings.Path);
return(hubDescription.PartitionIds);
#endif
}
public static async Task<EventHubDescription> UpdateEventHub(string eventHubName, NamespaceManager namespaceManager)
{
// Add a consumer group
EventHubDescription ehd = await namespaceManager.GetEventHubAsync(eventHubName);
await namespaceManager.CreateConsumerGroupIfNotExistsAsync(ehd.Path, "consumerGroupName");
// Create a customer SAS rule with Manage permissions
ehd.UserMetadata = "Some updated info";
string ruleName = "myeventhubmanagerule";
string ruleKey = SharedAccessAuthorizationRule.GenerateRandomKey();
ehd.Authorization.Add(new SharedAccessAuthorizationRule(ruleName, ruleKey, new AccessRights[] { AccessRights.Manage, AccessRights.Listen, AccessRights.Send }));
EventHubDescription ehdUpdated = await namespaceManager.UpdateEventHubAsync(ehd);
return ehd;
}
public static async Task <EventHubDescription> UpdateEventHub(string eventHubName, NamespaceManager namespaceManager)
{
// Add a consumer group
EventHubDescription ehd = await namespaceManager.GetEventHubAsync(eventHubName);
await namespaceManager.CreateConsumerGroupIfNotExistsAsync(ehd.Path, "consumerGroupName");
// Create a customer SAS rule with Manage permissions
ehd.UserMetadata = "Some updated info";
string ruleName = "myeventhubmanagerule";
string ruleKey = SharedAccessAuthorizationRule.GenerateRandomKey();
ehd.Authorization.Add(new SharedAccessAuthorizationRule(ruleName, ruleKey, new AccessRights[] { AccessRights.Manage, AccessRights.Listen, AccessRights.Send }));
EventHubDescription ehdUpdated = await namespaceManager.UpdateEventHubAsync(ehd);
return(ehd);
}
private async void StartDevices()
{
// 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.
if (!await namespaceManager.EventHubExistsAsync(cboEventHub.Text))
{
WriteToLog(string.Format(EventHubDoesNotExists, cboEventHub.Text));
return;
}
var eventHubDescription = await namespaceManager.GetEventHubAsync(cboEventHub.Text);
WriteToLog(string.Format(EventHubCreatedOrRetrieved, cboEventHub.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 = cboEventHub.Text;
var senderKey = authorizationRule.PrimaryKey;
var status = DefaultStatus;
var eventInterval = txtEventIntervalInMilliseconds.IntegerValue;
var minValue = txtMinValue.IntegerValue;
var maxValue = txtMaxValue.IntegerValue;
var minOffset = txtMinOffset.IntegerValue;
var maxOffset = txtMaxOffset.IntegerValue;
var spikePercentage = trackbarSpikePercentage.Value;
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}";
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 = GetValue(minValue, maxValue, minOffset, maxOffset, spikePercentage);
var timestamp = DateTime.Now;
// Create EventData object with the payload serialized in JSON format
var payload = new Payload
{
DeviceId = deviceId,
Name = deviceName,
Status = status,
Value = value,
Timestamp = timestamp
};
var json = JsonConvert.SerializeObject(payload);
using (var eventData = new EventData(Encoding.UTF8.GetBytes(json))
{
PartitionKey = deviceName
})
{
// Create custom properties
eventData.Properties.Add(DeviceId, deviceId);
eventData.Properties.Add(DeviceName, deviceName);
eventData.Properties.Add(DeviceStatus, status);
eventData.Properties.Add(Value, value);
eventData.Properties.Add(Timestamp, timestamp);
// Send the event to the event hub
await eventHubClient.SendAsync(eventData);
WriteToLog($"[Event] DeviceId=[{payload.DeviceId:000}] " +
$"Value=[{payload.Value:000}] " +
$"Timestamp=[{payload.Timestamp}]");
}
// 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(string.Format(EventHubUrl,
serviceBusNamespace,
eventHubName,
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 = GetValue(minValue, maxValue, minOffset, maxOffset, spikePercentage);
var timestamp = DateTime.Now;
// Create EventData object with the payload serialized in JSON format
var payload = new Payload
{
DeviceId = deviceId,
Name = deviceName,
Status = status,
Value = value,
Timestamp = timestamp
};
var json = JsonConvert.SerializeObject(payload);
// Create HttpContent
var postContent = new ByteArrayContent(Encoding.UTF8.GetBytes(json));
// Create custom properties
postContent.Headers.Add(DeviceId, deviceId.ToString(CultureInfo.InvariantCulture));
postContent.Headers.Add(DeviceName, deviceName);
//postContent.Headers.Add(DeviceStatus, location);
postContent.Headers.Add(Value, value.ToString(CultureInfo.InvariantCulture));
postContent.Headers.Add(Timestamp, timestamp.ToString(CultureInfo.InvariantCulture));
try
{
var response =
await
httpClient.PostAsync(
httpClient.BaseAddress + "/messages" + "?timeout=60" + ApiVersion,
postContent, cancellationToken);
response.EnsureSuccessStatusCode();
WriteToLog($"[Event] DeviceId=[{payload.DeviceId:000}] " +
$"Value=[{payload.Value:000}] " +
$"Timestamp=[{payload.Timestamp}]");
}
catch (HttpRequestException ex)
{
WriteToLog(string.Format(SendFailed, deviceId, ex.Message));
}
// Wait for the event time interval
Thread.Sleep(eventInterval);
}
}
},
cancellationToken).ContinueWith(t =>
#pragma warning restore 4014
#pragma warning restore 4014
{
if (t.IsFaulted && t.Exception != null)
{
HandleException(t.Exception);
}
}, cancellationToken);
}
}
private async void StartDevices()
{
// 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.
if (!await namespaceManager.EventHubExistsAsync(cboEventHub.Text))
{
WriteToLog(string.Format(EventHubDoesNotExists, cboEventHub.Text));
return;
}
var eventHubDescription = await namespaceManager.GetEventHubAsync(cboEventHub.Text);
WriteToLog(string.Format(EventHubCreatedOrRetrieved, cboEventHub.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 = cboEventHub.Text;
var senderKey = authorizationRule.PrimaryKey;
var status = DefaultStatus;
var eventInterval = txtEventIntervalInMilliseconds.IntegerValue;
var minValue = txtMinValue.IntegerValue;
var maxValue = txtMaxValue.IntegerValue;
var minOffset = txtMinOffset.IntegerValue;
var maxOffset = txtMaxOffset.IntegerValue;
var spikePercentage = trackbarSpikePercentage.Value;
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}";
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 = GetValue(minValue, maxValue, minOffset, maxOffset, spikePercentage);
var timestamp = DateTime.Now;
// Create EventData object with the payload serialized in JSON format
var payload = new Payload
{
DeviceId = deviceId,
Name = deviceName,
Status = status,
Value = value,
Timestamp = timestamp
};
var json = JsonConvert.SerializeObject(payload);
using (var eventData = new EventData(Encoding.UTF8.GetBytes(json))
{
PartitionKey = deviceName
})
{
// Create custom properties
eventData.Properties.Add(DeviceId, deviceId);
eventData.Properties.Add(DeviceName, deviceName);
eventData.Properties.Add(DeviceStatus, status);
eventData.Properties.Add(Value, value);
eventData.Properties.Add(Timestamp, timestamp);
// Send the event to the event hub
await eventHubClient.SendAsync(eventData);
WriteToLog($"[Event] DeviceId=[{payload.DeviceId:000}] " +
$"Value=[{payload.Value:000}] " +
$"Timestamp=[{payload.Timestamp}]");
}
// 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(string.Format(EventHubUrl,
serviceBusNamespace,
eventHubName,
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 = GetValue(minValue, maxValue, minOffset, maxOffset, spikePercentage);
var timestamp = DateTime.Now;
// Create EventData object with the payload serialized in JSON format
var payload = new Payload
{
DeviceId = deviceId,
Name = deviceName,
Status = status,
Value = value,
Timestamp = timestamp
};
var json = JsonConvert.SerializeObject(payload);
// Create HttpContent
var postContent = new ByteArrayContent(Encoding.UTF8.GetBytes(json));
// Create custom properties
postContent.Headers.Add(DeviceId, deviceId.ToString(CultureInfo.InvariantCulture));
postContent.Headers.Add(DeviceName, deviceName);
//postContent.Headers.Add(DeviceStatus, location);
postContent.Headers.Add(Value, value.ToString(CultureInfo.InvariantCulture));
postContent.Headers.Add(Timestamp, timestamp.ToString(CultureInfo.InvariantCulture));
try
{
var response =
await
httpClient.PostAsync(
httpClient.BaseAddress + "/messages" + "?timeout=60" + ApiVersion,
postContent, cancellationToken);
response.EnsureSuccessStatusCode();
WriteToLog($"[Event] DeviceId=[{payload.DeviceId:000}] " +
$"Value=[{payload.Value:000}] " +
$"Timestamp=[{payload.Timestamp}]");
}
catch (HttpRequestException ex)
{
WriteToLog(string.Format(SendFailed, deviceId, ex.Message));
}
// Wait for the event time interval
Thread.Sleep(eventInterval);
}
}
},
cancellationToken).ContinueWith(t =>
#pragma warning restore 4014
#pragma warning restore 4014
{
if (t.IsFaulted && t.Exception != null)
{
HandleException(t.Exception);
}
}, cancellationToken);
}
}
