* reproducer test of AESCounterBuiltinRNG issue
* update documentation of random-number-generator
* deprecate AES128CounterSecureRNG AES256CounterSecureRNG
* incorporate feedback from Johannes
* fix NPE in shutdownTransport
* perhaps because shutdown before started
* system.dispatcher is used in other places of the shutdown
* improve logging of compression advertisment progress
* adjust RestartFlow.withBackoff parameters
* quarantine after ActorSystemTerminating signal
(will cleanup compressions)
* Quarantine idle associations
* liveness checks by sending extra HandshakeReq and update the
lastUsed when reply received
* concervative default value to survive network partition, in
case no other messages are sent
* Adjust logging and QuarantinedEvent for harmless quarantine
* Harmless if it was via the shutdown signal or cluster leaving
* The ThreadLocal Serialization.currentTransportInformation is used for serializing local
actor refs, but it's also useful when a serializer library e.g. custom serializer/deserializer
in Jackson need access to the current ActorSystem.
* We set this in a rather ad-hoc way from remoting and in some persistence plugins, but it's only
set for serialization and not deserialization, and it's easy for Persistence plugins or other
libraries to forget this when using Akka serialization directly.
* This change is automatically setting the info when using the ordinary serialize and deserialize
methods.
* It's also set when LocalActorRefProvider, which wasn't always the case previously.
* Keep a cached instance of Serialization.Information in the provider to avoid
creating new instances all the time.
* Added optional Persistence TCK tests to verify that the plugin is setting this
if it's using some custom calls to the serializer.
Each build is now over 40mb logs.
A lot of DEBUG logging was left on for test failures that have been
fixed. Added an issue # for ones that are still valid or if if it on
as the test verifies debug
Use ConfigFactory.load to pick up overrides in the additional actor
system. Otherwise one runs with udp and other tcp for the artery-tcp
job.
Fixes#24806
* deduplicate logic for IODispatcher #24604
* introduce a resolveDispatcher helper in ActorAttributes
* mention akka.stream.materializer.blocking-io-dispatcher instead of akka.stream.blocking-io-dispatcher in scaladocs
* fix a flaky test
* cosmetic changes in the touched files
* move resolveDispather helper to the Dispatcher companion object under a new name resolve
* filter out mima warning
* fix mima excludes after the 2.5.11 release
* address review comments
* update stream-io.md with the correct dispatcher config key
* mark ActorAttributes.Dispatcher#resolve as internal API
* use the dispatche config key in ActorMaterializer
* add private[akka] to the resolve methods
```
[error] /localhome/jenkinsakka/workspace/akka-nightly-jdk9/akka-remote/src/main/scala/akka/remote/artery/tcp/ArteryTcpTransport.scala:160:35: ambiguous reference to overloaded definition,
[error] both method limit in class ByteBuffer of type (x$1: Int)java.nio.ByteBuffer
[error] and method limit in class Buffer of type ()Int
[error] match expected type ?
[error] val size = env.byteBuffer.limit
```
* fix memory leak in SystemMessageDelivery
* initial set of tests for idle outbound associations, credit to mboogerd
* close inbound compression when quarantined, #23967
* make sure compressions for quarantined are removed in case they are lingering around
* also means that advertise will not be done for quarantined
* remove tombstone in InboundCompressions
* simplify async callbacks by using invokeWithFeedback
* compression for old incarnation, #24400
* it was fixed by the other previous changes
* also confirmed by running the SimpleClusterApp with TCP
as described in the ticket
* test with tcp and tls-tcp transport
* handle the stop signals differently for tcp transport because they
are converted to StreamTcpException
* cancel timers on shutdown
* share the top-level FR for all Association instances
* use linked queue for control and large streams, less memory usage
* remove quarantined idle Association completely after a configured delay
* note that shallow Association instances may still lingering in the
heap because of cached references from RemoteActorRef, which may
be cached by LruBoundedCache (used by resolve actor ref).
Those are small, since the queues have been removed, and the cache
is bounded.
* transport config
* TCP specific classes in akka.remote.artery.tcp package
* TcpFraming stage that handle the additional streamId field and length based framing.
Credit to jrudolph for this clean solution, which made it possible to use same
envolope header for Aeron and TCP.
* magic first bytes to detect invalid access
* drain SendQueue to deadLetters in postStop
* error handling, restart, inbound and outbound streams
* udp vs tcp in autoSelectPort
* TCP specific flight recorder events
* update reference documentation
* Refactoring to separate the Aeron specific things, ArteryAeronUdpTransport
* move Aeron specific classes to akka.remote.artery.aeron package
* move Version to ArterySettings, and describe strategy for envelope header changes
* More generous timeout in DaemonicSpec
Also:
* allow it to complete faster if possible
* avoid potential race with port number
* always shut the extra actor system down
* less dilation
* +rem #24265 protobuf serializer for Address and UniqueAddress in akka-remote
* remove the duplication, by using previously existing type
* fixed doc link
* make it easier to enable the additional no-java-serialization bindings
* fixed akka-actor failure due to changes
* cleanup
* Update reference.conf
* Update serialization.md
* Update reference.conf
The flag used to show a record is dirty/commited was overwritten by the
last 4 bytes of the previous metadata. Most of the time this isn't
caught as the record is written fixed width and typically the last bytes
are 0s which is the same as the Commited flag. However under
concurrency this can overwrite the Dirty flag that is preventing
corruption.
* DaemonMsgCreate is not a system message. We send it over the control
stream because remote deployment process depends on message ordering
for DaemonMsgCreate and Watch messages. That is all good.
* We also send DaemonMsgCreate over the ordinary message stream (all
outbound lanes) so that the first ordinary message that is sent to
the ref does not arrive before the actor is created. This is not needed,
since the retried resolve in the Decoder will take care of that anyway.
* Inbound lanes were not covered, but not needed.
* Then the deduplication of DaemonMsgCreate messages in RemoteSystemDaemon
is not needed.
* Added some more tests for these things.
* describe lanes in reference docs
* Pass HandshakeReq in all inbound lanes, #23527
The HandshakeReq message must be passed in each inbound lane to
ensure that it arrives before any application message. Otherwise there is a risk
that an application message arrives in the InboundHandshake stage before the
handshake is completed and then it would be dropped.
* mima
