* Move artery settings from remoting settings to dedicated class.
* #20587 Move hardcoded settings to configuration file.
* Copy reused settings from remote to the artery
* outbound compression is now immutable, by simply using
CompressionTable[ActorRef] and CompressionTable[String]
* immutable outbound compression will make it possible to use
them from multiple Encoder instances, when we add several lanes
for parallel serialization
* outbound compression tables not shared via AssociationState
* the advertised tables are sent to the Encoder stage via async
callback, no need to reference the tables in other places than
the Encoder stage, no more races via shared mutable state
* when outbound stream is started or restarted it can start out
without compression, until next advertisement is received
* ensure outbound compression is cleared before handshake is signaled complete
* failing test was akka.cluster.AttemptSysMsgRedelivery when
running with Artery
* we rely on that system messages are not dropped before
the redelivery stage, i.e. blackhole must be after that
* =art now correctly compresses and 2 table mode working
* =art AGRESSIVELY optimising hashing, not convienved about correctness yet
* fix HandshakeShouldDropCompressionTableSpec
* StreamSupervisor as system actor so that it is
stopped after ordinary actors
* when transport is shutdown send flush message to all
outbound associations (over control stream) and wait for ack
or timeout
There were two related problems with remote deployment when
using Artery.
* DaemonMsgCreate is not a SystemMessage, but must be sent over the control stream because
remote deployment process depends on message ordering for DaemonMsgCreate and Watch messages.
It must also be sent over the ordinary message stream so that it arrives (and creates the
destination) before the first ordinary message arrives.
* The first point solves the creation of the remote deployed actor but it's not enough.
Resolve of the recipient actor ref may still happen before the actor is created. This
is solved by retrying the resolve for the first message of a remote deployed actor.
* reduce allocations with specialized ImmutableLongMap
* backed by arrays, allocation free lookups with binary search
* use it for UID -> Association Map
* pass Association in InboundEnvelope to reduce to only
one lookup per incoming message
* use ImmutableLongMap instead of the QuarantinedUIDSet
* new SendQueue Source based on agrona ManyToOneConcurrentArrayQueue
* jmh benchmark for send queue
* JMH benchmark for Source.queue, Source.actorRef and the new SendQueue
* inject the queue so that we can start sending to it before materialization
* Get rid of computeIfAbsent in the AssociationRegistry
by making it possible to send (enque) messages to the
Association instance immediatly after construction.
* we don't want to include the full origin address in each message,
only the UID
* that means that the restarted receiving system can't initate a
new handshake immediately when it sees message from unknown origin
* instead we inject HandshakeReq from the sending system once in a while
(1 per second) which will trigger the new handshake
* any messages that arrives before the HandshakeReq are dropped, but
that is fine since the system was just restarted anyway
* note that the injected handshake is only done for active connections,
when a message is sent
* also changed the UID to a Long, but there are more places in old remoting
that must be changed before we actually can use a Long value
fix lost first message, #20566
* the first message was sometimes dropped by the InboundHandshake stage
because it came from unknown origin, i.e. the handshake had not completed
* that happended because the ordinary messagage arrived before the
first HandshakeReq, which may happen since we sent the HandshakeReq
over the control stream
* this changes so that HandshakeReq is sent over the same stream, not
only on the control stream and thereby the HandshakeReq will arrive
before any other message
* always send HandshakeReq as first message
* also when the handshake on sender side has been completed at startup
* moved code from preStart to onPull
* CodecBenchmark that tests encode, decode and combined
encode + decode
* refactoring of codec stages to make it possible to
run them without real ArteryTransport
* also fixed a bug in inbound stream for large messages,
it was using wrong envelope pool
* First stab at separate large message channel for Artery
* Full actor paths, no implicit "/user/" part
* Various small fixes after review
* Fixes to make it work after rebasing
* Use a separate EnvelopeBufferPool for the large message stream
* Docs for actorSelection not sending through large message stream
* InboundQuarantineCheck stage sends back Quarantined control
message if sender system is quarantined
* Ported old RemoteRestartedQuarantinedSpec
* outbound quarantine check and piercing with ActorSelectionMessage
* port of old RemoteQuarantinePiercingSpec and PiercingShouldKeepQuarantineSpec
* quarantine if sys msg buffer overflow
* handle UID incarnations, shared association state that can be swapped
for new handshakes
* detect that message comes from unknown origin and then initiate new
handshake (handled by InboundHandshake stage)
* simplify the OutboundHandshake stage
* doesn't have to listen for HandshakeRsp replies, it can just listen
to when the uniqueRemoteAddress future is completed, InboundHandshake
stage completes the handshake when it receives HandshakeRsp
* send the HandshakeReq via the control message ingress, instead of
pushing it downstreams, than also means that HandshakeReq is only sent
on the control stream, which is good
* materialization race condition
* instead of sending the the control messages (e.g. handshake reply,
sys msg ack) via the normal message send ingress point they are
now injected via side channel and will therefore not go through
higher level stages such as handshake and system message delivery
* UID exchange with handshake stages
* second iteration of reply side-channel, observable
* InboundContext and OutboundContext to facilitate testing
without real transport
* collapse ArterySubsystem and Transport into ArteryTransport
* incomplete HandshakeRestartReceiverSpec (origin address missing
to be able to implement that part
* remove embedded aeron media driver directory on shutdown
