private void CompareExpectedGetResult(StorageAccountGetResponse response)
{
StorageAccountModel result = response.StorageAccount;
Assert.Equal(result.Properties.AccountType, StorageAccountType.StandardLRS);
Assert.Equal(result.Properties.CreationTime, "Thu, 20 Aug 2015 16:08:53 GMT");
Assert.Equal(result.Properties.TenantAccountName, "705mystorageaccount1@2015-08-20T16:09:34.2006267Z");
Assert.Equal(result.Properties.State, StorageAccountState.Created);
Assert.Equal(result.Properties.PrimaryLocation, "DevFabric");
Assert.Equal(result.Properties.StatusOfPrimary, RegionStatus.Available);
result = response.StorageAccount;
Assert.Equal(result.Properties.AccountStatus, StorageAccountStatus.OutOfRetentionPeriod);
Assert.NotNull(result.Properties.DeletedTime);
Assert.Null(result.Properties.RecycledTime);
Assert.Equal(result.Properties.CurrentOperation, StorageAccountOperation.Delete);
Assert.Equal(result.Properties.PrimaryEndpoints.Count, 3);
Assert.NotNull(result.Properties.WacInternalState);
Assert.NotNull(result.Properties.AccountId);
Assert.NotNull(result.Properties.Permissions);
}
private Task <StorageAccountGetResponse> CreateGetResponse(string serviceName)
{
Task <StorageAccountGetResponse> resultTask;
var data = accounts.FirstOrDefault(a => a.Name == serviceName);
if (data != null)
{
var storageServiceGetResponse = new StorageAccountGetResponse
{
StorageAccount = new StorageAccount
{
Name = data.Name,
Properties = new StorageAccountProperties
{
Endpoints =
{
new Uri(data.BlobEndpoint),
new Uri(data.QueueEndpoint),
new Uri(data.TableEndpoint)
}
}
}
};
resultTask = Tasks.FromResult(storageServiceGetResponse);
}
else
{
resultTask = Tasks.FromException <StorageAccountGetResponse>(ClientMocks.Make404Exception());
}
return(resultTask);
}
public override ProvisionAddOnResult Provision(AddonProvisionRequest request)
{
var provisionResult = new ProvisionAddOnResult("");
var manifest = request.Manifest;
var inputDevParams = request.DeveloperParameters;
try
{
// parse required options here, use developer options class to do so.
var manifestProperties = manifest.GetProperties();
// Developer Options will be instantiated first time here (hence, null).
var devParams = DeveloperParameters.Parse(inputDevParams, manifestProperties);
// establish MSFT Azure Storage client
var client = EstablishClient(devParams);
// ok now we need to understand what the developer wants to do.
// ------------------------------------------------------------
// logic:
// - if the developer wishes to create a storage account, we go that route first
// - if a storage account exists, test it (including above)
// - create the blob container
// ------------------------------------------------------------
var parameters = CreateStorageAccountParameters(devParams);
var mResponse = client.StorageAccounts.Create(parameters);
do
{
StorageAccountGetResponse verificationResponse = client.StorageAccounts.Get(parameters.Name);
if (verificationResponse.StorageAccount.Properties.Status.Equals(StorageAccountStatus.Created))
{
StorageAccountGetResponse azureconnectioninfo =
client.StorageAccounts.Get(devParams.StorageAccountName);
StorageAccountGetKeysResponse keysForStorageUnit =
client.StorageAccounts.GetKeys(devParams.StorageAccountName);
var connectionInfo = new ConnectionInfo
{
PrimaryKey = keysForStorageUnit.PrimaryKey,
SecondaryKey = keysForStorageUnit.SecondaryKey,
StorageAccountName = azureconnectioninfo.StorageAccount.Name,
URI = keysForStorageUnit.Uri.ToString()
};
provisionResult.ConnectionData = connectionInfo.ToString();
// deprovision request of storage account was successful.
provisionResult.IsSuccess = true;
break;
}
Thread.Sleep(TimeSpan.FromSeconds(10d));
} while (true);
}
catch (Exception e)
{
provisionResult.EndUserMessage = e.Message;
}
return(provisionResult);
}
internal StorageAccountGetResponse GetStorageAccountProperties()
{
StorageAccountGetResponse gr = new StorageAccountGetResponse();
gr = _storageManagementClient.StorageAccounts.Get(
_parameters.StorageAccountName);
return(gr);
}
public Uri UploadFileToBlob(BlobUploadParameters parameters)
{
StorageAccountGetKeysResponse keys = StorageManagementClient.StorageAccounts.GetKeys(parameters.StorageName);
string storageKey = keys.PrimaryKey;
StorageAccountGetResponse storageService = StorageManagementClient.StorageAccounts.Get(parameters.StorageName);
Uri blobEndpointUri = storageService.StorageAccount.Properties.Endpoints[0];
return(UploadFile(parameters.StorageName,
GeneralUtilities.CreateHttpsEndpoint(blobEndpointUri.ToString()),
storageKey, parameters));
}
/// <summary>
/// Checks for the existence of a specific storage container, if it doesn't exist it will create it.
/// It also checks for a specific storage account that suits the system, if it doesn't exist in the subscription
/// it will create it before attempting to create the container.
/// </summary>
/// <param name="client">The <see cref="StorageManagementClient"/> that is performing the operation.</param>
/// <param name="model">The DevOpsFlex rich model object that contains everything there is to know about this database spec.</param>
/// <returns>The async <see cref="Task"/> wrapper.</returns>
public static async Task CreateContainerIfNotExistsAsync(this StorageManagementClient client, AzureStorageContainer model)
{
Contract.Requires(client != null);
Contract.Requires(model != null);
Contract.Requires(model.System != null);
string accountName;
lock (StorageAccountGate)
{
FlexStreams.BuildEventsObserver.OnNext(new CheckForParentResourceEvent(AzureResource.StorageAccount, AzureResource.StorageContainer, model.Name));
accountName = FlexConfiguration.StorageAccountChooser.Choose(client, model.System.StorageType.GetEnumDescription()).Result;
StorageAccountGetResponse account = null;
try
{
account = client.StorageAccounts.Get(accountName);
}
catch
{
// ignored
}
if (account == null)
{
accountName = (model.System.LogicalName + FlexDataConfiguration.StorageAccountString + FlexDataConfiguration.Branch).ToLower();
client.StorageAccounts.Create(
new StorageAccountCreateParameters
{
Name = accountName,
Location = model.System.Location.GetEnumDescription(),
AccountType = model.System.StorageType.GetEnumDescription()
});
FlexStreams.BuildEventsObserver.OnNext(new ProvisionEvent(AzureResource.StorageAccount, accountName));
}
else
{
accountName = account.StorageAccount.Name;
FlexStreams.BuildEventsObserver.OnNext(new FoundExistingEvent(AzureResource.StorageAccount, accountName));
}
}
await client.CreateContainerIfNotExistsAsync(
accountName,
FlexConfiguration.GetNaming <AzureStorageContainer>()
.GetSlotName(model, FlexDataConfiguration.Branch, FlexDataConfiguration.Configuration),
model.PublicAccess,
model.Acl);
}
private static void GetStorageAccountProperties(ManagementControllerParameters managementControllerParameters, int step)
{
using (var controller = new ManagementController(managementControllerParameters))
{
Console.WriteLine("\n{1}. Get properties for Storage Account named {0}.", managementControllerParameters.StorageAccountName, step);
ConsoleContinuePrompt("Get Properties");
StorageAccountGetResponse gr = controller.GetStorageAccountProperties();
Console.WriteLine(" Status.................: {0}", gr.StorageAccount.Properties.Status);
Console.WriteLine(" Label..................: {0}", gr.StorageAccount.Properties.Label);
Console.WriteLine(" Description............: {0}", gr.StorageAccount.Properties.Description);
Console.WriteLine(" Affinity Group.........: {0}", gr.StorageAccount.Properties.AffinityGroup);
Console.WriteLine(" Location...............: {0}", gr.StorageAccount.Properties.Location);
Console.WriteLine(" Geo-Primary Region.....: {0}", gr.StorageAccount.Properties.GeoPrimaryRegion);
Console.WriteLine(" Geo-Secondary Region...: {0}", gr.StorageAccount.Properties.GeoSecondaryRegion);
Console.WriteLine(" Last geo-failover time.: {0}\n", gr.StorageAccount.Properties.LastGeoFailoverTime.ToString());
Console.WriteLine("...Complete");
}
}
public override void ExecuteCmdlet()
{
MediaServicesClient = MediaServicesClient ?? new MediaServicesClient(Profile, Profile.Context.Subscription, WriteDebug);
StorageAccountGetKeysResponse storageKeysResponse = null;
Uri storageEndPoint = null;
string storageAccountKey = null;
CatchAggregatedExceptionFlattenAndRethrow(() => { storageKeysResponse = MediaServicesClient.GetStorageServiceKeysAsync(StorageAccountName).Result; });
storageAccountKey = storageKeysResponse.PrimaryKey;
StorageAccountGetResponse storageGetResponse = null;
CatchAggregatedExceptionFlattenAndRethrow(() => { storageGetResponse = MediaServicesClient.GetStorageServicePropertiesAsync(StorageAccountName).Result; });
if (storageGetResponse.StorageAccount.Properties != null && storageGetResponse.StorageAccount.Properties.Endpoints.Count > 0)
{
storageEndPoint = storageGetResponse.StorageAccount.Properties.Endpoints[0];
}
else
{
throw new Exception(string.Format(Resources.EndPointNotFoundForBlobStorage, Name));
}
AccountCreationResult result = null;
var request = new MediaServicesAccountCreateParameters()
{
AccountName = Name,
BlobStorageEndpointUri = storageEndPoint,
Region = Location,
StorageAccountKey = storageAccountKey,
StorageAccountName = StorageAccountName
};
CatchAggregatedExceptionFlattenAndRethrow(() => { result = new AccountCreationResult(MediaServicesClient.CreateNewAzureMediaServiceAsync(request).Result); });
WriteObject(result, false);
}
public void NewMediaServiceAccountShouldPassWithValidParameters()
{
// Setup
Mock <IMediaServicesClient> clientMock = new Mock <IMediaServicesClient>();
const string storageAccountName = "teststorage";
const string storageAccountKey = "key";
const string accountName = "testaccount";
const string region = "West US";
const string blobStorageEndpointUri = "http://awesome.blob.core.windows.net/";
MediaServicesAccountCreateParameters request = new MediaServicesAccountCreateParameters
{
AccountName = accountName,
BlobStorageEndpointUri = new Uri(blobStorageEndpointUri),
Region = region,
StorageAccountKey = storageAccountKey,
StorageAccountName = storageAccountName
};
clientMock.Setup(f => f.CreateNewAzureMediaServiceAsync(It.Is <MediaServicesAccountCreateParameters>(creationRequest => request.AccountName == accountName))).Returns(
Task.Factory.StartNew(() => new MediaServicesAccountCreateResponse
{
Account = new MediaServicesCreatedAccount {
AccountId = Guid.NewGuid().ToString(),
AccountName = request.AccountName,
SubscriptionId = Guid.NewGuid().ToString()
}
}));
clientMock.Setup(f => f.GetStorageServiceKeysAsync(storageAccountName)).Returns(
Task.Factory.StartNew(() => new StorageAccountGetKeysResponse
{
PrimaryKey = storageAccountKey,
SecondaryKey = storageAccountKey
}));
clientMock.Setup(f => f.GetStorageServicePropertiesAsync(storageAccountName)).Returns(Task.Factory.StartNew(() =>
{
StorageAccountGetResponse response = new StorageAccountGetResponse
{
StorageAccount = new StorageAccount
{
Properties = new StorageAccountProperties()
}
};
response.StorageAccount.Properties.Endpoints.Add(new Uri(blobStorageEndpointUri));
return(response);
}));
// Test
NewAzureMediaServiceCommand command = new NewAzureMediaServiceCommand
{
CommandRuntime = new MockCommandRuntime(),
Name = accountName,
Location = region,
StorageAccountName = storageAccountName,
MediaServicesClient = clientMock.Object,
};
command.ExecuteCmdlet();
Assert.AreEqual(1, ((MockCommandRuntime)command.CommandRuntime).OutputPipeline.Count);
AccountCreationResult accountCreationResult = (AccountCreationResult)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault();
Assert.IsNotNull(accountCreationResult);
Assert.AreEqual(accountName, accountCreationResult.Name);
}
private void CompareExpectedGetResult(StorageAccountGetResponse response)
{
StorageAccountModel result = response.StorageAccount;
Assert.Equal(result.Properties.AccountType, StorageAccountType.StandardLRS);
Assert.Equal(result.Properties.CreationTime, "Thu, 20 Aug 2015 16:08:53 GMT");
Assert.Equal(result.Properties.TenantAccountName, "705mystorageaccount1@2015-08-20T16:09:34.2006267Z");
Assert.Equal(result.Properties.State, StorageAccountState.Created);
Assert.Equal(result.Properties.PrimaryLocation, "DevFabric");
Assert.Equal(result.Properties.StatusOfPrimary, RegionStatus.Available);
result = response.StorageAccount;
Assert.Equal(result.Properties.AccountStatus, StorageAccountStatus.OutOfRetentionPeriod);
Assert.NotNull(result.Properties.DeletedTime);
Assert.Null(result.Properties.RecycledTime);
Assert.Equal(result.Properties.CurrentOperation, StorageAccountOperation.Delete);
Assert.Equal(result.Properties.PrimaryEndpoints.Count, 3);
Assert.NotNull(result.Properties.WacInternalState);
Assert.NotNull(result.Properties.AccountId);
Assert.NotNull(result.Properties.Permissions);
}
public void CanCreateMediaServicesAccountSuccessfully()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var mode = HttpMockServer.GetCurrentMode();
var managementClient = GetManagementClient();
var storageClient = GetStorageManagementClient();
var mediaClient = GetMediaServicesManagementClient();
var storageAccountName = TestUtilities.GenerateName();
var mediaAccountName = TestUtilities.GenerateName();
string location = ManagementTestUtilities.GetDefaultLocation(managementClient, "HighMemory");
Assert.DoesNotThrow(() =>
{
try
{
storageClient.StorageAccounts.Create(new StorageAccountCreateParameters
{
Name = storageAccountName,
AccountType = "Standard_LRS",
Location = location,
});
var storageResult = storageClient.StorageAccounts.Get(storageAccountName);
var blobEndpoint = storageResult.StorageAccount.Properties.Endpoints.First();
var keyResult = storageClient.StorageAccounts.GetKeys(storageAccountName);
StorageAccountGetResponse storageStatus = null;
int tries = 0;
do
{
TestUtilities.Wait(TimeSpan.FromSeconds(5));
storageStatus = storageClient.StorageAccounts.Get(storageAccountName);
++tries;
} while (storageStatus.StorageAccount.Properties.Status != StorageAccountStatus.Created &&
tries < 10);
mediaClient.Accounts.Create(new MediaServicesAccountCreateParameters
{
AccountName = mediaAccountName,
BlobStorageEndpointUri = blobEndpoint,
StorageAccountName = storageAccountName,
StorageAccountKey = keyResult.PrimaryKey,
Region = location
});
var mediaGetResult = mediaClient.Accounts.Get(mediaAccountName);
Assert.Equal(mediaGetResult.Account.AccountName, mediaAccountName);
Assert.Equal(mediaGetResult.Account.AccountRegion, location);
Assert.Equal(mediaGetResult.Account.StorageAccountName, storageAccountName);
mediaClient.Accounts.RegenerateKey(mediaAccountName, MediaServicesKeyType.Primary);
var mediaAccountList = mediaClient.Accounts.List();
var matchingMediaAccount =
mediaAccountList.First(
m => string.Equals(m.Name, mediaAccountName, StringComparison.Ordinal));
Assert.NotNull(matchingMediaAccount);
}
finally
{
TestUtilities.Wait(3000);
TestUtilities.IgnoreExceptions(() => mediaClient.Accounts.Delete(mediaAccountName));
TestUtilities.IgnoreExceptions(() => storageClient.StorageAccounts.Delete(storageAccountName));
}
});
}
}
private Task<StorageAccountGetResponse> CreateGetResponse(string serviceName)
{
Task<StorageAccountGetResponse> resultTask;
var data = accounts.FirstOrDefault(a => a.Name == serviceName);
if (data != null)
{
var storageServiceGetResponse = new StorageAccountGetResponse
{
StorageAccount = new StorageAccount
{
Name = data.Name,
Properties = new StorageAccountProperties
{
Endpoints =
{
new Uri(data.BlobEndpoint),
new Uri(data.QueueEndpoint),
new Uri(data.TableEndpoint)
}
}
}
};
resultTask = Tasks.FromResult(storageServiceGetResponse);
}
else
{
resultTask = Tasks.FromException<StorageAccountGetResponse>(ClientMocks.Make404Exception());
}
return resultTask;
}
