private void BRecover_Click(object sender, RoutedEventArgs e) { if (MessageBox.Show("You are going to restore the original state of the folders. Do you proceed?", "Recovering junctions", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes) { BatchRunner.RunFile((string)LBRecovery.SelectedItem, RecoveryComplete); } }
public void TestBatchRunnerUpsert() { var csv = File.ReadAllText("contactsupsert.csv"); var b = new BatchRunner(_UserName, _Password, _SecurityToken).Run(OperationType.upsert, "Contact", BulkContentType.CSV, csv, "CMS_Family_ID__c"); File.AppendAllText("results.csv", b.Result); }
private void BFinalize_Click(object sender, RoutedEventArgs e) { if (MessageBox.Show("You are going to remove the original state of the folders. Do you proceed?", "Deleting backup", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes) { BatchRunner.RunFile((string)LBFinalize.SelectedItem, FinalizeComplete); } }
public void Test_Cancelled( ) { Mock <IRecordImporter> mockImporter = new Mock <IRecordImporter>(MockBehavior.Strict); Mock <IObjectsReader> mockReader = new Mock <IObjectsReader>(MockBehavior.Strict); Mock <ICancellationWatcher> mockCancellation = new Mock <ICancellationWatcher>(MockBehavior.Loose); IList <IObjectReader> readers; readers = Enumerable.Range(0, 10).Select(i => new Mock <IObjectReader>( ).Object).ToList( ); mockReader.Setup(reader => reader.GetObjects( )).Returns(() => readers); mockCancellation.Setup(c => c.IsCancellationRequested).Returns(true); BatchRunner batchRunner = new BatchRunner { RecordImporter = mockImporter.Object, ObjectsReader = mockReader.Object, CancellationWatcher = mockCancellation.Object }; batchRunner.ProcessAll( ); mockReader.VerifyAll( ); mockImporter.VerifyAll( ); }
public void Test_Runs(int sampleSize, int call1, int call2) { Mock <IRecordImporter> mockImporter = new Mock <IRecordImporter>(MockBehavior.Strict); Mock <IObjectsReader> mockReader = new Mock <IObjectsReader>(MockBehavior.Strict); Mock <ICancellationWatcher> mockCancellation = new Mock <ICancellationWatcher>(MockBehavior.Loose); IList <IObjectReader> readers; readers = Enumerable.Range(0, sampleSize).Select(i => new Mock <IObjectReader>( ).Object).ToList( ); mockReader.Setup(reader => reader.GetObjects( )).Returns(() => readers); mockImporter.Setup(importer => importer.ImportRecords(It.Is <IEnumerable <IObjectReader> >(list => list.Count( ) == call1 && list.First() == readers[0]))); if (call2 > 0) { mockImporter.Setup(importer => importer.ImportRecords(It.Is <IEnumerable <IObjectReader> >(list => list.Count( ) == call2 && list.First( ) == readers [call1]))); } mockCancellation.Setup(c => c.IsCancellationRequested).Returns(false); BatchRunner batchRunner = new BatchRunner { RecordImporter = mockImporter.Object, ObjectsReader = mockReader.Object, CancellationWatcher = mockCancellation.Object }; batchRunner.ProcessAll( ); mockReader.VerifyAll( ); mockImporter.VerifyAll( ); }
public void Test_RecordImporter_NotSet( ) { BatchRunner batchRunner = new BatchRunner( ); batchRunner.ObjectsReader = new Mock <IObjectsReader>( ).Object; Assert.Throws <InvalidOperationException>(() => batchRunner.ProcessAll( )); }
public void Test_BatchSize_OutOfRange(int batchSize) { BatchRunner batchRunner = new BatchRunner( ); batchRunner.RecordImporter = new Mock <IRecordImporter>( ).Object; batchRunner.ObjectsReader = new Mock <IObjectsReader>( ).Object; batchRunner.BatchSize = batchSize; Assert.Throws <InvalidOperationException>(() => batchRunner.ProcessAll( )); }
public void StartStopTest() { var scheduledRunner = new BatchRunner <Param, bool>(TimeSpan.FromMilliseconds(100), 10, 1024, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000), new BatchWorker()); scheduledRunner.Start(); Thread.Sleep(100); scheduledRunner.Stop(); }
private async Task RunConsoleBatch(IArguments args) { var appProvider = GetApplicationProvider(); var opts = args.GetOptions(appProvider); using (var batchRunner = new BatchRunner(appProvider, Console.Out, new ConsoleProgressWriter())) { await batchRunner.BatchRun(opts).ConfigureAwait(false); } }
static async Task <int> Main(string[] args) { // To run locally, uncomment these lines: //BatchRunner.StoreBatchOutput = false; return(await BatchRunner.Run <CompressDatasetTask>(async (task) => { var options = CompressDatasetTaskOptions.Parse(args); return await task.Run(options); })); }
public void EnqueueAndWaitTest() { var scheduledRunner = new BatchRunner <Param, bool>(TimeSpan.FromMilliseconds(100), 10, 1024, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000), new BatchWorker()); scheduledRunner.Start(); var result = scheduledRunner.EnqueueAndWaitItem(new Param()); scheduledRunner.Stop(); Assert.IsTrue(result); }
public void TestBatchRunnersWithSharedLogin() { var api = new BulkApiContext(); api.Login(_UserName, _Password, _SecurityToken).Wait(); var csv = File.ReadAllText("contactsupsert.csv"); var b1 = new BatchRunner(api).Run(OperationType.upsert, "Contact", BulkContentType.CSV, csv, "CMS_Family_ID__c"); var b2 = new BatchRunner(api).Run(OperationType.query, "Contact", BulkContentType.CSV, _SOQL, null); File.AppendAllText("results.csv", b1.Result); File.AppendAllText("results.csv", b2.Result); }
public void StoppingEnqueueWaitTest() { var scheduledRunner = new BatchRunner <Param, bool>(TimeSpan.FromMilliseconds(100), 10, 1024, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000), new BatchWorker()); scheduledRunner.Start(); var @event = new ManualResetEvent(false); var workItem = new WorkItem <Param, bool>(@event, new Param()); scheduledRunner.Stop(); scheduledRunner.EnqueueItem(workItem); @event.WaitOne(scheduledRunner.WaitTime); Assert.IsFalse(workItem.Result); }
public static void Start(IBatchParameters batchParameters, IMessagingServiceClient messagingServiceClient) { var batchWorkerRecord = new BatchWorkerRecord(messagingServiceClient); var batchWorkerReceiveAndForget = new BatchWorkerReceiveAndForget(messagingServiceClient); var batchWorkerPeek = new BatchWorkerPeek(messagingServiceClient); var batchWorkerCommit = new BatchWorkerCommit(messagingServiceClient); BatchRunnerReceiveAndForget = new BatchRunner <long, OutgoingMessageToStoreWithState>( batchParameters.MessagingReceiveAndForgetCollectionTime, batchParameters.MessagingReceiveAndForgetCollectionBatch, batchParameters.MessagingReceiveAndForgetFlushBatch, batchParameters.MessagingReceiveAndForgetOperationTimeout, batchParameters.MessagingReceiveAndForgetWorkerStopTimeout, batchWorkerReceiveAndForget); BatchRunnerPeek = new BatchRunner <long, OutgoingMessageToStoreWithState>( batchParameters.MessagingPeekCollectionTime, batchParameters.MessagingPeekCollectionBatch, batchParameters.MessagingPeekFlushBatch, batchParameters.MessagingPeekOperationTimeout, batchParameters.MessagingPeekWorkerStopTimeout, batchWorkerPeek); BatchRunnerCommit = new BatchRunner <long, OutgoingState>( batchParameters.MessagingCommitCollectionTime, batchParameters.MessagingCommitCollectionBatch, batchParameters.MessagingCommitFlushBatch, batchParameters.MessagingCommitOperationTimeout, batchParameters.MessagingCommitWorkerStopTimeout, batchWorkerCommit); BatchRunnerRecord = new BatchRunner <OutgoingMessageToStore, OutgoingState>( batchParameters.MessagingRecordCollectionTime, batchParameters.MessagingRecordCollectionBatch, batchParameters.MessagingRecordFlushBatch, batchParameters.MessagingRecordOperationTimeout, batchParameters.MessagingRecordWorkerStopTimeout, batchWorkerRecord); BatchRunnerReceiveAndForget.Start(); BatchRunnerPeek.Start(); BatchRunnerCommit.Start(); BatchRunnerRecord.Start(); }
public void EnqueueAndWaitManyItemsAbove64Test() { bool wasOk = false; var thread = new Thread(() => { var scheduledRunner = new BatchRunner <Param, bool>(TimeSpan.FromMilliseconds(100), 10, 1024, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000), new BatchWorkerFullOk()); scheduledRunner.Start(); var result = scheduledRunner.EnqueueAndWaitManyItems(Enumerable.Range(0, 1000).Select(p => new Param())); scheduledRunner.Stop(); wasOk = result.All(t => t.Result); }); thread.SetApartmentState(ApartmentState.MTA); thread.Start(); thread.Join(); Assert.IsTrue(wasOk); }
public async Task <bool> ExecuteAsync() { if (!m_IsExecuting) { m_IsExecuting = true; m_CurrentCancellationToken = new CancellationTokenSource(); m_LogWriter.Log += OnLog; m_PrgHander.ProgressChanged += OnProgressChanged; m_PrgHander.JobScopeSet += OnJobScopeSet; m_PrgHander.Completed += OnJobCompleted; try { var cancellationToken = m_CurrentCancellationToken.Token; using (m_CurrentBatchRunner = m_BatchRunnerFact.Invoke(m_Job, m_LogWriter, m_PrgHander)) { return(await m_CurrentBatchRunner.BatchRunAsync(cancellationToken).ConfigureAwait(false)); } } catch (Exception ex) { m_LogWriter.WriteLine(ex.ParseUserError()); throw; } finally { m_LogWriter.Log -= OnLog; m_PrgHander.ProgressChanged -= OnProgressChanged; } } else { throw new Exception("Job is currently running"); } }
public async Task <bool> ExecuteAsync() { if (!m_IsExecuting) { m_IsExecuting = true; m_CurrentCancellationToken = new CancellationTokenSource(); m_LogWriter.Log += OnLog; m_PrgHander.ProgressChanged += OnProgressChanged; m_PrgHander.JobScopeSet += OnJobScopeSet; m_PrgHander.Completed += OnJobCompleted; try { using (var batchRunner = new BatchRunner(m_AppProvider, m_LogWriter, m_PrgHander)) { var cancellationToken = m_CurrentCancellationToken.Token; return(await batchRunner.BatchRun(m_Job, cancellationToken).ConfigureAwait(false)); } } catch (Exception ex) { m_LogWriter.WriteLine(ex.ParseUserError(out _)); throw; } finally { m_LogWriter.Log -= OnLog; m_PrgHander.ProgressChanged -= OnProgressChanged; } } else { throw new Exception("Execution is already running"); } }
public void EnqueueWaitFailTooTest() { var scheduledRunner = new BatchRunner <Param, bool>(TimeSpan.FromMilliseconds(100), 10, 1024, TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000), new BatchWorker()); scheduledRunner.Start(); var event1 = new ManualResetEvent(false); var workItem1 = new WorkItem <Param, bool>(event1, new Param()); scheduledRunner.EnqueueItem(workItem1); var event2 = new ManualResetEvent(false); var workItem2 = new WorkItem <Param, bool>(event2, new Param()); scheduledRunner.EnqueueItem(workItem2); event1.WaitOne(scheduledRunner.WaitTime); event2.WaitOne(scheduledRunner.WaitTime); scheduledRunner.Stop(); Assert.IsTrue(workItem1.Result); Assert.IsFalse(workItem2.Result); }
/// <summary> /// Start processing an import run, after checking has been performed. /// </summary> /// <param name="importRun">A writable import run entity. Caller will save.</param> internal void StartImportSafe(ImportRun importRun) { ImportConfig importConfig = importRun.ImportConfigUsed; if (importConfig == null) { throw new ConnectorConfigException("Import configuration could not be loaded."); } if (importConfig.ImportConfigMapping == null) { throw new ConnectorConfigException("Import configuration has no mapping."); } IObjectsReader recordsReader = null; IReaderToEntityAdapter entityAdapter; IImportReporter importRunReporter; IRecordImporter recordImporter; ICancellationWatcher cancellationWatcher; BatchRunner batchRunner; try { // Reads records out of the file to count recordsReader = GetRecordsReader(importRun, importConfig); importRun.ImportRecordsTotal = recordsReader.GetObjects( ).Count( ); importRun.Save( ); // Re-reads records out of the file for importing recordsReader = GetRecordsReader(importRun, importConfig); // Writes records into entities entityAdapter = GetEntityAdapter(importConfig); // Create a reporter to process progress notifications importRunReporter = new ImportRunReporter(importRun); // Create a reporter to process progress notifications cancellationWatcher = new ImportRunCancellationWatcher(importRun); // Activate record impoter bool testRun = importRun.ImportTestRun == true; recordImporter = _recordImporterActivator(entityAdapter, importRunReporter, importConfig.ImportConfigMapping, testRun); if (recordImporter == null) { throw new Exception("recordImporter failed to activate."); } // Connects the reader to the writer batchRunner = new BatchRunner { ObjectsReader = recordsReader, RecordImporter = recordImporter, CancellationWatcher = cancellationWatcher }; // Go! Run as user using (new SecurityBypassContext(false)) { batchRunner.ProcessAll( ); } } finally { recordsReader?.Dispose( ); } }
public void TestBatchRunnerQuery() { var b = new BatchRunner(_UserName, _Password, _SecurityToken).Run(OperationType.query, "Contact", BulkContentType.CSV, _SOQL, null); File.AppendAllText("results.csv", b.Result); }