protected PersistenceSpec(string config)
: base(config)
{
_name = NamePrefix + "-" + _counter.GetAndIncrement();
Clean = new Cleanup(this);
Clean.Initialize();
}
/// <summary>
/// Performs all of the initialization to get the PCF metrics forwarding engine up and running.
/// </summary>
/// <param name="settings">The options and settings needed to communicate with PCF.</param>
/// <param name="system">Optional. An <see cref="ActorSystem" /> used to spawn the underlying actors needed to do the job.</param>
/// <returns>A new <see cref="PcfMetricRecorder" /> instance.</returns>
public static PcfMetricRecorder Create(PcfMetricForwarderSettings settings, ActorSystem system = null)
{
var weOwnActorSystem = false;
if (system == null) // create our own ActorSystem if it doesn't already exist.
{
weOwnActorSystem = true;
system = ActorSystem.Create("pbpcfmetrics",
settings.DebugLogging ? DebugHocon : NormalHocon);
}
// spawn as a System actor, so in the event of being in a non-owned system our traces get shut down
// only after all of the user-defined actors have terminated.
var reporterActor = system.AsInstanceOf <ExtendedActorSystem>().SystemActorOf(
Props.Create(() => new MetricsReporterActor(settings)),
$"pcf-reporter-{NameCounter.GetAndIncrement()}");
var counterActor = system.AsInstanceOf <ExtendedActorSystem>().SystemActorOf(
Props.Create(() =>
new CounterAggregator(reporterActor, settings.TimeProvider ?? new DateTimeOffsetTimeProvider())),
$"pcf-reporter-{NameCounter.GetAndIncrement()}");
return(new PcfMetricRecorder(reporterActor, counterActor, weOwnActorSystem ? system : null));
}
public void SharedFiber_shutdown_should_not_disrupt_original_Fiber()
{
var atomicCounter = new AtomicCounter(0);
var originalFiber = FiberFactory.CreateFiber(2); //going to use a dedicated thread Fiber
var sharedFiber1 = new SharedFiber(originalFiber);
var sharedFiber2 = sharedFiber1.Clone();
for (var i = 0; i < 1000; i++)
{
originalFiber.Add(() => atomicCounter.GetAndIncrement());
sharedFiber1.Add(() => atomicCounter.GetAndIncrement());
}
sharedFiber1.GracefulShutdown(TimeSpan.FromSeconds(1)).Wait(); //wait for the fiber to finish
Assert.AreEqual(2000, atomicCounter.Current); //should have a total count of 2000
for (var i = 0; i < 1000; i++)
{
originalFiber.Add(() => atomicCounter.GetAndIncrement());
sharedFiber1.Add(() => atomicCounter.GetAndIncrement());
}
Thread.Sleep(TimeSpan.FromSeconds(1));
Assert.AreEqual(3000, atomicCounter.Current); //should have a total count of 3000
Assert.IsTrue(sharedFiber2.Running);
Assert.IsTrue(originalFiber.Running);
Assert.IsFalse(sharedFiber1.Running);
}
protected PersistenceSpec(string config, ITestOutputHelper output = null)
: base(config, output)
{
_name = NamePrefix + "-" + _counter.GetAndIncrement();
Clean = new Cleanup(this);
Clean.Initialize();
}
private void Main_Load(object sender, EventArgs e)
{
_chartActor = Program.ChartActors.ActorOf(Props.Create(() => new ChartingActor(sysChart)), "charting");
var series = ChartDataHelper.RandomSeries("FakeSeries" + _seriesCounter.GetAndIncrement());
_chartActor.Tell(new ChartingActor.InitializeChart(new Dictionary <string, Series>()
{
{ series.Name, series }
}));
}
public FailAfterSuccess(TestLatch latch, AtomicCounter counter)
{
StartWith(
AllSucceed(
AnySucceed(
After(
Execute(_ => counter.GetAndIncrement()),
Fail()),
Execute(_ => counter.GetAndIncrement())),
Execute(_ => latch.CountDown())), null);
}
public SuccessAfterFailure(TestLatch latch, AtomicCounter counter)
{
StartWith(
AllSucceed(
AllComplete(
After(
AllSucceed(
Execute(_ => counter.GetAndIncrement()),
Fail()),
Not(Fail())),
Execute(_ => counter.GetAndIncrement())),
Execute(_ => latch.CountDown())), null);
}
public void Should_be_able_to_change_NetworkEventLoop_error_handler_at_runtime()
{
var eventLoop = EventLoopFactory.CreateNetworkEventLoop();
var count = new AtomicCounter(0);
var trappedException = false;
var backgroundProducer = Task.Run(() =>
{
for (var i = 0; i < 10; i++)
{
eventLoop.Execute(() => count.GetAndIncrement());
Thread.Sleep(10);
}
});
eventLoop.SetExceptionHandler((connection, exception) => trappedException = true, null);
eventLoop.Execute(() =>
{
throw new Exception("I'm an exception!");
});
backgroundProducer.Wait();
Assert.AreEqual(10, count.Current);
Assert.IsTrue(trappedException);
}
public override Routee NewRoutee(Props routeeProps, IActorContext context)
{
var name = "c" + _childNameCounter.GetAndIncrement();
var actorRef = context.ActorOf(EnrichWithPoolDispatcher(routeeProps, context), name);
return(new ActorRefRoutee(actorRef));
}
private void btnAddSeries_Click(object sender, EventArgs e)
{
var series = ChartDataHelper.RandomSeries($"Fake Series {_seriesCounter.GetAndIncrement()}");
var message = new AddSeriesMessage(series);
_chartActor.Tell(message);
}
/// <summary>
/// Sends a message to the tail chopping router's collection of routees.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="sender">The sender of the message.</param>
public override void Send(object message, IActorRef sender)
{
_routees.Shuffle();
var routeeIndex = new AtomicCounter(0);
var completion = new TaskCompletionSource <object>();
var cancelable = new Cancelable(_scheduler);
_scheduler.Advanced.ScheduleRepeatedly(TimeSpan.Zero, _interval, async() =>
{
var currentIndex = routeeIndex.GetAndIncrement();
if (currentIndex < _routees.Length)
{
completion.TrySetResult(await((Task <object>)_routees[currentIndex].Ask(message, null)));
}
}, cancelable);
_scheduler.Advanced.ScheduleOnce(_within, () =>
{
completion.TrySetException(new TimeoutException(String.Format("Ask timed out on {0} after {1}", sender, _within)));
}, cancelable);
var request = completion.Task;
completion.Task.ContinueWith(task =>
{
cancelable.Cancel(false);
});
request.PipeTo(sender);
}
private void Main_Load(object sender, EventArgs e)
{
_chartActor = Program.ChartActors.ActorOf(Props.Create(() => new ChartingActor(sysChart, btnPauseResume)), "charting");
var series = ChartDataHelper.RandomSeries("FakeSeries" + _seriesCounter.GetAndIncrement());
_chartActor.Tell(new ChartingActor.InitializeChart(null));
_coordinatorActor = Program.ChartActors.ActorOf(Props.Create(() =>
new PerformanceCounterCoordinatorActor(_chartActor)), "counters");
// CPU button toggle actor
_toggleActors[CounterType.Cpu] = Program.ChartActors.ActorOf(
Props.Create(() => new ButtonToggleActor(_coordinatorActor, btnCpu,
CounterType.Cpu, false))
.WithDispatcher("akka.actor.synchronized-dispatcher"));
// MEMORY button toggle actor
_toggleActors[CounterType.Memory] = Program.ChartActors.ActorOf(
Props.Create(() => new ButtonToggleActor(_coordinatorActor, btnMemory,
CounterType.Memory, false))
.WithDispatcher("akka.actor.synchronized-dispatcher"));
// DISK button toggle actor
_toggleActors[CounterType.Disk] = Program.ChartActors.ActorOf(
Props.Create(() => new ButtonToggleActor(_coordinatorActor, btnDisk,
CounterType.Disk, false))
.WithDispatcher("akka.actor.synchronized-dispatcher"));
// Set the CPU toggle to ON so we start getting some data
_toggleActors[CounterType.Cpu].Tell(new ButtonToggleActor.Toggle());
}
/// <summary>
/// Sends a message to the tail chopping router's collection of routees.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="sender">The sender of the message.</param>
public override void Send(object message, ActorRef sender)
{
routees.Shuffle();
var routeeIndex = new AtomicCounter(0);
var completion = new TaskCompletionSource <object>();
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var scheduledSends = scheduler.Schedule(TimeSpan.Zero, interval, async() =>
{
var currentIndex = routeeIndex.GetAndIncrement();
if (currentIndex < routees.Length)
{
completion.TrySetResult(await((Task <object>)routees[currentIndex].Ask(message, null)));
}
}, token);
var withinTimeout = scheduler.ScheduleOnce(within, () =>
{
completion.TrySetException(new TimeoutException(String.Format("Ask timed out on {0} after {1}", sender, within)));
}, token);
var request = completion.Task;
completion.Task.ContinueWith((task) =>
{
tokenSource.Cancel(false);
});
request.PipeTo(sender);
}
public void Setup(BenchmarkContext context)
{
_system = ActorSystem.Create($"GetMailboxTypeSpec{Counter.GetAndIncrement()}");
_messageDispatcher = _system.Dispatchers.Lookup(EchoActor.Props.Dispatcher);
_mailboxes = new Mailboxes(_system);
_createActorThroughput = context.GetCounter(CreateThroughputCounter);
}
static ActorSystem LaunchFrontend(string port)
{
Console.WriteLine("Start - actorsystem for frontend node - port: {0}", port);
var config =
ConfigurationFactory.ParseString("akka.remote.helios.tcp.port=" + port)
.WithFallback(ConfigurationFactory.ParseString("akka.cluster.roles = [frontend]"))
.WithFallback(_clusterConfig);
var system = ActorSystem.Create("ClusterSystem", config);
var frontend = system.ActorOf(Props.Create<FrontendActor>(port), "frontend");
var interval = TimeSpan.FromSeconds(2);
var timeout = TimeSpan.FromSeconds(5);
var counter = new AtomicCounter();
system.Scheduler.Advanced.ScheduleRepeatedly(interval, interval,
() => frontend.Ask(new Messages.Request("request-" + counter.GetAndIncrement() + " from frontend node port " + port), timeout)
.ContinueWith( r =>
{
if (!r.IsCanceled)
{
Console.WriteLine(r.Result);
// Debug.WriteLine(r.Result);
}
}));
Console.WriteLine("End - actorsystem for frontend node - port: {0}", port);
return system;
}
public MongoDbCurrentEventsByPersistenceIdsSpec(ITestOutputHelper output, DatabaseFixture databaseFixture)
: base(CreateSpecConfig(databaseFixture, Counter.GetAndIncrement()), "MongoDbCurrentEventsByPersistenceIdsSpec", output)
{
_output = output;
output.WriteLine(databaseFixture.ConnectionString + Counter.Current);
ReadJournal = Sys.ReadJournalFor <MongoDbReadJournal>(MongoDbReadJournal.Identifier);
}
public void Required_spec317_mustNotSignalOnErrorWhenPendingAboveLongMaxValue_forSynchronousPublisher()
{
var sent = new AtomicCounter(0);
var publisher = new LamdaPublisher <int>(onSubscribe: subscriber =>
{
var started = false;
var cancelled = false;
subscriber.OnSubscribe(new LamdaSubscription(onRequest: n =>
{
if (!started)
{
started = true;
while (!cancelled)
{
subscriber.OnNext(sent.GetAndIncrement());
}
}
}, onCancel: () => cancelled = true));
});
var verification = CustomPublisherVerification(publisher);
verification.Required_spec317_mustNotSignalOnErrorWhenPendingAboveLongMaxValue();
// 11 due to the implementation of this particular TCK test (see impl)
Assert.AreEqual(11, sent.Current);
}
public void Setup(BenchmarkContext context)
{
_mailboxThroughput = context.GetCounter(MailboxCounterName);
System = ActorSystem.Create($"{GetType().Name}{Counter.GetAndIncrement()}");
_targetActor = new CounterRef(_mailboxThroughput);
System.EventStream.Subscribe(_targetActor, typeof(string));
}
public void Setup(BenchmarkContext context)
{
_selectionOpCounter = context.GetCounter(ActorSelectionCounterName);
System = ActorSystem.Create("MailboxThroughputSpecBase" + Counter.GetAndIncrement());
_receiver = System.ActorOf(Props.Create(() => new BenchmarkActor(_selectionOpCounter, NumberOfMessages, _resetEvent)));
_receiverActorPath = _receiver.Path;
_oneMessageBenchmarkProps = Props.Create(() => new BenchmarkActor(_selectionOpCounter, 1, _resetEvent));
}
public void Setup(BenchmarkContext context)
{
_actorSystem = ActorSystem.Create("MessageDispatcher" + Counter.GetAndIncrement(), RemoteHocon);
_systemAddress = RARP.For(_actorSystem).Provider.DefaultAddress;
_inboundMessageDispatcherCounter = context.GetCounter(MessageDispatcherThroughputCounterName);
_message = SerializedMessage.CreateBuilder().SetSerializerId(0).SetMessage(ByteString.CopyFromUtf8("foo")).Build();
_dispatcher = new DefaultMessageDispatcher(_actorSystem, RARP.For(_actorSystem).Provider, _actorSystem.Log);
_targetActorRef = new BenchmarkActorRef(_inboundMessageDispatcherCounter, RARP.For(_actorSystem).Provider);
}
public void Setup(BenchmarkContext context)
{
_mailboxThroughput = context.GetCounter(MailboxCounterName);
System = ActorSystem.Create($"{GetType().Name}{Counter.GetAndIncrement()}");
_actorBasePatternMatchActorRef = System.ActorOf(BenchmarkActorBasePatternMatchActor.Props(_mailboxThroughput, MailboxMessageCount * 3, _resetEvent));
_untypedActorRef = System.ActorOf(BenchmarkUntypedActor.Props(_mailboxThroughput, MailboxMessageCount * 3, _resetEvent));
_receiveActorRef = System.ActorOf(BenchmarkReceiveActor.Props(_mailboxThroughput, MailboxMessageCount * 3, _resetEvent));
_minimalActorRef = new BenchmarkMinimalActorRef(_mailboxThroughput, MailboxMessageCount, _resetEvent);
}
protected Eventsourced()
{
LastSequenceNr = 0L;
Extension = Persistence.Instance.Apply(Context.System);
_instanceId = InstanceCounter.GetAndIncrement();
_maxMessageBatchSize = Extension.Settings.Journal.MaxMessageBatchSize;
_currentState = RecoveryPending();
_internalStash = CreateStash();
}
public void Should_not_be_able_to_add_jobs_after_shutdown()
{
var atomicCounter = new AtomicCounter(0);
var fiber = FiberFactory.CreateFiber(2);
for (var i = 0; i < 1000; i++)
{
fiber.Add(() => atomicCounter.GetAndIncrement());
}
fiber.GracefulShutdown(TimeSpan.FromSeconds(1)).Wait(); //wait for the fiber to finish
//try to increment the counter a bunch more times
for (var i = 0; i < 1000; i++)
{
fiber.Add(() => atomicCounter.GetAndIncrement());
}
//value should be equal to its pre-shutdown value
Assert.AreEqual(1000, atomicCounter.Current);
}
public void Setup(BenchmarkContext context)
{
_actorSystem = ActorSystem.Create("MessageDispatcher" + Counter.GetAndIncrement(), RemoteHocon);
_systemAddress = RARP.For(_actorSystem).Provider.DefaultAddress;
_inboundMessageDispatcherCounter = context.GetCounter(MessageDispatcherThroughputCounterName);
_message = new SerializedMessage {
SerializerId = 0, Message = ByteString.CopyFromUtf8("foo")
};
_dispatcher = new DefaultMessageDispatcher(_actorSystem.AsInstanceOf <ExtendedActorSystem>(), RARP.For(_actorSystem).Provider, _actorSystem.Log);
_targetActorRef = new BenchmarkActorRef(_inboundMessageDispatcherCounter, RARP.For(_actorSystem).Provider);
}
public void Should_use_multiple_threads_to_process_queue()
{
var atomicCounter = new AtomicCounter(0);
var fiber = FiberFactory.CreateFiber(2);
for (var i = 0; i < 1000; i++)
{
fiber.Add(() => atomicCounter.GetAndIncrement());
}
fiber.GracefulShutdown(TimeSpan.FromSeconds(1)).Wait(); //wait for the fiber to finish
Assert.AreEqual(1000, atomicCounter.Current);
}
public override Routee NewRoutee(Props routeeProps, IActorContext context)
{
_nodeAddrEnumerator.MoveNext();
var name = "c" + _childNameCounter.GetAndIncrement();
var deploy = new Deploy(routeeProps.RouterConfig, new RemoteScope(_nodeAddrEnumerator.Current));
var actorRef = context.AsInstanceOf <ActorCell>()
.AttachChild(Local.EnrichWithPoolDispatcher(routeeProps, context).WithDeploy(deploy), false, name);
return(new ActorRefRoutee(actorRef));
}
public ShortTimeoutLongTask(TestLatch latch, AtomicCounter counter)
{
StartWith(
Loop(
ReceiveAny(s => s.Equals("RUN"),
After(
Timeout(TimeSpan.FromMilliseconds(100),
Delay(5.Seconds(), Execute(_ => counter.GetAndIncrement())),
Execute(_ =>
{
counter.GetAndDecrement();
Sender.Tell("TIMEOUT");
})),
Execute(_ => latch.CountDown())))), null);
}
/// <summary>
/// Sends a message to the collection of routees.
/// </summary>
/// <param name="message">The message that is being sent.</param>
/// <param name="sender">The actor sending the message.</param>
public override void Send(object message, IActorRef sender)
{
_routees.Shuffle();
var routeeIndex = new AtomicCounter(0);
var completion = new TaskCompletionSource <object>();
var cancelable = new Cancelable(_scheduler);
completion.Task
.ContinueWith(task => cancelable.Cancel(false));
if (_routees.Length == 0)
{
completion.TrySetResult(NoRoutee);
}
else
{
_scheduler.Advanced.ScheduleRepeatedly(TimeSpan.Zero, _interval, async() =>
{
var currentIndex = routeeIndex.GetAndIncrement();
if (currentIndex >= _routees.Length)
{
return;
}
try
{
completion.TrySetResult(
await(_routees[currentIndex].Ask(message, _within)).ConfigureAwait(false));
}
catch (AskTimeoutException)
{
completion.TrySetResult(
new Status.Failure(
new AskTimeoutException($"Ask timed out on {sender} after {_within}")));
}
catch (TaskCanceledException)
{
completion.TrySetResult(
new Status.Failure(
new AskTimeoutException($"Ask timed out on {sender} after {_within}")));
}
}, cancelable);
}
completion.Task.PipeTo(sender);
}
protected override void OnReceive(object message)
{
PatternMatch.Match(message)
.With <string>(str =>
{
if (str.Equals("bar"))
{
_barCount.GetAndIncrement();
_barLatch.CountDown();
}
if (str.Equals("foo"))
{
_fooLatch.CountDown();
}
});
}
public void Subscribe(ISubscriber <int> subscriber)
=> subscriber.OnSubscribe(new LamdaSubscription(onRequest: n =>
{
Action signalling = () =>
{
for (var i = 0L; i < n; i++)
{
try
{
// shutdown cleanly in when the task is shutting down
if (_token.IsCancellationRequested)
{
return;
}
subscriber.OnNext((int)i);
}
catch (Exception ex)
{
// signal others to shut down
_source.Cancel();
if (ex is Latch.ExpectedOpenLatchException)
{
if (!_concurrentAccessCaused.CompareAndSet(false, true))
{
throw new Exception("Concurrent access detected", ex);
}
// error signalled once already, stop more errors from propagating
return;
}
else
{
throw;
}
}
}
};
// must be guarded like this in case a Subscriber triggers request() synchronously from it's onNext()
while (_startedSignallingThreads.GetAndIncrement() < MaxSignallingThreads && !_token.IsCancellationRequested)
{
new Thread(() => signalling()).Start();
}
}));
static void LaunchFrontend(string[] args)
{
var port = args.Length > 0 ? args[0] : "0";
var config =
ConfigurationFactory.ParseString("akka.remote.helios.tcp.port=" + port)
.WithFallback(ConfigurationFactory.ParseString("akka.cluster.roles = [frontend]"))
.WithFallback(_clusterConfig);
var system = ActorSystem.Create("ClusterSystem", config);
var backendRouter =
system.ActorOf(
Props.Empty.WithRouter(new ClusterRouterGroup(new ConsistentHashingGroup("/user/backend"),
new ClusterRouterGroupSettings(10, false, "backend", ImmutableHashSet.Create("/user/backend")))));
var frontend = system.ActorOf(Props.Create(() => new FrontendActor(backendRouter)), "frontend");
var interval = TimeSpan.FromSeconds(12);
var counter = new AtomicCounter();
system.Scheduler.Advanced.ScheduleRepeatedly(interval, interval,() => frontend.Tell(new StartCommand("hello-" + counter.GetAndIncrement())));
}
static void LaunchFrontend(string[] args)
{
var port = args.Length > 0 ? args[0] : "0";
var config =
ConfigurationFactory.ParseString("akka.remote.helios.tcp.port=" + port)
.WithFallback(ConfigurationFactory.ParseString("akka.cluster.roles = [frontend]"))
.WithFallback(_clusterConfig);
var system = ActorSystem.Create("ClusterSystem", config);
var frontend = system.ActorOf(Props.Create<TransformationFrontend>(), "frontend");
var interval = TimeSpan.FromSeconds(2);
var timeout = TimeSpan.FromSeconds(5);
var counter = new AtomicCounter();
system.Scheduler.Advanced.ScheduleRepeatedly(interval, interval,
() => frontend.Ask(new TransformationMessages.TransformationJob("hello-" + counter.GetAndIncrement()), timeout)
.ContinueWith(
r => Console.WriteLine(r.Result)));
}
/// <summary>
/// Performs all of the setup and initialization needed to get the Zipkin Kafka reporting engine up and running.
/// </summary>
/// <param name="options">The set of options for configuring timeouts and batch sizes.</param>
/// <param name="actorSystem">
/// Optional. If using Akka.NET, you can hook your own <see cref="ActorSystem" /> into our
/// reporting engine.
/// </param>
/// <returns></returns>
public static ZipkinKafkaSpanReporter Create(ZipkinKafkaReportingOptions options,
ActorSystem actorSystem = null)
{
// force this component to explode if the end-user screwed up the URI somehow.
var weOwnActorSystem = false;
if (actorSystem == null) // create our own ActorSystem if it doesn't already exist.
{
weOwnActorSystem = true;
actorSystem = ActorSystem.Create("pbzipkin",
options.DebugLogging ? DebugHocon : NormalHocon);
}
// spawn as a System actor, so in the event of being in a non-owned system our traces get shut down
// only after all of the user-defined actors have terminated.
var zipkinActor = actorSystem.AsInstanceOf <ExtendedActorSystem>().SystemActorOf(
Props.Create(() => new KafkaReportingActor(options)),
$"zipkin-tracing-kafka-{NameCounter.GetAndIncrement()}");
return(new ZipkinKafkaSpanReporter(zipkinActor, weOwnActorSystem ? actorSystem : null));
}