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);
