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