public ClientWorkingPolicy(ResponsePolicy policy, ClientManager client, ISocketMessage msg, bool noDelay) { this.Policy = policy; this.Client = client; this.Message = msg; this.NoDelay = noDelay; }
public QueuedOutMessage(ClientManager clmngr, ISocketMessage msg, bool shutdown) { this.Client = clmngr; this.Command = msg; this.Length = 0; this.ShutdownClientAfterSend = shutdown; }
/// <summary> /// 向客户端下发消息 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> /// <returns></returns> public virtual CommonResult NotifyClient(object sender, ClientNotifEventArgs e) { int[] sessionIDs = e.Recvs; ISocketMessage msg = e.Command; ClientManager clmngr = null; CommonResult result = CommonResult.OtherError; try { if (sessionIDs == null || sessionIDs.Length < 1 || msg == null) { return(CommonResult.NoData); } foreach (int sessionID in sessionIDs) { if (!_Clients.ContainsKey(sessionID)) { continue; } clmngr = this._Clients[sessionID] as ClientManager; AppendToOutMessageQueue(new QueuedOutMessage(clmngr, msg)); } result = CommonResult.Success; } catch (Exception ex) { DebugMessage(string.Format("NotifiClient Error:{0};Source:{1}", ex.Message, ex.Source)); result = CommonResult.SystemError; } finally { } return(result); }
public QueuedOutMessage(ClientManager clmngr, ISocketMessage msg) { this.Client = clmngr; this.Command = msg; this.Length = 0; this.ShutdownClientAfterSend = false; }
public void Handle(Type type, ISocketMessage message, StateObject context) { var serviceType = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()).Where(s => s.GetInterface(typeof(IHandleMessage).Name) != null).FirstOrDefault(a => a.GetInterfaces().Any(s => s.IsGenericType && s.GenericTypeArguments[0] == type)); var service = (IHandleMessage)Activator.CreateInstance(serviceType.Assembly.FullName, serviceType.FullName).Unwrap(); serviceType.GetMethods().FirstOrDefault(x => x.GetParameters().Any(a => a.ParameterType == type)).Invoke(service, new object[] { message, context }); }
public void Handle(Type type, ISocketMessage message, StateObject context) { var serviceType = typeof(IHandleMessage <>).MakeGenericType(type); var service = Container.Resolve(serviceType); serviceType.GetMethods().FirstOrDefault(x => x.GetParameters().Any(a => a.ParameterType == type)).Invoke(service, new object[] { message, context }); }
private void Send(ISocketMessage socketMessage) { var byteData = _serializer.Serialize(socketMessage); BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), this); sendDone.WaitOne(); }
/// <summary> /// 构造函数 /// </summary> /// <param name="tConfig">Socket基础配置</param> /// <param name="protocolType">Socket 类型,默认为TCP</param> /// <param name="autoconnec">是否重连</param> /// <param name="autoConnecSecond">重连间隔</param> /// <param name="bufferSize">自定义的缓冲区大小,</param> /// <param name="ISocketMessage">自定义回调,</param> public TSock(TConfig tConfig, ISocketMessage socketMessage, ProtocolType protocolType = ProtocolType.Tcp, bool autoconnec = true, int autoConnecSecond = 1000, int bufferSize = 1024) { this.bufferSize = bufferSize; this.socketMessage = socketMessage; InitLize(tConfig); this.autoConnecSecond = autoConnecSecond; this.protocolType = protocolType; this.autoconnec = autoconnec; }
public virtual CommonResult BroadCastToClient(object sender, ClientNotifEventArgs e) { CommonResult result = CommonResult.InvalidParams; ISocketMessage msg = e.Command; int senderUID = e.Sender; int[] keys = null; try { if (this._Clients.Keys.Count > 0) { // 如果指定了广播受众 if (e.Recvs != null && e.Recvs.Length > 0) { keys = e.Recvs; } else { // 否则群发 lock (this._Clients.SyncRoot) { if (this._Clients.Keys.Count < 1) { return(CommonResult.Success); } keys = new int[this._Clients.Keys.Count]; this._Clients.Keys.CopyTo(keys, 0); } } if (keys != null && keys.Length > 0) { ClientManager clmngr = null; foreach (int uid in keys) { // 如果发送人是普通用户,则检查其是否在某个用户的黑名单里 if (this._Clients.ContainsKey(uid)) { clmngr = this._Clients[uid] as ClientManager; AppendToOutMessageQueue(new QueuedOutMessage(clmngr, msg)); } } } } result = CommonResult.Success; } catch (Exception ex) { DebugMessage(string.Format("BroadCastToClient Error:{0};Source:{1}", ex.Message, ex.Source)); result = CommonResult.SystemError; } finally { } return(result); }
public InternalServer(IPAddress ipAddress, int port, ILogger logger) { _logger = logger; TcpListener = new TcpListener(ipAddress, port); _socketMessage = new JsonSocketMessage(); Clients = new Dictionary <Socket, Guid>(); ServerId = Guid.NewGuid(); }
public ISocketMessage CreateCustomer(ISocketMessage socketMessage) { var createCustomerCommand = (CreateCustomerCommand)socketMessage; return(new CustomerCreatedReply { CorrelationId = createCustomerCommand.CorrelationId, CustomerId = Guid.NewGuid().ToString() }); }
public void Send(ISocketMessage messageBase) { try { } catch (Exception e) { _logger.Warn(e.Message); } }
public ISocketMessage PlaceOrder(ISocketMessage socketMessage) { var placeOrderCommand = (PlaceOrderCommand)socketMessage; return(new OrderPlacedReply { CorrelationId = placeOrderCommand.CorrelationId, CustomerId = placeOrderCommand.CustomerId, OrderId = "OIX-111-120618", PlacedAt = DateTime.Now }); }
public ISocketMessage GetOrders(ISocketMessage socketMessage) { var getOrdersCommand = (GetOrdersCommand)socketMessage; return(new OrdersReply { CorrelationId = getOrdersCommand.CorrelationId, CustomerName = "John Doe", OrderId = getOrdersCommand.OrderId, PlacedAt = DateTime.Now.AddMonths(-2) }); }
public virtual void SendToClient(int sessionID, ISocketMessage msg) { if (sessionID <= 0 || msg == null) { return; } if (this._Clients.ContainsKey(sessionID)) { ClientManager clmngr = this._Clients[sessionID] as ClientManager; SendToClient(clmngr, msg); } }
/// <summary> /// 创建TCP对象接口 /// </summary> /// <param name="config"></param> /// <param name="protocolType"></param> /// <param name="autoconnec"></param> /// <param name="autoConnecSecond"></param> /// <param name="bufferSize"></param> /// <returns></returns> public TSock CreateTcpSocket(TConfig config, ISocketMessage socketMessage, bool autoconnec = true, int autoConnecSecond = 1000, int bufferSize = 1024) { TSock sock = new TSock(config, socketMessage, ProtocolType.Tcp, autoconnec, autoConnecSecond, bufferSize); var temp = tcpSockList.Find(m => m.tConfig.name.Equals(config.name)); if (temp != null) { temp.Dispose(); tcpSockList.Remove(temp); } tcpSockList.Add(sock); return(sock); }
public Task Write(ISessionData session, ISocketClient client, ISocketMessage message) { try { WhenWriting(session, client, message); } catch (Exception oops) { Debug.WriteLine(ToString() + "|" + oops.Message); return(Task.FromException(oops)); } return(Task.CompletedTask); }
public override void Add(ISocketMessage message) { if (_messages.TryAdd(message.Id, message)) { _orderedMessages.Enqueue(message.Id); ulong msgId; ISocketMessage msg; while (_orderedMessages.Count > _size && _orderedMessages.TryDequeue(out msgId)) { _messages.TryRemove(msgId, out msg); } } }
public SocketMessageEventArgs(ISocketMessage message, ISocketWriter writer) { if (message == null) { throw new ArgumentNullException(nameof(message)); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } this.Message = message; this.SocketWriter = writer; }
public T Call <T>(ISocketMessage socketMessage) where T : ISocketMessage { T response; using (var socketClient = new SocketClient(_remoteEndpoint)) { socketClient.StartClient(); response = socketClient.Call <T>(socketMessage); socketClient.Shutdown(SocketShutdown.Both); socketClient.Close(); } return(response); }
public void Send(Socket socket, ISocketMessage messageBase) { try { if (socket.Connected) { byte[] serialized = messageBase.Serialize(); Socket.BeginSendTo(serialized, 0, serialized.Length, 0, socket.RemoteEndPoint, SendCallback, socket); } } catch (SocketException e) { _logger.Warn(e.Message); } }
public byte[] Serialize(ISocketMessage socketMessage) { var jsonContent = JsonConvert.SerializeObject(socketMessage); var jsonBytes = _encoding.GetBytes(jsonContent); var bytes = new byte[jsonBytes.Length + SocketMessageHeaders.MessageSizeEndIndex]; var messageSizeBytes = BitConverter.GetBytes(jsonBytes.Length); //Set the message size using the first 4 bytes of the array. Buffer.BlockCopy(messageSizeBytes, 0, bytes, 0, messageSizeBytes.Length); //Fill the rest of the array with the socketMessage Buffer.BlockCopy(jsonBytes, 0, bytes, messageSizeBytes.Length, jsonBytes.Length); return(bytes); }
private bool ProcessMessage(ISessionData session, ISocketClient client, ISocketMessage message) { var user = _clientStates.Values.Where(c => c.ConnectionId == client.ConnectionId).SingleOrDefault(); byte[] bytes = message.GetRawBytes(); string result = (bytes[0]) switch { (byte)'/' => ProcessSlashCommand(user, session, client, ref bytes), (byte)'?' => GetHelpText(), _ => "Bad command or file name." // :) }; client.Send(Encoding.ASCII.GetBytes(result + "\n")); return(true); }
public void Send(ISocketMessage socketMessageBase) { try { Socket client = TcpClient.Client; if (!client.Connected) { return; } byte[] serialized = socketMessageBase.Serialize(); client.BeginSend(serialized, 0, serialized.Length, 0, SendMessageCallback, client); } catch (Exception e) { _logger.Warn(e.Message); } }
public void SendAsc(QueuedOutMessage msg) { try { if (msg == null || msg.Client == null || !msg.Client.Socket.Connected || msg.Command == null) { return; } ClientManager clmngr = msg.Client; ISocketMessage message = msg.Command; byte[] buf = message.GetBytes(); msg.Length = (uint)buf.Length; msg.ShutdownClientAfterSend = true; clmngr.Socket.BeginSend(buf, 0, buf.Length, SocketFlags.None, new AsyncCallback(SendAscyCallback), msg); } catch { } finally { } }
public virtual void SendToClient(ClientManager clmngr, ISocketMessage msg) { try { if (clmngr == null || msg == null || msg.Length == 0) { return; } byte[] buf = msg.GetBytes(); if (buf == null || buf.Length < 1) { return; } int i = clmngr.Socket.Send(buf, buf.Length, SocketFlags.None); } catch (Exception ex) { string strError = ex.Message; DebugMessage(string.Format("SendToClient Error:{0};Source:{1}", ex.Message, ex.Source)); } finally { } }
private bool ProcessPendingAuth(ISessionData session, ISocketClient client, ISocketMessage message) { var user = _clientStates.Values.Where(c => c.ConnectionId == client.ConnectionId).SingleOrDefault(); //TODO: Error handling in chat server component var msg = message.GetRawBytes(); if (msg.Length == 0 || msg.Length > 16) { client.Send(_("Invalid alias" + user.LinePrompt)); return(false); } user.Alias = Encoding.ASCII.GetString(msg); user.Commands.Add(new JoinCommand()); //TODO: Populate commands based on access? Dunno user.Commands.Add(new ListRoomsCommand()); client.Send(_($"Welcome {user.Alias}\n>")); user.Flags = ChatStates.Connected | ChatStates.Authenticated; return(true); }
/// <summary> /// 处理用户请求 /// </summary> /// <param name="clmngr"></param> /// <param name="message"></param> /// <returns></returns> public override bool HandleRequest(ClientManager clmngr, ISocketMessage message) { bool goRecieving = false; HttpContext context = null; try { _RequestTimes++; HttpRequest request = HttpRequest.ParseFromRawMessage(this, message.ToString()); if (!request.IsRequestError) { //检查主机头是否符合设置 if (!CheckRequestHost(request)) { //shutdown client ShutdownClient(clmngr); return goRecieving; } //获取该request的handlers CometCommandHandlerPipeline handlePipeline = GetRegistedCommandHandlers(request); if (handlePipeline == null) { //shutdown client ShutdownClient(clmngr); return goRecieving; } context = new HttpContext(this, clmngr, request); CometCommand cometCmd = handlePipeline.Command; request.Command = cometCmd; if (!clmngr.IsAuthedUser) { RegistUser(clmngr, request); } //如果要求长连接 if (cometCmd.RequireKeepAlive) { //登记本次请求事务 if (RegistKeepAliveRequestContext(clmngr, request) == null) { //shutdown client ShutdownClient(clmngr); return goRecieving; } } //执行处理管道 if (handlePipeline.Count > 0) { foreach (Handler.IHttpHandler handler in handlePipeline.Handlers) { if (handler != null) { handler.HandleRequest(clmngr, context); } } } } else { HandleErrorRequest(clmngr, request); } } catch (Exception ex) { if (ex is BussinessException) { ExceptionResult result = new ExceptionResult() { ErrorCode = "B10001", ErrorMessage = ex.Message }; context.Response.Write(Common.Utility.Json.JsonHelper.ObjToJson(result)); } else { ShutdownClient(clmngr); Console.WriteLine(string.Format("Error occured when HandleRequest:{0} ", ex.Message)); } } finally { } return goRecieving; }
protected override void WhenReceiving(ISessionData session, ISocketClient client, ISocketMessage message) { /* <-- INCOMING --> * 255 253 1 IAC DO ECHO * 255 253 31 IAC DO NAWS * 255 251 1 IAC WILL ECHO * 255 251 3 IAC WILL SUPPRESS-GO-AHEAD * */ /* <-- REPLY WITH --> * 255 252 1 IAC WONT ECHO * 255 252 31 IAC WONT NAWS * 255 254 1 IAC DONT ECHO * 255 254 3 IAC DONT SUPPRESS-GO-AHEAD * */ // https://www.iana.org/assignments/telnet-options/telnet-options.xhtml var options = new List <TelnetPacketOption>(); TelnetPacketOption option = null; byte b; byte lastByte = 0x00; var pos = 0; var bytes = message.GetRawBytes(); // so is this bytes 'by ref'? if (message.FirstByte != B.Iac) // wrong B.Iac value, hell... could be wrong acronym even. { goto DoneWithOptions; // ignore the packet if it doesn't have any options? whatever } do { b = bytes[pos++]; // byte for the current position if (b == B.Iac) // if it's an identifier for IAC then make a new option { Debug.Write("IAC "); if (lastByte == b) // if two IAC bytes (255, 0xFF) then the next byte starts content (if I recall, will look it up) { break; } option = new TelnetPacketOption(); options.Add(option); } option.Declaration = (bytes[pos++]) switch { B.Will => TelnetDeclarations.Will, B.Wont => TelnetDeclarations.Wont, B.Do => TelnetDeclarations.Do, B.Dont => TelnetDeclarations.Dont, _ => TelnetDeclarations.None, }; Debug.Write(Enum.GetName(typeof(TelnetDeclarations), option.Declaration) + " "); option.Value = (bytes[pos++]) switch { (byte)TelnetOptions.Echo => TelnetOptions.Echo, (byte)TelnetOptions.SupressGoAhead => TelnetOptions.SupressGoAhead, (byte)TelnetOptions.FlowControl => TelnetOptions.FlowControl, // moar _ => TelnetOptions.Null, }; Debug.WriteLine(Enum.GetName(typeof(TelnetOptions), option.Value)); lastByte = b; }while (true);
public ClientNotifEventArgs(int sender, int[] uids, ISocketMessage cmd) { this.Sender = sender; this.Recvs = uids; this.Command = cmd; }
public T Call <T>(ISocketMessage socketMessage) where T : ISocketMessage { Send(socketMessage); return(Receive <T>()); }
/// <summary> /// /// </summary> /// <param name="clmngr"></param> /// <param name="request"></param> /// <returns>true = 继续接收数据</returns> public virtual bool HandleRequest(ClientManager clmngr, ISocketMessage request) { return true; }
public virtual void SendToClient(int sessionID, ISocketMessage msg) { if (sessionID <= 0 || msg == null) return; if (this._Clients.ContainsKey(sessionID)) { ClientManager clmngr = this._Clients[sessionID] as ClientManager; SendToClient(clmngr, msg); } }
protected override void WhenReceiving(ISessionData session, ISocketClient client, ISocketMessage message) { var user = _clientStates.Values.Where(c => c.ConnectionId == client.ConnectionId).SingleOrDefault(); if (user == null) { Debug.WriteLine($"{client.ConnectionId}: Invalid Connection"); return; } var success = (user.Flags) switch // discarding to use cooler syntax { ChatStates.Connected | ChatStates.Authenticated => ProcessMessage(session, client, message), ChatStates.Connected | ChatStates.Authenticating => ProcessPendingAuth(session, client, message), _ => false }; Debug.WriteLine($"{user.ConnectionId} {success}"); }
public virtual void SendToClient(ClientManager clmngr, ISocketMessage msg) { try { if (clmngr == null || msg == null || msg.Length == 0) return; byte[] buf = msg.GetBytes(); if (buf == null || buf.Length < 1) return; int i = clmngr.Socket.Send(buf, buf.Length, SocketFlags.None); } catch (Exception ex) { string strError = ex.Message; DebugMessage(string.Format("SendToClient Error:{0};Source:{1}", ex.Message, ex.Source)); } finally { } }
protected virtual void OnMessageReceived(SocketHandler handler, ISocketMessage message) { trace.TraceEvent(TraceEventType.Verbose, 0, $"Received { message.MessageTypeId } ({ message.MessageLength } bytes): {message.GetType()}"); this.MessageReceived?.Invoke(this, new SocketMessageEventArgs(message, handler)); }
public void SendMessage(ISocketMessage message) { var data = Serialize(new Parcel(message)); _pipe.Write(data); }