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();
        }
Ejemplo n.º 5
0
        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();
        }
Ejemplo n.º 6
0
        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);
 }
Ejemplo n.º 14
0
        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!");
            }
        }
Ejemplo n.º 15
0
 public void UnsubscribeRpcClient <TR, TH>(string routingKey)
     where TR : IIntegrationEventReply
     where TH : IIntegrationRpcClientHandler <TR>
 {
     SubsManager.RemoveSubscriptionRpcClient <TR, TH>(routingKey);
 }