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