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; }
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>>(); }