private void OnConnected(TcpSocketConnect data) { if (data.Status == SocketStatus.OK) { socket.Send(outgoing, OnSent); } else { Console.WriteLine("OnConnected"); socket.Dispose(); } }
private void TearDown() { if (_clientSocket != null) { if (_clientSocket.IsConnected) { _clientSocket.Close(); } _clientSocket.Dispose(); } if (_evtSendWait != null) { _evtSendWait.Dispose(); } if (_fileSymProcessor != null) { _fileSymProcessor.Dispose(); } if (_rcvBuffer != null) { _rcvBuffer.Dispose(); } if (_sndBuffer != null) { _sndBuffer.Dispose(); } if (_filePath != null) { _filePath = null; } }
public void RejectHugePacket() { using (TcpListener listener = new TcpListener(1024)) { listener.Blocking = true; listener.Listen(PORT); TcpSocket clientSock = new TcpSocket(); var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result; var status = listener.Accept(out TcpSocket serverSock); Assert.AreEqual(SocketStatus.Done, status); var largePacket = new NetPacket(); largePacket.WriteBytes(new byte[8192], true); while (clientSock.Send(largePacket) != SocketStatus.Done) { ; } Assert.AreEqual(SocketStatus.Disconnected, serverSock.Receive(largePacket)); Assert.IsFalse(serverSock.Connected); clientSock.Dispose(); serverSock.Dispose(); largePacket.Dispose(); } }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, /// or resetting unmanaged resources. /// </summary> protected virtual void Dispose(bool aDisposing) { if (!mIsDisposed) { if (aDisposing) { if (Player != null) { Player.Dispose(); } if (mSocket != null) { mSocket.Dispose(); } } Player = null; CurTask = null; mNetworkWorker = null; mSocket = null; mIsDisposed = true; } }
public void SocketDisposeTest() { TcpSocket sock = new TcpSocket(); sock.Dispose(); Assert.CatchAsync <ObjectDisposedException>(() => { return(sock.ConnectAsync("localhost", 1002).AsTask()); }); }
public void BufferSizeTest() { TcpSocket socket = new TcpSocket(); socket.ReceiveBufferSize = 1024; Assert.AreEqual(1024, socket.ReceiveBufferSize); socket.Dispose(); }
public void DisposeTest() { var tcp = new TcpSocket(); tcp.Dispose(); Assert.IsNull(tcp.SendBuffer); Assert.IsNull(tcp.ReceiveBuffer); }
public void CanDisposeNewTcpSocket() { using (CompletionThread worker = new CompletionThread()) { SocketFactory factory = new SocketFactory(worker); TcpSocket socket = factory.Tcp(); socket.Dispose(); } }
// [Test] public void StressTest() { TcpListener listener = new TcpListener(); listener.Listen(PORT); TcpSocket clientSock = new TcpSocket(); var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result; var status = listener.Accept(out TcpSocket serverSock); for (int i = 0; i < 1000000; i++) { NetPacket packet = new NetPacket(); var messageTo = Guid.NewGuid().ToString(); packet.WriteString(messageTo); while (serverSock.Send(packet) != SocketStatus.Done) { ; } packet.Clear(); while (clientSock.Receive(packet) != SocketStatus.Done) { ; } Assert.AreEqual(messageTo, packet.ReadString()); packet.ResetWrite(); packet.WriteString($"Message with code {messageTo} received."); while (clientSock.Send(packet) != SocketStatus.Done) { ; } packet.Clear(); while (serverSock.Receive(packet) != SocketStatus.Done) { ; } packet.Dispose(); } listener.Dispose(); clientSock.Dispose(); serverSock.Dispose(); }
public void ReconnectTest() { TcpSocket socket = new TcpSocket(); Assert.IsFalse(socket.Connected); socket.Connect(new DnsEndPoint("www.google.com", 80)); Assert.IsTrue(socket.Connected); socket.Dispose(); Assert.IsFalse(socket.Connected); socket.Reconnect(); Assert.IsTrue(socket.Connected); }
public void TestConnect() { TcpSocket tcp = new TcpSocket(); tcp.Connect(Common.GetIpEndPoint()); //Test connected Common.WaitConnected(tcp); Assert.IsTrue(tcp.IsConnected); //Test disconnect tcp.DisConnect(); Assert.IsFalse(tcp.IsConnected); tcp.Dispose(); }
protected virtual void Dispose(bool aDisposing) { if (!mIsDisposed) { if (aDisposing) { if (mSocket != null) { mSocket.Dispose(); } } mSocket = null; mIsDisposed = true; } }
public void SendReceiveTest() { const string serverMessage = "HelloFromServer"; const string clientMessage = "ResponseFromClient"; using (TcpListener listener = new TcpListener()) { listener.Blocking = true; listener.Listen(PORT); TcpSocket clientSock = new TcpSocket(); var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result; var status = listener.Accept(out TcpSocket serverSock); NetPacket packet = new NetPacket(); NetPacket clientPacket = new NetPacket(); packet.WriteString(serverMessage); // Send message to client. Assert.AreEqual(SocketStatus.Done, serverSock.Send(packet)); // Read message from server. Assert.AreEqual(SocketStatus.Done, clientSock.Receive(clientPacket)); Assert.AreEqual(serverMessage, clientPacket.ReadString()); // Send message back to server. clientPacket.Clear(SerializationMode.Writing); clientPacket.WriteString(clientMessage); Assert.AreEqual(SocketStatus.Done, clientSock.Send(clientPacket)); // Read message from client. Assert.AreEqual(SocketStatus.Done, serverSock.Receive(packet)); Assert.AreEqual(clientMessage, packet.ReadString()); clientSock.Dispose(); serverSock.Dispose(); packet.Dispose(); clientPacket.Dispose(); } }
public void CanReceiveDataUsingCallbackToExampleSite() { TimeSpan timeout = TimeSpan.FromSeconds(2); ManualResetEvent check = new ManualResetEvent(false); IPAddress[] addresses = Dns.GetHostAddresses("www.example.com"); IPEndPoint endpoint = new IPEndPoint(addresses[0], 80); string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n"; byte[] data = Encoding.ASCII.GetBytes(request); using (CompletionThread worker = new CompletionThread()) { SocketFactory factory = new SocketFactory(worker); TcpSocket socket = factory.Tcp(); socket.Bind(); worker.Start(); TcpSocketReceiveCallback onReceived = result => { check.Set(); }; TcpSocketSendCallback onSent = result => { socket.Receive(data, onReceived); }; TcpSocketConnectCallback onConnected = result => { socket.Send(data, onSent); }; socket.Connect(endpoint, onConnected); bool completed = check.WaitOne(timeout); Assert.That(completed, Is.True); socket.Dispose(); } }
public void LifecycleTest() { TcpSocket socket = new TcpSocket(); Assert.IsFalse(socket.Connected); socket.Connect(new DnsEndPoint("www.google.com", 80)); Assert.IsTrue(socket.Connected); byte[] data = Encoding.ASCII.GetBytes(@"GET / HTTP/1.1 "); socket.Send(data, 0, data.Length, SocketFlags.None); byte[] responseData = new byte[128]; socket.Receive(responseData, 0, SocketFlags.None); string response = Encoding.ASCII.GetString(responseData); socket.Dispose(); }
public void TestConnectAPI() { TcpSocket tcp = new TcpSocket(); tcp.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 7777)); Common.WaitConnected(tcp); Assert.IsTrue(tcp.IsConnected); tcp.Dispose(); tcp = new TcpSocket(); tcp.Connect(IPAddress.Parse("127.0.0.1"), 7777); Common.WaitConnected(tcp); Assert.IsTrue(tcp.IsConnected); tcp.Dispose(); tcp = new TcpSocket(); tcp.Connect("127.0.0.1", 7777); Common.WaitConnected(tcp); Assert.IsTrue(tcp.IsConnected); tcp.Dispose(); }
public async Task KafkaTcpSocketShouldDisposeEvenWhilePollingToReconnect() { int connectionAttempt = 0; var config = new ConnectionConfiguration(onConnecting: (e, a, _) => { connectionAttempt = a; }); var endpoint = Endpoint.Resolve(TestConfig.ServerUri(), TestConfig.InfoLog); using (var test = new TcpSocket(endpoint, config, TestConfig.InfoLog)) { var taskResult = test.ReadAsync(4, CancellationToken.None); await TaskTest.WaitFor(() => connectionAttempt > 1); test.Dispose(); await Task.WhenAny(taskResult, Task.Delay(1000)).ConfigureAwait(false); Assert.That(taskResult.IsFaulted, Is.True); Assert.That(taskResult.Exception.InnerException, Is.TypeOf <ObjectDisposedException>()); } }
private async void OnAccepted(TcpSocketAccept data) { if (data.Status == SocketStatus.OK) { socket.Accept(OnAccepted); } if (data.Status == SocketStatus.OK) { TcpSocket other = data.Connection; byte[] bytes = new byte[1024]; while (true) { TcpSocketReceive received = await other.Receive(bytes); SocketBuffer buffer = new SocketBuffer(bytes, 0, received.Count); if (received.Count == 0) { break; } if (received.Status != SocketStatus.OK) { break; } TcpSocketSend sent = await other.Send(buffer); if (sent.Status != SocketStatus.OK) { break; } } other.Dispose(); } }
public void Dispose() { server?.Dispose(); }
public void Dispose() { socket.Dispose(); incoming.Dispose(); outgoing.Dispose(); }
public void Stop() { socket.Dispose(); }
public void Dispose() { socket.Dispose(); }
public void Dispose() { client.Dispose(); }