private void SafeSocketOperation(string operationName, SocketInfo socketInfo, Action action, Action <Exception> exceptionHandler = null) { try { action(); } catch (SocketException ex) { if (_socketEventListener != null) { Task.Factory.StartNew(() => { _socketEventListener.OnSocketException(socketInfo, ex); }); } if (exceptionHandler != null) { exceptionHandler(ex); } } catch (ObjectDisposedException) { } catch (Exception ex) { _logger.Error( string.Format("Socket {0} has unknown exception, remoting endpoint address:{1}", operationName, socketInfo.SocketRemotingEndpointAddress), ex); if (exceptionHandler != null) { exceptionHandler(ex); } } }
private void NotifyNewSocketAccepted(SocketInfo socketInfo) { if (_socketEventListener != null) { Task.Factory.StartNew(() => _socketEventListener.OnNewSocketAccepted(socketInfo)); } }
public ClientSocket Connect(string address, int port) { _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _socket.ReceiveBufferSize = 8192; _socket.Connect(address, port); _socketInfo = new SocketInfo(_socket); return(this); }
public void SendMessage(SocketInfo socketInfo, byte[] message, Action <SendResult> messageSentCallback) { if (message.Length == 0) { throw new Exception(string.Format("Send message failed, message length cannot be zero, target socket address:{0}", socketInfo.SocketRemotingEndpointAddress)); } var wrappedMessage = SocketUtils.BuildMessage(message); if (wrappedMessage.Length > 0) { SafeSocketOperation("BeginSend", socketInfo, () => { socketInfo.InnerSocket.BeginSend(wrappedMessage, 0, wrappedMessage.Length, SocketFlags.None, SendCallback, new SendContext(socketInfo, wrappedMessage, messageSentCallback)); }); } }
public void Start(Action <ReceiveContext> messageReceivedCallback) { if (_isRunning) { return; } _isRunning = true; _listenNewClientWorker = new Worker("ServerSocket.AcceptNewClient", () => { if (!_isRunning) { return; } _messageReceivedCallback = messageReceivedCallback; _newClientSocketSignal.Reset(); try { _socket.BeginAccept(asyncResult => { if (!_isRunning) { return; } var clientSocket = _socket.EndAccept(asyncResult); var socketInfo = new SocketInfo(clientSocket); NotifyNewSocketAccepted(socketInfo); _newClientSocketSignal.Set(); if (!_isRunning) { return; } _socketService.ReceiveMessage(socketInfo, receivedMessage => { var receiveContext = new ReceiveContext(socketInfo, receivedMessage, context => { _socketService.SendMessage(context.ReplySocketInfo, context.ReplyMessage, sendResult => { if (context.ReplySentCallback != null) { context.ReplySentCallback(sendResult); } }); }); _messageReceivedCallback(receiveContext); }); }, _socket); } catch (SocketException socketException) { _logger.Error(string.Format("Socket accept exception, ErrorCode:{0}", socketException.SocketErrorCode), socketException); } catch (Exception ex) { _logger.Error("Unknown socket accept exception.", ex); } if (_isRunning) { _newClientSocketSignal.WaitOne(); } }); _listenNewClientWorker.Start(); }
public ReceiveContext(SocketInfo replySocketInfo, byte[] receivedMessage, Action <ReceiveContext> messageHandledCallback) { ReplySocketInfo = replySocketInfo; ReceivedMessage = receivedMessage; MessageHandledCallback = messageHandledCallback; }
public ReceiveState(SocketInfo sourceSocket, int receiveSize, Action <byte[]> messageReceivedCallback) { SourceSocket = sourceSocket; ReceiveSize = receiveSize; MessageReceivedCallback = messageReceivedCallback; }
public void ReceiveMessage(SocketInfo sourceSocket, Action <byte[]> messageReceivedCallback) { ReceiveInternal(new ReceiveState(sourceSocket, SocketUtils.MessageHeaderLength, messageReceivedCallback)); }
private void StartToReceiveMessageBody(ReceiveState receiveState, byte[] messageHeaderBuffer, SocketInfo sourceSocketInfo, int bytesRead) { string errorMessage; var messageLength = SocketUtils.ParseMessageLength(messageHeaderBuffer, out errorMessage); if (messageLength > 0) { receiveState.MessageSize = messageLength; _logger.DebugFormat("Start to receive new message, message body size:{0}, bytesRead:{1}", receiveState.MessageSize, bytesRead); var size = receiveState.MessageSize <= ReceiveState.BufferSize ? receiveState.MessageSize.Value : ReceiveState.BufferSize; receiveState.ReceivedData.Clear(); receiveState.ClearBuffer(); receiveState.ReceiveSize = size; ReceiveInternal(receiveState); } else { _logger.ErrorFormat("Parse message length failed, source socket address:{0}, receiveSize:{1}, bytesRead:{2}, errorMessage:{3}", sourceSocketInfo.SocketRemotingEndpointAddress, receiveState.ReceiveSize, bytesRead, errorMessage); } }
public SendContext(SocketInfo targetSocket, byte[] message, Action <SendResult> messageSendCallback) { TargetSocket = targetSocket; Message = message; MessageSendCallback = messageSendCallback; }