public Task <bool> Handle(JobMessage <TestJob> request, CancellationToken cancellationToken)
{
var data = request.Data;
_logger.LogInformation("TestJobHandler消费;Topic:{Topic},JobId:{JobId},Body:{Body}", request.Topic,
data.JobId, data.Body);
DelayedRedisHelper.RPush(nameof(TestJobHandler), data.JobId);
return(Task.FromResult(true));
}
public async Task<DateTime?> GetNextJobExecTimeAsync(string topic)
{
var items = await DelayedRedisHelper.ZRangeByScoreWithScoresAsync<string>($"{queuePrefix}{topic}", decimal.Zero,
decimal.MaxValue
, 1);
if (items == null || items.Length == 0)
return null;
return DateTimeOffset.FromUnixTimeSeconds(long.Parse(items[0].score.ToString("0000"))).LocalDateTime;
}
public static void AddDealyQueueService(this IServiceCollection services, string delayQueRedis)
{
DelayedRedisHelper.Initialization(new CSRedisClient(delayQueRedis));
services.AddSingleton(typeof(IDelayer <>), typeof(Delayer <>));
services.AddSingleton(typeof(IDelayedMessageProcessor <>), typeof(DelayedMessageProcessor <>));
services.AddMediatR(AppDomain.CurrentDomain.GetAssemblies());
}
public static void AddDealyQueueService(this IServiceCollection services, IConfiguration configuration)
{
DelayedRedisHelper.Initialization(new CSRedisClient(configuration.GetSection("DelayQueue:Redis").Value));
services.AddSingleton(typeof(IDelayer <>), typeof(Delayer <>));
services.AddSingleton(typeof(IDelayedMessageProcessor <>), typeof(DelayedMessageProcessor <>));
services.AddMediatR(AppDomain.CurrentDomain.GetAssemblies());
}
public async Task should_consume_delay_job()
{
DelayedRedisHelper.Del(nameof(TestJobHandler));
var delayer = _serviceProvider.GetRequiredService <IDelayer <TestJob> >();
for (int j = 0; j < 100; j++)
{
await delayer.PutDealyJob(
new TestJob(TimeSpan.FromSeconds(1), "abcde====" + j, j.ToString()));
}
Thread.Sleep(1000 * 20);
var num = DelayedRedisHelper.LLen(nameof(TestJobHandler));
_testOutputHelper.WriteLine("消费：" + num);
Assert.True(num == 100);
_testOutputHelper.WriteLine("ok");
}
public async Task shou_add_to_bucket()
{
var jobid = Guid.NewGuid().ToString("N");
var delayer = _serviceProvider.GetRequiredService <IDelayer <TestJob> >();
await delayer.PutDealyJob(
new TestJob(TimeSpan.FromSeconds(10), "abcde====" + jobid, jobid));
var jobpool = await new JobPool <TestJob>().GetJobAsync(jobid);
Assert.NotNull(jobpool);
Assert.True(jobpool.JobId == jobid);
var bucketJob = await new Bucket().GetNextJobExecTimeAsync(nameof(TestJob));
Assert.True(bucketJob != null);
await new JobPool <TestJob>().DelJobAsync(jobid);
await new Bucket().RemoveJobAsync(nameof(TestJob), jobid);
DelayedRedisHelper.Del(nameof(TestJobHandler));
}
public Task<long> DelJobAsync(string jobId)
{
return DelayedRedisHelper.DelAsync($"{_prefix}{jobId}");
}
public Task<T> GetJobAsync(string jobId)
{
return DelayedRedisHelper.GetAsync<T>($"{_prefix}{jobId}");
}
public Task<bool> PutJobAsync(T job)
{
//检验jobid是否全局唯一？
return DelayedRedisHelper.SetAsync($"{_prefix}{job.JobId}", job);
}
public Task<long> RemoveJobAsync(string topic, string jobId)
{
return DelayedRedisHelper.ZRemAsync($"{queuePrefix}{topic}", jobId);
}
public Task<string[]> GetExpireJobsAsync(string topic, long limit)
{
return DelayedRedisHelper.ZRangeByScoreAsync<string>($"{queuePrefix}{topic}", decimal.Zero,
GetDelaySeconds(TimeSpan.Zero), limit);
}
public Task<long> PushJobToBucketAsync(string topic, string jobId, TimeSpan delay)
{
var delaySec = GetDelaySeconds(delay);
return DelayedRedisHelper.ZAddAsync($"{queuePrefix}{topic}", (delaySec, jobId));
}
public Task PushToReadyQueue(string topic, T job)
{
return(DelayedRedisHelper.RPushAsync($"{queuePrefix}{topic}", job));
}
public Task <T> GetJobFromReadyQueue(string topic, int timeoutSeconds)
{
var data = DelayedRedisHelper.BLPop <T>(timeoutSeconds, $"{queuePrefix}{topic}");
return(Task.FromResult(data));
}
