|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using System.Runtime;
using System.ServiceModel;
using System.Threading;
namespace System.ServiceModel.Dispatcher
{
internal class ConcurrencyBehavior
{
private ConcurrencyMode _concurrencyMode;
private bool _enforceOrderedReceive;
internal ConcurrencyBehavior(DispatchRuntime runtime)
{
_concurrencyMode = runtime.ConcurrencyMode;
_enforceOrderedReceive = runtime.EnsureOrderedDispatch;
}
internal bool IsConcurrent(ref MessageRpc rpc)
{
return IsConcurrent(_concurrencyMode, _enforceOrderedReceive, rpc.Channel.HasSession);
}
internal static bool IsConcurrent(ConcurrencyMode concurrencyMode, bool ensureOrderedDispatch, bool hasSession)
{
if (concurrencyMode != ConcurrencyMode.Single)
{
return true;
}
if (hasSession)
{
return false;
}
if (ensureOrderedDispatch)
{
return false;
}
return true;
}
internal static bool IsConcurrent(ChannelDispatcher runtime, bool hasSession)
{
bool isConcurrencyModeSingle = true;
foreach (EndpointDispatcher endpointDispatcher in runtime.Endpoints)
{
if (endpointDispatcher.DispatchRuntime.EnsureOrderedDispatch)
{
return false;
}
if (endpointDispatcher.DispatchRuntime.ConcurrencyMode != ConcurrencyMode.Single)
{
isConcurrencyModeSingle = false;
}
}
if (!isConcurrencyModeSingle)
{
return true;
}
if (!hasSession)
{
return true;
}
return false;
}
internal void LockInstance(ref MessageRpc rpc)
{
if (_concurrencyMode != ConcurrencyMode.Multiple)
{
ConcurrencyInstanceContextFacet resource = rpc.InstanceContext.Concurrency;
lock (rpc.InstanceContext.ThisLock)
{
if (!resource.Locked)
{
resource.Locked = true;
}
else
{
MessageRpcWaiter waiter = new MessageRpcWaiter(rpc.Pause());
resource.EnqueueNewMessage(waiter);
}
}
if (_concurrencyMode == ConcurrencyMode.Reentrant)
{
rpc.OperationContext.IsServiceReentrant = true;
}
}
}
internal void UnlockInstance(ref MessageRpc rpc)
{
if (_concurrencyMode != ConcurrencyMode.Multiple)
{
ConcurrencyBehavior.UnlockInstance(rpc.InstanceContext);
}
}
internal static void UnlockInstanceBeforeCallout(OperationContext operationContext)
{
if (operationContext != null && operationContext.IsServiceReentrant)
{
ConcurrencyBehavior.UnlockInstance(operationContext.InstanceContext);
}
}
private static void UnlockInstance(InstanceContext instanceContext)
{
ConcurrencyInstanceContextFacet resource = instanceContext.Concurrency;
lock (instanceContext.ThisLock)
{
if (resource.HasWaiters)
{
IWaiter nextWaiter = resource.DequeueWaiter();
nextWaiter.Signal();
}
else
{
//We have no pending Callouts and no new Messages to process
resource.Locked = false;
}
}
}
internal static void LockInstanceAfterCallout(OperationContext operationContext)
{
if (operationContext != null)
{
InstanceContext instanceContext = operationContext.InstanceContext;
if (operationContext.IsServiceReentrant)
{
ConcurrencyInstanceContextFacet resource = instanceContext.Concurrency;
ThreadWaiter waiter = null;
lock (instanceContext.ThisLock)
{
if (!resource.Locked)
{
resource.Locked = true;
}
else
{
waiter = new ThreadWaiter();
resource.EnqueueCalloutMessage(waiter);
}
}
if (waiter != null)
{
waiter.Wait();
}
}
}
}
internal interface IWaiter
{
void Signal();
}
internal class MessageRpcWaiter : IWaiter
{
private IResumeMessageRpc _resume;
internal MessageRpcWaiter(IResumeMessageRpc resume)
{
_resume = resume;
}
void IWaiter.Signal()
{
try
{
bool alreadyResumedNoLock;
_resume.Resume(out alreadyResumedNoLock);
if (alreadyResumedNoLock)
{
Fx.Assert("ConcurrencyBehavior resumed more than once for same call.");
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
}
}
}
internal class ThreadWaiter : IWaiter
{
private ManualResetEvent _wait = new ManualResetEvent(false);
void IWaiter.Signal()
{
_wait.Set();
}
internal void Wait()
{
_wait.WaitOne();
_wait.Dispose();
}
}
}
internal class ConcurrencyInstanceContextFacet
{
internal bool Locked;
private Queue<ConcurrencyBehavior.IWaiter> _calloutMessageQueue;
private Queue<ConcurrencyBehavior.IWaiter> _newMessageQueue;
internal bool HasWaiters
{
get
{
return (((_calloutMessageQueue != null) && (_calloutMessageQueue.Count > 0)) ||
((_newMessageQueue != null) && (_newMessageQueue.Count > 0)));
}
}
private ConcurrencyBehavior.IWaiter DequeueFrom(Queue<ConcurrencyBehavior.IWaiter> queue)
{
ConcurrencyBehavior.IWaiter waiter = queue.Dequeue();
if (queue.Count == 0)
{
queue.TrimExcess();
}
return waiter;
}
internal ConcurrencyBehavior.IWaiter DequeueWaiter()
{
// Finishing old work takes precedence over new work.
if ((_calloutMessageQueue != null) && (_calloutMessageQueue.Count > 0))
{
return this.DequeueFrom(_calloutMessageQueue);
}
else
{
return this.DequeueFrom(_newMessageQueue);
}
}
internal void EnqueueNewMessage(ConcurrencyBehavior.IWaiter waiter)
{
if (_newMessageQueue == null)
_newMessageQueue = new Queue<ConcurrencyBehavior.IWaiter>();
_newMessageQueue.Enqueue(waiter);
}
internal void EnqueueCalloutMessage(ConcurrencyBehavior.IWaiter waiter)
{
if (_calloutMessageQueue == null)
_calloutMessageQueue = new Queue<ConcurrencyBehavior.IWaiter>();
_calloutMessageQueue.Enqueue(waiter);
}
}
}
|