private static DateTime CalculateRequestTimeout(ActivateJobsRequest request)
{
// we need a higher request deadline then the long polling request timeout
var longPollingTimeout = request.RequestTimeout;
return(longPollingTimeout <= 0
? TimeSpan.FromSeconds(10).FromUtcNow()
: TimeSpan.FromSeconds((longPollingTimeout / 1000f) + 10).FromUtcNow());
}
public void ShouldSendRequestsWithDifferentAmounts()
{
// given
var expectedRequest = new ActivateJobsRequest
{
Timeout = 123L,
MaxJobsToActivate = 4,
Type = "foo",
Worker = "jobWorker"
};
var expectedSecondRequest = new ActivateJobsRequest
{
Timeout = 123L,
MaxJobsToActivate = 2, // first response contains 3 jobs and one is handled (blocking) so 2 jobs remain in queue
// so we can try to activate 2 new jobs
Type = "foo",
Worker = "jobWorker"
};
TestService.AddRequestHandler(typeof(ActivateJobsRequest), request => CreateExpectedResponse());
// when
var receivedJobs = new List <IJob>();
using (var jobWorker = ZeebeClient.NewWorker()
.JobType("foo")
.Handler((jobClient, job) =>
{
// block job handling
using (var signal = new EventWaitHandle(false, EventResetMode.AutoReset))
{
signal.WaitOne();
}
})
.MaxJobsActive(4)
.Name("jobWorker")
.Timeout(123L)
.PollInterval(TimeSpan.FromMilliseconds(100))
.Open())
{
Assert.True(jobWorker.IsOpen());
while (TestService.Requests.Count < 2)
{
}
}
// then
var actualRequest = TestService.Requests[0];
Assert.AreEqual(expectedRequest, actualRequest);
var actualSecondRequest = TestService.Requests[1];
Assert.AreEqual(expectedSecondRequest, actualSecondRequest);
}
public JobWorkerBuilder(IZeebeClient zeebeClient,
Gateway.GatewayClient gatewayClient,
ILoggerFactory loggerFactory = null)
{
LoggerFactory = loggerFactory;
Activator = new JobActivator(gatewayClient);
Request = new ActivateJobsRequest();
JobClient = zeebeClient;
ThreadCount = 1;
}
internal JobWorker(Gateway.GatewayClient client, ActivateJobsRequest request, TimeSpan pollInterval,
IJobClient jobClient, JobHandler jobHandler)
{
source = new CancellationTokenSource();
this.client = client;
activeRequest = request;
this.pollInterval = pollInterval;
this.jobClient = jobClient;
this.jobHandler = jobHandler;
}
internal JobWorker(JobWorkerBuilder builder)
{
source = new CancellationTokenSource();
activator = new JobActivator(builder.Client);
activeRequest = builder.Request;
maxJobsActive = activeRequest.MaxJobsToActivate;
pollInterval = builder.PollInterval();
jobClient = new JobClientWrapper(builder.JobClient);
jobHandler = builder.Handler();
autoCompletion = builder.AutoCompletionEnabled();
}
internal JobWorker(Gateway.GatewayClient client, ActivateJobsRequest request, TimeSpan pollInterval,
IJobClient jobClient, JobHandler jobHandler)
{
this.source = new CancellationTokenSource();
this.client = client;
this.activator = new JobActivator(client);
this.activeRequest = request;
this.maxJobsActive = request.MaxJobsToActivate;
this.pollInterval = pollInterval;
this.jobClient = jobClient;
this.jobHandler = jobHandler;
}
internal JobWorker(JobWorkerBuilder builder)
{
this.jobWorkerBuilder = builder;
this.source = new CancellationTokenSource();
this.logger = builder.LoggerFactory?.CreateLogger <JobWorker>();
this.jobHandler = jobWorkerBuilder.Handler();
this.autoCompletion = builder.AutoCompletionEnabled();
this.pollInterval = jobWorkerBuilder.PollInterval();
this.activateJobsRequest = jobWorkerBuilder.Request;
jobActivator = jobWorkerBuilder.Activator;
this.maxJobsActive = jobWorkerBuilder.Request.MaxJobsToActivate;
this.thresholdJobsActivation = maxJobsActive * 0.6;
}
public void ShouldSendFailCommandOnExceptionInJobHandler()
{
// given
var expectedRequest = new ActivateJobsRequest
{
Timeout = 123L,
MaxJobsToActivate = 1,
Type = "foo",
Worker = "jobWorker"
};
var expectedFailRequest = new FailJobRequest
{
JobKey = 1,
ErrorMessage = "Job worker 'jobWorker' tried to handle job of type 'foo', but exception occured 'Fail'",
Retries = 2
};
TestService.AddRequestHandler(typeof(ActivateJobsRequest), request => CreateExpectedResponse());
// when
using (var jobWorker = ZeebeClient.NewWorker()
.JobType("foo")
.Handler((jobClient, job) =>
{
if (job.Key == 1)
{
throw new Exception("Fail");
}
})
.MaxJobsActive(1)
.Name("jobWorker")
.Timeout(123L)
.PollInterval(TimeSpan.FromMilliseconds(100))
.Open())
{
Assert.True(jobWorker.IsOpen());
while (TestService.Requests.Count < 2)
{
}
}
// then
var actualRequest = TestService.Requests[0];
Assert.AreEqual(expectedRequest, actualRequest);
var actualFailRequest = TestService.Requests[1];
Assert.AreEqual(expectedFailRequest, actualFailRequest);
}
public async Task <IActivateJobsResponse> SendActivateRequest(ActivateJobsRequest request, CancellationToken?cancelationToken = null)
{
using (var stream = client.ActivateJobs(request))
{
var responseStream = stream.ResponseStream;
if (await MoveNext(responseStream, cancelationToken))
{
var response = responseStream.Current;
return(new Responses.ActivateJobsResponses(response));
}
// empty response
return(new Responses.ActivateJobsResponses());
}
}
public void ShouldSendRequestReceiveResponseAsExpected()
{
// given
var expectedRequest = new ActivateJobsRequest
{
Timeout = 123L,
Amount = 1,
Type = "foo",
Worker = "jobWorker"
};
TestService.AddRequestHandler(typeof(ActivateJobsRequest), request => CreateExpectedResponse());
// when
var signal = new EventWaitHandle(false, EventResetMode.AutoReset);
var receivedJobs = new List <IJob>();
using (var jobWorker = ZeebeClient.NewWorker()
.JobType("foo")
.Handler((jobClient, job) =>
{
receivedJobs.Add(job);
if (receivedJobs.Count == 3)
{
signal.Set();
}
})
.Limit(1)
.Name("jobWorker")
.Timeout(123L)
.PollInterval(TimeSpan.FromMilliseconds(100))
.Open())
{
Assert.True(jobWorker.IsOpen());
signal.WaitOne();
}
// then
var actualRequest = TestService.Requests[0];
Assert.AreEqual(expectedRequest, actualRequest);
Assert.AreEqual(receivedJobs.Count, 3);
AssertJob(receivedJobs[0], 1);
AssertJob(receivedJobs[1], 2);
AssertJob(receivedJobs[2], 3);
}
public async Task SendActivateRequest(ActivateJobsRequest request, ConsumeJob consumer, DateTime?requestTimeout = null, CancellationToken?cancellationToken = null)
{
var activateRequestTimeout = requestTimeout ?? CalculateRequestTimeout(request);
using (var stream = client.ActivateJobs(request, deadline: activateRequestTimeout))
{
var responseStream = stream.ResponseStream;
while (await MoveNext(responseStream, cancellationToken))
{
var currentResponse = responseStream.Current;
var response = new ActivateJobsResponses(currentResponse);
await consumer.Invoke(response);
}
}
}
public async Task <IActivateJobsResponse> SendActivateRequest(ActivateJobsRequest request, DateTime?requestTimeout = null, CancellationToken?cancelationToken = null)
{
DateTime activateRequestTimeout = requestTimeout ?? CalculateRequestTimeout(request);
using (var stream = client.ActivateJobs(request, deadline: activateRequestTimeout))
{
var responseStream = stream.ResponseStream;
if (await MoveNext(responseStream, cancelationToken))
{
var response = responseStream.Current;
return(new ActivateJobsResponses(response));
}
// empty response
return(new ActivateJobsResponses());
}
}
public async Task <IActivateJobsResponse> SendActivateRequest(ActivateJobsRequest request, CancellationToken?cancelationToken = null)
{
// we need a higher request deadline then the long polling request timeout
var requestTimeout = request.RequestTimeout <= 0 ? 10 : (request.RequestTimeout / 1000) + 10;
using (var stream = client.ActivateJobs(request, deadline: DateTime.UtcNow.AddSeconds(requestTimeout)))
{
var responseStream = stream.ResponseStream;
if (await MoveNext(responseStream, cancelationToken))
{
var response = responseStream.Current;
return(new Responses.ActivateJobsResponses(response));
}
// empty response
return(new Responses.ActivateJobsResponses());
}
}
public override async Task ActivateJobs(ActivateJobsRequest request, IServerStreamWriter <ActivateJobsResponse> responseStream, ServerCallContext context)
{
await responseStream.WriteAsync((ActivateJobsResponse)HandleRequest(request, context));
}
public ActivateJobsCommand(GatewayClient client, IAsyncRetryStrategy asyncRetryStrategy)
{
this.asyncRetryStrategy = asyncRetryStrategy;
activator = new JobActivator(client);
Request = new ActivateJobsRequest();
}
public override AsyncServerStreamingCall <ActivateJobsResponse> ActivateJobs(ActivateJobsRequest request, CallOptions options)
{
throw new ObjectDisposedException(ZeebeClientWasAlreadyDisposed);
}
public override AsyncServerStreamingCall <ActivateJobsResponse> ActivateJobs(ActivateJobsRequest request, Metadata headers = null, DateTime?deadline = null,
CancellationToken cancellationToken = default(CancellationToken))
{
throw new ObjectDisposedException(ZeebeClientWasAlreadyDisposed);
}
public ActivateJobsCommand(GatewayClient client)
{
activator = new JobActivator(client);
request = new ActivateJobsRequest();
}
public async Task <IList <ActivatedJob> > PublishMessage([FromBody] ActivateJobsRequest request)
{
return(await _daprClient.InvokeBindingAsync <ActivateJobsRequest, IList <ActivatedJob> >(
"command", Commands.ActivateJobs, request));
}
