Hi Stephen,
wasn’t your requirement to drop the whole sub-list when a failure occurs during
its processing? That is not achieved with this design: you’ll have to buffer
all events and only release the buffer when the substream completes
successfully. Something like
.fold(Vector.empty[Int])(_
So, the suggestion is something like this?:
val subStreamFuture = Source(Seq(Seq(1, 2), Seq(3, 4, 5), Seq(6)))
.flatMapMerge(5, m => Source.single(m)
.mapConcat(identity)
.via(subFlow)
.map(Success(_))
.recover { case t: Throwable => Failure(t) }
.collect { cas
Regarding that suggestion, here is a code sample on how you might
accomplish the case of a graph stage that registers for updates from an
actor:
https://github.com/Keenworks/SampleActorStage
Curt Siffert
On Thursday, June 8, 2017 at 4:27:43 AM UTC-7, Akka Team wrote:
>
> One way would be mapAs
Hello Patrik,
I am trying to explore the tradeoffs of instantiating a new routee when
there is overhead of state reconciliation. In my application, routees
themselves can be CPU intensive, and as a result distributing the load
across multiple machine improves performance (especially when we have a
Source.actorRef and Sink.actorRef both allows for integration with actors
without custom graph stages, so you could use those to interact with
DistributedPubSub in various ways. If you have special needs to can likely
use the actor integration in GraphStage as described here in the docs:
http://doc
When re-configuring the netty execution context you must make sure that the
used execution context has enough threads for netty, in newer versions of
Akka you should also see this warning hinting about that:
WARNING: Failed to get all worker threads ready within 10 second(s). Make
sure to specify
There is no max-time-to-live for a connection,
only akka.http.host-connection-pool.idle-timeout but that requires there to
be no requests going through the connection for a timeout before it is
terminated.
I'd expect that when you deploy the new version, the old version get
undeployed and those co
One way would be mapAsync(1)(elem =>
ask-actor-and-combine-elem-with-token). If asking for every element is too
expensive you could make a custom graph stage which asks the actor on
materialisation to get the first token, but then also registers for updates
from the actor, that can be done using th
Arun, please do not post the same question to 3 different channels when you
already were given a response.
If you need to re send a question, please at least link back to where you
asked already.
This was answered in:
https://stackoverflow.com/questions/44366796/no-matching-constructor-found-on-cl
I think resizer is only for local router. Also, I don't understand why
adding more actors should improve performance if the bottleneck is outside
of these actors. Have you tried by just using the local replicator from
each node without any routers. If not, please explain why that is not a
good fit
I am trying to implement websocket using akka actors in play framework.
Actors/FileUploaderActor.scala:
class FileUploaderActor extends Actor{
override def receive: Receive = {
case UploadFile(billerId, filename, subCategory, count, dueDate) =>
val fileOberverActor = ActorSystem().
11 matches
Mail list logo
