/// <summary>
/// 获取实例
/// </summary>
/// <param name="provider">服务提供程序</param>
/// <param name="context">订阅上下文</param>
protected override object GetInstance(IServiceProvider provider, ConsumerContext context)
{
var capHeader = new CapHeader(context.DeliverMessage.Headers);
InitTraceIdContext(capHeader);
return(base.GetInstance(provider, context));
}
public Task Handle(CreateUserEvent @event, [FromCap] CapHeader header, CancellationToken cancellationToken)
{
//需要重新设置身份认证头
EngineContext.Current.ClaimManager.CapEventBusReSetClaim(header);
_logger.LogInformation($"Handling 'CreateUserEvent' eventId:{@event.Id}");
var cacheConfig = EngineContext.Current.GetAppModuleConfig <CacheConfig>();
var timeSpan = TimeSpan.FromSeconds(cacheConfig.CacheBaseConfig.DefaultCacheTime);
_locker.PerformActionWithLock(@event.Id.ToString(),
timeSpan, () =>
{
var command = new EventCreateUserCommand(
@event.UserAccount,
@event.UserPassword.ToMd5(),
@event.UserName,
@event.ContactNumber,
DataState.Enable,
UserType.TenantAdminUser, //此处创建的为租户管理员
@event.TenantId
);
_bus.SendCommand(command, cancellationToken).Wait(cancellationToken);
if (_notifications.HasNotifications())
{
var errorMessage = _notifications.GetNotificationMessage();
_logger.LogError(
$"Handling 'CreateUserEvent' event Error Code:{400},Message:{errorMessage}",
@event);
}
});
return(Task.CompletedTask);
}
public async Task <ConsumerExecutedResult> InvokeAsync(ConsumerContext context,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var methodInfo = context.ConsumerDescriptor.MethodInfo;
_logger.LogDebug("Executing subscriber method : {0}", methodInfo.Name);
var executor = _executors.GetOrAdd(methodInfo.MetadataToken,
x => ObjectMethodExecutor.Create(methodInfo, context.ConsumerDescriptor.ImplTypeInfo));
using var scope = _serviceProvider.CreateScope();
var provider = scope.ServiceProvider;
var obj = GetInstance(provider, context);
var message = context.DeliverMessage;
var parameterDescriptors = context.ConsumerDescriptor.Parameters;
var executeParameters = new object[parameterDescriptors.Count];
for (var i = 0; i < parameterDescriptors.Count; i++)
{
if (parameterDescriptors[i].IsFromCap)
{
executeParameters[i] = new CapHeader(message.Headers);
}
else
{
if (message.Value != null)
{
if (message.Value is JToken jToken) //reading from storage
{
executeParameters[i] = jToken.ToObject(parameterDescriptors[i].ParameterType);
}
else
{
var converter = TypeDescriptor.GetConverter(parameterDescriptors[i].ParameterType);
if (converter.CanConvertFrom(message.Value.GetType()))
{
executeParameters[i] = converter.ConvertFrom(message.Value);
}
else
{
executeParameters[i] =
Convert.ChangeType(message.Value, parameterDescriptors[i].ParameterType);
}
}
}
}
}
var resultObj = await ExecuteWithParameterAsync(executor, obj, executeParameters);
return(new ConsumerExecutedResult(resultObj, message.GetId(), message.GetCallbackName()));
}
public async Task <ConsumerExecutedResult> InvokeAsync(ConsumerContext context, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var methodInfo = context.ConsumerDescriptor.MethodInfo;
_logger.LogDebug("Executing subscriber method : {0}", methodInfo.Name);
var executor = _executors.GetOrAdd(methodInfo.MetadataToken, x => ObjectMethodExecutor.Create(methodInfo, context.ConsumerDescriptor.ImplTypeInfo));
using (var scope = _serviceProvider.CreateScope())
{
var provider = scope.ServiceProvider;
var srvType = context.ConsumerDescriptor.ServiceTypeInfo?.AsType();
var implType = context.ConsumerDescriptor.ImplTypeInfo.AsType();
object obj = null;
if (srvType != null)
{
obj = provider.GetServices(srvType).FirstOrDefault(o => o.GetType() == implType);
}
if (obj == null)
{
obj = ActivatorUtilities.GetServiceOrCreateInstance(provider, implType);
}
var message = context.DeliverMessage;
var parameterDescriptors = context.ConsumerDescriptor.Parameters;
var executeParameters = new object[parameterDescriptors.Count];
for (var i = 0; i < parameterDescriptors.Count; i++)
{
if (parameterDescriptors[i].IsFromCap)
{
executeParameters[i] = new CapHeader(message.Headers);
}
else
{
if (message.Value is JToken jToken) //reading from storage
{
executeParameters[i] = jToken.ToObject(parameterDescriptors[i].ParameterType);
}
else
{
executeParameters[i] = message.Value;
}
}
}
var resultObj = await ExecuteWithParameterAsync(executor, obj, executeParameters);
return(new ConsumerExecutedResult(resultObj, message.GetId(), message.GetCallbackName()));
}
}
public void AddPayment(Guid orderId, [FromCap] CapHeader header)
{
using (var transaction = _paymentDbContext.Database.BeginTransaction(_capBus, autoCommit: false))
{
_paymentDbContext.Payments.Add(new Entities.Payment()
{
OrderId = orderId
});
_paymentDbContext.SaveChanges();
transaction.Commit();
}
}
public async Task <IActionResult> CreateDeviceSms(List <EventQueue> items, [FromCap] CapHeader header)
{
var inserts = new List <DeviceSms>();
foreach (var item in items)
{
var data = await PreItem <DeviceSmsForDeviceDto>(item);
if (data == null)
{
continue;
}
var device = data.Item1;
var dto = data.Item2;
var sms = dto.MapTo <DeviceSms>();
if (string.IsNullOrEmpty(sms.FromPhone))
{
sms.FromPhone = device.Mobile;
}
if (string.IsNullOrEmpty(sms.FromPhone))
{
sms.FromPhone = " ";
}
if (string.IsNullOrEmpty(sms.ToPhone))
{
sms.ToPhone = device.Mobile;
}
if (string.IsNullOrEmpty(sms.ToPhone))
{
sms.ToPhone = " ";
}
sms.CreateTime = DateTime.Now;
sms.DeviceId = device.Id;
sms.FromPhone = sms.FromPhone?.Replace("+86", "").Trim();
sms.ToPhone = sms.ToPhone?.Replace("+86", "").Trim();
inserts.Add(sms);
}
if (inserts.Any())
{
await _deviceService.InsertDeviceSmsRange(inserts);
}
return(Success());
}
public async Task TestMessage1Async(TestMessage message, [FromCap] CapHeader header)
{
if (message.ThrowException)
{
throw new NotImplementedException("主动触发，暂未生效");
}
Debug.WriteLine(message.Id);
await MessageEventBus.PublishAsync(new TestMessageEvent2(message, message.Send));
if (message.NeedCommit)
{
await UnitOfWork.CommitAsync();
}
}
public Task RetryEvent(IEvent @event, EventContext context)
{
Check.NotNull(@event, nameof(@event));
Check.NotNull(context, nameof(context));
var header = (context as CapEventPublishContext)?.Header;
if (header != null && header.TryGetValue("retry-count", out string retryCount))
{
var dict = header.ToDictionary(d => d.Key, d => d.Value);
dict["retry-count"] = (retryCount.ParseByInt() + 1).ToString();
header = new CapHeader(dict);
}
return(_capPublisher.PublishAsync(context.RouteKey, @event, header));
}
/// <summary>
/// 初始化跟踪标识上下文
/// </summary>
private static void InitTraceIdContext(CapHeader capHeader)
{
if (!capHeader.TryGetValue(Headers.TraceId, out var traceId))
{
return;
}
if (TraceIdContext.Current == null)
{
TraceIdContext.Current = new TraceIdContext(traceId);
}
else
{
TraceIdContext.Current.TraceId = traceId;
}
}
public async Task TestMessage1Async(TestMessage message, [FromCap] CapHeader header)
{
if (message.ThrowException)
{
throw new NotImplementedException("主动触发，暂未生效");
}
Log.Info($"测试一波CAP消息 - 0: {message.Id}");
Logger.LogDebug($"测试一波CAP消息 - 1: {message.Id}");
var log = Bing.Logs.Log.GetLog(nameof(TestMessageEventHandler));
log.Debug($"测试一波CAP消息 - 1 - 1: {message.Id}");
Debug.WriteLine(message.Id);
await MessageEventBus.PublishAsync(new TestMessageEvent2(message, message.Send));
if (message.NeedCommit)
{
await UnitOfWork.CommitAsync();
}
}
/// <summary>
/// 初始化跟踪标识上下文
/// </summary>
private void InitTraceIdContext(CapHeader capHeader)
{
if (capHeader == null)
{
return;
}
if (!capHeader.TryGetValue("bing-trace-id", out var traceId))
{
return;
}
_logger.LogDebug("Init TraceId: {0}", traceId);
if (TraceIdContext.Current == null)
{
TraceIdContext.Current = new TraceIdContext(traceId);
}
else
{
TraceIdContext.Current.TraceId = traceId;
}
}
public Task Handle(RemoveAuthorizeCacheEvent @event, [FromCap] CapHeader header,
CancellationToken cancellationToken)
{
EngineContext.Current.ClaimManager.CapEventBusReSetClaim(header);
_locker.PerformActionWithLock(@event.Id.ToString(),
TimeSpan.FromMinutes(30),
() =>
{
try
{
_staticCacheManager.RemoveByPrefix(GirvsAuthorizePermissionCacheKeyManager
.CurrentUserAuthorizeCacheKeyPrefix);
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
}
});
return(Task.CompletedTask);
}
private async Task <TelemetrySpan> PreBefore(CapHeader header)
{
if (!header.ContainsKey(CurrentDeviceId))
{
throw new Exception("currentDeviceId不可为空");
}
_dbContextFactory.IsTransaction = true;
var deviceId = Convert.ToInt32(header[CurrentDeviceId]);
var deviceDto = await _deviceService.GetDeviceById_Pref(deviceId);
_current.Device = deviceDto;
var tracer = _tracerFactory.GetTracer(header[CapMsgName]);
var traceId = header.ContainsKey(TraceId) ? header[TraceId] : CommonHelper.NewSequentialGuid().ToString();
var spanId = tracer.CurrentSpan.Context.SpanId;
var spanContext = new SpanContext(
ActivityTraceId.CreateFromString(traceId),
spanId, // ActivitySpanId.CreateFromString(""),
ActivityTraceFlags.None);
return(tracer.StartSpan(header[CapMsgName], spanContext, SpanKind.Server));
}
public async Task <ConsumerExecutedResult> InvokeAsync(ConsumerContext context, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var methodInfo = context.ConsumerDescriptor.MethodInfo;
var reflectedType = methodInfo.ReflectedType.Name;
_logger.LogDebug("Executing subscriber method : {0}", methodInfo.Name);
var key = $"{methodInfo.Module.Name}_{reflectedType}_{methodInfo.MetadataToken}";
var executor = _executors.GetOrAdd(key, x => ObjectMethodExecutor.Create(methodInfo, context.ConsumerDescriptor.ImplTypeInfo));
using (var scope = _serviceProvider.GetService <ICapServiceScope>())
{
var obj = scope.GetInstance(context);
var message = context.DeliverMessage;
var parameterDescriptors = context.ConsumerDescriptor.Parameters;
var executeParameters = new object[parameterDescriptors.Count];
for (var i = 0; i < parameterDescriptors.Count; i++)
{
if (parameterDescriptors[i].IsFromCap)
{
executeParameters[i] = new CapHeader(message.Headers);
}
else
{
if (message.Value != null)
{
if (_serializer.IsJsonType(message.Value)) // use ISerializer when reading from storage, skip other objects if not Json
{
executeParameters[i] = _serializer.Deserialize(message.Value, parameterDescriptors[i].ParameterType);
}
else
{
var converter = TypeDescriptor.GetConverter(parameterDescriptors[i].ParameterType);
if (converter.CanConvertFrom(message.Value.GetType()))
{
executeParameters[i] = converter.ConvertFrom(message.Value);
}
else
{
if (parameterDescriptors[i].ParameterType.IsInstanceOfType(message.Value))
{
executeParameters[i] = message.Value;
}
else
{
executeParameters[i] = Convert.ChangeType(message.Value, parameterDescriptors[i].ParameterType);
}
}
}
}
}
}
var resultObj = await ExecuteWithParameterAsync(executor, obj, executeParameters);
return(new ConsumerExecutedResult(resultObj, message.GetId(), message.GetCallbackName()));
}
}
public static void CapEventBusReSetClaim(this IGirvsClaimManager claimManager, CapHeader capHeader)
{
var claimdic = capHeader.ToDictionary(x => x.Key, v => v.Value);
claimdic.SetDictionaryKeyValue(GirvsIdentityClaimTypes.IdentityType,
IdentityType.EventMessageUser.ToString());
claimManager.SetFromDictionary(claimdic);
}
public void CheckReceivedMessage1(string message, [FromCap] CapHeader header)
{
Console.WriteLine(header["my.kafka.offset"]);
Console.WriteLine(header["my.kafka.partition"]);
}
public abstract Task Handle(TIntegrationEvent @event, CapHeader header, CancellationToken cancellationToken);
private void SubscribeCallback(object model, [FromCap] CapHeader headers)
{
var callbackId = headers[Headers.CorrelationId];
_callbackService.AddResponse(callbackId, model);
}
public void MSubscribe(Person p, [FromCap] CapHeader header)
{
var id = header[Headers.MessageId];
_logger.LogInformation($@"{DateTime.Now} Subscriber invoked for message {id}, Info: {p}");
}
public void Cap(string message, [FromCap] CapHeader header)
{
Console.WriteLine($"Cap {message}");
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(header));
}
public void EntitiesCreatedSubscribe(EntitiesCreatedIntegrationEvent value, [FromCap] CapHeader header)
{
_logger.LogDebug("EntitiesCreatedSubscribe.Headers:{@header} Value{@value}", header, value);
}
public void Date(Message <DateTime> message, [FromCap] CapHeader header)
{
Console.WriteLine($"Date: {System.Text.Json.JsonSerializer.Serialize(message)}");
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(header));
}
public void Bytes(Message <byte[]> message, [FromCap] CapHeader header)
{
Console.WriteLine($"Bytes: {System.Text.Json.JsonSerializer.Serialize(message)}");
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(header));
}
public async Task Subscriber2(long id, [FromCap] CapHeader header)
{
var person = await _service.GetByIdAsync(id);
Console.WriteLine($@"{DateTime.Now} Subscriber invoked, Info: {person}");
}
public void Subscriber2(Person p, [FromCap] CapHeader header)
{
var id = header[Headers.MessageId];
Console.WriteLine($@"{DateTime.Now} Subscriber invoked, Info: {p}");
}
public void Subscribe(Person p, [FromCap] CapHeader header)
{
_logger.LogInformation("Subscribe Invoked: " + MyTopic + p);
}
/// <summary>
/// 调用订阅者方法
/// </summary>
/// <param name="context"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <ConsumerExecutedResult> InvokeAsync(ConsumerContext context, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var methodInfo = context.ConsumerDescriptor.MethodInfo;
var reflectedType = methodInfo.ReflectedType.Name;
_logger.LogDebug("Executing subscriber method : {0}", methodInfo.Name);
var key = $"{methodInfo.Module.Name}_{reflectedType}_{methodInfo.MetadataToken}";
var executor = _executors.GetOrAdd(key, x => ObjectMethodExecutor.Create(methodInfo, context.ConsumerDescriptor.ImplTypeInfo));
using var scope = _serviceProvider.CreateScope();
var provider = scope.ServiceProvider;
var obj = GetInstance(provider, context);
var message = context.DeliverMessage;
var parameterDescriptors = context.ConsumerDescriptor.Parameters;
var executeParameters = new object[parameterDescriptors.Count];
// 租户数据可能在消息标头中
var tenantId = message.GetTenantIdOrNull();
for (var i = 0; i < parameterDescriptors.Count; i++)
{
if (parameterDescriptors[i].IsFromCap)
{
executeParameters[i] = new CapHeader(message.Headers);
}
else
{
if (message.Value != null)
{
if (_serializer.IsJsonType(message.Value)) // use ISerializer when reading from storage, skip other objects if not Json
{
var eventData = _serializer.Deserialize(message.Value, parameterDescriptors[i].ParameterType);
// 租户数据也可能存在事件数据中
if (tenantId == null && eventData is IMultiTenant tenant)
{
tenantId = tenant.TenantId;
}
executeParameters[i] = eventData;
}
else
{
var converter = TypeDescriptor.GetConverter(parameterDescriptors[i].ParameterType);
if (converter.CanConvertFrom(message.Value.GetType()))
{
var eventData = converter.ConvertFrom(message.Value);
// 租户数据也可能存在事件数据中
if (tenantId == null && eventData is IMultiTenant tenant)
{
tenantId = tenant.TenantId;
}
executeParameters[i] = eventData;
}
else
{
if (parameterDescriptors[i].ParameterType.IsInstanceOfType(message.Value))
{
// 租户数据也可能存在事件数据中
if (tenantId == null && message.Value is IMultiTenant tenant)
{
tenantId = tenant.TenantId;
}
executeParameters[i] = message.Value;
}
else
{
var eventData = Convert.ChangeType(message.Value, parameterDescriptors[i].ParameterType);
// 租户数据也可能存在事件数据中
if (tenantId == null && eventData is IMultiTenant tenant)
{
tenantId = tenant.TenantId;
}
executeParameters[i] = eventData;
}
}
}
}
}
}
// 改变租户
using (_currentTenant.Change(tenantId))
{
var resultObj = await ExecuteWithParameterAsync(executor, obj, executeParameters);
return(new ConsumerExecutedResult(resultObj, message.GetId(), message.GetCallbackName()));
}
}
public Task Handle(AuthorizeEvent @event, [FromCap] CapHeader header, CancellationToken cancellationToken)
{
_logger.LogInformation($"Handling 'AuthorizeEvent' eventId:{@event.Id}");
//需要重新设置身份认证头
EngineContext.Current.ClaimManager.CapEventBusReSetClaim(header);
var cacheConfig = EngineContext.Current.GetAppModuleConfig <CacheConfig>();
var timeSpan = TimeSpan.FromSeconds(cacheConfig.CacheBaseConfig.DefaultCacheTime);
var isLock = _locker.PerformActionWithLock(@event.Id.ToString(),
timeSpan, () =>
{
var servicePermissionCommandModels = new List <ServicePermissionCommandModel>();
foreach (var permissionAuthoriz in @event.AuthorizePermissions)
{
servicePermissionCommandModels.Add(new ServicePermissionCommandModel()
{
ServiceName = permissionAuthoriz.ServiceName,
ServiceId = permissionAuthoriz.ServiceId,
Permissions = permissionAuthoriz.Permissions,
OperationPermissionModels = permissionAuthoriz.OperationPermissionModels
});
}
var serviceDataRuleCommandModels = new List <ServiceDataRuleCommandModel>();
foreach (var authorizeDataRule in @event.AuthorizeDataRules)
{
foreach (var dataRuleFieldModel in authorizeDataRule.AuthorizeDataRuleFieldModels)
{
serviceDataRuleCommandModels.Add(new ServiceDataRuleCommandModel()
{
EntityTypeName = authorizeDataRule.EntityTypeName,
EntityDesc = authorizeDataRule.EntityDesc,
FieldName = dataRuleFieldModel.FieldName,
FieldType = dataRuleFieldModel.FieldType,
FieldValue = dataRuleFieldModel.FieldValue,
ExpressionType = dataRuleFieldModel.ExpressionType,
FieldDesc = dataRuleFieldModel.FieldDesc,
UserType = dataRuleFieldModel.UserType
});
}
}
var command =
new NeedAuthorizeListCommand(servicePermissionCommandModels, serviceDataRuleCommandModels);
_bus.SendCommand(command).Wait(cancellationToken);
if (_notifications.HasNotifications())
{
var errorMessage = _notifications.GetNotificationMessage();
_logger.LogError(
$"Handling 'AuthorizeEvent' event Error Code:{400},Message:{errorMessage}",
@event);
}
});
_logger.LogInformation($"本次事件处理过程中，Reids锁的情况为：{isLock} 事件ID为：{@event.Id}");
return(Task.CompletedTask);
}
public void Subscriber2(DateTime p, [FromCap] CapHeader header)
{
Console.WriteLine($@"{DateTime.Now} Subscriber invoked, Info: {p}");
}
public void Subscribe(Person p, [FromCap] CapHeader header)
{
_logger.LogInformation($"{header[Headers.MessageName]} subscribed with value --> " + p);
}
