protected static TransferLocation GetSourceDirectoryTransferLocation(TransferLocation dirLocation, string relativePath)
{
if (dirLocation.Type == TransferLocationType.AzureFileDirectory)
{
AzureFileDirectoryLocation azureFileDirLocation = dirLocation as AzureFileDirectoryLocation;
var destDirectory = azureFileDirLocation.FileDirectory.GetDirectoryReference(relativePath);
AzureFileDirectoryLocation azureFileLocation = new AzureFileDirectoryLocation(destDirectory);
azureFileLocation.FileRequestOptions = azureFileDirLocation.FileRequestOptions;
return(azureFileLocation);
}
else if (dirLocation.Type == TransferLocationType.LocalDirectory)
{
DirectoryLocation localDirLocation = dirLocation as DirectoryLocation;
var destDirectory = Path.Combine(localDirLocation.DirectoryPath, relativePath);
DirectoryLocation localSubDirLocation = new DirectoryLocation(destDirectory);
return(localSubDirLocation);
}
else
{
// For now, HierarchyDirectoryTransfer should only be used when source is Azure File Directory.
throw new ArgumentException("TransferLocationType");
}
}
protected 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, fileEntry.RelativePath));
default:
throw new ArgumentException("TransferLocationType");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Transfer"/> class.
/// </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 Transfer(TransferLocation source, TransferLocation dest, TransferMethod transferMethod)
{
this.Source = source;
this.Destination = dest;
this.TransferMethod = transferMethod;
this.ProgressTracker = new TransferProgressTracker();
this.OriginalFormatVersion = Constants.FormatVersion;
}
// Summary:
// Determines whether the specified transfer location is equal to the current transfer location.
//
// Parameters:
// obj:
// The transfer location to compare with the current transfer location.
//
// Returns:
// true if the specified transfer location is equal to the current transfer location; otherwise, false.
public override bool Equals(object obj)
{
TransferLocation location = obj as TransferLocation;
if (location == null || this.Type != location.Type)
{
return(false);
}
return(this.ToString() == location.ToString());
}
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 static void UpdateCredentials(TransferLocation dirLocation, TransferLocation subLocation)
{
if (dirLocation.Type == TransferLocationType.AzureBlobDirectory)
{
AzureBlobDirectoryLocation blobDirectoryLocation = dirLocation as AzureBlobDirectoryLocation;
(subLocation as AzureBlobLocation).UpdateCredentials(blobDirectoryLocation.BlobDirectory.ServiceClient.Credentials);
}
else if (dirLocation.Type == TransferLocationType.AzureFileDirectory)
{
AzureFileDirectoryLocation fileDirectoryLocation = dirLocation as AzureFileDirectoryLocation;
(subLocation as AzureFileLocation).UpdateCredentials(fileDirectoryLocation.FileDirectory.ServiceClient.Credentials);
}
}
private static INameResolver GetNameResolver(TransferLocation sourceLocation, TransferLocation destLocation, char?delimiter)
{
Debug.Assert(sourceLocation != null, "sourceLocation");
Debug.Assert(destLocation != null, "destLocation");
switch (sourceLocation.Type)
{
case TransferLocationType.AzureBlobDirectory:
if (destLocation.Type == TransferLocationType.AzureBlobDirectory)
{
return(new AzureBlobToAzureBlobNameResolver());
}
else if (destLocation.Type == TransferLocationType.AzureFileDirectory)
{
return(new AzureBlobToAzureFileNameResolver(delimiter));
}
else if (destLocation.Type == TransferLocationType.LocalDirectory)
{
return(new AzureToFileNameResolver(delimiter));
}
break;
case TransferLocationType.AzureFileDirectory:
if (destLocation.Type == TransferLocationType.AzureBlobDirectory ||
destLocation.Type == TransferLocationType.AzureFileDirectory)
{
return(new AzureFileToAzureNameResolver());
}
else if (destLocation.Type == TransferLocationType.LocalDirectory)
{
return(new AzureToFileNameResolver(null));
}
break;
case TransferLocationType.LocalDirectory:
if (destLocation.Type == TransferLocationType.AzureBlobDirectory)
{
return(new FileToAzureBlobNameResolver());
}
else if (destLocation.Type == TransferLocationType.AzureFileDirectory)
{
return(new FileToAzureFileNameResolver());
}
break;
default:
throw new ArgumentException("Unsupported source location", "sourceLocation");
}
throw new ArgumentException("Unsupported destination location", "destLocation");
}
/// <summary>
/// Gets a transfer with the specified source location, destination location and transfer method.
/// </summary>
/// <param name="sourceLocation">Source location of the transfer.</param>
/// <param name="destLocation">Destination location of the transfer.</param>
/// <param name="transferMethod">Transfer method.</param>
/// <returns>A transfer that matches the specified source location, destination location and transfer method; Or null if no matches.</returns>
public Transfer GetTransfer(TransferLocation sourceLocation, TransferLocation destLocation, TransferMethod transferMethod)
{
Transfer transfer = null;
if (this.transfers.TryGetValue(new TransferKey(sourceLocation, destLocation), out transfer))
{
if (transfer.TransferMethod == transferMethod)
{
return(transfer);
}
}
return(null);
}
internal void GetSubDirLocation(string relativePath, out TransferLocation sourceLocation, out TransferLocation destLocation)
{
if (string.IsNullOrEmpty(relativePath))
{
sourceLocation = this.Source;
destLocation = this.Destination;
return;
}
else
{
var transferEntry = CreateDirectoryTransferEntry(relativePath);
sourceLocation = GetSourceDirectoryTransferLocation(this.Source, relativePath);
destLocation = GetDestinationSubDirTransferLocation(this.Destination, transferEntry);
}
}
/// <summary>
/// Creates the default request options for specific location.
/// </summary>
/// <param name="location">The location <see cref="TransferLocation"/> which needs get a default request options.</param>
/// <returns>The default request options which implements <see cref="IRequestOptions"/> for specific location.</returns>
internal static IRequestOptions CreateDefaultRequestOptions(TransferLocation location)
{
if (null == location)
{
throw new ArgumentNullException(nameof(location));
}
IRequestOptions requestOptions;
switch (location.Type)
{
case TransferLocationType.AzureBlob:
requestOptions = ((AzureBlobLocation)location).Blob.Uri.Scheme == Uri.UriSchemeHttps
? DefaultHttpsBlobRequestOptions
: DefaultBlobRequestOptions;
break;
case TransferLocationType.AzureBlobDirectory:
requestOptions = ((AzureBlobDirectoryLocation)location).BlobDirectory.Uri.Scheme == Uri.UriSchemeHttps
? DefaultHttpsBlobRequestOptions
: DefaultBlobRequestOptions;
break;
case TransferLocationType.AzureFile:
requestOptions = ((AzureFileLocation)location).AzureFile.Uri.Scheme == Uri.UriSchemeHttps
? DefaultHttpsFileRequestOptions
: DefaultFileRequestOptions;
break;
case TransferLocationType.AzureFileDirectory:
requestOptions = ((AzureFileDirectoryLocation)location).FileDirectory.Uri.Scheme == Uri.UriSchemeHttps
? DefaultHttpsFileRequestOptions
: DefaultFileRequestOptions;
break;
default:
throw new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
"{0} is invalid, cannot get IRequestOptions for location type {1}",
nameof(location),
location.Type));
}
return(requestOptions);
}
/// <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.SnapshotQualifiedUri.Host, destFile.SnapshotQualifiedUri.Host, StringComparison.OrdinalIgnoreCase) &&
string.Equals(sourceFile.SnapshotQualifiedUri.PathAndQuery, destFile.SnapshotQualifiedUri.PathAndQuery, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException(Resources.SourceAndDestinationLocationCannotBeEqualException);
}
}
this.transferJob = new TransferJob(this);
}
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");
}
}
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");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MultipleObjectsTransfer"/> class.
/// </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 MultipleObjectsTransfer(TransferLocation source, TransferLocation dest, TransferMethod transferMethod)
: base(source, dest, transferMethod)
{
this.subTransfers = new TransferCollection <SingleObjectTransfer>();
this.subTransfers.OverallProgressTracker.Parent = this.ProgressTracker;
}
public SerializableTransferLocation(TransferLocation location)
{
this.Location = location;
}
/// <summary>
/// Gets a transfer with the specified source location, destination location and transfer method.
/// </summary>
/// <param name="sourceLocation">Source location of the transfer.</param>
/// <param name="destLocation">Destination location of the transfer.</param>
/// <param name="transferMethod">Transfer method.</param>
/// <returns>A transfer that matches the specified source location, destination location and transfer method; Or null if no matches.</returns>
internal Transfer GetTransfer(TransferLocation sourceLocation, TransferLocation destLocation, TransferMethod transferMethod)
{
return(this.TransferCollection.GetTransfer(sourceLocation, destLocation, transferMethod));
}
protected TransferLocation GetDestinationTransferLocation(TransferLocation dirLocation, TransferEntry entry)
{
string destRelativePath = this.nameResolver.ResolveName(entry);
AzureBlobEntry sourceBlobEntry = entry as AzureBlobEntry;
switch (dirLocation.Type)
{
case TransferLocationType.AzureBlobDirectory:
{
AzureBlobDirectoryLocation blobDirLocation = dirLocation as AzureBlobDirectoryLocation;
BlobType destBlobType = this.BlobType;
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);
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);
return(new FileLocation(path, destRelativePath));
}
default:
throw new ArgumentException("TransferLocationType");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DirectoryTransfer"/> class.
/// </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 DirectoryTransfer(TransferLocation source, TransferLocation dest, TransferMethod transferMethod)
: base(source, dest, transferMethod)
{
}
