/// <summary>
/// Creates the response model given server response
/// </summary>
/// <param name="response">Server Response</param>
/// <returns>Response Model</returns>
private AzureSqlDatabaseImportExportBaseModel CreateImportExportResponse(ImportExportResponse response, AzureSqlDatabaseImportExportBaseModel originalModel)
{
AzureSqlDatabaseImportExportBaseModel model = originalModel == null ? new AzureSqlDatabaseImportExportBaseModel() : originalModel.Copy();
model.OperationStatusLink = response.OperationStatusLink;
model.Status = response.Status.ToString();
model.ErrorMessage = response.Error == null ? "" : response.Error.Message;
return(model);
}
/// <summary>
/// Creates a new export request
/// </summary>
/// <param name="exportRequest">Export request parameters</param>
/// <returns>Operation response including the OperationStatusLink to get the operation status</returns>
public AzureSqlDatabaseImportExportBaseModel Export(AzureSqlDatabaseImportExportBaseModel exportRequest)
{
ExportRequestParameters parameters = new ExportRequestParameters()
{
AdministratorLogin = exportRequest.AdministratorLogin,
AdministratorLoginPassword = AzureSqlServerAdapter.Decrypt(exportRequest.AdministratorLoginPassword),
StorageKey = exportRequest.StorageKey,
StorageKeyType = exportRequest.StorageKeyType.ToString(),
StorageUri = exportRequest.StorageUri
};
if (exportRequest.AuthenticationType != AuthenticationType.None)
{
parameters.AuthenticationType = exportRequest.AuthenticationType.ToString().ToLowerInvariant();
}
ImportExportResponse response = Communicator.Export(exportRequest.ResourceGroupName, exportRequest.ServerName,
exportRequest.DatabaseName, parameters, Util.GenerateTracingId());
return(CreateImportExportResponse(response, exportRequest));
}
/// <summary>
/// Creates a new import request
/// </summary>
/// <param name="importRequest">Import request parameters</param>
/// <returns>Operation response including the OperationStatusLink to get the operation status</returns>
public AzureSqlDatabaseImportExportBaseModel Import(AzureSqlDatabaseImportModel importRequest)
{
ImportRequestParameters parameters = new ImportRequestParameters()
{
AdministratorLogin = importRequest.AdministratorLogin,
AdministratorLoginPassword = AzureSqlServerAdapter.Decrypt(importRequest.AdministratorLoginPassword),
StorageKey = importRequest.StorageKey,
StorageKeyType = importRequest.StorageKeyType.ToString(),
StorageUri = importRequest.StorageUri,
DatabaseMaxSize = importRequest.DatabaseMaxSizeBytes,
Edition = importRequest.Edition != Database.Model.DatabaseEdition.None ? importRequest.Edition.ToString() : string.Empty,
ServiceObjectiveName = importRequest.ServiceObjectiveName,
DatabaseName = importRequest.DatabaseName
};
if (importRequest.AuthenticationType != AuthenticationType.None)
{
parameters.AuthenticationType = importRequest.AuthenticationType.ToString().ToLowerInvariant();
}
ImportExportResponse response = Communicator.Import(importRequest.ResourceGroupName, importRequest.ServerName, parameters, Util.GenerateTracingId());
return(CreateImportExportResponse(response, importRequest));
}
private void ValidateImportExport(bool createServer = true, bool createDatabase = true, bool createFirewallRule = true,
string operationName = "Export", bool missingFields = false, HttpStatusCode expectedStatueCode = HttpStatusCode.Accepted)
{
var handler = new BasicDelegatingHandler();
// Management Clients
var sqlClient = Sql2ScenarioHelper.GetSqlClient(handler);
var resClient = Sql2ScenarioHelper.GetResourceClient(handler);
// Variables for server create
string serverName = TestUtilities.GenerateName("csm-sql-ie");
string resGroupName = TestUtilities.GenerateName("csm-rg-servercrud");
string serverLocation = "North Europe";
string adminLogin = "******";
string adminPass = "******";
string version = "12.0";
// Variables for database create
string databaseName = TestUtilities.GenerateName("csm-sql-db_ie");
string databaseEdition = "Standard";
long databaseMaxSize = 5L * 1024L * 1024L * 1024L; // 5 GB
Guid dbSloS1 = new Guid("1b1ebd4d-d903-4baa-97f9-4ea675f5e928"); // S1
string serviceObjectiveName = "S1";
// Create firewall test.
string firewallRuleName = TestUtilities.GenerateName("sql-fwrule");
string startIp1 = "0.0.0.0";
string endIp1 = "255.255.255.255";
string storageKey = "StorageKey";
string storageKeyType = "StorageAccessKey";
string exportBacpacLink = string.Format(CultureInfo.InvariantCulture, "http://test.blob.core.windows.net/databases/{0}.bacpac", databaseName);
string importBacpacLink = "http://test.blob.core.windows.net/databases/test.bacpac";
string testMode = Environment.GetEnvironmentVariable("AZURE_TEST_MODE");
if (testMode == "Record")
{
string importBacpacBaseUrl = Environment.GetEnvironmentVariable("TEST_EXPORT_BACPAC");
storageKey = Environment.GetEnvironmentVariable("TEST_STORAGE_KEY");
exportBacpacLink = string.Format(CultureInfo.InvariantCulture, "{0}/{1}.bacpac", importBacpacBaseUrl, databaseName);
importBacpacLink = Environment.GetEnvironmentVariable("TEST_IMPORT_BACPAC");
Assert.False(string.IsNullOrWhiteSpace(storageKey), "Environment variable TEST_EXPORT_BACPAC has not been set");
Assert.False(string.IsNullOrWhiteSpace(importBacpacBaseUrl), "Environment variable TEST_EXPORT_BACPAC has not been set");
Assert.False(string.IsNullOrWhiteSpace(importBacpacLink), "Environment variable TEST_IMPORT_BACPAC has not been set");
}
// Create the resource group.
resClient.ResourceGroups.CreateOrUpdate(resGroupName, new ResourceGroup()
{
Location = serverLocation,
});
try
{
//////////////////////////////////////////////////////////////////////
// Create server
if (createServer)
{
var createResponse = sqlClient.Servers.CreateOrUpdate(resGroupName, serverName, new ServerCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new ServerCreateOrUpdateProperties()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
Version = version,
}
});
TestUtilities.ValidateOperationResponse(createResponse, HttpStatusCode.Created);
}
//////////////////////////////////////////////////////////////////////
// Create database
if (createServer && createDatabase)
{
var createDbResponse = sqlClient.Databases.CreateOrUpdate(resGroupName, serverName, databaseName, new DatabaseCreateOrUpdateParameters()
{
Location = serverLocation,
Properties = new DatabaseCreateOrUpdateProperties()
{
Edition = databaseEdition,
MaxSizeBytes = databaseMaxSize,
RequestedServiceObjectiveId = dbSloS1
},
});
TestUtilities.ValidateOperationResponse(createDbResponse, HttpStatusCode.Created);
}
//////////////////////////////////////////////////////////////////////
// Create firewall rule
if (createServer && createFirewallRule)
{
var firewallCreate = sqlClient.FirewallRules.CreateOrUpdate(resGroupName, serverName, firewallRuleName, new FirewallRuleCreateOrUpdateParameters()
{
Properties = new FirewallRuleCreateOrUpdateProperties()
{
StartIpAddress = startIp1,
EndIpAddress = endIp1,
}
});
TestUtilities.ValidateOperationResponse(firewallCreate, HttpStatusCode.Created);
}
//////////////////////////////////////////////////////////////////////
//Import Export
try
{
ImportExportResponse importExportResponse = null;
if (operationName == ExportOperationName)
{
ExportRequestParameters parameters = new ExportRequestParameters()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass
};
if (!missingFields)
{
parameters.StorageKey = storageKey;
parameters.StorageKeyType = storageKeyType;
parameters.StorageUri = new Uri(exportBacpacLink);
}
importExportResponse = sqlClient.ImportExport.Export(resGroupName, serverName, databaseName, parameters);
}
else if (operationName == ImportOperationName)
{
ImportRequestParameters parameters = new ImportRequestParameters()
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
StorageKey = storageKey,
StorageKeyType = storageKeyType,
StorageUri = new Uri(importBacpacLink),
DatabaseName = databaseName
};
if (!missingFields)
{
parameters.DatabaseMaxSize = databaseMaxSize;
parameters.Edition = databaseEdition;
parameters.ServiceObjectiveName = serviceObjectiveName;
}
importExportResponse = sqlClient.ImportExport.Import(resGroupName, serverName, parameters);
}
else if (operationName == ImportExistingDbOperationName)
{
ImportExtensionRequestParameteres parameters = new ImportExtensionRequestParameteres()
{
Properties = new ImportExtensionProperties
{
AdministratorLogin = adminLogin,
AdministratorLoginPassword = adminPass,
StorageKey = storageKey,
StorageKeyType = storageKeyType,
StorageUri = new Uri(importBacpacLink)
}
};
importExportResponse = sqlClient.ImportExport.ImportToExistingDatabase(resGroupName, serverName, databaseName, parameters);
}
if (expectedStatueCode == HttpStatusCode.Accepted)
{
Assert.Equal(importExportResponse.Status, OperationStatus.InProgress);
ImportExportOperationStatusResponse statusResponse = sqlClient.ImportExport.GetImportExportOperationStatus(importExportResponse.OperationStatusLink);
while (statusResponse.Status == Microsoft.Azure.OperationStatus.InProgress)
{
statusResponse = sqlClient.ImportExport.GetImportExportOperationStatus(importExportResponse.OperationStatusLink);
if (statusResponse.Status == Microsoft.Azure.OperationStatus.InProgress)
{
ValidateImportExportOperationStatusResponseProperties(statusResponse);
}
}
Assert.Equal(statusResponse.Status, OperationStatus.Succeeded);
ValidateImportExportOperationStatusResponseProperties(statusResponse.Properties);
}
TestUtilities.ValidateOperationResponse(importExportResponse, expectedStatueCode);
}
catch (CloudException exception)
{
Assert.Equal(exception.Response.StatusCode, expectedStatueCode);
}
if (operationName == ImportOperationName && !createDatabase && !missingFields)
{
DatabaseGetResponse databaseGetResponse = sqlClient.Databases.Get(resGroupName, serverName, databaseName);
TestUtilities.ValidateOperationResponse(databaseGetResponse);
}
}
finally
{
// Clean up the resource group.
resClient.ResourceGroups.Delete(resGroupName);
}
}
static void Main(string[] args)
{
//Authenticate With Client ID and Secret (OR Implement MSI)
ClientCredential Credentials = new ClientCredential("YOUR CLIENT ID HERE", "YOUR CLIENT SECRET HERE");
AuthenticationContext AuthContext = new AuthenticationContext(String.Format("https://login.windows.net/{0}", "YOUR TENANT ID HERE"));
AuthenticationResult AuthResult = AuthContext.AcquireTokenAsync("https://management.core.windows.net/", Credentials).Result;
TokenCredentials AuthTokenCredentials = new TokenCredentials(AuthResult.AccessToken);
_client = new SqlManagementClient(AuthTokenCredentials);
_client.SubscriptionId = "YOU SUBSCRIPTION ID HERE";
EnterResourceGroup:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine();
Console.WriteLine("Enter Resource Group Name:");
Console.ForegroundColor = ConsoleColor.White;
String ResourceGroupName = Console.ReadLine();
if (String.IsNullOrWhiteSpace(ResourceGroupName))
{
goto EnterResourceGroup;
}
IEnumerable <Server> Servers = _client.Servers.ListByResourceGroup(ResourceGroupName);
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine();
Console.WriteLine("Available Servers:");
Console.WriteLine("---------------------");
Console.ForegroundColor = ConsoleColor.White;
foreach (Server CurrentServer in Servers)
{
Console.WriteLine(CurrentServer.Name);
}
EnterServerName:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine();
Console.WriteLine("Enter a Server Name:");
Console.ForegroundColor = ConsoleColor.White;
String ServerName = Console.ReadLine();
if (String.IsNullOrWhiteSpace(ServerName) || Servers.FirstOrDefault(x => x.Name.ToLowerInvariant() == ServerName.ToLowerInvariant()) == null)
{
goto EnterServerName;
}
EnterLoginDetails:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine();
Console.WriteLine("Enter Server Login Details (Username and Password Comma Separated (,)):");
Console.ForegroundColor = ConsoleColor.White;
String LoginDetails = Console.ReadLine();
if (String.IsNullOrWhiteSpace(LoginDetails) || !LoginDetails.Contains(","))
{
goto EnterLoginDetails;
}
String[] LoginDetailsArray = LoginDetails.Split(',');
if (LoginDetailsArray.Count() < 2)
{
goto EnterLoginDetails;
}
IEnumerable <ElasticPool> Pools =
ListElasticPools(ResourceGroupName, ServerName);
if (Pools == null || Pools.Count() == 0)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine();
Console.WriteLine("Please create an Elastic Pool first!");
Console.ReadKey();
return;
}
EnterElasticPoolName:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine();
Console.WriteLine("Enter Elastic Pool Name:");
Console.ForegroundColor = ConsoleColor.White;
String ElasticPoolName = Console.ReadLine();
ElasticPool currentElasticPool = null;
if (String.IsNullOrWhiteSpace(ElasticPoolName) || Pools.FirstOrDefault(x => x.Name.ToLowerInvariant() == ElasticPoolName.ToLowerInvariant()) == null)
{
goto EnterElasticPoolName;
}
else
{
currentElasticPool = Pools.FirstOrDefault(x => x.Name.ToLowerInvariant() == ElasticPoolName.ToLowerInvariant());
}
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine();
Console.WriteLine("Creating Template Database, This May Take Sometime...");
//********************************************************************************//
//Here is where you will actually Import the database, //
//Provide the information to Blob Storage Account that holds your Database BACPAC //
//Important Information: The Database and Elastic Pool must have compatible SKU's //
//For Example: ElasticPool -> Standard, Database -> Standard S2 //
//********************************************************************************//
ImportRequest ImportRequestInfo =
new ImportRequest(StorageKeyType.StorageAccessKey,
"YOUR STORAGE ACCOUNT ACCESS KEY HERE", "YOUR BLOBL STORAGE URI HERE",
LoginDetailsArray[0], LoginDetailsArray[1],
currentElasticPool.Name + "-templatedb", "Standard", "S2", "100", AuthenticationType.SQL);
ImportExportResponse Response =
_client.Databases.Import(ResourceGroupName, ServerName, ImportRequestInfo);
Console.WriteLine("Adding Template Database To Elastic Pool, This May Take Sometime...");
//***********************************************************************************//
//Here we fetch the newly created Database out ready for updating the SKU and Pool ID//
//***********************************************************************************//
Database NewlyCreatedDatabase = _client.Databases.Get(ResourceGroupName, ServerName, Response.DatabaseName);
//Modified The ElasticPoolId (Provide The Selected ElasticPool Id So We Can Link.
NewlyCreatedDatabase.ElasticPoolId = currentElasticPool.Id;
//Modified The SKU So That The Database Is Compatible With The ElasticPool
NewlyCreatedDatabase.Sku = new Sku("ElasticPool", "Standard");
//Update The Database With The New SKU Settings And Elastic Pool Id.
_client.Databases.CreateOrUpdate(ResourceGroupName, ServerName, Response.DatabaseName, NewlyCreatedDatabase);
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine();
Console.WriteLine("Created Database And Linked To Selected Elastic Pool Successfully !");
}
