private static TransferControllerBase GenerateTransferConstroller(
TransferScheduler transferScheduler,
TransferJob transferJob,
CancellationToken cancellationToken)
{
TransferControllerBase controller = null;
switch (transferJob.Transfer.TransferMethod)
{
case TransferMethod.SyncCopy:
controller = new SyncTransferController(transferScheduler, transferJob, cancellationToken);
break;
case TransferMethod.ServiceSideAsyncCopy:
controller = CreateAsyncCopyController(transferScheduler, transferJob, cancellationToken);
break;
case TransferMethod.ServiceSideSyncCopy:
controller = CreateServiceSideSyncCopyConstroller(transferScheduler, transferJob, cancellationToken);
break;
case TransferMethod.DummyCopy:
controller = new DummyTransferController(transferScheduler, transferJob, cancellationToken);
break;
}
return(controller);
}
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();
}
}
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();
}
}
