* Harden multi-dc joining, #29280
* failing test MultiDcJoinSpec
* require that all have seen the gossip seen for the first member in other DC
* the test also revealed that gossip wasn't propagated between DCs when
the VectorClock was the same and only seen is different
* add a SHA-1 disgest of the seen in the GossipStatus to detect that they
are different and that full gossip should be exchanged
* comments
* another test
* mima version
* Watch all regions as they may shutdown after rebalance starts
* Send graceful shutdown to selection if no coordinator found
* mima
* Add missing new line
* Make log markers consistent for rebalance worker
* Allow entities to stop by terminating in sharding without remember entities #29383
We missed an allowed transition from running/active to stopped/NoState in shard.
when the logic was rewritten.
* Add a toggle to opt-in crash shard on illegal state transitions
Default is logging an error and not crashing shard and all other entities, our tests have the toggle enabled.
* A fix for passivation when not using remember entities fixing #29359 and possibly #27549
Updated stream-composition.md to use Flow.fromSinkAndSourceCoupledMat or Flow.fromSinkAndSourceCoupled rather than the deprecated CoupledTerminationFlow.fromSinkAndSource.
Fixes#28769
Use case for this is if you have a sequence of elements that has been
partitioned across multiple streams, and you want to merge them back
together in order. It will typically be used in combination with
`zipWithIndex` to define the index for the sequence, followed by a
`Partition`, followed by the processing of different substreams with
different flows (each flow emitting exactly one output for each input),
and then merging with this stage, using the index from `zipWithIndex`.
A more concrete use case is if you're consuming messages from a message
broker, and you have a flow that you wish to apply to some messages, but
not others, you can partition the message stream according to which
should be processed by the flow and which should bypass it, and then
bring the elements back together acknowledgement. If an ordinary merge
was used rather than this, the messages that bypass the processing flow
would likely overtake the messages going through the processing flow,
and the result would be out of order offset acknowledgement which would
lead to dropping messages on failure.
I've included a minimal version of the above example in the documentation.
New type StatusReply simplifies the very common use case of replying to a request with either a successful reply or an error reply which can be repetitive to define for every actor, with the additional overhead of having to make sure each such sealed top type + 2 concrete reply classes has working serialization.
Especially in the Scala 2.13 version, the previous `if xs.iterator.isEmpty`
for the common case was a big problem, since it expensively created an
iterator even for the most common ++=(ByteString) case.
It turned up in profiles, the usual implementation in 2.13 is through
SeqOps.isEmpty -> lengthCompare which checks if knownSize != -1 for
the fast path. All of that doesn't sound too bad but introduces enough
indirection that the inliner might not be able to inline all of that
which then leads to a multimorphic callsite e.g. to call lengthCompare.
