public async Task GetAllStorageAccounts() { //create two storage accounts string accountName1 = await CreateValidAccountNameAsync(namePrefix); string accountName2 = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName1, GetDefaultStorageAccountParameters())).Value; StorageAccount account2 = (await storageAccountContainer.CreateOrUpdateAsync(accountName2, GetDefaultStorageAccountParameters())).Value; //validate two storage accounts int count = 0; StorageAccount account3 = null; StorageAccount account4 = null; await foreach (StorageAccount account in storageAccountContainer.GetAllAsync()) { count++; if (account.Id.Name == accountName1) { account3 = account; } if (account.Id.Name == accountName2) { account4 = account; } } Assert.AreEqual(count, 2); VerifyAccountProperties(account3, true); VerifyAccountProperties(account4, true); }
public async Task CreateStorageAccountWithAccessTier() { //create storage account with accesstier hot string accountName1 = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(kind: Kind.BlobStorage); parameters.AccessTier = AccessTier.Hot; StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName1, parameters)).Value; //validate VerifyAccountProperties(account, false); Assert.AreEqual(AccessTier.Hot, account.Data.AccessTier); Assert.AreEqual(Kind.BlobStorage, account.Data.Kind); //create storage account with accesstier cool string accountName2 = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); parameters.AccessTier = AccessTier.Cool; account = (await storageAccountContainer.CreateOrUpdateAsync(accountName2, parameters)).Value; //validate VerifyAccountProperties(account, false); Assert.AreEqual(AccessTier.Cool, account.Data.AccessTier); Assert.AreEqual(Kind.BlobStorage, account.Data.Kind); }
public async Task StorageAccountRegenerateKey() { Sanitizer.AddJsonPathSanitizer("$.keys.[*].value"); //create storage account and get keys string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName, GetDefaultStorageAccountParameters())).Value; VerifyAccountProperties(account1, true); StorageAccountListKeysResult keys = await account1.GetKeysAsync(); Assert.NotNull(keys); StorageAccountKey key2 = keys.Keys.First( t => StringComparer.OrdinalIgnoreCase.Equals(t.KeyName, "key2")); Assert.NotNull(key2); //regenerate key and verify the key's change StorageAccountRegenerateKeyParameters keyParameters = new StorageAccountRegenerateKeyParameters("key2"); StorageAccountListKeysResult regenKeys = await account1.RegenerateKeyAsync(keyParameters); StorageAccountKey regenKey2 = regenKeys.Keys.First( t => StringComparer.OrdinalIgnoreCase.Equals(t.KeyName, "key2")); Assert.NotNull(regenKey2); //validate the key is different from origin one if (Mode != RecordedTestMode.Playback) { Assert.AreNotEqual(key2.Value, regenKey2.Value); } }
public async Task ListServiceSAS() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; string canonicalizedResourceParameter = "/blob/" + accountName + "/music"; ServiceSasParameters serviceSasParameters = new ServiceSasParameters(canonicalizedResource: canonicalizedResourceParameter) { Resource = "c", Permissions = "rdwlacup", Protocols = HttpProtocol.HttpsHttp, SharedAccessStartTime = Recording.UtcNow, SharedAccessExpiryTime = Recording.UtcNow.AddHours(1), KeyToSign = "key1" }; Response <ListServiceSasResponse> result = await account.GetServiceSASAsync(serviceSasParameters); ServiceSasParameters resultCredentials = ParseServiceSASToken(result.Value.ServiceSasToken, canonicalizedResourceParameter); Assert.AreEqual(serviceSasParameters.Resource, resultCredentials.Resource); Assert.AreEqual(serviceSasParameters.Permissions, resultCredentials.Permissions); Assert.AreEqual(serviceSasParameters.Protocols, resultCredentials.Protocols); Assert.NotNull(serviceSasParameters.SharedAccessStartTime); Assert.NotNull(serviceSasParameters.SharedAccessExpiryTime); }
public async Task createStorageAccountAndGetFileShareContainer() { ArmClient armClient = new ArmClient(new DefaultAzureCredential()); Subscription subscription = armClient.DefaultSubscription; string rgName = "myRgName"; Location location = Location.WestUS2; ResourceGroupCreateOrUpdateOperation operation = await subscription.GetResourceGroups().CreateOrUpdateAsync(rgName, new ResourceGroupData(location)); ResourceGroup resourceGroup = operation.Value; this.resourceGroup = resourceGroup; Sku sku = new Sku(SkuName.StandardGRS); Kind kind = Kind.Storage; string locationStr = "westus2"; StorageAccountCreateParameters parameters = new StorageAccountCreateParameters(sku, kind, locationStr); StorageAccountContainer accountContainer = resourceGroup.GetStorageAccounts(); string accountName = "myAccount"; StorageAccountCreateOperation accountCreateOperation = await accountContainer.CreateOrUpdateAsync(accountName, parameters); storageAccount = await accountCreateOperation.WaitForCompletionAsync(); #region Snippet:Managing_FileShares_GetFileService FileServiceContainer fileServiceContainer = storageAccount.GetFileServices(); FileService fileService = await fileServiceContainer.GetAsync("default"); #endregion this.fileService = fileService; }
public async Task CreateLargeFileShareOnStorageAccount() { //create storage account and enable large share string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); Sku sku = new Sku(SkuName.StandardLRS); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(sku: sku, kind: Kind.StorageV2); parameters.LargeFileSharesState = LargeFileSharesState.Enabled; StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; VerifyAccountProperties(account1, false); //create file share with share quota 5200, which is allowed in large file shares string fileShareName = Recording.GenerateAssetName("testfileshare"); FileService fileService = await account1.GetFileServices().GetAsync("default"); FileShareContainer shareContainer = fileService.GetFileShares(); FileShareData shareData = new FileShareData(); shareData.ShareQuota = 5200; FileShareCreateOperation fileShareCreateOperation = await shareContainer.CreateOrUpdateAsync(fileShareName, shareData); FileShare share = await fileShareCreateOperation.WaitForCompletionAsync(); Assert.AreEqual(share.Data.ShareQuota, shareData.ShareQuota); }
public async Task ListStorageAccountSAS() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; AccountSasParameters accountSasParameters = new AccountSasParameters(services: "b", resourceTypes: "sco", permissions: "rl", sharedAccessExpiryTime: Recording.UtcNow.AddHours(1)) { Protocols = HttpProtocol.HttpsHttp, SharedAccessStartTime = Recording.UtcNow, KeyToSign = "key1" }; Response <ListAccountSasResponse> result = await account.GetAccountSASAsync(accountSasParameters); AccountSasParameters resultCredentials = ParseAccountSASToken(result.Value.AccountSasToken); Assert.AreEqual(accountSasParameters.Services, resultCredentials.Services); Assert.AreEqual(accountSasParameters.ResourceTypes, resultCredentials.ResourceTypes); Assert.AreEqual(accountSasParameters.Permissions, resultCredentials.Permissions); Assert.AreEqual(accountSasParameters.Protocols, resultCredentials.Protocols); Assert.NotNull(accountSasParameters.SharedAccessStartTime); Assert.NotNull(accountSasParameters.SharedAccessExpiryTime); }
public async Task CreateDeleteStorageAccount() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName, GetDefaultStorageAccountParameters())).Value; Assert.AreEqual(accountName, account1.Id.Name); VerifyAccountProperties(account1, true); AssertStorageAccountEqual(account1, await account1.GetAsync()); //validate if created successfully StorageAccount account2 = await storageAccountContainer.GetAsync(accountName); VerifyAccountProperties(account2, true); AssertStorageAccountEqual(account1, account2); StorageAccount account3 = await storageAccountContainer.GetIfExistsAsync(accountName + "1"); Assert.IsNull(account3); Assert.IsTrue(await storageAccountContainer.CheckIfExistsAsync(accountName)); Assert.IsFalse(await storageAccountContainer.CheckIfExistsAsync(accountName + "1")); //delete storage account await account1.DeleteAsync(); //validate if deleted successfully Assert.IsFalse(await storageAccountContainer.CheckIfExistsAsync(accountName)); StorageAccount account4 = await storageAccountContainer.GetIfExistsAsync(accountName); Assert.IsNull(account4); }
public async Task StorageAccountRevokeUserDelegationKeys() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; //revoke user delegation keys await account.RevokeUserDelegationKeysAsync(); }
public async Task CreateStorageAccountAndGetQueueContainer() { _resourceGroup = await CreateResourceGroupAsync(); string accountName = await CreateValidAccountNameAsync("teststoragemgmt"); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); _storageAccount = (await storageAccountContainer.CreateOrUpdateAsync(accountName, GetDefaultStorageAccountParameters())).Value; _queueServiceContainer = _storageAccount.GetQueueServices(); _queueService = await _queueServiceContainer.GetAsync("default"); _storageQueueContainer = _queueService.GetStorageQueues(); }
public async Task CreateStorageAccountWithEncrpytion() { //create storage account with encryption settings string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(); parameters.Encryption = new Encryption(KeySource.MicrosoftStorage) { Services = new EncryptionServices { Blob = new EncryptionService { Enabled = true }, File = new EncryptionService { Enabled = true } } }; StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; VerifyAccountProperties(account, true); //verify encryption settings Assert.NotNull(account.Data.Encryption); Assert.NotNull(account.Data.Encryption.Services.Blob); Assert.True(account.Data.Encryption.Services.Blob.Enabled); Assert.NotNull(account.Data.Encryption.Services.Blob.LastEnabledTime); Assert.NotNull(account.Data.Encryption.Services.File); Assert.NotNull(account.Data.Encryption.Services.File.Enabled); Assert.NotNull(account.Data.Encryption.Services.File.LastEnabledTime); if (null != account.Data.Encryption.Services.Table) { if (account.Data.Encryption.Services.Table.Enabled.HasValue) { Assert.False(account.Data.Encryption.Services.Table.LastEnabledTime.HasValue); } } if (null != account.Data.Encryption.Services.Queue) { if (account.Data.Encryption.Services.Queue.Enabled.HasValue) { Assert.False(account.Data.Encryption.Services.Queue.LastEnabledTime.HasValue); } } }
public async Task GetAllPrivateLinkResources() { //create resource group and storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(sku: new Sku(SkuName.StandardLRS), kind: Kind.StorageV2); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; //get all private link resources Response <IReadOnlyList <PrivateLinkResource> > privateLinkResources = await account.GetPrivateLinkResourcesAsync(); Assert.NotNull(privateLinkResources.Value); }
public async Task CreateOrUpdate() { #region Snippet:Managing_StorageAccounts_CreateStorageAccount //first we need to define the StorageAccountCreateParameters Sku sku = new Sku(SkuName.StandardGRS); Kind kind = Kind.Storage; string location = "westus2"; StorageAccountCreateParameters parameters = new StorageAccountCreateParameters(sku, kind, location); //now we can create a storage account with defined account name and parameters StorageAccountContainer accountContainer = resourceGroup.GetStorageAccounts(); string accountName = "myAccount"; StorageAccountCreateOperation accountCreateOperation = await accountContainer.CreateOrUpdateAsync(accountName, parameters); StorageAccount storageAccount = accountCreateOperation.Value; #endregion }
public async Task ListStorageAccountAvailableLocations() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; //get available locations IEnumerable <Location> locationList = await account.GetAvailableLocationsAsync(); Assert.NotNull(locationList); }
public async Task GetAllPrivateEndPointConnections() { //create resource group and storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(sku: new Sku(SkuName.StandardLRS), kind: Kind.StorageV2); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; PrivateEndpointConnectionContainer privateEndpointConnectionContainer = account.GetPrivateEndpointConnections(); //get all private endpoint connections List <PrivateEndpointConnection> privateEndpointConnections = await privateEndpointConnectionContainer.GetAllAsync().ToEnumerableAsync(); Assert.NotNull(privateEndpointConnections); }
public async Task CreateStorageAccountWithEnableNfsV3() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(kind: Kind.StorageV2); parameters.EnableNfsV3 = false; StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; //validate VerifyAccountProperties(account, false); Assert.NotNull(account.Data.PrimaryEndpoints.Web); Assert.AreEqual(Kind.StorageV2, account.Data.Kind); Assert.False(account.Data.EnableNfsV3); }
public async Task CreateUpdateGetEncryptionScope() { //create resource group and storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(kind: Kind.StorageV2); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; EncryptionScopeContainer encryptionScopeContainer = account.GetEncryptionScopes(); //create encryption scope EncryptionScopeData parameter = new EncryptionScopeData() { Source = EncryptionScopeSource.MicrosoftStorage, State = EncryptionScopeState.Enabled, RequireInfrastructureEncryption = false }; EncryptionScope encryptionScope = (await encryptionScopeContainer.CreateOrUpdateAsync("scope", parameter)).Value; Assert.AreEqual("scope", encryptionScope.Id.Name); Assert.AreEqual(EncryptionScopeState.Enabled, encryptionScope.Data.State); Assert.AreEqual(EncryptionScopeSource.MicrosoftStorage, encryptionScope.Data.Source); //patch encryption scope encryptionScope.Data.State = EncryptionScopeState.Disabled; encryptionScope = await encryptionScope.PatchAsync(encryptionScope.Data); Assert.AreEqual(encryptionScope.Data.State, EncryptionScopeState.Disabled); //get all encryption scopes List <EncryptionScope> encryptionScopes = await encryptionScopeContainer.GetAllAsync().ToEnumerableAsync(); encryptionScope = encryptionScopes.First(); Assert.AreEqual("scope", encryptionScope.Id.Name); Assert.AreEqual(EncryptionScopeState.Disabled, encryptionScope.Data.State); Assert.AreEqual(EncryptionScopeSource.MicrosoftStorage, encryptionScope.Data.Source); }
public async Task CreateStorageAccountWithFileStorage() { //create storage account with file storage string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); Sku sku = new Sku(SkuName.PremiumLRS); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(sku: sku, kind: Kind.FileStorage); StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; //validate VerifyAccountProperties(account1, false); Assert.AreEqual(Kind.FileStorage, account1.Data.Kind); Assert.AreEqual(SkuName.PremiumLRS, account1.Data.Sku.Name); //this storage account should only have endpoints on file Assert.IsNull(account1.Data.PrimaryEndpoints.Blob); Assert.IsNull(account1.Data.PrimaryEndpoints.Dfs); Assert.NotNull(account1.Data.PrimaryEndpoints.File); Assert.IsNull(account1.Data.PrimaryEndpoints.Table); Assert.IsNull(account1.Data.PrimaryEndpoints.Queue); }
public async Task AddRemoveTag() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; //add tag to this storage account account = await account.AddTagAsync("key", "value"); //verify the tag is added successfully Assert.AreEqual(account.Data.Tags.Count, 1); //remove tag account = await account.RemoveTagAsync("key"); //verify the tag is removed successfully Assert.AreEqual(account.Data.Tags.Count, 0); }
public async Task GetStorageAccountLastSyncTime() { //create storage account string accountName1 = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); Sku sku = new Sku(SkuName.StandardRagrs); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(sku: sku, kind: Kind.StorageV2); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName1, parameters)).Value; Assert.AreEqual(SkuName.StandardRagrs, account.Data.Sku.Name); Assert.Null(account.Data.GeoReplicationStats); //expand account = await account.GetAsync(StorageAccountExpand.GeoReplicationStats); Assert.NotNull(account.Data.GeoReplicationStats); Assert.NotNull(account.Data.GeoReplicationStats.Status); Assert.NotNull(account.Data.GeoReplicationStats.LastSyncTime); Assert.NotNull(account.Data.GeoReplicationStats.CanFailover); }
public async Task SetGetDeleteManagementPolicy() { //create resource group and storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(kind: Kind.StorageV2); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; ManagementPolicyContainer managementPolicyContainer = account.GetManagementPolicies(); //Enable LAT BlobServiceContainer blobServiceContainer = account.GetBlobServices(); BlobService blobService = await blobServiceContainer.GetAsync("Default"); blobService.Data.LastAccessTimeTrackingPolicy = new LastAccessTimeTrackingPolicy(true); _ = await blobService.SetServicePropertiesAsync(blobService.Data); // create ManagementPolicy to set, the type of policy rule should always be Lifecycle List <ManagementPolicyRule> rules = new List <ManagementPolicyRule>(); ManagementPolicyAction action = new ManagementPolicyAction() { BaseBlob = new ManagementPolicyBaseBlob() { Delete = new DateAfterModification(1000, null) } }; ManagementPolicyDefinition definition1 = new ManagementPolicyDefinition(action) { Filters = new ManagementPolicyFilter(blobTypes: new List <string>() { "blockBlob", "appendBlob" }), }; ManagementPolicyRule rule1 = new ManagementPolicyRule("rule1", "Lifecycle", definition1); rules.Add(rule1); ManagementPolicyDefinition definition2 = new ManagementPolicyDefinition(action) { Filters = new ManagementPolicyFilter(blobTypes: new List <string>() { "appendBlob" }), }; ManagementPolicyRule rule2 = new ManagementPolicyRule("rule2", "Lifecycle", definition2); rules.Add(rule2); ManagementPolicyDefinition definition3 = new ManagementPolicyDefinition(action) { Filters = new ManagementPolicyFilter(blobTypes: new List <string>() { "blockBlob" }), }; ManagementPolicyRule rule3 = new ManagementPolicyRule("rule3", "Lifecycle", definition3); rules.Add(rule3); ManagementPolicyData parameter = new ManagementPolicyData() { Policy = new ManagementPolicySchema(rules) }; //set management policy, the policy name should always be default ManagementPolicy managementPolicy = (await managementPolicyContainer.CreateOrUpdateAsync("default", parameter)).Value; Assert.NotNull(managementPolicy); Assert.AreEqual(managementPolicy.Data.Policy.Rules.Count, 3); //delete namagement policy await managementPolicy.DeleteAsync(); }
public async Task CreateUpdataNetworkRule() { //create storage account with network rule string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(); parameters.NetworkRuleSet = new NetworkRuleSet(defaultAction: DefaultAction.Deny) { Bypass = @"Logging, AzureServices", IpRules = { new IPRule(iPAddressOrRange: "23.45.67.89") } }; StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; VerifyAccountProperties(account1, false); //verify network rule StorageAccountData accountData = account1.Data; Assert.NotNull(accountData.NetworkRuleSet); Assert.AreEqual(@"Logging, AzureServices", accountData.NetworkRuleSet.Bypass.ToString()); Assert.AreEqual(DefaultAction.Deny, accountData.NetworkRuleSet.DefaultAction); Assert.IsEmpty(accountData.NetworkRuleSet.VirtualNetworkRules); Assert.NotNull(accountData.NetworkRuleSet.IpRules); Assert.IsNotEmpty(accountData.NetworkRuleSet.IpRules); Assert.AreEqual("23.45.67.89", accountData.NetworkRuleSet.IpRules[0].IPAddressOrRange); Assert.AreEqual(DefaultAction.Allow.ToString(), accountData.NetworkRuleSet.IpRules[0].Action); //update network rule StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters() { NetworkRuleSet = new NetworkRuleSet(defaultAction: DefaultAction.Deny) { Bypass = @"Logging, Metrics", IpRules = { new IPRule(iPAddressOrRange: "23.45.67.90"), new IPRule(iPAddressOrRange: "23.45.67.91") } } }; StorageAccount account2 = await account1.UpdateAsync(updateParameters); //verify updated network rule accountData = account2.Data; Assert.NotNull(accountData.NetworkRuleSet); Assert.AreEqual(@"Logging, Metrics", accountData.NetworkRuleSet.Bypass.ToString()); Assert.AreEqual(DefaultAction.Deny, accountData.NetworkRuleSet.DefaultAction); Assert.IsEmpty(accountData.NetworkRuleSet.VirtualNetworkRules); Assert.NotNull(accountData.NetworkRuleSet.IpRules); Assert.IsNotEmpty(accountData.NetworkRuleSet.IpRules); Assert.AreEqual("23.45.67.90", accountData.NetworkRuleSet.IpRules[0].IPAddressOrRange); Assert.AreEqual(DefaultAction.Allow.ToString(), accountData.NetworkRuleSet.IpRules[0].Action); Assert.AreEqual("23.45.67.91", accountData.NetworkRuleSet.IpRules[1].IPAddressOrRange); Assert.AreEqual(DefaultAction.Allow.ToString(), accountData.NetworkRuleSet.IpRules[1].Action); //update network rule to allow updateParameters = new StorageAccountUpdateParameters() { NetworkRuleSet = new NetworkRuleSet(defaultAction: DefaultAction.Allow) }; StorageAccount account3 = await account2.UpdateAsync(updateParameters); //verify updated network rule accountData = account3.Data; Assert.NotNull(accountData.NetworkRuleSet); Assert.AreEqual(@"Logging, Metrics", accountData.NetworkRuleSet.Bypass.ToString()); Assert.AreEqual(DefaultAction.Allow, accountData.NetworkRuleSet.DefaultAction); }
public async Task EventCreateGetUpdateDelete() { var location = await GetLocation(); var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); ResourceGroup resourceGroup = (await ArmClient.DefaultSubscription.GetResourceGroups().CreateOrUpdateAsync(resourceGroupName, new ResourceGroupData(location))).Value; // Prepare Storage Account var accountName = Recording.GenerateAssetName("sdktestaccount"); var storageAccountCreateParameters = new StorageAccountCreateParameters( new ResourceManager.Storage.Models.Sku("Standard_LRS"), Kind.StorageV2, "eastus2" ) { AccessTier = AccessTier.Hot }; StorageAccountContainer storageAccountContainer = resourceGroup.GetStorageAccounts(); await storageAccountContainer.CreateOrUpdateAsync(accountName, storageAccountCreateParameters); // Create NameSpace var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); // Create Eventhub var eventhubName = Recording.GenerateAssetName(Helper.EventHubPrefix); var createEventhubResponse = await EventHubsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventhubName, new Eventhub() { MessageRetentionInDays = 4, PartitionCount = 4, Status = EntityStatus.Active, CaptureDescription = new CaptureDescription() { Enabled = true, Encoding = EncodingCaptureDescription.Avro, IntervalInSeconds = 120, SizeLimitInBytes = 10485763, Destination = new Destination() { Name = "EventHubArchive.AzureBlockBlob", BlobContainer = "container", ArchiveNameFormat = "{Namespace}/{EventHub}/{PartitionId}/{Year}/{Month}/{Day}/{Hour}/{Minute}/{Second}", StorageAccountResourceId = "/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroupName + "/providers/Microsoft.Storage/storageAccounts/" + accountName }, SkipEmptyArchives = true } }); Assert.NotNull(createEventhubResponse); Assert.AreEqual(createEventhubResponse.Value.Name, eventhubName); Assert.True(createEventhubResponse.Value.CaptureDescription.SkipEmptyArchives); //Get the created EventHub var getEventHubResponse = await EventHubsOperations.GetAsync(resourceGroupName, namespaceName, eventhubName); Assert.NotNull(getEventHubResponse.Value); Assert.AreEqual(EntityStatus.Active, getEventHubResponse.Value.Status); Assert.AreEqual(getEventHubResponse.Value.Name, eventhubName); //Get all Event Hubs for a given NameSpace var getListEventHubResponse = EventHubsOperations.ListByNamespaceAsync(resourceGroupName, namespaceName); var list = await getListEventHubResponse.ToEnumerableAsync(); Assert.NotNull(getListEventHubResponse); Assert.True(list.Count() >= 1); // Update the EventHub getEventHubResponse.Value.CaptureDescription.IntervalInSeconds = 130; getEventHubResponse.Value.CaptureDescription.SizeLimitInBytes = 10485900; getEventHubResponse.Value.MessageRetentionInDays = 5; //TODO time exception var UpdateEventHubResponse = (await EventHubsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventhubName, getEventHubResponse.Value)).Value; Assert.NotNull(UpdateEventHubResponse); // Get the updated EventHub and verify the properties var getEventResponse = await EventHubsOperations.GetAsync(resourceGroupName, namespaceName, eventhubName); Assert.NotNull(getEventResponse); Assert.AreEqual(EntityStatus.Active, getEventResponse.Value.Status); Assert.AreEqual(5, getEventResponse.Value.MessageRetentionInDays); // Delete the Evnet Hub var deleteEventResponse = await EventHubsOperations.DeleteAsync(resourceGroupName, namespaceName, eventhubName); // Delete namespace and check for the NotFound exception var deleteNamespaceResponse = await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroupName, namespaceName)); }
public async Task UpdateStorageAccount() { //create storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName, GetDefaultStorageAccountParameters())).Value; VerifyAccountProperties(account1, true); //update sku StorageAccountUpdateParameters parameters = new StorageAccountUpdateParameters() { Sku = new Sku(SkuName.StandardLRS), }; account1 = await account1.UpdateAsync(parameters); Assert.AreEqual(account1.Data.Sku.Name, SkuName.StandardLRS); // validate StorageAccount account2 = await storageAccountContainer.GetAsync(accountName); Assert.AreEqual(account2.Data.Sku.Name, SkuName.StandardLRS); //update tags parameters.Tags.Clear(); parameters.Tags.Add("key3", "value3"); parameters.Tags.Add("key4", "value4"); parameters.Tags.Add("key5", "value5"); account1 = await account1.UpdateAsync(parameters); Assert.AreEqual(account1.Data.Tags.Count, parameters.Tags.Count); //validate account2 = await storageAccountContainer.GetAsync(accountName); Assert.AreEqual(account2.Data.Tags.Count, parameters.Tags.Count); //update encryption parameters.Encryption = new Encryption(KeySource.MicrosoftStorage) { Services = new EncryptionServices { Blob = new EncryptionService { Enabled = true }, File = new EncryptionService { Enabled = true } } }; account1 = await account1.UpdateAsync(parameters); Assert.NotNull(account1.Data.Encryption); //validate account2 = await storageAccountContainer.GetAsync(accountName); Assert.NotNull(account2.Data.Encryption); Assert.NotNull(account2.Data.Encryption.Services.Blob); Assert.True(account2.Data.Encryption.Services.Blob.Enabled); Assert.NotNull(account2.Data.Encryption.Services.Blob.LastEnabledTime); Assert.NotNull(account2.Data.Encryption.Services.File); Assert.True(account2.Data.Encryption.Services.File.Enabled); Assert.NotNull(account2.Data.Encryption.Services.File.LastEnabledTime); //update http traffic only and validate parameters = new StorageAccountUpdateParameters() { EnableHttpsTrafficOnly = false }; account1 = await account1.UpdateAsync(parameters); Assert.AreEqual(account1.Data.EnableHttpsTrafficOnly, false); account2 = await storageAccountContainer.GetAsync(accountName); Assert.AreEqual(account2.Data.EnableHttpsTrafficOnly, false); parameters = new StorageAccountUpdateParameters() { EnableHttpsTrafficOnly = true }; account1 = await account1.UpdateAsync(parameters); Assert.AreEqual(account1.Data.EnableHttpsTrafficOnly, true); account2 = await storageAccountContainer.GetAsync(accountName); Assert.AreEqual(account2.Data.EnableHttpsTrafficOnly, true); }
public async Task CreateUpdateGetDeleteBlobInventoryPolicy() { //create resource group and storage account string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccountCreateParameters parameters = GetDefaultStorageAccountParameters(kind: Kind.StorageV2); StorageAccount account = (await storageAccountContainer.CreateOrUpdateAsync(accountName, parameters)).Value; BlobInventoryPolicyContainer blobInventoryPolicyContainer = account.GetBlobInventoryPolicies(); //create a blob container string containerName = Recording.GenerateAssetName("testblob"); BlobContainerData data = new BlobContainerData(); BlobServiceContainer blobServiceContainer = account.GetBlobServices(); BlobService blobService = await blobServiceContainer.GetAsync("default"); BlobContainerContainer blobContainerContainer = blobService.GetBlobContainers(); BlobContainer container = (await blobContainerContainer.CreateOrUpdateAsync(containerName, new BlobContainerData())).Value; //prepare schema fields string[] BlobSchemaField = new string[] { "Name", "Creation-Time", "Last-Modified", "Content-Length", "Content-MD5", "BlobType", "AccessTier", "AccessTierChangeTime", "Snapshot", "VersionId", "IsCurrentVersion", "Metadata", "LastAccessTime" }; string[] ContainerSchemaField = new string[] { "Name", "Last-Modified", "Metadata", "LeaseStatus", "LeaseState", "LeaseDuration", "PublicAccess", "HasImmutabilityPolicy", "HasLegalHold" }; List <string> blobSchemaFields1 = new List <string>(BlobSchemaField); List <string> blobSchemaFields2 = new List <string>(); blobSchemaFields2.Add("Name"); List <string> containerSchemaFields1 = new List <string>(ContainerSchemaField); List <string> containerSchemaFields2 = new List <string>(); containerSchemaFields2.Add("Name"); // prepare policy objects,the type of policy rule should always be Inventory List <BlobInventoryPolicyRule> ruleList = new List <BlobInventoryPolicyRule>(); BlobInventoryPolicyRule rule1 = new BlobInventoryPolicyRule(true, "rule1", containerName, new BlobInventoryPolicyDefinition( filters: new BlobInventoryPolicyFilter( blobTypes: new List <string>(new string[] { "blockBlob" }), prefixMatch: new List <string>(new string[] { "prefix1", "prefix2" }), includeBlobVersions: true, includeSnapshots: true), format: Format.Csv, schedule: Schedule.Weekly, objectType: ObjectType.Blob, schemaFields: blobSchemaFields1)); BlobInventoryPolicyRule rule2 = new BlobInventoryPolicyRule(true, "rule2", containerName, new BlobInventoryPolicyDefinition( format: Format.Csv, schedule: Schedule.Daily, objectType: ObjectType.Container, schemaFields: containerSchemaFields1)); BlobInventoryPolicyRule rule3 = new BlobInventoryPolicyRule(true, "rule3", containerName, new BlobInventoryPolicyDefinition( format: Format.Parquet, schedule: Schedule.Weekly, objectType: ObjectType.Container, schemaFields: containerSchemaFields2)); ruleList.Add(rule1); ruleList.Add(rule2); BlobInventoryPolicySchema policy = new BlobInventoryPolicySchema(true, "Inventory", ruleList); BlobInventoryPolicyData parameter = new BlobInventoryPolicyData() { Policy = policy }; //create and get policy, the name of blob inventory policy should always be default BlobInventoryPolicy blobInventoryPolicy = (await blobInventoryPolicyContainer.CreateOrUpdateAsync("default", parameter)).Value; blobInventoryPolicy = await blobInventoryPolicyContainer.GetAsync("default"); Assert.AreEqual(blobInventoryPolicy.Data.Policy.Rules.Count, 2); //update policy ruleList.Add(rule3); BlobInventoryPolicySchema policy2 = new BlobInventoryPolicySchema(true, "Inventory", ruleList); BlobInventoryPolicyData parameter2 = new BlobInventoryPolicyData() { Policy = policy2 }; blobInventoryPolicy = (await blobInventoryPolicyContainer.CreateOrUpdateAsync("default", parameter2)).Value; Assert.AreEqual(blobInventoryPolicy.Data.Policy.Rules.Count, 3); //delete policy await blobInventoryPolicy.DeleteAsync(); }