public IMessageCtrl AsyncProcessMessage(IMessage msg,
IMessageSink replySink)
{
ITransportHeaders transportHeaders = new TransportHeaders();
Stream stream = _nextInChain.GetRequestStream(msg, transportHeaders);
if (stream == null)
{
stream = new MemoryStream();
}
_binaryCore.Serializer.Serialize(stream, msg, null);
if (stream is MemoryStream)
{
stream.Position = 0;
}
ClientChannelSinkStack stack = new ClientChannelSinkStack(replySink);
stack.Push(this, msg);
_nextInChain.AsyncProcessRequest(stack, msg, transportHeaders, stream);
// FIXME: No idea about how to implement IMessageCtrl
return(null);
}
private void AsyncProcessMessageOnce(IMessage msg,
Ior target, IMessageSink replySink)
{
IIorProfile selectedProfile;
uint reqId;
try {
// allocate (reserve) connection
GiopClientConnectionDesc conDesc = AllocateConnection(msg, target, out selectedProfile, out reqId);
SimpleGiopMsg.SetMessageAsyncRequest(msg); // mark message as async, needed for portable interceptors
ITransportHeaders requestHeaders;
Stream requestStream;
SerialiseRequest(msg, selectedProfile, conDesc, reqId,
out requestHeaders, out requestStream);
// pass the serialised GIOP-request to the first stream handling sink
// this sink is the last sink in the message handling sink chain, therefore the reply sink chain of all the previous message handling
// sink is passed to the ClientChannelSinkStack, which will inform this chain of the received reply
ClientChannelSinkStack clientSinkStack = new ClientChannelSinkStack(replySink);
AsyncProcessingData asyncData = new AsyncProcessingData(msg, conDesc);
clientSinkStack.Push(this, asyncData); // push the formatter onto the sink stack, to get the chance to handle the incoming reply stream
// forward the message to the next sink
m_nextSink.AsyncProcessRequest(clientSinkStack, msg, requestHeaders, requestStream);
// for oneway messages, release the connections for future use
if ((msg is IMethodCallMessage) && GiopMessageHandler.IsOneWayCall((IMethodCallMessage)msg))
{
m_conManager.RequestOnConnectionCompleted(msg); // release the connection, because this interaction is complete
}
} catch {
// release the connection, if something went wrong during connection allocation and send
m_conManager.RequestOnConnectionCompleted(msg); // release the connection, because this interaction is complete
throw;
}
}
public IMessageCtrl AsyncProcessMessage(IMessage msg,
IMessageSink replySink)
{
ITransportHeaders transportHeaders = new TransportHeaders();
transportHeaders[CommonTransportKeys.RequestUri] = ((IMethodCallMessage)msg).Uri;
transportHeaders["Content-Type"] = "application/octet-stream";
Stream stream = _nextInChain.GetRequestStream(msg, transportHeaders);
if (stream == null)
{
stream = new MemoryStream();
}
_binaryCore.Serializer.Serialize(stream, msg, null);
if (stream is MemoryStream)
{
stream.Position = 0;
}
ClientChannelSinkStack stack = new ClientChannelSinkStack(replySink);
stack.Push(this, msg);
_nextInChain.AsyncProcessRequest(stack, msg, transportHeaders, stream);
// FIXME: No idea about how to implement IMessageCtrl
return(null);
}
public IMessageCtrl AsyncProcessMessage(IMessage requestMsg, IMessageSink replySink)
{
// parameters validation
IMethodCallMessage methodCall = (requestMsg as IMethodCallMessage);
if (methodCall == null)
{
throw new NotSupportedException();
}
try
{
// serialize request
ITransportHeaders requestHeaders;
Stream requestStream;
SerializeRequest(methodCall, out requestHeaders, out requestStream);
// create sink stack for async request processing
ClientChannelSinkStack sinkStack = new ClientChannelSinkStack(replySink);
sinkStack.Push(this, requestMsg); // save request message as state
// call next sink to dispatch method call
_nextSink.AsyncProcessRequest(sinkStack, requestMsg, requestHeaders, requestStream);
}
catch (Exception ex)
{
if (replySink != null)
{
// process exception synchronously
replySink.SyncProcessMessage(new ReturnMessage(ex, methodCall));
}
}
return(null);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg,
IMessageSink replySink)
{
Stream reqStream;
FormatMessage(msg, out reqStream);
TransportHeaders reqHeaders = new TransportHeaders();
ClientChannelSinkStack stack = new ClientChannelSinkStack(replySink);
stack.Push(this, msg);
_next.AsyncProcessRequest(stack, msg, reqHeaders, reqStream);
return(null);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
ITransportHeaders transportHeader = new TransportHeaders();
Stream requestStream = this._nextInChain.GetRequestStream(msg, transportHeader);
if (requestStream == null)
{
requestStream = new MemoryStream();
}
this._binaryCore.Serializer.Serialize(requestStream, msg, null);
if (requestStream is MemoryStream)
{
requestStream.Position = (long)0;
}
ClientChannelSinkStack clientChannelSinkStack = new ClientChannelSinkStack(replySink);
clientChannelSinkStack.Push(this, msg);
this._nextInChain.AsyncProcessRequest(clientChannelSinkStack, msg, transportHeader, requestStream);
return(null);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMethodCallMessage methodCallMessage = msg as IMethodCallMessage;
try
{
ITransportHeaders headers;
Stream stream;
SerializeRequest(msg, out headers, out stream);
ClientChannelSinkStack clientChannelSinkStack = new ClientChannelSinkStack(replySink);
clientChannelSinkStack.Push(this, msg);
nextSink.AsyncProcessRequest(clientChannelSinkStack, msg, headers, stream);
}
catch (Exception ex)
{
IMessage returnMessage = new ReturnMessage(ex, methodCallMessage);
if (replySink == null)
{
return(null);
}
replySink.SyncProcessMessage(returnMessage);
}
return(null);
}
/// <summary>
/// Looks for a failed broadcast receivers and invoke them again.
/// </summary>
public void SendMessageToFailedReceiversDirectly()
{
if (this._secondStagePerformed)
{
return;
}
this._secondStagePerformed = true;
BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter;
// the second stage of the broadcasting
using (ReaderAutoLocker reader = new ReaderAutoLocker(this._dispatcher._readerWriterLock))
{
// to prevent firing resultCollector.AllMessagesReceived event
this.UnrepliedReceivers[_uniqueReceiverName] = null;
lock (this)
{
foreach (DictionaryEntry entry in this.Failed)
{
OperationException operationException = entry.Value as OperationException;
if (operationException != null && operationException.OperationErrorMessage != null &&
operationException.OperationErrorMessage.ErrorIdentifier == "GenuineChannels.Exception.Broadcast.RemoteEndPointDidNotReplyForTimeOut")
{
string uri = (string)entry.Key;
ReceiverInfo receiverInfo = this._dispatcher.GetReceiverInfo(uri);
// whether this receiver is expected to receive message via broadcast channel
if (receiverInfo == null || receiverInfo.NeedsBroadcastSimulation)
{
continue;
}
// switch it back to simulation mode if the limit is exceeded
lock (receiverInfo)
{
receiverInfo.NumberOfMulticastFails++;
if (this._dispatcher.MaximumNumberOfConsecutiveFailsToEnableSimulationMode != 0 &&
receiverInfo.NumberOfMulticastFails >= this._dispatcher.MaximumNumberOfConsecutiveFailsToEnableSimulationMode)
{
// force simulation
receiverInfo.NeedsBroadcastSimulation = true;
receiverInfo.NumberOfMulticastFails = 0;
}
}
// each time a new stream is created because sinks change stream position concurrently
Stream messageToBeSent = (Stream)this._messageStream.Clone();
TransportHeaders transportHeaders = new TransportHeaders();
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0)
{
string methodName = BinaryLogWriter.ParseInvocationMethod(this._iMessage.Properties["__MethodName"] as string, this._iMessage.Properties["__TypeName"] as string);
string invocationTarget = receiverInfo.MbrUri;
binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.SendMessageToFailedReceiversDirectly",
LogMessageType.BroadcastRecipientInvokedAfterTimeout, null, null, receiverInfo.DbgRemoteHost, null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, false, this._dispatcher, this, false, receiverInfo,
invocationTarget, methodName,
"The broadcast invocation is being directed to the recipient, which did not respond during the first stage.");
}
// set destination MBR
this._iMessage.Properties["__Uri"] = receiverInfo.MbrUri;
transportHeaders[Message.TransportHeadersBroadcastObjRefOrCourt] = receiverInfo.SerializedObjRef;
ClientChannelSinkStack clientChannelSinkStack = new ClientChannelSinkStack(this);
clientChannelSinkStack.Push(this, null);
receiverInfo.IClientChannelSink.AsyncProcessRequest(clientChannelSinkStack, this._iMessage, transportHeaders, messageToBeSent);
}
}
}
this.UnrepliedReceivers.Remove(_uniqueReceiverName);
if (this.UnrepliedReceivers.Count <= 0)
{
this.AllMessagesReceived.Set();
}
}
}
/// <summary>
/// Sends the invocation to all registered receivers.
/// </summary>
/// <param name="msg">The message to be sent.</param>
public void PerformBroadcasting(IMessage msg)
{
BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter;
string methodName = null;
string invocationTarget = null;
// the first stage of the broadcasting
try
{
ArrayList listOfExcludedReceivers = new ArrayList();
this._iMessage = msg;
methodName = BinaryLogWriter.ParseInvocationMethod(msg.Properties["__MethodName"] as string, msg.Properties["__TypeName"] as string);
BinaryFormatter formatterForLocalRecipients = null;
// serialize the message
BinaryFormatter binaryFormatter = new BinaryFormatter(new RemotingSurrogateSelector(), new StreamingContext(StreamingContextStates.Other));
this._messageStream = new GenuineChunkedStream(false);
binaryFormatter.Serialize(this._messageStream, msg);
// to trace the message if it could reach the server via several channels
string callGuidSubstring = null;
if (this._dispatcher.IgnoreRecurrentCalls)
{
callGuidSubstring = Guid.NewGuid().ToString("N");
}
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0)
{
binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting",
LogMessageType.BroadcastInvocationInitiated, null, null, null,
binaryLogWriter[LogCategory.BroadcastEngine] > 1 ? (Stream)this._messageStream.Clone() : null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, true, this._dispatcher, this, false, null,
methodName, null,
"The broadcast invocation is initiated.");
}
// to prevent firing resultCollector.AllMessagesReceived event
this.UnrepliedReceivers[_uniqueReceiverName] = null;
object[] listOfReceiverInfo;
this._dispatcher.GetListOfReceivers(out listOfReceiverInfo, msg, this);
// through all recipients
for (int i = 0; i < listOfReceiverInfo.Length; i++)
{
ReceiverInfo receiverInfo = listOfReceiverInfo[i] as ReceiverInfo;
if (receiverInfo == null)
{
continue;
}
string mbrUri = (string)receiverInfo.MbrUri;
invocationTarget = mbrUri;
try
{
lock (receiverInfo)
{
if (this._dispatcher.MaximumNumberOfConsecutiveFailsToExcludeReceiverAutomatically != 0 &&
receiverInfo.NumberOfFails >= this._dispatcher.MaximumNumberOfConsecutiveFailsToExcludeReceiverAutomatically)
{
// put it to the list containing receivers being excluded
listOfExcludedReceivers.Add(mbrUri);
continue;
}
}
// think that it'll fail
if (!receiverInfo.Local && receiverInfo.GeneralBroadcastSender == null)
{
lock (this)
{
this.Failed[mbrUri] = GenuineExceptions.Get_Broadcast_RemoteEndPointDidNotReplyForTimeOut();
}
}
if (receiverInfo.Local)
{
// call to local appdomain
// ignore recurrent calls
if (this._dispatcher.IgnoreRecurrentCalls && UniqueCallTracer.Instance.WasGuidRegistered(mbrUri + callGuidSubstring))
{
continue;
}
// we'll wait for the answer from this receiver
this.UnrepliedReceivers[mbrUri] = null;
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0)
{
binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting",
LogMessageType.BroadcastRecipientInvoked, null, null, null, null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, false, this._dispatcher, this, false, receiverInfo,
null, null,
"The local receiver is invoked via LocalPerformer.");
}
if (formatterForLocalRecipients == null)
{
formatterForLocalRecipients = new BinaryFormatter();
}
// fixed in 2.5.9.6
IMessage iLocalMessage = (IMessage)formatterForLocalRecipients.Deserialize((Stream)this._messageStream.Clone());
// queue task to run the call locally
//IMessage iLocalMessage = (IMessage) binaryFormatter.Deserialize( (Stream) this._messageStream.Clone() );
LocalPerformer localPerformer = new LocalPerformer(iLocalMessage, this, receiverInfo.MbrObject);
GenuineThreadPool.QueueUserWorkItem(new WaitCallback(localPerformer.Call), null, false);
}
else if (receiverInfo.GeneralBroadcastSender != null)
{
// call via true multicast channel
Stream messageToBeSent = (Stream)this._messageStream.Clone();
// send via real broadcast sender to the specific court
msg.Properties["__Uri"] = string.Empty;
Message message = Message.CreateOutcomingMessage(receiverInfo.GeneralBroadcastSender.ITransportContext, msg, new TransportHeaders(), messageToBeSent, false);
message.DestinationMarshalByRef = receiverInfo.SerializedObjRef;
message.GenuineMessageType = GenuineMessageType.TrueBroadcast;
// to ignore recurrent calls on the remote side
if (this._dispatcher.IgnoreRecurrentCalls)
{
message.ITransportHeaders[Message.TransportHeadersBroadcastSendGuid] = callGuidSubstring;
}
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0)
{
message.ITransportHeaders[Message.TransportHeadersInvocationTarget] = invocationTarget;
message.ITransportHeaders[Message.TransportHeadersMethodName] = methodName;
binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting",
LogMessageType.BroadcastRecipientInvoked, null, null, null, null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, false, this._dispatcher, this, false, receiverInfo,
null, null,
"Mulsticast sender is being invoked.");
}
// register to catch all the answers
receiverInfo.GeneralBroadcastSender.ITransportContext.IIncomingStreamHandler.RegisterResponseProcessor(message.MessageId, this);
// and send it
receiverInfo.GeneralBroadcastSender.SendMessage(message, this);
}
else
{
// send the invocation through the usual channel
// we'll wait for the reply
this.UnrepliedReceivers[mbrUri] = null;
// send only if this receiver is not expected to receive message via broadcast channel
if (receiverInfo.NeedsBroadcastSimulation)
{
// each time a new stream is created because sinks change stream position concurrently
Stream messageToBeSent = (Stream)this._messageStream.Clone();
TransportHeaders transportHeaders = new TransportHeaders();
// to ignore recurrent calls on the remote side
if (this._dispatcher.IgnoreRecurrentCalls)
{
transportHeaders[Message.TransportHeadersBroadcastSendGuid] = callGuidSubstring;
}
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0)
{
binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting",
LogMessageType.BroadcastRecipientInvoked, null, null, receiverInfo.DbgRemoteHost, null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, false, this._dispatcher, this, false, receiverInfo,
null, null,
"The broadcast recipient is being invoked directly.");
}
// invoke the destination MBR
msg.Properties["__Uri"] = receiverInfo.MbrUri;
transportHeaders[Message.TransportHeadersBroadcastObjRefOrCourt] = receiverInfo.SerializedObjRef;
transportHeaders[Message.TransportHeadersMbrUriName] = receiverInfo.MbrUri;
transportHeaders[Message.TransportHeadersGenuineMessageType] = GenuineMessageType.BroadcastEngine;
transportHeaders[Message.TransportHeadersInvocationTarget] = invocationTarget;
transportHeaders[Message.TransportHeadersMethodName] = methodName;
ClientChannelSinkStack clientChannelSinkStack = new ClientChannelSinkStack(this);
clientChannelSinkStack.Push(this, null);
receiverInfo.IClientChannelSink.AsyncProcessRequest(clientChannelSinkStack, this._iMessage, transportHeaders, messageToBeSent);
}
}
}
catch (Exception ex)
{
this.ParseResult(mbrUri, null, ex);
}
}
// remove set uri from the hash to check wither the invocation finished
this.UnrepliedReceivers.Remove(_uniqueReceiverName);
if (this.UnrepliedReceivers.Count <= 0)
{
this.AllMessagesReceived.Set();
}
this.StartReceiving();
if (listOfExcludedReceivers.Count > 0)
{
foreach (string uri in listOfExcludedReceivers)
{
this._dispatcher.Remove(uri);
}
}
}
catch (Exception ex)
{
// LOG:
if (binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0)
{
binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "ResultCollector.PerformBroadcasting",
LogMessageType.BroadcastInvocationInitiated, ex, null, null, null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, false, this._dispatcher, this, false, null,
invocationTarget, methodName,
"A critical failure occurred during broadcast.");
}
throw;
}
}
