public async Task <INetworkStream> NewStream(PeerId peer, IEnumerable <ProtocolId> protocols, CancellationToken cancellationToken) { var pref = PreferredProtocol(peer, protocols); if (pref != "") { return(await NewStream(peer, pref, cancellationToken)); } var protosstrs = protocols.Select(p => p.ToString()).ToArray(); var s = await Network.NewStreamAsync(peer, cancellationToken); if (s == null) { return(null); } var selected = await MultistreamMuxer.SelectOneOfAsync(protosstrs, ((IReadWriter)s).AsSystemStream(), cancellationToken); if (selected == null) { s.Dispose(); return(null); } s.Protocol = new ProtocolId(selected); Peerstore.AddProtocols(peer, selected); //reporter return(s); }
private static void SubTestLs(params string[] protos) { var mr = new MultistreamMuxer(); var mset = new Dictionary <string, bool>(); foreach (var proto in protos) { mr.AddHandler(proto, null); mset.Add(proto, true); } using (var buf = new MemoryStream()) { mr.Ls(buf); buf.Seek(0, SeekOrigin.Begin); ulong n; var count = Binary.Varint.Read(buf, out n); Assert.Equal((int)n, buf.Length - count); ulong nitems; Binary.Varint.Read(buf, out nitems); Assert.Equal((int)nitems, protos.Length); for (var i = 0; i < (int)nitems; i++) { var token = MultistreamMuxer.ReadNextToken(buf); Assert.True(mset.ContainsKey(token)); } Assert.Equal(buf.Position, buf.Length); } }
public Task Async_TestSelectFails() { return(UsePipeWithMuxerAsync(async(a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); mux.NegotiateAsync(a, CancellationToken.None); await Assert.ThrowsAsync <NotSupportedException>(() => MultistreamMuxer.SelectOneOfAsync(new[] { "/d", "/e" }, b, CancellationToken.None)); })); }
public void TestAddHandlerOverride() { UsePipeWithMuxer((a, b, mux) => { mux.AddHandler("/foo", (p, s) => throw new XunitException("should not get executed")); mux.AddHandler("/foo", (p, s) => true); var task = Task.Factory.StartNew(() => MultistreamMuxer.SelectProtoOrFail("/foo", a)); Assert.True(mux.Handle(b)); Assert.True(task.Wait(500)); }, verify: true); }
public void TestSelectFails() { UsePipeWithMuxer((a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); Task.Factory.StartNew(() => mux.Negotiate(a)); Assert.Throws <NotSupportedException>(() => MultistreamMuxer.SelectOneOf(new[] { "/d", "/e" }, b)); }); }
public Task TestAddSyncAndAsyncHandlers() { return(UsePipeWithMuxerAsync(async(a, b, mux) => { mux.AddHandler("/foo", asyncHandle: (p, s, c) => Task.FromResult(true)); var selectTask = MultistreamMuxer.SelectProtoOrFailAsync("/foo", a, CancellationToken.None); var result = await mux.HandleAsync(b, CancellationToken.None); await selectTask; Assert.True(result); }, verify: true)); }
public Task Async_TestProtocolNegotation() { return(UsePipeWithMuxerAsync(async(a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); var negotiator = mux.NegotiateAsync(a, CancellationToken.None); await MultistreamMuxer.SelectProtoOrFailAsync("/a", b, CancellationToken.None); var protocol = (await negotiator).Protocol; Assert.Equal("/a", protocol); }, verify: true)); }
public void TestProtocolNegotation() { UsePipeWithMuxer((a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); var negotiator = Task.Factory.StartNew(() => mux.Negotiate(a)); MultistreamMuxer.SelectProtoOrFail("/a", b); var result = Task.WhenAny(negotiator, Task.Delay(500)).Result; Assert.True(result == negotiator); Assert.Equal("/a", negotiator.Result.Protocol); }, verify: true); }
public Task Async_TestSelectOne() { return(UsePipeWithMuxerAsync(async(a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); var negotiator = mux.NegotiateAsync(a, CancellationToken.None); await MultistreamMuxer.SelectOneOfAsync(new[] { "/d", "/e", "/c" }, b, CancellationToken.None); var result = await Task.WhenAny(negotiator, Task.Delay(500)); Assert.Equal(negotiator, result); Assert.Equal("/c", negotiator.Result.Protocol); }, verify: true)); }
public void TestHandleFunc() { UsePipeWithMuxer((a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", (p, s) => { Assert.Equal("/c", p); return(true); })); var task = Task.Factory.StartNew(() => MultistreamMuxer.SelectProtoOrFail("/c", a)); Assert.True(mux.Handle(b)); Assert.True(task.Wait(500)); }, verify: true); }
public void TestRemoveProtocol() { var mux = new MultistreamMuxer(); mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); var protos = mux.Protocols.ToList(); protos.Sort(); Assert.Equal(protos, new[] { "/a", "/b", "/c" }); mux.RemoveHandler("/b"); protos = mux.Protocols.ToList(); protos.Sort(); Assert.Equal(protos, new[] { "/a", "/c" }); }
public BasicHost(INetwork network, BasicHostOptions options = 0) { Network = network; Mux = new MultistreamMuxer(); _ids = new IdService(this); var handle = new Action <INetworkStream>(s => Mux.Handle(((IReadWriteCloser)s).AsSystemStream())); //relay service //reporter if (options.HasFlag(BasicHostOptions.NatPortMap)) { _nat = new NatManager(this); } network.SetConnectionHandler(NewConnectionHandler); network.SetStreamHandler(NewStreamHandler); }
public Task Async_TestSelectOneAndWrite() { return(UsePipeWithMuxerAsync(async(a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); var task = Task.Factory.StartNew(async() => { var selected = await mux.NegotiateAsync(a, CancellationToken.None); Assert.Equal("/c", selected.Protocol); }); var sel = await MultistreamMuxer.SelectOneOfAsync(new[] { "/d", "/e", "/c" }, b, CancellationToken.None); Assert.Equal("/c", sel); Assert.True(task.Wait(500)); }, verify: true)); }
public void TestSelectOneAndWrite() { UsePipeWithMuxer((a, b, mux) => { mux.AddHandler(new TestHandler("/a", null)); mux.AddHandler(new TestHandler("/b", null)); mux.AddHandler(new TestHandler("/c", null)); var task = Task.Factory.StartNew(() => { var selected = mux.Negotiate(a); Assert.Equal("/c", selected.Protocol); }); var sel = MultistreamMuxer.SelectOneOf(new[] { "/d", "/e", "/c" }, b); Assert.Equal("/c", sel); Assert.True(task.Wait(500)); }, verify: true); }
public void IdentifyConnection(INetworkConnection connection) { TaskCompletionSource <bool> tcs; if (_current.TryGetValue(connection, out tcs)) { tcs.Task.Wait(); return; } tcs = new TaskCompletionSource <bool>(); _current.TryAdd(connection, tcs); try { using (var s = connection.NewStream()) { s.Protocol = Id; //wrap reporter MultistreamMuxer.SelectProtoOrFail(Id, ((IReadWriter)s).AsSystemStream()); ResponseHandler(s); _current.TryRemove(connection, out tcs); } } catch (Exception e) { tcs.TrySetException(e); } finally { tcs.TrySetResult(true); } }