Exemple #1
0
        public InterDomainMessageResponse ProcessMessage(IInterDomainMessage message)
        {
            InterDomainMessageResponse ret  = null;
            RoutedInterDomainMessage   ridm = (RoutedInterDomainMessage)message;

            lock (_myRoutes)
            {
                foreach (sRoute srt in ridm.HandlerRoutes)
                {
                    if (_myRoutes.Contains(srt))
                    {
                        if (_messageController.HandlesMessage(ridm))
                        {
                            ret = new InterDomainMessageResponse(ridm, _messageController.ProcessMessage(ridm));
                            break;
                        }
                    }
                }
            }
            if (ret == null)
            {
                lock (_subRoutes)
                {
                    foreach (sRoute srt in ridm.HandlerRoutes)
                    {
                        if (_subRoutes.ContainsKey(srt))
                        {
                            foreach (Core cr in _subRoutes[srt])
                            {
                                if (cr.HandlesMessage(ridm))
                                {
                                    ret = cr.ProcessMessage(ridm);
                                    break;
                                }
                            }
                            if (ret != null)
                            {
                                break;
                            }
                        }
                    }
                }
            }
            return(ret);
        }
Exemple #2
0
        public static InterDomainMessageResponse ProcessInterDomainMessage(IInterDomainMessage message)
        {
            DateTime start = DateTime.Now;

            message = new RoutedInterDomainMessage(message);
            message = _core.AbsoluteParent.InterceptMessage(message);
            Debug("Time to intercept interdomain message {0}:{1}ms", message.Name, DateTime.Now.Subtract(start).TotalMilliseconds);
            start = DateTime.Now;
            InterDomainMessageResponse ret = _core.AbsoluteParent.ProcessMessage(message);

            Debug("Time to handle interdomain message {0}:{1}ms", message.Name, DateTime.Now.Subtract(start).TotalMilliseconds);
            start = DateTime.Now;
            if (ret != null)
            {
                _core.AbsoluteParent.InterceptResponse(ref ret);
                Debug("Time to intercept interdomain response {0}:{1}ms", message.Name, DateTime.Now.Subtract(start).TotalMilliseconds);
            }
            return(ret);
        }
Exemple #3
0
        public void InterceptResponse(ref InterDomainMessageResponse response)
        {
            RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)response.Message;

            lock (_myRoutes)
            {
                foreach (sRoute srt in ridm.PostInterceptRoutes)
                {
                    if (_myRoutes.Contains(srt))
                    {
                        if (_messageController.InterceptsResponse(response))
                        {
                            _messageController.InterceptResponse(ref response);
                        }
                        break;
                    }
                }
            }
            List <Core> subCores = new List <Core>();

            lock (_subRoutes)
            {
                foreach (sRoute srt in ridm.PostInterceptRoutes)
                {
                    if (_subRoutes.ContainsKey(srt))
                    {
                        foreach (Core cr in _subRoutes[srt])
                        {
                            if (!subCores.Contains(cr))
                            {
                                subCores.Add(cr);
                            }
                        }
                    }
                }
                foreach (Core cr in subCores)
                {
                    cr.InterceptResponse(ref response);
                }
            }
        }