void BubbleUpClickEvent(object sender, EventArgs e)
{
TransferEntry entry = this as TransferEntry;
//TransferListControl parent = entry.Item.Parent as TransferListControl;
entry.Item.Selected = true;
}
private IEnumerable <Transfer> AllTransfers(CancellationToken cancellationToken)
{
// return all existing transfers in subTransfers
foreach (var transfer in this.subTransfers.GetEnumerator())
{
Utils.CheckCancellation(cancellationToken);
transfer.Context = this.Context;
transfer.ContentType = this.ContentType;
this.UpdateTransfer(transfer);
yield return(transfer);
}
// list new transfers
if (this.enumerateContinuationToken != null)
{
this.SourceEnumerator.EnumerateContinuationToken = this.enumerateContinuationToken.ListContinuationToken;
}
var enumerator = this.SourceEnumerator.EnumerateLocation(cancellationToken).GetEnumerator();
while (true)
{
Utils.CheckCancellation(cancellationToken);
// lock enumerator
if (!enumerator.MoveNext())
{
yield break;
}
TransferEntry entry = enumerator.Current;
ErrorEntry errorEntry = entry as ErrorEntry;
if (errorEntry != null)
{
TransferException exception = errorEntry.Exception as TransferException;
if (null != exception)
{
throw exception;
}
else
{
throw new TransferException(
TransferErrorCode.FailToEnumerateDirectory,
errorEntry.Exception.GetExceptionMessage(),
errorEntry.Exception);
}
}
Transfer transfer = this.CreateTransfer(entry);
lock (this.lockEnumerateContinuationToken)
{
this.subTransfers.AddTransfer(transfer);
this.enumerateContinuationToken = new SerializableListContinuationToken(entry.ContinuationToken);
}
yield return(transfer);
}
}
private void CanceledItemFromList(TransferEntry entry)
{
entry.Remaining.Text = "";
entry.Message.Text = "Canceled";
//entry.Item.BackColor = Color.SeaShell;
entry.Item.SubItems[(int)ColumnIndex.Progress].Control = entry.Message;
this.Invalidate();
}
protected override SingleObjectTransfer CreateTransfer(TransferEntry entry)
{
TransferLocation sourceLocation = GetSourceTransferLocation(this.Source, entry);
TransferLocation destLocation = GetDestinationTransferLocation(this.Destination, entry);
SingleObjectTransfer transfer = new SingleObjectTransfer(sourceLocation, destLocation, this.TransferMethod);
transfer.Context = this.Context;
return(transfer);
}
public void TransferStarted(object sender, TransferFileProgressArgs args)
{
string key = args.FilePath;
TransferEntry entry = new TransferEntry(args);
Debug.Assert(entry.Data.State == TransferState.STARTED);
AddItemToList(entry);
OnChangedTransferState(entry);
}
private void ListNewTransfers(CancellationToken cancellationToken)
{
// list new transfers
if (this.enumerateContinuationToken != null)
{
this.SourceEnumerator.EnumerateContinuationToken = this.enumerateContinuationToken.ListContinuationToken;
}
ShouldTransferCallbackAsync shouldTransferCallback = this.DirectoryContext?.ShouldTransferCallbackAsync;
try
{
var enumerator = this.SourceEnumerator.EnumerateLocation(cancellationToken).GetEnumerator();
while (true)
{
Utils.CheckCancellation(cancellationToken);
if (!enumerator.MoveNext())
{
break;
}
TransferEntry entry = enumerator.Current;
ErrorEntry errorEntry = entry as ErrorEntry;
if (errorEntry != null)
{
TransferException exception = errorEntry.Exception as TransferException;
if (null != exception)
{
throw exception;
}
else
{
throw new TransferException(
TransferErrorCode.FailToEnumerateDirectory,
errorEntry.Exception.GetExceptionMessage(),
errorEntry.Exception);
}
}
this.shouldTransferQueue.EnqueueJob(async() =>
{
SingleObjectTransfer candidate = this.CreateTransfer(entry);
bool shouldTransfer = shouldTransferCallback == null || await shouldTransferCallback(candidate.Source.Instance, candidate.Destination.Instance);
return(new Tuple <SingleObjectTransfer, TransferEntry>(shouldTransfer ? candidate : null, entry));
});
}
}
finally
{
this.shouldTransferQueue.CompleteAdding();
}
}
internal SingleObjectTransfer CreateTransfer(TransferEntry entry)
{
TransferLocation sourceLocation = GetSourceTransferLocation(this.Source, entry);
sourceLocation.IsInstanceInfoFetched = true;
TransferLocation destLocation = GetDestinationTransferLocation(this.Destination, entry);
var transferMethod = IsDummyCopy(entry) ? TransferMethod.DummyCopy : this.TransferMethod;
SingleObjectTransfer transfer = new SingleObjectTransfer(sourceLocation, destLocation, transferMethod);
transfer.Context = this.Context;
return(transfer);
}
private bool IsDummyCopy(TransferEntry entry)
{
if (this.Source.Type == TransferLocationType.AzureBlobDirectory &&
this.Destination.Type == TransferLocationType.LocalDirectory)
{
if (IsDirectoryBlob((entry as AzureBlobEntry)?.Blob))
{
return(true);
}
}
return(false);
}
public void TransferCompleted(object sender, TransferFileProgressArgs args)
{
string key = args.FilePath;
TransferEntry entry = Transfers[key];
if (entry == null)
{
return;
}
Debug.Assert(entry.Data.State == TransferState.COMPLETED);
OnChangedTransferState(entry);
}
public void TransferCanceled(object sender, TransferFileProgressArgs args)
{
string key = args.FilePath;
TransferEntry entry = Transfers[key];
if (entry == null)
{
return;
}
Debug.Assert(entry.Data.State == TransferState.CANCELED);
entry.Exception = args.Exception;
OnChangedTransferState(entry);
}
public void TransferProgress(object sender, TransferFileProgressArgs args)
{
string key = args.FilePath;
TransferEntry entry = Transfers[key];
if (entry == null)
{
return;
}
Debug.Assert(entry.Data.State == TransferState.TRANSFERRING);
//entry.Remaining.Text = FileSizeToString(entry.Data.TotalBytes - entry.Data.TransferredBytes);
OnChangedTransferState(entry);
}
private void OnChangedTransferState(TransferEntry entry)
{
switch (entry.Data.State)
{
case TransferState.CANCELED:
CanceledItemFromList(entry);
break;
case TransferState.FAILED:
FailedItemFromList(entry);
break;
case TransferState.COMPLETED:
RemoveItemFromList(entry);
break;
}
}
private void AddItemToList(TransferEntry entry)
{
// Add to our fast-lookup collection.
Transfers.Add(entry);
// Add to UI.
GLItem item = this.Items.Add("");
item.Tag = entry;
item.SubItems[(int)ColumnIndex.Path].Control = entry.Path;
item.SubItems[(int)ColumnIndex.Remaining].Control = entry.Remaining;
item.SubItems[(int)ColumnIndex.Progress].Control = entry.Progress;
entry.Item = item;
// Invalidation is required in order to immediately display the control.
this.Invalidate();
}
private void FailedItemFromList(TransferEntry entry)
{
entry.Remaining.Text = "";
entry.Message.Text = "Failed";
entry.Item.BackColor = Color.SeaShell;
entry.Item.SubItems[(int)ColumnIndex.Progress].Control = entry.Message;
this.Invalidate();
if (entry.Tooltip == null)
{
entry.Tooltip = new ToolTip();
entry.Tooltip.AutoPopDelay = 5000;
entry.Tooltip.InitialDelay = 100;
entry.Tooltip.ReshowDelay = 100;
entry.Tooltip.ToolTipIcon = ToolTipIcon.Error;
entry.Tooltip.ToolTipTitle = "Transfer failed";
}
entry.Tooltip.SetToolTip(entry.Message, entry.Exception.Message);
}
private TransferLocation GetDestinationTransferLocation(TransferLocation dirLocation, TransferEntry entry)
{
string destRelativePath = this.nameResolver.ResolveName(entry);
switch (dirLocation.Type)
{
case TransferLocationType.AzureBlobDirectory:
{
AzureBlobDirectoryLocation blobDirLocation = dirLocation as AzureBlobDirectoryLocation;
BlobType destBlobType = this.BlobType;
AzureBlobEntry sourceBlobEntry = entry as AzureBlobEntry;
if (sourceBlobEntry != null)
{
// if source is Azure blob storage, source and destination blob share the same blob type
destBlobType = sourceBlobEntry.Blob.BlobType;
}
CloudBlob blob = null;
switch (destBlobType)
{
case Blob.BlobType.BlockBlob:
case Blob.BlobType.Unspecified:
blob = blobDirLocation.BlobDirectory.GetBlockBlobReference(destRelativePath);
break;
case Blob.BlobType.PageBlob:
blob = blobDirLocation.BlobDirectory.GetPageBlobReference(destRelativePath);
break;
case Blob.BlobType.AppendBlob:
blob = blobDirLocation.BlobDirectory.GetAppendBlobReference(destRelativePath);
break;
}
AzureBlobLocation retLocation = new AzureBlobLocation(blob);
retLocation.BlobRequestOptions = blobDirLocation.BlobRequestOptions;
return(retLocation);
}
case TransferLocationType.AzureFileDirectory:
{
AzureFileDirectoryLocation fileDirLocation = dirLocation as AzureFileDirectoryLocation;
CloudFile file = fileDirLocation.FileDirectory.GetFileReference(destRelativePath);
CreateParentDirectoryIfNotExists(file);
AzureFileLocation retLocation = new AzureFileLocation(file);
retLocation.FileRequestOptions = fileDirLocation.FileRequestOptions;
return(retLocation);
}
case TransferLocationType.LocalDirectory:
{
DirectoryLocation localDirLocation = dirLocation as DirectoryLocation;
string path = Path.Combine(localDirLocation.DirectoryPath, destRelativePath);
CreateParentDirectoryIfNotExists(path);
return(new FileLocation(path));
}
default:
throw new ArgumentException("TransferLocationType");
}
}
private static TransferLocation GetSourceTransferLocation(TransferLocation dirLocation, TransferEntry entry)
{
switch (dirLocation.Type)
{
case TransferLocationType.AzureBlobDirectory:
AzureBlobDirectoryLocation azureBlobDirLocation = dirLocation as AzureBlobDirectoryLocation;
AzureBlobEntry azureBlobEntry = entry as AzureBlobEntry;
AzureBlobLocation azureBlobLocation = new AzureBlobLocation(azureBlobEntry.Blob);
azureBlobLocation.BlobRequestOptions = azureBlobDirLocation.BlobRequestOptions;
return(azureBlobLocation);
case TransferLocationType.AzureFileDirectory:
AzureFileDirectoryLocation azureFileDirLocation = dirLocation as AzureFileDirectoryLocation;
AzureFileEntry azureFileEntry = entry as AzureFileEntry;
AzureFileLocation azureFileLocation = new AzureFileLocation(azureFileEntry.File);
azureFileLocation.FileRequestOptions = azureFileDirLocation.FileRequestOptions;
return(azureFileLocation);
case TransferLocationType.LocalDirectory:
FileEntry fileEntry = entry as FileEntry;
return(new FileLocation(fileEntry.FullPath));
default:
throw new ArgumentException("TransferLocationType");
}
}
public string ResolveName(TransferEntry sourceEntry)
{
return(sourceEntry.RelativePath.Replace('\\', '/'));
}
private void RemoveItemFromList(TransferEntry entry)
{
this.Items.Remove(entry.Item);
this.Invalidate();
}
protected TransferLocation GetDestTransferLocationForEmptyDir(TransferLocation dirLocation, TransferEntry entry)
{
string destRelativePath = this.nameResolver.ResolveName(entry);
AzureBlobEntry sourceBlobEntry = entry as AzureBlobEntry;
switch (dirLocation.Type)
{
case TransferLocationType.AzureBlobDirectory:
{
return(null);
}
case TransferLocationType.AzureFileDirectory:
{
AzureFileDirectoryLocation fileDirLocation = dirLocation as AzureFileDirectoryLocation;
CloudFileDirectory destDirLocation = fileDirLocation.FileDirectory;
if (!string.IsNullOrEmpty(destRelativePath))
{
destDirLocation = destDirLocation.GetDirectoryReference(destRelativePath);
}
AzureFileDirectoryLocation retLocation = new AzureFileDirectoryLocation(destDirLocation);
retLocation.FileRequestOptions = fileDirLocation.FileRequestOptions;
return(retLocation);
}
case TransferLocationType.LocalDirectory:
{
return(null);
}
default:
throw new ArgumentException("TransferLocationType");
}
}
public string ResolveName(TransferEntry sourceEntry)
{
return(sourceEntry.RelativePath.TrimEnd(new char[] { ' ' }).Replace('\\', '/'));
}
public async Task ExecuteAsync(CancellationToken cancellationToken)
{
await Task.Yield();
this.CreateDestinationDirectory(cancellationToken);
var enumerator = this.transferEnumerator.EnumerateLocation(cancellationToken).GetEnumerator();
while (true)
{
if (!enumerator.MoveNext())
{
break;
}
TransferEntry entry = enumerator.Current;
ErrorEntry errorEntry = entry as ErrorEntry;
if (errorEntry != null)
{
TransferException exception = errorEntry.Exception as TransferException;
if (null != exception)
{
throw exception;
}
else
{
throw new TransferException(
TransferErrorCode.FailToEnumerateDirectory,
errorEntry.Exception.GetExceptionMessage(),
errorEntry.Exception);
}
}
if (entry.IsDirectory)
{
this.baseDirectoryTransfer.AddSubDir(entry.RelativePath, () =>
{
var currentContinuationToken = new SerializableListContinuationToken(entry.ContinuationToken);
currentContinuationToken.Journal = this.enumerateContinuationToken.Journal;
currentContinuationToken.StreamJournalOffset = this.enumerateContinuationToken.StreamJournalOffset;
this.enumerateContinuationToken = currentContinuationToken;
return(this.enumerateContinuationToken);
});
}
else
{
SingleObjectTransfer transferItem = this.baseDirectoryTransfer.CreateTransfer(entry);
#if DEBUG
Utils.HandleFaultInjection(entry.RelativePath, transferItem);
#endif
this.CreateDestinationParentDirectoryRecursively(transferItem);
this.baseDirectoryTransfer.AddSingleObjectTransfer(transferItem, () =>
{
var currentContinuationToken = new SerializableListContinuationToken(entry.ContinuationToken);
currentContinuationToken.Journal = this.enumerateContinuationToken.Journal;
currentContinuationToken.StreamJournalOffset = this.enumerateContinuationToken.StreamJournalOffset;
this.enumerateContinuationToken = currentContinuationToken;
return(this.enumerateContinuationToken);
});
}
}
}
protected TransferLocation GetDestinationSubDirTransferLocation(TransferLocation dirLocation, TransferEntry entry)
{
string destRelativePath = this.NameResolver.ResolveName(entry);
switch (dirLocation.Type)
{
case TransferLocationType.AzureBlobDirectory:
{
AzureBlobDirectoryLocation blobDirLocation = dirLocation as AzureBlobDirectoryLocation;
BlobType destBlobType = this.BlobType;
// TODO: should handle blob type here.
AzureBlobDirectoryLocation retLocation = new AzureBlobDirectoryLocation(blobDirLocation.BlobDirectory.GetDirectoryReference(destRelativePath));
retLocation.BlobRequestOptions = blobDirLocation.BlobRequestOptions;
return(retLocation);
}
case TransferLocationType.AzureFileDirectory:
{
AzureFileDirectoryLocation fileDirLocation = dirLocation as AzureFileDirectoryLocation;
CloudFileDirectory azureDirectory = fileDirLocation.FileDirectory.GetDirectoryReference(destRelativePath);
AzureFileDirectoryLocation retLocation = new AzureFileDirectoryLocation(azureDirectory);
retLocation.FileRequestOptions = fileDirLocation.FileRequestOptions;
return(retLocation);
}
case TransferLocationType.LocalDirectory:
{
DirectoryLocation localDirLocation = dirLocation as DirectoryLocation;
string path = LongPath.Combine(localDirLocation.DirectoryPath, destRelativePath);
return(new DirectoryLocation(path));
}
default:
throw new ArgumentException("TransferLocationType");
}
}
public string ResolveName(TransferEntry sourceEntry)
{
return sourceEntry.RelativePath.TrimEnd(new char[] {' '}).Replace('\\', '/');
}
protected abstract SingleObjectTransfer CreateTransfer(TransferEntry entry);
public string ResolveName(TransferEntry sourceEntry)
{
return sourceEntry.RelativePath.Replace('\\', '/');
}
private IEnumerable <SingleObjectTransfer> AllTransfers(CancellationToken cancellationToken)
{
if (null == this.Journal)
{
// return all existing transfers in subTransfers
foreach (var transfer in this.subTransfers.GetEnumerator())
{
Utils.CheckCancellation(cancellationToken);
transfer.Context = this.Context;
this.UpdateTransfer(transfer);
yield return(transfer as SingleObjectTransfer);
}
}
else
{
foreach (var transfer in this.Journal.ListSubTransfers())
{
Utils.CheckCancellation(cancellationToken);
transfer.Context = this.Context;
this.UpdateTransfer(transfer);
this.subTransfers.AddTransfer(transfer, false);
yield return(transfer);
}
}
while (true)
{
Utils.CheckCancellation(cancellationToken);
Tuple <SingleObjectTransfer, TransferEntry> pair;
try
{
pair = this.shouldTransferQueue.DequeueResult();
}
catch (InvalidOperationException)
{
// Task queue is empty and CompleteAdding. No more transfer to dequeue.
break;
}
catch (AggregateException aggregateException)
{
// Unwrap the AggregateException.
ExceptionDispatchInfo.Capture(aggregateException.Flatten().InnerExceptions[0]).Throw();
break;
}
SingleObjectTransfer transfer = pair.Item1;
TransferEntry entry = pair.Item2;
lock (this.lockEnumerateContinuationToken)
{
if (null != transfer)
{
this.subTransfers.AddTransfer(transfer);
}
this.enumerateContinuationToken = new SerializableListContinuationToken(entry.ContinuationToken);
}
if (null != transfer)
{
this.Journal?.AddSubtransfer(transfer);
}
this.Journal?.UpdateJournalItem(this);
if (null == transfer)
{
continue;
}
try
{
this.CreateParentDirectory(transfer);
}
catch (Exception ex)
{
transfer.OnTransferFailed(ex);
// Don't keep failed transfers in memory if they can be persisted to a journal.
if (null != this.Journal)
{
this.subTransfers.RemoveTransfer(transfer);
}
continue;
}
#if DEBUG
FaultInjectionPoint fip = new FaultInjectionPoint(FaultInjectionPoint.FIP_ThrowExceptionAfterEnumerated);
string fiValue;
string filePath = entry.RelativePath;
CloudBlob sourceBlob = transfer.Source.Instance as CloudBlob;
if (sourceBlob != null && sourceBlob.IsSnapshot)
{
filePath = Utils.AppendSnapShotTimeToFileName(filePath, sourceBlob.SnapshotTime);
}
if (fip.TryGetValue(out fiValue) &&
string.Equals(fiValue, filePath, StringComparison.OrdinalIgnoreCase))
{
throw new TransferException(TransferErrorCode.Unknown, "test exception thrown because of ThrowExceptionAfterEnumerated is enabled", null);
}
#endif
yield return(transfer);
}
}
private IEnumerable <SingleObjectTransfer> AllTransfers(CancellationToken cancellationToken)
{
if (null == this.Journal)
{
// return all existing transfers in subTransfers
foreach (var transfer in this.subTransfers.GetEnumerator())
{
Utils.CheckCancellation(cancellationToken);
transfer.Context = this.Context;
this.UpdateTransfer(transfer);
yield return(transfer as SingleObjectTransfer);
}
}
else
{
foreach (var transfer in this.Journal.ListSubTransfers())
{
Utils.CheckCancellation(cancellationToken);
transfer.Context = this.Context;
this.UpdateTransfer(transfer);
this.subTransfers.AddTransfer(transfer, false);
yield return(transfer);
}
}
while (true)
{
Utils.CheckCancellation(cancellationToken);
Tuple <SingleObjectTransfer, TransferEntry> pair;
try
{
pair = this.shouldTransferQueue.DequeueResult();
}
catch (InvalidOperationException)
{
// Task queue is empty and CompleteAdding. No more transfer to dequeue.
break;
}
catch (AggregateException aggregateException)
{
// Unwrap the AggregateException.
ExceptionDispatchInfo.Capture(aggregateException.Flatten().InnerExceptions[0]).Throw();
break;
}
SingleObjectTransfer transfer = pair.Item1;
TransferEntry entry = pair.Item2;
lock (this.lockEnumerateContinuationToken)
{
if (null != transfer)
{
this.subTransfers.AddTransfer(transfer);
}
this.enumerateContinuationToken = new SerializableListContinuationToken(entry.ContinuationToken);
}
if (null != transfer)
{
this.Journal?.AddSubtransfer(transfer);
}
this.Journal?.UpdateJournalItem(this);
if (null == transfer)
{
continue;
}
try
{
this.CreateParentDirectory(transfer);
}
catch (Exception ex)
{
transfer.OnTransferFailed(ex);
// Don't keep failed transfers in memory if they can be persisted to a journal.
if (null != this.Journal)
{
this.subTransfers.RemoveTransfer(transfer);
}
continue;
}
#if DEBUG
Utils.HandleFaultInjection(entry.RelativePath, transfer);
#endif
yield return(transfer);
}
}
