PathEnumeratorBase
using Relativity.Transfer.Resources;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Relativity.Transfer
{
[Obsolete("This enumeration support will be removed in next release. In order to perform file enumeration use EnumerationBuilder and IEnumerationOrchestrator")]
public abstract class PathEnumeratorBase : IPathEnumerator
{
private readonly IPathValidationProvider pathValidationProvider;
protected ITransferLog Log { get; }
protected IFileSystemService FileSystemService { get; }
internal PathEnumeratorBase(ITransferLog log, IPathValidationProvider pathValidationProvider, IFileSystemService fileSystemService)
{
if (log == null)
throw new ArgumentNullException("log");
if (pathValidationProvider == null)
throw new ArgumentNullException("pathValidationProvider");
if (fileSystemService == null)
throw new ArgumentNullException("fileSystemService");
Log = log;
FileSystemService = fileSystemService;
this.pathValidationProvider = pathValidationProvider;
}
public virtual Task<EnumeratedPathsResult> EnumerateAsync(PathEnumeratorContext context)
{
return EnumerateAsync(context, CancellationToken.None);
}
[AsyncStateMachine(typeof(<EnumerateAsync>d__9))]
public virtual Task<EnumeratedPathsResult> EnumerateAsync(PathEnumeratorContext context, CancellationToken token)
{
<EnumerateAsync>d__9 stateMachine = default(<EnumerateAsync>d__9);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<EnumeratedPathsResult>.Create();
stateMachine.<>4__this = this;
stateMachine.context = context;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public virtual Task<SerializedPathsResult> SerializeAsync(string batchDirectory, PathEnumeratorContext context)
{
return SerializeAsync(batchDirectory, context, CancellationToken.None);
}
[AsyncStateMachine(typeof(<SerializeAsync>d__11))]
public Task<SerializedPathsResult> SerializeAsync(string batchDirectory, PathEnumeratorContext context, CancellationToken token)
{
<SerializeAsync>d__11 stateMachine = default(<SerializeAsync>d__11);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<SerializedPathsResult>.Create();
stateMachine.<>4__this = this;
stateMachine.batchDirectory = batchDirectory;
stateMachine.context = context;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
protected virtual int GetMaxDegreeOfFileParallelism(PathEnumeratorContext context)
{
if (context == null)
throw new ArgumentNullException("context");
return Math.Min(context.MaxDegreeOfFileParallelism, 8);
}
protected virtual int GetMaxDegreeOfDirectoryParallelism(PathEnumeratorContext context)
{
if (context == null)
throw new ArgumentNullException("context");
return Math.Min(context.MaxDegreeOfDirectoryParallelism, 8);
}
protected virtual void OnInitialize(PathEnumeratorContext context, CancellationToken token)
{
}
protected abstract Task<bool> OnCheckFileExistsAsync(string path, CancellationToken token);
protected abstract Task<bool> OnCheckFolderExistsAsync(string path, CancellationToken token);
protected abstract Task<bool> OnCheckIsEmptyAsync(string path, CancellationToken token);
protected abstract Task<IEnumerable<FileItem>> OnEnumerateFilesAsync(string path, PathEnumeratorContext context, CancellationToken token);
protected abstract Task<IEnumerable<FolderItem>> OnEnumerateFoldersAsync(string path, PathEnumeratorContext context, CancellationToken token);
protected abstract Task<FileItem> OnGetFileItemAsync(string path, CancellationToken token);
protected abstract Task<FolderItem> OnGetFolderItemAsync(string path, CancellationToken token);
protected virtual string GetLocalPath(string path)
{
return path;
}
private static StringBuilder BuildTargetPath(string targetPath, string searchPathFolder, string subDirectory, bool isTargetPathUnix)
{
StringBuilder stringBuilder = new StringBuilder(targetPath);
if (stringBuilder.Length > 0) {
if (!string.IsNullOrEmpty(searchPathFolder)) {
stringBuilder.Append("\\");
stringBuilder.Append(searchPathFolder);
}
if (!string.IsNullOrEmpty(subDirectory)) {
stringBuilder.Append("\\");
stringBuilder.Append(subDirectory);
}
if (isTargetPathUnix)
stringBuilder.Replace("\\", "/");
else
stringBuilder.Replace("/", "\\");
}
return stringBuilder;
}
private static TransferPath CreateTransferPath(string searchPath, PathEnumeratorContext context, string searchPathFolder, FileItem fileItem, bool isParentedDirectorySearch, ITransferLog logger)
{
if (string.IsNullOrEmpty(fileItem.FullName)) {
logger.LogError(CoreStrings.FileInfoInvalidExceptionMessage, fileItem.Name, LogRedaction.OnPositions(default(int)));
throw new ArgumentException("Invalid file info - check logs for more details.", "fileItem");
}
if (!context.PreserveFolders)
return new TransferPath(fileItem.FullName, TransferPathAttributes.File, context.TargetPath, TransferDirection.Upload, fileItem.Name, fileItem.Length);
string subDirectory = null;
if (isParentedDirectorySearch) {
subDirectory = ((!string.IsNullOrEmpty(fileItem.FolderName)) ? fileItem.FolderName.Replace(searchPath, string.Empty) : string.Empty);
subDirectory = PathHelper.TrimLeadingSlash(subDirectory);
}
string targetPath = BuildTargetPath(context.TargetPath, searchPathFolder, subDirectory, context.IsTargetPathUnix).ToString();
return new TransferPath(fileItem.FullName, TransferPathAttributes.File, targetPath, TransferDirection.Upload, fileItem.Name, fileItem.Length);
}
private void AddTransferPathForEmptyDirectory(string searchPath, PathEnumeratorContext context, PathSearchStorage storage, string searchPathFolder, FolderItem folderItem, bool isParentedDirectorySearch)
{
string targetPath = GetTargetPath(searchPath, context, searchPathFolder, folderItem, isParentedDirectorySearch);
TransferPath transferPath = new TransferPath(folderItem.FullName, TransferPathAttributes.Directory | TransferPathAttributes.Empty, targetPath, TransferDirection.Upload);
PathValidationResult validationResult = pathValidationProvider.Validate(transferPath);
storage.Add(transferPath, validationResult);
}
private static string GetTargetPath(string searchPath, PathEnumeratorContext context, string searchPathFolder, FolderItem folderItem, bool isParentedDirectorySearch)
{
if (context.PreserveFolders) {
string subDirectory = null;
if (isParentedDirectorySearch) {
subDirectory = ((!string.IsNullOrEmpty(folderItem.Parent)) ? folderItem.Parent.Replace(searchPath, string.Empty) : string.Empty);
subDirectory = PathHelper.TrimLeadingSlash(subDirectory);
}
return BuildTargetPath(context.TargetPath, searchPathFolder, subDirectory, context.IsTargetPathUnix).ToString();
}
return context.TargetPath;
}
private void RegisterPathError(PathEnumeratorContext context, PathSearchStorage storage, string path, Exception exception)
{
Log.LogWarning(exception, "A path enumeration failure occurred.", Array.Empty<object>());
storage.PathErrors.Add(new ErrorPath(path, exception.Message));
context.PublishProgress(false, storage);
}
[AsyncStateMachine(typeof(<EnumerateTransferPaths>d__28))]
private Task EnumerateTransferPaths(string searchPath, PathEnumeratorContext context, PathSearchStorage storage, CancellationToken token)
{
<EnumerateTransferPaths>d__28 stateMachine = default(<EnumerateTransferPaths>d__28);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.searchPath = searchPath;
stateMachine.context = context;
stateMachine.storage = storage;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
}
}