Akka | Examples and explanations of how Akka toolkit works

You can type your route to receive a JsObject (from SprayJson):

If you're going to assign different roles to different nodes, those nodes cannot use the same configuration. The easiest way to accomplish this is through n1 having "testRole1" in its akka.cluster.roles list and n2 having "testRole2" in its akka.cluster.roles list.

Everything in akka.cluster config is only configuring that node for participation in the cluster (it's configuring the cluster component on that node). A few of the settings have to be the same across the nodes of a cluster (e.g. the SBR settings), but a setting on n1 doesn't affect a setting on n2.

In Akka Classic, you would have something like

Echoing the comment as an answer just so this doesn't show as unanswered:

So my question is... how do I emit a final element when the scoreFlux completes?

You can simply use concatWith() to concatenate the publisher you want after your original flux completes. If you only want that to be evaluated when the original publisher completes, make sure you wrap it up in Mono.defer(), which will prevent the pre-emptive execution.

The function (ActorContext[String] => Behavior[String]) passed to Behaviors.setup is executed when the actor is spawned, regardless of whether there's a message to process.

The function ((ActorContext[String], String) => Behavior[String]) passed to Behaviors.receive is not executed until there's a message to process.

Note that if you had

I'm struck by

...I can't take the entire file content, frame it into separate objects, store them all to Kafka and commit only after that

Since it seems (and you can comment if I'm getting this wrong) that the offset commit is effectively an acknowledgement that you've fully processed a file, there's no way around not committing the offset until after all the objects in the file in the message at that offset have been produced to Kafka.

The downside of Source.via(Flow.flatMapConcat.via(...)).map.via(...) is that it's a single stream and everything between the first and second vias, inclusive takes a while.

If you're OK with interleaving objects from files in the output topic and are OK with an unavoidable chance of an object from a given file being produced twice to the output topic (both of these may or may not impose meaningful constraints/difficulties on the implementation of downstream consumers of that topic), you can parallelize the processing of a file. The mapAsync stream stage is especially useful for this:

In general, stages in Akka Streams do not share state: they only pass elements of the stream between themselves. Thus the only general way to pass state between stages of a stream is to embed the state into the elements being passed.

In some cases, one could use SourceWithContext/FlowWithContext:

Essentially, a FlowWithContext is just a Flow that contains tuples of element and context, but the advantage is in the operators: most operators on FlowWithContext will work on the element rather than on the tuple, allowing you to focus on your application logic rather without worrying about the context.

In this particular case, since groupBy is doing something similar to reordering elements, FlowWithContext doesn't support groupBy, so you'll have to embed the IDs into the stream elements...

(...Unless you want to dive into the deep end of a custom graph stage, which will likely dwarf the complexity of embedding the IDs into the stream elements.)

What is happening is basically:

• the Future result of createSchool(...) is bound to createSchool
• workedVal is initialized to false
• a callback is attached to createSchool
• workedVal is checked and false
• Ok with the error message is returned
• The createSchool Future completes
• The callback is executed, possibly setting workedVal

You'll have to make it an async Action, which means every path has to result in a Future

So something like this should work

This is because the redis client wants to create a top level actor under /user which is not possible with a typed actor system because there the /user actor is yours and the only one who is allowed to spawn children of that actor is itself.

The etaty library should be updated to not require doing that (for example return an actor for you to start, or use systemActorOf to start its own internal actors). You can however work around this by using a classic actor system in your app, and adapting to the typed APIs instead.