public async Task<EventHubDescription> CreateEventHubAsync()
{
string serviceBusNamespace = "iotmc-ns";
string serviceBusManageKey = "<< Add your SAS here >>";
string eventHubName = "IoTMC";
string eventHubSASKeyName = "Device01";
Uri serviceBusUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, string.Empty);
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", serviceBusManageKey);
NamespaceManager nameSpaceManager = new NamespaceManager(string.Format("//{0}/", serviceBusUri.Host), tokenProvider);
string eventHubKey = SharedAccessAuthorizationRule.GenerateRandomKey();
EventHubDescription eventHubDescription = new EventHubDescription(eventHubName)
{
PartitionCount = 8,
MessageRetentionInDays = 1
};
SharedAccessAuthorizationRule eventHubSendRule = new SharedAccessAuthorizationRule(eventHubSASKeyName, eventHubKey, new[] { AccessRights.Send, AccessRights.Listen });
eventHubDescription.Authorization.Add(eventHubSendRule);
eventHubDescription = await nameSpaceManager.CreateEventHubIfNotExistsAsync(eventHubDescription);
string eventHubSASKey = ((SharedAccessAuthorizationRule)eventHubDescription.Authorization.First()).PrimaryKey;
return eventHubDescription;
}
static void Main(string[] args)
{
string serviceBusNamespace = "Please Provide Your ServiceBus Namespace";
string serviceBusManageKey = "Please Provide Your ServiceBus Shared Access Key";
Uri serviceBusUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, string.Empty);
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", serviceBusManageKey);
NamespaceManager nameSpaceManager = new NamespaceManager(string.Format("//{0}/", serviceBusUri.Host), tokenProvider);
string eventHubName = "EventHubCreatedWithCode";
string eventHubKeyName = "EventHubKey";
string eventHubKey = SharedAccessAuthorizationRule.GenerateRandomKey();
EventHubDescription eventHubDescription = new EventHubDescription(eventHubName)
{
PartitionCount = 8, MessageRetentionInDays = 1
};
SharedAccessAuthorizationRule eventHubSendRule = new SharedAccessAuthorizationRule(eventHubKeyName, eventHubKey, new[] { AccessRights.Send, AccessRights.Listen });
eventHubDescription.Authorization.Add(eventHubSendRule);
eventHubDescription = nameSpaceManager.CreateEventHubIfNotExists(eventHubDescription);
string primaryKey = ((SharedAccessAuthorizationRule)eventHubDescription.Authorization.First()).PrimaryKey;
Console.WriteLine("Primary Key: {0}", primaryKey);
Console.ReadLine();
}
protected override void CreateTopic(NamespaceManager nsm)
{
if (nsm.TopicExists(topicName))
{
nsm.DeleteTopic(topicName);
}
if (!nsm.TopicExists(topicName))
{
// this topic will use Topic related Shared Access Keys
TopicDescription td = new TopicDescription(topicName);
// create a new SAS for topic
tsKey = SharedAccessAuthorizationRule.GenerateRandomKey();
td.Authorization.Add(new SharedAccessAuthorizationRule(tsKeyName, tsKey, new[] { AccessRights.Send }));
tlKey = SharedAccessAuthorizationRule.GenerateRandomKey();
td.Authorization.Add(new SharedAccessAuthorizationRule(tlKeyName, tlKey, new[] { AccessRights.Listen }));
nsm.CreateTopic(td);
}
_tc = _cf.CreateTopicClient(nsName, topicName, tsKeyName, tsKey);
if (!nsm.SubscriptionExists(topicName, topicSubName))
{
nsm.CreateSubscription(topicName, topicSubName);
}
_sc = _cf.CreateSubscriptionClient(nsName, topicName, topicSubName, tlKeyName, tlKey);
}
public async Task <EventHubDescription> CreateEventHubAsync()
{
string serviceBusNamespace = "iotmc-ns";
string serviceBusManageKey = "<< Add your SAS here >>";
string eventHubName = "IoTMC";
string eventHubSASKeyName = "Device01";
Uri serviceBusUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceBusNamespace, string.Empty);
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", serviceBusManageKey);
NamespaceManager nameSpaceManager = new NamespaceManager(string.Format("//{0}/", serviceBusUri.Host), tokenProvider);
string eventHubKey = SharedAccessAuthorizationRule.GenerateRandomKey();
EventHubDescription eventHubDescription = new EventHubDescription(eventHubName)
{
PartitionCount = 8,
MessageRetentionInDays = 1
};
SharedAccessAuthorizationRule eventHubSendRule = new SharedAccessAuthorizationRule(eventHubSASKeyName, eventHubKey, new[] { AccessRights.Send, AccessRights.Listen });
eventHubDescription.Authorization.Add(eventHubSendRule);
eventHubDescription = await nameSpaceManager.CreateEventHubIfNotExistsAsync(eventHubDescription);
string eventHubSASKey = ((SharedAccessAuthorizationRule)eventHubDescription.Authorization.First()).PrimaryKey;
return(eventHubDescription);
}
public void getSasKey()
{
try
{
// Create namespace manager.
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty);
TokenProvider td = TokenProvider.CreateSharedAccessSignatureTokenProvider(namespaceManageKeyName, namespaceManageKey);
NamespaceManager nm = new NamespaceManager(uri, td);
// Create event hub with a SAS rule that enables sending to that event hub
EventHubDescription ed = new EventHubDescription(ehubname)
{
PartitionCount = 32
};
string eventHubSendKeyName = "EventHubSendKey";
string eventHubSendKey = SharedAccessAuthorizationRule.GenerateRandomKey();
SharedAccessAuthorizationRule eventHubSendRule = new SharedAccessAuthorizationRule
(eventHubSendKeyName, eventHubSendKey, new[] { AccessRights.Send });
ed.Authorization.Add(eventHubSendRule);
nm.CreateEventHub(ed);
string resource = "insightsehub.servicebus.windows.net/" + ehubname;
//Copy this SAS Key for use in configuring the VM Diagnostics
string saskey = SharedAccessSignatureTokenProvider.GetSharedAccessSignature(eventHubSendKeyName,
eventHubSendKey, resource, TimeSpan.FromDays(365));
Console.WriteLine("Event HUb Endpoint created");
}
catch (Exception ex)
{
Console.WriteLine("Exception " + ex.StackTrace);
}
}
private static void CreateServiceBusQueue(string queueName)
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(ConnectionStringForManaging);
if (namespaceManager.QueueExists(queueName))
{
Console.WriteLine($"Queue '{queueName}' exists.");
return;
}
var qd = new QueueDescription(queueName);
var sendKey = SharedAccessAuthorizationRule.GenerateRandomKey();
var receiveKey = SharedAccessAuthorizationRule.GenerateRandomKey();
qd.Authorization.Add(new SharedAccessAuthorizationRule("SendKey", sendKey, new[] { AccessRights.Send }));
qd.Authorization.Add(new SharedAccessAuthorizationRule("ReceiveKey", receiveKey, new[] { AccessRights.Listen }));
namespaceManager.CreateQueue(qd);
Console.WriteLine($"Created queue '{queueName}'.");
Console.WriteLine($"Now manually update the App.config in the Queue Listening-Service with the Send and Receive connection strings for this Queue:'{queueName}'.");
Console.WriteLine("Send Key - SharedAccessKeyName:'SendKey'");
Console.WriteLine($"Send Key - SharedAccessKey:'{sendKey}'");
Console.WriteLine();
Console.WriteLine($"Receive Key - SharedAccessKeyName:'ReceiveKey'");
Console.WriteLine($"Receive Key - SharedAccessKey:'{receiveKey}'");
Console.WriteLine("Hit any key to continue...");
Console.ReadKey(true);
}
public SharedAccessAuthorizationPolicyDetailsDto(
SharedAccessAuthorizationRule sharedAccessAuthorizationRule)
{
KeyName = sharedAccessAuthorizationRule.KeyName;
PrimaryKey = sharedAccessAuthorizationRule.PrimaryKey;
SecondaryKey = sharedAccessAuthorizationRule.SecondaryKey;
Rights = sharedAccessAuthorizationRule.Rights;
}
private static void RegenerateKey(QueueDescription description, string ruleName, TextWriter log)
{
SharedAccessAuthorizationRule rule;
if (!description.Authorization.TryGetSharedAccessAuthorizationRule(ruleName, out rule))
{
throw new Exception($"Authorization rule {ruleName} was not found");
}
rule.SecondaryKey = rule.PrimaryKey;
rule.PrimaryKey = SharedAccessAuthorizationRule.GenerateRandomKey();
log.WriteLine($"Authorization rule: {ruleName}\nPrimary key: {rule.PrimaryKey}\nSecondary key: {rule.SecondaryKey}");
}
private void SetAccessPassword(string accessKeyName, string password, IEnumerable <AccessRights> rights)
{
SharedAccessAuthorizationRule sharedAccessAuthorizationRule;
lock (this.Authorization)
{
if (!this.Authorization.TryGetSharedAccessAuthorizationRule(accessKeyName, out sharedAccessAuthorizationRule))
{
sharedAccessAuthorizationRule = new SharedAccessAuthorizationRule(accessKeyName, password, rights);
this.Authorization.Add(sharedAccessAuthorizationRule);
}
else
{
sharedAccessAuthorizationRule.PrimaryKey = password;
sharedAccessAuthorizationRule.Rights = rights;
}
}
}
public async Task<EventHubDescription> CreateEventHubByConnectionStringAsync()
{
string eventHubName = "IoTMC";
string eventHubSASKeyName = "Device01";
string serviceBusConnectionString = "Endpoint=sb://iotmc-ns.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=<<Add your SAS here>>";
NamespaceManager nameSpaceManager = NamespaceManager.CreateFromConnectionString(serviceBusConnectionString);
string eventHubKey = SharedAccessAuthorizationRule.GenerateRandomKey();
EventHubDescription eventHubDescription = new EventHubDescription(eventHubName)
{
PartitionCount = 8,
MessageRetentionInDays = 1
};
SharedAccessAuthorizationRule eventHubSendRule = new SharedAccessAuthorizationRule(eventHubSASKeyName, eventHubKey,
new[] { AccessRights.Send, AccessRights.Listen });
eventHubDescription.Authorization.Add(eventHubSendRule);
eventHubDescription = await nameSpaceManager.CreateEventHubIfNotExistsAsync(eventHubDescription);
string eventHubSASKey = ((SharedAccessAuthorizationRule)eventHubDescription.Authorization.First()).PrimaryKey;
return eventHubDescription;
}
static public SharedAccessAuthorizationRule ToSharedAccessAuthorizationRule(
this ServiceBusSharedAccessAuthorizationRule sbRule)
{
List<AccessRights> rights = new List<AccessRights>();
if (sbRule.Rights.Contains(AccessRight.Listen))
{
rights.Add(AccessRights.Listen);
}
if (sbRule.Rights.Contains(AccessRight.Manage))
{
rights.Add(AccessRights.Manage);
}
if (sbRule.Rights.Contains(AccessRight.Send))
{
rights.Add(AccessRights.Send);
}
var sasRule = new SharedAccessAuthorizationRule(sbRule.KeyName, sbRule.PrimaryKey, sbRule.SecondaryKey, rights);
sasRule.Revision = sbRule.Revision;
return sasRule;
}
/// <summary>
/// Updates shared access signature authorization for the service bus entity. This authorization works on
/// public Microsoft Azure environments and Windows Azure Pack on prim as well.
/// </summary>
/// <param name="namespaceName">The service bus namespace name</param>
/// <param name="entityName">The fully qualified service bus entity name</param>
/// <param name="entityType">The service bus entity type (e.g. Queue)</param>
/// <param name="ruleName">The SAS authorization rule name</param>
/// <param name="primaryKey">The SAS primary key. It'll be generated if empty</param>
/// <param name="secondaryKey">The SAS secondary key</param>
/// <param name="permissions">Set of permissions given to the rule</param>
/// <returns>The created Shared Access Signature authorization rule</returns>
public virtual ExtendedAuthorizationRule UpdateSharedAccessAuthorization(
string namespaceName,
string entityName,
ServiceBusEntityType entityType,
string ruleName,
string primaryKey,
string secondaryKey,
params AccessRights[] permissions)
{
bool removed = false;
ExtendedAuthorizationRule rule = GetAuthorizationRule( namespaceName, entityName, entityType, ruleName);
if (null == rule)
{
throw new ArgumentException(Resources.ServiceBusAuthorizationRuleNotFound);
}
SharedAccessAuthorizationRule oldRule = (SharedAccessAuthorizationRule)rule.Rule;
SharedAccessAuthorizationRule newRule = new SharedAccessAuthorizationRule(
ruleName,
string.IsNullOrEmpty(primaryKey) ? SharedAccessAuthorizationRule.GenerateRandomKey() : primaryKey,
secondaryKey,
permissions ?? oldRule.Rights);
// Create namespace manager
NamespaceManager namespaceManager = CreateNamespaceManager(namespaceName);
// Add the SAS rule and update the entity
switch (entityType)
{
case ServiceBusEntityType.Queue:
QueueDescription queue = namespaceManager.GetQueue(entityName);
removed = queue.Authorization.Remove(oldRule);
Debug.Assert(removed);
queue.Authorization.Add(newRule);
namespaceManager.UpdateQueue(queue);
break;
case ServiceBusEntityType.Topic:
TopicDescription topic = namespaceManager.GetTopic(entityName);
removed = topic.Authorization.Remove(oldRule);
Debug.Assert(removed);
topic.Authorization.Add(newRule);
namespaceManager.UpdateTopic(topic);
break;
case ServiceBusEntityType.Relay:
RelayDescription relay = namespaceManager.GetRelayAsync(entityName).Result;
removed = relay.Authorization.Remove(oldRule);
Debug.Assert(removed);
relay.Authorization.Add(newRule);
namespaceManager.UpdateRelayAsync(relay).Wait();
break;
case ServiceBusEntityType.NotificationHub:
NotificationHubDescription notificationHub = namespaceManager.GetNotificationHub(entityName);
removed = notificationHub.Authorization.Remove(oldRule);
Debug.Assert(removed);
notificationHub.Authorization.Add(newRule);
namespaceManager.UpdateNotificationHub(notificationHub);
break;
default:
throw new Exception(string.Format(Resources.ServiceBusEntityTypeNotFound, entityType.ToString()));
}
return CreateExtendedAuthorizationRule(newRule, namespaceName, entityName, entityType);
}
/// <summary>
/// Creates shared access signature authorization for the service bus namespace. This authorization works on
/// public Microsoft Azure environments and Windows Azure Pack on prim as well.
/// </summary>
/// <param name="namespaceName">The service bus namespace name</param>
/// <param name="ruleName">The SAS authorization rule name</param>
/// <param name="primaryKey">The SAS primary key. It'll be generated if empty</param>
/// <param name="secondaryKey">The SAS secondary key</param>
/// <param name="permissions">Set of permissions given to the rule</param>
/// <returns>The created Shared Access Signature authorization rule</returns>
public virtual ExtendedAuthorizationRule CreateSharedAccessAuthorization(
string namespaceName,
string ruleName,
string primaryKey,
string secondaryKey,
params AccessRights[] permissions)
{
SharedAccessAuthorizationRule rule = new SharedAccessAuthorizationRule(
ruleName,
string.IsNullOrEmpty(primaryKey) ? SharedAccessAuthorizationRule.GenerateRandomKey() : primaryKey,
secondaryKey,
permissions);
rule = ServiceBusClient.Namespaces.CreateAuthorizationRule(
namespaceName,
rule.ToServiceBusSharedAccessAuthorizationRule())
.AuthorizationRule.ToSharedAccessAuthorizationRule();
return CreateExtendedAuthorizationRule(rule, namespaceName);
}
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);
}
}
