public async Task CancelRegisteredJobAsync(string queueName, FirebusJob job)
{
var client = GetQueueClient(queueName);
if (job.Items == null || !job.Items.ContainsKey("$sn"))
{
throw new InvalidOperationException("The job has insufficient information");
}
await client.CancelScheduledMessageAsync((long)job.Items["$sn"]);
}
private FirebusJob ExtractJob <TService>(Expression <Action <TService> > jobAction)
{
var type = jobAction.Type.GenericTypeArguments[0].AssemblyQualifiedName;
var methodCall = (MethodCallExpression)jobAction.Body;
var args = methodCall.Arguments.Select(arg => arg.Evaluate()).ToArray();
var argTypes = methodCall.Arguments.Select(arg => arg.Type.AssemblyQualifiedName).ToArray();
var job = new FirebusJob
{
ServiceTypeName = type,
MethodName = methodCall.Method.Name,
Parameters = args,
ParameterTypeNames = argTypes
};
return(job);
}
private async Task ExecuteJobAsync(FirebusJob job, JobContext context)
{
var type = Type.GetType(job.ServiceTypeName);
if (type == null)
{
throw new TypeLoadException($"Failed to load type '{job.ServiceTypeName}'");
}
var args = job.ParameterTypeNames
.Select(tn => Type.GetType(tn))
.Zip(job.Parameters, (t, arg) => (Type: t, Argument: arg))
.Select(pair =>
pair.Type.IsEnum
? Convert.ChangeType(pair.Argument, pair.Type.GetEnumUnderlyingType())
: pair.Argument)
.ToArray();
var method = type.GetMethods()
.SingleOrDefault(m =>
m.Name == job.MethodName &&
m.GetParameters()
.Zip(job.ParameterTypeNames,
(p1, p2) => (p1.ParameterType, ArgumentType: Type.GetType(p2)))
.All(pair => pair.ParameterType.IsAssignableFrom(pair.ArgumentType)));
if (method == null)
{
throw new MissingMethodException($"Failed to find matched method '{job.MethodName}'");
}
var instance = context.ServiceProvider.GetService(type);
if (instance == null)
{
throw new Exception($"Could not resolve a service of type '{type.FullName}'");
}
if (method.Invoke(instance, args) is Task returnTask)
{
await returnTask;
}
}
public async Task RegisterJobAsync(FirebusJob job, DateTime?scheduledTimeUtc)
{
object queueNameObj = null;
job.Items?.TryGetValue("$queue", out queueNameObj);
var queueName = (queueNameObj as string) ?? _defaultQueueName;
var queueClient = GetQueueClient(queueName);
await queueClient.SendAsync(new Message
{
ContentType = "application/json",
Body = Encoding.UTF8.GetBytes(
JsonConvert.SerializeObject(job,
new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
})),
ScheduledEnqueueTimeUtc = scheduledTimeUtc ?? default
});
public async Task HandleJobAsync(FirebusJob job)
{
var scope = _serviceProvider.CreateScope();
var serviceProvider = scope.ServiceProvider;
var contextAccessor = serviceProvider.GetService <JobExecutionContextAccessor>();
var context = new JobContext(job, serviceProvider);
contextAccessor.Context = context;
try
{
foreach (var filter in _serverOptions.BeforeExecuteJobFilters)
{
if (!await filter.OnBeforeExecuteJob(context))
{
return;
}
}
await ExecuteJobAsync(job, context);
foreach (var filter in _serverOptions.AfterExecuteJobFilters)
{
await filter.OnAfterExecuteJob(context);
}
}
catch (Exception e)
{
if (_serverOptions.ExceptionHandler != null)
{
await _serverOptions.ExceptionHandler.HandleAsync(e);
}
}
}
public async Task CancelRegisteredJobAsync(string queueName, FirebusJob job)
{
await _peeker.CancelRegisteredJobAsync(queueName, job);
}
