public void TestStringToBytes(string s, string h)
{
var b1 = Hex.Decode(h);
var b2 = Multiaddress.Decode(s).ToBytes();
Assert.Equal(b1, b2);
}
public static void SubtestTransport(ITransport ta, ITransport tb, string addr)
{
var maddr = Multiaddress.Decode(addr);
Assert.That(maddr, Is.Not.Null);
var listener = ta.Listen(maddr);
Assert.That(listener, Is.Not.Null);
var dialer = tb.Dialer(maddr);
Assert.That(dialer, Is.Not.Null);
var accepted = listener.AcceptAsync(CancellationToken.None);
var dialed = dialer.DialAsync(listener.Multiaddress, CancellationToken.None);
Task.WaitAll(accepted, dialed);
var a = accepted.Result;
var b = dialed.Result;
try
{
Assert.DoesNotThrow(() => CheckDataTransfer(a, b));
}
finally
{
a.Dispose();
b.Dispose();
}
}
/// <summary>
///
/// </summary>
/// <param name="address"></param>
/// <param name="key"></param>
/// <param name="collections"></param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task <ThreadId> NewDbFromAdd(string address, string key, IList <Models.CollectionInfo> collections, CancellationToken cancellationToken = default)
{
Multiaddress addr = Multiaddress.Decode(address);
byte[] keyBytes = ThreadKey.FromString(key).Bytes;
NewDBFromAddrRequest request = new()
{
Addr = ByteString.CopyFrom(addr.ToBytes()),
Key = ByteString.CopyFrom(keyBytes)
};
if (collections != null)
{
//TODO: Finish mapping
request.Collections.AddRange(collections.Select(c =>
{
return(_mapper.Map <Grpc.CollectionConfig>(c));
}).ToArray());
}
await _apiClient.NewDBFromAddrAsync(request, headers : _threadContext.Metadata, cancellationToken : cancellationToken);
//TODO: Get the threadID and Address
string threadId = string.Empty;
return(ThreadId.FromString(threadId));
}
private void ConsumeObservedAddress(byte[] observed, INetworkConnection connection)
{
if (observed == null)
{
return;
}
var maddr = Multiaddress.Decode(observed);
if (maddr == null)
{
return;
}
var ifaceaddrs = Host.Network.InterfaceListenAddresses;
if (ifaceaddrs == null)
{
return;
}
if (!ifaceaddrs.Contains(connection.LocalMultiaddress))
{
return;
}
_observedAddresses.Add(maddr, connection.RemoteMultiaddress);
}
public void TestBytesToString(string s1, string h)
{
var b = Hex.Decode(h);
var s2 = Multiaddress.Decode(s1).ToString();
Assert.Equal(s1, s2);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
var token = JToken.Load(reader);
switch (token.Type)
{
case JTokenType.Null:
return(null);
case JTokenType.String:
return(Multiaddress.Decode((string)token));
case JTokenType.Bytes:
return(Multiaddress.Decode((byte[])token));
case JTokenType.Object:
var value = (string)token["$value"];
return(value == null ? null : Multiaddress.Decode(value));
default:
throw new SerializationException("Unknown Multiaddress format");
}
}
public void TestTcpTransportCantListenUtp()
{
var utpa = Multiaddress.Decode("/ip4/127.0.0.1/udp/0/utp");
Assert.That(utpa, Is.Not.Null);
var tpt = new TcpTransport();
Assert.Throws <NotSupportedException>(() => tpt.Listen(utpa));
}
public void Multiaddress_GivenIPv6Udp_ReturnsValidEndPoint()
{
var ma = Multiaddress.Decode("/ip6/::1/udp/1337");
ProtocolType p;
var ep = ma.ToEndPoint(out p);
Assert.Equal(AddressFamily.InterNetworkV6, ep.AddressFamily);
Assert.Equal(IPAddress.IPv6Loopback, ep.Address);
Assert.Equal(1337, ep.Port);
Assert.Equal(ProtocolType.Udp, p);
}
public void Socket_GivenMultiaddress_CreatesSocket()
{
var ma = Multiaddress.Decode("/ip4/127.0.0.1/tcp/1337");
using (var socket = ma.CreateSocket())
{
Assert.Equal(AddressFamily.InterNetwork, socket.AddressFamily);
Assert.Equal(ProtocolType.Tcp, socket.ProtocolType);
Assert.Equal(SocketType.Stream, socket.SocketType);
}
}
public void Multiaddress_GivenIPv4Tcp_ReturnsValidEndPoint()
{
var ma = Multiaddress.Decode("/ip4/127.0.0.1/tcp/1337");
ProtocolType p;
var ep = ma.ToEndPoint(out p);
Assert.Equal(AddressFamily.InterNetwork, ep.AddressFamily);
Assert.Equal(IPAddress.Loopback, ep.Address);
Assert.Equal(1337, ep.Port);
Assert.Equal(ProtocolType.Tcp, p);
}
/// <summary>
///
/// </summary>
/// <param name="dbId">The ID of the database.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task <DBInfo> GetDbInfoAsync(ThreadId dbId, CancellationToken cancellationToken = default)
{
GetDBInfoRequest request = new()
{
DbID = ByteString.CopyFrom(dbId.Bytes)
};
GetDBInfoReply dbInfo = await _apiClient.GetDBInfoAsync(request, headers : _threadContext.Metadata, cancellationToken : cancellationToken);
return(new DBInfo()
{
Key = ThreadKey.FromBytes(dbInfo.Key.ToByteArray()).ToString(),
Addrs = dbInfo.Addrs.Select(addr => Multiaddress.Decode(addr.ToByteArray()).ToString()).ToList()
});
}
public void TestEqual()
{
var m1 = Multiaddress.Decode("/ip4/127.0.0.1/udp/1234");
var m2 = Multiaddress.Decode("/ip4/127.0.0.1/tcp/1234");
var m3 = Multiaddress.Decode("/ip4/127.0.0.1/tcp/1234");
var m4 = Multiaddress.Decode("/ip4/127.0.0.1/tcp/1234");
Assert.NotEqual(m1, m2);
Assert.NotEqual(m2, m1);
Assert.Equal(m2, m3);
Assert.Equal(m3, m2);
Assert.Equal(m1, m1);
Assert.Equal(m2, m4);
Assert.Equal(m4, m3);
}
public void TestGetValue()
{
var a =
Multiaddress.Decode(
"/ip4/127.0.0.1/utp/tcp/5555/udp/1234/utp/ipfs/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP");
Assert.Equal("127.0.0.1", a.Protocols.OfType <IP4>().FirstOrDefault()?.ToString());
Assert.Equal("", a.Protocols.OfType <UTP>().FirstOrDefault()?.ToString());
Assert.Equal("5555", a.Protocols.OfType <TCP>().FirstOrDefault()?.ToString());
Assert.Equal("1234", a.Protocols.OfType <UDP>().FirstOrDefault()?.ToString());
Assert.Equal("QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP", a.Protocols.OfType <IPFS>().FirstOrDefault()?.ToString());
a = Multiaddress.Decode("/ip4/0.0.0.0/unix/a/b/c/d");
Assert.Equal("0.0.0.0", a.Protocols.OfType <IP4>().FirstOrDefault()?.ToString());
Assert.Equal("a/b/c/d", a.Protocols.OfType <Unix>().FirstOrDefault()?.ToString());
}
public void TestBytesSplitAndJoin(string s, params string[] res)
{
var m = Multiaddress.Decode(s);
var split = m.Split().ToArray();
Assert.Equal(split.Length, res.Length);
for (var i = 0; i < split.Length; i++)
{
Assert.Equal(split[i].ToString(), res[i]);
}
var joined = Multiaddress.Join(split);
Assert.Equal(m, joined);
}
public void TestEncapsulate()
{
var m = Multiaddress.Decode("/ip4/127.0.0.1/udp/1234");
var m2 = Multiaddress.Decode("/udp/5678");
var b = m.Encapsulate(m2);
Assert.Equal("/ip4/127.0.0.1/udp/1234/udp/5678", b.ToString());
var m3 = Multiaddress.Decode("/udp/5678");
var c = b.Decapsulate(m3);
Assert.Equal("/ip4/127.0.0.1/udp/1234", c.ToString());
var m4 = Multiaddress.Decode("/ip4/127.0.0.1");
var d = c.Decapsulate(m4);
Assert.Equal("", d.ToString());
}
public void TestConstructFails(string addr)
{
Assert.ThrowsAny <Exception>(() => Multiaddress.Decode(addr));
}
private static Multiaddress Ma(string s) => Multiaddress.Decode(s);
private static Multiaddress[] MakeAddresses(int count) => Enumerable.Range(0, count)
.Select(i => Multiaddress.Decode($"/ip4/127.0.0.1/tcp/{i}")).ToArray();
public void TestAddrMatch()
{
var a = new[]
{
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/2345"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/tcp/2345"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/tcp/2345"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/udp/1234"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/udp/1234"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/ip6/::1"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/ip6/::1"),
Multiaddress.Decode("/ip6/::1/tcp/1234"),
Multiaddress.Decode("/ip6/::1/tcp/2345"),
Multiaddress.Decode("/ip6/::1/tcp/1234/tcp/2345"),
Multiaddress.Decode("/ip6/::1/tcp/1234/tcp/2345"),
Multiaddress.Decode("/ip6/::1/tcp/1234/udp/1234"),
Multiaddress.Decode("/ip6/::1/tcp/1234/udp/1234"),
Multiaddress.Decode("/ip6/::1/tcp/1234/ip6/::1"),
Multiaddress.Decode("/ip6/::1/tcp/1234/ip6/::1"),
};
TestAddr(a[0], a, new []
{
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/2345"),
});
TestAddr(a[2], a, new[]
{
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/tcp/2345"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/tcp/2345"),
});
TestAddr(a[4], a, new[]
{
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/udp/1234"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/udp/1234"),
});
TestAddr(a[6], a, new[]
{
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/ip6/::1"),
Multiaddress.Decode("/ip4/1.2.3.4/tcp/1234/ip6/::1"),
});
TestAddr(a[8], a, new[]
{
Multiaddress.Decode("/ip6/::1/tcp/1234"),
Multiaddress.Decode("/ip6/::1/tcp/2345"),
});
TestAddr(a[10], a, new[]
{
Multiaddress.Decode("/ip6/::1/tcp/1234/tcp/2345"),
Multiaddress.Decode("/ip6/::1/tcp/1234/tcp/2345"),
});
TestAddr(a[12], a, new[]
{
Multiaddress.Decode("/ip6/::1/tcp/1234/udp/1234"),
Multiaddress.Decode("/ip6/::1/tcp/1234/udp/1234"),
});
TestAddr(a[14], a, new[]
{
Multiaddress.Decode("/ip6/::1/tcp/1234/ip6/::1"),
Multiaddress.Decode("/ip6/::1/tcp/1234/ip6/::1"),
});
}
public void TestThinWaist(string addr, bool expected)
{
var m = Multiaddress.Decode(addr);
Assert.Equal(expected, m.IsThinWaist());
}
public void TestConstructSucceeds(string addr)
{
Multiaddress.Decode(addr);
}