This is the first step towards a completely new and optimized actor
implementation for Akka Typed. The full previously existing test suite
passes for both implementations. The following is an incomplete list of
things that remain to be done:
* document the semantic differences between untyped and typed, in
particular around actor restarts and the delivery ordering guarantees
for Terminated messages (also document the difference between
ActorSystemImpl and ActorSystemAdapter)
* implement EventStream and logging—this currently just delegates to an
extra untyped ActorSystem (of course To Be Fixed)
* implement dispatcher selection
* implement and test queue size limitation
* implement optimized message queue instead of CLQ (for zero-allocation
messaging)
* clean up test log output (something does not work with TestEventListener
and EventFilter for ActorSystemImpl tests)
* document the capabilities (or more appropriately: the limitations) of
interoperability between ActorSystemImpl and ActorSystemAdapter
* fix ActorPath UID generation (i.e. make sure that everything gets a
meaningful value instead of zero)
* re-evaluate throughput/rescheduling logic in ActorCell
Oh, and by the way: as per PerformanceSpec (doing simple ping-pong) the
new implementation is ca. 30% faster than the adapter over akka-actor
:-)
This is useful in at least two scenarios:
- Unit testing actors that communicate to their parent directly
- Testing re-creating (typically persistent) actors with the same name
* fix for infinite timeout disabling timeout infrastructure (#20817)
* filtering out timeout-access header in tests where necessary (#20817)
* filtering out timeout-access header in additional tests (#20817)
* added DummyCancellable object to avoid allocation (#20817)
* added test showing that timeout is correctly reset for both infinite as well as finite initial request-timeout (#20817)
The single-request-in-actor-example does not consume the response
in where the status code is not OK. Although this is unlikely
to cause backpressure issues as the response is likely to have
a HttpEntity.Strict entity, the example is confusing as it
does not follow the warning about always consuming the response.
remove `new AnyRef`
before:
```
new AnyRef {
class Listener extends Actor {
def receive = {
case m: Jazz => println(s"${self.path.name} is listening to: ${m.artist}")
case m: Electronic => println(s"${self.path.name} is listening to: ${m.artist}")
}
}
```
after:
```
class Listener extends Actor {
def receive = {
case m: Jazz => println(s"${self.path.name} is listening to: ${m.artist}")
case m: Electronic => println(s"${self.path.name} is listening to: ${m.artist}")
}
}
```
* [#21090] Added the improved code for loggingResponsetime and added the link in the docs
* [#21090] Added javadocs for logRequestResponseTime
* [#21090] Removed the compilation error caused by the missing imports
* [#21090] Removed the compilation error caused by type
* [#21090] Improved the identation of the code
* [#21090] Improved the identation of the code
* [#21090] Removed the empty line
* [#21090] Refactored the documentation with clear explanations
added CSV examples
updated docs
EntityStreamingSupport is now an entry point, to all streaming things
both read and write side use it
it's easy to extend as well
