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