/// <summary>
/// Create stirage service
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public StorageAccount CreateStorageService(StorageAccountCreateParameters input)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
// storage services must use lowercase names
input.Name = input.Name.ToLowerInvariant();
var existing = GetStorageService(input.Name);
if(existing != null)
{
return existing;
}
var affinityGroupManager = new AzureAffinityGroupManager();
affinityGroupManager.EnsureAffinityGroupExists(input.AffinityGroup);
TestEasyLog.Instance.Info(string.Format("Creating storage service '{0}'", input.Name));
StorageManagementClient.StorageAccounts.CreateAsync(input, new CancellationToken()).Wait();
existing = GetStorageService(input.Name);
if (string.Compare(existing.Name, AzureServiceConstants.DefaultStorageServiceName,
StringComparison.InvariantCultureIgnoreCase) != 0) // never remember default storage service to avoid deletion
{
Dependencies.TestResourcesCollector.Remember(AzureResourceType.StorageService, existing.Name, existing.Name);
}
return existing;
}
private void AddService(StorageAccountCreateParameters createParameters)
{
Add(a =>
{
a.Name = createParameters.Name;
});
}
/// <summary>
/// The Begin Creating Storage Account operation creates a new storage
/// account in Azure. (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/hh264518.aspx
/// for more information)
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.Storage.IStorageAccountOperations.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Begin Creating Storage Account
/// operation.
/// </param>
/// <returns>
/// A standard service response including an HTTP status code and
/// request ID.
/// </returns>
public static AzureOperationResponse BeginCreating(this IStorageAccountOperations operations, StorageAccountCreateParameters parameters)
{
return Task.Factory.StartNew((object s) =>
{
return ((IStorageAccountOperations)s).BeginCreatingAsync(parameters);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// The Create Storage Account operation creates a new storage account
/// in Windows Azure. (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/hh264518.aspx
/// for more information)
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.Storage.IStorageAccountOperations.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Create Storage Account operation.
/// </param>
/// <returns>
/// A standard service response including an HTTP status code and
/// request ID.
/// </returns>
public static OperationResponse BeginCreating(this IStorageAccountOperations operations, StorageAccountCreateParameters parameters)
{
try
{
return operations.BeginCreatingAsync(parameters).Result;
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Count > 1)
{
throw;
}
else
{
throw ex.InnerException;
}
}
}
public void CanAbortStorageAccountMigrationToSrp()
{
TestLogTracingInterceptor.Current.Start();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
var mgmt = TestBase.GetServiceClient<ManagementClient>();
var storage = TestBase.GetServiceClient<StorageManagementClient>();
try
{
var location = mgmt.GetDefaultLocation("Storage");
const string westUS = "West US";
if (mgmt.Locations.List().Any(
c => string.Equals(c.Name, westUS, StringComparison.OrdinalIgnoreCase)))
{
location = westUS;
}
var storageAccountName = HttpMockServer.GetAssetName(
"teststorage1234",
"teststorage").ToLower();
Assert.True(storage.StorageAccounts
.CheckNameAvailability(storageAccountName).IsAvailable);
// Create
var storageCreateParams = new StorageAccountCreateParameters
{
Location = location,
AffinityGroup = null,
Label = "Test测试1",
Description = "Test测试2",
Name = storageAccountName,
AccountType = StorageAccountTypes.StandardGRS,
ExtendedProperties = new Dictionary<string, string>
{
{ "foo1", "bar" },
{ "foo2", "baz" }
}
};
var st1 = storage.StorageAccounts.Create(storageCreateParams);
// Get
var storageCreated = storage.StorageAccounts
.Get(storageAccountName).StorageAccount;
VerifyStorageAccount(
storageCreated,
storageCreateParams.Name,
storageCreateParams.Label,
storageCreateParams.Description,
storageCreateParams.Location,
storageCreateParams.AccountType);
Assert.True(storageCreated.ExtendedProperties["foo1"] == "bar");
Assert.True(storageCreated.ExtendedProperties["foo2"] == "baz");
var response = storage.StorageAccounts.PrepareMigration(storageAccountName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
storageCreated = storage.StorageAccounts.Get(storageAccountName).StorageAccount;
Assert.Equal(IaaSClassicToArmMigrationState.Prepared, storageCreated.MigrationState);
response = storage.StorageAccounts.AbortMigration(storageAccountName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
}
finally
{
undoContext.Dispose();
mgmt.Dispose();
storage.Dispose();
TestLogTracingInterceptor.Current.Stop();
}
}
}
public void CanCreateUpdateGetAndDeleteStorageAccounts()
{
TestLogTracingInterceptor.Current.Start();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
var mgmt = TestBase.GetServiceClient<ManagementClient>();
var storage = TestBase.GetServiceClient<StorageManagementClient>();
try
{
var location = mgmt.GetDefaultLocation("Storage");
const string westUS = "West US";
if (mgmt.Locations.List().Any(
c => string.Equals(c.Name, westUS, StringComparison.OrdinalIgnoreCase)))
{
location = westUS;
}
var storageAccountName = HttpMockServer.GetAssetName(
"teststorage1234",
"teststorage").ToLower();
Assert.True(storage.StorageAccounts
.CheckNameAvailability(storageAccountName).IsAvailable);
// Create
var storageCreateParams = new StorageAccountCreateParameters
{
Location = location,
AffinityGroup = null,
Label = "Test测试1",
Description = "Test测试2",
Name = storageAccountName,
AccountType = StorageAccountTypes.StandardGRS,
ExtendedProperties = new Dictionary<string, string>
{
{ "foo1", "bar" },
{ "foo2", "baz" }
}
};
var st1 = storage.StorageAccounts.Create(storageCreateParams);
// Get
var storageCreated = storage.StorageAccounts
.Get(storageAccountName).StorageAccount;
VerifyStorageAccount(
storageCreated,
storageCreateParams.Name,
storageCreateParams.Label,
storageCreateParams.Description,
storageCreateParams.Location,
storageCreateParams.AccountType);
Assert.True(storageCreated.ExtendedProperties["foo1"] == "bar");
Assert.True(storageCreated.ExtendedProperties["foo2"] == "baz");
// Update
var storageUpdateParams = new StorageAccountUpdateParameters
{
Label = "Test测试3",
Description = "Test测试4",
AccountType = StorageAccountTypes.StandardRAGRS
};
var st2 = storage.StorageAccounts.Update(
storageAccountName,
storageUpdateParams);
// List
var storageUpdated = storage.StorageAccounts.List()
.First(s => s.Name == storageAccountName);
VerifyStorageAccount(
storageUpdated,
storageAccountName,
storageUpdateParams.Label,
storageUpdateParams.Description,
storageCreateParams.Location,
storageUpdateParams.AccountType);
// Keys
var st3 = storage.StorageAccounts.GetKeys(storageAccountName);
var st4 = storage.StorageAccounts.RegenerateKeys(
new StorageAccountRegenerateKeysParameters
{
Name = storageAccountName,
KeyType = StorageKeyType.Primary
});
var st5 = storage.StorageAccounts.GetKeys(storageAccountName);
Assert.True(st5.PrimaryKey != st3.PrimaryKey
&& st5.SecondaryKey == st3.SecondaryKey);
// Delete
var st6 = storage.StorageAccounts.Delete(storageAccountName);
Assert.True(!storage.StorageAccounts.List()
.StorageAccounts.Any(s => s.Name == storageAccountName));
}
finally
{
undoContext.Dispose();
mgmt.Dispose();
storage.Dispose();
TestLogTracingInterceptor.Current.Stop();
}
}
}
public void BackupRestore()
{
using (var context = UndoContext.Current)
{
context.Start("ResourceProviderFunctionalTests", "BackupRestore");
TryCreateApiService();
// create storage account with blob container for the API Management backup
var storageManagementClient = GetServiceClient<StorageManagementClient>();
var storageAccountName = TestUtilities.GenerateName("hydraapimstorage");
Assert.True(
storageManagementClient.StorageAccounts.CheckNameAvailability(storageAccountName).IsAvailable,
"Could not generate unique storage account name");
var storageCreateParams = new StorageAccountCreateParameters
{
Name = storageAccountName,
Location = Location,
AffinityGroup = null,
Label = "ApimHydraBackupRestoreTest",
Description = "Api Management hydra client backup/restore test",
AccountType = StorageAccountTypes.StandardGRS
};
storageManagementClient.StorageAccounts.Create(storageCreateParams);
var storageKeysResponse = storageManagementClient.StorageAccounts.GetKeys(storageAccountName);
const string apimBackupContainerName = "apimbackupcontainer";
// create API Management backup
var apiManagementClient = GetServiceClient<ApiManagementClient>(new CSMTestEnvironmentFactory());
apiManagementClient.RefreshAccessToken();
const string apimBackupName = "apimbackup.zip";
var backupRestoreParameters = new ApiServiceBackupRestoreParameters
{
StorageAccount = storageAccountName,
AccessKey = storageKeysResponse.PrimaryKey,
ContainerName = apimBackupContainerName,
BackupName = apimBackupName
};
var response =
apiManagementClient.ResourceProvider.Backup(
ResourceGroupName,
ApiManagementServiceName,
backupRestoreParameters);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
// restore Api Management service from backup
apiManagementClient.RefreshAccessToken();
response =
apiManagementClient.ResourceProvider.Restore(
ResourceGroupName,
ApiManagementServiceName,
backupRestoreParameters);
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var getResponse = apiManagementClient.ResourceProvider.Get(ResourceGroupName, ApiManagementServiceName);
Assert.NotNull(getResponse);
Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);
Assert.NotNull(getResponse.Value);
Assert.Equal("Succeeded", getResponse.Value.Properties.ProvisioningState);
}
}
/// <summary>
/// The Create Storage Account operation creates a new storage account
/// in Azure. (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/hh264518.aspx
/// for more information)
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.Storage.IStorageAccountOperations.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Create Storage Account
/// operation.
/// </param>
/// <returns>
/// The response body contains the status of the specified asynchronous
/// operation, indicating whether it has succeeded, is inprogress, or
/// has failed. Note that this status is distinct from the HTTP status
/// code returned for the Get Operation Status operation itself. If
/// the asynchronous operation succeeded, the response body includes
/// the HTTP status code for the successful request. If the
/// asynchronous operation failed, the response body includes the HTTP
/// status code for the failed request and error information regarding
/// the failure.
/// </returns>
public static Task<OperationStatusResponse> CreateAsync(this IStorageAccountOperations operations, StorageAccountCreateParameters parameters)
{
return operations.CreateAsync(parameters, CancellationToken.None);
}
/// <summary>
/// The Begin Creating Storage Account operation creates a new storage
/// account in Azure. (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/hh264518.aspx
/// for more information)
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.Storage.IStorageAccountOperations.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Begin Creating Storage Account
/// operation.
/// </param>
/// <returns>
/// A standard service response including an HTTP status code and
/// request ID.
/// </returns>
public static Task<AzureOperationResponse> BeginCreatingAsync(this IStorageAccountOperations operations, StorageAccountCreateParameters parameters)
{
return operations.BeginCreatingAsync(parameters, CancellationToken.None);
}
/// <summary>
/// Creates storage service if it does not exist.
/// </summary>
/// <param name="name">The storage service name</param>
/// <param name="label">The storage service label</param>
/// <param name="location">The location name. If not provided default one will be used</param>
/// <param name="affinityGroup">The affinity group name</param>
public void CreateStorageServiceIfNotExist(
string name,
string label = null,
string location = null,
string affinityGroup = null)
{
if (!StorageServiceExists(name))
{
var createParameters = new StorageAccountCreateParameters {Name = name, Label = label, AccountType = "Standard_LRS"};
if (!string.IsNullOrEmpty(affinityGroup))
{
createParameters.AffinityGroup = affinityGroup;
}
else
{
location = string.IsNullOrEmpty(location) ? GetDefaultLocation() : location;
createParameters.Location = location;
}
TranslateException(() => StorageClient.StorageAccounts.Create(createParameters));
}
}
internal void ExecuteCommand()
{
ServiceManagementProfile.Initialize();
var parameters = new StorageAccountCreateParameters
{
Name = this.StorageAccountName,
Label = this.Label,
Description = this.Description,
AffinityGroup = this.AffinityGroup,
Location = this.Location,
AccountType = string.IsNullOrEmpty(this.Type) ? StorageAccountTypes.StandardGRS : this.Type
};
ExecuteClientActionNewSM(
parameters,
CommandRuntime.ToString(),
() => this.StorageClient.StorageAccounts.Create(parameters));
}
private static StorageAccountCreateParameters CreateStorageAccountParameters(DeveloperParameters developerOptions)
{
var parameters = new StorageAccountCreateParameters
{
Description = developerOptions.Description,
//GeoReplicationEnabled = developerOptions.GeoReplicationEnabled,
// for now. not sure what the label entails.
Label = developerOptions.StorageAccountName,
Name = developerOptions.StorageAccountName
};
if (developerOptions.AffinityGroup != null)
{
parameters.AffinityGroup = developerOptions.AffinityGroup;
}
else if (developerOptions.Location != null)
{
parameters.Location = developerOptions.Location;
}
else
{
throw new ArgumentException(
"Must have a value for either AffinityGroup or Location. Please verify your settings in the manifest file.");
}
return parameters;
}
private async void CreateStorageAccount()
{
Host.StatusMessage = "Creating Storage Account";
var acct = new StorageAccountCreateParameters
{
ServiceName = NewStorageAccountName,
Location = SelectedLocation.Name
};
await _storageClient.StorageAccounts.CreateAsync(acct);
Host.StatusMessage = "Storage Account Created";
await GetStorageAccounts();
}