public async Task <AsyncSocketSession> GetConnectedSocket(IProcessor processor)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = true,
LingerState = new LingerOption(true, 2)
};
var serverSocketAccept = listener.AcceptSocketAsync();
socket.Connect(new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port));
await serverSocketAccept;
var serverSocket = serverSocketAccept.Result;
var session = new AsyncSocketSession(Guid.NewGuid().ToString(),
socket,
processor,
SocketAwaitablePool,
BlockingBufferManager);
serverSocketsBySession.Add(session, serverSocket);
return(session);
}
public ServerSession(
System.Net.Sockets.Socket workSocket,
System.Net.IPEndPoint bindEndPoint,
string bindEndPointName,
bool serverKeepAlive,
ProcessorFactory processorFactory)
{
workSocket.NoDelay = true; //donot use Nagle
_clientIp = ((System.Net.IPEndPoint)workSocket.RemoteEndPoint).Address;
_bindEndPoint = bindEndPoint;
_bindEndPointName = bindEndPointName;
_serverKeepAlive = serverKeepAlive;
_processorFactory = processorFactory;
_session = new AsyncSocketSession(workSocket);
_session.ConnectionClose += new EventHandler <ConnectionCloseEventArgs>(session_ConnectionClose);
_session.SendComplete += new EventHandler <SendCompleteEventArgs>(session_SendComplete);
_session.ReceiveHeaderComplete += new EventHandler <ReceiveHeaderCompleteEventArgs>(session_ReceiveHeaderComplete);
_session.ReceiveBodyComplete += new EventHandler <ReceiveBodyCompleteEventArgs>(session_ReceiveBodyComplete);
_connectionToken = System.Guid.NewGuid().ToString("N");
_bodyBuffer = new byte[BODY_BUFFER_LENGTH];
//set the active time
_lastActiveTime = DateTime.Now;
}
private static void Server_NewClientAccepted(Socket client, ISocketSession session)
{
Console.WriteLine("----- new client ------------");
AsyncSocketSession ass = session as AsyncSocketSession;
ass.SetReceiveHandler(arg =>
{
Console.WriteLine("----- new receive ------------");
string received = System.Text.Encoding.UTF8.GetString(arg.Buffer, arg.Offset, arg.BytesTransferred);
Console.WriteLine(received);
ass.Send(received);
});
}
private static void Server_ReadCompleted(Socket client, object state)
{
SocketAsyncEventArgs arg = state as SocketAsyncEventArgs;
string received = System.Text.Encoding.UTF8.GetString(arg.Buffer, arg.Offset, arg.BytesTransferred);
Console.WriteLine(received);
AsyncSocketSession session = arg.UserToken as AsyncSocketSession;
if (session == null)
{
return;
}
session.Send(received);
}
public ArraySegment <byte> ReadDataSentFromSession(AsyncSocketSession session)
{
Thread.Sleep(1000);
var receiveBuffer = new byte[16000];
var serverSocket = serverSocketsBySession[session];
int totalBytesRead = 0;
while (serverSocket.Available > 0)
{
int bytesRead = serverSocket.Receive(receiveBuffer, totalBytesRead, 1000, SocketFlags.None);
totalBytesRead += bytesRead;
Thread.Sleep(1000);
}
return(new ArraySegment <byte>(receiveBuffer, 0, totalBytesRead));
}
public async Task ServerIsAbleToProcessPacketsAndCleansUpResources(ISocketSessionFactory sessionFactory, IProcessor processor, IPlayer player)
{
player.GetCityCount().Returns(1);
player.HasTwoFactorAuthenticated = DateTime.Now;
var socketAwaitablePool = new SocketAwaitablePool(10);
var buffer = new BlockingBufferManager(1000, 15);
Socket serverSideSocket = null;
AsyncSocketSession session = null;
sessionFactory.CreateAsyncSocketSession(Arg.Any <string>(), Arg.Any <Socket>())
.Returns(args =>
{
serverSideSocket = args.Arg <Socket>();
session = new AsyncSocketSession(string.Empty, serverSideSocket, processor, socketAwaitablePool, buffer)
{
Player = player
};
return(session);
});
AsyncTcpServer server = new AsyncTcpServer(sessionFactory, socketAwaitablePool, buffer);
try
{
server.Start("127.0.0.1", 0);
// Connect and verify client connected and socket options are set
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = true
};
var packetToSend1 = new Packet(Command.MarketSell);
packetToSend1.AddString("Hello");
var bytesToSendOnConnect = packetToSend1.GetBytes();
await socket.ConnectAsync(new SocketAwaitable
{
RemoteEndPoint = server.LocalEndPoint
});
await Task.Delay(1000);
await socket.SendAsync(new SocketAwaitable
{
Buffer = new ArraySegment <byte>(bytesToSendOnConnect, 0, bytesToSendOnConnect.Length)
});
await Task.Delay(1000);
server.GetSessionCount().Should().Be(1);
serverSideSocket.Connected.Should().BeTrue();
serverSideSocket.NoDelay.Should().BeTrue();
serverSideSocket.SendTimeout.Should().Be(1000);
// Send packets and verify server processes packets
var packetToSend2 = new Packet(Command.MarketBuy);
packetToSend2.AddString("World");
var bytesToSecondAfterConnect = packetToSend2.GetBytes();
await socket.SendAsync(new SocketAwaitable
{
Buffer = new ArraySegment <byte>(bytesToSecondAfterConnect, 0, bytesToSecondAfterConnect.Length)
});
await Task.Delay(1000);
// Stop server and verify it disconnect and releases resources
server.Stop();
await Task.Delay(1000);
player.HasTwoFactorAuthenticated.Should().Be(null);
serverSideSocket.Connected.Should().BeFalse();
socketAwaitablePool.Count.Should().Be(10);
buffer.AvailableBuffers.Should().Be(15);
processor.Received(1).Execute(session, Arg.Is <Packet>(packet => packet.GetBytes().SequenceEqual(bytesToSecondAfterConnect)));
processor.Received(1).Execute(session, Arg.Is <Packet>(packet => packet.GetBytes().SequenceEqual(bytesToSendOnConnect)));
processor.Received(1).ExecuteEvent(session, Arg.Is <Packet>(packet => packet.Cmd == Command.OnDisconnect));
}
finally
{
server.Stop();
}
}
public void CloseSessionFromServerSide(AsyncSocketSession session)
{
var serverSocket = serverSocketsBySession[session];
serverSocket.Close();
}
