EnumerationBuilder
public sealed class EnumerationBuilder : IEnumerationFinalActionsBuilder, IEnumerationNecessaryActionsBuilder
using Relativity.DataTransfer.Nodes;
using Relativity.Transfer.Enumeration.Batches;
using Relativity.Transfer.Enumeration.Filters;
using Relativity.Transfer.Enumeration.Interfaces;
using Relativity.Transfer.Enumeration.Native;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Relativity.Transfer.Enumeration
{
public sealed class EnumerationBuilder : IEnumerationFinalActionsBuilder, IEnumerationNecessaryActionsBuilder
{
private static ITransferLog _logger;
private static readonly INativeMethods _nativeMethods = NativeMethodsFactory.Create();
private static IEnumeratorProvider _initialEnumerator;
private static TransferDirection _transferDirection = TransferDirection.None;
private INode _rootNode;
private IEnumerable<INode> _sourceNodes;
private IEnumerable<INodeFilter> _filters;
private IEnumerationHandler<EnumerationIssue> _skippedItemHandler;
private IEnumerationHandler<EnumerationStatistic> _statisticsHandler;
private IEnumerationHandler<SerializedBatch> _batchCreatedHandler;
private BatchingParameters _batchingParameters;
private EnumerationBuilder()
{
}
public static IEnumerationNecessaryActionsBuilder ForUpload(ITransferLog logger, Guid correlationId)
{
return ForUpload(new ParallelEnumerator(new NodeEnumerableFactory(new CachedNodeFactory(), _nativeMethods, logger), logger), logger, correlationId);
}
public static IEnumerationNecessaryActionsBuilder ForUpload(IEnumeratorProvider enumerator, ITransferLog logger, Guid correlationId)
{
Assertions.RequireNonNull(enumerator, "enumerator");
_initialEnumerator = enumerator;
_transferDirection = TransferDirection.Upload;
_logger = new EnumerationLog(logger, correlationId);
_logger.LogInformation("Enumeration builder for {TransferDirection} operation initialized.", _transferDirection);
return new EnumerationBuilder();
}
public static IEnumerationNecessaryActionsBuilder ForDownload(IEnumeratorProvider enumerator, ITransferLog logger, Guid correlationId)
{
Assertions.RequireNonNull(enumerator, "enumerator");
_initialEnumerator = enumerator;
_transferDirection = TransferDirection.Download;
_logger = new EnumerationLog(logger, correlationId);
_logger.LogInformation("Enumeration builder for {TransferDirection} operation initialized.", _transferDirection);
return new EnumerationBuilder();
}
public IEnumerationFinalActionsBuilder StartFrom(IEnumerable<INode> nodesOfSameParent)
{
ValidateSourceNodes(nodesOfSameParent);
_sourceNodes = nodesOfSameParent;
INode parentOfFirst = nodesOfSameParent.First().Parent;
if (nodesOfSameParent.Any((INode node) => !node.Parent.Equals(parentOfFirst)))
throw new ArgumentException("Source nodes should come from a single directory", "nodesOfSameParent");
_rootNode = parentOfFirst;
return this;
}
public IEnumerationFinalActionsBuilder StartFrom(IEnumerable<INode> nodesUnderRootNode, INode rootNode)
{
ValidateSourceNodes(nodesUnderRootNode);
_sourceNodes = nodesUnderRootNode;
Assertions.RequireNonNull(rootNode, "rootNode");
_rootNode = rootNode;
return this;
}
public IEnumerationFinalActionsBuilder WithFilters(IEnumerable<INodeFilter> filters, IEnumerationHandler<EnumerationIssue> skippedItemHandler)
{
Assertions.RequireNonNull(filters, "filters");
Assertions.RequireNonNull(skippedItemHandler, "skippedItemHandler");
_filters = filters;
_skippedItemHandler = skippedItemHandler;
string text = string.Join(", ", from x in filters
select x.GetType().ToString());
_logger.LogInformation("Enumeration enriched with following filters: {FilterNames}.", text);
return this;
}
public IEnumerationFinalActionsBuilder WithStatistics(IEnumerationHandler<EnumerationStatistic> statisticsHandler)
{
Assertions.RequireNonNull(statisticsHandler, "statisticsHandler");
_statisticsHandler = statisticsHandler;
_logger.LogInformation("Enumeration enriched with statistic handler.", Array.Empty<object>());
return this;
}
public IEnumerationFinalActionsBuilder WithBatching(INode destinationNode, IDirectory batchSerializationDirectory, IEnumerationHandler<SerializedBatch> batchCreatedHandler)
{
Assertions.RequireNonNull(_rootNode, "_rootNode");
Assertions.RequireNonNull(_sourceNodes, "_sourceNodes");
Assertions.RequireNonNull(destinationNode, "destinationNode");
Assertions.RequireNonNull(batchSerializationDirectory, "batchSerializationDirectory");
Assertions.RequireNonNull(batchCreatedHandler, "batchCreatedHandler");
_batchingParameters = new BatchingParameters(_rootNode, destinationNode, batchSerializationDirectory, _transferDirection);
_batchCreatedHandler = batchCreatedHandler;
_logger.LogInformation("Batching requested. Source: {Source}, destination: {Destination}, batchDirectory: {BatchDirectory}.", _rootNode.Name, destinationNode.Name, batchSerializationDirectory.Name, LogRedaction.OnPositions(0, 1));
return this;
}
public IEnumerationOrchestrator Create()
{
IEnumeratorProvider enumeratorProvider = _initialEnumerator;
if (_skippedItemHandler != null)
enumeratorProvider = new EnumerationWithFilters(enumeratorProvider, _filters, _skippedItemHandler);
if (_statisticsHandler != null)
enumeratorProvider = new EnumerationWithStatistics(enumeratorProvider, _statisticsHandler);
if (_batchingParameters != null && _batchCreatedHandler != null) {
BatchAggregator batchCreationStrategy = new BatchAggregator(_batchingParameters, _batchCreatedHandler, _logger, new JsonFileSerializer());
enumeratorProvider = new EnumerationWithBatches(enumeratorProvider, batchCreationStrategy, _logger);
}
return new EnumerationOrchestrator(enumeratorProvider, _sourceNodes);
}
private void ValidateSourceNodes(IEnumerable<INode> sourceNodes)
{
Assertions.RequireNonNull(sourceNodes, "sourceNodes");
if (sourceNodes.FirstOrDefault() == null)
throw new ArgumentException("There need to be at least 1 source node to enumerate", "sourceNodes");
}
}
}