protected override void OnResponseMessageReceived(object sender, DuplexChannelMessageEventArgs e) { using (EneterTrace.Entering()) { if (BrokerMessageReceived == null) { EneterTrace.Warning(TracedObject + ErrorHandler.NobodySubscribedForMessage); return; } BrokerMessageReceivedEventArgs anEvent = null; try { BrokerMessage aMessage = mySerializer.ForResponseReceiver(e.ResponseReceiverId).Deserialize <BrokerMessage>(e.Message); anEvent = new BrokerMessageReceivedEventArgs(aMessage.MessageTypes[0], aMessage.Message); } catch (Exception err) { EneterTrace.Warning(TracedObject + "failed to deserialize the request message.", err); anEvent = new BrokerMessageReceivedEventArgs(err); } try { BrokerMessageReceived(this, anEvent); } catch (Exception err) { EneterTrace.Warning(TracedObject + ErrorHandler.DetectedException, err); } } }
private void Send(EBrokerRequest request, string[] messageTypes) { using (EneterTrace.Entering()) { BrokerMessage aBrokerMessage = new BrokerMessage(request, messageTypes); Send(aBrokerMessage); } }
public _T Deserialize <_T>(object serializedData) { using (EneterTrace.Entering()) { if (serializedData is byte[] == false) { throw new ArgumentException("Input parameter 'serializedData' is not byte[]."); } if (typeof(_T) != typeof(BrokerMessage)) { throw new InvalidOperationException("Data can be deserialized only into" + typeof(BrokerMessage).Name); } BrokerMessage aResult; byte[] aData = (byte[])serializedData; using (MemoryStream aStream = new MemoryStream(aData)) { BinaryReader aReader = new BinaryReader(aStream); // Read broker request. int aBrokerRequestNumber = aReader.ReadByte(); EBrokerRequest aBrokerRequest = (EBrokerRequest)aBrokerRequestNumber; // Read number of message types. int aNumberOfMessageTypes = myEncoderDecoder.ReadInt32(aReader, myIsLittleEndian); // Read message types. string[] aMessageTypes = new string[aNumberOfMessageTypes]; for (int i = 0; i < aMessageTypes.Length; ++i) { string aMessageType = myEncoderDecoder.ReadPlainString(aReader, Encoding.UTF8, myIsLittleEndian); aMessageTypes[i] = aMessageType; } if (aBrokerRequest == EBrokerRequest.Publish) { object aPublishedMessage = myEncoderDecoder.Read(aReader, myIsLittleEndian); aResult = new BrokerMessage(aMessageTypes[0], aPublishedMessage); } else { aResult = new BrokerMessage(aBrokerRequest, aMessageTypes); } return((_T)(object)aResult); } } }
public void SendMessage(string eventId, object message) { using (EneterTrace.Entering()) { try { BrokerMessage aBrokerMessage = new BrokerMessage(eventId, message); Send(aBrokerMessage); } catch (Exception err) { EneterTrace.Error(TracedObject + "failed to send the message to the broker.", err); throw; } } }
public void SendMessage(string eventId, object serializedMessage) { using (EneterTrace.Entering()) { BrokerMessage aNotifyMessage = new BrokerMessage(eventId, serializedMessage); // If one serializer is used for the whole communication then pre-serialize the message to increase the performance. // If there is SerializerProvider callback then the serialization must be performed before sending individualy // for each client. object aSerializedNotifyMessage = null; if (mySerializer.IsSameForAllResponseReceivers()) { aSerializedNotifyMessage = mySerializer.Serialize <BrokerMessage>(aNotifyMessage); } Publish(myLocalReceiverId, aNotifyMessage, aSerializedNotifyMessage); } }
public object Serialize <_T>(_T dataToSerialize) { using (EneterTrace.Entering()) { if (typeof(_T) != typeof(BrokerMessage)) { throw new InvalidOperationException("Only " + typeof(BrokerMessage).Name + " can be serialized."); } object aTemp = dataToSerialize; BrokerMessage aBrokerMessage = (BrokerMessage)aTemp; using (MemoryStream aStream = new MemoryStream()) { BinaryWriter aWriter = new BinaryWriter(aStream); // Write broker request. byte aBrokerRequestValue = (byte)aBrokerMessage.Request; aWriter.Write((byte)aBrokerRequestValue); // Write message types. myEncoderDecoder.WriteInt32(aWriter, aBrokerMessage.MessageTypes.Length, myIsLittleEndian); foreach (string aMessageType in aBrokerMessage.MessageTypes) { myEncoderDecoder.WritePlainString(aWriter, aMessageType, Encoding.UTF8, myIsLittleEndian); } // Write message. if (aBrokerMessage.Request == EBrokerRequest.Publish) { myEncoderDecoder.Write(aWriter, aBrokerMessage.Message, myIsLittleEndian); } return(aStream.ToArray()); } } }
private void Send(BrokerMessage message) { using (EneterTrace.Entering()) { if (AttachedDuplexOutputChannel == null) { string anError = TracedObject + "failed to send the message because it is not attached to any duplex output channel."; EneterTrace.Error(anError); throw new InvalidOperationException(anError); } try { object aSerializedMessage = mySerializer.ForResponseReceiver(AttachedDuplexOutputChannel.ResponseReceiverId).Serialize <BrokerMessage>(message); AttachedDuplexOutputChannel.SendMessage(aSerializedMessage); } catch (Exception err) { string anError = TracedObject + "failed to send a message to the Broker."; EneterTrace.Error(anError, err); throw; } } }
private void Publish(string publisherResponseReceiverId, BrokerMessage message, object originalSerializedMessage) { using (EneterTrace.Entering()) { List <TSubscription> anIdetifiedSubscriptions = new List <TSubscription>(); using (ThreadLock.Lock(mySubscribtions)) { foreach (TSubscription aMessageSubscription in mySubscribtions) { if ((myIsPublisherSelfnotified || aMessageSubscription.ReceiverId != publisherResponseReceiverId) && aMessageSubscription.MessageTypeId == message.MessageTypes[0]) { anIdetifiedSubscriptions.Add(aMessageSubscription); } } } Dictionary <string, IEnumerable <string> > aFailedSubscribers = new Dictionary <string, IEnumerable <string> >(); int aNumberOfSentSubscribers = 0; foreach (TSubscription aSubscription in anIdetifiedSubscriptions) { if (aSubscription.ReceiverId == myLocalReceiverId) { if (BrokerMessageReceived != null) { try { BrokerMessageReceivedEventArgs anEvent = new BrokerMessageReceivedEventArgs(message.MessageTypes[0], message.Message); BrokerMessageReceived(this, anEvent); } catch (Exception err) { EneterTrace.Warning(TracedObject + ErrorHandler.DetectedException, err); } ++aNumberOfSentSubscribers; } } else { object aSerializedMessage = originalSerializedMessage; if (aSerializedMessage == null) { try { ISerializer aSerializer = mySerializer.ForResponseReceiver(aSubscription.ReceiverId); aSerializedMessage = aSerializer.Serialize <BrokerMessage>(message); } catch (Exception err) { EneterTrace.Error(TracedObject + "failed to serialize BrokerMessage using GetSerializeCallback.", err); } } if (aSerializedMessage != null) { IEnumerable <string> anUnsubscribedMessagesDueToFailure = Send(aSubscription.ReceiverId, aSerializedMessage); if (anUnsubscribedMessagesDueToFailure.Any()) { aFailedSubscribers[aSubscription.ReceiverId] = anUnsubscribedMessagesDueToFailure; } else { ++aNumberOfSentSubscribers; } } } } if (MessagePublished != null) { PublishInfoEventArgs anEvent = new PublishInfoEventArgs(publisherResponseReceiverId, message.MessageTypes[0], message.Message, aNumberOfSentSubscribers); try { MessagePublished(this, anEvent); } catch (Exception err) { EneterTrace.Warning(TracedObject + ErrorHandler.DetectedException, err); } } // If sending to some subscribers failed then they were unsubscribed. foreach (KeyValuePair <string, IEnumerable <string> > aFailedSubscriber in aFailedSubscribers) { RaiseClientUnsubscribed(aFailedSubscriber.Key, aFailedSubscriber.Value); } } }