// -=-=-=-=-=-=-=-=- IServerChannelSink -=-=-=-=-=-=-=-=-
/// <remarks>
/// Acts as though Remoting request has travalled up the server
/// side Remoting channel.
/// </remarks>
/// <summary>
/// Retrieves response to Remoting request.
/// </summary>
/// <param name="sinkStack">Default ServerChannelSinkStack</param>
/// <param name="requestMsg">The request message</param>
/// <param name="requestHeaders">No used.</param>
/// <param name="requestStream">No used.</param>
/// <param name="responseMsg">The response message to return</param>
/// <param name="responseHeaders">No used.</param>
/// <param name="responseStream">No used.</param>
/// <returns></returns>
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders,
out Stream responseStream)
{
ServerProcessing sp;
requestHeaders = new TransportHeaders();
sp = ChannelServices.DispatchMessage(sinkStack, requestMsg, out responseMsg);
responseHeaders = null;
responseStream = null;
return(sp);
}
private void ProcessMessage(object waitCallbackState)
{
var requestMessage = (NullMessages.RequestMessage)waitCallbackState;
// replace full url with object url
var url = requestMessage.RequestHeaders[CommonTransportKeys.RequestUri].ToString();
string objectUri;
NullChannel.ParseUrl(url, out objectUri);
objectUri = objectUri ?? url;
requestMessage.RequestHeaders[CommonTransportKeys.RequestUri] = objectUri;
requestMessage.Message.Properties["__Uri"] = objectUri;
// add client address property for compatibility
var callContext = requestMessage.Message.Properties["__CallContext"] as LogicalCallContext;
callContext.SetData(ClientAddressSink.CallContextSlotName, IPAddress.Loopback);
IMessage responseMsg;
ITransportHeaders responseHeaders;
Stream responseStream;
// create sink stack to process request message
var stack = new ServerChannelSinkStack();
stack.Push(this, null);
// process request message
ServerProcessing serverProcessing;
if (NextChannelSink != null)
{
// full processing mode, with deserialization
serverProcessing = NextChannelSink.ProcessMessage(stack, null,
requestMessage.RequestHeaders, requestMessage.RequestStream,
out responseMsg, out responseHeaders, out responseStream);
}
else
{
// fast processing mode, bypassing deserialization
serverProcessing = ChannelServices.DispatchMessage(stack, requestMessage.Message, out responseMsg);
responseHeaders = null;
responseStream = null;
}
// send back the reply
switch (serverProcessing)
{
case ServerProcessing.Complete:
stack.Pop(this);
NullMessages.AddResponse(requestMessage, new NullMessages.ResponseMessage
{
Message = responseMsg,
ResponseHeaders = responseHeaders,
ResponseStream = responseStream
});
break;
case ServerProcessing.Async:
stack.StoreAndDispatch(NextChannelSink, null);
break;
case ServerProcessing.OneWay:
stack.Pop(this);
break;
}
}
