mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Dispatcher/InstanceContextManager.cs

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

namespace System.ServiceModel.Dispatcher
{
    using System.Diagnostics;
    using System.Runtime;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.Threading;
    using System.ServiceModel.Diagnostics.Application;

    interface IInstanceContextManager
    {
        void Abort();
        void Add(InstanceContext instanceContext);
        IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state);
        IAsyncResult BeginCloseInput(TimeSpan timeout, AsyncCallback callback, object state);
        void Close(TimeSpan timeout);
        void CloseInput(TimeSpan timeout);
        void EndClose(IAsyncResult result);
        void EndCloseInput(IAsyncResult result);
        bool Remove(InstanceContext instanceContext);
        InstanceContext[] ToArray();
    }

    class InstanceContextManager : LifetimeManager, IInstanceContextManager
    {
        int firstFreeIndex;
        Item[] items;

        public InstanceContextManager(object mutex)
            : base(mutex)
        {
        }

        public void Add(InstanceContext instanceContext)
        {
            bool added = false;

            lock (this.ThisLock)
            {
                if (this.State == LifetimeState.Opened)
                {
                    if (instanceContext.InstanceContextManagerIndex != 0)
                        return;
                    if (this.firstFreeIndex == 0)
                        this.GrowItems();
                    this.AddItem(instanceContext);
                    base.IncrementBusyCountWithoutLock();
                    added = true;
                }
            }

            if (!added)
            {
                instanceContext.Abort();
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString()));
            }
        }

        void AddItem(InstanceContext instanceContext)
        {
            int index = this.firstFreeIndex;
            this.firstFreeIndex = this.items[index].nextFreeIndex;
            this.items[index].instanceContext = instanceContext;
            instanceContext.InstanceContextManagerIndex = index;
        }

        public IAsyncResult BeginCloseInput(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return new CloseInputAsyncResult(timeout, callback, state, this.ToArray());
        }

        void CloseInitiate(TimeSpan timeout)
        {
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            InstanceContext[] instances = this.ToArray();
            for (int index = 0; index < instances.Length; index++)
            {
                InstanceContext instance = instances[index];
                try
                {
                    if (instance.State == CommunicationState.Opened)
                    {
                        IAsyncResult result = instance.BeginClose(timeoutHelper.RemainingTime(), Fx.ThunkCallback(new AsyncCallback(CloseInstanceContextCallback)), instance);
                        if (!result.CompletedSynchronously)
                            continue;
                        instance.EndClose(result);
                    }
                    else
                    {
                        instance.Abort();
                    }
                }
                catch (ObjectDisposedException e)
                {
                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
                }
                catch (InvalidOperationException e)
                {
                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
                }
                catch (CommunicationException e)
                {
                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
                }
                catch (TimeoutException e)
                {
                    if (TD.CloseTimeoutIsEnabled())
                    {
                        TD.CloseTimeout(e.Message);
                    }
                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
                }
            }
        }

        public void CloseInput(TimeSpan timeout)
        {
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            InstanceContext[] instances = this.ToArray();
            for (int index = 0; index < instances.Length; index++)
                instances[index].CloseInput(timeoutHelper.RemainingTime());
        }

        static void CloseInstanceContextCallback(IAsyncResult result)
        {
            if (result.CompletedSynchronously)
                return;
            InstanceContext instanceContext = (InstanceContext)result.AsyncState;
            try
            {
                instanceContext.EndClose(result);
            }
            catch (ObjectDisposedException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
             }
             catch (InvalidOperationException e)
             {
                 DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
             }
             catch (CommunicationException e)
             {
                 DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
             }
             catch (TimeoutException e)
             {
                 if (TD.CloseTimeoutIsEnabled())
                 {
                     TD.CloseTimeout(e.Message);
                 }
                 DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
             }
        }

        public void EndCloseInput(IAsyncResult result)
        {
            CloseInputAsyncResult.End(result);
        }

        void GrowItems()
        {
            Item[] existingItems = this.items;
            if (existingItems != null)
            {
                this.InitItems(existingItems.Length * 2);
                for (int i = 1; i < existingItems.Length; i++)
                    this.AddItem(existingItems[i].instanceContext);
            }
            else
            {
                this.InitItems(4);
            }
        }

        void InitItems(int count)
        {
            this.items = new Item[count];
            for (int i = count - 2; i > 0; i--)
            {
                this.items[i].nextFreeIndex = i + 1;
            }
            this.firstFreeIndex = 1;
        }

        protected override void OnAbort()
        {
            InstanceContext[] instances = this.ToArray();
            for (int index = 0; index < instances.Length; index++)
            {
                instances[index].Abort();
            }

            base.OnAbort();
        }

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        {
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            CloseInitiate(timeoutHelper.RemainingTime());
            return base.OnBeginClose(timeoutHelper.RemainingTime(), callback, state);
        }

        protected override void OnClose(TimeSpan timeout)
        {
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            CloseInitiate(timeoutHelper.RemainingTime());
            base.OnClose(timeoutHelper.RemainingTime());
        }

        protected override void OnEndClose(IAsyncResult result)
        {
            base.OnEndClose(result);
        }

        public bool Remove(InstanceContext instanceContext)
        {
            if (instanceContext == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("instanceContext"));

            lock (this.ThisLock)
            {
                int index = instanceContext.InstanceContextManagerIndex;
                if (index == 0)
                    return false;
                instanceContext.InstanceContextManagerIndex = 0;
                this.items[index].nextFreeIndex = this.firstFreeIndex;
                this.items[index].instanceContext = null;
                this.firstFreeIndex = index;
            }

            base.DecrementBusyCount();
            return true;
        }

        public InstanceContext[] ToArray()
        {
            if (this.items == null)
            {
                return EmptyArray<InstanceContext>.Instance;
            }

            lock (this.ThisLock)
            {
                int count = 0;
                for (int i = 1; i < this.items.Length; i++)
                    if (this.items[i].instanceContext != null)
                        count++;

                if (count == 0)
                    return EmptyArray<InstanceContext>.Instance;

                InstanceContext[] array = new InstanceContext[count];
                count = 0;
                for (int i = 1; i < this.items.Length; i++)
                {
                    InstanceContext instanceContext = this.items[i].instanceContext;
                    if (instanceContext != null)
                    {
                        array[count++] = instanceContext;
                    }
                }

                return array;
            }
        }

        struct Item
        {
            public int nextFreeIndex;
            public InstanceContext instanceContext;
        }
    }

    class CloseInputAsyncResult : AsyncResult
    {
        bool completedSynchronously;
        Exception exception;
        static AsyncCallback nestedCallback = Fx.ThunkCallback(new AsyncCallback(Callback));
        int count;
        TimeoutHelper timeoutHelper;

        public CloseInputAsyncResult(TimeSpan timeout, AsyncCallback otherCallback, object state, InstanceContext[] instances)
            : base(otherCallback, state)
        {
            this.timeoutHelper = new TimeoutHelper(timeout);
            completedSynchronously = true;

            count = instances.Length;
            if (count == 0)
            {
                Complete(true);
                return;
            }

            for (int index = 0; index < instances.Length; index++)
            {
                CallbackState callbackState = new CallbackState(this, instances[index]);
                IAsyncResult result;
                try
                {
                    result = instances[index].BeginCloseInput(this.timeoutHelper.RemainingTime(), nestedCallback, callbackState);
                }
#pragma warning suppress 56500 // covered by FxCOP
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }
                    Decrement(true, e);
                    continue;
                }
                if (result.CompletedSynchronously)
                {
                    instances[index].EndCloseInput(result);
                    Decrement(true);
                }
            }
        }

        static void Callback(IAsyncResult result)
        {
            if (result.CompletedSynchronously)
                return;
            CallbackState callbackState = (CallbackState)result.AsyncState;
            try
            {
                callbackState.Instance.EndCloseInput(result);
                callbackState.Result.Decrement(false);
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }
                callbackState.Result.Decrement(false, e);
            }
        }

        void Decrement(bool completedSynchronously)
        {
            if (completedSynchronously == false)
                this.completedSynchronously = false;
            if (Interlocked.Decrement(ref count) == 0)
            {
                if (this.exception != null)
                    Complete(this.completedSynchronously, this.exception);
                else
                    Complete(this.completedSynchronously);
            }
        }

        void Decrement(bool completedSynchronously, Exception exception)
        {
            this.exception = exception;
            this.Decrement(completedSynchronously);
        }

        public static void End(IAsyncResult result)
        {
            AsyncResult.End<CloseInputAsyncResult>(result);
        }

        class CallbackState
        {
            InstanceContext instance;
            CloseInputAsyncResult result;

            public CallbackState(CloseInputAsyncResult result, InstanceContext instance)
            {
                this.result = result;
                this.instance = instance;
            }

            public InstanceContext Instance
            {
                get { return instance; }
            }

            public CloseInputAsyncResult Result
            {
                get { return result; }
            }
        }
    }
}