public async ValueTask <bool> CallAsync( IMessageScope scope, IMessageHandlerFactory handlerFactory, IMessage message, IRichMessageDescriptor messageDescriptor, List <Exception> exceptions = null, CancellationToken cancellationToken = default) { exceptions = exceptions ?? new List <Exception>(); var handlerDescriptor = handlerFactory.GetHandlerDescriptor(); if (handlerDescriptor.IsAsync) { if (handlerDescriptor.IsRich) { await ProcessRichMessageHandlingExceptionAsync(scope, handlerFactory, handlerDescriptor.MessageType, message, messageDescriptor, exceptions); } else { await ProcessMessageHandlingExceptionAsync(scope, handlerFactory, handlerDescriptor.MessageType, message, exceptions); } } else { if (handlerDescriptor.IsRich) { ProcessRichMessageHandlingException(scope, handlerFactory, handlerDescriptor.MessageType, message, messageDescriptor, exceptions); } else { ProcessMessageHandlingException(scope, handlerFactory, handlerDescriptor.MessageType, message, exceptions); } } return(true); }
private ICoreSession ParseSession(IRichMessageDescriptor messageDescriptor) { if (messageDescriptor.Headers is null) { return(null); } messageDescriptor.Headers.TryGetValue(SessionConsts.CityId, out var city); messageDescriptor.Headers.TryGetValue(SessionConsts.CompanyId, out var companyId); messageDescriptor.Headers.TryGetValue(SessionConsts.CompanyName, out var companyName); messageDescriptor.Headers.TryGetValue(SessionConsts.StoreId, out var storeId); messageDescriptor.Headers.TryGetValue(SessionConsts.StoreName, out var storeName); messageDescriptor.Headers.TryGetValue(SessionConsts.BrokerId, out var brokerId); messageDescriptor.Headers.TryGetValue(SessionConsts.BrokerName, out var brokerName); messageDescriptor.Headers.TryGetValue(SessionConsts.OrganizationId, out var organizationId); messageDescriptor.Headers.TryGetValue(SessionConsts.OrganizationName, out var organizationName); messageDescriptor.Headers.TryGetValue(SessionConsts.CurrentUserId, out var currentUserId); messageDescriptor.Headers.TryGetValue(SessionConsts.CurrentUserName, out var currentUserName); var session = new CoreSession( TryConvertFromBytes(city as byte[]), TryConvertFromBytes(companyId as byte[]).AsGuidOrNull(), TryUriDecode(TryConvertFromBytes(companyName as byte[])), TryConvertFromBytes(storeId as byte[]).AsGuidOrNull(), TryUriDecode(TryConvertFromBytes(storeName as byte[])), TryConvertFromBytes(brokerId as byte[]), TryUriDecode(TryConvertFromBytes(brokerName as byte[])), TryConvertFromBytes(organizationId as byte[]), TryUriDecode(TryConvertFromBytes(organizationName as byte[])), TryConvertFromBytes(currentUserId as byte[]), TryUriDecode(TryConvertFromBytes(currentUserName as byte[]))); return(session); }
public void HandleMessage(WebTestMessage message, IRichMessageDescriptor descriptor) { if (_coreSessionProvider is MessageCoreSessionProvider provider) { if (provider.MessageDescriptor == descriptor) { return; } } throw new ApplicationException("Session错误"); }
public IMessageScope CreateScope(IMessage message, IRichMessageDescriptor messageDescriptor) { var sessionProvider = new MessageCoreSessionProvider(message, messageDescriptor); var scope = _lifetimeScope.BeginLifetimeScope(builder => { builder.RegisterInstance(sessionProvider) .As <ICoreSessionProvider>() .PropertiesAutowired(); }); var messageScope = new MessageScope(scope); return(messageScope); }
private async ValueTask ProcessMessageAsync( IRichMessageDescriptor descriptor, byte[] message) { Logger.LogInformation($"ProcessMessageAsync: Exchange: {descriptor.MessageGroup}, Topic: {descriptor.MessageTopic}"); if (!_subscribers.TryGetValue(descriptor, out var func)) { Logger.LogWarning($"ProcessMessageAsync: Subscriber not exists"); return; } var typedMessage = _messageConverter.Deserialize(descriptor, message); if (typedMessage == null) { Logger.LogWarning($"ProcessMessageAsync: Cannot convert message to a typed message"); return; } await func(typedMessage, descriptor); }
public virtual async ValueTask OnMessageReceivedAsync(IMessage message, IRichMessageDescriptor descriptor) { if (message is null) { return; } using (var scope = _scopeCreator.CreateScope(message, descriptor)) { var messageStore = scope.Resolve(typeof(IConsumedMessageStore)) as IConsumedMessageStore; if (await messageStore.IsConsumedAsync(descriptor, message)) { _logger.LogWarning($"[{descriptor.MessageGroup}][{descriptor.MessageTopic}][{descriptor.MessageId}]Message already consumed."); return; } await ProcessMessageAsync(scope, message.GetType(), message, descriptor); await messageStore.StoreAsync(descriptor, message); } }
public IMessageScope CreateScope(IMessage message, IRichMessageDescriptor messageDescriptor) { var coreSessionProvider = new MessageCoreSessionProvider(message, messageDescriptor); return(new MessageScope(_iocManager, coreSessionProvider)); }
public MessageCoreSessionProvider(IMessage message, IRichMessageDescriptor messageDescriptor) { _message = message; MessageDescriptor = messageDescriptor; }
ValueTask IMessageBus.OnMessageReceivedAsync(IMessage message, IRichMessageDescriptor descriptor) { return(new ValueTask()); }
public async ValueTask <bool> CallAsync(IMessageScope scope, IMessageHandlerFactory handlerFactory, IMessage message, IRichMessageDescriptor messageDescriptor, List <Exception> exceptions = null, CancellationToken cancellationToken = default) { var handlerDescriptor = handlerFactory.GetHandlerDescriptor(); IMessageHandler handler = null; try { handler = handlerFactory.GetHandler(scope); if (handlerDescriptor.IsAsync) { await GetOrCreateAsyncHandlerCallCache(handlerDescriptor).Invoke(handler, message, messageDescriptor); } else { GetOrCreateSyncHandlerCallCache(handlerDescriptor).Invoke(handler, message, messageDescriptor); } } catch (TargetInvocationException e) { exceptions?.Add(e.InnerException); return(false); } catch (Exception e) { exceptions?.Add(e); return(false); } finally { if (handler != null) { handlerFactory.ReleaseHandler(scope, handler); } } return(true); }
private async ValueTask ProcessRichMessageHandlingExceptionAsync(IMessageScope scope, IMessageHandlerFactory asyncHandlerFactory, Type messageType, IMessage message, IRichMessageDescriptor descriptor, List <Exception> exceptions) { var handlerInstance = asyncHandlerFactory.GetHandler(scope); try { if (handlerInstance == null) { throw new ArgumentNullException($"Registered async rich message handler for message type {messageType.Name} is null!"); } var ifType = typeof(IAsyncRichMessageHandler <>).MakeGenericType(messageType); var method = ifType.GetMethod( nameof(IAsyncRichMessageHandler <IMessage> .HandleMessageAsync), new[] { messageType, typeof(IRichMessageDescriptor) } ); await(ValueTask) method.Invoke(handlerInstance, new object[] { message, descriptor }); } catch (TargetInvocationException ex) { exceptions.Add(ex.InnerException); } catch (Exception ex) { exceptions.Add(ex); } finally { asyncHandlerFactory.ReleaseHandler(scope, handlerInstance); } }
private void ProcessRichMessageHandlingException(IMessageScope scope, IMessageHandlerFactory handlerFactory, Type messageType, IMessage message, IRichMessageDescriptor descriptor, List <Exception> exceptions) { var eventHandler = handlerFactory.GetHandler(scope); try { if (eventHandler == null) { throw new ArgumentNullException($"Registered rich message handler for message type {messageType.Name} is null!"); } var handlerType = typeof(IRichMessageHandler <>).MakeGenericType(messageType); var method = handlerType.GetMethod( nameof(IRichMessageHandler <IMessage> .HandleMessage), new[] { messageType, typeof(IRichMessageDescriptor) } ); method.Invoke(eventHandler, new object[] { message, descriptor }); } catch (TargetInvocationException ex) { exceptions.Add(ex.InnerException); } catch (Exception ex) { exceptions.Add(ex); } finally { handlerFactory.ReleaseHandler(scope, eventHandler); } }
public IMessageScope CreateScope(IMessage message, IRichMessageDescriptor messageDescriptor) { return(new NullMessageScope()); }
protected async ValueTask ProcessMessageAsync(IMessageScope scope, Type messageType, IMessage message, IRichMessageDescriptor descriptor) { var exceptions = new List <Exception>(); await new SynchronizationContextRemover(); foreach (var handlerFactories in _messageHandlerFactoryStore.GetHandlerFactories(messageType).ToList()) { foreach (var handlerFactory in handlerFactories.MessageHandlerFactories) { var isCallSuccess = await _messageHandlerCaller.CallAsync(scope, handlerFactory, message, descriptor, exceptions); if (!isCallSuccess) { var errorMessage = $"Call message handler error"; exceptions.Add(new MessageBusException(errorMessage)); } } } //Implements generic argument inheritance. See IMessageWithInheritableGenericArgument if (messageType.IsGenericType && messageType.GenericTypeArguments.Length == 1 && typeof(IMessageWithInheritableGenericArgument).IsAssignableFrom(messageType)) { var genericArg = messageType.GetGenericArguments()[0]; var baseArg = genericArg.BaseType; if (baseArg != null) { var baseMessageType = messageType.GetGenericTypeDefinition().MakeGenericType(baseArg); var constructorArgs = ((IMessageWithInheritableGenericArgument)messageType).GetConstructorArgs(); //TODO: Use Expression Tree instead / or do Inheritable Abstractions var baseMessage = (IMessage)Activator.CreateInstance(baseMessageType, constructorArgs); await ProcessMessageAsync(scope, baseMessageType, baseMessage, descriptor); } } if (exceptions.Any()) { if (exceptions.Count == 1) { ExceptionDispatchInfo.Capture(exceptions[0]).Throw(); } throw new AggregateException("More than one error has occurred while handling the message: " + messageType, exceptions); } }