Пример #1
0
        private void Initialize()
        {
            // Basic initialization

            ChannelHost.Start();
            hostStarted = true;

            channels     = new Dictionary <string, TInternal>();
            channelQueue = new LimitedQueue <TInternal>(maxAcceptedChannels);
            acceptQueue  = new Queue <AsyncResult <TInternal, object> >();
            waitQueue    = new Queue <AsyncResult <bool, object> >();

            // Register the endpoint with the router.

            SessionHandlerInfo sessionInfo;

            sessionInfo = this.GetSessionHandlerInfo();
            sessionMode = sessionInfo != null && sessionInfo.SessionType == typeof(DuplexSession);

            if (sessionMode)
            {
                ChannelHost.Router.Dispatcher.AddLogical(new MsgHandlerDelegate(OnReceive), ep, typeof(DuplexSessionMsg), false, sessionInfo);
            }
            else
            {
                ChannelHost.Router.Dispatcher.AddLogical(new MsgHandlerDelegate(OnReceive), ep, typeof(WcfEnvelopeMsg), false, sessionInfo);
            }

            // Start the background task timer

            arBkTimer = AsyncTimer.BeginTimer(bkTaskInterval, onBkTask, null);
        }
Пример #2
0
        private int maxReceiveQueueSize;                        // Maximum size of the queue

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="channelManager">The responsible channel manager.</param>
        /// <param name="localAddress">The local <see cref="EndpointAddress" /> this channel will use to receive requests.</param>
        public InputChannel(ChannelManagerBase channelManager, EndpointAddress localAddress)
            : base(channelManager)
        {
            this.maxReceiveQueueSize = ServiceModelHelper.MaxAcceptedMessages;  // $todo(jeff.lill): Hardcoding this

            this.listener     = (InputChannelListener)channelManager;
            this.localAddress = localAddress;
            this.msgQueue     = new LimitedQueue <Message>(maxReceiveQueueSize);
        }
Пример #3
0
        private TimeSpan bkTaskInterval;                                                // Channel background task interval

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="context">The <see cref="BindingContext" /> holding the information necessary to construct the channel stack.</param>
        internal InputChannelListener(BindingContext context)
            : base(context)
        {
            this.maxReceiveQueueSize = ServiceModelHelper.MaxAcceptedMessages;      // $todo(jeff.lill): Hardcoded
            this.bkTaskInterval      = ServiceModelHelper.DefaultBkTaskInterval;    //                   This too

            this.msgQueue     = new LimitedQueue <Message>(maxReceiveQueueSize);
            this.waitQueue    = new QueueArray <AsyncResult <bool, InputChannel> >();
            this.receiveQueue = new QueueArray <AsyncResult <Message, InputChannel> >();
        }
Пример #4
0
        private TimeSpan bkTaskInterval;                                                    // Channel background task interval

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="context">The <see cref="BindingContext" /> holding the information necessary to construct the channel stack.</param>
        internal ReplyChannelListener(BindingContext context)
            : base(context)
        {
            this.maxRequestQueueSize = ServiceModelHelper.MaxAcceptedMessages;      // $todo(jeff.lill): Hardcoded
            this.maxRequestQueueTime = ServiceModelHelper.MaxRequestQueueTime;      //
            this.bkTaskInterval      = ServiceModelHelper.DefaultBkTaskInterval;    //

            this.requestQueue = new LimitedQueue <RequestInfo>(maxRequestQueueSize);
            this.waitQueue    = new QueueArray <AsyncResult <bool, ReplyChannel> >();
            this.receiveQueue = new QueueArray <AsyncResult <RequestInfo, ReplyChannel> >();
        }
Пример #5
0
        private PayloadSizeEstimator payloadEstimator;                          // Used to estimate the buffer required to serialize
                                                                                // the next message sent
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="channelManager">The responsible channel manager.</param>
        /// <param name="localAddress">The local <see cref="EndpointAddress" /> this channel will use to receive requests.</param>
        /// <param name="encoder">The <see cref="MessageEncoder" /> for serializing messages to the wire format.</param>
        public ReplyChannel(ChannelManagerBase channelManager, EndpointAddress localAddress, MessageEncoder encoder)
            : base(channelManager)
        {
            this.maxReceiveQueueSize = ServiceModelHelper.MaxAcceptedMessages; // $todo(jeff.lill): Hardcoding this

            this.listener         = (ReplyChannelListener)channelManager;
            this.localAddress     = localAddress;
            this.requestQueue     = new LimitedQueue <RequestInfo>(maxReceiveQueueSize);
            this.pendingRequests  = new Dictionary <Guid, MsgRequestContext>();
            this.encoder          = encoder;
            this.payloadEstimator = new PayloadSizeEstimator(ServiceModelHelper.PayloadEstimatorSampleCount);
        }
Пример #6
0
        private void Cleanup(Exception e)
        {
            using (TimedLock.Lock(ChannelHost.SyncRoot))
            {
                if (hostStarted)
                {
                    // Remove the route from the message router.

                    if (ChannelHost.Router != null)
                    {
                        ChannelHost.Router.Dispatcher.RemoveTarget(this);
                    }

                    hostStarted = false;
                    ChannelHost.Stop();
                }
            }

            List <LillTekChannelBase> abortChannels = null;

            using (TimedLock.Lock(this))
            {
                // Terminate any pending accepts

                if (acceptQueue != null)
                {
                    while (acceptQueue.Count > 0)
                    {
                        acceptQueue.Dequeue().Notify();
                    }

                    acceptQueue = null;
                }

                // Terminate any pending waits

                if (waitQueue != null)
                {
                    while (waitQueue.Count > 0)
                    {
                        waitQueue.Dequeue().Notify();
                    }

                    waitQueue = null;
                }

                // Abort any queued accepted channels

                if (channelQueue != null)
                {
                    while (channelQueue.Count > 0)
                    {
                        TInternal channel = channelQueue.Dequeue();

                        if (channel.State != CommunicationState.Closed)
                        {
                            channel.Abort();
                        }
                    }

                    channelQueue = null;
                }

                // $todo(jeff.lill): Delete this ------------------------

                // Setup to abort all of the listener's channels.

                if (channels != null && channels.Count > 0)
                {
                    abortChannels = new List <LillTekChannelBase>(channels.Count);
                    foreach (LillTekChannelBase channel in channels.Values)
                    {
                        abortChannels.Add(channel);
                    }
                }

                //---------------------------------------------------

                // Stop the background task timer

                onBkTask = null;
            }

            // Actually abort the channels outside of the lock.

            if (abortChannels != null)
            {
                foreach (LillTekChannelBase channel in abortChannels)
                {
                    channel.Close();
                }
            }
        }