Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Channels/RequestContextBase.cs

@@ -0,0 +1,344 @@
+//----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//----------------------------------------------------------------------------
+namespace System.ServiceModel.Channels
+{
+    using System;
+    using System.Diagnostics;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Diagnostics;
+    using System.ServiceModel.Diagnostics.Application;
+
+    abstract class RequestContextBase : RequestContext
+    {
+        TimeSpan defaultSendTimeout;
+        TimeSpan defaultCloseTimeout;
+        CommunicationState state = CommunicationState.Opened;
+        Message requestMessage;
+        Exception requestMessageException;
+        bool replySent;
+        bool replyInitiated;
+        bool aborted;
+        object thisLock = new object();
+
+        protected RequestContextBase(Message requestMessage, TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
+        {
+            this.defaultSendTimeout = defaultSendTimeout;
+            this.defaultCloseTimeout = defaultCloseTimeout;
+            this.requestMessage = requestMessage;
+        }
+
+        public void ReInitialize(Message requestMessage)
+        {
+            this.state = CommunicationState.Opened;
+            this.requestMessageException = null;
+            this.replySent = false;
+            this.replyInitiated = false;
+            this.aborted = false;
+            this.requestMessage = requestMessage;
+        }
+
+        public override Message RequestMessage
+        {
+            get
+            {
+                if (this.requestMessageException != null)
+                {
+#pragma warning suppress 56503 // [....], see outcome of DCR 50092
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.requestMessageException);
+                }
+
+                return requestMessage;
+            }
+        }
+
+        protected void SetRequestMessage(Message requestMessage)
+        {
+            Fx.Assert(this.requestMessageException == null, "Cannot have both a requestMessage and a requestException.");
+            this.requestMessage = requestMessage;
+        }
+
+        protected void SetRequestMessage(Exception requestMessageException)
+        {
+            Fx.Assert(this.requestMessage == null, "Cannot have both a requestMessage and a requestException.");
+            this.requestMessageException = requestMessageException;
+        }
+
+        protected bool ReplyInitiated
+        {
+            get { return this.replyInitiated; }
+        }
+
+        protected object ThisLock
+        {
+            get
+            {
+                return thisLock;
+            }
+        }
+
+        public bool Aborted
+        {
+            get
+            {
+                return this.aborted;
+            }
+        }
+
+        public TimeSpan DefaultCloseTimeout
+        {
+            get { return this.defaultCloseTimeout; }
+        }
+
+        public TimeSpan DefaultSendTimeout
+        {
+            get { return this.defaultSendTimeout; }
+        }
+
+        public override void Abort()
+        {
+            lock (ThisLock)
+            {
+                if (state == CommunicationState.Closed)
+                    return;
+
+                state = CommunicationState.Closing;
+
+                this.aborted = true;
+            }
+
+            if (DiagnosticUtility.ShouldTraceWarning)
+            {
+                TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.RequestContextAbort,
+                    SR.GetString(SR.TraceCodeRequestContextAbort), this);
+            }
+
+            try
+            {
+                this.OnAbort();
+            }
+            finally
+            {
+                state = CommunicationState.Closed;
+            }
+        }
+
+        public override void Close()
+        {
+            this.Close(this.defaultCloseTimeout);
+        }
+
+        public override void Close(TimeSpan timeout)
+        {
+            if (timeout < TimeSpan.Zero)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("timeout", timeout,
+                    SR.GetString(SR.ValueMustBeNonNegative)));
+            }
+
+            bool sendAck = false;
+            lock (ThisLock)
+            {
+                if (state != CommunicationState.Opened)
+                    return;
+
+                if (TryInitiateReply())
+                {
+                    sendAck = true;
+                }
+
+                state = CommunicationState.Closing;
+            }
+
+            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
+            bool throwing = true;
+
+            try
+            {
+                if (sendAck)
+                {
+                    OnReply(null, timeoutHelper.RemainingTime());
+                }
+
+                OnClose(timeoutHelper.RemainingTime());
+                state = CommunicationState.Closed;
+                throwing = false;
+            }
+            finally
+            {
+                if (throwing)
+                    this.Abort();
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+
+            if (!disposing)
+                return;
+
+            if (this.replySent)
+            {
+                this.Close();
+            }
+            else
+            {
+                this.Abort();
+            }
+        }
+
+        protected abstract void OnAbort();
+        protected abstract void OnClose(TimeSpan timeout);
+        protected abstract void OnReply(Message message, TimeSpan timeout);
+        protected abstract IAsyncResult OnBeginReply(Message message, TimeSpan timeout, AsyncCallback callback, object state);
+        protected abstract void OnEndReply(IAsyncResult result);
+
+        protected void ThrowIfInvalidReply()
+        {
+            if (state == CommunicationState.Closed || state == CommunicationState.Closing)
+            {
+                if (aborted)
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationObjectAbortedException(SR.GetString(SR.RequestContextAborted)));
+                else
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().FullName));
+            }
+
+            if (this.replyInitiated)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ReplyAlreadySent)));
+        }
+
+        /// <summary>
+        /// Attempts to initiate the reply. If a reply is not initiated already (and the object is opened), 
+        /// then it initiates the reply and returns true. Otherwise, it returns false.
+        /// </summary>
+        protected bool TryInitiateReply()
+        {
+            lock (this.thisLock)
+            {
+                if ((this.state != CommunicationState.Opened) || this.replyInitiated)
+                {
+                    return false;
+                }
+                else
+                {
+                    this.replyInitiated = true;
+                    return true;
+                }
+            }
+        }
+
+        public override IAsyncResult BeginReply(Message message, AsyncCallback callback, object state)
+        {
+            return this.BeginReply(message, this.defaultSendTimeout, callback, state);
+        }
+
+        public override IAsyncResult BeginReply(Message message, TimeSpan timeout, AsyncCallback callback, object state)
+        {
+            // "null" is a valid reply (signals a 202-style "ack"), so we don't have a null-check here
+            lock (this.thisLock)
+            {
+                this.ThrowIfInvalidReply();
+                this.replyInitiated = true;
+            }
+
+            return OnBeginReply(message, timeout, callback, state);
+        }
+
+        public override void EndReply(IAsyncResult result)
+        {
+            OnEndReply(result);
+            this.replySent = true;
+        }
+
+        public override void Reply(Message message)
+        {
+            this.Reply(message, this.defaultSendTimeout);
+        }
+
+        public override void Reply(Message message, TimeSpan timeout)
+        {
+            // "null" is a valid reply (signals a 202-style "ack"), so we don't have a null-check here
+            lock (this.thisLock)
+            {
+                this.ThrowIfInvalidReply();
+                this.replyInitiated = true;
+            }
+
+            this.OnReply(message, timeout);
+            this.replySent = true;
+        }
+
+        // This method is designed for WebSocket only, and will only be used once the WebSocket response was sent.
+        // For WebSocket, we never call HttpRequestContext.Reply to send the response back. 
+        // Instead we call AcceptWebSocket directly. So we need to set the replyInitiated and 
+        // replySent boolean to be true once the response was sent successfully. Otherwise when we 
+        // are disposing the HttpRequestContext, we will see a bunch of warnings in trace log.
+        protected void SetReplySent()
+        {
+            lock (this.thisLock)
+            {
+                this.ThrowIfInvalidReply();
+                this.replyInitiated = true;
+            }
+
+            this.replySent = true;
+        }
+    }
+
+    class RequestContextMessageProperty : IDisposable
+    {
+        RequestContext context;
+        object thisLock = new object();
+
+        public RequestContextMessageProperty(RequestContext context)
+        {
+            this.context = context;
+        }
+
+        public static string Name
+        {
+            get { return "requestContext"; }
+        }
+
+        void IDisposable.Dispose()
+        {
+            bool success = false;
+            RequestContext thisContext;
+
+            lock (this.thisLock)
+            {
+                if (this.context == null)
+                    return;
+                thisContext = this.context;
+                this.context = null;
+            }
+
+            try
+            {
+                thisContext.Close();
+                success = true;
+            }
+            catch (CommunicationException e)
+            {
+                DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
+            }
+            catch (TimeoutException e)
+            {
+                if (TD.CloseTimeoutIsEnabled())
+                {
+                    TD.CloseTimeout(e.Message);
+                }
+                DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
+            }
+            finally
+            {
+                if (!success)
+                {
+                    thisContext.Abort();
+                }
+            }
+        }
+    }
+}