public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
#if !DISABLE_REMOTING
ServerIdentity identity = (ServerIdentity)RemotingServices.GetMessageTargetIdentity(msg);
if (identity.HasServerDynamicSinks)
{
identity.NotifyServerDynamicSinks(true, msg, false, true);
if (replySink != null)
{
replySink = new ServerObjectReplySink(identity, replySink);
}
}
IMessageCtrl res = _nextSink.AsyncProcessMessage(msg, replySink);
if (replySink == null)
{
identity.NotifyServerDynamicSinks(false, msg, true, true);
}
return(res);
#else
IMessageCtrl res = _nextSink.AsyncProcessMessage(msg, replySink);
return(res);
#endif
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
// only for method calls
if (msg as IMethodCallMessage != null)
{
LogicalCallContext lcc =
(LogicalCallContext)msg.Properties["__CallContext"];
lcc.SetData("priority", Thread.CurrentThread.Priority);
return(_nextMsgSink.AsyncProcessMessage(msg, replySink));
}
else
{
return(_nextMsgSink.AsyncProcessMessage(msg, replySink));
}
}
/*
* Execute is called to complete a work item (sync or async).
* Execute assumes that the context is set correctly and the lock
* is taken (i.e. it makes no policy decisions)
*
* It is called from the following 3 points:
* 1. thread pool thread executing the callback for an async item
* 2. calling thread executing the callback for a queued sync item
* 3. calling thread directly calling Execute for a non-queued sync item
*/
internal virtual void Execute()
{
// Execute should be called with the domain policy enforced
// i.e. a Synchronization domain should be locked etc ...
BCLDebug.Assert(IsSignaled(), "IsSignaled()");
ContextTransitionFrame frame = new ContextTransitionFrame();
Thread.CurrentThread.EnterContext(_ctx, ref frame);
LogicalCallContext oldCallCtx = CallContext.SetLogicalCallContext(_callCtx);
if (IsAsync())
{
//DBGConsole.WriteLine(Thread.CurrentThread.GetHashCode()+"] AsyncWork.Execute");
_nextSink.AsyncProcessMessage(_reqMsg, _replySink);
}
else if (_nextSink != null)
{
//DBGConsole.WriteLine(Thread.CurrentThread.GetHashCode()+"] SyncWork.Execute");
_replyMsg = _nextSink.SyncProcessMessage(_reqMsg);
}
CallContext.SetLogicalCallContext(oldCallCtx);
Thread.CurrentThread.ReturnToContext(ref frame);
}
[System.Security.SecurityCritical] // auto-generated
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
Message.DebugOut("+++++++++++++++++++++++++ SrvCtxTerminator: SyncProcessMsg");
IMessageCtrl msgCtrl = null;
IMessage errMsg = ValidateMessage(reqMsg);
if (errMsg == null)
{
errMsg = DisallowAsyncActivation(reqMsg);
}
if (errMsg != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(errMsg);
}
}
else
{
// <
MarshalByRefObject obj;
IMessageSink nextChain = GetObjectChain(reqMsg, out obj);
IDisposable iDis;
if (obj != null && ((iDis = (obj as IDisposable)) != null))
{
DisposeSink dsink = new DisposeSink(iDis, replySink);
replySink = dsink;
}
msgCtrl = nextChain.AsyncProcessMessage(
reqMsg,
replySink);
}
return(msgCtrl);
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
IMessageCtrl result = null;
IMessage message = InternalSink.ValidateMessage(reqMsg);
if (message != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(message);
}
}
else
{
IMessageSink messageSink = this._stackBuilderSink.ServerObject as IMessageSink;
if (messageSink != null)
{
result = messageSink.AsyncProcessMessage(reqMsg, replySink);
}
else
{
result = this._stackBuilderSink.AsyncProcessMessage(reqMsg, replySink);
}
}
return(result);
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
IMessageCtrl result = null;
IMessage message = InternalSink.ValidateMessage(reqMsg);
if (message == null)
{
message = InternalSink.DisallowAsyncActivation(reqMsg);
}
if (message != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(message);
}
}
else
{
MarshalByRefObject marshalByRefObject;
IMessageSink objectChain = this.GetObjectChain(reqMsg, out marshalByRefObject);
IDisposable iDis;
if (marshalByRefObject != null && (iDis = (marshalByRefObject as IDisposable)) != null)
{
DisposeSink disposeSink = new DisposeSink(iDis, replySink);
replySink = disposeSink;
}
result = objectChain.AsyncProcessMessage(reqMsg, replySink);
}
return(result);
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
IMessageCtrl ctrl = null;
MarshalByRefObject obj2;
IDisposable disposable;
IMessage msg = InternalSink.ValidateMessage(reqMsg);
if (msg == null)
{
msg = InternalSink.DisallowAsyncActivation(reqMsg);
}
if (msg != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(msg);
}
return(ctrl);
}
IMessageSink objectChain = this.GetObjectChain(reqMsg, out obj2);
if ((obj2 != null) && ((disposable = obj2 as IDisposable) != null))
{
DisposeSink sink2 = new DisposeSink(disposable, replySink);
replySink = sink2;
}
return(objectChain.AsyncProcessMessage(reqMsg, replySink));
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
IMessageCtrl messageCtrl = (IMessageCtrl)null;
IMessage msg1 = InternalSink.ValidateMessage(reqMsg) ?? InternalSink.DisallowAsyncActivation(reqMsg);
if (msg1 != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(msg1);
}
}
else
{
MarshalByRefObject marshalByRefObject;
IMessageSink objectChain = this.GetObjectChain(reqMsg, out marshalByRefObject);
IDisposable iDis;
if (marshalByRefObject != null && (iDis = marshalByRefObject as IDisposable) != null)
{
replySink = (IMessageSink) new DisposeSink(iDis, replySink);
}
IMessage msg2 = reqMsg;
IMessageSink replySink1 = replySink;
messageCtrl = objectChain.AsyncProcessMessage(msg2, replySink1);
}
return(messageCtrl);
}
[System.Security.SecurityCritical] // auto-generated
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
IMessageCtrl msgCtrl = null;
IMessage errMsg = ValidateMessage(reqMsg);
// <
if (errMsg != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(errMsg);
}
}
else
{
// Pass call on to the server object specific chain
IMessageSink serverAsSink = _stackBuilderSink.ServerObject as IMessageSink;
if (serverAsSink != null)
{
msgCtrl = serverAsSink.AsyncProcessMessage(reqMsg, replySink);
}
else
{
msgCtrl = _stackBuilderSink.AsyncProcessMessage(reqMsg, replySink);
}
}
return(msgCtrl);
}
[System.Security.SecurityCritical] // auto-generated
internal static Object AsyncProcessMessageCallback(Object[] args)
{
IMessage reqMsg = (IMessage)args[0];
IMessageSink replySink = (IMessageSink)args[1];
IMessageSink channelSink = (IMessageSink)args[2];
return(channelSink.AsyncProcessMessage(reqMsg, replySink));
}
internal static object AsyncProcessMessageCallback(object[] args)
{
IMessage msg = (IMessage)args[0];
IMessageSink replySink = (IMessageSink)args[1];
IMessageSink messageSink = (IMessageSink)args[2];
return(messageSink.AsyncProcessMessage(msg, replySink));
}
public IMessageCtrl AsyncProcessMessage(IMessage im, IMessageSink ims)
{
CallSeq.Add("--> " + _type + " AsyncProcessMessage " + im.Properties["__MethodName"]);
IMessageCtrl ret = _next.AsyncProcessMessage(im, ims);
CallSeq.Add("<-- " + _type + " AsyncProcessMessage " + im.Properties["__MethodName"]);
return(ret);
}
public static IMessage SyncDispatchMessage(IMessage msg)
{
IMessage message = null;
bool flag = false;
try
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
ChannelServices.IncrementRemoteCalls();
if (!(msg is TransitionCall))
{
ChannelServices.CheckDisconnectedOrCreateWellKnownObject(msg);
MethodBase methodBase = ((IMethodMessage)msg).MethodBase;
flag = RemotingServices.IsOneWay(methodBase);
}
IMessageSink crossContextChannelSink = ChannelServices.GetCrossContextChannelSink();
if (!flag)
{
message = crossContextChannelSink.SyncProcessMessage(msg);
}
else
{
crossContextChannelSink.AsyncProcessMessage(msg, null);
}
}
catch (Exception e)
{
if (!flag)
{
try
{
IMessage message3;
if (msg == null)
{
IMessage message2 = new ErrorMessage();
message3 = message2;
}
else
{
message3 = msg;
}
IMethodCallMessage methodCallMessage = (IMethodCallMessage)message3;
message = new ReturnMessage(e, methodCallMessage);
if (msg != null)
{
((ReturnMessage)message).SetLogicalCallContext(methodCallMessage.LogicalCallContext);
}
}
catch (Exception)
{
}
}
}
return(message);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
if (_att.IsReEntrant)
{
_att.ReleaseLock(); // Unlock when leaving the context
replySink = new SynchronizedContextReplySink(replySink, _att, true);
}
return(_next.AsyncProcessMessage(msg, replySink));
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
var contextSyncContext = new ContextSynchronizationContext(SynchronizationContext.Current);
var syncContextReplacer = new SynchronizationContextReplacer(contextSyncContext);
DelegateMessageSink.SyncProcessMessageDelegate replySyncDelegate = (n, m) => SyncProcessMessageDelegateForAsyncReply(n, m, syncContextReplacer);
var newReplySink = new DelegateMessageSink(replySink, replySyncDelegate, null);
return(m_NextSink.AsyncProcessMessage(msg, newReplySink));
}
public override IMessageCtrl AsyncObjectProcessMessage(IMessage msg, IMessageSink replySink)
{
MarshalByRefObject obj = (MarshalByRefObject)Activator.CreateInstance(_objectType, true);
IMessageSink serverSink = _context.CreateServerObjectSinkChain(obj, false);
if (obj is IDisposable)
{
replySink = new DisposerReplySink(replySink, ((IDisposable)obj));
}
return(serverSink.AsyncProcessMessage(msg, replySink));
}
public override IMessageCtrl AsyncObjectProcessMessage(IMessage msg, IMessageSink replySink)
{
MarshalByRefObject marshalByRefObject = (MarshalByRefObject)Activator.CreateInstance(this._objectType, true);
IMessageSink messageSink = this._context.CreateServerObjectSinkChain(marshalByRefObject, false);
if (marshalByRefObject is IDisposable)
{
replySink = new DisposerReplySink(replySink, (IDisposable)marshalByRefObject);
}
return(messageSink.AsyncProcessMessage(msg, replySink));
}
/// <summary>
/// Defined by the IMessageSink interface. Asynchronously processes the given message.
/// </summary>
/// <param name="msg">
/// The message to process.
/// </param>
/// <param name="replySink">
/// The reply sink for the reply message.
/// </param>
/// <returns>
/// Returns an IMessageCtrl interface that provides a way to control asynchronous
/// messages after they have been dispatched.
/// </returns>
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
// Create a delegate reference to the callback function that will handle async calls.
AsyncExceptionContextSink.AsyncExceptionDelegate aed =
new AsyncExceptionContextSink.AsyncExceptionDelegate(AsyncCallback);
// Create a new AsyncExceptionContextSink object to act as the reply sink.
replySink = (IMessageSink) new AsyncExceptionContextSink(replySink, aed);
// Pass the call on to the next sink in the chain.
return(_NextSink.AsyncProcessMessage(msg, replySink));
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
try
{
IMessageCtrl rtnMsgCtrl = _nextSink.AsyncProcessMessage(msg, replySink);
return(rtnMsgCtrl);
}
catch (Exception e)
{
SeleniumLog log = SeleniumLog.Instance();
log.Warning().WriteLine("SeleniumLog Exception: 01-11 - " + e.Message);
return(null);
}
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMethodCallMessage mcm = msg as IMethodCallMessage;
if (mcm != null)
{
_log.Warning("Async call on {0}.{1}, no intercept apply.", mcm.MethodName, mcm.TypeName);
}
else
{
_log.Warning("Async call detected, no intercept apply, message is {0}.", msg);
}
return(m_NextSink.AsyncProcessMessage(msg, replySink));
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMethodMessage methodMessage = (IMethodMessage)msg;
string assemblyName = GetAssemblyName(methodMessage);
string typeName = GetTypeName(methodMessage);
string methodName = GetMethodName(methodMessage);
string exceptionName = "Not Available";
string exceptionMessage = "Method invoked asynchronously";
LogbookEntry logbookEntry = new LogbookEntry(assemblyName, typeName, methodName, exceptionName, exceptionMessage);
DoLogging(logbookEntry);
return(m_NextSink.AsyncProcessMessage(msg, replySink));
}
public static IMessage SyncDispatchMessage(IMessage msg)
{
IMessage message = null;
bool flag = false;
try
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
IncrementRemoteCalls();
if (!(msg is TransitionCall))
{
CheckDisconnectedOrCreateWellKnownObject(msg);
flag = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase);
}
IMessageSink crossContextChannelSink = GetCrossContextChannelSink();
if (!flag)
{
return(crossContextChannelSink.SyncProcessMessage(msg));
}
crossContextChannelSink.AsyncProcessMessage(msg, null);
}
catch (Exception exception)
{
if (flag)
{
return(message);
}
try
{
IMethodCallMessage mcm = (msg != null) ? ((IMethodCallMessage)msg) : ((IMethodCallMessage) new ErrorMessage());
message = new ReturnMessage(exception, mcm);
if (msg != null)
{
((ReturnMessage)message).SetLogicalCallContext(mcm.LogicalCallContext);
}
}
catch (Exception)
{
}
}
return(message);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
if (syncContext == null)
{
return(nextSink.AsyncProcessMessage(msg, replySink));
}
// Make a copy of the message since MS.NET seems to free the original message
// once it has been dispatched.
if (!isMono)
{
msg = new MethodCall(msg);
}
MsgData md = new MsgData();
md.InMessage = msg;
md.ReplySink = replySink;
syncContext.AsyncDispatch(new StatefulMessageHandler(AsyncDispatchMessage), md);
return(null);
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
IMessageCtrl ctrl = null;
IMessage msg = InternalSink.ValidateMessage(reqMsg);
if (msg != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(msg);
}
return(ctrl);
}
IMessageSink serverObject = this._stackBuilderSink.ServerObject as IMessageSink;
if (serverObject != null)
{
return(serverObject.AsyncProcessMessage(reqMsg, replySink));
}
return(this._stackBuilderSink.AsyncProcessMessage(reqMsg, replySink));
}
/// <summary>
/// Process asynchronous messages through the sink chain. Mocking can be applied here.
/// </summary>
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
if (RecorderManager.IsPlaying)
{
MockableCall call = new MockableCall(null, (IMethodCallMessage)msg);
AsyncCallHandler handler = new AsyncCallHandler(replySink, call);
RecorderManager.RecordCall(call);
}
else if (RecorderManager.IsRecording)
{
}
else
{
return(NextSink.AsyncProcessMessage(msg, replySink));
}
return(nextMessageSink.AsyncProcessMessage(
msg,
new AsyncCallHandler(
replySink,
new MockableCall(null, (IMethodCallMessage)msg)
)
));
}
public IMessageCtrl AsyncProcessMessage(IMessage msg,
IMessageSink replySink)
{
ChangeUri(msg);
return(_sink.AsyncProcessMessage(msg, replySink));
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
//BCLDebug.Trace("REMOTE","Lease ",id," AsyncProcessMessage");
lease.RenewOnCall();
return(nextSink.AsyncProcessMessage(msg, replySink));
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMessageCtrl rtnMsgCtrl = nextSink.AsyncProcessMessage(msg, replySink);
return(rtnMsgCtrl);
}
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink)
{
IMessageCtrl messageCtrl = (IMessageCtrl)null;
IMessage msg = InternalSink.ValidateMessage(reqMsg);
if (msg != null)
{
if (replySink != null)
{
replySink.SyncProcessMessage(msg);
}
}
else
{
IMessageSink messageSink = this._stackBuilderSink.ServerObject as IMessageSink;
messageCtrl = messageSink == null?this._stackBuilderSink.AsyncProcessMessage(reqMsg, replySink) : messageSink.AsyncProcessMessage(reqMsg, replySink);
}
return(messageCtrl);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
_att.AcquireLock();
replySink = new SynchronizedContextReplySink(replySink, _att, false);
return(_next.AsyncProcessMessage(msg, replySink));
}
