public void handle_envelope_sent_then_message_failed_tracking_for_the_same_message_to_multiple_nodes()
{
MessageHistory.ClearHistory();
var envelope1 = new EnvelopeToken();
var node1 = new StubChannelNode();
var node2 = new StubChannelNode();
MessageHistory.Record(new EnvelopeSent(envelope1, node1));
MessageHistory.Record(new EnvelopeSent(envelope1, node2));
MessageHistory.Outstanding().Count().ShouldBe(2);
envelope1.Destination = node1.Uri;
MessageHistory.Record(new MessageFailed
{
Envelope = envelope1
});
MessageHistory.Outstanding().Count().ShouldBe(1);
envelope1.Destination = node2.Uri;
MessageHistory.Record(new MessageFailed
{
Envelope = envelope1
});
MessageHistory.Outstanding().Any().ShouldBeFalse();
}
public void handle_envelope_sent_then_message_successful_for_multiple_messages_to_the_same_node()
{
MessageHistory.ClearHistory();
var envelope1 = new EnvelopeToken();
var envelope2 = new EnvelopeToken();
var node1 = new StubChannelNode();
MessageHistory.Record(new EnvelopeSent(envelope1, node1).ToMessageTrack());
MessageHistory.Record(new EnvelopeSent(envelope2, node1).ToMessageTrack());
MessageHistory.Outstanding().Count().ShouldBe(2);
envelope1.Destination = node1.Uri;
MessageHistory.Record(new MessageSuccessful
{
Envelope = envelope1
}.ToMessageTrack());
MessageHistory.Outstanding().Count().ShouldBe(1);
envelope2.Destination = node1.Uri;
MessageHistory.Record(new MessageSuccessful
{
Envelope = envelope2
}.ToMessageTrack());
MessageHistory.Outstanding().Any().ShouldBeFalse();
}
public EnvelopeSent(EnvelopeToken envelope, ChannelNode node)
{
Envelope = envelope;
Uri = node.Uri;
Key = node.Key;
}
public void handle_envelope_sent_then_message_successful_tracking_for_the_same_message_to_multiple_nodes()
{
MessageHistory.StartListening();
var envelope1 = new EnvelopeToken();
var node1 = new StubChannelNode();
var node2 = new StubChannelNode();
var messageWatcher = new MessageWatcher();
messageWatcher.Handle(new EnvelopeSent(envelope1, node1));
messageWatcher.Handle(new EnvelopeSent(envelope1, node2));
MessageHistory.Outstanding().Count().ShouldEqual(2);
envelope1.Destination = node1.Uri;
messageWatcher.Handle(new MessageSuccessful
{
Envelope = envelope1
});
MessageHistory.Outstanding().Count().ShouldEqual(1);
envelope1.Destination = node2.Uri;
messageWatcher.Handle(new MessageSuccessful
{
Envelope = envelope1
});
MessageHistory.Outstanding().Any().ShouldBeFalse();
}
public void SetUp()
{
theToken = ObjectMother.EnvelopeWithMessage().ToToken();
theToken.ParentId = Guid.NewGuid().ToString();
theToken.Headers["A"] = "1";
theToken.Headers["B"] = "2";
theRecord = new MessageRecord(theToken);
}
public void Send(byte[] data, IHeaders headers)
{
var envelope = new EnvelopeToken
{
Data = data,
Headers = headers
};
_queue.Enqueue(envelope);
}
public void Enqueue(EnvelopeToken envelope)
{
using (var stream = new MemoryStream())
{
_formatter.Serialize(stream, envelope);
stream.Position = 0;
var bytes = stream.ReadAllBytes();
_queue.Add(bytes);
}
}
public MessageRecord(EnvelopeToken envelope)
{
Id = envelope.CorrelationId;
ParentId = envelope.ParentId;
if (envelope.Message != null)
{
_messageType = envelope.Message.GetType();
Type = _messageType.FullName;
}
Headers = envelope.Headers.Keys().Select(x => "{0}={1}".ToFormat(x, envelope.Headers[x])).Join(";");
}
private void SendResponseMessage(object message, EnvelopeToken request)
{
var sender = Runtime.Get <IEnvelopeSender>();
var response = new Envelope
{
Message = message,
Destination = request.ReplyUri,
OriginalId = request.OriginalId ?? request.CorrelationId,
ParentId = request.CorrelationId,
ResponseId = request.CorrelationId
};
sender.Send(response);
}
public void moves_to_delayed_queue()
{
InMemoryQueueManager.ClearAll();
var envelope = new EnvelopeToken();
var callback = new InMemoryCallback(null, envelope);
callback.MoveToDelayedUntil(DateTime.Now);
var delayed = InMemoryQueueManager.DelayedEnvelopes().Single();
delayed.CorrelationId.ShouldEqual(envelope.CorrelationId);
delayed.ExecutionTime.ShouldNotBeNull();
}
private void handle(EnvelopeToken envelope, string status, Uri uri)
{
if (envelope.IsPollingJobRelated())
{
return;
}
var track = new MessageTrack
{
Type = "OutstandingEnvelope",
Id = envelope.CorrelationId,
FullName = "{0}@{1}".ToFormat(envelope.CorrelationId, uri),
Status = status
};
Bottles.Services.Messaging.EventAggregator.SendMessage(track);
}
public void SetUp()
{
theEvents = MockRepository.GenerateMock <IEventAggregator>();
theListener = new ReplyListener <Message1>(theEvents, correlationId, 10.Minutes());
theMessage = new Message1();
var envelope = new EnvelopeToken
{
Message = theMessage
};
envelope.Headers[Envelope.ResponseIdKey] = correlationId;
theListener.Handle(new EnvelopeReceived
{
Envelope = envelope
});
}
public void dequeue_a_single_transport_should_log_all_the_requeued_envelopes()
{
var logger = new RecordingLogger();
Services.Inject <ILogger>(logger);
var envelopes = new EnvelopeToken[] { new EnvelopeToken(), new EnvelopeToken(), new EnvelopeToken() };
LocalSystemTime = DateTime.Today.AddHours(5);
var theTransport = MockFor <ITransport>();
theTransport.Stub(x => x.ReplayDelayed(UtcSystemTime))
.Return(envelopes);
ClassUnderTest.DequeuFromTransport(theTransport, UtcSystemTime);
envelopes.Each(env => {
logger.InfoMessages.ShouldContain(new DelayedEnvelopeAddedBackToQueue {
Envelope = env
});
});
}
public void SetUp()
{
theEvents = MockRepository.GenerateMock <IEventAggregator>();
theListener = new ReplyListener <Message1>(theEvents, correlationId, 10.Minutes());
var envelope = new EnvelopeToken
{
Message = new FailureAcknowledgement
{
CorrelationId = Guid.NewGuid().ToString(),
Message = "No soup for you!"
}
};
envelope.Headers[Envelope.ResponseIdKey] = correlationId;
theListener.Handle(new EnvelopeReceived
{
Envelope = envelope
});
}
public void Handle(EnvelopeReceived message)
{
EnvelopeToken envelope = message.Envelope;
_receivedEnvelopes.Add(envelope);
// Acknowledge that the message was received so it doesn't
// get stuck as Outstanding in the MessageHistory
// Sometimes this happens in the wrong order so we need to
// wait for it to be in the pending list first.
FubuMVC.Core.Services.Wait.Until(() => MessageHistory.Outstanding().Any(x => x.Id == envelope.CorrelationId),
millisecondPolling: 50,
timeoutInMilliseconds: 1000);
var track = new MessageTrack
{
FullName = "{0}@{1}".ToFormat(envelope.CorrelationId, envelope.Destination),
Id = envelope.CorrelationId,
Status = MessageTrack.Received,
Type = "OutstandingEnvelope"
};
FubuMVC.Core.Services.Messaging.GlobalMessageTracking.SendMessage(track);
}
public void can_round_trip_an_envelope_through_the_queue()
{
var envelope = new EnvelopeToken();
envelope.CorrelationId = Guid.NewGuid().ToString();
envelope.Headers["Foo"] = "Bar";
envelope.Data = new byte[] { 1, 2, 3, 4, 5 };
var queue = new InMemoryQueue(new Uri("memory://foo"));
var receiver = new RecordingReceiver();
var task = Task.Factory.StartNew(() => queue.Receive(receiver));
queue.Enqueue(envelope);
Wait.Until(() => receiver.Received.Count > 0, timeoutInMilliseconds: 2000);
var received = receiver.Received.Single();
received.CorrelationId.ShouldEqual(envelope.CorrelationId);
received.ContentType.ShouldEqual(envelope.ContentType);
received.Data.ShouldEqual(envelope.Data);
task.SafeDispose();
}
public static void AddToDelayedQueue(EnvelopeToken envelope)
{
_delayedLock.Write(() => {
_delayed.Add(envelope);
});
}
public InMemoryCallback(InMemoryQueue parent, EnvelopeToken token)
{
_parent = parent;
_token = token;
}
