public virtual IMessage SyncProcessMessage(IMessage reqMsg) { // we just switch back to the old context before calling // the next replySink IMessage retMsg = null; if (_replySink != null) { ContextTransitionFrame frame = new ContextTransitionFrame(); Thread.CurrentThread.EnterContext(_cliCtx, ref frame); // Call the dynamic sinks to notify that the async call // has completed Thread.CurrentContext.NotifyDynamicSinks( reqMsg, // this is the async reply true, // bCliSide false, // bStart true, // bAsync true); // bNotifyGlobals // call the original reply sink now that we have moved // to the correct client context retMsg = _replySink.SyncProcessMessage(reqMsg); // return the thread to its earlier context Thread.CurrentThread.ReturnToContext(ref frame); } return(retMsg); }
/* package */ internal virtual void FinishAsyncWork(Object stateIgnored) { // set to the server context ContextTransitionFrame frame = new ContextTransitionFrame(); Context srvCtx = _srvID.ServerContext; Thread.CurrentThread.EnterContext(srvCtx, ref frame); LogicalCallContext threadPoolCallCtx = CallContext.SetLogicalCallContext(_callCtx); // Call the server context chain Async. We provide workItem as our // replySink ... this will cause the replySink.ProcessMessage // to switch back to the context of the original caller thread. // Call the dynamic sinks to notify that the async call // is starting srvCtx.NotifyDynamicSinks( _reqMsg, false, // bCliSide true, // bStart true, // bAsync true); // bNotifyGlobals IMessageCtrl ctrl = srvCtx.GetServerContextChain().AsyncProcessMessage( _reqMsg, (IMessageSink)this); // change back to the old context CallContext.SetLogicalCallContext(threadPoolCallCtx); Thread.CurrentThread.ReturnToContext(ref frame); }
} // DoDispatch internal byte[] DoTransitionDispatch( byte[] reqStmBuff, SmuggledMethodCallMessage smuggledMcm, out SmuggledMethodReturnMessage smuggledMrm) { // Note: To be safe w.r.t. the app domain leak code, this frame // should have no non-agile references in it. ContextTransitionFrame frame = new ContextTransitionFrame(); // change to server domain Thread.CurrentThread.EnterContextInternal( null, _srvContextID, _srvDomainID, ref frame); byte[] retBuff = null; smuggledMrm = null; try { Message.DebugOut("#### : changed to Server Domain :: " + (Thread.CurrentContext.InternalContextID).ToString("X")); retBuff = DoDispatch(reqStmBuff, smuggledMcm, out smuggledMrm); } catch (Exception e) { // This will catch exceptions thrown by the infrastructure, // Serialization/Deserialization etc // Those thrown by the server are already taken care of // and encoded in the retMsg .. so we don't come here for // that case. // We are in another appDomain, so we can't simply throw // the exception object across. The following marshals it // into a serialized return message. IMessage retMsg = new ReturnMessage(e, new ErrorMessage()); //*********************** SERIALIZE RET-MSG ****************** retBuff = CrossAppDomainSerializer.SerializeMessage(retMsg).GetBuffer(); retMsg = null; } finally { RemotingServices.LogRemotingStage(RemotingServices.SERVER_RET_SEND); Thread.CurrentThread.ReturnToContext(ref frame); Message.DebugOut("#### : changed back to Client Domain " + (Thread.CurrentContext.InternalContextID).ToString("X")); } // System.Diagnostics.Debugger.Break(); return(retBuff); } // DoTransitionDispatch
internal void EnterContext(Context newContext, ref ContextTransitionFrame frame) { EnterContextInternal(newContext, newContext.InternalContextID, 0, ref frame); // The newContext parameter is passed in just to keep GC from // collecting a new context when we are trying to enter it. // By the time this returns, the m_Context field in the managed // thread is already set to the newContext ... so from there on // the newContext is rooted. // EnterContextInternal is directly called by the X-AppDomain // channel since it only has the target context-id and not the // context object itself (since the latter is in another domain) // It is also called directly when we are bootstrapping a new // AppDomain w.r.t. remoting (in CreateProxyForDomain). In both // these cases, the newContext is null. }
public virtual IMessage SyncProcessMessage(IMessage msg) { // This gets called when the called object finishes the AsyncWork... // This is called irrespective of whether we delegated the initial // work to a thread pool thread or not. Quite likely it will be // called on a user thread (i.e. a thread different from the // forward call thread) // we just switch back to the old context before calling // the next replySink IMessage retMsg = null; if (_replySink != null) { // This assert covers the common case (ThreadPool) // and checks that the reply thread for the async call // indeed emerges from the server context. BCLDebug.Assert( (_srvID == null) || (_srvID.ServerContext == Thread.CurrentContext), "Thread expected to be in the server context!"); // Call the dynamic sinks to notify that the async call // has completed Thread.CurrentContext.NotifyDynamicSinks( msg, // this is the async reply false, // bCliSide false, // bStart true, // bAsync true); // bNotifyGlobals ContextTransitionFrame frame = new ContextTransitionFrame(); Thread.CurrentThread.EnterContext(_oldCtx, ref frame); retMsg = _replySink.SyncProcessMessage(msg); Thread.CurrentThread.ReturnToContext(ref frame); } return(retMsg); }
internal extern bool EnterContextInternal(Context ctx, Int32 id, Int32 appDomainID, ref ContextTransitionFrame frame);
internal extern bool ReturnToContext(ref ContextTransitionFrame frame);
} // AsyncProcessMessage internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink) { ServerIdentity srvID = GetServerIdentity(reqMsg); AsyncWorkItem workItem = null; // If active, notify the profiler that an asynchronous remoting message was received. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { Object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) { g = (Guid)obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(g, true); // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is sent. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ServerAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context srvCtx = srvID.ServerContext; //if (srvCtx.IsThreadPoolAware) //{ // this is the case when we do not queue the work item since the // server context claims to be doing its own threading. Context oldCtx = Thread.CurrentContext; // change to server object context ContextTransitionFrame frame = new ContextTransitionFrame(); Thread.CurrentThread.EnterContext(srvID.ServerContext, ref frame); // we use the work item just as our replySink in this case if (replySink != null) { workItem = new AsyncWorkItem(replySink, oldCtx); } Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain"); // call the server context chain IMessageCtrl msgCtrl = srvID.ServerContext.GetServerContextChain().AsyncProcessMessage(reqMsg, (IMessageSink)workItem); Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain"); // chain back to the dispatch thread context Thread.CurrentThread.ReturnToContext(ref frame); //} return(msgCtrl); } // DoDispatch
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call starting!!\n"); // One way Async notifications may potentially pass a null reply sink. IMessage errMsg = ValidateMessage(reqMsg); IMessageCtrl msgCtrl = null; if (errMsg != null) { if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { ServerIdentity srvID = GetServerIdentity(reqMsg); AsyncWorkItem workItem = null; // If active, notify the profiler that an asynchronous remoting message was received. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { Object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) { g = (Guid)obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(g, true); // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is sent. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ServerAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context srvCtx = srvID.ServerContext; if (srvCtx.IsThreadPoolAware) { // this is the case when we do not queue the work item since the // server context claims to be doing its own threading. Context oldCtx = Thread.CurrentContext; // change to server object context ContextTransitionFrame frame = new ContextTransitionFrame(); srvCtx = srvID.ServerContext; Thread.CurrentThread.EnterContext(srvCtx, ref frame); // we use the work item just as our replySink in this case if (replySink != null) { workItem = new AsyncWorkItem(replySink, oldCtx); } Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain"); srvCtx.NotifyDynamicSinks( reqMsg, false, // bCliSide true, // bStart true, // bAsync true); // bNotifyGlobals // call the server context chain msgCtrl = srvCtx.GetServerContextChain().AsyncProcessMessage( reqMsg, (IMessageSink)workItem); // Note: for async calls, we will do the return notification // for dynamic properties only when the async call // completes (i.e. when the replySink gets called) Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain"); // chain back to the dispatch thread context Thread.CurrentThread.ReturnToContext(ref frame); } else { // This is the case where we take care of returning the calling // thread asap by using the ThreadPool for completing the call. // we use a more elaborate WorkItem and delegate the work to the thread pool workItem = new AsyncWorkItem(reqMsg, replySink, Thread.CurrentContext, srvID); WaitCallback threadFunc = new WaitCallback(workItem.FinishAsyncWork); // Note: Dynamic sinks are notified in the threadFunc ThreadPool.QueueUserWorkItem(threadFunc); msgCtrl = null; } } Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Async call returning!!\n"); return(msgCtrl); } // AsyncProcessMessage
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { IMessage replyMsg = null; try { Message.DebugOut("\n::::::::::::::::::::::::: CrossContext Channel: Sync call starting"); IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { return(errMsg); } ServerIdentity srvID = GetServerIdentity(reqMsg); Message.DebugOut("Got Server identity \n"); BCLDebug.Assert(null != srvID, "null != srvID"); BCLDebug.Assert(null != srvID.ServerContext, "null != srvID.ServerContext"); bool fEnteredContext = false; ContextTransitionFrame frame = new ContextTransitionFrame(); try { Context srvCtx = srvID.ServerContext; Thread.CurrentThread.EnterContext(srvCtx, ref frame); fEnteredContext = true; // If profiling of remoting is active, must tell the profiler that we have received // a message. if (RemotingServices.CORProfilerTrackRemoting()) { Guid g = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { Object obj = reqMsg.Properties["CORProfilerCookie"]; if (obj != null) { g = (Guid)obj; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(g, false); } Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: passing to ServerContextChain"); // Server side notifications for dynamic sinks are done // in the x-context channel ... this is to maintain // symmetry of the point of notification between // the client and server context srvCtx.NotifyDynamicSinks( reqMsg, false, // bCliSide true, // bStart false, // bAsync true); // bNotifyGlobals replyMsg = srvCtx.GetServerContextChain().SyncProcessMessage(reqMsg); srvCtx.NotifyDynamicSinks( replyMsg, false, // bCliSide false, // bStart false, // bAsync true); // bNotifyGlobals Message.DebugOut("::::::::::::::::::::::::: CrossContext Channel: back from ServerContextChain"); // If profiling of remoting is active, must tell the profiler that we are sending a // reply message. if (RemotingServices.CORProfilerTrackRemoting()) { Guid g; RemotingServices.CORProfilerRemotingServerSendingReply(out g, false); if (RemotingServices.CORProfilerTrackRemotingCookie()) { replyMsg.Properties["CORProfilerCookie"] = g; } } } finally { if (fEnteredContext) { Thread.CurrentThread.ReturnToContext(ref frame); } } } catch (Exception e) { Message.DebugOut("Arrgh.. XCTXSink::throwing exception " + e + "\n"); replyMsg = new ReturnMessage(e, (IMethodCallMessage)reqMsg); if (reqMsg != null) { ((ReturnMessage)replyMsg).SetLogicalCallContext( (LogicalCallContext) reqMsg.Properties[Message.CallContextKey]); } } Message.DebugOut("::::::::::::::::::::::::::: CrossContext Channel: Sync call returning!!\n"); return(replyMsg); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: AsyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); IMessageCtrl msgCtrl = null; if (errMsg == null) { errMsg = DisallowAsyncActivation(reqMsg); } if (errMsg != null) { if (replySink != null) { replySink.SyncProcessMessage(errMsg); } } else { // If active, notify the profiler that an asynchronous remoting call is being made. if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid g; RemotingServices.CORProfilerRemotingClientSendingMessage(out g, true); if (RemotingServices.CORProfilerTrackRemotingCookie()) { reqMsg.Properties["CORProfilerCookie"] = g; } // Only wrap the replySink if the call wants a reply if (replySink != null) { // Now wrap the reply sink in our own so that we can notify the profiler of // when the reply is received. Upon invocation, it will notify the profiler // then pass control on to the replySink passed in above. IMessageSink profSink = new ClientAsyncReplyTerminatorSink(replySink); // Replace the reply sink with our own replySink = profSink; } } Context cliCtx = Thread.CurrentContext; // Notify dynamic sinks that an Async call started cliCtx.NotifyDynamicSinks( reqMsg, true, // bCliSide true, // bStart true, // bAsync true); // bNotifyGlobals // Intercept the async reply to force the thread back // into the client-context before it executes further // and to notify dynamic sinks if (replySink != null) { replySink = new AsyncReplySink(replySink, cliCtx); } // Forward call to the channel. IMessageSink channelSink = GetChannelSink(reqMsg); // Move to default context unless we are going through // the cross-context channel ContextTransitionFrame frame = new ContextTransitionFrame(); if (channelSink != CrossContextChannel.MessageSink) { Thread.CurrentThread.EnterContext( Context.DefaultContext, ref frame); } msgCtrl = channelSink.AsyncProcessMessage(reqMsg, replySink); if (channelSink != CrossContextChannel.MessageSink) { Thread.CurrentThread.ReturnToContext(ref frame); } } return(msgCtrl); }
public virtual IMessage SyncProcessMessage(IMessage reqMsg) { Message.DebugOut("+++++++++++++++++++++++++ CliCtxTerminator: SyncProcessMsg"); IMessage errMsg = ValidateMessage(reqMsg); if (errMsg != null) { return(errMsg); } Context ctx = Thread.CurrentContext; bool bHasDynamicSinks = ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide true, // bStart false, // bAsync true); // bNotifyGlobals IMessage replyMsg; if (reqMsg is IConstructionCallMessage) { errMsg = ctx.NotifyActivatorProperties( reqMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } replyMsg = ((IConstructionCallMessage)reqMsg).Activator.Activate( (IConstructionCallMessage)reqMsg); BCLDebug.Assert(replyMsg is IConstructionReturnMessage, "bad ctorRetMsg"); errMsg = ctx.NotifyActivatorProperties( replyMsg, false /*bServerSide*/); if (errMsg != null) { return(errMsg); } } else { ChannelServices.NotifyProfiler(reqMsg, RemotingProfilerEvent.ClientSend); // Forward call to the channel. IMessageSink channelSink = GetChannelSink(reqMsg); // Move to default context unless we are going through // the cross-context channel ContextTransitionFrame frame = new ContextTransitionFrame(); if (channelSink != CrossContextChannel.MessageSink) { Thread.CurrentThread.EnterContext( Context.DefaultContext, ref frame); } replyMsg = channelSink.SyncProcessMessage(reqMsg); if (channelSink != CrossContextChannel.MessageSink) { Thread.CurrentThread.ReturnToContext(ref frame); } ChannelServices.NotifyProfiler(replyMsg, RemotingProfilerEvent.ClientReceive); } if (bHasDynamicSinks) { ctx.NotifyDynamicSinks(reqMsg, true, // bCliSide false, // bStart false, // bAsync true); // bNotifyGlobals } return(replyMsg); }