akka | Build highly concurrent , distributed , and resilient message

TradingStrategy's protocol would have to include messages indicating order updates. A TradingStrategy actor can register a message adapter which will translate the messages sent by the order actor into TradingStrategy's protocol: the TradingStrategy can present the "virtual" ActorRef returned by the message adapter to the order actor without the order actor knowing that its a TradingStrategy.

What you configured is the Connection source enforcement which makes sure that a Hono device (identified via the AMQP header device_id) may only updates the twin with the same "thing id" in Ditto.

That enforcement fails as your thingId you set in the Ditto Protocol JSON is my-tenant:org.acme:my-device-1 - the topic's first segment is the namespace, the second segment the name - combined those 2 segments become the "thing ID", see also: Protocol topic specification.

So you probably want to send the following message instead:

You can use the limitedParallelism-function on a Dispatcher (experimental in v1.6.0), and use the returned dispatcher to call your asynchronous functions. The function returns a view over the original dispatcher which limits the parallelism to a limit you provide. You can use it like this:

To call the expression version with two arguments, you need:

Broadly, actors run on an dispatcher which selects a thread from a pool and runs that actor's Receive for some number of messages from the mailbox. There is no guarantee in general that an actor will run on a given thread (ignoring vacuous examples like a pool with a single thread, or a dispatcher which always runs a given actor in a specific thread).

That dispatcher is also a Scala ExecutionContext which allows arbitrary tasks to be scheduled for execution on its thread pool; such tasks include Future callbacks.

So in your actor, what happens when a messageA is received?

• The actor calls createApi() and saves it
• It calls the callA method on api
• It closes api
• It arranges to forward the result of callA when it's available to the sender
• It is now ready to process another message and may or may not actually process another message

What this actually means depends on what callA does. If callA schedules a task on the execution context, it will return the future as soon as the task is scheduled and the callbacks have been arranged; there is no guarantee that the task or callbacks have been executed when the future is returned. As soon as the future is returned, your actor closes api (so this might happen at any point in the task's or callbacks' execution).

In short, depending on how api is implemented (and you might not have control over how it's implemented) and on the implementation details, the following ordering is possible

• Thread1 (processing messageA) sets up tasks in the dispatcher
• Thread1 closes api and arranges for the result to be piped
• Thread2 starts executing task
• Thread1 moves on to processing some other message
• Thread2's task fails because api has been closed

In short, when mixing Futures and actors, the "single-threaded illusion" in Akka can be broken: it becomes possible for arbitrarily many threads to manipulate the actor's state.

In this example, because the only shared state between Futureland and actorland is local to the processing of a single message, it's not that bad: the general rule in force here is:

• As soon as you hand mutable (e.g. closeable) state from an actor to a future (this includes, unless you can be absolutely sure what's happening, calling a method on that stateful object which returns a future), it's best for the actor to forget about the existence of that object

How then to close api?

Well, assuming that callA isn't doing anything funky with api (like saving the instance in some pool of instances), after messageA is done processing and the future is completed, nothing has access to api. So the simplest, and likely most correct, thing to do is arrange for api to be closed after the future has completed, along these lines

The Akka docs call out your situation:

The Akka HTTP WebSocket API does not support half-closed connections which means that if either stream completes the entire connection is closed (after a “Closing Handshake” has been exchanged or a timeout of 3 seconds has passed).

In your case, outgoing (being a Source.single) completes as soon as it has emitted the TextMessage. The webSocketFlow receives the completion message and then tears down the connection.

The solution is to delay when outgoing completes, perhaps even delaying it forever (or at least until the application is killed).

Two standard sources are potentially useful for delaying completion in the scenario where you don't want to send messages through the websocket.

• Source.maybe materializes as a Promise which you can complete with an optional terminating message. It will not complete unless and until the promise is completed.

• Source.never never completes. You could achieve this by just not completing Source.maybe, but this is less overhead than that.

So what would it look like in code?

IActorRefFactory is an interface responsible for determining a parent and in case of Akka.FSharp it's implemented by ActorSystem and Actor<_> as well. So in your case just use:

There were two mistakes I found, fixing which solved the problem.

Mistake 1

I was forgetting to pass appConf as an argument while creating an instance of ActorSystem, without which ActorSystem was always getting created with default akka configs. Hence always make sure to pass appConf while creating an instance of ActorSystem otherwise your akka configurations will never take effect.

HelloWorld.Scala

Note that you're using the web interface to connect. The YCQL api is available on the 9042 port.

Also note that akka will use the default Cassandra driver. And it's best to use the YugabyteDB fork: https://github.com/yugabyte/cassandra-java-driver

Then you can also see how to setup a cluster in multiple regions https://docs.yugabyte.com/latest/deploy/multi-dc/