public async Task TransferAsync(string sourceName, object sourceConfiguration,
string sinkName, object sinkConfiguration, ITransferStatistics statistics, CancellationToken cancellation)
{
IDataSourceAdapterFactoryAdapter sourceFactoryAdapter;
if (!sources.TryGetValue(sourceName, out sourceFactoryAdapter))
throw Errors.UnknownDataSource(sourceName);
IDataSinkAdapterFactoryAdapter sinkFactoryAdapter;
if (!sinks.TryGetValue(sinkName, out sinkFactoryAdapter))
throw Errors.UnknownDataSink(sinkName);
var context = new DataTransferContext
{
SourceName = sourceName,
SinkName = sinkName
};
try
{
// Lets start timer now, since factories may take some time as well and we want to capture that
statistics.Start();
var source = sourceFactoryAdapter.CreateAsync(sourceConfiguration, context, cancellation);
var sink = sinkFactoryAdapter.CreateAsync(sinkConfiguration, context, cancellation);
using (var sourceInstance = await source)
using (var sinkInstance = await sink)
await transferAction.ExecuteAsync(sourceInstance, sinkInstance, statistics, cancellation);
}
finally
{
statistics.Stop();
}
}
public async Task TransferAsync(string sourceName, object sourceConfiguration,
string sinkName, object sinkConfiguration, ITransferStatistics statistics, CancellationToken cancellation)
{
IDataSourceAdapterFactoryAdapter sourceFactoryAdapter;
if (!sources.TryGetValue(sourceName, out sourceFactoryAdapter))
{
throw Errors.UnknownDataSource(sourceName);
}
IDataSinkAdapterFactoryAdapter sinkFactoryAdapter;
if (!sinks.TryGetValue(sinkName, out sinkFactoryAdapter))
{
throw Errors.UnknownDataSink(sinkName);
}
var context = new DataTransferContext
{
SourceName = sourceName,
SinkName = sinkName
};
// Lets start timer now, since factories may take some time as well and we want to capture that
statistics.Start();
var source = sourceFactoryAdapter.CreateAsync(sourceConfiguration, context);
var sink = sinkFactoryAdapter.CreateAsync(sinkConfiguration, context);
using (var sourceInstance = await source)
using (var sinkInstance = await sink)
await transferAction.ExecuteAsync(sourceInstance, sinkInstance, statistics, cancellation);
}
public async Task ExecuteAsync(IDataSourceAdapter source, IDataSinkAdapter sink, ITransferStatistics statistics, CancellationToken cancellation)
{
Guard.NotNull("source", source);
Guard.NotNull("sink", sink);
Guard.NotNull("statistics", statistics);
var writeTasks = Enumerable
.Range(0, sink.MaxDegreeOfParallelism)
.Select(i => (Task)Task.FromResult<object>(null))
.ToArray();
var fatalExceptions = new List<Exception>();
var readOutput = new ReadOutputByRef();
IDataItem dataItem;
while (!cancellation.IsCancellationRequested)
{
readOutput.Wipe();
try
{
dataItem = await source.ReadNextAsync(readOutput, cancellation);
}
catch (NonFatalReadException nonFatalException)
{
statistics.AddError(readOutput.DataItemId, nonFatalException);
continue;
}
catch (Exception exception)
{
fatalExceptions.Add(exception);
break;
}
if (dataItem == null || cancellation.IsCancellationRequested)
break;
var completed = await Task.WhenAny(writeTasks);
writeTasks[Array.IndexOf(writeTasks, completed)] =
TransferDataItem(sink, readOutput.DataItemId, dataItem, statistics, cancellation);
}
// Report completion to the sink
try
{
await sink.CompleteAsync(cancellation);
}
catch (Exception exception)
{
fatalExceptions.Add(exception);
}
// Wait for all on-going writes to complete
for (var index = 0; index < writeTasks.Length; ++index)
await writeTasks[index];
// Throw fatal exceptions, if any
if (fatalExceptions.Any())
throw new AggregateException(fatalExceptions);
}
public async Task <TransferResult> RunAsync()
{
ValidateConfiguration();
IDataAdapterDefinition sourceDefinition;
if (!transferService.GetKnownSources().TryGetValue(configuration.SourceName, out sourceDefinition))
{
throw Errors.UnknownSource(configuration.SourceName);
}
IDataAdapterDefinition sinkDefinition;
if (!transferService.GetKnownSinks().TryGetValue(configuration.TargetName, out sinkDefinition))
{
throw Errors.UnknownDestination(configuration.TargetName);
}
ITransferStatistics statistics = null;
using (var cancellation = new ConsoleCancellationSource())
{
statistics = await statisticsHandler.CreateNew(statisticsConfiguration, cancellation.Token);
using (new Timer(PrintStatistics, statistics, TimeSpan.Zero, GetProgressUpdateInterval()))
{
await transferService
.TransferAsync(
// From
configuration.SourceName,
dataAdapterConfiguration.TryCreate(sourceDefinition.ConfigurationType, configuration.SourceConfiguration),
// To
configuration.TargetName,
dataAdapterConfiguration.TryCreate(sinkDefinition.ConfigurationType, configuration.TargetConfiguration),
// With statistics
statistics,
// Allow cancellation
cancellation.Token);
}
}
if (statistics == null)
{
return(TransferResult.Empty);
}
var statisticsSnapshot = statistics.GetSnapshot();
statisticsHandler.PrintResult(statisticsSnapshot);
return(new TransferResult(statisticsSnapshot.Transferred, statisticsSnapshot.Failed));
}
public ObservableErrorsTransferStatistics(ITransferStatistics defaultStatistics, IErrorDetailsProvider errorDetailsProvider,
SynchronizationContext observableSynchronizationContext)
{
Guard.NotNull("defaultStatistics", defaultStatistics);
Guard.NotNull("errorDetailsProvider", errorDetailsProvider);
Guard.NotNull("observableSynchronizationContext", observableSynchronizationContext);
this.defaultStatistics = defaultStatistics;
this.errorDetailsProvider = errorDetailsProvider;
this.observableSynchronizationContext = observableSynchronizationContext;
errors = new ObservableCollection<KeyValuePair<string, string>>();
}
public ObservableErrorsTransferStatistics(ITransferStatistics defaultStatistics, IErrorDetailsProvider errorDetailsProvider,
SynchronizationContext observableSynchronizationContext)
{
Guard.NotNull("defaultStatistics", defaultStatistics);
Guard.NotNull("errorDetailsProvider", errorDetailsProvider);
Guard.NotNull("observableSynchronizationContext", observableSynchronizationContext);
this.defaultStatistics = defaultStatistics;
this.errorDetailsProvider = errorDetailsProvider;
this.observableSynchronizationContext = observableSynchronizationContext;
errors = new ObservableCollection <KeyValuePair <string, string> >();
}
private static async Task TransferDataItem(IDataSinkAdapter sink, string dataItemId, IDataItem dataItem, ITransferStatistics statistics, CancellationToken cancellation)
{
try
{
await sink.WriteAsync(dataItem, cancellation);
statistics.AddTransferred();
}
catch (AggregateException aggregateException)
{
foreach (var exception in aggregateException.Flatten().InnerExceptions)
statistics.AddError(dataItemId, exception);
}
catch (Exception exception)
{
statistics.AddError(dataItemId, exception);
}
}
public ObservableErrorsTransferStatistics(ITransferStatistics defaultStatistics, SynchronizationContext observableSynchronizationContext)
{
this.defaultStatistics = defaultStatistics;
this.observableSynchronizationContext = observableSynchronizationContext;
errors = new ObservableCollection <KeyValuePair <string, Exception> >();
}
public ImportOperationContext(ITransferStatistics statistics, ImportViewModel viewModel)
{
Statistics = statistics;
ViewModel = viewModel;
}
public ImportOperationContext(ITransferStatistics statistics, ImportViewModel viewModel)
{
Statistics = statistics;
ViewModel = viewModel;
}
private static async Task TransferDataItem(IDataSinkAdapter sink, string dataItemId, IDataItem dataItem, ITransferStatistics statistics, CancellationToken cancellation)
{
try
{
await sink.WriteAsync(dataItem, cancellation);
statistics.AddTransferred();
}
catch (AggregateException aggregateException)
{
foreach (var exception in aggregateException.Flatten().InnerExceptions)
{
statistics.AddError(dataItemId, exception);
}
}
catch (Exception exception)
{
statistics.AddError(dataItemId, exception);
}
}
private static async Task TransferData(IDataSourceAdapter source, IDataSinkAdapter sink, ITransferStatistics statistics, CancellationToken cancellation)
{
var writeTasks = Enumerable
.Range(0, sink.MaxDegreeOfParallelism)
.Select(i => (Task)Task.FromResult <object>(null))
.ToArray();
var fatalExceptions = new List <Exception>();
var readOutput = new ReadOutputByRef();
IDataItem dataItem;
while (!cancellation.IsCancellationRequested)
{
readOutput.Wipe();
try
{
dataItem = await source.ReadNextAsync(readOutput, cancellation);
}
catch (NonFatalReadException nonFatalException)
{
statistics.AddError(readOutput.DataItemId, nonFatalException);
continue;
}
catch (Exception exception)
{
fatalExceptions.Add(exception);
break;
}
if (dataItem == null || cancellation.IsCancellationRequested)
{
break;
}
var completed = await Task.WhenAny(writeTasks);
writeTasks[Array.IndexOf(writeTasks, completed)] =
TransferDataItem(sink, readOutput.DataItemId, dataItem, statistics, cancellation);
}
// Report completion to the sink
try
{
await sink.CompleteAsync(cancellation);
}
catch (Exception exception)
{
fatalExceptions.Add(exception);
}
// Wait for all on-going writes to complete
for (var index = 0; index < writeTasks.Length; ++index)
{
await writeTasks[index];
}
// Throw fatal exceptions, if any
if (fatalExceptions.Any())
{
throw new AggregateException(fatalExceptions);
}
}
public async Task ExecuteAsync(IDataSourceAdapter source, IDataSinkAdapter sink, ITransferStatistics statistics, CancellationToken cancellation)
{
Guard.NotNull("source", source);
Guard.NotNull("sink", sink);
try
{
statistics.Start();
await TransferData(source, sink, statistics, cancellation);
}
finally
{
statistics.Stop();
}
}
public ObservableErrorsTransferStatistics(ITransferStatistics defaultStatistics, SynchronizationContext observableSynchronizationContext)
{
this.defaultStatistics = defaultStatistics;
this.observableSynchronizationContext = observableSynchronizationContext;
errors = new ObservableCollection<KeyValuePair<string, Exception>>();
}
