public AzureTestContext(Dictionary <string, List <string> > subscriptionToDatabaseMap) { AzureAccountManagerMock = new Mock <IAzureAuthenticationManager>(); List <IAzureUserAccountSubscriptionContext> accountSubscriptions = new List <IAzureUserAccountSubscriptionContext>(); AzureResourceManagerMock = new Mock <IAzureResourceManager>(); foreach (string subscriptionName in subscriptionToDatabaseMap.Keys) { var azureAccount = new AzureUserAccount(); string tenantId = Guid.NewGuid().ToString(); AzureSubscriptionIdentifier subId = new AzureSubscriptionIdentifier(azureAccount, tenantId, subscriptionName, null); var subscription = new AzureUserAccountSubscriptionContext(subId, new TokenCredentials("dummy")); accountSubscriptions.Add(subscription); var sessionMock = new Mock <IAzureResourceManagementSession>(); IAzureResourceManagementSession session = sessionMock.Object; sessionMock.Setup(x => x.SubscriptionContext).Returns(subscription); AzureResourceManagerMock.Setup(x => x.CreateSessionAsync(subscription)).Returns(Task.FromResult(session)); MockServersAndDatabases(subscriptionToDatabaseMap[subscriptionName], session); } AzureAccountManagerMock.Setup(x => x.GetSelectedSubscriptionsAsync()).Returns (Task.FromResult(accountSubscriptions as IEnumerable <IAzureUserAccountSubscriptionContext>)); }
/// <summary> /// Finds Azure resource for the given subscription and server name /// </summary> private async Task <IAzureSqlServerResource> FindAzureResourceForSubscriptionAsync( string serverName, IAzureResourceManagementSession session) { try { IEnumerable <IAzureSqlServerResource> resources = await ResourceManager.GetSqlServerAzureResourcesAsync(session); if (resources == null) { return(null); } foreach (IAzureSqlServerResource resource in resources) { if (serverName.Equals(resource.FullyQualifiedDomainName, StringComparison.OrdinalIgnoreCase)) { return(resource); } } } catch (ServiceExceptionBase ex) { HandleError(ex, serverName, session.SubscriptionContext); } catch (Exception ex) { throw new FirewallRuleException(SR.FirewallRuleCreationFailed, ex); } return(null); }
/// <summary> /// Returns a list of azure databases given subscription resource group name and server name /// </summary> /// <param name="azureResourceManagementSession">Subscription Context which includes credentials to use in the resource manager</param> /// <param name="resourceGroupName">Resource Group Name</param> /// <param name="serverName">Server name</param> /// <returns>The list of databases</returns> public async Task <IEnumerable <IAzureResource> > GetAzureDatabasesAsync( IAzureResourceManagementSession azureResourceManagementSession, string resourceGroupName, string serverName) { CommonUtil.CheckForNull(azureResourceManagementSession, "azureResourceManagerSession"); try { AzureResourceManagementSession vsAzureResourceManagementSession = azureResourceManagementSession as AzureResourceManagementSession; if (vsAzureResourceManagementSession != null) { IEnumerable <Database> databaseListResponse = await ExecuteCloudRequest( () => vsAzureResourceManagementSession.SqlManagementClient.Databases.ListByServerAsync(resourceGroupName, serverName), SR.FailedToGetAzureDatabasesErrorMessage); return(databaseListResponse.Select(x => new AzureResourceWrapper(x) { ResourceGroupName = resourceGroupName })); } } catch (Exception ex) { Logger.Write(LogLevel.Error, string.Format(CultureInfo.CurrentCulture, "Failed to get databases {0}", ex.Message)); throw; } return(null); }
/// <summary> /// Returns a list of azure servers given subscription /// </summary> /// <param name="azureResourceManagementSession">Subscription Context which includes credentials to use in the resource manager</param> /// <returns>The list of Sql server resources</returns> public async Task <IEnumerable <IAzureSqlServerResource> > GetSqlServerAzureResourcesAsync( IAzureResourceManagementSession azureResourceManagementSession) { CommonUtil.CheckForNull(azureResourceManagementSession, "azureResourceManagerSession"); List <IAzureSqlServerResource> sqlServers = new List <IAzureSqlServerResource>(); try { AzureResourceManagementSession vsAzureResourceManagementSession = azureResourceManagementSession as AzureResourceManagementSession; if (vsAzureResourceManagementSession != null) { IServersOperations serverOperations = vsAzureResourceManagementSession.SqlManagementClient.Servers; IPage <Server> servers = await ExecuteCloudRequest( () => serverOperations.ListAsync(), SR.FailedToGetAzureSqlServersWithError); if (servers != null) { sqlServers.AddRange(servers.Select(server => { var serverResource = new SqlAzureResource(server); // TODO ResourceGroup name return(serverResource); })); } } } catch (Exception ex) { TraceException(TraceEventType.Error, (int)TraceId.AzureResource, ex, "Failed to get servers"); throw; } return(sqlServers); }
/// <summary> /// Returns a list of Azure sql databases for given subscription /// </summary> private async Task <ServiceResponse <FirewallRuleResource> > TryFindAzureResourceForSubscriptionAsync(object notRequired, IAzureUserAccountSubscriptionContext input, string serverName, CancellationToken cancellationToken, CancellationToken internalCancellationToken) { ServiceResponse <FirewallRuleResource> result = null; if (!cancellationToken.IsCancellationRequested) { using (IAzureResourceManagementSession session = await ResourceManager.CreateSessionAsync(input)) { IAzureSqlServerResource azureSqlServer = await FindAzureResourceForSubscriptionAsync(serverName, session); if (azureSqlServer != null) { result = new ServiceResponse <FirewallRuleResource>(new FirewallRuleResource() { SubscriptionContext = input, AzureResource = azureSqlServer }.SingleItemAsEnumerable()); result.Found = true; } } } return(result ?? new ServiceResponse <FirewallRuleResource>()); }
public AzureServerDatabaseDiscoveryProvider(IAzureResourceManager azureResourceManager, IAzureResourceManagementSession session, ServerDefinition serverDefinition) { CommonUtil.CheckForNull(session, "session"); CommonUtil.CheckForNull(azureResourceManager, "azureResourceManager"); _session = session; AzureResourceManager = azureResourceManager; ServerDefinition = serverDefinition ?? ServerDefinition.Default; }
public async Task <FirewallRuleResponse> CreateFirewallRuleAsync( IAzureResourceManagementSession azureResourceManagementSession, IAzureSqlServerResource azureSqlServer, FirewallRuleRequest firewallRuleRequest) { CommonUtil.CheckForNull(azureResourceManagementSession, "azureResourceManagerSession"); CommonUtil.CheckForNull(firewallRuleRequest, "firewallRuleRequest"); CommonUtil.CheckForNull(azureSqlServer, "azureSqlServer"); try { AzureResourceManagementSession vsAzureResourceManagementSession = azureResourceManagementSession as AzureResourceManagementSession; if (vsAzureResourceManagementSession != null) { var firewallRule = new RestFirewallRule() { EndIpAddress = firewallRuleRequest.EndIpAddress.ToString(), StartIpAddress = firewallRuleRequest.StartIpAddress.ToString() }; IFirewallRulesOperations firewallRuleOperations = vsAzureResourceManagementSession.SqlManagementClient.FirewallRules; var firewallRuleResponse = await ExecuteCloudRequest( () => firewallRuleOperations.CreateOrUpdateWithHttpMessagesAsync( azureSqlServer.ResourceGroupName ?? string.Empty, azureSqlServer.Name, firewallRuleRequest.FirewallRuleName, firewallRule, GetCustomHeaders()), SR.FirewallRuleCreationFailedWithError); var response = firewallRuleResponse.Body; return(new FirewallRuleResponse() { StartIpAddress = response.StartIpAddress, EndIpAddress = response.EndIpAddress, Created = true }); } // else respond with failure case return(new FirewallRuleResponse() { Created = false }); } catch (Exception ex) { TraceException(TraceEventType.Error, (int)TraceId.AzureResource, ex, "Failed to create firewall rule"); throw; } }
private async Task <ServiceResponse <DatabaseInstanceInfo> > GetDatabasesForServerFromService( IAzureResourceManagementSession session, IAzureSqlServerResource azureSqlServer, string serverName, CancellationToken cancellationToken, CancellationToken internalCancellationToken) { try { if (cancellationToken.IsCancellationRequested) { return(new ServiceResponse <DatabaseInstanceInfo>()); } ServerInstanceInfo serverInstanceInfo = new ServerInstanceInfo(ServerDefinition) { Name = azureSqlServer.Name, FullyQualifiedDomainName = azureSqlServer.FullyQualifiedDomainName, AdministratorLogin = azureSqlServer.AdministratorLogin }; OnDatabaseFound(new DatabaseInstanceInfo(serverInstanceInfo)); IEnumerable <IAzureResource> databases = await AzureResourceManager.GetAzureDatabasesAsync( session, azureSqlServer.ResourceGroupName, azureSqlServer.Name); if (cancellationToken.IsCancellationRequested) { return(new ServiceResponse <DatabaseInstanceInfo>()); } else { IEnumerable <DatabaseInstanceInfo> data = databases.Select(x => ConvertToModel(serverInstanceInfo, x)); ServiceResponse <DatabaseInstanceInfo> result = new ServiceResponse <DatabaseInstanceInfo>(data); foreach (var databaseInstance in result.Data) { if (cancellationToken.IsCancellationRequested) { break; } OnDatabaseFound(databaseInstance); } return(result); } } catch (Exception ex) { return(new ServiceResponse <DatabaseInstanceInfo>(ex)); } }
public async Task <ServiceResponse <ServerInstanceInfo> > GetServerInstancesAsync() { ServiceResponse <ServerInstanceInfo> result = new ServiceResponse <ServerInstanceInfo>(); List <ServerInstanceInfo> serverInstances = new List <ServerInstanceInfo>(); if (AccountManager != null && AzureAccountManager != null && AzureResourceManager != null) { try { IEnumerable <IAzureUserAccountSubscriptionContext> subscriptions = await AzureAccountManager.GetSelectedSubscriptionsAsync(); if (subscriptions != null) { foreach (IAzureUserAccountSubscriptionContext subscription in subscriptions) { using (IAzureResourceManagementSession session = await AzureResourceManager.CreateSessionAsync(subscription)) { IEnumerable <IAzureSqlServerResource> azureResources = await AzureResourceManager.GetSqlServerAzureResourcesAsync(session); serverInstances.AddRange( azureResources.Select(x => new ServerInstanceInfo(ServerDefinition) { Name = x.Name, FullyQualifiedDomainName = x.FullyQualifiedDomainName, AdministratorLogin = x.AdministratorLogin })); } } } result = new ServiceResponse <ServerInstanceInfo>(serverInstances); } catch (Exception ex) { result = new ServiceResponse <ServerInstanceInfo>(serverInstances, new List <Exception>() { ex }); } } return(result); }
private void MockServersAndDatabases(List <string> resourceNames, IAzureResourceManagementSession session) { IEnumerable <IAzureResource> azureResources = resourceNames.Select( x => new AzureResourceWrapper(new TrackedResource(Guid.NewGuid().ToString(), "id", x, "type")) { ResourceGroupName = Guid.NewGuid().ToString() } ).ToList(); List <IAzureSqlServerResource> servers = new List <IAzureSqlServerResource>(); foreach (var azureResourceWrapper in azureResources.ToList()) { var serverName = GetServerName(azureResourceWrapper.Name); if (string.IsNullOrEmpty(serverName) || servers.Any(x => x.Name == serverName)) { continue; } var databases = azureResources.Where(x => x.Name.StartsWith(serverName + "/")); if (serverName.Equals("error", StringComparison.OrdinalIgnoreCase)) { AzureResourceManagerMock.Setup(x => x.GetAzureDatabasesAsync(session, azureResourceWrapper.ResourceGroupName, serverName)) .Throws(new ApplicationException(serverName)); } else { AzureResourceManagerMock.Setup(x => x.GetAzureDatabasesAsync(session, azureResourceWrapper.ResourceGroupName, serverName)) .Returns(Task.FromResult(databases)); } Server azureSqlServer = new Server(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), serverName, null, null, null, null, null, null, null, null, fullyQualifiedDomainName: serverName + ".database.windows.net"); servers.Add(new SqlAzureResource(azureSqlServer) { ResourceGroupName = azureResourceWrapper.ResourceGroupName }); } AzureResourceManagerMock.Setup(x => x.GetSqlServerAzureResourcesAsync(session)) .Returns(Task.FromResult(servers as IEnumerable <IAzureSqlServerResource>)); }
/// <summary> /// Returns a list of Azure sql databases for given subscription /// </summary> private async Task <ServiceResponse <DatabaseInstanceInfo> > GetDatabaseForSubscriptionFromServiceAsync( IAzureUserAccountSubscriptionContext input, string serverName, CancellationToken cancellationToken, CancellationToken internalCancellationToken) { ServiceResponse <DatabaseInstanceInfo> result = null; try { if (!cancellationToken.IsCancellationRequested && !internalCancellationToken.IsCancellationRequested) { using (IAzureResourceManagementSession session = await AzureResourceManager.CreateSessionAsync(input)) { //find the server matches with the given servername which should be only one bool shouldFilter = !string.IsNullOrEmpty(serverName); IEnumerable <IAzureSqlServerResource> sqlAzureServers = await AzureResourceManager.GetSqlServerAzureResourcesAsync(session); IEnumerable <IAzureSqlServerResource> filteredServers = !shouldFilter ? sqlAzureServers : sqlAzureServers.Where(x => x.FullyQualifiedDomainName != null && x.FullyQualifiedDomainName.Equals(serverName, StringComparison.OrdinalIgnoreCase)); IList <IAzureSqlServerResource> filteredServersList = filteredServers.ToList(); result = await GetDatabasesForSubscriptionServersAsync(session, filteredServersList.ToList(), cancellationToken); //Set response Found to true to notify the other tasks to cancel if (shouldFilter && filteredServersList.Any()) { result.Found = true; } } } } catch (Exception ex) { result = new ServiceResponse <DatabaseInstanceInfo>(ex); } return(result ?? new ServiceResponse <DatabaseInstanceInfo>()); }
/// <summary> /// Creates firewall rule for given subscription and IP address range /// </summary> private async Task <FirewallRuleResponse> CreateFirewallRule(FirewallRuleResource firewallRuleResource, IPAddress startIpAddress, IPAddress endIpAddress) { CommonUtil.CheckForNull(firewallRuleResource, "firewallRuleResource"); try { if (firewallRuleResource.IsValid) { FirewallRuleRequest request = new FirewallRuleRequest() { StartIpAddress = startIpAddress, EndIpAddress = endIpAddress }; using (IAzureResourceManagementSession session = await ResourceManager.CreateSessionAsync(firewallRuleResource.SubscriptionContext)) { return(await ResourceManager.CreateFirewallRuleAsync( session, firewallRuleResource.AzureResource, request)); } } } catch (ServiceExceptionBase) { throw; } catch (Exception ex) { throw new FirewallRuleException(string.Format(CultureInfo.CurrentCulture, SR.FirewallRuleCreationFailedWithError, ex.Message), ex); } return(new FirewallRuleResponse() { Created = false }); }
private async Task <ServiceResponse <DatabaseInstanceInfo> > GetDatabasesForSubscriptionServersAsync(IAzureResourceManagementSession session, IList <IAzureSqlServerResource> filteredServersList, CancellationToken cancellationToken) { ServiceResponse <DatabaseInstanceInfo> result = null; AzureServerDatabaseDiscoveryProvider azureServerDatabaseDiscoveryProvider = new AzureServerDatabaseDiscoveryProvider(AzureResourceManager, session, ServerDefinition); azureServerDatabaseDiscoveryProvider.DatabaseFound += AzureServerDatabaseDiscoveryProviderOnDatabaseFound; if (filteredServersList.Any()) { result = await azureServerDatabaseDiscoveryProvider.GetDatabasesForServers(filteredServersList, cancellationToken); } return(result ?? new ServiceResponse <DatabaseInstanceInfo>()); }