/// <summary> /// Initializes a new instance of the <see cref="TransferJob"/> class. /// </summary> /// <param name="other">The other transfer job to copy properties.</param> private TransferJob(TransferJob other) { this.Overwrite = other.Overwrite; this.CopyId = other.CopyId; this.CheckPoint = other.CheckPoint.Copy(); this.Status = other.Status; }
/// <summary> /// Initializes a new instance of the <see cref="TransferJob"/> class. /// </summary> private TransferJob(TransferJob other) { this.Overwrite = other.Overwrite; this.CopyId = other.CopyId; this.CheckPoint = other.CheckPoint.Copy(); this.Status = other.Status; }
public FileAsyncCopyController( TransferScheduler transferScheduler, TransferJob transferJob, CancellationToken cancellationToken) : base(transferScheduler, transferJob, cancellationToken) { if (transferJob.Destination.Type != TransferLocationType.AzureFile) { throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Resources.ParameterCannotBeNullException, "Dest.AzureFile"), "transferJob"); } if (transferJob.Source.Type != TransferLocationType.SourceUri && transferJob.Source.Type != TransferLocationType.AzureBlob && transferJob.Source.Type != TransferLocationType.AzureFile) { throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Resources.ProvideExactlyOneOfThreeParameters, "Source.SourceUri", "Source.Blob", "Source.AzureFile"), "transferJob"); } this.destLocation = this.TransferJob.Destination as AzureFileLocation; this.destFile = this.destLocation.AzureFile; }
public void UpdateTransferJobStatus(TransferJob transferJob, TransferJobStatus targetStatus) { lock (this.ProgressTracker) { switch (targetStatus) { case TransferJobStatus.Transfer: if (transferJob.Status == TransferJobStatus.Failed) { this.ProgressTracker.AddNumberOfFilesFailed(-1); } break; case TransferJobStatus.Skipped: this.ProgressTracker.AddNumberOfFilesSkipped(1); break; case TransferJobStatus.Finished: this.ProgressTracker.AddNumberOfFilesTransferred(1); break; case TransferJobStatus.Failed: this.ProgressTracker.AddNumberOfFilesFailed(1); break; case TransferJobStatus.NotStarted: case TransferJobStatus.Monitor: default: break; } transferJob.Status = targetStatus; } }
protected async Task RunTransferJob(TransferJob job, ProgressRecord record) { this.SetRequestOptionsInTransferJob(job); job.OverwritePromptCallback = this.ConfirmOverwrite; try { await this.transferJobRunner.RunTransferJob(job, (percent, speed) => { record.PercentComplete = (int)percent; record.StatusDescription = string.Format(CultureInfo.CurrentCulture, Resources.FileTransmitStatus, (int)percent, Util.BytesToHumanReadableSize(speed)); this.OutputStream.WriteProgress(record); }, this.CmdletCancellationToken); record.PercentComplete = 100; record.StatusDescription = Resources.TransmitSuccessfully; this.OutputStream.WriteProgress(record); } catch (OperationCanceledException) { record.StatusDescription = Resources.TransmitCancelled; this.OutputStream.WriteProgress(record); } catch (Exception e) { record.StatusDescription = string.Format(CultureInfo.CurrentCulture, Resources.TransmitFailed, e.Message); this.OutputStream.WriteProgress(record); throw; } }
/// <summary> /// Initializes a new instance of the <see cref="SingleObjectTransfer"/> class. /// </summary> /// <param name="other">Another <see cref="SingleObjectTransfer"/> object. </param> private SingleObjectTransfer(SingleObjectTransfer other) : base(other) { this.ProgressTracker = other.ProgressTracker.Copy(); this.transferJob = other.transferJob.Copy(); this.transferJob.Transfer = this; }
/// <summary> /// Initializes a new instance of the <see cref="TransferJob"/> class. /// </summary> private TransferJob(TransferJob other) { this.Source = other.Source; this.Destination = other.Destination; this.Overwrite = other.Overwrite; this.CopyId = other.CopyId; this.CheckPoint = other.CheckPoint.Copy(); this.Status = other.Status; }
private async Task ExecuteJobInternalAsync( TransferJob job, CancellationToken cancellationToken) { Debug.Assert( job.Status == TransferJobStatus.NotStarted || job.Status == TransferJobStatus.Monitor || job.Status == TransferJobStatus.Transfer); TransferControllerBase controller = null; switch (job.Transfer.TransferMethod) { case TransferMethod.SyncCopy: controller = new SyncTransferController(this, job, cancellationToken); break; case TransferMethod.AsyncCopy: controller = AsyncCopyController.CreateAsyncCopyController(this, job, cancellationToken); break; } Utils.CheckCancellation(this.cancellationTokenSource.Token); this.controllerQueue.Add(controller, this.cancellationTokenSource.Token); try { await controller.TaskCompletionSource.Task; } #if EXPECT_INTERNAL_WRAPPEDSTORAGEEXCEPTION catch (Exception ex) when(ex is StorageException || (ex is AggregateException && ex.InnerException is StorageException)) { var storageException = ex as StorageException ?? ex.InnerException as StorageException; if (storageException.InnerException is OperationCanceledException) { throw storageException.InnerException; } throw new TransferException(TransferErrorCode.Unknown, Resources.UncategorizedException, storageException); } #else catch (StorageException se) { throw new TransferException( TransferErrorCode.Unknown, Resources.UncategorizedException, se); } #endif finally { controller.Dispose(); } }
public Task RunTransferJob(TransferJob job, Action<double, double> progressReport, CancellationToken cancellationToken) { try { return runnerValidation(job); } catch (AssertFailedException e) { this.assertException = e; throw new MockupException("AssertFailed"); } }
private static void UpdateProgress(TransferJob job, Action updateAction) { try { job.ProgressUpdateLock?.EnterReadLock(); updateAction(); } finally { job.ProgressUpdateLock?.ExitReadLock(); } }
/// <summary> /// Execute a transfer job asynchronously. /// </summary> /// <param name="job">Transfer job to be executed.</param> /// <param name="cancellationToken">Token used to notify the job that it should stop.</param> public Task ExecuteJobAsync( TransferJob job, CancellationToken cancellationToken) { if (null == job) { throw new ArgumentNullException("job"); } lock (this.disposeLock) { this.CheckDisposed(); return(ExecuteJobInternalAsync(job, cancellationToken)); } }
public Task RunTransferJob(TransferJob job, Action<double, double> progressReport, CancellationToken cancellationToken) { TaskCompletionSource<object> downloadCompletionSource = new TaskCompletionSource<object>(); job.Starting += (sender, eventArgs) => { if (cancellationToken.IsCancellationRequested) { return; } progressReport(0, 0); }; job.ProgressUpdated += (sender, eventArgs) => { if (cancellationToken.IsCancellationRequested) { return; } progressReport(eventArgs.Progress, eventArgs.Speed); }; job.Finished += (sender, eventArgs) => { if (cancellationToken.IsCancellationRequested) { return; } if (eventArgs.Exception == null) { downloadCompletionSource.SetResult(null); } else { downloadCompletionSource.SetException(eventArgs.Exception); } }; this.manager.ExecuteJobAsync(job, cancellationToken); return downloadCompletionSource.Task; }
/// <summary> /// Initializes a new instance of the <see cref="SingleObjectTransfer"/> class. /// This constructor will check whether source and destination is valid for the operation: /// Uri is only valid for non-staging copy. /// cannot copy from local file/stream to local file/stream /// </summary> /// <param name="source">Transfer source.</param> /// <param name="dest">Transfer destination.</param> /// <param name="transferMethod">Transfer method, see <see cref="TransferMethod"/> for detail available methods.</param> public SingleObjectTransfer(TransferLocation source, TransferLocation dest, TransferMethod transferMethod) : base(source, dest, transferMethod) { if (null == source) { throw new ArgumentNullException("source"); } if (null == dest) { throw new ArgumentNullException("dest"); } if ((null != source.FilePath || null != source.Stream) && (null != dest.FilePath || null != dest.Stream)) { throw new InvalidOperationException(Resources.LocalToLocalTransferUnsupportedException); } if ((null != source.Blob) && (null != dest.Blob)) { if (source.Blob.BlobType != dest.Blob.BlobType) { throw new InvalidOperationException(Resources.SourceAndDestinationBlobTypeDifferent); } if (StorageExtensions.Equals(source.Blob, dest.Blob)) { throw new InvalidOperationException(Resources.SourceAndDestinationLocationCannotBeEqualException); } } if ((null != source.AzureFile) && (null != dest.AzureFile) && string.Equals(source.AzureFile.Uri.Host, dest.AzureFile.Uri.Host, StringComparison.OrdinalIgnoreCase) && string.Equals(source.AzureFile.Uri.AbsolutePath, dest.AzureFile.Uri.AbsolutePath, StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException(Resources.SourceAndDestinationLocationCannotBeEqualException); } this.transferJob = new TransferJob(this.Source, this.Destination); this.transferJob.Transfer = this; }
/// <summary> /// Initializes a new instance of the <see cref="SingleObjectTransfer"/> class. /// This constructor will check whether source and destination is valid for the operation: /// Uri is only valid for non-staging copy. /// cannot copy from local file/stream to local file/stream /// </summary> /// <param name="source">Transfer source.</param> /// <param name="dest">Transfer destination.</param> /// <param name="transferMethod">Transfer method, see <see cref="TransferMethod"/> for detail available methods.</param> public SingleObjectTransfer(TransferLocation source, TransferLocation dest, TransferMethod transferMethod) : base(source, dest, transferMethod) { Debug.Assert(source != null && dest != null); Debug.Assert( source.Type == TransferLocationType.FilePath || source.Type == TransferLocationType.Stream || source.Type == TransferLocationType.AzureBlob || source.Type == TransferLocationType.AzureFile || source.Type == TransferLocationType.SourceUri); Debug.Assert( dest.Type == TransferLocationType.FilePath || dest.Type == TransferLocationType.Stream || dest.Type == TransferLocationType.AzureBlob || dest.Type == TransferLocationType.AzureFile || dest.Type == TransferLocationType.SourceUri); Debug.Assert(!((source.Type == TransferLocationType.FilePath || source.Type == TransferLocationType.Stream) && (dest.Type == TransferLocationType.FilePath || dest.Type == TransferLocationType.Stream))); if (source.Type == TransferLocationType.AzureBlob && dest.Type == TransferLocationType.AzureBlob) { CloudBlob sourceBlob = (source as AzureBlobLocation).Blob; CloudBlob destBlob = (dest as AzureBlobLocation).Blob; if (sourceBlob.BlobType != destBlob.BlobType) { throw new InvalidOperationException(Resources.SourceAndDestinationBlobTypeDifferent); } if (StorageExtensions.Equals(sourceBlob, destBlob)) { throw new InvalidOperationException(Resources.SourceAndDestinationLocationCannotBeEqualException); } } if (source.Type == TransferLocationType.AzureFile && dest.Type == TransferLocationType.AzureFile) { CloudFile sourceFile = (source as AzureFileLocation).AzureFile; CloudFile destFile = (dest as AzureFileLocation).AzureFile; if (string.Equals(sourceFile.Uri.Host, destFile.Uri.Host, StringComparison.OrdinalIgnoreCase) && string.Equals(sourceFile.Uri.AbsolutePath, destFile.Uri.AbsolutePath, StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException(Resources.SourceAndDestinationLocationCannotBeEqualException); } } this.transferJob = new TransferJob(this); }
protected TransferControllerBase(TransferScheduler transferScheduler, TransferJob transferJob, CancellationToken userCancellationToken) { if (null == transferScheduler) { throw new ArgumentNullException("transferScheduler"); } if (null == transferJob) { throw new ArgumentNullException("transferJob"); } this.Scheduler = transferScheduler; this.TransferJob = transferJob; this.transferSchedulerCancellationTokenRegistration = this.Scheduler.CancellationTokenSource.Token.Register(this.CancelWork); this.userCancellationTokenRegistration = userCancellationToken.Register(this.CancelWork); this.TaskCompletionSource = new TaskCompletionSource<object>(); }
public BlobAsyncCopyController( TransferScheduler transferScheduler, TransferJob transferJob, CancellationToken cancellationToken) : base(transferScheduler, transferJob, cancellationToken) { this.destLocation = transferJob.Destination as AzureBlobLocation; CloudBlob transferDestBlob = this.destLocation.Blob; if (null == transferDestBlob) { throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Resources.ParameterCannotBeNullException, "Dest.Blob"), "transferJob"); } if (transferDestBlob.IsSnapshot) { throw new ArgumentException(Resources.DestinationMustBeBaseBlob, "transferJob"); } AzureBlobLocation sourceBlobLocation = transferJob.Source as AzureBlobLocation; if (sourceBlobLocation != null) { if (sourceBlobLocation.Blob.BlobType != transferDestBlob.BlobType) { throw new ArgumentException(Resources.SourceAndDestinationBlobTypeDifferent, "transferJob"); } if (StorageExtensions.Equals(sourceBlobLocation.Blob, transferDestBlob)) { throw new InvalidOperationException(Resources.SourceAndDestinationLocationCannotBeEqualException); } } this.destBlob = transferDestBlob; }
private async Task ExecuteJobInternalAsync( TransferJob job, CancellationToken cancellationToken) { Debug.Assert( job.Status == TransferJobStatus.NotStarted || job.Status == TransferJobStatus.Monitor || job.Status == TransferJobStatus.Transfer); TransferControllerBase controller = null; switch (job.Transfer.TransferMethod) { case TransferMethod.SyncCopy: controller = new SyncTransferController(this, job, cancellationToken); break; case TransferMethod.AsyncCopy: controller = AsyncCopyController.CreateAsyncCopyController(this, job, cancellationToken); break; } Utils.CheckCancellation(this.cancellationTokenSource); this.controllerQueue.Add(controller, this.cancellationTokenSource.Token); try { await controller.TaskCompletionSource.Task; } catch (StorageException sex) { throw new TransferException(TransferErrorCode.Unknown, Resources.UncategorizedException, sex); } finally { controller.Dispose(); } }
private async Task ExecuteJobInternalAsync( TransferJob job, CancellationToken cancellationToken) { Debug.Assert( job.Status == TransferJobStatus.NotStarted || job.Status == TransferJobStatus.Monitor || job.Status == TransferJobStatus.Transfer); TransferControllerBase controller = null; switch (job.Transfer.TransferMethod) { case TransferMethod.SyncCopy: controller = new SyncTransferController(this, job, cancellationToken); break; case TransferMethod.AsyncCopy: controller = AsyncCopyController.CreateAsyncCopyController(this, job, cancellationToken); break; } Utils.CheckCancellation(this.cancellationTokenSource); this.controllerQueue.Add(controller, this.cancellationTokenSource.Token); try { await controller.TaskCompletionSource.Task; } catch(StorageException sex) { throw new TransferException(TransferErrorCode.Unknown, Resources.UncategorizedException, sex); } finally { controller.Dispose(); } }
/// <summary> /// Execute a transfer job asynchronously. /// </summary> /// <param name="job">Transfer job to be executed.</param> /// <param name="cancellationToken">Token used to notify the job that it should stop.</param> public Task ExecuteJobAsync( TransferJob job, CancellationToken cancellationToken) { if (null == job) { throw new ArgumentNullException("job"); } lock (this.disposeLock) { this.CheckDisposed(); return ExecuteJobInternalAsync(job, cancellationToken); } }
/// <summary> /// Download blob to local file /// </summary> /// <param name="blob">Source blob object</param> /// <param name="filePath">Destination file path</param> internal virtual async Task DownloadBlob(long taskId, IStorageBlobManagement localChannel, CloudBlob blob, string filePath) { string activity = String.Format(Resources.ReceiveAzureBlobActivity, blob.Name, filePath); string status = Resources.PrepareDownloadingBlob; ProgressRecord pr = new ProgressRecord(OutputStream.GetProgressId(taskId), activity, status); DataMovementUserData data = new DataMovementUserData() { Data = blob, TaskId = taskId, Channel = localChannel, Record = pr }; TransferJob downloadJob = new TransferJob( new TransferLocation(blob), new TransferLocation(filePath), TransferMethod.SyncCopy); BlobRequestOptions requestOptions = downloadJob.Source.RequestOptions as BlobRequestOptions; if (null == requestOptions) { requestOptions = new BlobRequestOptions(); } requestOptions.DisableContentMD5Validation = !checkMd5; downloadJob.Source.RequestOptions = requestOptions; await this.RunTransferJob(downloadJob, data); this.WriteCloudBlobObject(data.TaskId, data.Channel, blob); }
/// <summary> /// Initializes a new instance of the <see cref="SingleObjectTransfer"/> class. /// </summary> /// <param name="info">Serialization information.</param> /// <param name="context">Streaming context.</param> protected SingleObjectTransfer(SerializationInfo info, StreamingContext context) : base(info, context) { this.transferJob = (TransferJob)info.GetValue(TransferJobName, typeof(TransferJob)); this.transferJob.Transfer = this; }
protected void SetRequestOptionsInTransferJob(TransferJob transferJob) { var cmdletOptions = this.RequestOptions; if (cmdletOptions == null) { return; } if (null != transferJob.Source.AzureFile) { this.SetRequestOptions(transferJob.Source, cmdletOptions); } if (null != transferJob.Destination.AzureFile) { this.SetRequestOptions(transferJob.Destination, cmdletOptions); } }
public override void ExecuteCmdlet() { // Step 1: Validate source file. FileInfo localFile = new FileInfo(this.GetUnresolvedProviderPathFromPSPath(this.Source)); if (!localFile.Exists) { throw new FileNotFoundException(string.Format(CultureInfo.CurrentCulture, Resources.SourceFileNotFound, this.Source)); } // Step 2: Build the CloudFile object which pointed to the // destination cloud file. this.RunTask(async taskId => { bool isDirectory; string[] path = NamingUtil.ValidatePath(this.Path, out isDirectory); var cloudFileToBeUploaded = await this.BuildCloudFileInstanceFromPathAsync(localFile.Name, path, isDirectory); var uploadJob = new TransferJob( new TransferLocation(localFile.FullName), new TransferLocation(cloudFileToBeUploaded), TransferMethod.SyncCopy); var progressRecord = new ProgressRecord( this.OutputStream.GetProgressId(taskId), string.Format(CultureInfo.CurrentCulture, Resources.SendAzureFileActivity, localFile.Name, cloudFileToBeUploaded.GetFullPath(), cloudFileToBeUploaded.Share.Name), Resources.PrepareUploadingFile); await this.RunTransferJob(uploadJob, progressRecord); if (this.PassThru) { this.OutputStream.WriteObject(taskId, cloudFileToBeUploaded); } }); }
/// <summary> /// Initializes a new instance of the <see cref="SingleObjectTransfer"/> class. /// </summary> /// <param name="other">Another <see cref="SingleObjectTransfer"/> object. </param> private SingleObjectTransfer(SingleObjectTransfer other) : base(other) { this.transferJob = other.transferJob.Copy(); this.transferJob.Transfer = this; }
protected void SetRequestOptionsInTransferJob(TransferJob transferJob) { BlobRequestOptions cmdletOptions = RequestOptions; if (cmdletOptions == null) { return; } if (null != transferJob.Source.Blob) { this.SetRequestOptions(transferJob.Source, cmdletOptions); } if (null != transferJob.Destination.Blob) { this.SetRequestOptions(transferJob.Destination, cmdletOptions); } }
public void UpdateTransferJobStatus(TransferJob transferJob, TransferJobStatus targetStatus) { lock (this.ProgressTracker) { switch (targetStatus) { case TransferJobStatus.Transfer: case TransferJobStatus.Monitor: if (transferJob.Status == TransferJobStatus.Failed) { this.ProgressTracker.AddNumberOfFilesFailed(-1); } break; case TransferJobStatus.Skipped: this.ProgressTracker.AddNumberOfFilesSkipped(1); break; case TransferJobStatus.Finished: this.ProgressTracker.AddNumberOfFilesTransferred(1); break; case TransferJobStatus.Failed: this.ProgressTracker.AddNumberOfFilesFailed(1); break; case TransferJobStatus.NotStarted: default: break; } transferJob.Status = targetStatus; } }
protected async Task EnqueueStartCopyJob(TransferJob startCopyJob, DataMovementUserData userData) { await this.RunTransferJob(startCopyJob, userData); this.OutputStream.WriteVerbose(userData.TaskId, startCopyJob.CopyId); Dictionary<string, string> destBlobPath = userData.Data as Dictionary<string, string>; if (destBlobPath != null) { var destChannel = userData.Channel; this.OutputStream.WriteVerbose(userData.TaskId, String.Format(Resources.CopyDestinationBlobPending, destBlobPath["Blob"], destBlobPath["Container"], startCopyJob.CopyId)); CloudBlobContainer container = destChannel.GetContainerReference(destBlobPath["Container"]); CloudBlob destBlob = this.GetDestinationBlobWithCopyId(destChannel, container, destBlobPath["Blob"]); if (destBlob != null) { this.WriteCloudBlobObject(userData.TaskId, destChannel, destBlob); } } }
public override void ExecuteCmdlet() { CloudFile fileToBeDownloaded; string[] path = NamingUtil.ValidatePath(this.Path, true); switch (this.ParameterSetName) { case LocalConstants.FileParameterSetName: fileToBeDownloaded = this.File; break; case LocalConstants.ShareNameParameterSetName: var share = this.BuildFileShareObjectFromName(this.ShareName); fileToBeDownloaded = share.GetRootDirectoryReference().GetFileReferenceByPath(path); break; case LocalConstants.ShareParameterSetName: fileToBeDownloaded = this.Share.GetRootDirectoryReference().GetFileReferenceByPath(path); break; case LocalConstants.DirectoryParameterSetName: fileToBeDownloaded = this.Directory.GetFileReferenceByPath(path); break; default: throw new PSArgumentException(string.Format(CultureInfo.InvariantCulture, "Invalid parameter set name: {0}", this.ParameterSetName)); } string resolvedDestination = this.GetUnresolvedProviderPathFromPSPath( string.IsNullOrWhiteSpace(this.Destination) ? "." : this.Destination); FileMode mode = this.Force ? FileMode.Create : FileMode.CreateNew; string targetFile; if (LocalDirectory.Exists(resolvedDestination)) { // If the destination pointed to an existing directory, we // would download the file into the folder with the same name // on cloud. targetFile = LocalPath.Combine(resolvedDestination, fileToBeDownloaded.GetBaseName()); } else { // Otherwise we treat the destination as a file no matter if // there's one existing or not. The overwrite behavior is configured // by FileMode. targetFile = resolvedDestination; } this.RunTask(async taskId => { var downloadJob = new TransferJob( new TransferLocation(fileToBeDownloaded), new TransferLocation(targetFile), TransferMethod.SyncCopy); var progressRecord = new ProgressRecord( this.OutputStream.GetProgressId(taskId), string.Format(CultureInfo.CurrentCulture, Resources.ReceiveAzureFileActivity, fileToBeDownloaded.GetFullPath(), targetFile), Resources.PrepareDownloadingFile); await this.RunTransferJob(downloadJob, progressRecord); if (this.PassThru) { this.OutputStream.WriteObject(taskId, fileToBeDownloaded); } }); }
/// <summary> /// Start copy using transfer mangager by source uri /// </summary> /// <param name="uri">source uri</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, Uri uri, CloudBlobContainer destContainer, string destBlobName) { NameUtil.ValidateContainerName(destContainer.Name); NameUtil.ValidateBlobName(destBlobName); Dictionary<string, string> BlobPath = new Dictionary<string, string>() { {"Container", destContainer.Name}, {"Blob", destBlobName} }; DataMovementUserData data = new DataMovementUserData() { Data = BlobPath, TaskId = taskId, Channel = destChannel, Record = null }; TransferJob startCopyJob = new TransferJob( new TransferLocation(uri), new TransferLocation(destContainer.GetBlockBlobReference(destBlobName)), TransferMethod.AsyncCopyInAzureStorageWithoutMonitor); await this.EnqueueStartCopyJob(startCopyJob, data); }
/// <summary> /// upload file to azure blob /// </summary> /// <param name="taskId">Task id</param> /// <param name="filePath">local file path</param> /// <param name="blob">destination azure blob object</param> internal virtual async Task Upload2Blob(long taskId, IStorageBlobManagement localChannel, string filePath, StorageBlob.CloudBlob blob) { string activity = String.Format(Resources.SendAzureBlobActivity, filePath, blob.Name, blob.Container.Name); string status = Resources.PrepareUploadingBlob; ProgressRecord pr = new ProgressRecord(OutputStream.GetProgressId(taskId), activity, status); DataMovementUserData data = new DataMovementUserData() { Data = blob, TaskId = taskId, Channel = localChannel, Record = pr }; TransferJob uploadJob = new TransferJob( new TransferLocation(filePath), new TransferLocation(blob), TransferMethod.SyncCopy); await this.RunTransferJob(uploadJob, data); if (this.BlobProperties != null || this.BlobMetadata != null) { await TaskEx.WhenAll( this.SetBlobProperties(localChannel, blob, this.BlobProperties), this.SetBlobMeta(localChannel, blob, this.BlobMetadata)); } try { await localChannel.FetchBlobAttributesAsync( blob, AccessCondition.GenerateEmptyCondition(), this.RequestOptions, this.OperationContext, this.CmdletCancellationToken); } catch (StorageException e) { //Handle the limited read permission. if (!e.IsNotFoundException()) { throw; } } WriteCloudBlobObject(data.TaskId, localChannel, blob); }