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