public async Task SocketTimeout3() { var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp); try { var endpoint = NetworkAddress.Parse("127.0.0.1:11000").IPEndPoint; await socket.ConnectAsync(endpoint, 60_000).CfAwait(); Assert.Fail("Expected an exception."); } catch (TimeoutException) { Assert.Fail("Did not expect TimeoutException."); } catch (Exception) { // ok } // socket is not ready (but not disposed) Assert.Throws <SocketException>(() => { socket.Send(Array.Empty <byte>()); }); }
static async Task Main(string[] args) { //Get configuration var networkAddress = NetworkAddress.Parse(ConfigurationManager.AppSettings["Network"]); var broadcastPort = int.Parse(ConfigurationManager.AppSettings["BroadcastUdpPort"]); var unicastPort = int.Parse(ConfigurationManager.AppSettings["UnicastTcpPort"]); localAddress = networkAddress.GetLocalAddress(); //This client exposes all of the high-level functionality var collaborationClient = new CollaborationClient(networkAddress, broadcastPort, unicastPort); collaborationClient.CollaborationRequestAccepted += OnCollaborationRequestAccepted; collaborationClient.CollaborationRequestDeclined += OnCollaborationRequestDeclined; collaborationClient.StopCollaborationRequested += OnStopCollaborationRequested; collaborationClient.SubscriptionRequested += OnSubscriptionRequested; collaborationClient.SubscriberNotifiedToStopCollaborating += OnSubscriberNotifiedToStopCollaborating; //Start listening per collaboration requests broadcasts var broadcastListenTask = StartListeningForCollaborationRequests(collaborationClient, listeningCancellationTokenSource.Token); //And also listen for subscription requests var subscriptionListenTask = StartListeningForSubscriptions(collaborationClient, listeningCancellationTokenSource.Token); //Then, read commands from the user HandleUserInput(collaborationClient); //When it's time to close the app, cancel any pending work and shutdown the hosts workCancellationTokenSource?.Cancel(); await Task.WhenAll(broadcastListenTask, subscriptionListenTask); }
public void ShouldTriggerPeersDataWhenLocal() { NetworkAddress remote = NetworkAddress.Parse(IPAddress.Loopback, 8345); using (PeersFixture fixture = new PeersFixture()) using (PeersSession session = fixture.Start()) { NetworkConnection connection = A.Fake <NetworkConnection>(); Handshake handshake = new Handshake(PeerHash.Random(), PeerHash.Random(), session.Coordinator.Hash, HandshakeOptions.Extended); MessageReceived extended = new MessageReceived { Type = "extended", Peer = handshake.Remote, Payload = new PeersMessage("d1:md6:ut_pexi3eee") }; Trigger handler = Trigger.Bind(ref session.Plugin.Hooks.OnPeersDataSent, data => { data.Peer.Should().Be(handshake.Remote); data.Hash.Should().Be(session.Coordinator.Hash); data.Remotes.Should().Contain(remote); }); session.Coordinator.Start(); session.Coordinator.Connect(connection, handshake); session.Coordinator.Handle(extended); session.Coordinator.SendPeers(handshake.Remote, remote); handler.Wait().Should().BeTrue(); } }
public async Task ShouldTriggerConnectionSentWhenSentSomeBytes() { 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); host.Accept(null); await socket.Connect(endpoint); NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint); Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionSent, data => { data.Remote.Should().Be(NetworkAddress.Parse(endpoint)); data.Connection.Should().Be(connection); data.Bytes.Should().Be(message.Length); }); connection.Send(message); handler.Wait().Should().BeTrue(); } }
public void MemberInfoTest() { var memberId = Guid.NewGuid(); var address = NetworkAddress.Parse("192.168.33.34:5569"); var version = new MemberVersion(4, 5, 6); var attributes = new Dictionary <string, string> { { "attribute", "value" } }; var x = new MemberInfo(memberId, address, version, true, attributes); Console.WriteLine(x); Assert.That(x.Id, Is.EqualTo(memberId)); Assert.That(x.Uuid, Is.EqualTo(memberId)); Assert.That(x.Address, Is.SameAs(address)); Assert.That(x.Version, Is.SameAs(version)); Assert.That(x.IsLite, Is.True); Assert.That(x.IsLiteMember, Is.True); var a = x.Attributes; Assert.That(a.Count, Is.EqualTo(1)); Assert.That(a["attribute"], Is.EqualTo("value")); Assert.That(x, Resolves.Equatable( // weird indeed, but only the ID matters new MemberInfo(memberId, x.Address, x.Version, x.IsLite, attributes), new MemberInfo(Guid.NewGuid(), x.Address, x.Version, x.IsLite, attributes) )); }
private void OnAccept(TcpSocketAccept data) { bool canAcceptMore = data.Status != SocketStatus.NotSocket && data.Status != SocketStatus.OperationAborted; if (canAcceptMore) { data.Socket.Accept(OnAccept); } if (data.Status == SocketStatus.OK) { IPEndPoint endpoint = data.GetRemote(); NetworkAddress remote = NetworkAddress.Parse(endpoint); NetworkDirection direction = NetworkDirection.Incoming; NetworkConnection connection = dependencies.Network.Create(data.Connection, direction, endpoint); hooks.CallConnectionArrived(remote, connection); } else { data.Connection?.Dispose(); } }
public void ArgumentExceptions() { var endpoint = NetworkAddress.Parse("127.0.0.1:11000").IPEndPoint; var s = new ClientSocketConnection(1, endpoint, new NetworkingOptions(), new SslOptions(), new NullLoggerFactory()); var c = new ClientMessageConnection(s, new NullLoggerFactory()); Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await c.SendAsync(null)); }
public async Task TimeoutsAfterMultipleRetries() { var address = NetworkAddress.Parse("127.0.0.1:11001"); using var _ = HConsole.Capture(consoleOptions => consoleOptions .ClearAll() .Configure().SetMaxLevel() .Configure(this).SetPrefix("TEST") .Configure <AsyncContext>().SetMinLevel() .Configure <SocketConnectionBase>().SetIndent(1).SetLevel(0).SetPrefix("SOCKET")); HConsole.WriteLine(this, "Begin"); HConsole.WriteLine(this, "Start server"); await using var server = new Server(address, async(xsvr, xconn, xmsg) => await HandleAsync(xsvr, xconn, xmsg, async(svr, conn, msg) => { HConsole.WriteLine(svr, "Handle request (wait...)"); await Task.Delay(500).CfAwait(); HConsole.WriteLine(svr, "Respond with error."); var response = ErrorsServerCodec.EncodeResponse(new[] { // make sure the error is retryable new ErrorHolder(RemoteError.RetryableHazelcast, "classname", "message", Enumerable.Empty <StackTraceElement>()) }); //HConsole.WriteLine(svr, "Respond with success."); //var response = ClientPingServerCodec.EncodeResponse(); response.CorrelationId = msg.CorrelationId; await conn.SendAsync(response).CfAwait(); }), LoggerFactory); await server.StartAsync().CfAwait(); HConsole.WriteLine(this, "Start client"); var options = HazelcastOptions.Build(configure: (configuration, options) => { options.Networking.Addresses.Add("127.0.0.1:11001"); options.Messaging.RetryTimeoutSeconds = 3; // default value is 120s }); await using var client = (HazelcastClient) await HazelcastClientFactory.StartNewClientAsync(options); HConsole.WriteLine(this, "Send message"); var message = ClientPingServerCodec.EncodeRequest(); // note: the error only happens *after* the server has responded // we could wait for the response for ever await AssertEx.ThrowsAsync <TaskTimeoutException>(async() => { // server will respond w/ error every 500ms and client will retry // until the 3s retry timeout (options above) is reached await client.Cluster.Messaging.SendAsync(message).CfAwait(); }); await server.StopAsync().CfAwait(); }
public async Task Test() { //var host = Dns.GetHostEntry(_hostname); //var ipAddress = host.AddressList[0]; //var endpoint = new IPEndPoint(ipAddress, _port); 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"); var server = new Server(address, ReceiveMessage, LoggerFactory); await server.StartAsync().CAF(); var options = HazelcastOptions.Build(Array.Empty <string>(), configure: (configuration, options) => { options.Networking.Addresses.Add("127.0.0.1:11001"); }); HConsole.WriteLine(this, "Start client 1"); await using var client1 = (HazelcastClient)HazelcastClientFactory.CreateClient(options); await client1.StartAsync().CAF(); HConsole.WriteLine(this, "Send message 1 to client 1"); var message = CreateMessage("ping"); var response = await client1.Cluster.Messaging.SendAsync(message, CancellationToken.None).CAF(); HConsole.WriteLine(this, "Got response: " + GetText(response)); HConsole.WriteLine(this, "Start client 2"); await using var client2 = (HazelcastClient)HazelcastClientFactory.CreateClient(options); await client2.StartAsync().CAF(); HConsole.WriteLine(this, "Send message 1 to client 2"); message = CreateMessage("a"); response = await client2.Cluster.Messaging.SendAsync(message, CancellationToken.None).CAF(); HConsole.WriteLine(this, "Got response: " + GetText(response)); HConsole.WriteLine(this, "Send message 2 to client 1"); message = CreateMessage("foo"); response = await client1.Cluster.Messaging.SendAsync(message, CancellationToken.None).CAF(); HConsole.WriteLine(this, "Got response: " + GetText(response)); //XConsole.WriteLine(this, "Stop client"); //await client1.CloseAsync().CAF(); HConsole.WriteLine(this, "Stop server"); await server.StopAsync().CAF(); await Task.Delay(1000).CAF(); HConsole.WriteLine(this, "End"); await Task.Delay(100).CAF(); }
public async Task Exceptions() { var endpoint = NetworkAddress.Parse("127.0.0.1:5701").IPEndPoint; var options = new SocketOptions(); await using var connection = new ClientSocketConnection(0, endpoint, options, new SslOptions(), new NullLoggerFactory(), 3); // OnReceiveMessageBytes is missing Assert.ThrowsAsync <InvalidOperationException>(async() => await connection.ConnectAsync(default));
public Task InitializeAsync(IDnsServer dnsServer, string config) { dynamic jsonConfig = JsonConvert.DeserializeObject(config); _enableBlocking = jsonConfig.enableBlocking.Value; if (jsonConfig.allowedNetworks is null) { _allowedNetworks = Array.Empty <NetworkAddress>(); } else { List <NetworkAddress> allowedNetworks = new List <NetworkAddress>(); foreach (dynamic allowedNetwork in jsonConfig.allowedNetworks) { allowedNetworks.Add(NetworkAddress.Parse(allowedNetwork.Value)); } _allowedNetworks = allowedNetworks; } if (jsonConfig.blockedNetworks is null) { _blockedNetworks = Array.Empty <NetworkAddress>(); } else { List <NetworkAddress> blockedNetworks = new List <NetworkAddress>(); foreach (dynamic blockedNetwork in jsonConfig.blockedNetworks) { blockedNetworks.Add(NetworkAddress.Parse(blockedNetwork.Value)); } _blockedNetworks = blockedNetworks; } if (jsonConfig.blockedQuestions is null) { _blockedQuestions = Array.Empty <BlockedQuestion>(); } else { List <BlockedQuestion> blockedQuestions = new List <BlockedQuestion>(); foreach (dynamic blockedQuestion in jsonConfig.blockedQuestions) { blockedQuestions.Add(new BlockedQuestion(blockedQuestion)); } _blockedQuestions = blockedQuestions; } return(Task.CompletedTask); }
public void Parse() { Assert.Throws <FormatException>(() => _ = NetworkAddress.Parse("[::1]:uh")); var address = NetworkAddress.Parse("127.0.0.1:5701"); Assert.That(address.HostName, Is.EqualTo("127.0.0.1")); Assert.That(address.Port, Is.EqualTo(5701)); Assert.That(NetworkAddress.TryParse("712.548", out var _), Is.False); var addresses = GetAddresses("127.0.0.1"); Console.WriteLine("127.0.0.1"); AssertAddresses(addresses, "127.0.0.1", false); addresses = GetAddresses("localhost"); Console.WriteLine("localhost"); AssertAddresses(addresses, "127.0.0.1", false); // on Windows, this gets 127.0.0.1 but on Linux it gets what the host name // maps to in /etc/hosts and by default on some systems (eg Debian) it can // be 127.0.1.1 instead of 127.0.0.1 // addresses = GetAddresses(Dns.GetHostName()); Console.Write(Dns.GetHostName()); var n = Dns.GetHostAddresses(Dns.GetHostName()).First(x => x.AddressFamily == AddressFamily.InterNetwork).ToString(); Console.WriteLine(" -> " + n); AssertAddresses(addresses, n, false); addresses = GetAddresses("::1"); Console.WriteLine("::1"); AssertAddresses(addresses, "[::1]", true); // on Windows, this gets the various fe80 local addresses (but not the random one // that we specified) - on Linux this gets nothing and it may eventually be an issue? // there are various issues corresponding to this situation, // see https://github.com/dotnet/runtime/issues/27534 // and fixes seem to be in the 5.0 milestone = n/a yet. addresses = GetAddresses("fe80::bd0f:a8bc:6480:238b"); Console.WriteLine("fe80::bd0f:a8bc:6480:238b"); if (OS.IsWindows) { // test the first 3, we might get more depending on NICs AssertAddresses(addresses, "*", true); } else { foreach (var a in addresses) { Console.WriteLine(" " + a); } } }
public void PartitionLostEventArgs() { var memberInfo = new MemberInfo(Guid.NewGuid(), NetworkAddress.Parse("127.0.0.1:88"), new MemberVersion(1, 1, 1), false, new Dictionary <string, string>()); var args = new PartitionLostEventArgs(12, 13, true, memberInfo); Assert.That(args.PartitionId, Is.EqualTo(12)); Assert.That(args.LostBackupCount, Is.EqualTo(13)); Assert.That(args.IsAllReplicasInPartitionLost); Assert.That(args.Member, Is.SameAs(memberInfo)); }
public void Parse() { Assert.Throws <FormatException>(() => _ = NetworkAddress.Parse("[::1]:uh")); var address = NetworkAddress.Parse("127.0.0.1:5701"); Assert.That(address.HostName, Is.EqualTo("127.0.0.1")); Assert.That(address.Port, Is.EqualTo(5701)); Assert.That(NetworkAddress.TryParse("712.548", out IEnumerable <NetworkAddress> _), Is.False);
public async Task OnReceiveMessage() { var endpoint = NetworkAddress.Parse("127.0.0.1:11000").IPEndPoint; var s = new ClientSocketConnection(1, endpoint, new NetworkingOptions(), new SslOptions(), new NullLoggerFactory()); var c = new ClientMessageConnection(s, new NullLoggerFactory()) { OnReceiveMessage = OnReceiveMessageNotImplemented }; Assert.That(c.OnReceiveMessage, Is.Not.Null); Assert.Throws <NotImplementedException>(() => c.OnReceiveMessage(default, default));
public void ShouldSanitizeNetworkAddress() { //Arrange var stringRepresentation = "192.168.191.128/19"; var expectedAddress = IPAddress.Parse("192.168.160.0"); //Act var actualAddress = NetworkAddress.Parse(stringRepresentation).Address; //Assert Assert.AreEqual(expectedAddress, actualAddress); }
public void Equality() { var address1 = NetworkAddress.Parse("127.0.0.1:5701"); var address2 = NetworkAddress.Parse("127.0.0.1:5702"); var address3 = NetworkAddress.Parse("127.0.0.1:5701"); Assert.That(address1 == address2, Is.False); Assert.That(address1 != address2, Is.True); Assert.That(address1 == address3, Is.True); Assert.That(address1 != address3, Is.False); }
public void ShouldCalculateBroadcastAddress() { //Arrange var stringRepresentation = "192.168.160.0/19"; var expectedAddress = IPAddress.Parse("192.168.191.255"); //Act var actualAddress = NetworkAddress.Parse(stringRepresentation).BroadcastAddress; //Assert Assert.AreEqual(expectedAddress, actualAddress); }
public void ConnectAsyncTimeout2() { var endpoint = NetworkAddress.Parse("www.hazelcast.com:5701").IPEndPoint; using var socket = new Socket(endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); Assert.ThrowsAsync <TimeoutException>(async() => { // no time for connection to be refused, timeout exception await socket.ConnectAsync(endpoint, 1, CancellationToken.None); }); }
/// <summary> /// Creates a new instance of the network connection relying on the /// already connected socket instance and direction value indicating /// who is the initiator of the connection. /// </summary> /// <param name="listener"></param> /// <param name="socket">The already connected socket.</param> /// <param name="direction">The direction indicating who initiated the connection.</param> /// <param name="identifier"></param> public NetworkPoolConnection(NetworkPoolListener listener, TcpSocket socket, NetworkDirection direction, long identifier, IPEndPoint remote) { this.listener = listener; this.socket = socket; this.direction = direction; this.identifier = identifier; this.remote = NetworkAddress.Parse(remote); incoming = new NetworkIncomingBuffer(listener, socket, identifier); outgoing = new NetworkOutgoingBuffer(listener, socket, identifier); }
public async Task SocketTimeout1() { await using var server = new Server(NetworkAddress.Parse("127.0.0.1:11000"), (svr, connection, message) => new ValueTask(), LoggerFactory); await server.StartAsync().CfAwait(); var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp); // server is listening, can connect within 1s timeout await socket.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000), 1_000).CfAwait(); socket.Close(); await server.StopAsync().CfAwait(); }
public void ShouldParseStringRepresentation() { //Arrange var stringRepresentation = "192.168.1.0/24"; var expectedAddress = IPAddress.Parse("192.168.1.0"); var expectedSignificantBits = 24; //Act var networdAddress = NetworkAddress.Parse(stringRepresentation); //Assert Assert.AreEqual(expectedAddress, networdAddress.Address); Assert.AreEqual(expectedSignificantBits, networdAddress.SignificantBits); }
public async Task CanRetryAndSucceed() { var address = NetworkAddress.Parse("127.0.0.1:11001"); HConsole.Configure(x => x.Configure(this).SetIndent(0).SetPrefix("TEST")); HConsole.WriteLine(this, "Begin"); HConsole.WriteLine(this, "Start server"); var count = 0; await using var server = new Server(address, async(xsvr, xconn, xmsg) => await HandleAsync(xsvr, xconn, xmsg, async(svr, conn, msg) => { HConsole.WriteLine(svr, "Handle request."); ClientMessage response; if (++count > 3) { HConsole.WriteLine(svr, "Respond with success."); response = ClientPingServerCodec.EncodeResponse(); } else { HConsole.WriteLine(svr, "Respond with error."); response = CreateErrorMessage(RemoteError.RetryableHazelcast); response.Flags |= ClientMessageFlags.BeginFragment | ClientMessageFlags.EndFragment; } response.CorrelationId = msg.CorrelationId; await conn.SendAsync(response).CfAwait(); }), LoggerFactory); await server.StartAsync().CfAwait(); 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) await HazelcastClientFactory.StartNewClientAsync(options); HConsole.WriteLine(this, "Send message"); var message = ClientPingServerCodec.EncodeRequest(); var token = new CancellationTokenSource(3_000).Token; await client.Cluster.Messaging.SendAsync(message, token); // default is 120s Assert.AreEqual(4, count); await server.StopAsync().CfAwait(); }
public void AuthenticationResultTest() { var clusterId = Guid.NewGuid(); var memberId = Guid.NewGuid(); var address = NetworkAddress.Parse("192.168.33.34:5569"); var x = new AuthenticationResult(clusterId, memberId, address, "4.5.6", true, 12, 4); Assert.That(x.ClusterId, Is.EqualTo(clusterId)); Assert.That(x.MemberId, Is.EqualTo(memberId)); Assert.That(x.MemberAddress, Is.SameAs(address)); Assert.That(x.ServerVersion, Is.EqualTo("4.5.6")); Assert.That(x.FailoverSupported); Assert.That(x.PartitionCount, Is.EqualTo(12)); Assert.That(x.SerializationVersion, Is.EqualTo(4)); }
public void bansAfterEnoughFailures() { for (int i = 0; i < MAX_ALLOWED_FAILURES + 1; i++) { eventLogListener.failure += Raise.With(null, SOURCE_ADDRESS); } Assert.NotEmpty(firewallRules); FirewallWASRule actual = firewallRules.First(); Assert.True(actual.IsEnable); Assert.Equal("Banned 192.0.2.0/24", actual.Name); Assert.Equal("Fail2Ban4Win", actual.Grouping); Assert.Equal(FirewallAction.Block, actual.Action); Assert.Equal(FirewallDirection.Inbound, actual.Direction); Assert.Equal(NetworkAddress.Parse("192.0.2.0/24"), actual.RemoteAddresses[0]); }
public void ShouldCreateNewConnection() { IPAddress address = IPAddress.Parse("127.0.0.1"); IPEndPoint remote = new IPEndPoint(address, 8080); NetworkDirection direction = NetworkDirection.Outgoing; using (NetworkFixture fixture = new NetworkFixture()) using (TcpSocket socket = fixture.Pool.New()) { NetworkConnection connection = fixture.Pool.Create(socket, direction, remote); connection.Should().NotBeNull(); connection.Direction.Should().Be(direction); connection.Remote.Should().Be(NetworkAddress.Parse(remote)); connection.Identifier.Should().BeGreaterThan(0); } }
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(); }
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(); } }
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);
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(); } }