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>
/// 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);
}
}
/// <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;
}
/// <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);
}
}
