public static Activity?Start(
string name,
ActivityKind activityKind,
IMessageConsumeContext context,
IEnumerable <KeyValuePair <string, object?> >?tags = null
)
=> Create(name, activityKind, context, tags)?.Start();
public async Task Consume(IMessageConsumeContext <CopyAvatarMessage> context)
{
try
{
context.Message.UserUID.Should().NotBeNullOrEmpty();
context.Message.AvatarUrl.Should().NotBeNullOrEmpty();
var user_uid = context.Message.UserUID;
var repo = provider.Resolve_ <IUserRepository>();
var user = await repo.QueryOneAsync(x => x.Id == user_uid);
user.Should().NotBeNull();
var client = provider.Resolve_ <IHttpClientFactory>().CreateClient("copy_avatar_client");
var fileUploadService = provider.Resolve_ <IFileUploadService>();
user.UserImg = await this.__download_and_upload__(client, fileUploadService, context.Message.AvatarUrl);
await repo.UpdateAsync(user);
var cache = provider.ResolveDistributedCache_();
var keyManager = provider.Resolve_ <ICacheKeyManager>();
await cache.RemoveAsync(keyManager.UserLoginInfo(user_uid));
}
catch (Exception e)
{
var _logger = provider.Resolve_ <ILogger <CopyAvatarUrlConsumer> >();
_logger.AddErrorLog(nameof(CopyAvatarUrlConsumer), e);
}
}
public async ValueTask <EventHandlingStatus> HandleEvent(IMessageConsumeContext context)
{
using var activity = SubscriptionActivity
.Create(
$"{Constants.Components.EventHandler}.{DiagnosticName}/{context.MessageType}",
ActivityKind.Internal,
tags: _defaultTags
)
?.SetContextTags(context)
?.Start();
try {
var status = await _innerHandler.HandleEvent(context).NoContext();
if (activity != null && status == EventHandlingStatus.Ignored)
{
activity.ActivityTraceFlags = ActivityTraceFlags.None;
}
activity?.SetActivityStatus(ActivityStatus.Ok());
return(status);
}
catch (Exception e) {
activity?.SetActivityStatus(ActivityStatus.Error(e, $"Error handling {context.MessageType}"));
throw;
}
}
public static Metadata GetMeta(this GatewayMessage gatewayMessage, IMessageConsumeContext context)
{
var(_, _, metadata) = gatewayMessage;
var meta = metadata == null ? new Metadata() : new Metadata(metadata);
return(meta.WithCausationId(context.MessageId));
}
public async Task Consume(IMessageConsumeContext <UserRoleChangedMessage> context)
{
var cache = provider.ResolveDistributedCache_();
var keyManager = provider.Resolve_ <ICacheKeyManager>();
var key = keyManager.AdminPermission(context.Message?.UserUID);
await cache.RemoveAsync(key);
}
public override async ValueTask <EventHandlingStatus> HandleEvent(IMessageConsumeContext context)
{
_output?.WriteLine(context.Message !.ToString());
await Task.Delay(_delay);
await EnsureHypothesis.Test(context.Message !, context.CancellationToken);
return(EventHandlingStatus.Success);
}
public override ValueTask Consume(IMessageConsumeContext context)
{
if (_filter(context))
{
return(_inner.Consume(context));
}
context.Ignore(_innerType);
return(default);
public override ValueTask Consume(IMessageConsumeContext context)
{
if (context is not DelayedAckConsumeContext ctx)
{
throw new InvalidCastException(
"Round robin consumer only works with delayed acknowledgement"
);
}
return(_worker.Write(ctx, ctx.CancellationToken));
}
public override ValueTask <EventHandlingStatus> HandleEvent(IMessageConsumeContext ctx)
{
Count++;
if (ctx == null)
{
throw new InvalidOperationException();
}
Processed.Add(ctx);
return(default);
public static Activity?Create(
string name,
ActivityKind activityKind,
IMessageConsumeContext context,
IEnumerable <KeyValuePair <string, object?> >?tags = null
)
{
context.ParentContext ??= GetParentContext(context.Metadata);
var activity = Create(name, activityKind, context.ParentContext, tags);
return(activity?.SetContextTags(context));
}
public async Task Consume(IMessageConsumeContext <OperationLogMessage> context)
{
try
{
context.Message.UID.Should().NotBeNullOrEmpty("请初始化操作日志");
var service = provider.Resolve_ <IMetroAdRepository <OperationLogEntity> >();
await service.AddAsync(context.Message);
}
catch (Exception e)
{
provider.Resolve_ <ILogger <OperationLogConsumer> >().AddErrorLog(nameof(OperationLogConsumer), e);
}
}
public async Task Consume(IMessageConsumeContext <PayNotifyLogMessage> context)
{
try
{
context.Message.UID.Should().NotBeNullOrEmpty("回调数据清闲init");
var service = provider.Resolve_ <IMetroAdRepository <PaymentNotificationEntity> >();
await service.AddAsync(context.Message);
}
catch (Exception e)
{
provider.Resolve_ <ILogger <PayNotifyLogConsumer> >().AddErrorLog(nameof(PayNotifyLogConsumer), e);
}
}
public async Task Consume(IMessageConsumeContext <OrderFinishedMessage> context)
{
try
{
var order_uid = context.Message.OrderUID;
//send mail
await Task.CompletedTask;
}
catch (Exception e)
{
provider.Resolve_ <ILogger <OrderFinishedConsumer> >().AddErrorLog(nameof(OrderFinishedConsumer), e);
}
}
public async Task Consume(IMessageConsumeContext <UserPhoneBindSmsMessage> context)
{
try
{
context.Message.Phone.Should().NotBeNullOrEmpty();
context.Message.Code.Should().NotBeNullOrEmpty();
var config = provider.ResolveConfig_();
string get_config(string key)
{
var config_res = config[$"aliyun:sms:{key}"];
config_res.Should().NotBeNullOrEmpty();
return(config_res);
}
//发送短信
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", get_config("key"), get_config("secret"));
DefaultAcsClient client = new DefaultAcsClient(profile);
CommonRequest request = new CommonRequest();
request.Method = MethodType.POST;
request.Domain = "dysmsapi.aliyuncs.com";
request.Version = "2017-05-25";
request.Action = "SendSms";
// request.Protocol = ProtocolType.HTTP;
request.AddQueryParameters("PhoneNumbers", context.Message.Phone);
request.AddQueryParameters("SignName", get_config("sign_name"));
request.AddQueryParameters("TemplateCode", get_config("template_code"));
request.AddQueryParameters("TemplateParam", new { code = context.Message.Code }.ToJson());
var response = client.GetCommonResponse(request);
var sms_res_content = System.Text.Encoding.Default.GetString(response.HttpResponse.Content);
sms_res_content.Should().NotBeNullOrEmpty();
var sms_res = sms_res_content.JsonToEntity <AliyunSmsRes>();
if (sms_res.Code?.ToLower() != "ok")
{
throw new MsgException(sms_res.Message ?? "sms error");
}
await Task.CompletedTask;
}
catch (Exception e)
{
var _logger = provider.Resolve_ <ILogger <IdConfirmSmsConsumer> >();
_logger.AddErrorLog(nameof(IdConfirmSmsConsumer), e);
}
}
public override async Task OnMessageReceived(IMessageConsumeContext <MessageType> message)
{
var model = message.Message;
using var s = this.provider.CreateScope();
var consumers = s.ServiceProvider.ResolveConsumerOptional <MessageType>();
foreach (var c in consumers)
{
#if DEBUG
this.logger.LogInformation($"消费：{model.ToJson()}");
#endif
var data = new BasicMessageConsumeContext <MessageType>(model);
await c.Consume(data);
}
}
public async Task Consume(IMessageConsumeContext <OrderPayedMessage> context)
{
try
{
var order_uid = context.Message.OrderUID;
var repo = provider.Resolve_ <IMetroAdRepository <OrderEntity> >();
var db = repo.Database;
var set = db.Set <FinanceFlowEntity>();
if (await set.AsNoTracking().AnyAsync(x => x.OrderUID == order_uid))
{
return;
}
var order = await db.Set <OrderEntity>().AsNoTracking().FirstOrDefaultAsync(x => x.UID == order_uid);
order.Should().NotBeNull();
order.PayTime.Should().NotBeNull();
order = (await provider.Resolve_ <IOrderService>().LoadUsers(new[] { order })).First();
var flow = new FinanceFlowEntity()
{
OrderUID = order.UID,
OrderNo = order.OrderNo,
PriceInCent = order.TotalPriceInCent,
FlowDirection = (int)FlowDirectionEnum.In,
PayMethod = order.PayMethod,
ConsumerName = order.User?.UserName,
ConsumerUID = order.UserUID,
OrderCreateTimeUtc = order.CreateTimeUtc,
};
flow.InitSelf();
set.Add(flow);
await db.SaveChangesAsync();
}
catch (Exception e)
{
provider.Resolve_ <ILogger <OrderPayedConsumer> >().AddErrorLog(nameof(OrderPayedConsumer), e);
}
}
public async Task Consume(IMessageConsumeContext <RolePermissionUpdatedMessage> context)
{
try
{
var role_id = context.Message?.RoleUID;
if (ValidateHelper.IsEmpty(role_id))
{
throw new ArgumentNullException(nameof(context));
}
var cache = provider.ResolveDistributedCache_();
var keyManager = provider.Resolve_ <ICacheKeyManager>();
var repo = provider.Resolve_ <IMSRepository <AdminRoleEntity> >();
var query = repo.NoTrackingQueryable;
var max_id = -1L;
var batch_size = 500;
while (true)
{
var list = await query
.Where(x => x.RoleUID == role_id)
.Where(x => x.Id > max_id)
.OrderBy(x => x.Id).Take(batch_size)
.Select(x => new { x.Id, x.AdminUID }).ToListAsync();
if (!list.Any())
{
break;
}
foreach (var m in list)
{
var key = keyManager.AdminPermission(m.AdminUID);
await cache.RemoveAsync(key);
}
max_id = list.Max(x => x.Id);
}
}
catch (Exception e)
{
var logger = provider.Resolve_ <ILogger <RolePermissionChangedConsumer> >();
logger.AddErrorLog(nameof(RolePermissionChangedConsumer), e);
}
}
public override async ValueTask <EventHandlingStatus> HandleEvent(IMessageConsumeContext context)
{
var shovelMessages = await _transform(context).NoContext();
if (shovelMessages.Length == 0)
{
return(EventHandlingStatus.Ignored);
}
AcknowledgeProduce?onAck = null;
if (context is DelayedAckConsumeContext delayed)
{
onAck = _ => delayed.Acknowledge();
}
try {
var grouped = shovelMessages.GroupBy(x => x.TargetStream);
await grouped
.Select(x => ProduceToStream(x.Key, x))
.WhenAll()
.NoContext();
}
catch (OperationCanceledException e) {
context.Nack <GatewayHandler>(e);
}
return(_awaitProduce ? EventHandlingStatus.Success : EventHandlingStatus.Pending);
Task ProduceToStream(StreamName streamName, IEnumerable <GatewayMessage <TProduceOptions> > toProduce)
=> toProduce.Select(
x =>
_eventProducer.Produce(
streamName,
x.Message,
x.GetMeta(context),
x.ProduceOptions,
onAck,
context.CancellationToken
)
)
.WhenAll();
}
public override async ValueTask Send(
IMessageConsumeContext context,
Func <IMessageConsumeContext, ValueTask>?next
)
{
if (context.Message == null || next == null)
{
return;
}
using var activity = Activity.Current?.Context != context.ParentContext
? SubscriptionActivity.Start(
$"{Constants.Components.Consumer}.{context.SubscriptionId}/{context.MessageType}",
ActivityKind.Consumer,
context,
_defaultTags
)
: Activity.Current;
if (activity?.IsAllDataRequested == true && context is DelayedAckConsumeContext delayedAckContext)
{
activity.SetContextTags(context)?.SetTag(TelemetryTags.Eventuous.Partition, delayedAckContext.PartitionId);
}
try {
await next(context).NoContext();
if (activity != null)
{
if (context.WasIgnored())
{
activity.ActivityTraceFlags = ActivityTraceFlags.None;
}
activity.SetActivityStatus(ActivityStatus.Ok());
}
}
catch (Exception e) {
activity?.SetActivityStatus(ActivityStatus.Error(e, $"Error handling {context.MessageType}"));
throw;
}
}
public async Task Consume(IMessageConsumeContext <RolePermissionUpdatedMessage> context)
{
try
{
var role_id = context.Message?.RoleUID;
if (ValidateHelper.IsEmpty(role_id))
{
throw new ArgumentNullException(nameof(context));
}
var cache = provider.ResolveDistributedCache_();
var keyManager = provider.Resolve_ <ICacheKeyManager>();
var repo = provider.Resolve_ <IRoleRepository>();
var query = repo.Queryable;
var page = 1;
var page_size = 500;
while (true)
{
var list = await repo.QueryAdminRoleEntity(role_id, page, page_size);
if (!list.Any())
{
break;
}
foreach (var m in list)
{
var key = keyManager.AdminPermission(m.AdminUID);
await cache.RemoveAsync(key);
}
++page;
}
}
catch (Exception e)
{
var logger = provider.Resolve_ <ILogger <RolePermissionChangedConsumer> >();
logger.AddErrorLog(nameof(RolePermissionChangedConsumer), e);
}
}
public override async ValueTask Consume(IMessageConsumeContext context)
{
if (context.Message == null)
{
return;
}
using var activity = Activity.Current?.Context != context.ParentContext
? SubscriptionActivity.Start(context, _defaultTags) : Activity.Current;
activity?.SetContextTags(context)?.Start();
try {
await _inner.Consume(context).NoContext();
}
catch (Exception e) {
activity?.SetStatus(ActivityStatus.Error(e, $"Error handling {context.MessageType}"));
throw;
}
}
public async ValueTask <EventHandlingStatus> HandleEvent(IMessageConsumeContext context)
{
const string retryKey = "eventuous-retry";
var pollyContext = new PollyContext {
{ retryKey, new RetryCounter() }
};
return(await _retryPolicy.ExecuteAsync(Execute, pollyContext).NoContext());
async Task <EventHandlingStatus> Execute(PollyContext ctx)
{
try {
return(await _inner.HandleEvent(context).NoContext());
}
catch (Exception e) {
var counter = ctx[retryKey] as RetryCounter;
Log.FailedToHandleMessageWithRetry(DiagnosticName, context.MessageType, counter !.Counter, e);
counter.Increase();
throw;
}
}
}
public async Task Consume(IMessageConsumeContext <AdWindowUsageLogMessage> context)
{
try
{
var order_uid = context.Message.OrderUID;
order_uid.Should().NotBeNullOrEmpty();
var order_service = provider.Resolve_ <IOrderService>();
var repo = provider.Resolve_ <IMetroAdRepository <OrderEntity> >();
var db = repo.Database;
var set = db.Set <AdWindowUsageEntity>();
set.RemoveRange(set.Where(x => x.OrderUID == order_uid));
await db.SaveChangesAsync();
var order = await order_service.GetByUID(order_uid);
order.Should().NotBeNull();
order = (await order_service.LoadItems(new[] { order })).First();
order.OrderItems.Should().NotBeNullOrEmpty();
var datas = this.__flat_data__(order);
if (datas.Any())
{
set.AddRange(datas);
await db.SaveChangesAsync();
}
}
catch (Exception e)
{
provider.Resolve_ <ILogger <AdWindowUsageConsumer> >().AddErrorLog(nameof(AdWindowUsageConsumer), e);
}
}
public override ValueTask<EventHandlingStatus> HandleEvent(IMessageConsumeContext evt) => default;
public async Task Consume(IMessageConsumeContext <TimeMessage> context)
{
this.logger.LogDebug(context.Message?.ToJson() ?? "errrrrrrrrrrrrrrrrr");
await Task.CompletedTask;
}
/// <summary>
/// Creates a new delayed ACK context instance
/// </summary>
/// <param name="inner">The original message context</param>
/// <param name="acknowledge">Function to ACK the message</param>
/// <param name="fail">Function to NACK the message in case of failure</param>
public DelayedAckConsumeContext(IMessageConsumeContext inner, Acknowledge acknowledge, Fail fail) : base(inner)
{
_acknowledge = acknowledge;
_fail = fail;
}
public override ValueTask <EventHandlingStatus> HandleEvent(IMessageConsumeContext context)
{
Called++;
Received = context;
return(default);
protected WrappedConsumeContext(IMessageConsumeContext innerContext) => InnerContext = innerContext;
public ValueTask <EventHandlingStatus> HandleEvent(IMessageConsumeContext context)
{
throw new NotImplementedException();
}
public override ValueTask Send(IMessageConsumeContext context, Func <IMessageConsumeContext, ValueTask>?next)
{
context.Items.AddItem(_key, _payload);
return(next?.Invoke(context) ?? default);
}
