internal async Task GetAzureContainerStoredAccessPolicyAsync(long taskId, IStorageBlobManagement localChannel, string containerName, string policyName) { //Get container instance, Get existing permissions CloudBlobContainer container_Track1 = Channel.GetContainerReference(containerName); BlobContainerClient container = AzureStorageContainer.GetTrack2BlobContainerClient(container_Track1, Channel.StorageContext, ClientOptions); BlobContainerAccessPolicy accessPolicy = (await container.GetAccessPolicyAsync(BlobRequestConditions, cancellationToken: CmdletCancellationToken).ConfigureAwait(false)).Value; IEnumerable <BlobSignedIdentifier> signedIdentifiers = accessPolicy.SignedIdentifiers; if (!String.IsNullOrEmpty(policyName)) { BlobSignedIdentifier signedIdentifier = null; foreach (BlobSignedIdentifier identifier in signedIdentifiers) { if (identifier.Id == policyName) { signedIdentifier = identifier; } } if (signedIdentifier == null) { throw new ResourceNotFoundException(String.Format(CultureInfo.CurrentCulture, Resources.PolicyNotFound, policyName)); } else { OutputStream.WriteObject(taskId, AccessPolicyHelper.ConstructPolicyOutputPSObject <BlobSignedIdentifier>(signedIdentifier)); } } else { foreach (BlobSignedIdentifier identifier in signedIdentifiers) { OutputStream.WriteObject(taskId, AccessPolicyHelper.ConstructPolicyOutputPSObject <BlobSignedIdentifier>(identifier)); } } }
/// <summary> /// create a new azure container /// </summary> /// <param name="name">container name</param> internal AzureStorageContainer CreateAzureContainer(string name, BlobContainerPublicAccessType accesslevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobRequestOptions requestOptions = RequestOptions; AccessCondition accessCondition = null; CloudBlobContainer container = Channel.GetContainerReference(name); bool created = Channel.CreateContainerIfNotExists(container, requestOptions, OperationContext); if (!created) { throw new ResourceAlreadyExistException(String.Format(Resources.ContainerAlreadyExists, name)); } BlobContainerPermissions permissions = new BlobContainerPermissions(); permissions.PublicAccess = accessLevel; if (accessLevel == BlobContainerPublicAccessType.Container || accessLevel == BlobContainerPublicAccessType.Blob) { Channel.SetContainerPermissions(container, permissions, accessCondition, requestOptions, OperationContext); } else { permissions = Channel.GetContainerPermissions(container, accessCondition, requestOptions, OperationContext); } AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); return(azureContainer); }
public void SetContainerAclSucessfullyTest() { AddTestContainers(); command.PassThru = true; string name = "test"; string accessLevel = StorageNouns.ContainerAclOff; ((MockCommandRuntime)command.CommandRuntime).ResetPipelines(); command.SetContainerAcl(name, accessLevel); AzureStorageContainer container = (AzureStorageContainer)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault(); Assert.AreEqual(BlobContainerPublicAccessType.Off, container.PublicAccess); ((MockCommandRuntime)command.CommandRuntime).ResetPipelines(); name = "publicoff"; accessLevel = StorageNouns.ContainerAclBlob; command.SetContainerAcl(name, accessLevel); container = (AzureStorageContainer)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault(); Assert.AreEqual(BlobContainerPublicAccessType.Blob, container.PublicAccess); ((MockCommandRuntime)command.CommandRuntime).ResetPipelines(); name = "publicblob"; accessLevel = StorageNouns.ContainerAclContainer; command.SetContainerAcl(name, accessLevel); container = (AzureStorageContainer)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault(); Assert.AreEqual(BlobContainerPublicAccessType.Container, container.PublicAccess); ((MockCommandRuntime)command.CommandRuntime).ResetPipelines(); name = "publiccontainer"; accessLevel = StorageNouns.ContainerAclOff; command.SetContainerAcl(name, accessLevel); container = (AzureStorageContainer)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault(); Assert.AreEqual(BlobContainerPublicAccessType.Off, container.PublicAccess); }
/// <summary> /// get blob content /// </summary> /// <param name="container">source container object</param> /// <param name="blobName">source blob name</param> /// <param name="fileName">destination file name</param> /// <returns>the downloaded AzureStorageBlob object</returns> internal void GetBlobContent(CloudBlobContainer container, string blobName, string fileName) { if (!NameUtil.IsValidBlobName(blobName)) { throw new ArgumentException(String.Format(Resources.InvalidBlobName, blobName)); } // Don't need get File full path here, since will get file full path in GetBlobContent() with blob object. ValidatePipelineCloudBlobContainer(container); if (UseTrack2Sdk()) { BlobContainerClient track2container = AzureStorageContainer.GetTrack2BlobContainerClient(container, Channel.StorageContext, ClientOptions); BlobBaseClient blobClient = track2container.GetBlobBaseClient(blobName); GetBlobContent(blobClient, fileName, true); } else { AccessCondition accessCondition = null; BlobRequestOptions requestOptions = RequestOptions; CloudBlob blob = GetBlobReferenceFromServerWithContainer(Channel, container, blobName, accessCondition, requestOptions, OperationContext); GetBlobContent(blob, fileName, true); } }
public async Task <bool> DeleteContainer(AzureStorageContainer container) { var containerRef = blobClient.GetContainerReference(container.Name); var opResult = await containerRef.DeleteIfExistsAsync(); return(opResult); }
public async Task <BlobContainerPublicAccessType> GetAccessLevel(AzureStorageContainer container) { var containerRef = blobClient.GetContainerReference(container.Name); var perms = await containerRef.GetPermissionsAsync(); return(perms.PublicAccess); }
/// <summary> /// Pack CloudBlobContainer and it's permission to AzureStorageContainer object /// </summary> /// <param name="containerList">An enumerable collection of CloudBlobContainer</param> /// <returns>An enumerable collection of AzureStorageContainer</returns> internal IEnumerable <AzureStorageContainer> PackCloudBlobContainerWithAcl(IEnumerable <CloudBlobContainer> containerList) { if (null == containerList) { yield break; } BlobRequestOptions requestOptions = null; AccessCondition accessCondition = null; foreach (CloudBlobContainer container in containerList) { BlobContainerPermissions permissions = null; try { permissions = Channel.GetContainerPermissions(container, accessCondition, requestOptions, OperationContext); } catch (Exception e) { //Log the error message and continue the process WriteVerboseWithTimestamp(String.Format(Resources.GetContainerPermissionException, container.Name, e.Message)); } AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); yield return(azureContainer); } }
/// <summary> /// get blob content /// </summary> /// <param name="container">source container object</param> /// <param name="blobName">source blob name</param> /// <param name="fileName">destination file name</param> /// <returns>the downloaded AzureStorageBlob object</returns> internal void GetBlobContent(CloudBlobContainer container, string blobName, string fileName) { if (!NameUtil.IsValidBlobName(blobName)) { throw new ArgumentException(String.Format(Resources.InvalidBlobName, blobName)); } string filePath = GetFullReceiveFilePath(fileName, blobName, null); ValidatePipelineCloudBlobContainer(container); if (UseTrack2SDK()) { BlobContainerClient track2container = AzureStorageContainer.GetTrack2BlobContainerClient(container, Channel.StorageContext, ClientOptions); BlobBaseClient blobClient = track2container.GetBlobBaseClient(blobName); GetBlobContent(blobClient, filePath, true); } else { AccessCondition accessCondition = null; BlobRequestOptions requestOptions = RequestOptions; CloudBlob blob = GetBlobReferenceFromServerWithContainer(Channel, container, blobName, accessCondition, requestOptions, OperationContext); GetBlobContent(blob, filePath, true); } }
/// <summary> /// set the access level of specified container /// </summary> /// <param name="name">container name</param> /// <param name="accessLevel">access level in ("off", "blob", "container")</param> internal void SetContainerAcl(string name, BlobContainerPublicAccessType accessLevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobContainerPermissions permissions = new BlobContainerPermissions(); permissions.PublicAccess = accessLevel; BlobRequestOptions requestOptions = RequestOptions; AccessCondition accessCondition = null; CloudBlobContainer container = Channel.GetContainerReference(name); if (!Channel.DoesContainerExist(container, requestOptions, OperationContext)) { throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name)); } Channel.SetContainerPermissions(container, permissions, accessCondition, requestOptions, OperationContext); AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); if (PassThru) { WriteObjectWithStorageContext(azureContainer); } }
public async Task <List <AzureStorageContainer> > GetContainers() { var list = new List <AzureStorageContainer>(); var prefix = string.Empty; var continuationToken = new BlobContinuationToken(); var requestOptions = new BlobRequestOptions(); var cancelToken = new CancellationToken(); var opContext = new OperationContext(); var operationOutcome = await blobClient.ListContainersSegmentedAsync(prefix, ContainerListingDetails.All, 1000, continuationToken, requestOptions, opContext, cancelToken); foreach (var item in operationOutcome.Results) { var container = new AzureStorageContainer(); container.Name = item.Name; var accessLevel = await GetAccessLevel(container); container.AccessLevel = new ContainerAccessLevel() { Code = accessLevel }; list.Add(container); } return(list); }
public void ExcuteCommandNewContainerTest() { string name = "containername"; command.Name = name; command.ExecuteCmdlet(); AzureStorageContainer container = (AzureStorageContainer)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault(); Assert.AreEqual(name, container.Name); }
public async Task ChangeAccessLevel(AzureStorageContainer container) { var containerRef = blobClient.GetContainerReference(container.Name); var perms = await containerRef.GetPermissionsAsync(); perms.PublicAccess = container.AccessLevel.Code; await containerRef.SetPermissionsAsync(perms); }
/// <summary> /// Write ICloudBlob to output using specified service channel /// </summary> /// <param name="blob">The output ICloudBlob object</param> /// <param name="channel">IStorageBlobManagement channel object</param> internal void WriteCloudContainerObject(long taskId, IStorageBlobManagement channel, CloudBlobContainer container, BlobContainerPermissions permissions, BlobContinuationToken continuationToken = null) { AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); azureContainer.Context = channel.StorageContext; azureContainer.ContinuationToken = continuationToken; OutputStream.WriteObject(taskId, azureContainer); }
private BlobBaseClient GetDestBlob(IStorageBlobManagement destChannel, string destContainerName, string destBlobName, global::Azure.Storage.Blobs.Models.BlobType?blobType) { NameUtil.ValidateContainerName(destContainerName); NameUtil.ValidateBlobName(destBlobName); BlobContainerClient container = AzureStorageContainer.GetTrack2BlobContainerClient(destChannel.GetContainerReference(destContainerName), destChannel.StorageContext, ClientOptions); BlobBaseClient destBlob = Util.GetTrack2BlobClient(container, destBlobName, destChannel.StorageContext, null, null, null, ClientOptions, blobType is null ? global::Azure.Storage.Blobs.Models.BlobType.Block : blobType.Value); return(destBlob); }
public void ExcuteCommandNewContainerTest() { string name = "containername"; command.Name = name; RunAsyncCommand(() => command.ExecuteCmdlet()); AzureStorageContainer container = (AzureStorageContainer)MockCmdRunTime.OutputPipeline.FirstOrDefault(); Assert.AreEqual(name, container.Name); }
/// <summary> /// remove azure blob /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">blob name</param> /// <returns>true if the blob is removed successfully, false if user cancel the remove operation</returns> internal async Task RemoveAzureBlob(long taskId, IStorageBlobManagement localChannel, CloudBlobContainer container, string blobName) { if (!NameUtil.IsValidBlobName(blobName)) { throw new ArgumentException(String.Format(Resources.InvalidBlobName, blobName)); } ValidatePipelineCloudBlobContainer(container); if (!UseTrack2Sdk()) { AccessCondition accessCondition = null; BlobRequestOptions requestOptions = null; CloudBlob blob = null; try { blob = await localChannel.GetBlobReferenceFromServerAsync(container, blobName, this.SnapshotTime, accessCondition, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false); } catch (InvalidOperationException) { blob = null; } if (null == blob && container.ServiceClient.Credentials.IsSharedKey) { throw new ResourceNotFoundException(String.Format(Resources.BlobNotFound, blobName, container.Name)); } else { //Construct the blob as CloudBlockBlob no matter what's the real blob type //We can't get the blob type if Credentials only have the delete permission and don't have read permission. blob = container.GetBlockBlobReference(blobName, this.SnapshotTime); } await RemoveAzureBlob(taskId, localChannel, blob, true).ConfigureAwait(false); } else { if (this.VersionId != null & this.SnapshotTime != null) { throw new ArgumentException("Can't input VersionId and SnapshotTime, since a blob can't have both."); } BlobContainerClient track2container = AzureStorageContainer.GetTrack2BlobContainerClient(container, localChannel.StorageContext, ClientOptions); BlobBaseClient blobClient = Util.GetTrack2BlobClient(track2container, blobName, localChannel.StorageContext, this.VersionId, null, this.SnapshotTime is null? null : this.SnapshotTime.Value.ToString("o"), ClientOptions); // Skip check blob existance, as Server will report error is necessary await RemoveAzureBlobTrack2(taskId, localChannel, blobClient, true).ConfigureAwait(false); } }
public void ExecuteCommandSetContainerAclTest() { AddTestContainers(); command.Name = "publicblob"; command.Permission = "container"; command.PassThru = true; command.ExecuteCmdlet(); AzureStorageContainer container = (AzureStorageContainer)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault(); Assert.AreEqual(BlobContainerPublicAccessType.Container, container.PublicAccess); }
public void ExecuteCommandSetContainerAclTest() { AddTestContainers(); command.Name = "publicblob"; command.Permission = BlobContainerPublicAccessType.Container; command.PassThru = true; RunAsyncCommand(() => command.ExecuteCmdlet()); AzureStorageContainer container = (AzureStorageContainer)MockCmdRunTime.OutputPipeline.FirstOrDefault(); Assert.Equal(BlobContainerPublicAccessType.Container, container.PublicAccess); }
/// <summary> /// create a new azure container /// </summary> /// <param name="name">container name</param> internal AzureStorageContainer CreateAzureContainer(string name, string accesslevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobRequestOptions requestOptions = null; AccessCondition accessCondition = null; CloudBlobContainer container = Channel.GetContainerReference(name); bool created = Channel.CreateContainerIfNotExists(container, requestOptions, OperationContext); if (!created) { throw new ResourceAlreadyExistException(String.Format(Resources.ContainerAlreadyExists, name)); } BlobContainerPermissions permissions = new BlobContainerPermissions(); accessLevel = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(accessLevel); switch (CultureInfo.CurrentCulture.TextInfo.ToTitleCase(accessLevel)) { case StorageNouns.ContainerAclOff: permissions.PublicAccess = BlobContainerPublicAccessType.Off; break; case StorageNouns.ContainerAclBlob: permissions.PublicAccess = BlobContainerPublicAccessType.Blob; break; case StorageNouns.ContainerAclContainer: permissions.PublicAccess = BlobContainerPublicAccessType.Container; break; default: throw new ArgumentException(Resources.OnlyOnePermissionForContainer); } if (accessLevel == StorageNouns.ContainerAclContainer || accessLevel == StorageNouns.ContainerAclBlob) { Channel.SetContainerPermissions(container, permissions, accessCondition, requestOptions, OperationContext); } else { permissions = Channel.GetContainerPermissions(container, accessCondition, requestOptions, OperationContext); } AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); return(azureContainer); }
internal string SetAzureContainerStoredAccessPolicy(IStorageBlobManagement localChannel, string containerName, string policyName, DateTime?startTime, DateTime?expiryTime, string permission, bool noStartTime, bool noExpiryTime) { //Get container instance, Get existing permissions CloudBlobContainer container_Track1 = Channel.GetContainerReference(containerName); BlobContainerClient container = AzureStorageContainer.GetTrack2BlobContainerClient(container_Track1, Channel.StorageContext, ClientOptions); BlobContainerAccessPolicy accessPolicy = container.GetAccessPolicy(cancellationToken: CmdletCancellationToken).Value; IEnumerable <BlobSignedIdentifier> signedIdentifiers = accessPolicy.SignedIdentifiers; //Set the policy with new value BlobSignedIdentifier signedIdentifier = null; foreach (BlobSignedIdentifier identifier in signedIdentifiers) { if (identifier.Id == policyName) { signedIdentifier = identifier; } } if (signedIdentifier == null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.PolicyNotFound, policyName)); } if (noStartTime) { signedIdentifier.AccessPolicy.PolicyStartsOn = DateTimeOffset.MinValue; } else if (startTime != null) { signedIdentifier.AccessPolicy.PolicyStartsOn = StartTime.Value.ToUniversalTime(); } if (noExpiryTime) { signedIdentifier.AccessPolicy.PolicyExpiresOn = DateTimeOffset.MinValue; } else if (ExpiryTime != null) { signedIdentifier.AccessPolicy.PolicyExpiresOn = ExpiryTime.Value.ToUniversalTime(); } if (this.Permission != null) { signedIdentifier.AccessPolicy.Permissions = this.Permission; signedIdentifier.AccessPolicy.Permissions = AccessPolicyHelper.OrderBlobPermission(this.Permission); } //Set permissions back to container container.SetAccessPolicy(accessPolicy.BlobPublicAccess, signedIdentifiers, BlobRequestConditions, CmdletCancellationToken); WriteObject(AccessPolicyHelper.ConstructPolicyOutputPSObject <BlobSignedIdentifier>(signedIdentifier)); return(policyName); }
/// <summary> /// set the access level of specified container /// </summary> /// <param name="name">container name</param> /// <param name="accessLevel">access level in ("off", "blob", "container")</param> internal async Task SetContainerAcl(long taskId, IStorageBlobManagement localChannel, string name, BlobContainerPublicAccessType accessLevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobRequestOptions requestOptions = RequestOptions; CloudBlobContainer container = localChannel.GetContainerReference(name); BlobContainerClient containerClient = AzureStorageContainer.GetTrack2BlobContainerClient(container, this.Channel.StorageContext, ClientOptions); // Get container permission and set the public access as input BlobContainerAccessPolicy accessPolicy; try { accessPolicy = containerClient.GetAccessPolicy(null, this.CmdletCancellationToken); } catch (global::Azure.RequestFailedException e) when(e.Status == 404) { throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name)); } PublicAccessType publicAccessType = PublicAccessType.None; switch (accessLevel) { case BlobContainerPublicAccessType.Blob: publicAccessType = PublicAccessType.Blob; break; case BlobContainerPublicAccessType.Container: publicAccessType = PublicAccessType.BlobContainer; break; case BlobContainerPublicAccessType.Off: publicAccessType = PublicAccessType.None; break; default: case BlobContainerPublicAccessType.Unknown: throw new ArgumentOutOfRangeException("Permission"); } await containerClient.SetAccessPolicyAsync(publicAccessType, accessPolicy.SignedIdentifiers, null, this.CmdletCancellationToken).ConfigureAwait(false); if (PassThru) { AzureStorageContainer storageContainer = new AzureStorageContainer(containerClient, Channel.StorageContext); storageContainer.SetTrack2Permission(); OutputStream.WriteObject(taskId, storageContainer); } }
public override int GetHashCode() { unchecked { var hashCode = (GlacierVaultName != null ? GlacierVaultName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (S3BucketName != null ? S3BucketName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (AwsRegionEndpoint != null ? AwsRegionEndpoint.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (AzureStorageContainer != null ? AzureStorageContainer.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (LocalFolderName != null ? LocalFolderName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ IntervalMilliseconds; return(hashCode); } }
/// <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); }
/// <summary> /// List containers by container name pattern. /// </summary> /// <param name="name">Container name pattern</param> /// <returns>An enumerable collection of cloudblob container</returns> internal IEnumerable <Tuple <AzureStorageContainer, BlobContinuationToken> > ListContainersByName(string name) { string prefix = string.Empty; if (String.IsNullOrEmpty(name) || WildcardPattern.ContainsWildcardCharacters(name)) { prefix = NameUtil.GetNonWildcardPrefix(name); WildcardOptions options = WildcardOptions.IgnoreCase | WildcardOptions.Compiled; WildcardPattern wildcard = null; if (!string.IsNullOrEmpty(name)) { wildcard = new WildcardPattern(name, options); } Func <string, bool> containerFilter = (containerName) => null == wildcard || wildcard.IsMatch(containerName); IEnumerable <Tuple <AzureStorageContainer, BlobContinuationToken> > containerList = ListContainersByPrefix(prefix, containerFilter); foreach (var containerInfo in containerList) { yield return(containerInfo); } } else { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } if (this.IncludeDeleted.IsPresent) { WriteWarning("Can't get single deleted container, so -IncludeDeleted will be omit when get single container with -Name."); } CloudBlobContainer container = Channel.GetContainerReference(name); BlobContainerClient containerClient = AzureStorageContainer.GetTrack2BlobContainerClient(container, this.Channel.StorageContext, ClientOptions); global::Azure.Storage.Blobs.Models.BlobContainerProperties properties = null; try { properties = containerClient.GetProperties(cancellationToken: this.CmdletCancellationToken); } catch (global::Azure.RequestFailedException e) when(e.Status == 404) { throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name)); } yield return(new Tuple <AzureStorageContainer, BlobContinuationToken>(new AzureStorageContainer(containerClient, Channel.StorageContext, properties), null)); } }
public void CreateContainerSuccessfullyTest() { string name = String.Empty; string accesslevel = StorageNouns.ContainerAclOff; ((MockCommandRuntime)command.CommandRuntime).ResetPipelines(); name = "test"; AzureStorageContainer container = command.CreateAzureContainer(name, accesslevel); Assert.AreEqual("test", container.Name); ((MockCommandRuntime)command.CommandRuntime).ResetPipelines(); AssertThrows<ResourceAlreadyExistException>(() => command.CreateAzureContainer(name, accesslevel), String.Format(Resources.ContainerAlreadyExists, name)); }
internal async Task SetBlobTag(long taskId, IStorageBlobManagement localChannel, CloudBlobContainer container, string blobName) { if (!NameUtil.IsValidBlobName(blobName)) { throw new ArgumentException(String.Format(Resources.InvalidBlobName, blobName)); } ValidatePipelineCloudBlobContainer(container); BlobContainerClient track2container = AzureStorageContainer.GetTrack2BlobContainerClient(container, this.Channel.StorageContext, ClientOptions); BlobBaseClient blobClient = Util.GetTrack2BlobClient(track2container, blobName, localChannel.StorageContext, null, false, null, ClientOptions); await SetBlobTag(taskId, localChannel, blobClient, true).ConfigureAwait(false); }
public override int GetHashCode() { unchecked { var hashCode = Disabled.GetHashCode(); hashCode = (hashCode * 397) ^ (GlacierVaultName != null ? GlacierVaultName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (S3BucketName != null ? S3BucketName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (AwsRegionEndpoint != null ? AwsRegionEndpoint.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (AzureStorageContainer != null ? AzureStorageContainer.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (LocalFolderName != null ? LocalFolderName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (int)IntervalMilliseconds.GetValueOrDefault(); hashCode = (hashCode * 397) ^ (int)FullBackupIntervalMilliseconds.GetValueOrDefault(); return(hashCode); } }
/// <summary> /// create a new azure container /// </summary> /// <param name="name">container name</param> internal async Task CreateAzureContainer(long taskId, IStorageBlobManagement localChannel, string name, BlobContainerPublicAccessType accesslevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobRequestOptions requestOptions = RequestOptions; CloudBlobContainer container = localChannel.GetContainerReference(name); BlobContainerClient containerClient = AzureStorageContainer.GetTrack2BlobContainerClient(container, localChannel.StorageContext); PublicAccessType containerPublicAccess = PublicAccessType.None; if (accesslevel == BlobContainerPublicAccessType.Blob) { containerPublicAccess = PublicAccessType.Blob; } else if (accesslevel == BlobContainerPublicAccessType.Container) { containerPublicAccess = PublicAccessType.BlobContainer; } global::Azure.Storage.Blobs.Models.BlobContainerEncryptionScopeOptions encryptionScopeOption = null; if (this.DefaultEncryptionScope != null) { encryptionScopeOption = new global::Azure.Storage.Blobs.Models.BlobContainerEncryptionScopeOptions() { // parameterset can ensure the 2 parameters must be set together. DefaultEncryptionScope = this.DefaultEncryptionScope, PreventEncryptionScopeOverride = this.preventEncryptionScopeOverride.Value }; } Response <BlobContainerInfo> responds = await containerClient.CreateIfNotExistsAsync(containerPublicAccess, null, encryptionScopeOption, CmdletCancellationToken).ConfigureAwait(false); if (responds == null || responds.Value == null) // Container already exist so not created again { throw new ResourceAlreadyExistException(String.Format(Resources.ContainerAlreadyExists, name)); } BlobContainerPermissions permissions = new BlobContainerPermissions() { PublicAccess = accesslevel }; container.FetchAttributes(); WriteCloudContainerObject(taskId, localChannel, container, permissions); }
public void CreateContainerSuccessfullyTest() { string name = String.Empty; BlobContainerPublicAccessType accesslevel = BlobContainerPublicAccessType.Off; MockCmdRunTime.ResetPipelines(); name = "test"; command.Name = name; RunAsyncCommand(() => command.ExecuteCmdlet()); AzureStorageContainer container = (AzureStorageContainer)MockCmdRunTime.OutputPipeline.FirstOrDefault(); Assert.AreEqual("test", container.Name); MockCmdRunTime.ResetPipelines(); AssertThrowsAsync <ResourceAlreadyExistException>(() => command.CreateAzureContainer(InitTaskId, BlobMock, name, accesslevel), String.Format(Resources.ContainerAlreadyExists, name)); }
/// <summary> /// set the access level of specified container /// </summary> /// <param name="name">container name</param> /// <param name="accessLevel">access level in ("off", "blob", "container")</param> internal void SetContainerAcl(string name, string accessLevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobContainerPermissions permissions = new BlobContainerPermissions(); switch (CultureInfo.CurrentCulture.TextInfo.ToTitleCase(accessLevel)) { case StorageNouns.ContainerAclOff: permissions.PublicAccess = BlobContainerPublicAccessType.Off; break; case StorageNouns.ContainerAclBlob: permissions.PublicAccess = BlobContainerPublicAccessType.Blob; break; case StorageNouns.ContainerAclContainer: permissions.PublicAccess = BlobContainerPublicAccessType.Container; break; default: throw new ArgumentException(Resources.OnlyOnePermissionForContainer); } BlobRequestOptions requestOptions = null; AccessCondition accessCondition = null; CloudBlobContainer container = Channel.GetContainerReference(name); if (!Channel.DoesContainerExist(container, requestOptions, OperationContext)) { throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name)); } Channel.SetContainerPermissions(container, permissions, accessCondition, requestOptions, OperationContext); AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); if (PassThru) { WriteObjectWithStorageContext(azureContainer); } }
public override void ExecuteCmdlet() { if (ShouldProcess(this.Name, "Restore deleted container")) { if (!NameUtil.IsValidContainerName(this.Name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, this.Name)); } BlobServiceClient blobServiceClient = Util.GetTrack2BlobServiceClient(this.Channel.StorageContext, ClientOptions); BlobContainerClient destContainerClient = blobServiceClient.UndeleteBlobContainer(this.Name, this.VersionId, this.Name, this.CmdletCancellationToken).Value; AzureStorageContainer destAzureStorageContainer = new AzureStorageContainer(destContainerClient, Channel.StorageContext); destAzureStorageContainer.SetTrack2Permission(); WriteObject(destAzureStorageContainer); } }
/// <summary> /// create a new azure container /// </summary> /// <param name="name">container name</param> internal AzureStorageContainer CreateAzureContainer(string name, string accesslevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobRequestOptions requestOptions = null; AccessCondition accessCondition = null; CloudBlobContainer container = Channel.GetContainerReference(name); bool created = Channel.CreateContainerIfNotExists(container, requestOptions, OperationContext); if (!created) { throw new ResourceAlreadyExistException(String.Format(Resources.ContainerAlreadyExists, name)); } BlobContainerPermissions permissions = new BlobContainerPermissions(); accessLevel = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(accessLevel); switch (CultureInfo.CurrentCulture.TextInfo.ToTitleCase(accessLevel)) { case StorageNouns.ContainerAclOff: permissions.PublicAccess = BlobContainerPublicAccessType.Off; break; case StorageNouns.ContainerAclBlob: permissions.PublicAccess = BlobContainerPublicAccessType.Blob; break; case StorageNouns.ContainerAclContainer: permissions.PublicAccess = BlobContainerPublicAccessType.Container; break; default: throw new ArgumentException(Resources.OnlyOnePermissionForContainer); } if(accessLevel == StorageNouns.ContainerAclContainer || accessLevel == StorageNouns.ContainerAclBlob) { Channel.SetContainerPermissions(container, permissions, accessCondition, requestOptions, OperationContext); } else { permissions = Channel.GetContainerPermissions(container, accessCondition, requestOptions, OperationContext); } AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); return azureContainer; }
/// <summary> /// Pack CloudBlobContainer and it's permission to AzureStorageContainer object /// </summary> /// <param name="containerList">An enumerable collection of CloudBlobContainer</param> /// <returns>An enumerable collection of AzureStorageContainer</returns> internal IEnumerable<AzureStorageContainer> PackCloudBlobContainerWithAcl(IEnumerable<CloudBlobContainer> containerList) { if (null == containerList) { yield break; } BlobRequestOptions requestOptions = null; AccessCondition accessCondition = null; foreach (CloudBlobContainer container in containerList) { BlobContainerPermissions permissions = null; try { permissions = Channel.GetContainerPermissions(container, accessCondition, requestOptions, OperationContext); } catch (Exception e) { //Log the error message and continue the process WriteVerboseWithTimestamp(String.Format(Resources.GetContainerPermissionException, container.Name, e.Message)); } AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); yield return azureContainer; } }
/// <summary> /// create a new azure container /// </summary> /// <param name="name">container name</param> internal AzureStorageContainer CreateAzureContainer(string name, BlobContainerPublicAccessType accesslevel) { if (!NameUtil.IsValidContainerName(name)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, name)); } BlobRequestOptions requestOptions = RequestOptions; AccessCondition accessCondition = null; CloudBlobContainer container = Channel.GetContainerReference(name); bool created = Channel.CreateContainerIfNotExists(container, requestOptions, OperationContext); if (!created) { throw new ResourceAlreadyExistException(String.Format(Resources.ContainerAlreadyExists, name)); } BlobContainerPermissions permissions = new BlobContainerPermissions(); permissions.PublicAccess = accessLevel; if (accessLevel == BlobContainerPublicAccessType.Container || accessLevel == BlobContainerPublicAccessType.Blob) { Channel.SetContainerPermissions(container, permissions, accessCondition, requestOptions, OperationContext); } else { permissions = Channel.GetContainerPermissions(container, accessCondition, requestOptions, OperationContext); } AzureStorageContainer azureContainer = new AzureStorageContainer(container, permissions); return azureContainer; }