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);
}
}
