protected PluginSpec(Config config = null, string actorSystemName = null, ITestOutputHelper output = null)
: base(FromConfig(config), actorSystemName, output)
{
Extension = Persistence.Instance.Apply(Sys as ExtendedActorSystem);
Pid = "p-" + Counter.IncrementAndGet();
WriterGuid = Guid.NewGuid().ToString();
}
private static void Main(string[] args)
{
// var config = ConfigurationFactory.ParseString(@"
// akka.loglevel = DEBUG
// akka.actor.debug.lifecycle = off");
var config = ConfigurationFactory.ParseString(@"
akka.loglevel = DEBUG
akka.actor.debug.lifecycle = off
akka.actor.deployment
{
/router1
{
router = smallest-mailbox-pool
nr-of-instances = 3
}
}
");
// var config = ConfigurationFactory.ParseString(@"
// akka.loglevel = DEBUG
// akka.actor.debug.lifecycle = off
// akka.actor.deployment
// {
// /router1
// {
// router = smallest-mailbox-pool
// nr-of-instances = 3
// }
// }
//");
var actorSystem = ActorSystem.Create("routing-demo", config);
var counter = new AtomicCounter();
counter.IncrementAndGet();
var router =
actorSystem.ActorOf(
Props.Create(
() => new RouteeActor(() => counter.IncrementAndGet()))
.WithRouter(FromConfig.Instance), "router1");
// var router =
// actorSystem.ActorOf(
// Props.Create<RouteeActor>(
// () => new RouteeActor(() => counter.IncrementAndGet()))
// .WithRouter(FromConfig.Instance), "router1");
for (int i = 0; i < 10; i++)
{
router.Tell(i);
}
Console.ReadLine();
}
public void A_restart_with_backoff_source_should_stop_on_completion_if_it_should_only_be_restarted_in_failures()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var probe = RestartSource.OnFailuresWithBackoff(() =>
{
created.IncrementAndGet();
var enumerable = new List <string> {
"a", "b", "c"
}.Select(c =>
{
switch (c)
{
case "c": return(created.Current == 1 ? throw new ArgumentException("failed") : "c");
default: return(c);
}
});
return(Source.From(enumerable));
}, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(20), 0).RunWith(this.SinkProbe <string>(), Materializer);
probe.RequestNext("a");
probe.RequestNext("b");
// will fail, and will restart
probe.RequestNext("a");
probe.RequestNext("b");
probe.RequestNext("c");
created.Current.Should().Be(2);
probe.Cancel();
}, Materializer);
}
private (AtomicCounter, TestPublisher.Probe <string>, TestSubscriber.Probe <string>, TestPublisher.Probe <string>, TestSubscriber.Probe <string>) SetupFlow(
TimeSpan minBackoff,
TimeSpan maxBackoff,
int maxRestarts = -1,
bool onlyOnFailures = false)
{
var created = new AtomicCounter(0);
var probe1 = this.SourceProbe <string>().ToMaterialized(this.SinkProbe <string>(), Keep.Both).Run(Materializer);
var flowInSource = probe1.Item1;
var flowInProbe = probe1.Item2;
var probe2 = this.SourceProbe <string>().ToMaterialized(BroadcastHub.Sink <string>(), Keep.Both).Run(Materializer);
var flowOutProbe = probe2.Item1;
var flowOutSource = probe2.Item2;
// We can't just use ordinary probes here because we're expecting them to get started/restarted. Instead, we
// simply use the probes as a message bus for feeding and capturing events.
var probe3 = this.SourceProbe <string>().ViaMaterialized(RestartFlowFactory(() =>
{
created.IncrementAndGet();
var snk = Flow.Create <string>()
.TakeWhile(s => s != "cancel")
.To(Sink.ForEach <string>(c => flowInSource.SendNext(c))
.MapMaterializedValue(task => task.ContinueWith(
t1 =>
{
if (t1.IsFaulted || t1.IsCanceled)
{
flowInSource.SendNext("in error");
}
else
{
flowInSource.SendNext("in complete");
}
})));
var src = flowOutSource.TakeWhile(s => s != "complete").Select(c =>
{
if (c == "error")
{
throw new ArgumentException("failed");
}
return(c);
}).WatchTermination((s1, task) =>
{
task.ContinueWith(_ =>
{
flowInSource.SendNext("out complete");
return(NotUsed.Instance);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
return(s1);
});
return(Flow.FromSinkAndSource(snk, src));
}, onlyOnFailures, RestartSettings.Create(minBackoff, maxBackoff, 0).WithMaxRestarts(maxRestarts, minBackoff)), Keep.Left)
.ToMaterialized(this.SinkProbe <string>(), Keep.Both).Run(Materializer);
var source = probe3.Item1;
var sink = probe3.Item2;
return(created, source, flowInProbe, flowOutProbe, sink);
}
public void A_restart_with_backoff_sink_should_not_restart_the_sink_when_maxRestarts_is_reached()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var(queue, sinkProbe) = this.SourceProbe <string>().ToMaterialized(this.SinkProbe <string>(), Keep.Both).Run(Materializer);
var probe = this.SourceProbe <string>()
.ToMaterialized(RestartSink.WithBackoff(() =>
{
created.IncrementAndGet();
return(Flow.Create <string>().TakeWhile(c => c != "cancel", inclusive: true).To(Sink.ForEach <string>(c => queue.SendNext(c))));
}, _shortRestartSettings.WithMaxRestarts(1, _shortMinBackoff)), Keep.Left)
.Run(Materializer);
probe.SendNext("cancel");
sinkProbe.RequestNext("cancel");
probe.SendNext("cancel");
sinkProbe.RequestNext("cancel");
probe.ExpectCancellation();
created.Current.Should().Be(2);
sinkProbe.Cancel();
probe.SendComplete();
}, Materializer);
}
public void A_restart_with_backoff_source_should_allow_using_withMaxRestarts_instead_of_minBackoff_to_determine_the_maxRestarts_reset_time()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var probe = RestartSource.WithBackoff(() =>
{
created.IncrementAndGet();
return(Source.From(new List <string> {
"a", "b"
}).TakeWhile(c => c != "b"));
}, _shortRestartSettings.WithMaxRestarts(2, TimeSpan.FromSeconds(1)))
.RunWith(this.SinkProbe <string>(), Materializer);
probe.RequestNext("a");
probe.RequestNext("a");
Thread.Sleep(_shortMinBackoff + TimeSpan.FromTicks(_shortMinBackoff.Ticks * 2) + _shortMinBackoff); // if using shortMinBackoff as deadline cause reset
probe.RequestNext("a");
probe.Request(1);
probe.ExpectComplete();
created.Current.Should().Be(3);
probe.Cancel();
}, Materializer);
}
public BatchingSqliteJournalSpec(ITestOutputHelper output)
: base(CreateSpecConfig($"Datasource=memdb-journal-batch-{counter.IncrementAndGet()}.db;Mode=Memory;Cache=Shared"), "BatchingSqliteJournalSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
public static Config CreatePersistenceConfig(bool rememberEntities = false)
{
var connectionString =
"Filename=file:memdb-journal-" + DbId.IncrementAndGet() + ".db;Mode=Memory;Cache=Shared";
var config = $@"
akka.actor.provider = cluster
akka.remote.dot-netty.tcp.port = 0
akka.cluster.sharding.state-store-mode=persistence
akka.cluster.sharding.remember-entities = {BoolToToggle(rememberEntities)}
akka.persistence.journal.plugin = ""akka.persistence.journal.sqlite""
akka.persistence.journal.sqlite {{
class = ""Akka.Persistence.Sqlite.Journal.SqliteJournal, Akka.Persistence.Sqlite""
auto-initialize = on
connection-string = ""{connectionString}""
}}
akka.persistence.snapshot-store {{
plugin = ""akka.persistence.snapshot-store.sqlite""
sqlite {{
class = ""Akka.Persistence.Sqlite.Snapshot.SqliteSnapshotStore, Akka.Persistence.Sqlite""
auto-initialize = on
connection-string = ""{connectionString}""
}}
}}";
return(config);
}
public void A_restart_with_backoff_source_should_reset_maxRestarts_when_source_runs_for_at_least_minimum_backoff_without_completing()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var probe = RestartSource.WithBackoff(() =>
{
created.IncrementAndGet();
return(Source.Single("a"));
}, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), 0, maxRestarts: 2).RunWith(this.SinkProbe <string>(), Materializer);
probe.RequestNext("a");
// There should be minBackoff delay
probe.RequestNext("a");
// The probe should now be backing off again with with increased backoff
// Now wait for the delay to pass, then it will start the new source, we also want to wait for the
// subsequent backoff to pass
const int minBackoff = 1000;
Thread.Sleep((minBackoff + (minBackoff * 2) + minBackoff + 500));
probe.RequestNext("a");
// We now are able to trigger the third restart, since enough time has elapsed to reset the counter
probe.RequestNext("a");
created.Current.Should().Be(4);
probe.Cancel();
}, Materializer);
}
public void A_restart_with_backoff_source_should_restart_on_failure()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var probe = RestartSource.WithBackoff(() =>
{
created.IncrementAndGet();
var enumerable = new List <string> {
"a", "b", "c"
}.Select(c =>
{
if (c == "c")
{
throw new ArgumentException("failed");
}
return(c);
});
return(Source.From(enumerable));
}, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(20), 0).RunWith(this.SinkProbe <string>(), Materializer);
probe.RequestNext("a");
probe.RequestNext("b");
probe.RequestNext("a");
probe.RequestNext("b");
probe.RequestNext("a");
created.Current.Should().Be(3);
probe.Cancel();
}, Materializer);
}
protected override bool ReceiveCommand(object message)
{
if (!CommonBehavior(message))
{
var cmd = message as Cmd;
if (cmd != null)
{
Sender.Tell(cmd.Data);
var @event = new Evt(cmd.Data);
PersistAsync(@event, evt =>
{
Thread.Sleep(300);
Sender.Tell(evt.Data.ToString() + "-a-" + _sendMessageCounter.IncrementAndGet());
});
PersistAsync(@event, evt => Sender.Tell(evt.Data.ToString() + "-b-" + _sendMessageCounter.IncrementAndGet()));
return(true);
}
}
else
{
return(true);
}
return(false);
}
public void A_restart_with_backoff_sink_should_backoff_before_restart()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var tuple = this.SourceProbe <string>().ToMaterialized(this.SinkProbe <string>(), Keep.Both).Run(Materializer);
var queue = tuple.Item1;
var sinkProbe = tuple.Item2;
var probe = this.SourceProbe <string>().ToMaterialized(RestartSink.WithBackoff(() =>
{
created.IncrementAndGet();
return(Flow.Create <string>().TakeWhile(c => c != "cancel", inclusive: true)
.To(Sink.ForEach <string>(c => queue.SendNext(c))));
}, TimeSpan.FromMilliseconds(200), TimeSpan.FromSeconds(2), 0), Keep.Left).Run(Materializer);
probe.SendNext("a");
sinkProbe.RequestNext("a");
probe.SendNext("cancel");
sinkProbe.RequestNext("cancel");
probe.SendNext("b");
sinkProbe.Request(1);
var deadline = TimeSpan.FromMilliseconds(100).FromNow();
sinkProbe.ExpectNext(TimeSpan.FromMilliseconds(300), "b");
deadline.IsOverdue.Should().BeTrue();
created.Current.Should().Be(2);
sinkProbe.Cancel();
probe.SendComplete();
}, Materializer);
}
public void A_restart_with_backoff_sink_should_run_normally()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var tcs = new TaskCompletionSource <IEnumerable <string> >();
var probe = this.SourceProbe <string>().ToMaterialized(RestartSink.WithBackoff(() =>
{
created.IncrementAndGet();
return(Sink.Seq <string>().MapMaterializedValue(task =>
{
task.ContinueWith(c => tcs.SetResult(c.Result));
return Done.Instance;
}));
}, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(20), 0), Keep.Left).Run(Materializer);
probe.SendNext("a");
probe.SendNext("b");
probe.SendNext("c");
probe.SendComplete();
tcs.Task.Result.Should().ContainInOrder("a", "b", "c");
created.Current.Should().Be(1);
}, Materializer);
}
public void A_restart_with_backoff_sink_should_not_restart_the_sink_when_completed_while_backing_off()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var tuple = this.SourceProbe <string>().ToMaterialized(this.SinkProbe <string>(), Keep.Both).Run(Materializer);
var queue = tuple.Item1;
var sinkProbe = tuple.Item2;
var probe = this.SourceProbe <string>().ToMaterialized(RestartSink.WithBackoff(() =>
{
created.IncrementAndGet();
return(Flow.Create <string>().TakeWhile(c => c != "cancel", inclusive: true)
.To(Sink.ForEach <string>(c => queue.SendNext(c))));
}, TimeSpan.FromMilliseconds(200), TimeSpan.FromSeconds(2), 0), Keep.Left).Run(Materializer);
probe.SendNext("a");
sinkProbe.RequestNext("a");
probe.SendNext("cancel");
sinkProbe.RequestNext("cancel");
// Should be backing off now
probe.SendComplete();
// Wait to ensure it isn't restarted
Thread.Sleep(300);
created.Current.Should().Be(1);
sinkProbe.Cancel();
}, Materializer);
}
public void A_restart_with_backoff_source_should_cancel_the_currently_running_source_when_cancelled()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var tcs = new TaskCompletionSource <Done>();
var probe = RestartSource.WithBackoff(() =>
{
created.IncrementAndGet();
return(Source.From(new List <string> {
"a", "b"
})
.WatchTermination((source, _) =>
{
tcs.SetResult(Done.Instance);
return source;
}));
}, TimeSpan.FromMilliseconds(10), TimeSpan.FromSeconds(2), 0).RunWith(this.SinkProbe <string>(), Materializer);
probe.RequestNext("a");
probe.Cancel();
tcs.Task.Result.Should().BeSameAs(Done.Instance);
// Wait to ensure it isn't restarted
Thread.Sleep(200);
created.Current.Should().Be(1);
}, Materializer);
}
public Logic(ProducerStage <TKey, TValue, TPass> self) : base(self.Shape)
{
this.self = self;
this.producer = self.producerProvider();
SetHandler(self.Out, onPull: () => TryPull(self.In));
SetHandler(self.In, onPush: () =>
{
var msg = Grab(self.In);
var result = SendToProducer(msg);
awaitingConfirmation.IncrementAndGet();
Push(self.Out, result);
},
onUpstreamFinish: () =>
{
inputIsClosed = true;
completionState.SetResult(NotUsed.Instance);
CheckForCompletion();
},
onUpstreamFailure: cause =>
{
inputIsClosed = true;
completionState.SetException(cause);
CheckForCompletion();
});
}
public void A_UnfoldResourceSource_must_not_close_the_resource_twice_when_read_fails_and_then_close_fails()
{
var closedCounter = new AtomicCounter(0);
var testException = new TestException("boom");
var probe = Source.UnfoldResource <int, int>(
() => 23, // the best resource there is
_ => throw new TestException("failing read"),
_ =>
{
closedCounter.IncrementAndGet();
if (closedCounter.Current == 1)
{
throw testException;
}
}
).RunWith(this.SinkProbe <int>(), Materializer);
EventFilter.Exception <TestException>().Expect(1, () =>
{
probe.Request(1);
probe.ExpectError().Should().Be(testException);
});
closedCounter.Current.Should().Be(1);
}
/// <summary>
/// Add an entry to the cache. Overrides existing entry.
/// </summary>
public void Add(KeyValuePair <TKey, TVal> entry)
{
var i = _n.IncrementAndGet();
_elements[i & _mask] = entry;
_lastUsed = DateTime.UtcNow;
}
internal override Routee NewRoutee(Props routeeProps, IActorContext context)
{
var name = "c" + _childNameCounter.IncrementAndGet();
var actorRef = ((ActorCell)context).AttachChild(Local.EnrichWithPoolDispatcher(routeeProps, context), false, name);
return(new ActorRefRoutee(actorRef));
}
public BatchingSqliteJournalSpec(ITestOutputHelper output)
: base(CreateSpecConfig("FullUri=file:memdb-journal-" + counter.IncrementAndGet() + ".db?mode=memory&cache=shared;"), "BatchingSqliteJournalSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
public SqliteJournalSpec(ITestOutputHelper output)
: base(CreateSpecConfig("Filename=file:memdb-journal-" + counter.IncrementAndGet() + ".db;Mode=Memory;Cache=Shared"), "SqliteJournalSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
public void A_restart_with_backoff_source_should_backoff_before_restart()
{
this.AssertAllStagesStopped(() =>
{
var created = new AtomicCounter(0);
var probe = RestartSource.WithBackoff(() =>
{
created.IncrementAndGet();
return(Source.From(new List <string> {
"a", "b"
}));
}, TimeSpan.FromMilliseconds(200), TimeSpan.FromMilliseconds(1000), 0).RunWith(this.SinkProbe <string>(), Materializer);
probe.RequestNext("a");
probe.RequestNext("b");
probe.Request(1);
// There should be a delay of at least 200ms before we receive the element, wait for 100ms.
var deadline = TimeSpan.FromMilliseconds(100).FromNow();
// But the delay shouldn't be more than 300ms.
probe.ExpectNext(TimeSpan.FromMilliseconds(300), "a");
deadline.IsOverdue.Should().Be(true);
created.Current.Should().Be(2);
probe.Cancel();
}, Materializer);
}
public SqliteSnapshotStoreSpec(ITestOutputHelper output)
: base(CreateSpecConfig("FullUri=file:memdb-snapshot-" + counter.IncrementAndGet() + ".db?mode=memory&cache=shared;"), "SqliteSnapshotStoreSpec", output)
{
SqlitePersistence.Get(Sys);
Initialize();
}
public void When_CancelFalse_is_called_Then_first_exception_should_not_prevent_rest_from_being_called()
{
var c = new Cancelable(Sys.Scheduler);
var callbacks = new AtomicCounter(0);
c.Token.Register(() => { throw new Exception("Something wonderful has happened."); });
c.Token.Register(() => callbacks.IncrementAndGet());
c.Token.Register(() => { throw new Exception("Your AKKA is alive!!!"); });
try
{
//First callback should prevent the second one from being called
c.Cancel(throwOnFirstException: false);
}
catch (AggregateException aggregateException)
{
aggregateException = aggregateException.Flatten();
foreach (var e in aggregateException.InnerExceptions)
{
if (!e.Message.StartsWith("Your") && !e.Message.StartsWith("Something"))
throw new Exception("Invalid exception received: " + e, e);
}
}
//HACK: Using the fact that when Cancel is called, callbacks are executed synchronously
callbacks.Current.ShouldBe(1);
c.IsCancellationRequested.ShouldBeTrue();
c.Token.IsCancellationRequested.ShouldBeTrue();
}
protected DiResolverSpec(Config config = null, string actorSystemName = null, string testActorName = null)
: base(new XunitAssertions(), config, actorSystemName, testActorName)
{
_pid = "p-" + Counter.IncrementAndGet();
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
var resolver = ConfigureDependencyResolver(Sys);
}
private TestKitBase(TestKitAssertions assertions, ActorSystem system, Config config, string actorSystemName = null)
{
if (assertions == null)
{
throw new ArgumentNullException("assertions");
}
if (system == null)
{
var configWithDefaultFallback = config.SafeWithFallback(_defaultConfig);
system = ActorSystem.Create(actorSystemName ?? "test", configWithDefaultFallback);
}
_assertions = assertions;
_system = system;
system.RegisterExtension(new TestKitExtension());
system.RegisterExtension(new TestKitAssertionsExtension(assertions));
_testKitSettings = TestKitExtension.For(_system);
_queue = new BlockingQueue <MessageEnvelope>();
_log = Logging.GetLogger(system, GetType());
var testActor = CreateTestActor(system, "testActor" + _testActorId.IncrementAndGet());
_testActor = testActor;
//Wait for the testactor to start
AwaitCondition(() =>
{
var repRef = _testActor as RepointableRef;
return(repRef == null || repRef.IsStarted);
}, TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(10));
}
public void When_CancelFalse_is_called_Then_first_exception_should_not_prevent_rest_from_being_called()
{
var c = new Cancelable(Sys.Scheduler);
var callbacks = new AtomicCounter(0);
c.Token.Register(() => { throw new Exception("Something wonderful has happened."); });
c.Token.Register(() => callbacks.IncrementAndGet());
c.Token.Register(() => { throw new Exception("Your AKKA is alive!!!"); });
try
{
//First callback should prevent the second one from being called
c.Cancel(throwOnFirstException: false);
}
catch (AggregateException aggregateException)
{
aggregateException = aggregateException.Flatten();
foreach (var e in aggregateException.InnerExceptions)
{
if (!e.Message.StartsWith("Your") && !e.Message.StartsWith("Something"))
{
throw new Exception("Invalid exception received: " + e, e);
}
}
}
//HACK: Using the fact that when Cancel is called, callbacks are executed synchronously
callbacks.Current.ShouldBe(1);
c.IsCancellationRequested.ShouldBeTrue();
c.Token.IsCancellationRequested.ShouldBeTrue();
}
public Bug25FixSpec(ITestOutputHelper helper, DatabaseFixture fixture)
: base(CreateSpecConfig(fixture, Counter.Current), output: helper)
{
_connectionString = new MongoUrl(fixture.ConnectionString + Counter.Current);
Counter.IncrementAndGet();
_output = helper;
_database = new Lazy <IMongoDatabase>(() =>
new MongoClient(_connectionString)
.GetDatabase(_connectionString.DatabaseName));
}
/// <summary>
/// Initializes the <see cref="TestState"/> for a new spec.
/// </summary>
/// <param name="system">The actor system this test will use. Can be null.</param>
/// <param name="config">The configuration that <paramref name="system"/> will use if it's null.</param>
/// <param name="actorSystemName">The name that <paramref name="system"/> will use if it's null.</param>
/// <param name="testActorName">The name of the test actor. Can be null.</param>
protected void InitializeTest(ActorSystem system, Config config, string actorSystemName, string testActorName)
{
_testState = new TestState();
if (system == null)
{
var configWithDefaultFallback = config.SafeWithFallback(_defaultConfig);
system = ActorSystem.Create(actorSystemName ?? "test", configWithDefaultFallback);
}
_testState.System = system;
system.RegisterExtension(new TestKitExtension());
system.RegisterExtension(new TestKitAssertionsExtension(_assertions));
_testState.TestKitSettings = TestKitExtension.For(_testState.System);
_testState.Queue = new BlockingQueue <MessageEnvelope>();
_testState.Log = Logging.GetLogger(system, GetType());
_testState.EventFilterFactory = new EventFilterFactory(this);
//register the CallingThreadDispatcherConfigurator
_testState.System.Dispatchers.RegisterConfigurator(CallingThreadDispatcher.Id,
new CallingThreadDispatcherConfigurator(_testState.System.Settings.Config, _testState.System.Dispatchers.Prerequisites));
if (string.IsNullOrEmpty(testActorName))
{
testActorName = "testActor" + _testActorId.IncrementAndGet();
}
var testActor = CreateTestActor(system, testActorName);
//Wait for the testactor to start
// Calling sync version here, since .Wait() causes deadlock
AwaitCondition(() =>
{
var repRef = testActor as IRepointableRef;
return(repRef == null || repRef.IsStarted);
}, TimeSpan.FromSeconds(5), TimeSpan.FromMilliseconds(10));
if (!(this is INoImplicitSender))
{
InternalCurrentActorCellKeeper.Current = (ActorCell)((ActorRefWithCell)testActor).Underlying;
}
else if (!(this is TestProbe))
//HACK: we need to clear the current context when running a No Implicit Sender test as sender from an async test may leak
//but we should not clear the current context when creating a testprobe from a test
{
InternalCurrentActorCellKeeper.Current = null;
}
SynchronizationContext.SetSynchronizationContext(
new ActorCellKeepingSynchronizationContext(InternalCurrentActorCellKeeper.Current));
_testState.TestActor = testActor;
}
public void Setup(BenchmarkContext context)
{
_opsCounter = context.GetCounter(MsgRcvCounter);
_actorSystem = ActorSystem.Create("SpecActor" + ActorSystemId.IncrementAndGet(), Config);
_dedup = _actorSystem.ActorOf(Props.Create(() => new TestDeDuplicatingActor()), "deduper");
// need to do a warm-up (ensures the actor is fully initialized before test begins)
context.Trace.Debug("START: Warming up DeDuplicatingActor");
_dedup.Ask <ActorIdentity>(new Identify(null)).Wait();
context.Trace.Debug("FINISH: Warming up DeDuplicatingActor");
}
public void Given_a_canceled_Cancelable_with_callback_Then_Cancel_should_be_possible_to_call_again_but_callbacks_should_not_be_called_again()
{
var c = new Cancelable(Sys.Scheduler);
var callbacks = new AtomicCounter(0);
c.Token.Register(() => callbacks.IncrementAndGet());
c.Cancel();
c.Cancel();
//HACK: Using the fact that when Cancel is called, callbacks are executed synchronously
callbacks.Current.ShouldBe(1);
}
public static Config JournalConfig(string connectionString)
{
TableName = "TestTable" + TableVersionCounter.IncrementAndGet();
return(ConfigurationFactory.ParseString(
@"akka.loglevel = DEBUG
akka.persistence.journal.plugin = ""akka.persistence.journal.azure-table""
akka.persistence.journal.azure-table.connection-string=""" + connectionString + @"""
akka.persistence.journal.azure-table.verbose-logging = on
akka.test.single-expect-default = 3s")
.WithFallback("akka.persistence.journal.azure-table.table-name=" + TableName));
}
public void Given_a_canceled_Cancelable_with_callback_Then_Cancel_should_be_possible_to_call_again_but_callbacks_should_not_be_called_again()
{
var c = new Cancelable(Sys.Scheduler);
var callbacks = new AtomicCounter(0);
c.Token.Register(() => callbacks.IncrementAndGet());
c.Cancel();
c.Cancel();
//HACK: Using the fact that when Cancel is called, callbacks are executed synchronously
callbacks.Current.ShouldBe(1);
}
public void A_supervisor_hierarchy_must_handle_failure_in_creation_when_supervision_strategy_returns_Resume_and_Restart()
{
var createAttempt = new AtomicCounter(0);
var preStartCalled = new AtomicCounter(0);
var postRestartCalled = new AtomicCounter(0);
EventFilter.Exception<Failure>()
.And.Exception<InvalidOperationException>("OH NO!")
.And.Error(start: "changing Recreate into Create")
.And.Error(start: "changing Resume into Create")
.Mute(() =>
{
//Create:
// failresumer
// |
// failingChild
// | (sometimes)
// workingChild
var failresumer = ActorOf((resumerDsl, context) =>
{
resumerDsl.Strategy = new OneForOneStrategy(ex => ex is ActorInitializationException ? (createAttempt.Current % 2 == 0 ? Directive.Resume : Directive.Restart) : Directive.Escalate);
var failingChild = context.ActorOf((childDsl, childContext) =>
{
var ca = createAttempt.IncrementAndGet();
if (ca <= 6 && ca % 3 == 0)
childContext.ActorOf(BlackHoleActor.Props, "workingChild" + ca);
if (ca < 6)
throw new InvalidOperationException("OH NO!");
childDsl.OnPreStart = _ => preStartCalled.IncrementAndGet();
childDsl.OnPostRestart = (e, _) => postRestartCalled.IncrementAndGet();
childDsl.ReceiveAny((m, actorContext) => actorContext.Sender.Tell(m));
}, "failingChild");
resumerDsl.ReceiveAny((m, _) => failingChild.Forward(m));
}, "failresumer");
//Send failresumer some meatballs. This message will be forwarded to failingChild
failresumer.Tell("Köttbullar");
ExpectMsg("Köttbullar");
});
createAttempt.Current.ShouldBe(6);
preStartCalled.Current.ShouldBe(1);
postRestartCalled.Current.ShouldBe(0);
}
public void A_Flow_with_SelectAsyncUnordered_must_not_run_more_futures_than_configured()
{
this.AssertAllStagesStopped(() =>
{
const int parallelism = 8;
var counter = new AtomicCounter();
var queue = new BlockingQueue<Tuple<TaskCompletionSource<int>, long>>();
var timer = new Thread(() =>
{
var delay = 500; // 50000 nanoseconds
var count = 0;
var cont = true;
while (cont)
{
try
{
var t = queue.Take(CancellationToken.None);
var promise = t.Item1;
var enqueued = t.Item2;
var wakeup = enqueued + delay;
while (DateTime.Now.Ticks < wakeup) { }
counter.Decrement();
promise.SetResult(count);
count++;
}
catch
{
cont = false;
}
}
});
timer.Start();
Func<Task<int>> deferred = () =>
{
var promise = new TaskCompletionSource<int>();
if (counter.IncrementAndGet() > parallelism)
promise.SetException(new Exception("parallelism exceeded"));
else
queue.Enqueue(Tuple.Create(promise, DateTime.Now.Ticks));
return promise.Task;
};
try
{
const int n = 10000;
var task = Source.From(Enumerable.Range(1, n))
.SelectAsyncUnordered(parallelism, _ => deferred())
.RunAggregate(0, (c, _) => c + 1, Materializer);
task.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
task.Result.Should().Be(n);
}
finally
{
timer.Interrupt();
}
}, Materializer);
}