public async Task Issue_4580_EmptyByteStringCausesPipeToBeClosed()
{
var serverPipe = new NamedPipeServerStream("unique-pipe-name", PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 20, 20);
var serverPipeConnectionTask = serverPipe.WaitForConnectionAsync();
var clientPipe = new NamedPipeClientStream(".", "unique-pipe-name", PipeDirection.In, PipeOptions.Asynchronous);
clientPipe.Connect();
await serverPipeConnectionTask;
var cnt = 0;
var writeToStreamTask = Source.From(Enumerable.Range(0, 100))
.Select(i => ByteString.FromString(i.ToString()))
.Select(bs => cnt++ == 10 ? ByteString.Empty : bs) // ByteString.Empty.ToArray() failed in original bug
.ToMaterialized(StreamConverters.FromOutputStream(() => serverPipe), Keep.Right)
.Run(Materializer);
var result = new List<string>();
var readFromStreamTask = StreamConverters.FromInputStream(() => clientPipe, 1)
.RunForeach(bs => result.Add(bs.ToString(Encoding.ASCII)), Materializer);
await Task.WhenAll(writeToStreamTask, readFromStreamTask);
var expected = Enumerable.Range(0, 100)
.SelectMany(i => i == 10 ? Array.Empty<string>() : i.ToString().Select(c => c.ToString()));
expected.SequenceEqual(result).ShouldBeTrue();
}
public override IPublisher <ByteString> CreatePublisher(long elements)
{
return(StreamConverters.FromInputStream(() => new InputStream())
.WithAttributes(ActorAttributes.CreateDispatcher("akka.test.stream-dispatcher"))
.Take(elements)
.RunWith(Sink.AsPublisher <ByteString>(false), Materializer));
}
public void OutputStreamSource_must_not_block_flushes_when_buffer_is_empty()
{
this.AssertAllStagesStopped(() =>
{
var t = StreamConverters.AsOutputStream()
.ToMaterialized(this.SinkProbe <ByteString>(), Keep.Both)
.Run(_materializer);
var outputStream = t.Item1;
var probe = t.Item2;
var s = probe.ExpectSubscription();
outputStream.Write(_bytesArray, 0, _byteString.Count);
var f = Task.Run(() =>
{
outputStream.Flush();
return(NotUsed.Instance);
});
s.Request(1);
ExpectSuccess(f, NotUsed.Instance);
probe.ExpectNext(_byteString);
var f2 = Task.Run(() =>
{
outputStream.Flush();
return(NotUsed.Instance);
});
ExpectSuccess(f2, NotUsed.Instance);
outputStream.Dispose();
probe.ExpectComplete();
}, _materializer);
}
public void OutputStreamSource_must_block_writes_when_buffer_is_full()
{
this.AssertAllStagesStopped(() =>
{
var t = StreamConverters.AsOutputStream()
.WithAttributes(Attributes.CreateInputBuffer(16, 16))
.ToMaterialized(this.SinkProbe <ByteString>(), Keep.Both)
.Run(_materializer);
var outputStream = t.Item1;
var probe = t.Item2;
var s = probe.ExpectSubscription();
for (var i = 1; i <= 16; i++)
{
outputStream.Write(_bytesArray, 0, _byteString.Count);
}
//blocked call
var f = Task.Run(() =>
{
outputStream.Write(_bytesArray, 0, _byteString.Count);
return(NotUsed.Instance);
});
ExpectTimeout(f, Timeout);
probe.ExpectNoMsg(TimeSpan.MinValue);
s.Request(17);
ExpectSuccess(f, NotUsed.Instance);
probe.ExpectNextN(Enumerable.Repeat(_byteString, 17).ToList());
outputStream.Dispose();
probe.ExpectComplete();
}, _materializer);
}
public void OutputStreamSource_must_block_flush_call_until_send_all_buffer_to_downstream()
{
this.AssertAllStagesStopped(() =>
{
var t = StreamConverters.AsOutputStream()
.ToMaterialized(this.SinkProbe <ByteString>(), Keep.Both)
.Run(_materializer);
var outputStream = t.Item1;
var probe = t.Item2;
var s = probe.ExpectSubscription();
outputStream.Write(_bytesArray, 0, _bytesArray.Length);
var f = Task.Run(() =>
{
outputStream.Flush();
return(NotUsed.Instance);
});
ExpectTimeout(f, Timeout);
probe.ExpectNoMsg(TimeSpan.MinValue);
s.Request(1);
ExpectSuccess(f, NotUsed.Instance);
probe.ExpectNext(_byteString);
outputStream.Dispose();
probe.ExpectComplete();
}, _materializer);
}
public static GraphBuilder CreateParsingGraphBuilder(Stream stream, Func <AkkaIO.ByteString, ModuleLogMessageData> parserFunc)
{
var source = StreamConverters.FromInputStream(() => stream);
var graph = source
.Via(FramingFlow)
.Select(parserFunc)
.MapMaterializedValue(_ => AkkaNet.NotUsed.Instance);
return(new GraphBuilder(graph));
}
public void InputStreamSink_should_throw_from_inputstream_read_if_terminated_abruptly()
{
var materializer = ActorMaterializer.Create(Sys);
var probe = this.CreatePublisherProbe <ByteString>();
var inputStream = Source.FromPublisher(probe).RunWith(StreamConverters.AsInputStream(), materializer);
materializer.Shutdown();
inputStream.Invoking(i => i.ReadByte()).Should().Throw <AbruptTerminationException>();
}
public void OutputStreamSink_must_complete_materialized_value_with_the_error()
{
this.AssertAllStagesStopped(() =>
{
var completion = Source.Failed <ByteString>(new Exception("Boom!"))
.RunWith(StreamConverters.FromOutputStream(() => new OutputStream()), _materializer);
AssertThrows <AbruptIOTerminationException>(completion.Wait);
}, _materializer);
}
public void OutputStreamSink_must_close_underlying_stream_when_error_received()
{
this.AssertAllStagesStopped(() =>
{
var p = CreateTestProbe();
Source.Failed <ByteString>(new Exception("Boom!"))
.RunWith(StreamConverters.FromOutputStream(() => new CloseOutputStream(p)), _materializer);
p.ExpectMsg("closed");
}, _materializer);
}
public void InputStreamSource_must_read_bytes_from_InputStream()
{
this.AssertAllStagesStopped(() =>
{
var f = StreamConverters.FromInputStream(() => new ListInputStream(new[] { "a", "b", "c" }))
.RunWith(Sink.First <ByteString>(), _materializer);
f.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
f.Result.ShouldBeEquivalentTo(ByteString.FromString("abc"));
}, _materializer);
}
public void OutputStreamSink_must_close_underlying_stream_when_completion_received()
{
this.AssertAllStagesStopped(() =>
{
var p = CreateTestProbe();
Source.Empty <ByteString>()
.RunWith(StreamConverters.FromOutputStream(() => new CompletionOutputStream(p)), _materializer);
p.ExpectMsg("closed");
}, _materializer);
}
public void InputStreamSink_should_fail_to_materialize_with_zero_sized_input_buffer()
{
Action a = () => Source.Single(_byteString).RunWith(StreamConverters.AsInputStream(Timeout).WithAttributes(Attributes.CreateInputBuffer(0, 0)), _materializer);
a.ShouldThrow<ArgumentException>();
/*
With Source.single we test the code path in which the sink
itself throws an exception when being materialized. If
Source.empty is used, the same exception is thrown by
Materializer.
*/
}
public void Setup(BenchmarkContext context)
{
_actorSystem = ActorSystem.Create("FileSourcesBenchmark");
_materializer = _actorSystem.Materializer();
_file = CreateFile();
_fileChannelSource = FileIO.FromFile(_file, BufferSize);
_fileInputStreamSource = StreamConverters.FromInputStream(() => File.OpenRead(_file.FullName), BufferSize);
_ioSourceLinesIterator = Source.FromEnumerator(() => File.ReadLines(_file.FullName).Select(ByteString.FromString).GetEnumerator());
}
public void InputStreamSink_should_read_bytes_from_input_stream()
{
this.AssertAllStagesStopped(() =>
{
var inputStream = Source.Single(_byteString).RunWith(StreamConverters.AsInputStream(), _materializer);
var result = ReadN(inputStream, _byteString.Count);
inputStream.Close();
result.Item1.Should().Be(_byteString.Count);
result.Item2.Should().BeEquivalentTo(_byteString);
}, _materializer);
}
public static IRunnableGraph <Task <IImmutableList <string> > > BuildMaterializedGraph(Stream stream)
{
var source = StreamConverters.FromInputStream(() => stream);
var seqSink = Sink.Seq <string>();
IRunnableGraph <Task <IImmutableList <string> > > graph = source
.Via(FramingFlow)
.Select(b => b.Slice(8))
.Select(b => b.ToString(Encoding.UTF8))
.ToMaterialized(seqSink, Keep.Right);
return(graph);
}
public void InputStreamSink_should_return_less_than_was_expected_when_data_source_has_provided_some_but_not_enough_data()
{
this.AssertAllStagesStopped(() =>
{
var inputStream = Source.Single(_byteString).RunWith(StreamConverters.AsInputStream(), _materializer);
var arr = new byte[_byteString.Count + 1];
inputStream.Read(arr, 0, arr.Length).Should().Be(arr.Length - 1);
inputStream.Close();
ByteString.Create(arr).ShouldBeEquivalentTo(_byteString.Concat(ByteString.Create(new byte[] { 0 })));
}, _materializer);
}
public void InputStreamSink_should_work_when_more_bytes_pulled_from_input_stream_than_available()
{
this.AssertAllStagesStopped(() =>
{
var inputStream = Source.Single(_byteString).RunWith(StreamConverters.AsInputStream(), _materializer);
var r = ReadN(inputStream, _byteString.Count * 2);
r.Item1.Should().Be(_byteString.Count);
r.Item2.ShouldBeEquivalentTo(_byteString);
inputStream.Close();
}, _materializer);
}
public void InputStreamSink_should_throw_exception_when_call_read_With_wrong_parameters()
{
this.AssertAllStagesStopped(() =>
{
var inputStream = Source.Single(_byteString).RunWith(StreamConverters.AsInputStream(), _materializer);
var buf = new byte[3];
Action(() => inputStream.Read(buf, -1, 2)).ShouldThrow <ArgumentException>();
Action(() => inputStream.Read(buf, 0, 5)).ShouldThrow <ArgumentException>();
Action(() => inputStream.Read(new byte[0], 0, 1)).ShouldThrow <ArgumentException>();
Action(() => inputStream.Read(buf, 0, 0)).ShouldThrow <ArgumentException>();
}, _materializer);
}
public void InputStreamSource_must_emit_as_soon_as_read()
{
this.AssertAllStagesStopped(() =>
{
var latch = new TestLatch(1);
var probe = StreamConverters.FromInputStream(() => new EmittedInputStream(latch), chunkSize: 1)
.RunWith(this.SinkProbe <ByteString>(), _materializer);
probe.Request(4);
probe.ExpectNext(ByteString.FromString("M"));
latch.CountDown();
probe.ExpectComplete();
}, _materializer);
}
public void InputStreamSink_should_return_minus_1_when_read_after_stream_is_completed()
{
this.AssertAllStagesStopped(() =>
{
var inputStream = Source.Single(_byteString).RunWith(StreamConverters.AsInputStream(), _materializer);
var r = ReadN(inputStream, _byteString.Count);
r.Item1.Should().Be(_byteString.Count);
r.Item2.ShouldBeEquivalentTo(_byteString);
inputStream.ReadByte().Should().Be(-1);
inputStream.Close();
}, _materializer);
}
public void InputStreamSink_should_read_next_byte_as_an_int_from_InputStream()
{
this.AssertAllStagesStopped(() =>
{
var bytes = ByteString.CopyFrom(new byte[] { 0, 100, 200, 255 });
var inputStream = Source.Single(bytes).RunWith(StreamConverters.AsInputStream(), _materializer);
Enumerable.Range(1, 5)
.Select(_ => inputStream.ReadByte())
.Should().BeEquivalentTo(new[] { 0, 100, 200, 255, -1 });
inputStream.Dispose();
}, _materializer);
}
public void OutputStreamSource_must_fail_to_materialize_with_zero_sized_input_buffer()
{
new Action(
() =>
StreamConverters.AsOutputStream(Timeout)
.WithAttributes(Attributes.CreateInputBuffer(0, 0))
.RunWith(Sink.First <ByteString>(), _materializer)).ShouldThrow <ArgumentException>();
/*
* With Sink.First we test the code path in which the source
* itself throws an exception when being materialized. If
* Sink.Ignore is used, the same exception is thrown by
* Materializer.
*/
}
public async Task <IReadOnlyList <string> > GetText(Stream stream)
{
Preconditions.CheckNotNull(stream, nameof(stream));
var source = StreamConverters.FromInputStream(() => stream);
var seqSink = Sink.Seq <string>();
IRunnableGraph <Task <IImmutableList <string> > > graph = source
.Via(FramingFlow)
.Select(b => b.Slice(8))
.Select(b => b.ToString(Encoding.UTF8))
.ToMaterialized(seqSink, Keep.Right);
IImmutableList <string> result = await graph.Run(this.materializer);
return(result);
}
public async Task <IReadOnlyList <ModuleLogMessage> > GetMessages(Stream stream, string moduleId)
{
Preconditions.CheckNotNull(stream, nameof(stream));
Preconditions.CheckNonWhiteSpace(moduleId, nameof(moduleId));
var source = StreamConverters.FromInputStream(() => stream);
var seqSink = Sink.Seq <ModuleLogMessage>();
IRunnableGraph <Task <IImmutableList <ModuleLogMessage> > > graph = source
.Via(FramingFlow)
.Select(b => this.logMessageParser.Parse(b, moduleId))
.ToMaterialized(seqSink, Keep.Right);
IImmutableList <ModuleLogMessage> result = await graph.Run(this.materializer);
return(result);
}
public void OutputStreamSource_must_throw_error_when_writer_after_stream_is_closed()
{
this.AssertAllStagesStopped(() =>
{
var t = StreamConverters.AsOutputStream()
.ToMaterialized(this.SinkProbe <ByteString>(), Keep.Both)
.Run(_materializer);
var outputStream = t.Item1;
var probe = t.Item2;
probe.ExpectSubscription();
outputStream.Dispose();
probe.ExpectComplete();
outputStream.Invoking(s => s.Write(_bytesArray, 0, _byteString.Count)).ShouldThrow <IOException>();
}, _materializer);
}
public void InputStreamSink_should_throw_error_when_reactive_stream_is_closed()
{
this.AssertAllStagesStopped(() =>
{
var t = this.SourceProbe <ByteString>()
.ToMaterialized(StreamConverters.AsInputStream(), Keep.Both)
.Run(_materializer);
var probe = t.Item1;
var inputStream = t.Item2;
probe.SendNext(_byteString);
inputStream.Close();
probe.ExpectCancellation();
Action block = () => inputStream.Read(new byte[1], 0, 1);
block.ShouldThrow <IOException>();
}, _materializer);
}
public void OutputStreamSource_must_read_bytes_from_OutputStream()
{
this.AssertAllStagesStopped(() =>
{
var t = StreamConverters.AsOutputStream()
.ToMaterialized(this.SinkProbe <ByteString>(), Keep.Both)
.Run(_materializer);
var outputStream = t.Item1;
var probe = t.Item2;
var s = probe.ExpectSubscription();
outputStream.Write(_bytesArray, 0, _bytesArray.Length);
s.Request(1);
probe.ExpectNext(_byteString);
outputStream.Dispose();
probe.ExpectComplete();
}, _materializer);
}
public void InputStreamSink_should_work_when_read_chunks_smaller_then_stream_chunks()
{
this.AssertAllStagesStopped(() =>
{
var bytes = RandomByteString(10);
var inputStream = Source.Single(bytes).RunWith(StreamConverters.AsInputStream(), _materializer);
while (bytes.NonEmpty)
{
var expected = bytes.Take(3);
bytes = bytes.Drop(3);
var result = ReadN(inputStream, 3);
result.Item1.Should().Be(expected.Count);
result.Item2.ShouldBeEquivalentTo(expected);
}
inputStream.Close();
}, _materializer);
}
public void InputStreamSink_should_use_dedicated_default_blocking_io_dispatcher_by_default()
{
this.AssertAllStagesStopped(() =>
{
var sys = ActorSystem.Create("dispatcher-testing", Utils.UnboundedMailboxConfig);
var materializer = ActorMaterializer.Create(sys);
try
{
this.SourceProbe <ByteString>().RunWith(StreamConverters.AsInputStream(), materializer);
(materializer as ActorMaterializerImpl).Supervisor.Tell(StreamSupervisor.GetChildren.Instance, TestActor);
var children = ExpectMsg <StreamSupervisor.Children>().Refs;
var actorRef = children.First(c => c.Path.ToString().Contains("inputStreamSink"));
Utils.AssertDispatcher(actorRef, "akka.stream.default-blocking-io-dispatcher");
}
finally
{
Shutdown(sys);
}
}, _materializer);
}
public void OutputStreamSource_must_not_leave_blocked_threads()
{
var tuple =
StreamConverters.AsOutputStream(Timeout)
.ToMaterialized(this.SinkProbe <ByteString>(), Keep.Both)
.Run(_materializer);
var outputStream = tuple.Item1;
var probe = tuple.Item2;
var sub = probe.ExpectSubscription();
// triggers a blocking read on the queue
// and then cancel the stage before we got anything
sub.Request(1);
sub.Cancel();
//we need to make sure that the underling BlockingCollection isn't blocked after the stream has finished,
//the jvm way isn't working so we need to use reflection and check the collection directly
//def threadsBlocked =
//ManagementFactory.getThreadMXBean.dumpAllThreads(true, true).toSeq
// .filter(t => t.getThreadName.startsWith("OutputStreamSourceSpec") &&
//t.getLockName != null &&
//t.getLockName.startsWith("java.util.concurrent.locks.AbstractQueuedSynchronizer"))
//awaitAssert(threadsBlocked should === (Seq()), 3.seconds)
var bindFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static;
var field = typeof(OutputStreamAdapter).GetField("_dataQueue", bindFlags);
var blockingCollection = field.GetValue(outputStream) as BlockingCollection <ByteString>;
//give the stage enough time to finish, otherwise it may take the hello message
Thread.Sleep(1000);
// if a take operation is pending inside the stage it will steal this one and the next take will not succeed
blockingCollection.Add(ByteString.FromString("hello"));
ByteString result;
blockingCollection.TryTake(out result, TimeSpan.FromSeconds(3)).Should().BeTrue();
result.ToString().Should().Be("hello");
}
