private static void DoLeaseOperation(CloudBlob blob, string leaseId, Microsoft.WindowsAzure.StorageClient.Protocol.LeaseAction action) { try { if (blob == null || leaseId == null) return; var creds = blob.ServiceClient.Credentials; var transformedUri = new Uri(creds.TransformUri(blob.Uri.ToString())); var req = BlobRequest.Lease(transformedUri, AzureBlobLeaseTimeout, action, leaseId); creds.SignRequest(req); req.GetResponse().Close(); } catch (WebException e) { Console.WriteLine("WebException", e.Message + ". DoLeaseOperation, blob: " + blob.Name + ", leaseId: " + leaseId + ", action " + action); } }
public virtual Task DownloadAsync(CloudBlob sourceBlob, string destPath, DownloadOptions options, SingleTransferContext context, CancellationToken cancellationToken) { throw new NotImplementedException(); }
/// <summary> /// Deletes the file. /// </summary> /// <param name="bucketName">Name of the bucket.</param> /// <param name="keyName">Name of the key.</param> public void DeleteFile(string bucketName, string keyName) { CloudBlob blob = GetBlob(bucketName, keyName); blob.DeleteIfExists(); }
/// <summary> /// Start copy operation by source and destination CloudBlob object /// </summary> /// <param name="srcCloudBlob">Source CloudBlob object</param> /// <param name="destCloudBlob">Destination CloudBlob object</param> /// <returns>Destination CloudBlob object</returns> private void StartCopyBlob(IStorageBlobManagement destChannel, CloudBlob srcCloudBlob, CloudBlob destCloudBlob) { ValidateBlobType(srcCloudBlob); Func <long, Task> taskGenerator = (taskId) => StartCopyInTransferManager(taskId, destChannel, srcCloudBlob, destCloudBlob); RunTask(taskGenerator); }
/// <summary> /// Start copy using transfer mangager by source CloudBlob object /// </summary> /// <param name="blob">Source CloudBlob object</param> /// <param name="destContainer">Destination CloudBlobContainer object</param> /// <param name="destBlobName">Destination blob name</param> /// <returns>Destination CloudBlob object</returns> private async Task StartCopyInTransferManager(long taskId, IStorageBlobManagement DestChannel, CloudBlob sourceBlob, CloudBlob destBlob) { NameUtil.ValidateBlobName(sourceBlob.Name); NameUtil.ValidateContainerName(destBlob.Container.Name); NameUtil.ValidateBlobName(destBlob.Name); Dictionary <string, string> BlobPath = new Dictionary <string, string>() { { "Container", destBlob.Container.Name }, { "Blob", destBlob.Name } }; DataMovementUserData data = new DataMovementUserData() { Data = BlobPath, TaskId = taskId, Channel = DestChannel, Record = null }; TransferJob startCopyJob = new TransferJob(new TransferLocation(sourceBlob), new TransferLocation(destBlob), TransferMethod.AsyncCopyInAzureStorageWithoutMonitor); await this.EnqueueStartCopyJob(startCopyJob, data); }
/// <summary> /// Write CloudBlob to output using specified service channel /// </summary> /// <param name="blob">The output CloudBlob object</param> /// <param name="channel">IStorageBlobManagement channel object</param> internal void WriteCloudBlobObject(long taskId, IStorageBlobManagement channel, CloudBlob blob, BlobContinuationToken continuationToken = null) { AzureStorageBlob azureBlob = new AzureStorageBlob(blob); azureBlob.Context = channel.StorageContext; azureBlob.ContinuationToken = continuationToken; OutputStream.WriteObject(taskId, azureBlob); }
internal async Task DeleteCloudAsync(long taskId, IStorageBlobManagement localChannel, CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption) { AccessCondition accessCondition = null; BlobRequestOptions requestOptions = null; await localChannel.DeleteCloudBlobAsync(blob, deleteSnapshotsOption, accessCondition, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false); string result = String.Format(Resources.RemoveBlobSuccessfully, blob.Name, blob.Container.Name); OutputStream.WriteVerbose(taskId, result); if (PassThru) { OutputStream.WriteObject(taskId, true); } }
/// <summary> /// Stop copy operation by CloudBlob object /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="copyId">Copy id</param> private async Task StopCopyBlob(long taskId, IStorageBlobManagement localChannel, CloudBlob blob, string copyId, bool fetchCopyIdFromBlob = false) { ValidateBlobType(blob); AccessCondition accessCondition = null; BlobRequestOptions abortRequestOption = RequestOptions ?? new BlobRequestOptions(); //Set no retry to resolve the 409 conflict exception abortRequestOption.RetryPolicy = new NoRetry(); if (null == blob) { throw new ArgumentException(String.Format(Resources.ObjectCannotBeNull, typeof(CloudBlob).Name)); } string specifiedCopyId = copyId; if (string.IsNullOrEmpty(specifiedCopyId) && fetchCopyIdFromBlob) { if (blob.CopyState != null) { specifiedCopyId = blob.CopyState.CopyId; } } string abortCopyId = string.Empty; if (string.IsNullOrEmpty(specifiedCopyId) || Force) { //Make sure we use the correct copy id to abort //Use default retry policy for FetchBlobAttributes BlobRequestOptions options = RequestOptions; await localChannel.FetchBlobAttributesAsync(blob, accessCondition, options, OperationContext, CmdletCancellationToken); if (blob.CopyState == null || String.IsNullOrEmpty(blob.CopyState.CopyId)) { ArgumentException e = new ArgumentException(String.Format(Resources.CopyTaskNotFound, blob.Name, blob.Container.Name)); OutputStream.WriteError(taskId, e); } else { abortCopyId = blob.CopyState.CopyId; } if (!Force) { string confirmation = String.Format(Resources.ConfirmAbortCopyOperation, blob.Name, blob.Container.Name, abortCopyId); if (!await OutputStream.ConfirmAsync(confirmation)) { string cancelMessage = String.Format(Resources.StopCopyOperationCancelled, blob.Name, blob.Container.Name); OutputStream.WriteVerbose(taskId, cancelMessage); } } } else { abortCopyId = specifiedCopyId; } await localChannel.AbortCopyAsync(blob, abortCopyId, accessCondition, abortRequestOption, OperationContext, CmdletCancellationToken); string message = String.Format(Resources.StopCopyBlobSuccessfully, blob.Name, blob.Container.Name); OutputStream.WriteObject(taskId, message); }
/// <summary> /// fetch blob attributes /// </summary> /// <param name="accessCondition">Access condition</param> /// <param name="options">blob request options</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> public void FetchBlobAttributes(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext) { return; }
public SingleFileSignature(FileInfo file, CloudBlob blob = null) : base(file.Directory, file.Name, new string[] { file.Name }, blob) { File = file; Size = File.Length; }
public async Task <bool> ExecuteAsync() { try { Log.LogMessage("Performing blob merge..."); if (string.IsNullOrEmpty(SourceBlobDirectory) || string.IsNullOrEmpty(TargetBlobDirectory)) { Log.LogError($"Please specify a source blob directory and a target blob directory"); } else { // Canonicalize the target uri string targetUri = GetCanonicalStorageUri(TargetBlobDirectory); // Invoke the blob URI parser on the target URI and deal with any container creation that needs to happen BlobUrlInfo targetUrlInfo = new BlobUrlInfo(targetUri); CloudStorageAccount storageAccount = new CloudStorageAccount(new WindowsAzure.Storage.Auth.StorageCredentials(targetUrlInfo.AccountName, AccountKey), true); CloudBlobClient client = storageAccount.CreateCloudBlobClient(); CloudBlobContainer targetContainer = client.GetContainerReference(targetUrlInfo.ContainerName); if (!SkipCreateContainer) { Log.LogMessage($"Creating container {targetUrlInfo.ContainerName} if it doesn't exist."); await targetContainer.CreateIfNotExistsAsync(); } string sourceUri = GetCanonicalStorageUri(SourceBlobDirectory); // Grab the source blob path from the source info and combine with the target blob path. BlobUrlInfo sourceBlobInfo = new BlobUrlInfo(sourceUri); // For now the source and target storage accounts should be the same, so the same account key is used for each. if (sourceBlobInfo.AccountName != targetUrlInfo.AccountName) { Log.LogError($"Source and target storage accounts should be identical"); } else { CloudBlobContainer sourceContainer = client.GetContainerReference(sourceBlobInfo.ContainerName); Log.LogMessage($"Listing blobs in {sourceUri}"); // Get all source URI's with the blob prefix BlobContinuationToken token = null; List <IListBlobItem> sourceBlobs = new List <IListBlobItem>(); do { BlobResultSegment segment = await sourceContainer.ListBlobsSegmentedAsync(sourceBlobInfo.BlobPath, true, BlobListingDetails.None, null, token, new BlobRequestOptions(), null); token = segment.ContinuationToken; sourceBlobs.AddRange(segment.Results); }while (token != null); // Ensure the source exists if (!SkipIfMissing && sourceBlobs.Count == 0) { Log.LogError($"No blobs found in {sourceUri}"); } await Task.WhenAll(sourceBlobs.Select(async blob => { // Determine the relative URI for the target. This works properly when the // trailing slash is left off of the source and target URIs. string relativeBlobPath = blob.Uri.ToString().Substring(sourceUri.Length); string specificTargetUri = GetCanonicalStorageUri(targetUri, relativeBlobPath); BlobUrlInfo specificTargetBlobUrlInfo = new BlobUrlInfo(specificTargetUri); CloudBlob targetBlob = targetContainer.GetBlobReference(specificTargetBlobUrlInfo.BlobPath); Log.LogMessage($"Merging {blob.Uri.ToString()} into {targetBlob.Uri.ToString()}"); if (!Overwrite && await targetBlob.ExistsAsync()) { Log.LogError($"Target blob {targetBlob.Uri.ToString()} already exists."); } await targetBlob.StartCopyAsync(blob.Uri); })); } } } catch (Exception e) { Log.LogErrorFromException(e, true); } return(!Log.HasLoggedErrors); }
public override void ExecuteCmdlet() { CloudBlob blob = null; if (ParameterSetName == BlobNamePipelineParmeterSetWithPermission || ParameterSetName == BlobNamePipelineParmeterSetWithPolicy) { blob = GetCloudBlobByName(Container, Blob); } else { blob = this.CloudBlob; } // When the input context is Oauth bases, can't generate normal SAS, but UserDelegationSas bool generateUserDelegationSas = false; if (Channel != null && Channel.StorageContext != null && Channel.StorageContext.StorageAccount.Credentials.IsToken) { if (ShouldProcess(blob.Name, "Generate User Delegation SAS, since input Storage Context is OAuth based.")) { generateUserDelegationSas = true; if (!string.IsNullOrEmpty(accessPolicyIdentifier)) { throw new ArgumentException("When input Storage Context is OAuth based, Saved Policy is not supported.", "Policy"); } } else { return; } } if (!(blob is InvalidCloudBlob) && !UseTrack2Sdk()) { SharedAccessBlobPolicy accessPolicy = new SharedAccessBlobPolicy(); bool shouldSetExpiryTime = SasTokenHelper.ValidateContainerAccessPolicy(Channel, blob.Container.Name, accessPolicy, accessPolicyIdentifier); SetupAccessPolicy(accessPolicy, shouldSetExpiryTime); string sasToken = GetBlobSharedAccessSignature(blob, accessPolicy, accessPolicyIdentifier, Protocol, Util.SetupIPAddressOrRangeForSAS(IPAddressOrRange), generateUserDelegationSas); if (FullUri) { string fullUri = blob.SnapshotQualifiedUri.ToString(); if (blob.IsSnapshot) { // Since snapshot URL already has '?', need remove '?' in the first char of sas fullUri = fullUri + "&" + sasToken.Substring(1); } else { fullUri = fullUri + sasToken; } WriteObject(fullUri); } else { WriteObject(sasToken); } } else // Use Track2 SDk { //Get blob instance BlobBaseClient blobClient; if (this.BlobBaseClient != null) { blobClient = this.BlobBaseClient; } else { blobClient = AzureStorageBlob.GetTrack2BlobClient(blob, Channel.StorageContext, this.ClientOptions); } // Get contaienr saved policy if any BlobSignedIdentifier identifier = null; if (ParameterSetName == BlobNamePipelineParmeterSetWithPolicy || ParameterSetName == BlobPipelineParameterSetWithPolicy) { BlobContainerClient container = AzureStorageContainer.GetTrack2BlobContainerClient(Channel.GetContainerReference(blobClient.BlobContainerName), Channel.StorageContext, ClientOptions); identifier = SasTokenHelper.GetBlobSignedIdentifier(container, this.Policy, CmdletCancellationToken); } //Create SAS builder BlobSasBuilder sasBuilder = SasTokenHelper.SetBlobSasBuilder_FromBlob(blobClient, identifier, this.Permission, this.StartTime, this.ExpiryTime, this.IPAddressOrRange, this.Protocol, this.EncryptionScope); //Create SAS and ourput string sasToken = SasTokenHelper.GetBlobSharedAccessSignature(Channel.StorageContext, sasBuilder, generateUserDelegationSas, ClientOptions, CmdletCancellationToken); if (sasToken[0] != '?') { sasToken = "?" + sasToken; } if (FullUri) { string fullUri = blobClient.Uri.ToString(); if (blob.IsSnapshot) { // Since snapshot URL already has '?', need remove '?' in the first char of sas fullUri = fullUri + "&" + sasToken.Substring(1); } else { fullUri = fullUri + sasToken; } WriteObject(fullUri); } else { WriteObject(sasToken); } } }
public static CloudBlob GetBlobReferenceFromServer(CloudBlobClient client, Uri blobUri) { CloudBlob blob = new CloudBlob(blobUri, client.Credentials); return(GetBlobReferenceFromServer(blob)); }
/// <summary> /// Start copy using transfer mangager by source CloudBlob object /// </summary> /// <param name="blob">Source CloudBlob object</param> /// <param name="destContainer">Destination CloudBlobContainer object</param> /// <param name="destBlobName">Destination blob name</param> /// <returns>Destination CloudBlob object</returns> private async Task StartCopyAsync(long taskId, IStorageBlobManagement destChannel, CloudBlob sourceBlob, CloudBlob destBlob) { NameUtil.ValidateBlobName(sourceBlob.Name); NameUtil.ValidateContainerName(destBlob.Container.Name); NameUtil.ValidateBlobName(destBlob.Name); await this.StartCopyFromBlob(taskId, destChannel, sourceBlob, destBlob); }
private async Task StartCopyFromUri(long taskId, IStorageBlobManagement destChannel, Uri srcUri, CloudBlob destBlob) { bool destExist = true; try { await destBlob.FetchAttributesAsync(null, this.RequestOptions, this.OperationContext, this.CmdletCancellationToken); } catch (StorageException ex) { if (ex.IsNotFoundException()) { destExist = false; } else { throw; } } if (!destExist || this.ConfirmOverwrite(srcUri.AbsoluteUri.ToString(), destBlob.Uri.ToString())) { string copyId = await destChannel.StartCopyAsync(destBlob, srcUri, null, null, this.RequestOptions, this.OperationContext, this.CmdletCancellationToken); this.OutputStream.WriteVerbose(taskId, String.Format(Resources.CopyDestinationBlobPending, destBlob.Name, destBlob.Container.Name, copyId)); this.WriteCloudBlobObject(taskId, destChannel, destBlob); } }
/// <summary> /// set blob meta data /// </summary> /// <param name="blob">ICloud blob object</param> /// <param name="accessCondition">Access condition</param> /// <param name="options">blob request options</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> public void SetBlobMetadata(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext) { return; }
/// <summary> /// whether the specified blob is a snapshot /// </summary> /// <param name="blob">CloudBlob object</param> /// <returns>true if the specified blob is snapshot, otherwise false</returns> internal bool IsSnapshot(CloudBlob blob) { return(!string.IsNullOrEmpty(blob.Name) && blob.SnapshotTime != null); }
/// <summary> /// Abort copy operation on specified blob /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="copyId">Copy id</param> /// <param name="accessCondition">Access condition</param> /// <param name="options">Blob request options</param> /// <param name="operationContext">Operation context</param> public void AbortCopy(CloudBlob blob, string copyId, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext) { return; }
/// <summary> /// remove the azure blob /// </summary> /// <param name="blob">Cloudblob object</param> /// <param name="isValidBlob">whether the Cloudblob parameter is validated</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, CloudBlob blob, bool isValidBlob) { if (!isValidBlob) { ValidatePipelineCloudBlob(blob); } ValidateBlobType(blob); DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None; bool retryDeleteSnapshot = false; if (IsSnapshot(blob)) { if (deleteSnapshot) { throw new ArgumentException(String.Format(Resources.CannotDeleteSnapshotForSnapshot, blob.Name, blob.SnapshotTime)); } } else { if (deleteSnapshot) { deleteSnapshotsOption = DeleteSnapshotsOption.DeleteSnapshotsOnly; } else if (force) { deleteSnapshotsOption = DeleteSnapshotsOption.IncludeSnapshots; } else { retryDeleteSnapshot = true; } } try { await DeleteCloudAsync(taskId, localChannel, blob, deleteSnapshotsOption).ConfigureAwait(false); retryDeleteSnapshot = false; } catch (StorageException e) { if (e.IsConflictException() && retryDeleteSnapshot) { //If x-ms-delete-snapshots is not specified on the request and the blob has associated snapshots, the Blob service returns status code 409 (Conflict). retryDeleteSnapshot = true; } else { throw; } } if (retryDeleteSnapshot) { string message = string.Format(Resources.ConfirmRemoveBlobWithSnapshot, blob.Name, blob.Container.Name); if (await OutputStream.ConfirmAsync(message).ConfigureAwait(false)) { deleteSnapshotsOption = DeleteSnapshotsOption.IncludeSnapshots; await DeleteCloudAsync(taskId, localChannel, blob, deleteSnapshotsOption).ConfigureAwait(false); } else { string result = String.Format(Resources.RemoveBlobCancelled, blob.Name, blob.Container.Name); OutputStream.WriteVerbose(taskId, result); } } }
/// <summary> /// Return a task that asynchronously check whether the specified blob exists. /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="options">Blob request options</param> /// <param name="operationContext">Operation context</param> /// <param name="cmdletCancellationToken">Cancellation token</param> /// <returns>A task object that asynchronously check whether the specified blob exists.</returns> public Task <bool> DoesBlobExistAsync(CloudBlob blob, BlobRequestOptions options, OperationContext operationContext, CancellationToken cmdletCancellationToken) { return(Task.Factory.StartNew(() => this.DoesBlobExist(blob, options, operationContext))); }
/// <summary> /// Get blob shared access signature /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="accessPolicy">SharedAccessBlobPolicy object</param> /// <param name="policyIdentifier">The existing policy identifier.</param> /// <returns></returns> private string GetBlobSharedAccessSignature(CloudBlob blob, SharedAccessBlobPolicy accessPolicy, string policyIdentifier, SharedAccessProtocol?protocol, IPAddressOrRange iPAddressOrRange) { CloudBlobContainer container = blob.Container; return(blob.GetSharedAccessSignature(accessPolicy, null, policyIdentifier, protocol, iPAddressOrRange)); }
/// <summary> /// Return a task that asynchronously fetch blob attributes /// </summary> /// <param name="blob">ICloud blob object</param> /// <param name="accessCondition">Access condition</param> /// <param name="options">Blob request options</param> /// <param name="operationContext">Operation context</param> /// <param name="cmdletCancellationToken">Cancellation token</param> /// <returns>Return a task that asynchronously fetch blob attributes</returns> public Task FetchBlobAttributesAsync(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cmdletCancellationToken) { return(Task.Factory.StartNew(() => this.FetchBlobAttributes(blob, accessCondition, options, operationContext))); }
private void StartCopyFromFile(IStorageBlobManagement destChannel, CloudFile srcFile, CloudBlob destBlob) { CloudBlockBlob destBlockBlob = destBlob as CloudBlockBlob; if (null == destBlockBlob) { throw new InvalidOperationException(Resources.OnlyCopyFromBlockBlobToAzureFile); } Func <long, Task> taskGenerator = (taskId) => this.StartCopyFromFile(taskId, destChannel, srcFile, destBlockBlob);; RunTask(taskGenerator); }
/// <summary> /// Return a task that asynchronously abort the blob copy operation /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="abortCopyId">Copy id</param> /// <param name="accessCondition">Access condition</param> /// <param name="abortRequestOption">Blob request options</param> /// <param name="operationContext">Operation context</param> /// <param name="cmdletCancellationToken">Cancellation token</param> /// <returns>Return a task that asynchronously abort the blob copy operation</returns> public Task AbortCopyAsync(CloudBlob blob, string copyId, AccessCondition accessCondition, BlobRequestOptions requestOption, OperationContext operationContext, CancellationToken cmdletCancellationToken) { return(Task.Factory.StartNew(() => this.AbortCopy(blob, copyId, accessCondition, requestOption, operationContext))); }
public async Task <bool> ExecuteAsync() { try { Log.LogMessage("Performing blob merge..."); string sourceKey = SourceAccountKey ?? AccountKey; string targetKey = TargetAccountKey ?? AccountKey; if (string.IsNullOrEmpty(SourceBlobDirectory) || string.IsNullOrEmpty(TargetBlobDirectory) || string.IsNullOrEmpty(sourceKey) || string.IsNullOrEmpty(targetKey)) { Log.LogError($"Please specify a source blob directory, a target blob directory and account keys"); } else { // Canonicalize the target uri string targetUri = GetCanonicalStorageUri(TargetBlobDirectory); // Invoke the blob URI parser on the target URI and deal with any container creation that needs to happen BlobUrlInfo targetUrlInfo = new BlobUrlInfo(targetUri); CloudStorageAccount targetStorageAccount = new CloudStorageAccount(new WindowsAzure.Storage.Auth.StorageCredentials(targetUrlInfo.AccountName, targetKey), true); CloudBlobClient targetClient = targetStorageAccount.CreateCloudBlobClient(); CloudBlobContainer targetContainer = targetClient.GetContainerReference(targetUrlInfo.ContainerName); if (!SkipCreateContainer) { Log.LogMessage($"Creating container {targetUrlInfo.ContainerName} if it doesn't exist."); await targetContainer.CreateIfNotExistsAsync(); } string sourceUri = GetCanonicalStorageUri(SourceBlobDirectory); // Grab the source blob path from the source info and combine with the target blob path. BlobUrlInfo sourceBlobInfo = new BlobUrlInfo(sourceUri); CloudStorageAccount sourceStorageAccount = new CloudStorageAccount(new WindowsAzure.Storage.Auth.StorageCredentials(sourceBlobInfo.AccountName, sourceKey), true); CloudBlobClient sourceClient = sourceStorageAccount.CreateCloudBlobClient(); CloudBlobContainer sourceContainer = sourceClient.GetContainerReference(sourceBlobInfo.ContainerName); Log.LogMessage($"Listing blobs in {sourceUri}"); // Get all source URI's with the blob prefix BlobContinuationToken token = null; List <IListBlobItem> sourceBlobs = new List <IListBlobItem>(); do { BlobResultSegment segment = await sourceContainer.ListBlobsSegmentedAsync(sourceBlobInfo.BlobPath, true, BlobListingDetails.None, null, token, new BlobRequestOptions(), null); token = segment.ContinuationToken; sourceBlobs.AddRange(segment.Results); }while (token != null); // Ensure the source exists if (!SkipIfMissing && sourceBlobs.Count == 0) { Log.LogError($"No blobs found in {sourceUri}"); } await Task.WhenAll(sourceBlobs.Select(async blob => { // Determine the relative URI for the target. This works properly when the // trailing slash is left off of the source and target URIs. string relativeBlobPath = blob.Uri.ToString().Substring(sourceUri.Length); string specificTargetUri = GetCanonicalStorageUri(targetUri, relativeBlobPath); BlobUrlInfo specificTargetBlobUrlInfo = new BlobUrlInfo(specificTargetUri); CloudBlob targetBlob = targetContainer.GetBlobReference(specificTargetBlobUrlInfo.BlobPath); Log.LogMessage($"Merging {blob.Uri.ToString()} into {targetBlob.Uri.ToString()}"); if (!Overwrite && await targetBlob.ExistsAsync()) { Log.LogError($"Target blob {targetBlob.Uri.ToString()} already exists."); } BlobUrlInfo specificSourceBlobUrlInfo = new BlobUrlInfo(blob.Uri); CloudBlob sourceBlob = sourceContainer.GetBlobReference(specificSourceBlobUrlInfo.BlobPath); SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy { Permissions = SharedAccessBlobPermissions.Read, SharedAccessStartTime = null, SharedAccessExpiryTime = DateTimeOffset.Now.AddMinutes(30) }; string sas = sourceBlob.GetSharedAccessSignature(policy); await targetBlob.StartCopyAsync(new Uri(blob.Uri + sas)); DateTime endWaitTime = DateTime.Now.AddMinutes(CopyWaitTimeoutInMinutes); TimeSpan waitInterval = TimeSpan.FromSeconds(30); ICloudBlob copyInProgessBlob; do { await Task.Delay(waitInterval); copyInProgessBlob = await targetContainer.GetBlobReferenceFromServerAsync(specificTargetBlobUrlInfo.BlobPath); }while (DateTime.Now.CompareTo(endWaitTime) < 0 && copyInProgessBlob.CopyState.Status == CopyStatus.Pending); if (copyInProgessBlob?.CopyState?.Status != CopyStatus.Success) { Log.LogError($"{copyInProgessBlob.Uri.ToString()} timed out or failed."); } else { Log.LogMessage($"{copyInProgessBlob.Uri.ToString()} completed."); } })); } } catch (Exception e) { Log.LogErrorFromException(e, true); } return(!Log.HasLoggedErrors); }
/// <summary> /// Return a task that asynchronously delete the specified blob /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="deleteSnapshotsOption">Snapshot delete option</param> /// <param name="accessCondition">Access condition</param> /// <param name="requestOptions">Blob request option</param> /// <param name="operationContext">Operation context</param> /// <param name="cmdletCancellationToken">Cancellation token</param> /// <returns>Return a task that asynchronously delete the specified blob</returns> public Task DeleteCloudBlobAsync(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions requestOptions, OperationContext operationContext, CancellationToken cmdletCancellationToken) { return(Task.Factory.StartNew(() => this.DeleteCloudBlob(blob, deleteSnapshotsOption, accessCondition, requestOptions, operationContext))); }
public virtual Task UploadAsync(string sourcePath, CloudBlob destBlob, UploadOptions options, SingleTransferContext context, CancellationToken cancellationToken) { throw new NotImplementedException(); }
/// <summary> /// Return a task that asynchronously set blob meta data /// </summary> /// <param name="blob">ICloud blob object</param> /// <param name="accessCondition">Access condition</param> /// <param name="options">Blob request options</param> /// <param name="operationContext">An object that represents the context for the current operation.</param> public Task SetBlobMetadataAsync(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cmdletCancellationToken) { return(Task.Factory.StartNew(() => this.SetBlobMetadata(blob, accessCondition, options, operationContext))); }
/// <summary> /// Gets the file. /// </summary> /// <param name="bucketName"></param> /// <param name="keyName"></param> /// <returns></returns> public byte[] GetFile(string bucketName, string keyName) { CloudBlob blob = GetBlob(bucketName, keyName); return(blob.DownloadByteArray()); }
public Task <string> StartCopyAsync(CloudBlob blob, Uri source, StandardBlobTier?standardBlobTier, RehydratePriority?rehydratePriority, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public static void ReleaseLease(CloudBlob blob, string leaseId) { DoLeaseOperation(blob, leaseId, Microsoft.WindowsAzure.StorageClient.Protocol.LeaseAction.Release); }
private async Task StartCopyFromBlob(long taskId, IStorageBlobManagement destChannel, CloudBlob srcBlob, CloudBlob destBlob) { try { await StartCopyFromUri(taskId, destChannel, srcBlob.GenerateUriWithCredentials(), destBlob); } catch (StorageException ex) { if (0 == string.Compare(ex.Message, BlobTypeMismatch, StringComparison.OrdinalIgnoreCase)) { // Current use error message to decide whether it caused by blob type mismatch, // We should ask xscl to expose an error code for this.. // Opened workitem 1487579 to track this. throw new InvalidOperationException(Resources.DestinationBlobTypeNotMatch); } else { throw; } } }