public DataReceiver() { TimeSpan throttle = TimeSpan.FromMilliseconds(100); string RegistryConnectionString = "akka.tcp://DataSourceActorSystem@" + serverURL + ":" + serverPort + "/user/DataSourceActor"; ColourConsole.WriteLineMagenta("Sending ConnectMessage"); ConnectMessage requestAccess = Context.ActorSelection(RegistryConnectionString).Ask <ConnectMessage>(new ConnectMessage(Self)).Result;//Changes DataSourceActorRef = requestAccess.ActorRef; Receive <PrepareUpload>(prepare => { ColourConsole.WriteLineMagenta("Sending MeasurementsSinkReady"); // obtain a sink you want to offer var sink = LogsSinksFor(prepare.Id); // materialize sink ref (remote is source data for us) StreamRefs.SinkRef <string>() .Throttle(1, throttle, 1, ThrottleMode.Shaping) .To(sink) .Run(Context.System.Materializer()) //I suspect the issue is within the "PipeTo" method, The remote actor never receives the "MeasurementsSinkReady" message .PipeTo(DataSourceActorRef, success: sinkRef => new MeasurementsSinkReady(prepare.Id, sinkRef)); }); }
public LogsSourceActor() { Receive <RequestLogs>(req => { var streamLogs = Source.From(Enumerable.Range(1, 5)).Select(i => i.ToString()); streamLogs.ToMaterialized(StreamRefs.SourceRef <string>(), Keep.Right) .Run(Context.System.Materializer()) .PipeTo(Sender, success: sourceRef => new LogsOffer(req.StreamId, sourceRef)); }); }
public DataSource() { Receive <RequestLogs>(request => { // create a source StreamLogs(request.StreamId) // materialize it using stream refs .RunWith(StreamRefs.SourceRef <string>(), Context.System.Materializer()) // and send to sender .PipeTo(Sender, success: sourceRef => new LogsOffer(request.StreamId, sourceRef)); }); }
public DataReceiver() { Receive <PrepareUpload>(prepare => { // obtain a source you want to offer var sink = LogsSinksFor(prepare.Id); // materialize sink ref (remote is source data for us) StreamRefs.SinkRef <string>() .To(sink) .Run(Context.System.Materializer()) .PipeTo(Sender, success: sinkRef => sinkRef); }); }
public ProducerActor(string data) { _data = data; Receive <RequestStream>(request => { // create a source StreamLogs() // materialize it using stream refs .RunWith(StreamRefs.SourceRef <string>(), Context.System.Materializer()) // and send to sender .PipeTo(Sender, success: sourceRef => new EnvelopedStream(sourceRef)); }); Receive <string>(_ => Sender.Tell("pong")); }
public async Task StreamRefThrowsSubscriptionTimeout() { var ex = await Assert.ThrowsAsync <RemoteStreamRefActorTerminatedException>(async delegate { TimeSpan subscriptionTimeout = TimeSpan.FromSeconds(3); var sourceRef = await Source .Single("NeverConsumedMsg") .RunWith(StreamRefs.SourceRef <string>() .AddAttributes(StreamRefAttributes.CreateSubscriptionTimeout(subscriptionTimeout)), Sys.Materializer()); Task.Delay(subscriptionTimeout + TimeSpan.FromSeconds(1)).Wait(); await sourceRef.Source.RunWith(Sink.Ignore <string>(), Sys.Materializer()); }); // ex.InnerException.Should().BeOfType<StreamRefSubscriptionTimeoutException>(); // null inside }
public MeasurementsTargetActor(int windowSize, IActorRef forwardActorRef) { _forwardActorRef = forwardActorRef; _thisActorRef = Context.Self; _avgSink = Flow .Create <double>() .WatchTermination(Keep.Right) .Sliding(windowSize) .Collect(win => win.Average()) .AlsoTo(Sink.ForEach <double>(avg => _forwardActorRef.Tell(avg))) .To(Sink.ForEach <double>(avg => _thisActorRef.Tell(avg))); // Calling Self here, uses Context of the stream instead of the actor! Receive <PrepareUpload>(pu => { var t = StreamRefs .SinkRef <double>() .ToMaterialized(_avgSink, Keep.Both) .Run(Context.System.Materializer()); t.Item1.PipeTo(Sender, success: sr => new MeasurementsSinkReady(pu.StreamId, sr)); _streamTask = t.Item2; }); Receive <double>(d => { _avg = d; }); Receive <string>(str => str == "notify when stream completes", delegate { _streamTask.PipeTo(Sender, success: () => StreamCompleted.Instance); }); Receive <string>(str => str == "get avg", delegate { Sender.Tell(_avg); }); }
public async Task SinkRef_declared_inside_poco_must_be_serialized_properly() { var actor = Sys.ActorOf(Props.Create <DataSource>()); var sink = Sink.ForEach <string>(str => { Output.WriteLine(str); }); var sinkRef = await StreamRefs.SinkRef <string>() .Throttle(1, TimeSpan.FromMilliseconds(100), 1, ThrottleMode.Shaping) .To(sink) .Run(Sys.Materializer()); var message = new MeasurementsSinkReady(sinkRef); var serializer = Sys.Serialization.FindSerializerFor(message); byte[] serialized = null; serializer.Invoking(s => serialized = s.ToBinary(message)).ShouldNotThrow(); object deserialized = null; serializer.Invoking(s => deserialized = s.FromBinary <MeasurementsSinkReady>(serialized)).ShouldNotThrow(); deserialized.Should().BeOfType <MeasurementsSinkReady>(); }
public DataSource() { TimeSpan throttle = TimeSpan.FromMilliseconds(1); string RegistryConnectionString = "akka.tcp://ReceiverActorSystem@" + serverURL + ":" + serverPort + "/user/DataReceiverActor"; ColourConsole.WriteLineMagenta("Sending ConnectMessage"); ConnectMessage requestAccess = Context.ActorSelection(RegistryConnectionString).Ask <ConnectMessage>(new ConnectMessage(Self)).Result;//Changes DataReceiverActorRef = requestAccess.ActorRef; Receive <RequestLogs>(request => { ColourConsole.WriteLineMagenta("Sending RequestLogs"); // create a source StreamLogs(request.StreamId) //Throttle outbound stream .Throttle(1, throttle, 1, ThrottleMode.Shaping) // materialize it using stream refs .RunWith(StreamRefs.SourceRef <string>(), Context.System.Materializer()) // and send to sink .PipeTo(DataReceiverActorRef, success: sourceRef => new LogsOffer(request.StreamId, sourceRef)); //DataReceiverActorRef was Sender }); }
protected override bool Receive(object message) { switch (message) { case "give": { /* * Here we're able to send a source to a remote recipient * For them it's a Source; for us it is a Sink we run data "into" */ var source = Source.From(new[] { "hello", "world" }); var aref = source.RunWith(StreamRefs.SourceRef <string>(), _materializer); aref.PipeTo(Sender); return(true); } case "give-infinite": { var source = Source.From(Enumerable.Range(1, int.MaxValue).Select(i => "ping-" + i)); var t = source.ToMaterialized(StreamRefs.SourceRef <string>(), Keep.Right).Run(_materializer); t.PipeTo(Sender); return(true); } case "give-fail": { var r = Source.Failed <string>(new Exception("Boom!")) .RunWith(StreamRefs.SourceRef <string>(), _materializer); r.PipeTo(Sender); return(true); } case "give-complete-asap": { var r = Source.Empty <string>().RunWith(StreamRefs.SourceRef <string>(), _materializer); r.PipeTo(Sender); return(true); } case "give-subscribe-timeout": { var r = Source.Repeat("is anyone there?") .ToMaterialized(StreamRefs.SourceRef <string>(), Keep.Right) .WithAttributes(StreamRefAttributes.CreateSubscriptionTimeout(TimeSpan.FromMilliseconds(500))) .Run(_materializer); r.PipeTo(Sender); return(true); } case "receive": { /* * We write out code, knowing that the other side will stream the data into it. * For them it's a Sink; for us it's a Source. */ var sink = StreamRefs.SinkRef <string>().To(Sink.ActorRef <string>(_probe, "<COMPLETE>")) .Run(_materializer); sink.PipeTo(Sender); return(true); } case "receive-ignore": { var sink = StreamRefs.SinkRef <string>().To(Sink.Ignore <string>()).Run(_materializer); sink.PipeTo(Sender); return(true); } case "receive-subscribe-timeout": { var sink = StreamRefs.SinkRef <string>() .WithAttributes(StreamRefAttributes.CreateSubscriptionTimeout(TimeSpan.FromMilliseconds(500))) .To(Sink.ActorRef <string>(_probe, "<COMPLETE>")) .Run(_materializer); sink.PipeTo(Sender); return(true); } case "receive-32": { // var t = StreamRefs.SinkRef<string>() // .ToMaterialized(TestSink.SinkProbe<string>(Context.System), Keep.Both) // .Run(_materializer); // // var sink = t.Item1; // var driver = t.Item2; // Task.Run(() => // { // driver.EnsureSubscription(); // driver.Request(2); // driver.ExpectNext(); // driver.ExpectNext(); // driver.ExpectNoMsg(TimeSpan.FromMilliseconds(100)); // driver.Request(30); // driver.ExpectNextN(30); // // return "<COMPLETED>"; // }).PipeTo(_probe); return(true); } default: return(false); } }