/// <summary>
/// Initializes a new instance of the <see cref="T:ExitGames.Diagnostics.Counter.AverageCounter"/> class.
/// </summary>
/// <param name="name">The counter name.</param>
public AverageCounter(string name)
: base(name)
{
this.sharedCounter = new SharedCounter(name);
this.sharedCounterBase = new SharedCounter(name);
this.oldSample = this.GetNextSample();
}
public async Task ItWorksWithCovarianceToo()
{
var counter = new SharedCounter(1);
Using(counter);
_activator.Handle <BaseMessage>(async baseMessage =>
{
throw new ApplicationException("1st level!!");
});
_activator.Handle <IFailed <BaseMessage> >(async failed =>
{
if (failed.Message is ConcreteMessage)
{
counter.Decrement();
return;
}
counter.Fail("Did not receive the expected message!");
});
await _bus.SendLocal(new ConcreteMessage());
counter.WaitForResetEvent();
}
public async Task IncludesFullErrorDetailsWhenSecondLevelRetriesFailToo()
{
var counter = new SharedCounter(1);
Using(counter);
_activator.Handle <string>(async str =>
{
throw new ApplicationException("1st level!!");
});
_activator.Handle <IFailed <string> >(async failed =>
{
throw new ApplicationException("2nd level!!");
});
await _bus.SendLocal("hej med dig!");
var transportMessage = await _network.WaitForNextMessageFrom("error");
var errorDetails = transportMessage.Headers[Headers.ErrorDetails];
Console.WriteLine(errorDetails);
Assert.That(errorDetails, Does.Contain("1st level!!"));
Assert.That(errorDetails, Does.Contain("2nd level!!"));
}
public void CorrelationIdFlows()
{
var correlationIds = new List<string>();
var counter = new SharedCounter(1);
_activator1.Handle<string>(async (bus, ctx, str) =>
{
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.Handle<string>(async (bus, ctx, str) =>
{
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
await bus.Advanced.Routing.Send("bus3", "hej!");
});
_activator3.Handle<string>(async (bus, ctx, str) =>
{
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
Assert.That(correlationIds.GroupBy(c => c).Count(), Is.EqualTo(1));
}
public void CorrelationSequenceIsIncremented()
{
var correlationSequenceNumbers = new List<int>();
var counter = new SharedCounter(1);
_activator1.Handle<string>(async (bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.Handle<string>(async (bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
await bus.Advanced.Routing.Send("bus3", "hej!");
});
_activator3.Handle<string>(async (bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
Assert.That(correlationSequenceNumbers, Is.EqualTo(new[] { 0, 1, 2 }));
}
public async Task ItWorks()
{
var counter = new SharedCounter(1);
Using(counter);
_activator.Handle <string>(async str =>
{
throw new ApplicationException("1st level!!");
});
_activator.Handle <IFailed <string> >(async failed =>
{
if (failed.Message != "hej med dig!")
{
counter.Fail("Did not receive the expected message!");
return;
}
counter.Decrement();
});
await _bus.SendLocal("hej med dig!");
counter.WaitForResetEvent();
}
static void RunTheTest(IRebusLoggerFactory logger)
{
using var sharedCounter = new SharedCounter(3, "Message counter")
{
Delay = TimeSpan.FromSeconds(2)
};
using var activator = new BuiltinHandlerActivator();
activator.Register(() => new SomeSaga(sharedCounter));
var bus = Configure.With(activator)
.Logging(l => l.Use(logger))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "saga_snapshots_integration_testerino"))
.Sagas(s => s.StoreInMemory())
.Options(o => o.EnableSagaAuditing().OutputToLog())
.Start();
Task.WaitAll(
bus.SendLocal("hej/med dig"),
bus.SendLocal("hej/igen"),
bus.SendLocal("hej/igen med dig")
);
sharedCounter.WaitForResetEvent(timeoutSeconds: 10);
}
public async Task EverythingHappensInSerialOrder(int numberOfMessages)
{
var bus = _activator.Bus;
var counter = new SharedCounter(numberOfMessages);
_activator.Handle <string>(async str =>
{
await Task.Yield();
_eventRecorder.Enqueue($"Handling {str}");
counter.Decrement();
});
foreach (var number in Enumerable.Range(1, numberOfMessages))
{
await bus.SendLocal($"{number}", new Dictionary <string, string> {
{ "number", number.ToString(CultureInfo.InvariantCulture) }
});
}
counter.WaitForResetEvent(5 + numberOfMessages / 10);
// allow for handler pipeline to finish processing the last message
await Task.Delay(500);
// now check that no events were interleaved at any point in time
foreach (var batch in _eventRecorder.Batch(4))
{
VerifyBatch(batch);
}
}
public void CorrelationIdIsFirstMessageId()
{
var messageIds = new List <string>();
var correlationIds = new List <string>();
var counter = new SharedCounter(1);
_activator1.Handle <string>(async(bus, ctx, str) =>
{
messageIds.Add(ctx.Headers[Headers.MessageId]);
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.Handle <string>(async(bus, ctx, str) =>
{
messageIds.Add(ctx.Headers[Headers.MessageId]);
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
var firstMessageId = messageIds.First();
Assert.That(correlationIds.All(c => c == firstMessageId), Is.True);
}
void InitOnEntry()
{
var flag = (this.ReceivedEvent as Config).Flag;
var counter = SharedCounter.Create(this.Id.Runtime, 0);
var n = this.CreateMachine(typeof(N2), new E(counter));
int v1 = counter.CompareExchange(10, 0); // if 0 then 10
int v2 = counter.GetValue();
if (flag == 0)
{
this.Assert((v1 == 5 && v2 == 5) ||
(v1 == 0 && v2 == 10) ||
(v1 == 0 && v2 == 15));
}
else if (flag == 1)
{
this.Assert((v1 == 0 && v2 == 10) ||
(v1 == 0 && v2 == 15));
}
else if (flag == 2)
{
this.Assert((v1 == 5 && v2 == 5) ||
(v1 == 0 && v2 == 15));
}
else if (flag == 3)
{
this.Assert((v1 == 5 && v2 == 5) ||
(v1 == 0 && v2 == 10));
}
}
private void InitOnEntry(Event e)
{
var flag = (e as SetupEvent).Flag;
var counter = SharedCounter.Create(this.Id.Runtime, 0);
this.CreateActor(typeof(N2), new E(counter));
int v1 = counter.CompareExchange(10, 0); // if 0 then 10
int v2 = counter.GetValue();
if (flag is 0)
{
this.Assert((v1 == 5 && v2 == 5) || (v1 is 0 && v2 == 10) ||
(v1 is 0 && v2 == 15));
}
else if (flag is 1)
{
this.Assert((v1 is 0 && v2 == 10) || (v1 is 0 && v2 == 15),
"Reached test assertion.");
}
else if (flag is 2)
{
this.Assert((v1 == 5 && v2 == 5) || (v1 is 0 && v2 == 15),
"Reached test assertion.");
}
else if (flag is 3)
{
this.Assert((v1 == 5 && v2 == 5) || (v1 is 0 && v2 == 10),
"Reached test assertion.");
}
}
public void CorrelationSequenceIsIncremented()
{
var correlationSequenceNumbers = new List <int>();
var counter = new SharedCounter(1);
_activator1.Handle <string>(async(bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.Handle <string>(async(bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
await bus.Advanced.Routing.Send("bus3", "hej!");
});
_activator3.Handle <string>(async(bus, ctx, str) =>
{
correlationSequenceNumbers.Add(int.Parse(ctx.Headers[Headers.CorrelationSequence]));
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
Assert.That(correlationSequenceNumbers, Is.EqualTo(new[] { 0, 1, 2 }));
}
public async Task ItWorks()
{
var counter = new SharedCounter(20);
var activator = new BuiltinHandlerActivator();
Using(activator);
activator.Register(() => new SimpleSaga1(counter));
activator.Register(() => new SimpleSaga2(counter));
var network = new InMemNetwork();
var bus = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "enforce exclusive access buggg repro"))
.Options(o => { o.SetNumberOfWorkers(2); })
.Sagas(s =>
{
s.StoreInMemory();
s.EnforceExclusiveAccess();
})
.Routing(r => r.TypeBased().Map <StartSaga>("enforce exclusive access buggg repro"))
.Timeouts(t => t.StoreInMemory())
.Start();
for (int i = 0; i < 10; i++)
{
var id = Guid.NewGuid();
Console.WriteLine($"Sending message with id {id}");
await bus.Send(new StartSaga { SessionId = id });
}
counter.WaitForResetEvent();
}
public void SentMessageCarriesTheTypeHeader()
{
var activator = Using(new BuiltinHandlerActivator());
var receivedHeaders = new Dictionary <string, string>();
var counter = new SharedCounter(1);
activator.Handle <SomeMessage>(async(bus, context, message) =>
{
foreach (var kvp in context.Headers)
{
receivedHeaders.Add(kvp.Key, kvp.Value);
}
counter.Decrement();
});
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "type-header-test"))
.Options(o => o.LogPipeline())
.Start();
activator.Bus.SendLocal(new SomeMessage()).Wait();
counter.WaitForResetEvent();
Assert.That(receivedHeaders.ContainsKey(Headers.Type), Is.True);
Assert.That(receivedHeaders[Headers.Type], Is.EqualTo("Rebus.Tests.Integration.SomeMessage, Rebus.Tests"));
}
public void CreatesSnapshotOfSagaData()
{
var sharedCounter = new SharedCounter(3, "Message counter")
{
Delay = TimeSpan.FromSeconds(2)
};
Using(sharedCounter);
_activator.Register(() => new SomeSaga(sharedCounter, false));
_starter.Start();
Task.WaitAll(
_bus.SendLocal("hej/med dig"),
_bus.SendLocal("hej/igen"),
_bus.SendLocal("hej/igen med dig")
);
sharedCounter.WaitForResetEvent(timeoutSeconds: 10);
var allSnapshots = _factory.GetAllSnapshots().ToList();
Assert.That(allSnapshots.Count, Is.EqualTo(3));
Assert.That(allSnapshots.All(s => s.SagaData.Id == allSnapshots.First().SagaData.Id),
"Not all snapshots had the same saga ID!");
Assert.That(allSnapshots.OrderBy(s => s.SagaData.Revision).Select(s => s.SagaData.Revision), Is.EqualTo(new[] { 0, 1, 2 }),
"Expected the three initial revisions");
}
public void CorrelationIdFlows()
{
var correlationIds = new List <string>();
var counter = new SharedCounter(1);
_activator1.Handle <string>(async(bus, ctx, str) =>
{
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.Handle <string>(async(bus, ctx, str) =>
{
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
await bus.Advanced.Routing.Send("bus3", "hej!");
});
_activator3.Handle <string>(async(bus, ctx, str) =>
{
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
Assert.That(correlationIds.GroupBy(c => c).Count(), Is.EqualTo(1));
}
public async Task WorksAsExpected()
{
const int count = 5;
var props = new ConcurrentQueue <SagaProps>();
var sharedCounter = new SharedCounter(count);
_activator.Register(() => new MyExclusiveSaga(props, sharedCounter));
_busStarter.Start();
var bus = _activator.Bus;
count.Times(() => bus.Advanced.SyncBus.SendLocal(new Go("corr1")));
sharedCounter.WaitForResetEvent();
// see if we get any extra props
await Task.Delay(TimeSpan.FromSeconds(1));
var recordedProps = props.ToList();
Assert.That(recordedProps.Count, Is.EqualTo(count));
Assert.That(recordedProps.First().IsNew, Is.True);
Assert.That(recordedProps.Skip(1).All(p => p.IsNew), Is.False);
}
public async Task ItWorksWithCovarianceToo()
{
var counter = new SharedCounter(1);
Using(counter);
_activator.Handle<BaseMessage>(async baseMessage =>
{
throw new ApplicationException("1st level!!");
});
_activator.Handle<IFailed<BaseMessage>>(async failed =>
{
if (failed.Message is ConcreteMessage)
{
counter.Decrement();
return;
}
counter.Fail("Did not receive the expected message!");
});
await _bus.SendLocal(new ConcreteMessage());
counter.WaitForResetEvent();
}
public async Task NizzleName(int messageCount, bool useNewIndexScript, bool dropOldIndex)
{
if (useNewIndexScript)
{
SqlTestHelper.Execute(IndexCreationScriptToCheck);
SqlTestHelper.DropIndex(TableName, $"IDX_RECEIVE_{TableName}");
}
Console.WriteLine($"Sending {messageCount} messages...");
await Task.WhenAll(Enumerable.Range(0, messageCount)
.Select(i => _adapter.Bus.SendLocal($"THIS IS MESSAGE {i}")));
var counter = new SharedCounter(messageCount);
_adapter.Handle <string>(async message => counter.Decrement());
Console.WriteLine("Waiting for messages to be received...");
var stopwtach = Stopwatch.StartNew();
_adapter.Bus.Advanced.Workers.SetNumberOfWorkers(3);
counter.WaitForResetEvent(messageCount / 500 + 5);
var elapsedSeconds = stopwtach.Elapsed.TotalSeconds;
Console.WriteLine($"{messageCount} messages received in {elapsedSeconds:0.0} s - that's {messageCount / elapsedSeconds:0.0} msg/s");
}
public async Task IntegrationTest()
{
using var counter = new SharedCounter(initialValue: 3);
var typeNames = new ConcurrentDictionary <Type, string>();
using var activator = new BuiltinHandlerActivator();
activator.Handle <object>(async(_, context, message) =>
{
typeNames[message.GetType()] = context.Headers.GetValue(Headers.Type);
counter.Decrement();
});
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "whatever"))
.Serialization(s => s.UseCustomMessageTypeNames()
.AddWithCustomName <FirstMessage>("FourthMessage") //< confuse the enemy!
.AddWithShortName <SecondMessage>()
.AllowFallbackToDefaultConvention())
.Start();
await activator.Bus.SendLocal(new FirstMessage());
await activator.Bus.SendLocal(new SecondMessage());
await activator.Bus.SendLocal(new ThirdMessage());
counter.WaitForResetEvent();
Assert.That(typeNames[typeof(FirstMessage)], Is.EqualTo("FourthMessage"));
Assert.That(typeNames[typeof(SecondMessage)], Is.EqualTo("SecondMessage"));
Assert.That(typeNames[typeof(ThirdMessage)], Is.EqualTo(typeof(ThirdMessage).GetSimpleAssemblyQualifiedName()));
}
public void CanDeferTransportMessage()
{
var counter = new SharedCounter(1);
Using(counter);
var customHeaders = new Dictionary<string, string>
{
{"testheader", "customizzle valuizzle"}
};
var didDeferTheMessage = false;
_forwarderActivator.Handle<string>(async (bus, str) =>
{
if (!didDeferTheMessage)
{
Console.WriteLine("Got the message for the first time - deferring it!");
await bus.Advanced.TransportMessage.Defer(TimeSpan.FromSeconds(2), customHeaders);
didDeferTheMessage = true;
return;
}
Console.WriteLine("Got the message after it was deferred... nice!");
counter.Decrement();
});
_forwarderActivator.Bus.SendLocal("hej med dig min ven!!!").Wait();
counter.WaitForResetEvent();
}
public void CanForwardMessageToErrorQueue()
{
var sharedCounter = new SharedCounter(1) { Delay = TimeSpan.FromSeconds(0.1) };
Using(sharedCounter);
_forwarderActivator.Handle<string>(async (bus, str) =>
{
await bus.Advanced.TransportMessage.Forward(ForwardedMessagesQueue, new Dictionary<string, string> {{"testheader", "OK"}});
});
_receiverActivator.Handle<string>(async (bus, context, str) =>
{
var headers = context.TransportMessage.Headers;
if (!headers.ContainsKey("testheader"))
{
sharedCounter.Fail("Could not find 'testheader' header!");
return;
}
var headerValue = headers["testheader"];
if (headerValue != "OK")
{
sharedCounter.Fail("'testheader' header had value {0}", headerValue);
return;
}
sharedCounter.Decrement();
});
_forwarderActivator.Bus.SendLocal("hej med dig min ven!!!").Wait();
sharedCounter.WaitForResetEvent();
}
public async Task CheckTimes()
{
var counter = new SharedCounter(2);
_activator.Register(() => new LongStringSaga(counter));
_starter.Start();
var longString = string.Join("/", Enumerable.Repeat("long string", 100000));
Console.WriteLine($"Sending string with {longString.Length} characters...");
await _activator.Bus.SendLocal($"secret-id/{longString}");
Console.WriteLine("Sending short string...");
var stopwatch = Stopwatch.StartNew();
await _activator.Bus.SendLocal("secret-id/hej med dig min ven!");
counter.WaitForResetEvent(timeoutSeconds: 10);
var elapsed = stopwatch.Elapsed;
Console.WriteLine($"Elapsed s: {elapsed.TotalSeconds:0.0}");
}
public static async Task WhenAll()
{
var counter = new SharedCounter();
var source1 = new ValueTaskCompletionSource();
var source2 = new ValueTaskCompletionSource();
var source3 = new ValueTaskCompletionSource();
ThreadPool.QueueUserWorkItem(state =>
{
counter.Inc();
Thread.Sleep(100);
source1.Complete();
});
ThreadPool.QueueUserWorkItem(state =>
{
counter.Inc();
Thread.Sleep(200);
source2.Complete();
});
ThreadPool.QueueUserWorkItem(state =>
{
counter.Inc();
Thread.Sleep(150);
source3.Complete();
});
await ValueTaskSynchronization.WhenAll(source1.Task, source2.Task, source3.Task);
Equal(3, counter.Value);
}
public async Task ItWorks()
{
var activator = Using(new BuiltinHandlerActivator());
var messagesBySagaId = new ConcurrentDictionary <Guid, int>();
var counter = new SharedCounter(5);
activator.Register(() => new MySaga(messagesBySagaId, counter));
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "saga-property-nesting"))
.Sagas(s => s.StoreInMemory())
.Start();
await activator.Bus.SendLocal(new MyMsg("hej1"));
await activator.Bus.SendLocal(new MyMsg("hej1"));
await activator.Bus.SendLocal(new MyMsg("hej2"));
await activator.Bus.SendLocal(new MyMsg("hej2"));
await activator.Bus.SendLocal(new MyMsg("hej2"));
counter.WaitForResetEvent();
Console.WriteLine(string.Join(Environment.NewLine, messagesBySagaId));
Assert.That(messagesBySagaId.Count, Is.EqualTo(2));
Assert.That(messagesBySagaId.Count(kvp => kvp.Value == 2), Is.EqualTo(1));
Assert.That(messagesBySagaId.Count(kvp => kvp.Value == 3), Is.EqualTo(1));
}
public async Task ItWorks()
{
var counter = new SharedCounter(1);
Using(counter);
_activator.Handle<string>(async str =>
{
throw new ApplicationException("1st level!!");
});
_activator.Handle<Failed<string>>(async failed =>
{
if (failed.Message != "hej med dig!")
{
counter.Fail("Did not receive the expected message!");
return;
}
counter.Decrement();
});
await _bus.SendLocal("hej med dig!");
counter.WaitForResetEvent();
}
public void CanDeferTransportMessage()
{
var counter = new SharedCounter(1);
Using(counter);
var customHeaders = new Dictionary <string, string>
{
{ "testheader", "customizzle valuizzle" }
};
var didDeferTheMessage = false;
_forwarderActivator.AddHandlerWithBusTemporarilyStopped <string>(async(bus, str) =>
{
if (!didDeferTheMessage)
{
Console.WriteLine("Got the message for the first time - deferring it!");
await bus.Advanced.TransportMessage.Defer(TimeSpan.FromSeconds(2), customHeaders);
didDeferTheMessage = true;
return;
}
Console.WriteLine("Got the message after it was deferred... nice!");
counter.Decrement();
});
_forwarderActivator.Bus.SendLocal("hej med dig min ven!!!").Wait();
counter.WaitForResetEvent();
}
public async Task CanCorrelateWithHeadersOfIncomingMessagesByUsingContext()
{
var sagaDataCounters = new ConcurrentDictionary <Guid, int>();
var sharedCounter = new SharedCounter(5);
_activator.Register(() => new MySaga(sharedCounter, sagaDataCounters, true));
_busStarter.Start();
var bus = _activator.Bus;
var sameMessage = new MyMessage();
var headers1 = new Dictionary <string, string> {
{ "custom-correlation-id", "saga1" }
};
var headers2 = new Dictionary <string, string> {
{ "custom-correlation-id", "saga2" }
};
await bus.SendLocal(sameMessage, headers1);
await bus.SendLocal(sameMessage, headers2);
await bus.SendLocal(sameMessage, headers2);
await bus.SendLocal(sameMessage, headers1);
await bus.SendLocal(sameMessage, headers1);
sharedCounter.WaitForResetEvent(timeoutSeconds: 2);
}
public void CreatesSnapshotOfSagaDataAlsoWhenImmediatelyMarkingAsComplete()
{
var sharedCounter = new SharedCounter(3, "Message counter")
{
Delay = TimeSpan.FromSeconds(1)
};
Using(sharedCounter);
_activator.Register(() => new SomeSaga(sharedCounter, true));
_starter.Start();
Task.WaitAll(
_bus.SendLocal("hej/med dig"),
_bus.SendLocal("hej/igen"),
_bus.SendLocal("hej/igen med dig")
);
sharedCounter.WaitForResetEvent();
Thread.Sleep(500); //< be sure that the snapshot has made it to the database
var allSnapshots = _factory.GetAllSnapshots().ToList();
Assert.That(allSnapshots.Count, Is.EqualTo(3));
Assert.That(allSnapshots.All(s => s.SagaData.Revision == 0), "Not all revisions were initial!: {0}", allSnapshots.Select(s => s.SagaData.Revision));
Assert.That(allSnapshots.Select(s => s.SagaData.Id).Distinct().Count(), Is.EqualTo(3), "Expected three different saga IDs!");
}
public async Task CanInitiateSagaAndOverrideItsId()
{
var counter = new SharedCounter(5);
_activator.Register(() => new DefaultSaga(counter));
_busStarter.Start();
var id1 = Guid.NewGuid();
var id2 = Guid.NewGuid();
// five messages using 2 ids
await _activator.Bus.SendLocal(new DefaultSagaMessage(id1));
await _activator.Bus.SendLocal(new DefaultSagaMessage(id2));
await _activator.Bus.SendLocal(new DefaultSagaMessage(id1));
await _activator.Bus.SendLocal(new DefaultSagaMessage(id2));
await _activator.Bus.SendLocal(new DefaultSagaMessage(id1));
counter.WaitForResetEvent();
var sagaInstances = _sagas.Instances.ToList();
Assert.That(sagaInstances.Count, Is.EqualTo(2));
}
public void SentMessageCarriesTheTypeHeader()
{
var activator = Using(new BuiltinHandlerActivator());
var receivedHeaders = new Dictionary<string, string>();
var counter = new SharedCounter(1);
activator.Handle<SomeMessage>(async (bus, context, message) =>
{
foreach (var kvp in context.Headers)
{
receivedHeaders.Add(kvp.Key, kvp.Value);
}
counter.Decrement();
});
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "type-header-test"))
.Options(o => o.LogPipeline())
.Start();
activator.Bus.SendLocal(new SomeMessage()).Wait();
counter.WaitForResetEvent();
Assert.That(receivedHeaders.ContainsKey(Headers.Type), Is.True);
Assert.That(receivedHeaders[Headers.Type], Is.EqualTo("Rebus.Tests.Integration.SomeMessage, Rebus.Tests"));
}
public void WorksWithPrefetch(int prefetch, int numberOfMessages, int maxParallelism)
{
var activator = Using(new BuiltinHandlerActivator());
var counter = new SharedCounter(numberOfMessages);
Using(counter);
activator.Handle <string>(async str =>
{
counter.Decrement();
});
Console.WriteLine("Sending {0} messages", numberOfMessages);
var transport = GetTransport();
var tasks = Enumerable.Range(0, numberOfMessages)
.Select(i => $"THIS IS MESSAGE # {i}")
.Select(async msg =>
{
using (var scope = new RebusTransactionScope())
{
var headers = DefaultHeaders();
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(msg));
var transportMessage = new TransportMessage(headers, body);
await transport.Send(_queueName, transportMessage, scope.TransactionContext);
await scope.CompleteAsync();
}
})
.ToArray();
Task.WhenAll(tasks).Wait();
Console.WriteLine("Receiving {0} messages", numberOfMessages);
var stopwatch = Stopwatch.StartNew();
Configure.With(activator)
.Logging(l => l.Console(LogLevel.Info))
.Transport(t =>
{
t.UseAzureServiceBus(AsbTestConfig.ConnectionString, _queueName)
.EnablePrefetching(prefetch);
})
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(maxParallelism);
})
.Start();
counter.WaitForResetEvent(timeoutSeconds: (int)(numberOfMessages * 0.1 + 3));
var elapsedSeconds = stopwatch.Elapsed.TotalSeconds;
Console.WriteLine("Receiving {0} messages took {1:0.0} s - that's {2:0.0} msg/s",
numberOfMessages, elapsedSeconds, numberOfMessages / elapsedSeconds);
}
public void IncludesCorrelationIdInTheThreeLoggedLines()
{
// ${basedir}/logs/logfile.log
#if NETSTANDARD1_3
var logFilePath = Path.Combine(AppContext.BaseDirectory, "logs", "logfile.log");
#else
var logFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs", "logfile.log");
#endif
if (File.Exists(logFilePath))
{
File.Delete(logFilePath);
}
var activator = new BuiltinHandlerActivator();
Configure.With(Using(activator))
.Logging(l => l.NLog())
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "test"))
.Start();
var counter = new SharedCounter(1);
Using(counter);
var logger = LogManager.GetLogger("test");
activator.Handle <string>(async str =>
{
logger.Info("1");
await Task.Delay(100);
logger.Info("2");
await Task.Delay(100);
logger.Info("3");
counter.Decrement();
});
var headers = new Dictionary <string, string>
{
{ Headers.CorrelationId, "known-correlation-id" }
};
activator.Bus.SendLocal("hej med dig min ven!!!", headers).Wait();
counter.WaitForResetEvent();
WaitForFile(logFilePath);
var loggedLines = File.ReadAllLines(logFilePath);
AssertLineIsThere(loggedLines, "1|known-correlation-id");
AssertLineIsThere(loggedLines, "2|known-correlation-id");
AssertLineIsThere(loggedLines, "3|known-correlation-id");
}
public void CanCorrelateWithIncomingMessageWhichIsInherited()
{
var counter = new SharedCounter(1);
_activator.Register((bus, context) => new PolySaga(counter));
_activator.Bus.SendLocal(new ConcreteInitiatingMessage()).Wait();
counter.WaitForResetEvent(timeoutSeconds: 2);
}
private void InitOnEntry()
{
var counter = SharedCounter.Create(this.Id.Runtime, 0);
this.CreateActor(typeof(N1), new E(counter));
counter.Increment();
var v = counter.GetValue();
this.Assert(v is 1, "Reached test assertion.");
}
void EntryInit()
{
var counter = SharedCounter.Create(this.Id.Runtime, 0);
this.CreateMachine(typeof(N), new E(counter));
counter.Increment();
var v = counter.GetValue();
this.Assert(v == 1);
}
private void InitOnEntry(Event e)
{
this.Counter = (e as E).Counter;
this.Counter.Add(-4);
this.Counter.Decrement();
var v = this.Counter.Exchange(100);
this.Counter.Add(-5);
this.Counter.Add(v - 100);
}
public void DoesNotLogWarningsUnderNormalUse()
{
var counter = new SharedCounter(3);
_activator.Handle<string>(async str => counter.Decrement());
_activator.Bus.SendLocal("hej").Wait();
_activator.Bus.SendLocal("med").Wait();
_activator.Bus.SendLocal("dig").Wait();
counter.WaitForResetEvent();
CleanUpDisposables();
var logLinesWarnLevelOrAbove = _logs.Where(l => l.Level >= LogLevel.Warn).ToList();
Assert.That(logLinesWarnLevelOrAbove.Any(), Is.False, $@"Got the following log lines >= WARN:
{string.Join(Environment.NewLine, logLinesWarnLevelOrAbove)}");
}
public async Task FailedMessageAllowsForAccessingHeaders()
{
var counter = new SharedCounter(1);
_activator.Handle<string>(async str =>
{
throw new ApplicationException("1st level!!");
});
var headersOfFailedMessage = new Dictionary<string,string>();
_activator.Handle<Failed<string>>(async failed =>
{
if (failed.Message != "hej med dig!")
{
counter.Fail("Did not receive the expected message!");
return;
}
foreach (var kvp in failed.Headers)
{
headersOfFailedMessage.Add(kvp.Key, kvp.Value);
}
Console.WriteLine();
Console.WriteLine("----------------------------------------------------------------------------------------------------");
Console.WriteLine(failed.ErrorDescription);
Console.WriteLine("----------------------------------------------------------------------------------------------------");
Console.WriteLine();
counter.Decrement();
});
var headers = new Dictionary<string, string>
{
{"custom-header", "with-a-custom-value" }
};
await _bus.SendLocal("hej med dig!", headers);
counter.WaitForResetEvent();
Console.WriteLine(string.Join(Environment.NewLine , headersOfFailedMessage.Select(kvp => string.Format(" {0}: {1}", kvp.Key, kvp.Value))));
Assert.That(headersOfFailedMessage["custom-header"], Is.EqualTo("with-a-custom-value"));
}
public void MessageIdsAreDifferent()
{
var messageIds = new List<string>();
var counter = new SharedCounter(1);
_activator1.Handle<string>(async (bus, ctx, str) =>
{
messageIds.Add(ctx.Headers[Headers.MessageId]);
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.Handle<string>(async (bus, ctx, str) =>
{
messageIds.Add(ctx.Headers[Headers.MessageId]);
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
Assert.That(messageIds.GroupBy(i => i).Count(), Is.EqualTo(2));
}
public void CorrelationIdIsFirstMessageId()
{
var messageIds = new List<string>();
var correlationIds = new List<string>();
var counter = new SharedCounter(1);
_activator1.Handle<string>(async (bus, ctx, str) =>
{
messageIds.Add(ctx.Headers[Headers.MessageId]);
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
await bus.Advanced.Routing.Send("bus2", "hej!");
});
_activator2.Handle<string>(async (bus, ctx, str) =>
{
messageIds.Add(ctx.Headers[Headers.MessageId]);
correlationIds.Add(ctx.Headers[Headers.CorrelationId]);
counter.Decrement();
});
_activator1.Bus.SendLocal("heeeej!").Wait();
counter.WaitForResetEvent();
var firstMessageId = messageIds.First();
Assert.That(correlationIds.All(c => c == firstMessageId), Is.True);
}
async Task RunDeferTest()
{
var replyCounter = new SharedCounter(1);
_client.Handle<string>(async reply =>
{
Console.WriteLine($"CLIENT got reply '{reply}' (elapsed: {_stopwatch.Elapsed.TotalSeconds:0.# s})");
replyCounter.Decrement();
});
await _client.Bus.Send("request");
replyCounter.WaitForResetEvent();
}
