public void Send(MemoryStream buffer, TransportMessage message)
{
if (_isInClosedState)
{
if (_closedStateStopwatch.Elapsed < _options.ClosedStateDuration)
{
_logger.DebugFormat("Send ignored in closed state, Peer: {0}, MessageTypeId: {1}, MessageId: {2}", _peerId, message.MessageTypeId, message.Id);
return;
}
SwitchToOpenState();
}
if (_socket.SendWithTimeout(buffer.GetBuffer(), (int)buffer.Position, _options.SendTimeout) >= 0)
{
_failedSendCount = 0;
return;
}
_logger.ErrorFormat("Unable to send message, destination peer: {0}, MessageTypeId: {1}, MessageId: {2}", _peerId, message.MessageTypeId, message.Id);
if (_failedSendCount >= _options.SendRetriesBeforeSwitchingToClosedState)
SwitchToClosedState();
++_failedSendCount;
}
public void should_send_MessageProcessingFailed_if_unable_to_deserialize_message()
{
SetupPeersHandlingMessage<MessageProcessingFailed>(_peerUp);
_bus.Start();
var command = new FakeCommand(123);
_messageSerializer.AddSerializationExceptionFor(command.TypeId(), "Serialization error");
using (SystemDateTime.PauseTime())
using (MessageId.PauseIdGeneration())
{
var transportMessage = command.ToTransportMessage();
var messageProcessingFailedBytes = new MessageProcessingFailed(null, null, null, DateTime.UtcNow, null).ToTransportMessage().MessageBytes;
_messageSerializer.AddSerializationFuncFor<MessageProcessingFailed>(x =>
{
x.FailingMessage.ShouldEqual(transportMessage);
x.ExceptionUtcTime.ShouldEqual(SystemDateTime.UtcNow);
x.ExceptionMessage.ShouldContain("Unable to deserialize message");
return messageProcessingFailedBytes;
});
_transport.RaiseMessageReceived(transportMessage);
var processingFailedTransportMessage = new TransportMessage(MessageUtil.TypeId<MessageProcessingFailed>(), messageProcessingFailedBytes, _self);
_transport.ExpectExactly(new TransportMessageSent(processingFailedTransportMessage, _peerUp));
}
}
public static MessageContext CreateNew(TransportMessage transportMessage)
{
return new MessageContext
{
MessageId = transportMessage.Id,
Originator = transportMessage.Originator,
};
}
public MessageProcessingFailed(TransportMessage failingMessage, string failingMessageJson, string exceptionMessage, DateTime exceptionUtcTime, string[] failingHandlerNames)
{
FailingMessage = failingMessage;
FailingMessageJson = failingMessageJson;
ExceptionMessage = exceptionMessage;
ExceptionUtcTime = exceptionUtcTime;
FailingHandlerNames = failingHandlerNames ?? ArrayUtil.Empty<string>();
}
public void Send(TransportMessage message, IEnumerable<Peer> peerIds)
{
var targets = peerIds.ToArray();
if (targets.Length != 0)
_messages.Add(new TransportMessageSent(message, targets));
var deserializedMessage = _messageSerializer.Deserialize(message.MessageTypeId, message.MessageBytes);
if (deserializedMessage != null)
MessagesSent.Add(deserializedMessage);
}
public static IMessage ToMessage(this IMessageSerializer serializer, TransportMessage transportMessage)
{
return serializer.Deserialize(transportMessage.MessageTypeId, transportMessage.MessageBytes);
}
public void ReconnectFor(string endPoint, TransportMessage message)
{
Disconnect();
EndPoint = endPoint;
ConnectFor(message);
}
public PersistMessageCommand(TransportMessage transportMessage, PeerId[] targets)
{
TransportMessage = transportMessage;
Targets = targets;
}
public abstract void OnRealTimeMessage(TransportMessage transportMessage);
public MessageReplayed(Guid replayId, TransportMessage message)
{
ReplayId = replayId;
Message = message;
}
public void Send(TransportMessage message, IEnumerable <Peer> peers, SendContext context)
{
_outboundSocketActions.Add(OutboundSocketAction.Send(message, peers, context));
}
private static void Serialize(MemoryStream outputBuffer, TransportMessage transportMessage)
{
outputBuffer.Position = 0;
Serializer.Serialize(outputBuffer, transportMessage);
}
private void TriggerMessageReceived(TransportMessage transportMessage)
{
MessageReceived(transportMessage);
}
public ReplayMessageCommand(TransportMessage messageToReplay, string[] handlerTypes)
{
MessageToReplay = messageToReplay;
HandlerTypes = handlerTypes ?? ArrayUtil.Empty<string>();
}
public void should_send_various_sized_messages()
{
var senderTransport = CreateAndStartZmqTransport();
senderTransport.SocketOptions.SendHighWaterMark = 3;
var receviedMessages = new List<TransportMessage>();
var receiverTransport = CreateAndStartZmqTransport(onMessageReceived: receviedMessages.Add);
var receiver = new Peer(new PeerId("Abc.Testing.Receiver.Up"), receiverTransport.InboundEndPoint);
var messageBytes = new byte[5000];
new Random().NextBytes(messageBytes);
var bigMessage = new TransportMessage(new MessageTypeId(typeof(FakeCommand)), messageBytes, new PeerId("X"), senderTransport.InboundEndPoint, MessageId.NextId());
senderTransport.Send(bigMessage, new[] { receiver });
Wait.Until(() => receviedMessages.Count == 1, 150.Milliseconds());
receviedMessages[0].ShouldHaveSamePropertiesAs(bigMessage);
var smallMessage = new TransportMessage(new MessageTypeId(typeof(FakeCommand)), new byte[1], new PeerId("X"), senderTransport.InboundEndPoint, MessageId.NextId());
senderTransport.Send(smallMessage, new[] { receiver });
Wait.Until(() => receviedMessages.Count == 2, 150.Milliseconds());
receviedMessages[1].ShouldHaveSamePropertiesAs(smallMessage);
}
public void Send(TransportMessage message, IEnumerable<Peer> peerIds)
{
var peerList = (peerIds as IList<Peer>) ?? peerIds.ToList();
var upPeers = (peerList.Count == 1 && peerList[0].IsUp) ? peerList : peerList.Where(peer => peer.IsUp);
_innerTransport.Send(message, upPeers);
if (!message.MessageTypeId.IsPersistent())
return;
var persistentPeerIds = peerList.Where(x => _peerDirectory.IsPersistent(x.Id))
.Select(x => x.Id)
.ToArray();
if (!persistentPeerIds.Any())
return;
var persistMessageCommand = new PersistMessageCommand(message, persistentPeerIds);
EnqueueOrSendToPersistenceService(persistMessageCommand);
}
public static OutboundSocketAction Send(TransportMessage message, IEnumerable <Peer> peers, SendContext context)
{
return(new OutboundSocketAction(message, peers, context));
}
private OutboundSocketAction(TransportMessage message, IEnumerable <Peer> targets, SendContext context)
{
Message = message;
Targets = targets as List <Peer> ?? targets.ToList();
Context = context;
}
public void AckMessage(TransportMessage transportMessage)
{
}
private OutboundSocketAction(TransportMessage message, IEnumerable <Peer> peers)
{
Message = message;
Peers = peers;
}
public void AckMessage(TransportMessage transportMessage)
{
_ackedMessages.Add(transportMessage);
}
public TransportMessageSent(TransportMessage transportMessage, params Peer[] targets)
{
TransportMessage = transportMessage;
Targets = targets;
}
public void Send(TransportMessage message, IEnumerable <Peer> peers)
{
Send(message, peers, new SendContext());
}
private void OnTransportMessageReceived(TransportMessage transportMessage)
{
if (_replayMessageTypeIds.Contains(transportMessage.MessageTypeId))
{
var replayEvent = (IReplayEvent)_serializer.ToMessage(transportMessage);
if (replayEvent.ReplayId == _currentReplayId)
_phase.OnReplayEvent(replayEvent);
return;
}
if (transportMessage.MessageTypeId == MessageTypeId.PersistenceStopping)
{
_persistenceIsDown = true;
var ackMessage = _innerTransport.CreateInfrastructureTransportMessage(MessageTypeId.PersistenceStoppingAck);
_logger.InfoFormat("Sending PersistenceStoppingAck to {0}", transportMessage.Originator.SenderId);
_innerTransport.Send(ackMessage, new[] { new Peer(transportMessage.Originator.SenderId, transportMessage.Originator.SenderEndPoint) });
return;
}
if (transportMessage.MessageTypeId.IsInfrastructure())
TriggerMessageReceived(transportMessage);
else
_phase.OnRealTimeMessage(transportMessage);
}
public override void ProcessPendingReceive(TransportMessage transportMessage)
{
if (Transport._receivedMessagesIds.ContainsKey(transportMessage.Id))
return;
try
{
Transport.TriggerMessageReceived(transportMessage);
}
catch (Exception exception)
{
var errorMessage = string.Format("Unable to handle message {0} during SafetyPhase.", transportMessage.MessageTypeId.FullName);
_logger.Error(errorMessage, exception);
}
Transport._receivedMessagesIds.TryAdd(transportMessage.Id, true);
}
public void AckMessage(TransportMessage transportMessage)
{
if (transportMessage.ForcePersistenceAck || (_isPersistent && transportMessage.MessageTypeId.IsPersistent()))
{
_logger.DebugFormat("PERSIST ACK: {0} {1}", transportMessage.MessageTypeId, transportMessage.Id);
EnqueueOrSendToPersistenceService(new MessageHandled(transportMessage.Id));
}
}
public override void OnRealTimeMessage(TransportMessage transportMessage)
{
Transport._pendingReceives.Add(transportMessage);
}
public override void OnRealTimeMessage(TransportMessage transportMessage)
{
Transport.TriggerMessageReceived(transportMessage);
}
public virtual void ProcessPendingReceive(TransportMessage transportMessage)
{
Transport._logger.ErrorFormat("DISCARDING MESSAGE {0} {1}", transportMessage.MessageTypeId, transportMessage.Id);
}
public void RaiseMessageReceived(TransportMessage transportMessage)
{
MessageReceived(transportMessage);
}
public void Send(TransportMessage message, IEnumerable <Peer> peerIds)
{
message.Environment = _environment;
_outboundSocketActions.Add(OutboundSocketAction.Send(message, peerIds.ToList()));
}