public BatchCheckpointEventHandler(
ProcessEvents processEvents,
ProcessErrors processErrors,
SaveCheckpoint checkpoint)
{
_processEvents = processEvents;
_processErrors = processErrors;
_checkpoint = checkpoint;
}
/**********************************************************************************/
public VenWrapper(VEN2b ven, IVenWrapper callbacks)
{
m_ven = ven;
m_callbacks = callbacks;
m_resources.setCallback(this);
m_processEvents = new ProcessEvents(callbacks);
m_resources.startThread();
}
public void Setup()
{
_fixture = new Fixture();
_mockGetHtmlDocument = new Mock <IGetHtmlDocument>();
_mockPdfParser = new Mock <IConvertHtmlToPdf>();
_sendToS3 = new Mock <IS3Gateway>();
_mockGetDocDetails = new Mock <IGetDetailsOfDocumentForProcessing>();
_logger = new Mock <IDbLogger>();
_localDbGateway = new Mock <ILocalDatabaseGateway>();
_processEvents = new ProcessEvents(_mockGetHtmlDocument.Object, _mockPdfParser.Object, _sendToS3.Object,
_mockGetDocDetails.Object, _logger.Object, _localDbGateway.Object);
ConfigurationHelper.SetDocumentConfigEnvironmentVariable();
}
public static async Task ProcessAsync(
this Task <IReceiverConnection> receiverConnection,
ProcessEvents processEvents,
ProcessErrors processErrors = default,
int?maxBatchSize = default,
TimeSpan?waitTime = default,
CancellationToken cancellationToken = default)
{
var connection = await receiverConnection.ConfigureAwait(false);
await connection.RunAsync(
processEvents : processEvents,
processErrors : processErrors ?? (_ => Task.CompletedTask),
maxBatchSize : maxBatchSize,
waitTime : waitTime,
cancellationToken : cancellationToken).ConfigureAwait(false);
}
public void OnMessageReceived(Func <IModel, BasicDeliverEventArgs, Task> processEvent)
{
ProcessEvents.Add(processEvent);
}
/// <summary>
///
/// </summary>
/// <remarks>
/// We can't use PartitionReceiver.SetReceiveHandler because it has an Environment.FailFast()
/// which might kill multiple partitions unnecessarily if they're hosted in the same process in Service Fabric.
/// </remarks>
/// <param name="processor"></param>
/// <param name="maxBatchSize"></param>
/// <param name="waitTime"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task RunAsync(
ProcessEvents processEvents,
ProcessErrors processErrors,
int?maxBatchSize = default,
TimeSpan?waitTime = default,
CancellationToken cancellationToken = default)
{
var handler = _handlers(processEvents, processErrors);
foreach (var _ in _loop)
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
var activity = new Activity("Process");
var events = default(IEnumerable <TestableEventData>);
try
{
if (ReceiveDiagnostics.IsEnabled("Process"))
{
ReceiveDiagnostics.StartActivity(
activity: activity,
args: new { });
}
events = await _receiver.ReceiveAsync(
maxMessageCount : maxBatchSize ?? Constants.DefaultMaxBatchSize,
waitTime : waitTime ?? Constants.DefaultOperationTimeout).ConfigureAwait(false);
if (events == null)
{
continue;
}
await handler.ProcessEventsAsync(events).ConfigureAwait(false);
}
catch (ReceiverDisconnectedException ex)
{
if (ReceiveDiagnostics.IsEnabled("Disconnection"))
{
ReceiveDiagnostics.Write("Disconnection", new { Exception = ex });
}
// Another partition has picked up the work,
// end the loop and finish RunAsync.
await _receiver.CloseAsync().ConfigureAwait(false);
break;
}
catch (Exception ex)
{
if (ReceiveDiagnostics.IsEnabled("Failure"))
{
ReceiveDiagnostics.Write("Failure", new { Exception = ex });
}
await handler.ProcessErrorAsync(ex).ConfigureAwait(false);
throw;
}
finally
{
if (events != null)
{
foreach (var @event in events)
{
@event.Dispose();
}
}
if (ReceiveDiagnostics.IsEnabled("Process"))
{
ReceiveDiagnostics.StopActivity(
activity: activity,
args: new { });
}
}
}
}
