EfemServerSocket.cs 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336
  1. using System;
  2. using System.Text;
  3. using System.Threading;
  4. using Aitex.Core.RT.Event;
  5. using Aitex.Core.RT.Log;
  6. using SuperSocket.SocketBase;
  7. using SuperSocket.SocketBase.Protocol;
  8. namespace Aitex.Sorter.RT.EFEMs.Servers
  9. {
  10. public class RData
  11. {
  12. public string StartMark { get; set; }
  13. public string EndMark { get; set; }
  14. public string Key { get; set; }
  15. public byte[] BodyBuffer { get; set; }
  16. public string BodyString { get; set; }
  17. }
  18. public class RRequestInfo : RequestInfo<RData>
  19. {
  20. public RRequestInfo(string key, RData data)
  21. {
  22. Initialize(key, data);
  23. }
  24. }
  25. public class RReceiveFilter : IReceiveFilter<RRequestInfo>
  26. {
  27. public int leftBufferSize;
  28. public Encoding Encoder = Encoding.GetEncoding("gbk");
  29. public string StartMark = "!Start";
  30. public string EndMark = "$End";
  31. public RReceiveFilter(Encoding encoder, string startMark, string endMark)
  32. {
  33. Encoder = encoder;
  34. StartMark = startMark;
  35. EndMark = endMark;
  36. }
  37. public RRequestInfo Filter(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest)
  38. {
  39. rest = 0;
  40. byte[] startMarkBuffer = Encoder.GetBytes(StartMark);
  41. byte[] endMarkBuffer = Encoder.GetBytes(EndMark);
  42. if (length < startMarkBuffer.Length + endMarkBuffer.Length)
  43. return null;
  44. byte[] data = new byte[length];
  45. Buffer.BlockCopy(readBuffer, offset, data, 0, length);
  46. string receiveStartMark = Encoder.GetString(data, 0, startMarkBuffer.Length);
  47. string receiveEndMark = Encoder.GetString(data, length - endMarkBuffer.Length, endMarkBuffer.Length);
  48. RData receiveData = new RData();
  49. receiveData.StartMark = StartMark;
  50. receiveData.Key = Guid.NewGuid().ToString("B");
  51. receiveData.BodyBuffer = new byte[length - startMarkBuffer.Length - endMarkBuffer.Length];
  52. Buffer.BlockCopy(data, startMarkBuffer.Length, receiveData.BodyBuffer, 0, length - startMarkBuffer.Length - endMarkBuffer.Length);
  53. receiveData.EndMark = EndMark;
  54. receiveData.BodyString = Encoder.GetString(receiveData.BodyBuffer);
  55. leftBufferSize = length - startMarkBuffer.Length - endMarkBuffer.Length;
  56. if (!receiveStartMark.Equals(StartMark) || !receiveEndMark.Equals(EndMark))
  57. return null;
  58. return new RRequestInfo(receiveData.Key, receiveData);
  59. }
  60. public int LeftBufferSize
  61. {
  62. get { return leftBufferSize; }
  63. }
  64. /// <summary>
  65. ///
  66. /// </summary>
  67. public SuperSocket.SocketBase.Protocol.IReceiveFilter<RRequestInfo> NextReceiveFilter
  68. {
  69. get { return this; }
  70. }
  71. public void Reset()
  72. {
  73. }
  74. public SuperSocket.SocketBase.Protocol.FilterState State
  75. {
  76. get;
  77. private set;
  78. }
  79. }
  80. public class RReceiveFilterFactory : SuperSocket.SocketBase.Protocol.IReceiveFilterFactory<RRequestInfo>
  81. {
  82. /// <summary>
  83. /// 字符编码
  84. /// </summary>
  85. public Encoding Encoder = Encoding.GetEncoding("gbk");
  86. public string StartMark = "!Start";
  87. public string EndMark = "$End";
  88. public RReceiveFilterFactory(Encoding encoder, string startMark, string endMark)
  89. {
  90. Encoder = encoder;
  91. StartMark = startMark;
  92. EndMark = endMark;
  93. }
  94. public SuperSocket.SocketBase.Protocol.IReceiveFilter<RRequestInfo> CreateFilter(SuperSocket.SocketBase.IAppServer appServer, SuperSocket.SocketBase.IAppSession appSession, System.Net.IPEndPoint remoteEndPoint)
  95. {
  96. return new RReceiveFilter(Encoder, StartMark, EndMark);
  97. }
  98. }
  99. public class RAppSession : SuperSocket.SocketBase.AppSession<RAppSession, RRequestInfo>
  100. {
  101. public uint DeviceUDID;
  102. protected override void HandleException(Exception e)
  103. {
  104. }
  105. }
  106. public class InvalidPackageException : ApplicationException
  107. {
  108. public InvalidPackageException(string msg)
  109. : base(msg)
  110. {
  111. }
  112. public override string Message
  113. {
  114. get
  115. {
  116. return base.Message;
  117. }
  118. }
  119. }
  120. public class RAppServer : SuperSocket.SocketBase.AppServer<RAppSession, RRequestInfo>
  121. {
  122. public static Encoding Encoder = Encoding.GetEncoding("gbk");
  123. public static string StartMark = string.Empty;
  124. public static string EndMark = ";\r";
  125. public RAppServer()
  126. : base(new RReceiveFilterFactory(Encoder, StartMark, EndMark))
  127. {
  128. }
  129. public RAppServer(Encoding encoder, string startMark, string endMark)
  130. : base(new RReceiveFilterFactory(encoder, startMark, endMark))
  131. {
  132. RAppServer.Encoder = encoder;
  133. RAppServer.StartMark = startMark;
  134. RAppServer.EndMark = endMark;
  135. }
  136. }
  137. public interface IEfemServerSocketCallback
  138. {
  139. void OnConnected(string sessionId);
  140. void OnDisconnected(string sessionId);
  141. void OnReceived(string msg);
  142. }
  143. public class EfemServerSocket
  144. {
  145. private RAppServer _server = null;
  146. private static Object _lockerSession = new Object();
  147. private RAppSession _session = null;
  148. private string _endMark;
  149. private IEfemServerSocketCallback _callback;
  150. private int _port;
  151. private bool _isFirstTimeReadyInfoMessage = true;
  152. public EfemServerSocket(IEfemServerSocketCallback callback, int port, string endMark = ";\r")
  153. {
  154. _endMark = endMark;
  155. _callback = callback;
  156. _port = port;
  157. _server = new RAppServer(Encoding.ASCII, string.Empty, _endMark);
  158. _server.NewSessionConnected += OnNewSessionConnected;
  159. _server.SessionClosed += OnSessionClosed;
  160. _server.NewRequestReceived += OnReceive;
  161. }
  162. public void Send(string msg)
  163. {
  164. if (_session != null)
  165. {
  166. if (!msg.StartsWith("INFO:READY") || (msg.StartsWith("INFO:READY") && _isFirstTimeReadyInfoMessage))
  167. {
  168. EV.PostInfoLog("Server", string.Format("[Send] {0};", msg));
  169. _isFirstTimeReadyInfoMessage = false;
  170. }
  171. lock (_lockerSession)
  172. {
  173. _session.Send(string.Format("{0};\r", msg));
  174. }
  175. }
  176. else
  177. {
  178. LOG.Write($"Session is null, can not send out {msg}");
  179. }
  180. }
  181. void OnNewSessionConnected(RAppSession session)
  182. {
  183. EV.PostInfoLog("Server", string.Format("Client {0} connected", session.SessionID));
  184. lock (_lockerSession)
  185. {
  186. if (_session != null)
  187. {
  188. EV.PostWarningLog("Server",
  189. string.Format("New connection in, previous connection {0} removed", _session.SessionID));
  190. _session.Close();
  191. }
  192. _session = session;
  193. }
  194. _callback.OnConnected(_session.SessionID);
  195. }
  196. void OnSessionClosed(RAppSession session, CloseReason reason)
  197. {
  198. EV.PostInfoLog("Server", $"Client {session.SessionID} Disconnected, {reason}");
  199. lock (_lockerSession)
  200. {
  201. if (_session != null && _session.SessionID == session.SessionID)
  202. {
  203. _session = null;
  204. }
  205. }
  206. _callback.OnDisconnected(session.SessionID);
  207. }
  208. void OnReceive(RAppSession session, RRequestInfo requestInfo)
  209. {
  210. string msgOrigin = requestInfo.Body.BodyString;
  211. EV.PostInfoLog("Server", string.Format("[Recv] {0};", msgOrigin));
  212. string[] cmdList = msgOrigin.Split(new char[] {';', '\r'}, StringSplitOptions.RemoveEmptyEntries);
  213. for (int i = 0; i < cmdList.Length; i++)
  214. {
  215. _callback.OnReceived(cmdList[i]);
  216. Thread.Sleep(50);
  217. }
  218. }
  219. public bool Start(string server, int port)
  220. {
  221. _server.Stop();
  222. if (_server.State == ServerState.NotInitialized)
  223. {
  224. if (!_server.Setup(server, port))
  225. {
  226. EV.PostAlarmLog("Server", $"Can not create server {server}:{port}");
  227. return false;
  228. }
  229. }
  230. if (!_server.Start())
  231. {
  232. EV.PostAlarmLog("Server", $"Can not listen on {server}:{port}");
  233. return false;
  234. }
  235. EV.PostInfoLog("Server", $"Listen on {server}:{port}");
  236. return true;
  237. }
  238. public void Stop()
  239. {
  240. if (_session != null)
  241. {
  242. lock (_lockerSession)
  243. {
  244. _session.Close();
  245. }
  246. }
  247. _server.Stop();
  248. EV.PostInfoLog("EFEM", $"Stopped Listen on {_port}");
  249. }
  250. }
  251. }