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