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