protected ISubscribeOn GetOrCreateSubscriber(ISubscriptionInfo info) { var type = info.GetType(); return(_subscribers.GetValueOrDefault(type) ?? (_subscribers[type] = _createSubscriber[type](this._entity))); }
/// <summary> /// Create resource group resource /// </summary> /// <param name="manager"></param> /// <param name="group"></param> /// <param name="deleteOnDispose"></param> /// <param name="subscription"></param> /// <param name="logger"></param> public ResourceGroupResource(ResourceGroupFactory manager, IResourceGroup group, bool deleteOnDispose, ISubscriptionInfo subscription, ILogger logger) { _manager = manager; _group = group; _logger = logger; _deleteOnDispose = deleteOnDispose; Subscription = subscription; }
/// <summary> /// Safe create /// </summary> /// <param name="main"></param> /// <param name="fallback"></param> /// <returns></returns> public static ISubscriptionInfo Create(ISubscriptionInfo main, ISubscriptionInfo fallback) { if (main == null) { return(fallback ?? new SubscriptionInfo()); } if (fallback == null) { return(main ?? new SubscriptionInfo()); } return(new CompositeInfo(main, fallback)); }
// Token: 0x0600105D RID: 4189 RVA: 0x0003EE40 File Offset: 0x0003D040 private void RemoveSubscriptions(ISubscriptionInfo subscriptions) { if (subscriptions == null) { return; } if (this.contextKeySubscriptions.Remove(subscriptions.ContextKey)) { subscriptions.NotifyAllChannelsRemoved(); } subscriptions.onNoActiveSubscriptionEvent -= this.NoActiveSubscription; subscriptions.noListenersForSubscriptionEvent -= this.NoActiveListeners; }
/// <summary> /// Get or create new named resource group /// </summary> /// <param name="service"></param> /// <param name="resourceGroup"></param> /// <param name="deleteOnDispose"></param> /// <param name="subscriptionInfo"></param> /// <returns></returns> public static async Task <IResourceGroupResource> GetOrCreateAsync( this IResourceGroupFactory service, string resourceGroup, bool deleteOnDispose, ISubscriptionInfo subscriptionInfo = null) { var rg = await Try.Async(() => service.GetAsync(resourceGroup, deleteOnDispose, subscriptionInfo)); if (rg == null) { rg = await service.CreateAsync(resourceGroup, deleteOnDispose, subscriptionInfo); } return(rg); }
/// <summary> /// Helper to create new client /// </summary> /// <param name="subscription"></param> /// <returns></returns> private async Task <IAzure> CreateClientAsync(ISubscriptionInfo subscription) { // Create azure fluent interface var environment = await subscription.GetAzureEnvironmentAsync(); var subscriptionId = await subscription.GetSubscriptionId(); var credentials = await _creds.GetAzureCredentialsAsync(environment); return(Azure .Configure() .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .Authenticate(credentials) .WithSubscription(subscriptionId)); }
/// <inheritdoc/> public async Task <IResourceGroupResource> CreateAsync(string resourceGroup, bool deleteOnDispose, ISubscriptionInfo subscription) { subscription = CompositeInfo.Create(subscription, _subscription); // Create resource group var client = await CreateClientAsync(subscription); if (string.IsNullOrEmpty(resourceGroup)) { // Create group name while (true) { resourceGroup = StringEx.CreateUnique(8, "rg"); var exists = await client.ResourceGroups.ContainAsync( resourceGroup); if (!exists) { break; } } } else { var exists = await client.ResourceGroups.ContainAsync( resourceGroup); if (exists) { throw new ExternalDependencyException("resource group already exists"); } } var region = await subscription.GetRegionAsync(); _logger.Information("Creating simulation group {resourceGroup} in {region}...", resourceGroup, region); var rg = await client.ResourceGroups.Define(resourceGroup) .WithRegion(region) .CreateAsync(); _logger.Information("Created resource group {resourceGroup}.", rg.Name); return(new ResourceGroupResource(this, rg, deleteOnDispose, subscription, _logger)); }
private void InitializeSubscription(ISubscriptionInfo subscriptionInfo) { if (disposed) { throw new ObjectDisposedException(nameof(subscriptionClients)); } lock (thisLock) { if (subscriptionClients.ContainsKey(subscriptionInfo.TopicName)) { return; } } var subscriptionClient = subscriptionClientFactory.Create( configuration.ServiceBusConnectionString, subscriptionInfo.TopicName, subscriptionInfo.SubscriptionName, subscriptionInfo.RetryPolicy); // Register the function that processes messages. subscriptionClient.RegisterMessageHandler( async(message, token) => { await ProcessMessagesAsync(message).ConfigureAwait(false); await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false); }, new MessageHandlerOptions(ExceptionReceivedHandlerAsync) { // Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity. // Set it according to how many messages the application wants to process in parallel. MaxConcurrentCalls = 1, // Indicates whether the message pump should automatically complete the messages after returning from user callback. // False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync(). AutoComplete = false }); lock (thisLock) { subscriptionClients.Add(subscriptionInfo.TopicName, subscriptionClient); } }
// Token: 0x0600105B RID: 4187 RVA: 0x0003EDAC File Offset: 0x0003CFAC private void NoActiveSubscription(object sender, EventArgs e) { ISubscriptionInfo subscriptionInfo = sender as ISubscriptionInfo; if (subscriptionInfo != null) { this.RemoveSubscriptions(subscriptionInfo); UserContextKey userContextKey; if (this.TryParseUserContextKey(subscriptionInfo.ContextKey, out userContextKey)) { UserContext userContext = UserContextManager.GetMailboxContextFromCache(userContextKey) as UserContext; if (userContext != null && userContext.IsGroupUserContext) { userContext.RetireMailboxSessionForGroupMailbox(); } } } }
/// <inheritdoc/> public async Task <IResourceGroupResource> GetAsync(string resourceGroup, bool deleteOnDispose, ISubscriptionInfo subscription) { if (string.IsNullOrEmpty(resourceGroup)) { throw new ArgumentNullException(nameof(resourceGroup)); } subscription = CompositeInfo.Create(subscription, _subscription); var client = await CreateClientAsync(subscription); var rg = await client.ResourceGroups.GetByNameAsync(resourceGroup); if (rg == null) { return(null); } return(new ResourceGroupResource(this, rg, deleteOnDispose, subscription, _logger)); }
private static string FormatMessage(ISubscriptionInfo subscriptionInfo, string additionalDetails) { var message = string.Empty; if (subscriptionInfo != null) { message = string.Format(CultureInfo.CurrentCulture, SubscriptionDetailsMessage, subscriptionInfo.EventType, subscriptionInfo.TopicName, subscriptionInfo.SubscriptionName, subscriptionInfo.HandlerType.FullName); if (!string.IsNullOrEmpty(additionalDetails)) { message = string.Concat(message, Environment.NewLine, Environment.NewLine); } } if (!string.IsNullOrEmpty(additionalDetails)) { message += additionalDetails; } return(message); }
public void LogTrace(ISubscriptionInfo subscriptionInfo) { LogTraceImpl(string.Empty); }
/// <summary> /// Create composite info /// </summary> /// <param name="main"></param> /// <param name="fallback"></param> internal CompositeInfo(ISubscriptionInfo main, ISubscriptionInfo fallback) { _main = main ?? throw new ArgumentNullException(nameof(main)); _fallback = fallback ?? throw new ArgumentNullException(nameof(fallback)); }
/// <summary> /// Get non auto-delete on dispose resource group /// </summary> /// <param name="service"></param> /// <param name="resourceGroup"></param> /// <param name="subscription"></param> /// <returns></returns> public static Task <IResourceGroupResource> GetAsync( this IResourceGroupFactory service, string resourceGroup, ISubscriptionInfo subscription) { return(service.GetAsync(resourceGroup, false, subscription)); }
public void LogTrace(ISubscriptionInfo subscriptionInfo, string details) { LogTraceImpl(FormatMessage(subscriptionInfo, details)); }
public void LogCriticalError(Exception ex, ISubscriptionInfo subscriptionInfo) { LogErrorImpl(ex, SeverityLevel.Critical, FormatMessage(subscriptionInfo, null)); }
internal void Subscribe(ISubscriptionInfo info) { this.GetOrCreateSubscriber(info).Attach(info); }
public void LogCriticalError(Exception ex, ISubscriptionInfo subscriptionInfo) { // Stub implementation }
public void LogCriticalError(Exception ex, ISubscriptionInfo subscriptionInfo, string additionalDetails) { LogErrorImpl(ex, SeverityLevel.Critical, FormatMessage(subscriptionInfo, additionalDetails)); }
public void LogTrace(ISubscriptionInfo subscriptionInfo) { // Stub implementation }
public void LogCriticalError(Exception ex, ISubscriptionInfo subscriptionInfo, string additionalDetails) { // Stub implementation }
public void Attach(ISubscriptionInfo info) { this.infos.Add(info); }
public void LogTrace(ISubscriptionInfo subscriptionInfo, string details) { // Stub implementation }
/// <summary> /// Environment of subscription /// </summary> public static async Task <AzureEnvironment> GetAzureEnvironmentAsync( this ISubscriptionInfo info) { return(AzureEnvironmentEx.FromName( await info.GetEnvironment())); }
/// <summary> /// create named resource group that is non auto-delete /// on dispose in specified subscription. /// </summary> /// <param name="service"></param> /// <param name="resourceGroup"></param> /// <param name="subscription"></param> /// <returns></returns> public static Task <IResourceGroupResource> CreateAsync( this IResourceGroupFactory service, string resourceGroup, ISubscriptionInfo subscription) => service.CreateAsync(resourceGroup, false, subscription);