void ThenTheAllAddressShouldBeLocalhost() {
NetworkAddress addr = new NetworkAddress("127.0.0.1");
Assert.AreEqual(addr, _validAddr1);
Assert.AreEqual(addr, _validAddr2);
Assert.AreEqual(addr, _validAddr3);
Assert.AreEqual(addr, _comparedAddr);
}
public void PeerConnectorConnect_WithConnectPeersSpecified_CanStart()
{
var peerAddressManager = new PeerAddressManager();
var ipAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var networkAddressConnectNode = new NetworkAddress(ipAddressThree, 80);
var nodeSettings = new NodeSettings
{
ConnectionManager = new Configuration.Settings.ConnectionManagerSettings()
};
nodeSettings.ConnectionManager.Connect.Add(networkAddressConnectNode.Endpoint);
var connector = this.CreatePeerConnectorConnectNode(nodeSettings, peerAddressManager);
Assert.True(connector.CanStartConnect);
}
public void CanSerializeDeserializePeerTableAfterBIP155()
{
AddressManager addrman = new AddressManager();
var netaddr = new NetworkAddress(new DnsEndPoint("wasabiukrxmkdgve5kynjztuovbg43uxcbcxn6y2okcrsg7gb6jdmbad.onion", 8333));
Assert.True(netaddr.AddressType == NetworkAddressType.Onion);
addrman.Add(netaddr);
addrman.SavePeerFile("serializerPeerBIP155.dat", Network.Main);
var loaddedAddrMgr = AddressManager.LoadPeerFile("serializerPeerBIP155.dat", Network.Main);
var addr = addrman.Select();
Assert.True(addr.Endpoint is DnsEndPoint);
var dns = addr.Endpoint as DnsEndPoint;
Assert.Equal("wasabiukrxmkdgve5kynjztuovbg43uxcbcxn6y2okcrsg7gb6jdmbad.onion", dns.Host);
Assert.Equal(8333, dns.Port);
}
public async Task Auth()
{
// need to start a real server (not the RC thing!)
//var address = NetworkAddress.Parse("sgay-l4");
var address = NetworkAddress.Parse("localhost");
HConsole.Configure(this, config => config.SetIndent(0).SetPrefix("TEST"));
HConsole.WriteLine(this, "Begin");
HConsole.WriteLine(this, "Start client ");
var client1 = new MemberConnection(address, new MessagingOptions(), new SocketOptions(), new SslOptions(), new Int64Sequence(), new NullLoggerFactory());
await client1.ConnectAsync(CancellationToken.None).CAF();
// RC assigns a GUID but the default cluster name is 'dev'
var clusterName = "dev";
var username = (string)null; // null
var password = (string)null; // null
var clientId = Guid.NewGuid();
var clientType = "CSP"; // CSharp
var serializationVersion = (byte)0x01;
var clientVersion = "4.0";
var clientName = "hz.client_0";
var labels = new HashSet <string>();
var requestMessage = ClientAuthenticationCodec.EncodeRequest(clusterName, username, password, clientId, clientType, serializationVersion, clientVersion, clientName, labels);
HConsole.WriteLine(this, "Send auth request");
var invocation = new Invocation(requestMessage, new MessagingOptions(), null, CancellationToken.None);
var responseMessage = await client1.SendAsync(invocation, CancellationToken.None).CAF();
HConsole.WriteLine(this, "Rcvd auth response " +
HConsole.Lines(this, 1, responseMessage.Dump()));
var response = ClientAuthenticationCodec.DecodeResponse(responseMessage);
var status = (AuthenticationStatus)response.Status;
NUnit.Framework.Assert.AreEqual(AuthenticationStatus.Authenticated, status);
HConsole.WriteLine(this, "Stop client");
await client1.DisposeAsync().CAF();
HConsole.WriteLine(this, "End");
await Task.Delay(100).CAF();
}
/// <summary>Attempts to connect to a random peer.</summary>
private Task ConnectAsync()
{
if (!this.peerAddressManager.Peers.Any())
{
return(Task.CompletedTask);
}
if (this.ConnectedPeers.Count >= this.MaximumNodeConnections)
{
return(Task.CompletedTask);
}
NetworkPeer peer = null;
try
{
NetworkAddress peerAddress = this.FindPeerToConnectTo();
if (peerAddress == null)
{
return(Task.CompletedTask);
}
using (var timeoutTokenSource = CancellationTokenSource.CreateLinkedTokenSource(this.nodeLifetime.ApplicationStopping))
{
timeoutTokenSource.CancelAfter(5000);
this.peerAddressManager.PeerAttempted(peerAddress.Endpoint, DateTimeProvider.Default.GetUtcNow());
var clonedConnectParamaters = this.CurrentParameters.Clone();
clonedConnectParamaters.ConnectCancellation = timeoutTokenSource.Token;
peer = this.networkPeerFactory.CreateConnectedNetworkPeer(this.network, peerAddress, clonedConnectParamaters);
peer.VersionHandshake(this.Requirements, timeoutTokenSource.Token);
return(Task.CompletedTask);
}
}
catch (Exception exception)
{
peer?.DisconnectWithException("Error while connecting", exception);
}
return(Task.CompletedTask);
}
public void ShouldTriggerConnectionRejected()
{
using (ConnectorFixture fixture = new ConnectorFixture())
using (ConnectorSession session = fixture.Start())
{
FileHash hash = FileHash.Random();
NetworkAddress address = NetworkAddress.Parse(session.Endpoint);
Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionEstablished, data =>
{
data.Remote.Should().NotBeNull();
data.Remote.Host.Should().Be("127.0.0.1");
data.Remote.Port.Should().Be(session.Endpoint.Port);
});
session.Connector.ConnectTo(hash, address);
handler.Wait().Should().BeTrue();
}
}
/// <summary>
/// Initializes parts of the object that are common for both inbound and outbound peers.
/// </summary>
/// <param name="inbound"><c>true</c> for inbound peers, <c>false</c> for outbound peers.</param>
/// <param name="peerAddress">Information about the peer including its network address, protocol version, time of last contact.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="parameters">Various settings and requirements related to how the connections with peers are going to be established, or <c>null</c> to use default parameters.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
private NetworkPeer(bool inbound, NetworkAddress peerAddress, Network network, NetworkPeerConnectionParameters parameters, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory)
{
this.loggerFactory = loggerFactory;
this.dateTimeProvider = dateTimeProvider;
this.MessageProducer = new MessageProducer <IncomingMessage>();
this.preferredTransactionOptions = network.NetworkOptions;
this.SupportedTransactionOptions = network.NetworkOptions & ~NetworkOptions.All;
this.Inbound = inbound;
this.LastSeen = peerAddress.Time.UtcDateTime;
this.PeerAddress = peerAddress;
this.Network = network;
this.Behaviors = new NetworkPeerBehaviorsCollection(this);
this.Parameters = parameters ?? new NetworkPeerConnectionParameters();
this.MyVersion = this.Parameters.CreateVersion(peerAddress.Endpoint, network, this.dateTimeProvider.GetTimeOffset());
}
public void TestDelAddrsFromTableNat() {
NetworkAddress srcIP1, srcIP2, dstIP1, dstIP2;
fw.AddAddrsToTableNAT(srcIP, dstIP);
srcIP1 = new NetworkAddress("192.168.0.2");
dstIP1 = new NetworkAddress("1.0.0.2");
srcIP2 = new NetworkAddress("192.168.0.3");
dstIP2 = new NetworkAddress("1.0.0.3");
fw.AddAddrsToTableNAT(srcIP1, dstIP1);
fw.AddAddrsToTableNAT(srcIP2, dstIP2);
Assert.AreEqual(fw.TableNAT.Count, 3);
fw.DelAddrsFromTableNat(srcIP1, dstIP1);
NetworkAddress[] record = new NetworkAddress[2];
record[0] = srcIP1;
record[1] = dstIP1;
Assert.AreEqual(fw.TableNAT.Count, 2);
Assert.AreNotEqual(fw.TableNAT[1][0], srcIP1);
Assert.AreNotEqual(fw.TableNAT[1][1], dstIP1);
}
public ServiceHttpProxy getOpenHttpProxy()
{
if (null == _host)
{
BaseException e = new BaseException(this, "null == _host");
throw e;
}
if (null != _openHttpProxy)
{
return _openHttpProxy;
}
NetworkAddress networkAddress = new NetworkAddress(_host, _port);
HttpDispatcher httpDispatcher = new HttpDispatcher(networkAddress);
_openHttpProxy = new ServiceHttpProxy(httpDispatcher);
return _openHttpProxy;
}
public void EncodeDecode_ReturnsInputDataExactly()
{
var netAddr = new NetworkAddress(true);
netAddr.Decode(baseNetAddrEncoded);
var unixTs = BitConverter.ToInt32(new byte[] { 0x29, 0xab, 0x5f, 0x49 }, 0);
var timestamp = DateTimeExtensions.FromUnixTime(unixTs);
Assert.Equal(timestamp.Date, new DateTime(2009, 1, 3));
Assert.Equal(timestamp, netAddr.Timestamp);
Assert.Equal(netAddr.Services, ServiceFlag.NodeNetwork);
Assert.Equal(netAddr.Port, 8333);
var bytes = netAddr.Encode();
Assert.True(bytes.SequenceEqual(baseNetAddrEncoded));
}
public void SerializeV2()
{
var addr = new NetworkAddress();
var mem = new MemoryStream();
var stream = new BitcoinStream(mem, true);
string HexStr()
{
var arr = mem.ToArray();
return(Encoders.Hex.EncodeData(arr, 1, arr.Length - 3));
}
// Add ADDRV2_FORMAT to the version so that the CNetAddr
// serialize method produces an address in v2 format.
stream.ProtocolVersion = NetworkAddress.AddrV2Format;
stream.Type = SerializationType.Hash;
stream.ReadWrite(addr);
Assert.Equal("021000000000000000000000000000000000", HexStr());
mem.Clear();
addr = new NetworkAddress(IPAddress.Parse("1.2.3.4"));
stream.ReadWrite(addr);
Assert.Equal("010401020304", HexStr());
mem.Clear();
addr = new NetworkAddress(IPAddress.Parse("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b"));
stream.ReadWrite(addr);
Assert.Equal("02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b", HexStr());
mem.Clear();
addr = new NetworkAddress();
addr.SetSpecial("6hzph5hv6337r6p2.onion");
stream.ReadWrite(addr);
Assert.Equal("030af1f2f3f4f5f6f7f8f9fa", HexStr());
mem.Clear();
addr = new NetworkAddress();
addr.SetSpecial("kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion");
stream.ReadWrite(addr);
Assert.Equal("042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88", HexStr());
}
public void PeerConnectorDiscover_WithConnectPeersSpecified_CanNotStart()
{
var nodeSettings = new NodeSettings
{
ConnectionManager = new Configuration.Settings.ConnectionManagerSettings()
};
var ipAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var networkAddressConnectNode = new NetworkAddress(ipAddressThree, 80);
nodeSettings.ConnectionManager.Connect.Add(networkAddressConnectNode.Endpoint);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerConnectorTests"));
var peerAddressManager = new PeerAddressManager(peerFolder, this.extendedLoggerFactory);
var connector = this.CreatePeerConnectorDiscovery(nodeSettings, peerAddressManager);
Assert.False(connector.CanStartConnect);
}
public async Task Test()
{
using var _ = HConsoleForTest();
var options = HazelcastOptions.Build();
options.Messaging.RetryTimeoutSeconds = 1;
var loggerFactory = new NullLoggerFactory();
var address = NetworkAddress.Parse("127.0.0.1:11000");
var state = new ServerState
{
Id = 0,
MemberId = Guid.NewGuid(),
Address = address
};
await using var server = new Server(address, ServerHandler, loggerFactory, state, "0")
{
MemberId = state.MemberId,
};
await server.StartAsync();
var serializationService = HazelcastClientFactory.CreateSerializationService(options.Serialization, loggerFactory);
var authenticator = new Authenticator(options.Authentication, serializationService);
ISequence <int> connectionIdSequence = new Int32Sequence();
ISequence <long> correlationIdSequence = new Int64Sequence();
var memberConnection = new MemberConnection(address, authenticator,
options.Messaging, options.Networking, options.Networking.Ssl,
connectionIdSequence, correlationIdSequence,
loggerFactory);
var memberConnectionHasClosed = false;
memberConnection.Closed += connection =>
{
memberConnectionHasClosed = true;
return(default);
static void Main(string[] args)
{
ExtKey masterKey = new ExtKey();
WalletCreation wc = new WalletCreation
{
Network = network,
RootKeys = new [] { masterKey.Neuter() }
};
Wallet wallet = new Wallet(wc);
wallet.Configure();
NetworkAddress na = new NetworkAddress(IPAddress.Parse("127.0.0.1"), 18444);
wallet.AddressManager.Add(na);
wallet.Group.MaximumNodeConnection = 1;
wallet.NewWalletTransaction += (Wallet sender, WalletTransaction wtx) =>
{
WalletTransactionsCollection wtxc = wallet.GetTransactions();
Console.WriteLine("wallet tx count => {0}", wtxc.Count);
Console.WriteLine("immature => {0}", wtxc.Summary.Immature.Amount);
Console.WriteLine("confirmed => {0}", wtxc.Summary.Confirmed.Amount);
Console.WriteLine("unconfirmed => {0}", wtxc.Summary.UnConfirmed.Amount);
Console.WriteLine("spendable => {0}", wtxc.Summary.Spendable.Amount);
};
wallet.Connect();
BitcoinAddress addr = wallet.GetNextScriptPubKey().GetDestinationAddress(network);
Console.WriteLine("receiver address => {0}", addr);
Task.Run(() => {
Console.WriteLine("wait a while before trigger tx ...");
Thread.Sleep(2000);
RPCClient client = new RPCClient("user:123456", "http://localhost:18443", network);
uint256 txid = client.SendToAddress(addr, Money.Coins(0.1m));
Console.WriteLine("trigger txid => {0}", txid);
client.Generate(1);
});
Console.ReadLine();
}
public async Task ShouldTriggerConnectionReceivedWhenReceivedSomeBytes()
{
NetworkDirection direction = NetworkDirection.Outgoing;
NetworkOutgoingMessage message = new RandomMessage(113);
using (NetworkFixture fixture = new NetworkFixture())
using (TcpSocket host = fixture.Pool.New())
using (TcpSocket socket = fixture.Pool.New())
{
TcpSocketInfo info = host.BindAndInfo();
int port = info.Endpoint.Port;
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port);
socket.Bind();
host.Listen(10);
Task <TcpSocketAccept> task = host.Accept();
await socket.Connect(endpoint);
TcpSocketAccept accept = await task;
NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint);
NetworkBlock block = new NetworkBlock(new byte[1024], 0, message.Length);
Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionReceived, data =>
{
data.Remote.Should().Be(NetworkAddress.Parse(endpoint));
data.Connection.Should().NotBeNull();
data.Bytes.Should().Be(message.Length);
});
connection.Receive(new NullReceiver());
message.ToBytes(block);
block.With((buffer, offset, count) =>
{
accept.Connection.Send(new SocketBuffer(buffer, offset, count), null);
});
handler.Wait().Should().BeTrue();
}
}
// ReSharper disable once ExcessiveIndentation
public static IAddress[] StringToAddresses(string str)
{
var remoteAddresses = new List <IAddress>();
foreach (var remoteAddress in str.Split(','))
{
if (DNSService.TryParse(remoteAddress, out var dns))
{
remoteAddresses.Add(dns);
}
else if (DHCPService.TryParse(remoteAddress, out var dhcp))
{
remoteAddresses.Add(dhcp);
}
else if (WINSService.TryParse(remoteAddress, out var wins))
{
remoteAddresses.Add(wins);
}
else if (LocalSubnet.TryParse(remoteAddress, out var localSubnet))
{
remoteAddresses.Add(localSubnet);
}
else if (DefaultGateway.TryParse(remoteAddress, out var defaultGateway))
{
remoteAddresses.Add(defaultGateway);
}
else if (IPRange.TryParse(remoteAddress, out var range))
{
remoteAddresses.Add(range);
}
else if (SingleIP.TryParse(remoteAddress, out SingleIP ip))
{
remoteAddresses.Add(ip);
}
else if (NetworkAddress.TryParse(remoteAddress, out var network))
{
remoteAddresses.Add(network);
}
}
return(remoteAddresses.ToArray());
}
public void GetHashCodeTest()
{
var addr1 = new NetworkAddress(NodeServiceFlags.NodeNone, IPAddress.Parse("1.2.3.4"), 111);
var addr2 = new NetworkAddress(NodeServiceFlags.NodeNone, IPAddress.Parse("1.2.3.4"), 111);
var addr3 = new NetworkAddress(NodeServiceFlags.NodeNetwork, IPAddress.Parse("1.2.3.4"), 111);
var addr4 = new NetworkAddress(NodeServiceFlags.NodeNone, IPAddress.Parse("1.2.3.5"), 111);
var addr5 = new NetworkAddress(NodeServiceFlags.NodeNone, IPAddress.Parse("1.2.3.4"), 112);
int h1 = addr1.GetHashCode();
int h2 = addr2.GetHashCode();
int h3 = addr3.GetHashCode();
int h4 = addr4.GetHashCode();
int h5 = addr5.GetHashCode();
Assert.Equal(h1, h2);
Assert.Equal(h1, h3);
Assert.NotEqual(h1, h4);
Assert.NotEqual(h1, h5);
Assert.NotEqual(h4, h5);
}
public void SocketTimeout2()
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
// server is not listening, connecting results in timeout after 1s
Assert.ThrowsAsync <TimeoutException>(async() =>
{
await socket.ConnectAsync(NetworkAddress.Parse("www.hazelcast.com:5701").IPEndPoint, 500).CfAwait();
});
// socket has been properly closed and disposed
Assert.Throws <ObjectDisposedException>(() =>
{
socket.Send(Array.Empty <byte>());
});
// can dispose multiple times
socket.Close();
socket.Dispose();
}
/// <inheritdoc/>
public Message GetVersionMsg(NetworkAddress addr)
{
byte[] temp = new byte[8];
new Random().NextBytes(temp);
var ver = new VersionPayload()
{
Version = settings.ProtocolVersion,
Services = settings.Services,
Timestamp = settings.Time,
ReceivingNodeNetworkAddress = addr,
TransmittingNodeNetworkAddress = new NetworkAddress(settings.Services, IPAddress.Loopback, settings.Port),
Nonce = BitConverter.ToUInt64(temp),
UserAgent = settings.UserAgent,
StartHeight = blockchain.Height,
Relay = settings.Relay
};
return(new Message(ver, settings.Network));
}
public void PeerSelectability_Decreases_AfterEachFailedAttempt()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var addressOne = new NetworkAddress(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var addressManager = new PeerAddressManager(peerFolder);
addressManager.AddPeer(addressOne, IPAddress.Loopback, PeerIntroductionType.Add);
var peer = addressManager.FindPeer(addressOne.Endpoint);
peer.Attempted(DateTimeOffset.Now);
var resultOne = peer.Selectability;
peer.Attempted(DateTimeOffset.Now);
var resultTwo = peer.Selectability;
Assert.True(resultOne > resultTwo);
}
private Task Listen(TcpClient nodeTcpClient, NetworkAddress clientNetworkAddress)
{
return(new Task(() => {
try {
while (Online)
{
var receivedObject = Receive(nodeTcpClient.GetStream());
HandleReceivedObject(receivedObject, clientNetworkAddress);
}
}
catch (IOException) {
OnUpdateState($"[CLOSED] {clientNetworkAddress}");
DeleteConnection(clientNetworkAddress);
}
catch (SerializationException) {
OnUpdateState($"[CLOSED] {clientNetworkAddress}");
DeleteConnection(clientNetworkAddress);
}
}));
}
public void SerializeV1()
{
var addr = new NetworkAddress();
var mem = new MemoryStream();
var stream = new BitcoinStream(mem, true);
string AddressHex()
{
var arr = mem.ToArray();
return(Encoders.Hex.EncodeData(arr, 8, 16));
}
// serialize method produces an address in v2 format.
stream.Type = SerializationType.Hash;
stream.ReadWrite(addr);
Assert.Equal("00000000000000000000000000000000", AddressHex());
mem.Clear();
addr = new NetworkAddress(IPAddress.Parse("1.2.3.4"));
stream.ReadWrite(addr);
Assert.Equal("00000000000000000000ffff01020304", AddressHex());
mem.Clear();
addr = new NetworkAddress(IPAddress.Parse("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b"));
stream.ReadWrite(addr);
Assert.Equal("1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b", AddressHex());
mem.Clear();
addr = new NetworkAddress();
addr.SetSpecial("6hzph5hv6337r6p2.onion");
stream.ReadWrite(addr);
Assert.Equal("fd87d87eeb43f1f2f3f4f5f6f7f8f9fa", AddressHex());
mem.Clear();
addr = new NetworkAddress();
addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion");
stream.ReadWrite(addr);
Assert.Equal("00000000000000000000000000000000", AddressHex());
}
public async Task TimeoutsIfServerIsTooSlow()
{
var address = NetworkAddress.Parse("127.0.0.1:11001");
HConsole.Configure(this, config => config.SetIndent(0).SetPrefix("TEST"));
HConsole.WriteLine(this, "Begin");
HConsole.WriteLine(this, "Start server");
await using var server = new Server(address, async(svr, conn, msg) =>
{
HConsole.WriteLine(svr, "Handle request (slowww...)");
await Task.Delay(10_000).CAF();
HConsole.WriteLine(svr, "Respond with success.");
var response = ClientPingServerCodec.EncodeResponse();
response.CorrelationId = msg.CorrelationId;
await conn.SendAsync(response).CAF();
}, LoggerFactory);
await server.StartAsync().CAF();
HConsole.WriteLine(this, "Start client");
var options = HazelcastOptions.Build(configure: (configuration, options) =>
{
options.Networking.Addresses.Add("127.0.0.1:11001");
});
await using var client = (HazelcastClient)HazelcastClientFactory.CreateClient(options);
await client.StartAsync().CAF();
HConsole.WriteLine(this, "Send message");
var message = ClientPingServerCodec.EncodeRequest();
Assert.ThrowsAsync <TaskCanceledException>(async() =>
{
var token = new CancellationTokenSource(3_000).Token;
await client.Cluster.Messaging.SendAsync(message, token); // default is 120s
});
// TODO dispose the client, the server
await server.StopAsync().CAF();
}
public void TestChild()
{
var n1 = new NetworkAddress("1");
var n2 = new NetworkAddress("1.1");
var snpp1 = new SubnetworkPointPool(new NetworkAddress("1.1.1"));
var snpp2 = new SubnetworkPointPool(new NetworkAddress("1.1.2"));
var snpp3 = new SubnetworkPointPool(new NetworkAddress("1.1.1.1"));
var snpp4 = new SubnetworkPointPool(new NetworkAddress("1.1.1.2"));
var expected = n2;
var actual = snpp1.NodeAddress.GetRootFromBeginning(n1.Levels + 1);
Assert.AreEqual(expected, actual);
actual = snpp2.NodeAddress.GetRootFromBeginning(n1.Levels + 1);
Assert.AreEqual(expected, actual);
actual = snpp3.NodeAddress.GetRootFromBeginning(n1.Levels + 1);
Assert.AreEqual(expected, actual);
actual = snpp4.NodeAddress.GetRootFromBeginning(n1.Levels + 1);
Assert.AreEqual(expected, actual);
}
public Task <PeerSession> ConnectAsync(FileHash hash, NetworkAddress remote)
{
runtime.Start();
PeerConnect connect = new PeerConnect
{
Hash = hash,
Address = remote,
Localhost = PeerHash.Random(),
Notifications = new NotificationCollection(),
Completion = new TaskCompletionSource <PeerSession>(),
Pipeline = runtime.Pipeline,
Files = runtime.Files,
Worker = runtime.Worker
};
connect.Start();
connect.Connect(remote);
return(connect.Completion.Task);
}
public void MembersUpdatedEventArgs()
{
var id1 = Guid.NewGuid();
var id2 = Guid.NewGuid();
var id3 = Guid.NewGuid();
var mi1 = new MemberInfo(id1, NetworkAddress.Parse("127.0.0.1:88"), new MemberVersion(1, 1, 1), false, new Dictionary <string, string>());
var mi2 = new MemberInfo(id2, NetworkAddress.Parse("127.0.0.1:88"), new MemberVersion(1, 1, 1), false, new Dictionary <string, string>());
var mi3 = new MemberInfo(id3, NetworkAddress.Parse("127.0.0.1:88"), new MemberVersion(1, 1, 1), false, new Dictionary <string, string>());
var args = new MembersUpdatedEventArgs(new [] { mi1 }, new [] { mi2 }, new [] { mi1, mi3 });
Assert.That(args.AddedMembers.Count, Is.EqualTo(1));
Assert.That(args.AddedMembers, Does.Contain(mi1));
Assert.That(args.RemovedMembers.Count, Is.EqualTo(1));
Assert.That(args.RemovedMembers, Does.Contain(mi2));
Assert.That(args.Members.Count, Is.EqualTo(2));
Assert.That(args.Members, Does.Contain(mi1));
Assert.That(args.Members, Does.Contain(mi3));
}
/// <summary>
/// Initializes an instance of the object for inbound network peers with already established connection.
/// </summary>
/// <param name="peerAddress">Information about the peer including its network address, protocol version, time of last contact.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="parameters">Various settings and requirements related to how the connections with peers are going to be established, or <c>null</c> to use default parameters.</param>
/// <param name="client">Already connected network client.</param>
/// <param name="peerVersion">Version message payload received from the peer.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public NetworkPeer(NetworkAddress peerAddress, Network network, NetworkPeerConnectionParameters parameters, NetworkPeerClient client, VersionPayload peerVersion, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory)
: this(true, peerAddress, network, parameters, dateTimeProvider, loggerFactory)
{
this.logger.LogTrace("()");
this.RemoteSocketEndpoint = client.RemoteEndPoint;
this.RemoteSocketAddress = this.RemoteSocketEndpoint.Address;
this.RemoteSocketPort = this.RemoteSocketEndpoint.Port;
this.PeerVersion = peerVersion;
this.Connection = new NetworkPeerConnection(this, client, this.dateTimeProvider, this.loggerFactory);
this.ConnectedAt = this.dateTimeProvider.GetUtcNow();
this.logger.LogTrace("Connected to advertised node '{0}'.", this.PeerAddress.Endpoint);
this.State = NetworkPeerState.Connected;
this.InitDefaultBehaviors(parameters);
this.Connection.StartReceiveMessages();
this.logger.LogTrace("(-)");
}
public void CableCloudPassMessageTest()
{
var cableCloud = new CableCloud(10000);
cableCloud.UpdateState += (sender, state) => Console.WriteLine(state);
cableCloud.StartListening();
var port1 = 10001;
var port2 = 10002;
var port3 = 10003;
var address1 = new NetworkAddress(1);
var address2 = new NetworkAddress(2);
var address3 = new NetworkAddress(3);
var output = new NetworkAddressNodePortPair(address1, 1);
var input1 = new NetworkAddressNodePortPair(address2, 1);
var input2 = new NetworkAddressNodePortPair(address3, 1);
cableCloud.AddLink(input1, output);
cableCloud.AddLink(input2, output);
_bytesToSend = BinarySerializer.Serialize(CreateCableCloudMessage(1, 100));
var listenerTask1 = StartTcpListener(port1, ReceiveMessage);
ConnectToCableCloud(port1);
var listenerTask2 = StartTcpListener(port2, SendMessage);
ConnectToCableCloud(port2);
var listenerTask3 = StartTcpListener(port3, SendMessage);
ConnectToCableCloud(port3);
Task.WaitAll(listenerTask1, listenerTask2, listenerTask3);
for (var i = 0; i < _bytesToSend.Length; i++)
{
Assert.AreEqual(_bytesToSend[i], _bytesReceived[i]);
}
}
public GlobalGaussianMixMapQ(OccupancyGrid2D globalOcGrid, GenericMulticastClient <LidarFilterPackageMessage> lidarFilterClient)
{
addressProvider = new HardcodedAddressProvider();
//lidarFilterPackageClient = new GenericMulticastClient<LidarFilterPackageMessage>(addressProvider.GetAddressByName("LidarFilterPackage"), new CSharpMulticastSerializer<LidarFilterPackageMessage>(true));
globalGaussianMixMapServer = new GenericMulticastServer <GlobalMapCell>(addressProvider.GetAddressByName("GlobalGaussianMixMap"), new CSharpMulticastSerializer <GlobalMapCell>(true));
globalGaussianMixMapServer.Start(NetworkAddress.GetBindingAddressByType(NetworkAddress.BindingType.Wired));
robotIDToPose = new Dictionary <int, PoseFilterState>();
robotIDToScan = new Dictionary <int, ILidarScan <ILidar2DPoint> >();
robotIDToSensorPose = new Dictionary <int, SensorPose>();
robotIDToTimestamp = new Dictionary <int, double>();
robotIDToPastTimestamp = new Dictionary <int, double>();
globalOcGridByEachRobot = new Dictionary <int, OccupancyGrid2D>();
robotIDToDynamicObstacles = new Dictionary <int, List <Polygon> >();
otherRobotPolygon = new Dictionary <int, Polygon>();
this.globalOcGrid = new OccupancyGrid2D(globalOcGrid);
laserToRobot = new SensorPose(0, 0, 0.5, 0, 0 / 180.0, 0, 0);
gaussianMixMapAlgorithm = new GaussianMixMappingQ(globalOcGrid, laserToRobot);
globalOcGridByEachRobotAlgorithm = new Dictionary <int, GaussianMixMappingQ>();
//lidarFilterPackageClient.Start(NetworkAddress.GetBindingAddressByType(NetworkAddress.BindingType.Wired));
lidarFilterClient.MsgReceived += new EventHandler <MsgReceivedEventArgs <LidarFilterPackageMessage> >(lidarFilterPackageClient_MsgReceived);
// local map request from robots
localMapRequestClient = new GenericMulticastClient <LocalMapRequestMessage>(addressProvider.GetAddressByName("LocalMapRequest"), new CSharpMulticastSerializer <LocalMapRequestMessage>(true));
localMapRequestClient.Start(NetworkAddress.GetBindingAddressByType(NetworkAddress.BindingType.Wired));
localMapRequestClient.MsgReceived += new EventHandler <MsgReceivedEventArgs <LocalMapRequestMessage> >(localMapRequestClient_MsgReceived);
// local map update sender
localMapResponseServer = new GenericMulticastServer <UpdateMapDataMessage>(addressProvider.GetAddressByName("LocalMapResponse"), new CSharpMulticastSerializer <UpdateMapDataMessage>(true));
localMapResponseServer.Start(NetworkAddress.GetBindingAddressByType(NetworkAddress.BindingType.Wired));
Thread t = new Thread(new ParameterizedThreadStart(UpdateGlobalMap));
t.Start();
//Thread t2 = new Thread(new ParameterizedThreadStart(SendGlobalUpdate));
//t2.Start();
}
public void ShouldTriggerConnectionTerminatedWhenTerminated()
{
IPAddress address = IPAddress.Parse("127.0.0.1");
IPEndPoint remote = new IPEndPoint(address, 8080);
NetworkDirection direction = NetworkDirection.Outgoing;
using (NetworkFixture fixture = new NetworkFixture())
{
Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionTerminated, data =>
{
data.Remote.Should().Be(NetworkAddress.Parse(remote));
data.Connection.Should().NotBeNull();
});
using (TcpSocket socket = fixture.Pool.New())
{
fixture.Pool.Create(socket, direction, remote).Terminate();
}
handler.Wait().Should().BeTrue();
}
}
public void PeerCanBeReturnedAsPreferred_NeverBeenConnectedTo_Scenario1()
{
var ipAddress = IPAddress.Parse("::ffff:192.168.0.1");
var addressOne = new NetworkAddress(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.2");
var addressTwo = new NetworkAddress(ipAddress, 80);
ipAddress = IPAddress.Parse("::ffff:192.168.0.3");
var addressThree = new NetworkAddress(ipAddress, 80);
var peerFolder = AssureEmptyDirAsDataFolder(Path.Combine(AppContext.BaseDirectory, "PeerAddressManager"));
var addressManager = new PeerAddressManager(peerFolder);
addressManager.AddPeer(addressOne, IPAddress.Loopback, PeerIntroductionType.Add);
addressManager.AddPeer(addressTwo, IPAddress.Loopback, PeerIntroductionType.Add);
addressManager.AddPeer(addressThree, IPAddress.Loopback, PeerIntroductionType.Add);
var networkAddresses = addressManager.SelectPeersToConnectTo();
Assert.Equal(3, networkAddresses.Count());
}
/// <summary>
/// Initializes an instance of the object for inbound network peers with already established connection.
/// </summary>
/// <param name="peerAddress">Information about the peer including its network address, protocol version, time of last contact.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="parameters">Various settings and requirements related to how the connections with peers are going to be established, or <c>null</c> to use default parameters.</param>
/// <param name="client">Already connected network client.</param>
/// <param name="peerVersion">Version message payload received from the peer.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public NetworkPeer(NetworkAddress peerAddress, Network network, NetworkPeerConnectionParameters parameters, TcpClient client, IDateTimeProvider dateTimeProvider, INetworkPeerFactory networkPeerFactory, ILoggerFactory loggerFactory)
: this(true, peerAddress, network, parameters, dateTimeProvider, loggerFactory)
{
this.Connection = networkPeerFactory.CreateNetworkPeerConnection(this, client, this.ProcessMessageAsync);
this.logger = loggerFactory.CreateLogger(this.GetType().FullName, $"[{this.Connection.Id}-{peerAddress.Endpoint}] ");
this.logger.LogTrace("()");
this.RemoteSocketEndpoint = this.PeerAddress.Endpoint;
this.RemoteSocketAddress = this.RemoteSocketEndpoint.Address;
this.RemoteSocketPort = this.RemoteSocketEndpoint.Port;
this.ConnectedAt = this.dateTimeProvider.GetUtcNow();
this.logger.LogTrace("Connected to advertised node '{0}'.", this.PeerAddress.Endpoint);
this.State = NetworkPeerState.Connected;
this.InitDefaultBehaviors(this.Parameters);
this.Connection.StartReceiveMessages();
this.logger.LogTrace("(-)");
}
public async Task ShouldTriggerConnectionTerminatedWhenSending()
{
NetworkDirection direction = NetworkDirection.Outgoing;
using (NetworkFixture fixture = new NetworkFixture())
using (TcpSocket host = fixture.Pool.New())
using (TcpSocket socket = fixture.Pool.New())
{
TcpSocketInfo info = host.BindAndInfo();
int port = info.Endpoint.Port;
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port);
socket.Bind();
host.Listen(10);
Task <TcpSocketAccept> task = host.Accept();
TcpSocketConnect connect = await socket.Connect(endpoint);
TcpSocketAccept accept = await task;
connect.Status.Should().Be(SocketStatus.OK);
accept.Status.Should().Be(SocketStatus.OK);
accept.Connection.Dispose();
NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint);
Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionTerminated, data =>
{
data.Remote.Should().Be(NetworkAddress.Parse(endpoint));
data.Connection.Should().NotBeNull();
});
for (int i = 0; i < 10; i++)
{
connection.Send(new OneByteMessage());
}
handler.Wait().Should().BeTrue();
}
}
void GivenTheNetworkAddressLocalhostIsArrayOf4Bytes() {
byte[] b = { 127, 0, 0, 1 };
_validAddr1 = new NetworkAddress(b);
}
public static NetworkAddress CreateNetworkAddress(long ID, global::System.Guid tid, string name, long createdById, long modifiedById, global::System.DateTimeOffset created, global::System.DateTimeOffset modified)
{
NetworkAddress networkAddress = new NetworkAddress();
networkAddress.Id = ID;
networkAddress.Tid = tid;
networkAddress.Name = name;
networkAddress.CreatedById = createdById;
networkAddress.ModifiedById = modifiedById;
networkAddress.Created = created;
networkAddress.Modified = modified;
return networkAddress;
}
public void SetUp() {
fw = new Firewall(new FilterMock(), new DistributorMock());
srcIP = new NetworkAddress("192.168.0.1");
dstIP = new NetworkAddress("1.0.0.1");
}
public static void EncodeNetworkAddress(BinaryWriter writer, NetworkAddress networkAddress)
{
writer.WriteUInt64(networkAddress.Services);
writer.WriteBytes(16, networkAddress.IPv6Address.ToArray());
writer.WriteUInt16BE(networkAddress.Port);
}
void AndGivenTheNetworkAddressLocalhostIsArrayOf10BytesWhereFrom2To5bytesThereIsAddress() {
byte[] b = { 0, 1, 127, 0, 0, 1, 6, 7, 8, 9 };
_validAddr2 = new NetworkAddress(b, 2);
}
public ServiceHttpProxy getAuthHttpProxy(ClientSecurityConfiguration clientSecurityConfiguration)
{
if (null == _host)
{
BaseException e = new BaseException(this, "null == _host");
throw e;
}
if (null != _authHttpProxy && _authHttpProxy.Authenticator.getSecurityConfiguration() == clientSecurityConfiguration)
{
return _authHttpProxy;
}
NetworkAddress networkAddress = new NetworkAddress(_host, _port);
HttpDispatcher httpDispatcher = new HttpDispatcher(networkAddress);
Authenticator authenticator = new Authenticator(false, clientSecurityConfiguration);
_authHttpProxy = new ServiceHttpProxy(httpDispatcher, authenticator);
return _authHttpProxy;
}
public static byte[] EncodeNetworkAddress(NetworkAddress networkAddress)
{
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
EncodeNetworkAddress(writer, networkAddress);
return stream.ToArray();
}
}
public HttpDispatcher(NetworkAddress networkAddress)
{
_networkAddress = networkAddress;
}
void AndGivenTheNetworkAddressLocalhostIsValidString() {
_validAddr3 = new NetworkAddress("127.0.0.1");
}
private void Setup()
{
log.enteredMethod();
if (null != _internalServerConfig)
{
if (null != _internalWebServer)
{
return;
}
_internalWebServer = new IntegrationTestServer();
_internalWebServer.Start();
_networkAddress = new NetworkAddress("127.0.0.1", 8081);
return;
}
if (null != _externalServerConfig)
{
String hostIp4Address = _externalServerConfig.GetString("hostIp4Address");
_networkAddress = new NetworkAddress(hostIp4Address, 8081);
return;
}
// else co-located ...
return;
}
void GivenTheNetworkAddressLocalhostIsOtherObjectNetworkAddress() {
byte[] b = { 127, 0, 0, 1 };
NetworkAddress otherAddress = new NetworkAddress(b);
_comparedAddr = new NetworkAddress(otherAddress);
}
void WhenTheUserInitializesNetworkAddresOthersAddress() {
_notSameAddr = new NetworkAddress(_comparedAddr);
}
