public void TryReadMessageTestTwoCompleteMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[10];
AbstractMessage messageToWrite1 = new BasicMessage(Guid.NewGuid(), fakeBody);
// Prepare the received buffer
SocketStateObject state = new SocketStateObject();
int offset = messageToWrite1.Header.Write(state.buffer, 0);
offset += fakeBody.Length;
fakeBody = new byte[15];
AbstractMessage messageToWrite2 = new BasicMessage(Guid.NewGuid(), fakeBody);
offset = messageToWrite2.Header.Write(state.buffer, offset);
offset += fakeBody.Length;
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = offset;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite1.MessageLength);
Assert.IsNull(state.message);
Assert.IsNotNull(state.pendingBuffer);
actual = AbstractMessage.TryReadMessage(message, state, 0);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite2.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
public void TryReadMessageTestOneLongMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[SocketStateObject.BufferSize * 2];
AbstractMessage messageToWrite = new BasicMessage(Guid.NewGuid(), fakeBody);
// Prepare the received buffer
SocketStateObject state = new SocketStateObject();
int offset = messageToWrite.Header.Write(state.buffer, 0);
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = SocketStateObject.BufferSize;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
byteRead = SocketStateObject.BufferSize;
actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
byteRead = messageToWrite.Header.HeaderLength;
actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
/// <summary>
/// Callback for asynchronous receiving.
/// </summary>
/// <param name="ar">The socket state object for receiving data</param>
private static void ProcessReceive(SocketAsyncEventArgs e)
{
AbstractAsyncTcpSocketClientHandler handler = (AbstractAsyncTcpSocketClientHandler)e.UserToken;
try
{
while (true)
{
//Trace.WriteLine(string.Format("Receive {0} bytes", e.BytesTransferred));
if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
{
int read = e.BytesTransferred;
// Fire event for incoming message
handler.OnReceivingMessage(handler);
while (true)
{
AbstractMessage message = AbstractMessage.TryReadMessage(handler.GetMessageInstance(), handler.stateObject, read);
// Fire event for received message
if (message != null)
{
ReceiveMessageStateObject rcvObj = new ReceiveMessageStateObject()
{
Handler = handler, Message = message
};
handler.OnReceiveMessage(rcvObj);
}
if (handler.stateObject.pendingBuffer == null)
{
break;
}
read = 0;
}
bool flagPending = ((TcpSocketAsync)handler.socket).ReceiveAsync(e);
if (flagPending)
{
break;
}
}
else
{
Trace.WriteLine(string.Format("SocketError {0}.", e.SocketError));
handler.Close();
break;
}
}
}
catch (MessageException mex)
{
// Invalid message
Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", mex));
handler.Close();
}
catch (SocketException sex)
{
if (sex.SocketErrorCode == SocketError.ConnectionReset || sex.SocketErrorCode == SocketError.ConnectionAborted)
{
Trace.WriteLine(string.Format("Socket error for disconnection {0} : {1} : {2}. Client will be disconnected", sex.ErrorCode, sex.SocketErrorCode, sex.Message));
handler.stateObject.message = null;
handler.stateObject.pendingBuffer = null;
handler.Close();
}
else
{
Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", sex));
handler.stateObject.message = null;
handler.stateObject.pendingBuffer = null;
handler.Close();
}
}
catch (Exception ex)
{
Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", ex));
handler.stateObject.message = null;
handler.stateObject.pendingBuffer = null;
handler.Close();
}
}
/// <summary>
/// Callback for asynchronous receiving.
/// </summary>
/// <param name="ar">The socket state object for receiving data</param>
protected static void ReadCallback(IAsyncResult ar)
{
SocketStateObject state = (SocketStateObject)ar.AsyncState;
AbstractTcpSocketClientHandler handler = state.workHandler;
try
{
// Read data from the client socket.
int read = handler.EndReceive(ar);
Trace.WriteLine(string.Format("Receive {0} bytes", read));
// Data was read from the client socket.
if (read > 0)
{
// Fire event for incoming message
handler.OnReceivingMessage(handler);
while (true)
{
AbstractMessage message = AbstractMessage.TryReadMessage(handler.GetMessageInstance(), state, read);
// Fire event for received message
if (message != null)
{
ReceiveMessageStateObject rcvObj = new ReceiveMessageStateObject()
{
Handler = handler, Message = message
};
handler.OnReceiveMessage(rcvObj);
}
if (state.pendingBuffer == null)
{
break;
}
read = 0;
}
handler.socket.BeginReceive(state, new AsyncCallback(ReadCallback));
}
else
{
handler.Close();
}
}
catch (MessageException mex)
{
// Invalid message
Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", mex));
state.message = null;
state.pendingBuffer = null;
handler.Close();
}
catch (SocketException sex)
{
if (sex.SocketErrorCode == SocketError.ConnectionReset || sex.SocketErrorCode == SocketError.ConnectionAborted)
{
Trace.WriteLine(string.Format("Socket error for disconnection {0} : {1} : {2}. Client will be disconnected", sex.ErrorCode, sex.SocketErrorCode, sex.Message));
state.message = null;
state.pendingBuffer = null;
handler.Close();
}
else
{
Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", sex));
state.message = null;
state.pendingBuffer = null;
handler.Close();
}
}
catch (Exception ex)
{
Trace.WriteLine(string.Format("Exception {0}. Connection will be closed", ex));
state.message = null;
state.pendingBuffer = null;
handler.Close();
}
}
public void TryReadMessageTestOneLongOneShortMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[SocketStateObject.BufferSize * 2];
AbstractMessage messageToWrite1 = new BasicMessage(Guid.NewGuid(), fakeBody);
fakeBody = new byte[50];
AbstractMessage messageToWrite2 = new BasicMessage(Guid.NewGuid(), fakeBody);
byte[] bufferToSend = new byte[messageToWrite1.MessageLength + messageToWrite2.MessageLength];
int offset = messageToWrite1.Header.Write(bufferToSend, 0);
offset += messageToWrite1.GetBuffer().Length;
offset = messageToWrite2.Header.Write(bufferToSend, offset);
offset += messageToWrite2.GetBuffer().Length;
// Read per block
int readOffset = 0;
int counter = 0;
SocketStateObject state = new SocketStateObject();
while (readOffset < bufferToSend.Length)
{
int size = ((bufferToSend.Length - readOffset) > SocketStateObject.BufferSize) ?
SocketStateObject.BufferSize : (bufferToSend.Length - readOffset);
// Prepare the received buffer
Array.Copy(bufferToSend, readOffset, state.buffer, 0, size);
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = size;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
switch (counter)
{
case 0:
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
break;
case 1:
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
break;
case 2:
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite1.MessageLength);
Assert.IsNull(state.message);
Assert.IsNotNull(state.pendingBuffer);
break;
}
counter++;
readOffset += size;
}
AbstractMessage message2 = new BasicMessage();
AbstractMessage actual2 = AbstractMessage.TryReadMessage(message2, state, 0);
Assert.IsNotNull(actual2);
Assert.AreEqual(actual2.MessageLength, messageToWrite2.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
