protected override void DisposeManagedResources() { _consumerChannelReply?.Dispose(); ConsumerChannel?.Dispose(); SubsManager?.Clear(); SubsManager?.ClearReply(); }
public void SubscribeDynamic <TH>(string eventName) where TH : IDynamicIntegrationEventHandler { DoInternalSubscription(eventName); SubsManager.AddDynamicSubscription <TH>(eventName); StartBasicConsume(); }
public void UnsubscribeRpc <T, TR, TH>(string routingKey) where T : IIntegrationEvent where TH : IIntegrationRpcHandler <T, TR> where TR : IIntegrationEventReply { SubsManager.RemoveSubscriptionRpc <T, TR, TH>(routingKey); }
public void SubscribeQueue <T, TH>(string routingKey) where T : IIntegrationEvent where TH : IIntegrationQueueHandler <T> { var eventName = SubsManager.GetEventKey <T>(); DoInternalSubscription(eventName + "." + routingKey); SubsManager.AddSubscriptionQueue <T, TH>(eventName + "." + routingKey); StartBasicConsume(); }
public void SubscribeRpcClient <TR, TH>(string routingKey) where TR : IIntegrationEventReply where TH : IIntegrationRpcClientHandler <TR> { //var eventName = SubsManager.GetEventKey<T>(); var eventNameResult = SubsManager.GetEventReplyKey <TR>(); Logger.LogDebug("SubscribeRpcClient: eventNameResult: " + eventNameResult + "." + routingKey); DoInternalSubscriptionRpc(/*eventName + "." + routingKey,*/ eventNameResult + "." + routingKey); SubsManager.AddSubscriptionRpcClient <TR, TH>(/*eventName + "." + routingKey,*/ eventNameResult + "." + routingKey); StartBasicConsume(); //StartBasicConsumeReply(); }
public void SubscribeRpcServer <T, TR, TH>(string routingKey) where T : IIntegrationEventRpc where TR : IIntegrationEventReply where TH : IIntegrationRpcServerHandler <T, TR> { var eventName = SubsManager.GetEventKey <T>(); var eventNameResult = SubsManager.GetEventReplyKey <TR>(); DoInternalSubscriptionRpc(eventName + "." + routingKey, eventNameResult + "." + routingKey); SubsManager.AddSubscriptionRpcServer <T, TR, TH>(eventName + "." + routingKey, eventNameResult + "." + routingKey); StartBasicConsume(); //StartBasicConsumeReply(); }
public void SubscribeRpc <T, TR, TH>(string routingKey) where T : IIntegrationEvent where TR : IIntegrationEventReply where TH : IIntegrationRpcHandler <T, TR> { var eventName = SubsManager.GetEventKey <T>(); var eventNameResult = SubsManager.GetEventReplyKey <TR>(); Logger.LogDebug("SubscribeRpc: eventName: " + eventName + "." + routingKey + " eventNameResult: " + eventNameResult + "." + routingKey); DoInternalSubscriptionRpc(eventName + "." + routingKey, eventNameResult + "." + routingKey); SubsManager.AddSubscriptionRpc <T, TR, TH>(eventName + "." + routingKey, eventNameResult + "." + routingKey); StartBasicConsume(); StartBasicConsumeReply(); }
protected override async ValueTask ProcessEvent(string routingKey, string eventName, ReadOnlyMemory <byte> message, CancellationToken cancel = default) { if (SubsManager.HasSubscriptionsForEvent(routingKey)) { var subscriptions = SubsManager.GetHandlersForEvent(routingKey); foreach (var subscription in subscriptions) { switch (subscription.SubscriptionManagerType) { case SubscriptionManagerType.Queue: try { if (EventHandler is null) { } else { var eventType = SubsManager.GetEventTypeByName(routingKey); await using var ms = new MemoryStream(message.ToArray()); var integrationEvent = Serializer.Deserialize(eventType, ms); var concreteType = typeof(IIntegrationQueueHandler <>).MakeGenericType(eventType); await((ValueTask <bool>)concreteType.GetMethod("Enqueue") .Invoke(EventHandler, new[] { integrationEvent, cancel })).ConfigureAwait(false); } } catch (Exception ex) { Logger.LogError("ProcessQueue: " + ex.Message + " - " + ex.StackTrace); } break; case SubscriptionManagerType.Dynamic: break; case SubscriptionManagerType.Typed: break; case SubscriptionManagerType.Rpc: break; default: throw new ArgumentOutOfRangeException(); } } } }//ProcessEvent.
private void DoInternalSubscriptionRpc(string eventName, string eventNameResult) { var containsKey = SubsManager.HasSubscriptionsForEvent(eventName); if (containsKey) { return; } if (!PersistentConnection.IsConnected) { PersistentConnection.TryConnect(); } using var channel = PersistentConnection.CreateModel(); channel.QueueBind(QueueName, ExchangeDeclareParameters.ExchangeName, eventName); channel.QueueBind(_queueNameReply, ExchangeDeclareParameters.ExchangeName, eventNameResult); }
private async ValueTask <dynamic> ProcessEventRpc(string routingKey, string eventName, ReadOnlyMemory <byte> message, CancellationToken cancel = default) { dynamic output = null; if (SubsManager.HasSubscriptionsForEvent(routingKey)) { var subscriptions = SubsManager.GetHandlersForEvent(routingKey); if (!subscriptions.Any()) { Logger.LogError("ProcessEventRpc subscriptions no items! " + routingKey); } foreach (var subscription in subscriptions) { switch (subscription.SubscriptionManagerType) { case SubscriptionManagerType.Rpc: try { if (EventHandler is null) { Logger.LogError("ProcessEventRpc _eventHandler is null!"); } else { var eventType = SubsManager.GetEventTypeByName(routingKey); if (eventType is null) { Logger.LogError("ProcessEventRpc: eventType is null! " + routingKey); return(null); } var eventReplyType = SubsManager.GetEventReplyTypeByName(routingKey); if (eventReplyType is null) { Logger.LogError("ProcessEventRpc: eventReplyType is null! " + routingKey); return(null); } using (var ms = new MemoryStream(message.ToArray())) { var integrationEvent = Serializer.Deserialize(eventType, ms); var concreteType = typeof(IIntegrationRpcHandler <,>).MakeGenericType(eventType, eventReplyType); output = await((dynamic)concreteType.GetMethod("HandleRpcAsync") .Invoke(EventHandler, new[] { integrationEvent, cancel })).ConfigureAwait(false); if (output is null) { Logger.LogError("ProcessEventRpc output is null!"); } } } } catch (Exception ex) { Logger.LogError("ProcessEventRpc: " + ex.Message + " - " + ex.StackTrace); } break; case SubscriptionManagerType.Dynamic: break; case SubscriptionManagerType.Typed: break; case SubscriptionManagerType.Queue: break; default: throw new ArgumentOutOfRangeException(); } } } else { Logger.LogError("ProcessEventRpc HasSubscriptionsForEvent " + routingKey + " No Subscriptions!"); } return(output); }//ProcessEventRpc.
public void UnsubscribeQueue <T, TH>(string routingKey) where T : IIntegrationEvent where TH : IIntegrationQueueHandler <T> { SubsManager.RemoveSubscriptionQueue <T, TH>(routingKey); }
protected override async ValueTask ProcessEvent(string routingKey, string eventName, ReadOnlyMemory <byte> message, CancellationToken cancel = default) { if (SubsManager.HasSubscriptionsForEvent(routingKey)) { if (_autofac != null) { await using var scope = _autofac.BeginLifetimeScope(AutofacScopeName); var subscriptions = SubsManager.GetHandlersForEvent(routingKey); foreach (var subscription in subscriptions) { //if (subscription.IsDynamic) //{ // var handler = // scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler; // //ToDo // //dynamic eventData = JObject.Parse(message); // //await using var ms = new MemoryStream(message); // //var integrationEvent = Serializer.Deserialize(eventType, ms); // //await handler.Handle(eventData); //} //else //{ // var eventType = _subsManager.GetEventTypeByName(routingKey); // //var integrationEvent = JsonConvert.DeserializeObject(message, eventType); // await using var ms = new MemoryStream(message); // var integrationEvent = Serializer.Deserialize(eventType, ms); // var handler = scope.ResolveOptional(subscription.HandlerType); // var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType); // await (ValueTask) concreteType.GetMethod("Handle") // .Invoke(handler, new[] {integrationEvent}); //} switch (subscription.SubscriptionManagerType) { //case InMemoryEventBusSubscriptionsManager.SubscriptionManagerType.Dynamic: // var handler = // scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler; // //ToDo // //dynamic eventData = JObject.Parse(message); // await using var ms = new MemoryStream(message); // var integrationEvent = Serializer.Deserialize(eventType, ms); // await handler.Handle(eventData); // break; //default: // { // var eventType = _subsManager.GetEventTypeByName(routingKey); // //var integrationEvent = JsonConvert.DeserializeObject(message, eventType); // await using var ms = new MemoryStream(message); // var integrationEvent = Serializer.Deserialize(eventType, ms); // var handler = scope.ResolveOptional(subscription.HandlerType); // var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType); // await (ValueTask)concreteType.GetMethod("Handle") // .Invoke(handler, new[] { integrationEvent, cancel }); // break; // } } } } } }//ProcessEvent.
public void UnsubscribeDynamic <TH>(string eventName) where TH : IDynamicIntegrationEventHandler { SubsManager.RemoveDynamicSubscription <TH>(eventName); }
private async ValueTask ProcessEventReply(string routingKey, string eventName, ReadOnlyMemory <byte> message, TaskCompletionSource <dynamic> tcs, CancellationToken cancel = default) { if (SubsManager.HasSubscriptionsForEventReply(routingKey)) { var subscriptions = SubsManager.GetHandlersForEventReply(routingKey); if (!subscriptions.Any()) { Logger.LogError("ProcessEventReply subscriptions no items! " + routingKey); } foreach (var subscription in subscriptions) { switch (subscription.SubscriptionManagerType) { case SubscriptionManagerType.Rpc: break; case SubscriptionManagerType.RpcClient: try { if (EventHandler is null) { Logger.LogError("ProcessEventReplyClient _eventHandler is null!"); } else { //var eventType = SubsManager.GetEventTypeByName(routingKey); //if (eventType is null) //{ // Logger.LogError("ProcessEventReplyClient: eventType is null! " + routingKey); // return; //} var eventResultType = SubsManager.GetEventReplyTypeByName(routingKey); if (eventResultType is null) { Logger.LogError("ProcessEventReplyClient: eventResultType is null! " + routingKey); return; } await using var ms = new MemoryStream(message.ToArray()); var integrationEvent = Serializer.Deserialize(eventResultType, ms); tcs.TrySetResult(integrationEvent); var concreteType = typeof(IIntegrationRpcClientHandler <>).MakeGenericType( eventResultType); await((ValueTask)concreteType.GetMethod("HandleReply") .Invoke(EventHandler, new[] { integrationEvent, cancel })).ConfigureAwait(false); } } catch (Exception ex) { Logger.LogError("ProcessEventReplyClient: " + ex.Message + " - " + ex.StackTrace); } break; case SubscriptionManagerType.RpcServer: break; case SubscriptionManagerType.Dynamic: break; case SubscriptionManagerType.Typed: break; case SubscriptionManagerType.Queue: break; default: throw new ArgumentOutOfRangeException(); } } } else { Logger.LogError("ProcessEventReplyClient HasSubscriptionsForEventReply " + routingKey + " No Subscriptions!"); } }
public void UnsubscribeRpcClient <TR, TH>(string routingKey) where TR : IIntegrationEventReply where TH : IIntegrationRpcClientHandler <TR> { SubsManager.RemoveSubscriptionRpcClient <TR, TH>(routingKey); }