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)); }