private void OnCopyTaskFinish(object userData, string copyId, Exception e)
{
DataMovementUserData data = userData as DataMovementUserData;
IStorageBlobManagement destChannel = data.Channel;
if (data != null && e == null)
{
OutputStream.WriteVerbose(data.TaskId, copyId);
Dictionary <string, string> destBlobPath = data.Data as Dictionary <string, string>;
if (destBlobPath != null)
{
OutputStream.WriteVerbose(data.TaskId, String.Format(Resources.CopyDestinationBlobPending, destBlobPath["Blob"], destBlobPath["Container"], copyId));
CloudBlobContainer container = destChannel.GetContainerReference(destBlobPath["Container"]);
try
{
ICloudBlob destBlob = GetDestinationBlobWithCopyId(destChannel, container, destBlobPath["Blob"]);
if (destBlob != null)
{
WriteICloudBlobObject(data.TaskId, destChannel, destBlob);
}
}
catch (Exception readException)
{
e = readException;
}
}
}
OnDMJobFinish(userData, e);
}
/// <summary>
/// Start copy operation by container name and blob name
/// </summary>
/// <param name="srcContainerName">Source container name</param>
/// <param name="srcBlobName">Source blob name</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement SrcChannel, IStorageBlobManagement destChannel, string srcContainerName, string srcBlobName, string destContainerName, string destBlobName)
{
ValidateBlobName(srcBlobName);
ValidateContainerName(srcContainerName);
ValidateContainerName(destContainerName);
if (string.IsNullOrEmpty(destBlobName))
{
destBlobName = srcBlobName;
}
ValidateBlobName(destBlobName);
AccessCondition accessCondition = null;
BlobRequestOptions options = RequestOptions;
CloudBlobContainer container = SrcChannel.GetContainerReference(srcContainerName);
ICloudBlob blob = SrcChannel.GetBlobReferenceFromServer(container, srcBlobName, accessCondition, options, OperationContext);
if (blob == null)
{
throw new ResourceNotFoundException(String.Format(Resources.BlobNotFound, srcBlobName, srcContainerName));
}
CloudBlobContainer destContainer = destChannel.GetContainerReference(destContainerName);
Func <long, Task> taskGenerator = (taskId) => StartCopyInTransferManager(taskId, destChannel, blob, destContainer, destBlobName);
RunTask(taskGenerator);
}
/// <summary>
/// Validate the container access policy
/// </summary>
/// <param name="policy">SharedAccessBlobPolicy object</param>
/// <param name="policyIdentifier">The policy identifier which need to be checked.</param>
public static bool ValidateContainerAccessPolicy(IStorageBlobManagement channel, string containerName,
SharedAccessBlobPolicy policy, string policyIdentifier)
{
if (string.IsNullOrEmpty(policyIdentifier))
{
return(true);
}
CloudBlobContainer container = channel.GetContainerReference(containerName);
AccessCondition accessCondition = null;
BlobRequestOptions options = null;
OperationContext context = null;
BlobContainerPermissions permission = channel.GetContainerPermissions(container, accessCondition, options, context);
SharedAccessBlobPolicy sharedAccessPolicy =
GetExistingPolicy <SharedAccessBlobPolicy>(permission.SharedAccessPolicies, policyIdentifier);
if (policy.Permissions != SharedAccessBlobPermissions.None)
{
throw new ArgumentException(Resources.SignedPermissionsMustBeOmitted);
}
if (policy.SharedAccessExpiryTime.HasValue && sharedAccessPolicy.SharedAccessExpiryTime.HasValue)
{
throw new ArgumentException(Resources.SignedExpiryTimeMustBeOmitted);
}
return(!sharedAccessPolicy.SharedAccessExpiryTime.HasValue);
}
internal async Task <SharedAccessBlobPolicies> GetPoliciesAsync(IStorageBlobManagement localChannel, string containerName, string policyName)
{
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = await localChannel.GetContainerPermissionsAsync(container, null, null, null, CmdletCancellationToken).ConfigureAwait(false);
return(blobContainerPermissions.SharedAccessPolicies);
}
/// <summary>
/// Start copy operation by source ICloudBlob object
/// </summary>
/// <param name="srcICloudBlob">Source ICloudBlob object</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, ICloudBlob srcICloudBlob, string destContainer, string destBlobName)
{
if (string.IsNullOrEmpty(destBlobName))
{
destBlobName = srcICloudBlob.Name;
}
ValidateBlobName(destBlobName);
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
ICloudBlob destBlob = null;
if (BlobType.PageBlob == srcICloudBlob.BlobType)
{
destBlob = container.GetPageBlobReference(destBlobName);
}
else if (BlobType.BlockBlob == srcICloudBlob.BlobType)
{
destBlob = container.GetBlockBlobReference(destBlobName);
}
else
{
throw new ArgumentException(String.Format(Resources.InvalidBlobType, srcICloudBlob.Name));
}
this.StartCopyBlob(destChannel, srcICloudBlob, destBlob);
}
/// <summary>
/// Start copy operation by source uri
/// </summary>
/// <param name="srcICloudBlob">Source uri</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, string srcUri, string destContainer, string destBlobName, AzureStorageContext context)
{
if (context != null)
{
Uri sourceUri = new Uri(srcUri);
Uri contextUri = new Uri(context.BlobEndPoint);
if (sourceUri.Host.ToLower() == contextUri.Host.ToLower())
{
CloudBlobClient blobClient = context.StorageAccount.CreateCloudBlobClient();
ICloudBlob blobReference = blobClient.GetBlobReferenceFromServer(sourceUri);
StartCopyBlob(destChannel, blobReference, destContainer, destBlobName);
}
else
{
WriteWarning(String.Format(Resources.StartCopySourceContextMismatch, srcUri, context.BlobEndPoint));
}
}
else
{
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
Func <long, Task> taskGenerator = (taskId) => StartCopyInTransferManager(taskId, destChannel, new Uri(srcUri), container, destBlobName);
RunTask(taskGenerator);
}
}
internal string CreateAzureContainerStoredAccessPolicy(IStorageBlobManagement localChannel, string containerName, string policyName, DateTime? startTime, DateTime? expiryTime, string permission)
{
if (!NameUtil.IsValidStoredAccessPolicyName(policyName))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.InvalidAccessPolicyName, policyName));
}
//Get existing permissions
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = localChannel.GetContainerPermissions(container);
//Add new policy
if (blobContainerPermissions.SharedAccessPolicies.Keys.Contains(policyName))
{
throw new ResourceAlreadyExistException(String.Format(CultureInfo.CurrentCulture, Resources.PolicyAlreadyExists, policyName));
}
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy();
AccessPolicyHelper.SetupAccessPolicy<SharedAccessBlobPolicy>(policy, startTime, expiryTime, permission);
blobContainerPermissions.SharedAccessPolicies.Add(policyName, policy);
//Set permissions back to container
localChannel.SetContainerPermissions(container, blobContainerPermissions);
return policyName;
}
private CloudBlob GetDestBlob(IStorageBlobManagement destChannel, string destContainerName, string destBlobName, BlobType blobType)
{
NameUtil.ValidateContainerName(destContainerName);
NameUtil.ValidateBlobName(destBlobName);
CloudBlobContainer container = destChannel.GetContainerReference(destContainerName);
CloudBlob destBlob = null;
if (BlobType.PageBlob == blobType)
{
destBlob = container.GetPageBlobReference(destBlobName);
}
else if (BlobType.BlockBlob == blobType)
{
destBlob = container.GetBlockBlobReference(destBlobName);
}
else if (BlobType.AppendBlob == blobType)
{
destBlob = container.GetAppendBlobReference(destBlobName);
}
else
{
throw new ArgumentException(String.Format(Resources.InvalidBlobType, blobType, destBlobName));
}
return(destBlob);
}
internal string CreateAzureContainerStoredAccessPolicy(IStorageBlobManagement localChannel, string containerName, string policyName, DateTime?startTime, DateTime?expiryTime, string permission)
{
if (!NameUtil.IsValidStoredAccessPolicyName(policyName))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.InvalidAccessPolicyName, policyName));
}
//Get existing permissions
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = localChannel.GetContainerPermissions(container);
//Add new policy
if (blobContainerPermissions.SharedAccessPolicies.Keys.Contains(policyName))
{
throw new ResourceAlreadyExistException(String.Format(CultureInfo.CurrentCulture, Resources.PolicyAlreadyExists, policyName));
}
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy();
AccessPolicyHelper.SetupAccessPolicy <SharedAccessBlobPolicy>(policy, startTime, expiryTime, permission);
blobContainerPermissions.SharedAccessPolicies.Add(policyName, policy);
//Set permissions back to container
localChannel.SetContainerPermissions(container, blobContainerPermissions);
return(policyName);
}
/// <summary>
/// Start copy operation by source ICloudBlob object
/// </summary>
/// <param name="srcICloudBlob">Source ICloudBlob object</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, ICloudBlob srcICloudBlob, string destContainer, string destBlobName)
{
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
Func <long, Task> taskGenerator = (taskId) => StartCopyInTransferManager(taskId, destChannel, srcICloudBlob, container, destBlobName);
RunTask(taskGenerator);
}
/// <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));
}
BlobContainerPermissions permissions = new BlobContainerPermissions();
permissions.PublicAccess = accessLevel;
BlobRequestOptions requestOptions = RequestOptions;
AccessCondition accessCondition = null;
CloudBlobContainer container = localChannel.GetContainerReference(name);
if (!await localChannel.DoesContainerExistAsync(container, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false))
{
throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name));
}
await localChannel.SetContainerPermissionsAsync(container, permissions, accessCondition, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false);
if (PassThru)
{
WriteCloudContainerObject(taskId, localChannel, container, permissions);
}
}
private CloudPageBlob GetDestBlob(IStorageBlobManagement destChannel, string destContainerName, string destBlobName)
{
NameUtil.ValidateContainerName(destContainerName);
NameUtil.ValidateBlobName(destBlobName);
CloudBlobContainer container = destChannel.GetContainerReference(destContainerName);
CloudPageBlob destBlob = container.GetPageBlobReference(destBlobName);
return(destBlob);
}
public void SetDestinationContainer(IStorageBlobManagement channel, string containerName)
{
if (Container == null)
{
if (!NameUtil.IsValidContainerName(containerName))
{
throw new ArgumentException(String.Format(Resources.InvalidContainerName, containerName));
}
Container = channel.GetContainerReference(containerName);
}
}
public void SetDestinationContainer(IStorageBlobManagement channel, string containerName)
{
if (Container == null)
{
if (!NameUtil.IsValidContainerName(containerName))
{
throw new ArgumentException(String.Format(Resources.InvalidContainerName, containerName));
}
Container = channel.GetContainerReference(containerName);
}
}
/// <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);
}
}
/// <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);
}
/// <summary>
/// Start copy operation by container name and blob name
/// </summary>
/// <param name="srcContainerName">Source container name</param>
/// <param name="srcBlobName">Source blob name</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination CloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement SrcChannel, IStorageBlobManagement destChannel, string srcContainerName, string srcBlobName, string destContainerName, string destBlobName)
{
NameUtil.ValidateBlobName(srcBlobName);
NameUtil.ValidateContainerName(srcContainerName);
if (string.IsNullOrEmpty(destBlobName))
{
destBlobName = srcBlobName;
}
AccessCondition accessCondition = null;
BlobRequestOptions options = RequestOptions;
CloudBlobContainer container = SrcChannel.GetContainerReference(srcContainerName);
CloudBlob blob = GetBlobReferenceFromServerWithContainer(SrcChannel, container, srcBlobName, accessCondition, options, OperationContext);
this.StartCopyBlob(destChannel, blob, destContainerName, destBlobName);
}
/// <summary>
/// get the CloudBlobContainer object by name if container exists
/// </summary>
/// <param name="containerName">container name</param>
/// <returns>return CloudBlobContianer object if specified container exists, otherwise throw an exception</returns>
internal async Task <CloudBlobContainer> GetCloudBlobContainerByName(IStorageBlobManagement localChannel, string containerName, bool skipCheckExists = false)
{
if (!NameUtil.IsValidContainerName(containerName))
{
throw new ArgumentException(String.Format(Resources.InvalidContainerName, containerName));
}
BlobRequestOptions requestOptions = RequestOptions;
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
if (!skipCheckExists && container.ServiceClient.Credentials.IsSharedKey &&
!await localChannel.DoesContainerExistAsync(container, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false))
{
throw new ArgumentException(String.Format(Resources.ContainerNotFound, containerName));
}
return(container);
}
internal string SetAzureContainerStoredAccessPolicy(IStorageBlobManagement localChannel, string containerName, string policyName, DateTime? startTime, DateTime? expiryTime, string permission, bool noStartTime, bool noExpiryTime)
{
//Get existing permissions
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = localChannel.GetContainerPermissions(container);
//Set the policy with new value
if (!blobContainerPermissions.SharedAccessPolicies.Keys.Contains(policyName))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.PolicyNotFound, policyName));
}
SharedAccessBlobPolicy policy = blobContainerPermissions.SharedAccessPolicies[policyName];
AccessPolicyHelper.SetupAccessPolicy<SharedAccessBlobPolicy>(policy, startTime, expiryTime, permission, noStartTime, noExpiryTime);
blobContainerPermissions.SharedAccessPolicies[policyName] = policy;
//Set permission back to container
localChannel.SetContainerPermissions(container, blobContainerPermissions);
WriteObject(AccessPolicyHelper.ConstructPolicyOutputPSObject<SharedAccessBlobPolicy>(blobContainerPermissions.SharedAccessPolicies, policyName));
return policyName;
}
/// <summary>
/// Start copy operation by source uri
/// </summary>
/// <param name="srcCloudBlob">Source uri</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination CloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, string srcUri, string destContainer, string destBlobName, AzureStorageContext context)
{
if (context != null)
{
Uri sourceUri = new Uri(srcUri);
Uri contextUri = new Uri(context.BlobEndPoint);
if (sourceUri.Host.ToLower() == contextUri.Host.ToLower())
{
CloudBlobClient blobClient = context.StorageAccount.CreateCloudBlobClient();
CloudBlob blobReference = null;
try
{
blobReference = Util.GetBlobReferenceFromServer(blobClient, sourceUri);
}
catch (InvalidOperationException)
{
blobReference = null;
}
if (null == blobReference)
{
throw new ResourceNotFoundException(String.Format(Resources.BlobUriNotFound, sourceUri.ToString()));
}
StartCopyBlob(destChannel, blobReference, destContainer, destBlobName);
}
else
{
WriteWarning(String.Format(Resources.StartCopySourceContextMismatch, srcUri, context.BlobEndPoint));
}
}
else
{
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
Func <long, Task> taskGenerator = (taskId) => StartCopyAsync(taskId, destChannel, new Uri(srcUri), container, destBlobName);
RunTask(taskGenerator);
}
}
internal string SetAzureContainerStoredAccessPolicy(IStorageBlobManagement localChannel, string containerName, string policyName, DateTime?startTime, DateTime?expiryTime, string permission, bool noStartTime, bool noExpiryTime)
{
//Get existing permissions
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = localChannel.GetContainerPermissions(container);
//Set the policy with new value
if (!blobContainerPermissions.SharedAccessPolicies.Keys.Contains(policyName))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.PolicyNotFound, policyName));
}
SharedAccessBlobPolicy policy = blobContainerPermissions.SharedAccessPolicies[policyName];
AccessPolicyHelper.SetupAccessPolicy <SharedAccessBlobPolicy>(policy, startTime, expiryTime, permission, noStartTime, noExpiryTime);
blobContainerPermissions.SharedAccessPolicies[policyName] = policy;
//Set permission back to container
localChannel.SetContainerPermissions(container, blobContainerPermissions);
WriteObject(AccessPolicyHelper.ConstructPolicyOutputPSObject <SharedAccessBlobPolicy>(blobContainerPermissions.SharedAccessPolicies, policyName));
return(policyName);
}
/// <summary>
/// remove azure container by container name
/// </summary>
/// <param name="name">container name</param>
internal async Task RemoveAzureContainer(long taskId, IStorageBlobManagement localChannel, string name)
{
if (!NameUtil.IsValidContainerName(name))
{
throw new ArgumentException(String.Format(Resources.InvalidContainerName, name));
}
BlobRequestOptions requestOptions = RequestOptions;
AccessCondition accessCondition = null;
CloudBlobContainer container = localChannel.GetContainerReference(name);
if (!await localChannel.DoesContainerExistAsync(container, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false))
{
throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name));
}
string result = string.Empty;
bool removed = false;
if (force || ContainerIsEmpty(container) || OutputStream.ConfirmAsync(String.Format("Remove container and all content in it: {0}", name)).Result)
{
await localChannel.DeleteContainerAsync(container, accessCondition, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false);
result = String.Format(Resources.RemoveContainerSuccessfully, name);
removed = true;
}
else
{
result = String.Format(Resources.RemoveContainerCancelled, name);
}
OutputStream.WriteVerbose(taskId, result);
if (PassThru)
{
OutputStream.WriteObject(taskId, removed);
}
}
/// <summary>
/// remove azure container by container name
/// </summary>
/// <param name="name">container name</param>
internal async Task RemoveAzureContainer(long taskId, IStorageBlobManagement localChannel, string name)
{
if (!NameUtil.IsValidContainerName(name))
{
throw new ArgumentException(String.Format(Resources.InvalidContainerName, name));
}
BlobRequestOptions requestOptions = RequestOptions;
AccessCondition accessCondition = null;
CloudBlobContainer container = localChannel.GetContainerReference(name);
if (!await localChannel.DoesContainerExistAsync(container, requestOptions, OperationContext, CmdletCancellationToken))
{
throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name));
}
string result = string.Empty;
bool removed = false;
if (force || await OutputStream.ConfirmAsync(name))
{
await localChannel.DeleteContainerAsync(container, accessCondition, requestOptions, OperationContext, CmdletCancellationToken);
result = String.Format(Resources.RemoveContainerSuccessfully, name);
removed = true;
}
else
{
result = String.Format(Resources.RemoveContainerCancelled, name);
}
OutputStream.WriteVerbose(taskId, result);
if (PassThru)
{
OutputStream.WriteObject(taskId, removed);
}
}
/// <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);
BlobContainerPermissions permissions = new BlobContainerPermissions();
permissions.PublicAccess = accesslevel;
bool created = await localChannel.CreateContainerIfNotExistsAsync(container, permissions.PublicAccess, requestOptions, OperationContext, CmdletCancellationToken);
if (!created)
{
throw new ResourceAlreadyExistException(String.Format(Resources.ContainerAlreadyExists, name));
}
WriteCloudContainerObject(taskId, localChannel, container, permissions);
}
/// <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);
BlobContainerPermissions permissions = new BlobContainerPermissions();
permissions.PublicAccess = accesslevel;
bool created = await localChannel.CreateContainerIfNotExistsAsync(container, permissions.PublicAccess, requestOptions, OperationContext, CmdletCancellationToken);
if (!created)
{
throw new ResourceAlreadyExistException(String.Format(Resources.ContainerAlreadyExists, name));
}
WriteCloudContainerObject(taskId, localChannel, container, permissions);
}
internal bool RemoveAzureContainerStoredAccessPolicy(IStorageBlobManagement localChannel, string containerName, string policyName)
{
bool success = false;
string result = string.Empty;
//Get existing permissions
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = localChannel.GetContainerPermissions(container);
//remove the specified policy
if (!blobContainerPermissions.SharedAccessPolicies.Keys.Contains(policyName))
{
throw new ResourceNotFoundException(String.Format(CultureInfo.CurrentCulture, Resources.PolicyNotFound, policyName));
}
if (this.Force || ConfirmRemove(policyName))
{
blobContainerPermissions.SharedAccessPolicies.Remove(policyName);
localChannel.SetContainerPermissions(container, blobContainerPermissions);
success = true;
}
return(success);
}
internal bool RemoveAzureContainerStoredAccessPolicy(IStorageBlobManagement localChannel, string containerName, string policyName)
{
bool success = false;
string result = string.Empty;
//Get existing permissions
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = localChannel.GetContainerPermissions(container);
//remove the specified policy
if (!blobContainerPermissions.SharedAccessPolicies.Keys.Contains(policyName))
{
throw new ResourceNotFoundException(String.Format(CultureInfo.CurrentCulture, Resources.PolicyNotFound, policyName));
}
if (this.Force || ConfirmRemove(policyName))
{
blobContainerPermissions.SharedAccessPolicies.Remove(policyName);
localChannel.SetContainerPermissions(container, blobContainerPermissions);
success = true;
}
return success;
}
/// <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;
AccessCondition accessCondition = null;
bool needUseTrack2 = false;
CloudBlobContainer container = localChannel.GetContainerReference(name);
// Get container permission and set the public access as input
BlobContainerPermissions permissions = null;
try
{
permissions = localChannel.GetContainerPermissions(container, null, requestOptions, OperationContext);
}
catch (StorageException e) when(e.IsNotFoundException())
{
throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name));
}
catch (StorageException e) when(e.IsConflictException())
{
// 409 Conflict, might caused by the container has an Stored access policy contains a permission that is not supported by Track1 SDK API veresion, so switch to Track2 SDK
needUseTrack2 = true;
}
if (!needUseTrack2) // Track1
{
permissions.PublicAccess = accessLevel;
await localChannel.SetContainerPermissionsAsync(container, permissions, accessCondition, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false);
if (PassThru)
{
WriteCloudContainerObject(taskId, localChannel, container, permissions);
}
}
else // Track2
{
BlobContainerClient containerClient = AzureStorageContainer.GetTrack2BlobContainerClient(container, this.Channel.StorageContext, ClientOptions);
// Get container permission and set the public access as input
BlobContainerAccessPolicy accessPolicy;
accessPolicy = containerClient.GetAccessPolicy(null, this.CmdletCancellationToken);
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(container, null);
storageContainer.Context = localChannel.StorageContext;
storageContainer.SetTrack2Permission();
OutputStream.WriteObject(taskId, storageContainer);
}
}
}
/// <summary>
/// Start copy operation by container name and blob name
/// </summary>
/// <param name="srcContainerName">Source container name</param>
/// <param name="srcBlobName">Source blob name</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination CloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement SrcChannel, IStorageBlobManagement destChannel, string srcContainerName, string srcBlobName, string destContainerName, string destBlobName)
{
NameUtil.ValidateBlobName(srcBlobName);
NameUtil.ValidateContainerName(srcContainerName);
if (string.IsNullOrEmpty(destBlobName))
{
destBlobName = srcBlobName;
}
AccessCondition accessCondition = null;
BlobRequestOptions options = RequestOptions;
CloudBlobContainer container = SrcChannel.GetContainerReference(srcContainerName);
CloudBlob blob = GetBlobReferenceFromServerWithContainer(SrcChannel, container, srcBlobName, accessCondition, options, OperationContext);
this.StartCopyBlob(destChannel, blob, destContainerName, destBlobName);
}
/// <summary>
/// Stop copy operation by name
/// </summary>
/// <param name="containerName">Container name</param>
/// <param name="blobName">Blob name</param>
/// <param name="copyId">copy id</param>
private async Task StopCopyBlob(long taskId, IStorageBlobManagement localChannel, string containerName, string blobName, string copyId)
{
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
await StopCopyBlob(taskId, localChannel, container, blobName, copyId);
}
private CloudBlob GetDestBlob(IStorageBlobManagement destChannel, string destContainerName, string destBlobName, BlobType blobType)
{
NameUtil.ValidateContainerName(destContainerName);
NameUtil.ValidateBlobName(destBlobName);
CloudBlobContainer container = destChannel.GetContainerReference(destContainerName);
CloudBlob destBlob = null;
if (BlobType.PageBlob == blobType)
{
destBlob = container.GetPageBlobReference(destBlobName);
}
else if (BlobType.BlockBlob == blobType)
{
destBlob = container.GetBlockBlobReference(destBlobName);
}
else if (BlobType.AppendBlob == blobType)
{
destBlob = container.GetAppendBlobReference(destBlobName);
}
else
{
throw new ArgumentException(String.Format(Resources.InvalidBlobType, blobType, destBlobName));
}
return destBlob;
}
internal async Task<SharedAccessBlobPolicies> GetPoliciesAsync(IStorageBlobManagement localChannel, string containerName, string policyName)
{
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
BlobContainerPermissions blobContainerPermissions = await localChannel.GetContainerPermissionsAsync(container, null, null, null, CmdletCancellationToken);
return blobContainerPermissions.SharedAccessPolicies;
}
/// <summary>
/// remove azure blob
/// </summary>
/// <param name="containerName">container name</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, string containerName, string blobName)
{
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
await RemoveAzureBlob(taskId, localChannel, container, blobName);
}
/// <summary>
/// Start copy operation by source ICloudBlob object
/// </summary>
/// <param name="srcICloudBlob">Source ICloudBlob object</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, ICloudBlob srcICloudBlob, string destContainer, string destBlobName)
{
if (string.IsNullOrEmpty(destBlobName))
{
destBlobName = srcICloudBlob.Name;
}
ValidateBlobName(destBlobName);
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
ICloudBlob destBlob = null;
if (BlobType.PageBlob == srcICloudBlob.BlobType)
{
destBlob = container.GetPageBlobReference(destBlobName);
}
else if (BlobType.BlockBlob == srcICloudBlob.BlobType)
{
destBlob = container.GetBlockBlobReference(destBlobName);
}
else
{
throw new ArgumentException(String.Format(Resources.InvalidBlobType, srcICloudBlob.Name));
}
this.StartCopyBlob(destChannel, srcICloudBlob, destBlob);
}
/// <summary>
/// Start copy operation by source ICloudBlob object
/// </summary>
/// <param name="srcICloudBlob">Source ICloudBlob object</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private ICloudBlob StartCopyBlob(ICloudBlob srcICloudBlob, string destContainer, string destBlobName)
{
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
return(StartCopyInTransferManager(srcICloudBlob, container, destBlobName));
}
/// <summary>
/// get the CloudBlobContainer object by name if container exists
/// </summary>
/// <param name="containerName">container name</param>
/// <returns>return CloudBlobContianer object if specified container exists, otherwise throw an exception</returns>
internal async Task<CloudBlobContainer> GetCloudBlobContainerByName(IStorageBlobManagement localChannel, string containerName, bool skipCheckExists = false)
{
if (!NameUtil.IsValidContainerName(containerName))
{
throw new ArgumentException(String.Format(Resources.InvalidContainerName, containerName));
}
BlobRequestOptions requestOptions = RequestOptions;
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
if (!skipCheckExists && container.ServiceClient.Credentials.IsSharedKey
&& !await localChannel.DoesContainerExistAsync(container, requestOptions, OperationContext, CmdletCancellationToken))
{
throw new ArgumentException(String.Format(Resources.ContainerNotFound, containerName));
}
return container;
}
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);
}
/// <summary>
/// Start copy operation by source ICloudBlob object
/// </summary>
/// <param name="srcICloudBlob">Source ICloudBlob object</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, ICloudBlob srcICloudBlob, string destContainer, string destBlobName)
{
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
Func<long, Task> taskGenerator = (taskId) => StartCopyInTransferManager(taskId, destChannel, srcICloudBlob, container, destBlobName);
RunTask(taskGenerator);
}
/// <summary>
/// Start copy operation by source uri
/// </summary>
/// <param name="srcICloudBlob">Source uri</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, string srcUri, string destContainer, string destBlobName, AzureStorageContext context)
{
if (context != null)
{
Uri sourceUri = new Uri(srcUri);
Uri contextUri = new Uri(context.BlobEndPoint);
if (sourceUri.Host.ToLower() == contextUri.Host.ToLower())
{
CloudBlobClient blobClient = context.StorageAccount.CreateCloudBlobClient();
ICloudBlob blobReference = blobClient.GetBlobReferenceFromServer(sourceUri);
StartCopyBlob(destChannel, blobReference, destContainer, destBlobName);
}
else
{
WriteWarning(String.Format(Resources.StartCopySourceContextMismatch, srcUri, context.BlobEndPoint));
}
}
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
Func<long, Task> taskGenerator = (taskId) => StartCopyInTransferManager(taskId, destChannel, new Uri(srcUri), container, destBlobName);
RunTask(taskGenerator);
}
/// <summary>
/// Stop copy operation by name
/// </summary>
/// <param name="containerName">Container name</param>
/// <param name="blobName">Blob name</param>
/// <param name="copyId">copy id</param>
private async Task StopCopyBlob(long taskId, IStorageBlobManagement localChannel, string containerName, string blobName, string copyId)
{
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
await StopCopyBlob(taskId, localChannel, container, blobName, copyId).ConfigureAwait(false);
}
/// <summary>
/// Start copy operation by container name and blob name
/// </summary>
/// <param name="srcContainerName">Source container name</param>
/// <param name="srcBlobName">Source blob name</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination ICloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement SrcChannel, IStorageBlobManagement destChannel, string srcContainerName, string srcBlobName, string destContainerName, string destBlobName)
{
ValidateBlobName(srcBlobName);
ValidateContainerName(srcContainerName);
ValidateContainerName(destContainerName);
if (string.IsNullOrEmpty(destBlobName))
{
destBlobName = srcBlobName;
}
ValidateBlobName(destBlobName);
AccessCondition accessCondition = null;
BlobRequestOptions options = RequestOptions;
CloudBlobContainer container = SrcChannel.GetContainerReference(srcContainerName);
ICloudBlob blob = SrcChannel.GetBlobReferenceFromServer(container, srcBlobName, accessCondition, options, OperationContext);
if (blob == null)
{
throw new ResourceNotFoundException(String.Format(Resources.BlobNotFound, srcBlobName, srcContainerName));
}
CloudBlobContainer destContainer = destChannel.GetContainerReference(destContainerName);
Func<long, Task> taskGenerator = (taskId) => StartCopyInTransferManager(taskId, destChannel, blob, destContainer, destBlobName);
RunTask(taskGenerator);
}
/// <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));
}
BlobContainerPermissions permissions = new BlobContainerPermissions();
permissions.PublicAccess = accessLevel;
BlobRequestOptions requestOptions = RequestOptions;
AccessCondition accessCondition = null;
CloudBlobContainer container = localChannel.GetContainerReference(name);
if (!await localChannel.DoesContainerExistAsync(container, requestOptions, OperationContext, CmdletCancellationToken))
{
throw new ResourceNotFoundException(String.Format(Resources.ContainerNotFound, name));
}
await localChannel.SetContainerPermissionsAsync(container, permissions, accessCondition, requestOptions, OperationContext, CmdletCancellationToken);
if (PassThru)
{
WriteCloudContainerObject(taskId, localChannel, container, permissions);
}
}
/// <summary>
/// remove azure blob
/// </summary>
/// <param name="containerName">container name</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, string containerName, string blobName)
{
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
await RemoveAzureBlob(taskId, localChannel, container, blobName);
}
/// <summary>
/// Start copy operation by source uri
/// </summary>
/// <param name="srcCloudBlob">Source uri</param>
/// <param name="destContainer">Destinaion container name</param>
/// <param name="destBlobName">Destination blob name</param>
/// <returns>Destination CloudBlob object</returns>
private void StartCopyBlob(IStorageBlobManagement destChannel, string srcUri, string destContainer, string destBlobName, AzureStorageContext context)
{
if (context != null)
{
Uri sourceUri = new Uri(srcUri);
Uri contextUri = new Uri(context.BlobEndPoint);
if (sourceUri.Host.ToLower() == contextUri.Host.ToLower())
{
CloudBlobClient blobClient = context.StorageAccount.CreateCloudBlobClient();
CloudBlob blobReference = null;
try
{
blobReference = Util.GetBlobReferenceFromServer(blobClient, sourceUri);
}
catch (InvalidOperationException)
{
blobReference = null;
}
if (null == blobReference)
{
throw new ResourceNotFoundException(String.Format(Resources.BlobUriNotFound, sourceUri.ToString()));
}
StartCopyBlob(destChannel, blobReference, destContainer, destBlobName);
}
else
{
WriteWarning(String.Format(Resources.StartCopySourceContextMismatch, srcUri, context.BlobEndPoint));
}
}
else
{
CloudBlobContainer container = destChannel.GetContainerReference(destContainer);
Func<long, Task> taskGenerator = (taskId) => StartCopyAsync(taskId, destChannel, new Uri(srcUri), container, destBlobName);
RunTask(taskGenerator);
}
}
internal async Task SetBlobTag(long taskId, IStorageBlobManagement localChannel, string containerName, string blobName)
{
CloudBlobContainer container = localChannel.GetContainerReference(containerName);
await SetBlobTag(taskId, localChannel, container, blobName).ConfigureAwait(false);
}