private void lstExecuteResult_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (ProcessErrors.ContainsKey(lstExecuteResult.SelectedIndex) && ProcessErrors[lstExecuteResult.SelectedIndex] != null)
{
frmInfo.ShowError(Language.Title, ProcessErrors[lstExecuteResult.SelectedIndex], this);
}
}
public BatchCheckpointEventHandler(
ProcessEvents processEvents,
ProcessErrors processErrors,
SaveCheckpoint checkpoint)
{
_processEvents = processEvents;
_processErrors = processErrors;
_checkpoint = checkpoint;
}
public static async Task ProcessAsync(
this Task <IReceiverConnection> receiver,
IWebHostBuilder webHostBuilder,
Action <HttpRequestMessage> eventRequestBuilder,
Action <HttpResponseMessage, HttpRequestMessage> poisonRequestBuilder = default,
ProcessErrors processErrors = default,
int?maxBatchSize = default,
TimeSpan?waitTime = default,
CancellationToken cancellationToken = default)
{
using (var server = new TestServer(webHostBuilder))
using (var client = server.CreateClient())
{
var events = Processors.CreateSerialEventProcessor(client, eventRequestBuilder, poisonRequestBuilder);
await receiver.ProcessAsync(events, processErrors, maxBatchSize, waitTime, cancellationToken).ConfigureAwait(false);
}
}
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);
}
/// <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 { });
}
}
}
}
