public async Task <List <DomainTopic> > GetDomainTopics(string credentialsAzureSubscriptionId, string credentialsTenantId, string credentialsClientId,
string credentialsClientSecret, string resourceGroupName, string domainName, string filter)
{
try
{
//Management SDKs (Microsoft.Azure.Management.EventGrid)
EventGridManagementClient managementClient = new EventGridManagementClient(credentials: new CustomLoginCredentials(credentialsTenantId, credentialsClientId, credentialsClientSecret));
managementClient.SubscriptionId = credentialsAzureSubscriptionId;
IPage <DomainTopic> topicsResult = await managementClient.DomainTopics.ListByDomainAsync(
resourceGroupName : resourceGroupName,
domainName : domainName,
filter : filter);
List <DomainTopic> topics = new List <DomainTopic>();
foreach (DomainTopic topic in topicsResult)
{
topics.Add(topic);
}
return(topics);
}
catch (Exception ex)
{
_logger?.LogError($"Unknown Exception. Type: {ex.GetType().ToString()} ; Message: {ex.Message} ; Details: {ex.ToString()}");
return(null);
}
}
public async Task <(List <string> domainTopicNames, string nextPageLink)> GetDomainTopics(
EventGridManagementClient eventGridManagementClient,
string resourceGroupName,
string domainName,
string nextPageLink = null)
{
AzureOperationResponse <IPage <DomainTopic> > result;
if (string.IsNullOrWhiteSpace(nextPageLink))
{
result = await eventGridManagementClient.DomainTopics.ListByDomainWithHttpMessagesAsync(resourceGroupName, domainName);
}
else
{
result = await eventGridManagementClient.DomainTopics.ListByDomainNextWithHttpMessagesAsync(nextPageLink);
}
var domainTopcicNames = new List <string>();
foreach (DomainTopic domainTopic in result.Body)
{
domainTopcicNames.Add(domainTopic.Name);
}
return(domainTopcicNames, result.Body.NextPageLink);
}
public static void SetEventSubscription(string authToken)
{
string settingKey = Constant.AppSettingKey.MediaPublishJobUrl;
string publishJobUrl = AppSetting.GetValue(settingKey);
EventSubscription eventSubscription = new EventSubscription(name: Constant.Media.Publish.EventGrid.SubscriptionName)
{
Destination = new WebHookEventSubscriptionDestination()
{
EndpointUrl = publishJobUrl
},
Filter = new EventSubscriptionFilter()
{
IncludedEventTypes = Constant.Media.Publish.EventGrid.EventTypes
}
};
TokenCredentials azureToken = AuthToken.AcquireToken(authToken, out string subscriptionId);
EventGridManagementClient eventGridClient = new EventGridManagementClient(azureToken)
{
SubscriptionId = subscriptionId
};
User userProfile = new User(authToken);
string eventScope = userProfile.MediaAccount.ResourceId;
eventGridClient.EventSubscriptions.CreateOrUpdate(eventScope, eventSubscription.Name, eventSubscription);
}
protected void InitializeClients(MockContext context)
{
if (!m_initialized)
{
lock (m_lock)
{
try
{
if (!m_initialized)
{
resourceManagementClient = EventGridManagementHelper.GetResourceManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
eventGridManagementClient = EventGridManagementHelper.GetEventGridManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
}
}
catch (Exception ex)
{
Console.Write(ex);
throw;
}
}
}
}
private async Task CreateEventGridSubscriptionAsync(Subscription subscription)
{
log.LogInformation("Creating event grid subscription");
AzureCredentials azureCreds = SdkContext.AzureCredentialsFactory.FromServicePrincipal(config["DockerSubAppClientId"], config["DockerSubAppSecret"], config["DockerSubAppTenant"], AzureEnvironment.AzureGlobalCloud);
using EventGridManagementClient managementClient = new EventGridManagementClient(azureCreds);
managementClient.SubscriptionId = config["AzureSubscription"];
await managementClient.EventSubscriptions.CreateOrUpdateAsync(
$"/subscriptions/{managementClient.SubscriptionId}/resourceGroups/{config["AzureResourceGroup"]}/providers/Microsoft.EventGrid/topics/docker-sub-tag-changed",
subscription.Id,
new EventSubscription(
topic : "docker-sub-tag-changed",
destination : new WebHookEventSubscriptionDestination(subscription.WebhookUrl),
eventDeliverySchema : "EventGridSchema",
filter : new EventSubscriptionFilter(advancedFilters : new List <AdvancedFilter>
{
new StringInAdvancedFilter(
$"{nameof(EventGridEvent.Data)}.{nameof(TagChangedData.SubscriptionId)}",
new List <string> {
subscription.Id
})
}))
);
}
static async Task DeleteEventGridTopicAsync(string rgname, string topicName, EventGridManagementClient EventGridMgmtClient)
{
Console.WriteLine($"Deleting EventGrid topic {topicName} in resource group {rgname}");
await EventGridMgmtClient.Topics.DeleteAsync(rgname, topicName);
Console.WriteLine("EventGrid topic " + topicName + " deleted");
}
public async Task DeleteDomainTopic(DataCleanupParameters parameters)
{
_log.LogDebug($"Deleting domain topic {parameters.DomainTopicName}");
try
{
EventGridManagementClient eventGridManagementClient = await _eventGridManager.GetEventGridManagementClient(
parameters.SubscriptionId,
parameters.ServicePrincipalClientId,
parameters.ServicePrincipalClientKey,
string.Concat(@"https://login.windows.net/", parameters.ServicePrincipalTenantId),
@"https://management.azure.com/");
await _eventGridManager.DeleteDomainTopic(
eventGridManagementClient,
parameters.ResourceGroupName,
parameters.EventGridName,
parameters.DomainTopicName);
}
catch (Exception ex)
{
_log.LogError(ex, "Exception encountered in DeleteDomainTopic method.");
throw;
}
_log.LogDebug($"Domain topic deletion completed! {parameters.DomainTopicName}");
return;
}
public async Task <EventSubscription> SubscribeEvent(
string credentialsAzureSubscriptionId,
string credentialsTenantId,
string credentialsClientId,
string credentialsClientSecret,
string scope,
string eventSubscriptionName,
string id,
string name,
string subscriptionType,
string topic,
string provisioningState,
List <string> labels,
string eventDeliverySchema,
int maxDeliveryAttempts,
int eventTimeToLiveInMinutes,
double expirationTimeInHours,
string endpointUrl,
int?maxEventsPerBatch)
{
await Task.Delay(0);
try
{
EventGridManagementClient managementClient = new EventGridManagementClient(credentials: new CustomLoginCredentials(credentialsTenantId, credentialsClientId, credentialsClientSecret));
managementClient.SubscriptionId = credentialsAzureSubscriptionId;
EventSubscriptionFilter filter = null;
DateTime? expirationTime = DateTime.UtcNow.AddHours(expirationTimeInHours);
RetryPolicy retryPolicy = new RetryPolicy(maxDeliveryAttempts: maxDeliveryAttempts,
eventTimeToLiveInMinutes: eventTimeToLiveInMinutes);
DeadLetterDestination deadLetterDestination = null;
WebHookEventSubscriptionDestination destination = new WebHookEventSubscriptionDestination(endpointUrl: endpointUrl,
maxEventsPerBatch: maxEventsPerBatch);
EventSubscription eventSubscriptionInfo = new EventSubscription(
id: id,
name: name,
type: subscriptionType,
topic: topic,
provisioningState: provisioningState,
destination: destination,
filter: filter,
labels: labels,
expirationTimeUtc: expirationTime,
eventDeliverySchema: eventDeliverySchema,
retryPolicy: retryPolicy,
deadLetterDestination: deadLetterDestination);
EventSubscription createdSubscription = await managementClient.EventSubscriptions.CreateOrUpdateAsync(
scope : scope,
eventSubscriptionName : eventSubscriptionName,
eventSubscriptionInfo : eventSubscriptionInfo);
return(createdSubscription);
}
catch (Exception ex)
{
_logger?.LogError($"Unknown Exception. Type: {ex.GetType().ToString()} ; Message: {ex.Message} ; Details: {ex.ToString()}");
return(null);
}
}
static async Task PerformDomainAndEventSubscriptionOperations()
{
string token = await GetAuthorizationHeaderAsync();
TokenCredentials credential = new TokenCredentials(token);
ResourceManagementClient resourcesClient = new ResourceManagementClient(credential)
{
SubscriptionId = SubscriptionId
};
EventGridManagementClient eventGridManagementClient = new EventGridManagementClient(credential)
{
SubscriptionId = SubscriptionId,
LongRunningOperationRetryTimeout = 2
};
try
{
// Register the EventGrid Resource Provider with the Subscription
await RegisterEventGridResourceProviderAsync(resourcesClient);
// Create a new resource group
await CreateResourceGroupAsync(ResourceGroupName, resourcesClient);
// Create a new Event Grid domain in a resource group
await CreateEventGridDomainAsync(ResourceGroupName, DomainName, eventGridManagementClient);
// Get the keys for the domain
DomainSharedAccessKeys domainKeys = await eventGridManagementClient.Domains.ListSharedAccessKeysAsync(ResourceGroupName, DomainName);
Console.WriteLine($"The key1 value of domain {DomainName} is: {domainKeys.Key1}");
// Create an event subscription at the scope of a topic under the domain
await CreateEventGridEventSubscriptionAsync(ResourceGroupName, DomainName, "domaintopic1", EventSubscriptionName, eventGridManagementClient, StorageAccountId, StorageQueueName);
// Delete the event subscription created above
await DeleteEventGridEventSubscriptionAsync(ResourceGroupName, DomainName, "domaintopic1", EventSubscriptionName, eventGridManagementClient);
// Create an event subscription at the scope of the domain
await CreateEventGridEventSubscriptionAsync(ResourceGroupName, DomainName, null, EventSubscriptionName, eventGridManagementClient, StorageAccountId, StorageQueueName);
// Delete the event subscription created above
await DeleteEventGridEventSubscriptionAsync(ResourceGroupName, DomainName, null, EventSubscriptionName, eventGridManagementClient);
// Delete the EventGrid domain with the given domain name and a resource group
await DeleteEventGridDomainAsync(ResourceGroupName, DomainName, eventGridManagementClient);
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
}
}
public async Task DeleteDomainTopic(
EventGridManagementClient eventGridManagementClient,
string resourceGroupName,
string domainName,
string domainTopicName)
{
await eventGridManagementClient.DomainTopics.DeleteWithHttpMessagesAsync(resourceGroupName, domainName, domainTopicName);
return;
}
public static EventGridManagementClient GetEventGridManagementClient(MockContext context, RecordedDelegatingHandler handler)
{
if (handler != null)
{
handler.IsPassThrough = true;
EventGridManagementClient eventGridManagementClient = context.GetServiceClient <EventGridManagementClient>(handlers: handler);
return(eventGridManagementClient);
}
return(null);
}
private async Task <EventGridManagementClient> CreateEventGridManagementClient()
{
string token = await GetAuthorizationHeaderAsync().ConfigureAwait(false);
TokenCredentials credential = new TokenCredentials(token);
EventGridManagementClient eventGridManagementClient = new EventGridManagementClient(credential)
{
SubscriptionId = eventGridSubscriptionOptions.CurrentValue.SubscriptionId,
};
return(eventGridManagementClient);
}
static async Task PerformTopicAndEventSubscriptionOperations()
{
string token = await GetAuthorizationHeaderAsync();
TokenCredentials credential = new TokenCredentials(token);
ResourceManagementClient resourcesClient = new ResourceManagementClient(credential)
{
SubscriptionId = SubscriptionId
};
EventGridManagementClient eventGridManagementClient = new EventGridManagementClient(credential)
{
SubscriptionId = SubscriptionId,
LongRunningOperationRetryTimeout = 2
};
try
{
// Register the EventGrid Resource Provider with the Subscription
await RegisterEventGridResourceProviderAsync(resourcesClient);
// Create a new resource group
await CreateResourceGroupAsync(ResourceGroupName, resourcesClient);
// Create a new Event Grid topic in a resource group
await CreateEventGridTopicAsync(ResourceGroupName, TopicName, eventGridManagementClient);
// Get the keys for the topic
TopicSharedAccessKeys topicKeys = await eventGridManagementClient.Topics.ListSharedAccessKeysAsync(ResourceGroupName, TopicName);
Console.WriteLine($"The key1 value of topic {TopicName} is: {topicKeys.Key1}");
// Create an event subscription
await CreateEventGridEventSubscriptionAsync(ResourceGroupName, TopicName, EventSubscriptionName, eventGridManagementClient, EndpointUrl);
// Delete the event subscription
await DeleteEventGridEventSubscriptionAsync(ResourceGroupName, TopicName, EventSubscriptionName, eventGridManagementClient);
// Delete an EventGrid topic with the given topic name and a resource group
await DeleteEventGridTopicAsync(ResourceGroupName, TopicName, eventGridManagementClient);
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
}
}
public Task DeleteDomainTopic(
EventGridManagementClient eventGridManagementClient,
string resourceGroupName,
string domainName,
string domainTopicName)
{
if (ThrowExceptionOnDelete)
{
throw new RequestFailedException(ExceptionMessage);
}
DeletedDomainTopics.Add(domainTopicName);
return(Task.CompletedTask);
}
public static EventGridManagementClient GetEventGridManagementClient(MockContext context, RecordedDelegatingHandler handler)
{
if (handler != null)
{
handler.IsPassThrough = true;
EventGridManagementClient eventGridManagementClient = context.GetServiceClient <EventGridManagementClient>(handlers: handler);
// By default test framework sets this to 0 during playback, and during record mode it uses default client timeout sets by the generated code
// If you want to change that time out during recording, please use HttpMockServer.Mode to detect Record/Playback
// Tests execution should not take more than 1 second during playback.
//eventGridManagementClient.LongRunningOperationRetryTimeout = 2;
return(eventGridManagementClient);
}
return(null);
}
private static void SetEventSubscription(EventGridManagementClient eventGridClient, string eventScope, string eventSubscriptionName, string eventHandlerUrl, string[] eventFilterTypes)
{
EventSubscription eventSubscription = new EventSubscription(name: eventSubscriptionName)
{
Destination = new WebHookEventSubscriptionDestination()
{
EndpointUrl = eventHandlerUrl
},
Filter = new EventSubscriptionFilter()
{
IncludedEventTypes = eventFilterTypes
}
};
eventGridClient.EventSubscriptions.CreateOrUpdate(eventScope, eventSubscription.Name, eventSubscription);
}
public async Task <DomainSharedAccessKeys> GetDomainKeys(string credentialsAzureSubscriptionId, string credentialsTenantId, string credentialsClientId,
string credentialsClientSecret, string domainName, string resourceGroupName)
{
try
{
//Management SDKs (Microsoft.Azure.Management.EventGrid)
EventGridManagementClient managementClient = new EventGridManagementClient(credentials: new CustomLoginCredentials(credentialsTenantId, credentialsClientId, credentialsClientSecret));
managementClient.SubscriptionId = credentialsAzureSubscriptionId;
DomainSharedAccessKeys domainKeys = await managementClient.Domains.ListSharedAccessKeysAsync(resourceGroupName : resourceGroupName, domainName : domainName);
return(domainKeys);
}
catch (Exception ex)
{
_logger?.LogError($"Unknown Exception. Type: {ex.GetType().ToString()} ; Message: {ex.Message} ; Details: {ex.ToString()}");
return(null);
}
}
protected void InitializeClients(MockContext context)
{
if (!m_initialized)
{
lock (m_lock)
{
if (!m_initialized)
{
resourceManagementClient = EventGridManagementHelper.GetResourceManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
eventGridManagementClient = EventGridManagementHelper.GetEventGridManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
}
}
}
}
public async Task <bool> RemoveDomainTopics(string credentialsAzureSubscriptionId, string credentialsTenantId, string credentialsClientId,
string credentialsClientSecret, string resourceGroupName, string domainName, string topicName)
{
try
{
//Management SDKs (Microsoft.Azure.Management.EventGrid)
EventGridManagementClient managementClient = new EventGridManagementClient(credentials: new CustomLoginCredentials(credentialsTenantId, credentialsClientId, credentialsClientSecret));
managementClient.SubscriptionId = credentialsAzureSubscriptionId;
await managementClient.DomainTopics.DeleteAsync(resourceGroupName : resourceGroupName, domainName : domainName, domainTopicName : topicName);
return(true);
}
catch (Exception ex)
{
_logger?.LogError($"Unknown Exception. Type: {ex.GetType().ToString()} ; Message: {ex.Message} ; Details: {ex.ToString()}");
return(false);
}
}
public async Task <Topic> RegisterTopic(string credentialsAzureSubscriptionId, string credentialsTenantId, string credentialsClientId, string credentialsClientSecret,
string resourceGroupName, string topicLocation, string topicName)
{
try
{
//Management SDKs (Microsoft.Azure.Management.EventGrid)
EventGridManagementClient managementClient = new EventGridManagementClient(credentials: new CustomLoginCredentials(credentialsTenantId, credentialsClientId, credentialsClientSecret));
managementClient.SubscriptionId = credentialsAzureSubscriptionId;
Topic topic = new Topic(location: topicLocation);
Topic createdTopic = await managementClient.Topics.CreateOrUpdateAsync(resourceGroupName : resourceGroupName, topicName : topicName, topicInfo : topic);
return(createdTopic);
}
catch (Exception ex)
{
_logger?.LogError($"Unknown Exception. Type: {ex.GetType().ToString()} ; Message: {ex.Message} ; Details: {ex.ToString()}");
return(null);
}
}
public async Task <Domain> RegisterDomain(string credentialsAzureSubscriptionId, string credentialsTenantId, string credentialsClientId,
string credentialsClientSecret, string domainName, string domainLocation, string resourceGroupName, string topicName)
{
try
{
//Management SDKs (Microsoft.Azure.Management.EventGrid)
EventGridManagementClient managementClient = new EventGridManagementClient(credentials: new CustomLoginCredentials(credentialsTenantId, credentialsClientId, credentialsClientSecret));
managementClient.SubscriptionId = credentialsAzureSubscriptionId;
Domain domainInfo = new Domain(domainLocation);
Domain createdDomain = await managementClient.Domains.CreateOrUpdateAsync(resourceGroupName : resourceGroupName, domainName : domainName,
domainInfo : domainInfo);
return(createdDomain);
}
catch (Exception ex)
{
_logger?.LogError($"Unknown Exception. Type: {ex.GetType().ToString()} ; Message: {ex.Message} ; Details: {ex.ToString()}");
return(null);
}
}
static async Task CreateEventGridTopicAsync(string rgname, string topicName, EventGridManagementClient EventGridMgmtClient)
{
Console.WriteLine("Creating an EventGrid topic...");
Dictionary <string, string> defaultTags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
};
Topic topic = new Topic()
{
Tags = defaultTags,
Location = DefaultLocation,
InputSchema = InputSchema.EventGridSchema,
InputSchemaMapping = null
};
Topic createdTopic = await EventGridMgmtClient.Topics.CreateOrUpdateAsync(rgname, topicName, topic);
Console.WriteLine("EventGrid topic created with name " + createdTopic.Name);
}
public Task <(List <string> domainTopicNames, string nextPageLink)> GetDomainTopics(
EventGridManagementClient eventGridManagementClient,
string resourceGroupName,
string domainName,
string nextPageLink)
{
if (ThrowExceptionOnGetTopics)
{
throw new RequestFailedException(ExceptionMessage);
}
TopicNameIndex++;
string returnNextPageLink = null;
if (ReturnDomainTopicNames.Count > TopicNameIndex)
{
returnNextPageLink = "Nextpage";
}
return(Task.FromResult((ReturnDomainTopicNames[TopicNameIndex - 1], returnNextPageLink)));
}
/// <summary>
/// Will create a system topic on a storage account where Azure will publish events for containers in the storage account.
/// Only one system topic can be created per storage account.
/// </summary>
private bool CreateStorageSystemTopic(string _TopicName, Action <string> _ErrorMessageAction = null)
{
try
{
SystemTopic TopicInfo = new SystemTopic(ResourceGroupLocation,
$"/subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/providers/Microsoft.EventGrid/systemTopics/{_TopicName}",
_TopicName,
"Microsoft.EventGrid/systemTopics",
null,
null,
$"/subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/providers/microsoft.storage/storageaccounts/{StorageAccountName}",
null,
"microsoft.storage.storageaccounts");
if (LastGeneratedToken.ExpiresOn.UtcDateTime <= DateTime.UtcNow)
{
ClientSecretCredential ClientCred = new ClientSecretCredential(TenantId, ClientId, ClientSecret);
TokenRequestContext RequestContext = new TokenRequestContext(new string[] { $"https://management.azure.com/.default" });
LastGeneratedToken = ClientCred.GetToken(RequestContext);
}
TokenCredentials TokenCredential = new TokenCredentials(new StringTokenProvider(LastGeneratedToken.Token, "Bearer"));
EventGridManagementClient ManagmentClient = new EventGridManagementClient(TokenCredential);
TokenCredential.InitializeServiceClient(ManagmentClient);
ManagmentClient.SubscriptionId = SubscriptionId;
AZSystemTopicOperations SystemTopicOperations = new AZSystemTopicOperations(ManagmentClient);
bool Success = SystemTopicOperations.CreateOrUpdate(ResourceGroupName, _TopicName, TopicInfo, out SystemTopic _, _ErrorMessageAction);
return(Success);
}
catch (Exception ex)
{
_ErrorMessageAction?.Invoke($"{ex.Message} :\n {ex.StackTrace}");
return(false);
}
}
public async Task <EventGridManagementClient> GetEventGridManagementClient(
string azureSubscriptionId,
string azureServicePrincipalClientId,
string azureServicePrincipalClientKey,
string azureAuthenticationAuthority,
string azureManagemernResourceUrl)
{
var cc = new ClientCredential(azureServicePrincipalClientId, azureServicePrincipalClientKey);
var context = new AuthenticationContext(azureAuthenticationAuthority);
AuthenticationResult result = await context.AcquireTokenAsync(azureManagemernResourceUrl, cc).ConfigureAwait(false);
var credential = new TokenCredentials(result.AccessToken);
var eventGridManagementClient = new EventGridManagementClient(credential)
{
SubscriptionId = azureSubscriptionId,
LongRunningOperationRetryTimeout = 50
};
return(eventGridManagementClient);
}
public static void SetMediaSubscription(MediaAccount mediaAccount)
{
ServiceClientCredentials clientCredentials = ApplicationTokenProvider.LoginSilentAsync(mediaAccount.DirectoryTenantId, mediaAccount.ServicePrincipalId, mediaAccount.ServicePrincipalKey).Result;
EventGridManagementClient eventGridClient = new EventGridManagementClient(clientCredentials)
{
SubscriptionId = mediaAccount.SubscriptionId
};
string settingKey = Constant.AppSettingKey.EventGridLiveEventUrl;
string jobOutputProgressUrl = AppSetting.GetValue(settingKey);
settingKey = Constant.AppSettingKey.EventGridJobStateFinalUrl;
string jobStateFinalUrl = AppSetting.GetValue(settingKey);
settingKey = Constant.AppSettingKey.EventGridLiveEventUrl;
string liveEventUrl = AppSetting.GetValue(settingKey);
string eventScope = mediaAccount.ResourceId;
SetEventSubscription(eventGridClient, eventScope, Constant.EventGrid.JobOutputProgressSubscriptionName, jobOutputProgressUrl, Constant.EventGrid.JobOutputProgressSubscriptionEvents);
SetEventSubscription(eventGridClient, eventScope, Constant.EventGrid.JobStateFinalSubscriptionName, jobStateFinalUrl, Constant.EventGrid.JobStateFinalSubscriptionEvents);
SetEventSubscription(eventGridClient, eventScope, Constant.EventGrid.LiveEventSubscriptionName, liveEventUrl, Constant.EventGrid.LiveEventSubscriptionEvents);
}
static async Task PerformEventSubscriptionOperationsForStorageEvents()
{
string token = await GetAuthorizationHeaderAsync();
TokenCredentials credential = new TokenCredentials(token);
ResourceManagementClient resourcesClient = new ResourceManagementClient(credential)
{
SubscriptionId = SubscriptionId
};
EventGridManagementClient eventGridManagementClient = new EventGridManagementClient(credential)
{
SubscriptionId = SubscriptionId,
LongRunningOperationRetryTimeout = 2
};
try
{
// Register the EventGrid Resource Provider with the Subscription
await RegisterEventGridResourceProviderAsync(resourcesClient);
// Create an event subscription to the storage account
await CreateEventGridEventSubscriptionAsync(EventSubscriptionName, eventGridManagementClient);
// Delete the event subscription
await DeleteEventGridEventSubscriptionAsync(EventSubscriptionName, eventGridManagementClient);
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
}
}
private async Task CreateNewEndpoint(AzureDigitalTwinsManagementClient dtClient, string subscriptionId, string resourceGroup, string instanceName)
{
var egClient = new EventGridManagementClient(GetAzureCredentials());
egClient.SubscriptionId = subscriptionId;
var topics = await egClient.Topics.ListBySubscriptionAsync($"name eq '{instanceName}'");
var topic = topics.FirstOrDefault();
if (topic == null)
{
_log.LogError($"Unable to find topic {instanceName} in subscription {subscriptionId}");
return;
}
var topicResourceGroup = topic.Id.Split("/", StringSplitOptions.RemoveEmptyEntries)[3];
var keys = await egClient.Topics.ListSharedAccessKeysAsync(topicResourceGroup, instanceName);
_log.LogInformation($"Creating endpoint for {instanceName}");
await dtClient.DigitalTwinsEndpoint.CreateOrUpdateAsync(resourceGroup, instanceName, EndpointId,
new Microsoft.Azure.Management.DigitalTwins.Models.EventGrid(topic.Endpoint, keys.Key1, accessKey2: keys.Key2));
}
static async Task DeleteEventGridEventSubscriptionAsync(string rgname, string topicName, string eventSubscriptionName, EventGridManagementClient eventGridMgmtClient)
{
Console.WriteLine($"Deleting event subscription {eventSubscriptionName} created for topic {topicName} in resource group {rgname}...");
Topic topic = await eventGridMgmtClient.Topics.GetAsync(rgname, topicName);
string eventSubscriptionScope = topic.Id;
await eventGridMgmtClient.EventSubscriptions.DeleteAsync(eventSubscriptionScope, eventSubscriptionName);
Console.WriteLine("Event subcription " + eventSubscriptionName + " deleted");
}
static async Task CreateEventGridEventSubscriptionAsync(string rgname, string topicName, string eventSubscriptionName, EventGridManagementClient eventGridMgmtClient, string endpointUrl)
{
Topic topic = await eventGridMgmtClient.Topics.GetAsync(rgname, topicName);
string eventSubscriptionScope = topic.Id;
Console.WriteLine($"Creating an event subscription to topic {topicName}...");
EventSubscription eventSubscription = new EventSubscription()
{
Destination = new WebHookEventSubscriptionDestination()
{
EndpointUrl = endpointUrl
},
// The below are all optional settings
EventDeliverySchema = EventDeliverySchema.EventGridSchema,
Filter = new EventSubscriptionFilter()
{
// By default, "All" event types are included
IsSubjectCaseSensitive = false,
SubjectBeginsWith = "",
SubjectEndsWith = ""
}
};
EventSubscription createdEventSubscription = await eventGridMgmtClient.EventSubscriptions.CreateOrUpdateAsync(eventSubscriptionScope, eventSubscriptionName, eventSubscription);
Console.WriteLine("EventGrid event subscription created with name " + createdEventSubscription.Name);
}
