Newbie with Akka and Streams here! I'm set on understanding the fundamentals of the latest Akka Streams API through standing up a prototype. ;0)
I've looked to the Typesafe Activator Template on Akka Http with Websockets to do this; and have posted questions on the Disqus comments section; but apparently there isn't anyone monitoring that. SO, I'm just going to re-post those here to see if anyone with relevant experience is able and willing to answer! Would be grateful to be referred to a coherent Blog/GitHub repo which would answer most of these questions in any case! THANKS so much in advance! 1) TweetActor publishes to EventStream; and TweetPublisher receives this and forwards to WebSocket. What's the logic for separating the TweetActor and TweetPublisher? i.e. TweetActor is essentially acting as a Publisher, and Source of 'flow' for Tweets; HOWEVER, I'm confused about the distinction between, and when to use: - context.system.eventStream.publish(tweet) within TweetActor VS - Flow instantiated with TweetPublisher Source 2) What if I wanted to integrate with an (external) REAL Tweets Stream API from Twitter; but I don't know how their API implements the Reactive Streams Protocol? How would I use AkkaHttp Streams as a Client to GET tweets from that external Source; i.e. What are the latest recommended APIs I should be using to handle that? - I'm seeing the Akka Template for AkkaSampleTwitterStream using this: response.entity.dataBytes.runForeach VS - following THIS Akka Template; wouldn't one be constructing a Flow that MIRRORs what's in THIS OUTWARD flow; instead with an INWARD flow? i.e. Source.ignore; and class TweetSubscriber extends ActorSubscriber[Tweet]? 3) What is the default serialization format for AkkaStreams; and is it set to a reasonably efficient one? Otherwise, where can I override this; and what's the best-practice for setting this to? 4) How do local Stream buffers work roughly? - Where and how are the default and custom configuration property files for cache size in terms of number of typed Objects setup so as not to blow-up local memory? - Is each Stream dedicated to only one type of message; albeit permitting bi-directional flows? - Where and how are the cache-eviction policies defaulted/configured in a property file? i.e. drop latest; or drop earliest? - What is the distinction between when you use a configured Flow that's Materialized later; OR, the context.system.eventStream (which is materialized by default with import of Akka Streams libraries?) 5) Handling versioning of incoming messages from external sources: - Is there a good example for error-handling for serialization errors based on version differences between the incoming external message; vs the assumed message structure processed internally? 6) Configuration of routes in externalized configuration files: - Is there a coherent example which shows how to setup configuration properties files for mapping URLs for REST and WebSocket endpoints? i.e. the nested code blocks within main.scala in this example could get hard to maintain in a larger application! -- >>>>>>>>>> Read the docs: http://akka.io/docs/ >>>>>>>>>> Check the FAQ: >>>>>>>>>> http://doc.akka.io/docs/akka/current/additional/faq.html >>>>>>>>>> Search the archives: https://groups.google.com/group/akka-user --- You received this message because you are subscribed to the Google Groups "Akka User List" group. To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To post to this group, send email to [email protected]. Visit this group at https://groups.google.com/group/akka-user. For more options, visit https://groups.google.com/d/optout.
