public static string Value()
{
if (string.IsNullOrEmpty(fingerPrint))
{
CounterToken counterToken = LogAgent.StartCounter();
string newValue = RegistryUtil.GetRegeditkeyValue(LicenseConstData.KeyRegistyPath, LicenseConstData.MacCodeKey);
if (string.IsNullOrEmpty(newValue))
{
string cpuId = CpuId();
string biosId = BiosId();
string baseId = BaseId();
fingerPrint = GetHash(
"\nCPU >> " + cpuId +
"\nBIOS >> " + biosId
+ "\nBASE >> " + baseId
);
RegistryUtil.SetSecurityLey(fingerPrint, LicenseConstData.KeyRegistyPath, LicenseConstData.MacCodeKey);
LogAgent.Info("CPU:" + cpuId + ";BIOS:" + biosId + ";BASE:" + baseId);
}
else
{
fingerPrint = newValue;
}
LogAgent.StopCounterAndLog(counterToken, "SystemUtil.Value:" + fingerPrint + " " + newValue);
}
return(fingerPrint);
}
/// <summary>
/// 执行方法前先执行这
/// </summary>
/// <param name="context"></param>
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
try
{
string Moudle = String.Format("接收[{0}-{1}]请求 {2}", MoudleName, MethodName, context.ActionDescriptor.DisplayName);
string RequestAddress = String.Format("RequestAddress: {0}:{1}", context.HttpContext.Connection.RemoteIpAddress.ToString(), context.HttpContext.Connection.RemotePort.ToString());
string URL = String.Format("uri: {0}", context.HttpContext.Request.Path.Value.ToString());
string method = String.Format("method: {0}", context.HttpContext.Request.Method.ToString());
string contentType = String.Format("contentType: {0}", context.HttpContext.Request.ContentType == null ? "null" : context.HttpContext.Request.ContentType.ToString());
string parameter = String.Format("parameter: {0}", JsonConvert.SerializeObject(context.ActionArguments));
StringBuilder message = new StringBuilder();
message.AppendLine(Moudle);
message.AppendLine(RequestAddress);
message.AppendLine(URL);
message.AppendLine(method);
message.AppendLine(contentType);
message.AppendLine(parameter);
LogAgent.Info(message.ToString());
CounterToken counterToken = LogAgent.StartCounter();
context.ActionDescriptor.Properties.TryAdd("Action-" + context.HttpContext.TraceIdentifier, counterToken);
}
catch (Exception ex)
{
LogAgent.Error(ex.ToString());
}
}
public void Close()
{
var originState = Interlocked.CompareExchange(ref _serverState, 3, 2);
if (originState != 2)
{
return;
}
try
{
_server.Close();
}
catch
{
}
var clientTransportList = _clientTransportDictionary.Values.ToList();
foreach (var transport in clientTransportList)
{
transport.Close();
}
_serverState = -1;
LogAgent.Info("server closed");
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="buffer"></param>
/// <param name="index"></param>
/// <param name="length"></param>
/// <param name="destination"></param>
public override void Send(byte[] buffer, int index, int length, INode destination)
{
var clientSocket = SocketMap[destination.nodeConfig.ToString()];
try
{
if (clientSocket.WasDisposed)
{
CloseConnection(clientSocket);
return;
}
var buf = Allocator.Buffer(length);
buf.WriteBytes(buffer, index, length);
Encoder.Encode(ConnectionAdapter, buf, out List <IByteBuf> encodedMessages);
foreach (var message in encodedMessages)
{
var state = CreateNetworkState(clientSocket.Local, destination, message, 0);
ListenerSocket.BeginSendTo(message.ToArray(), 0, message.ReadableBytes, SocketFlags.None,
destination.ToEndPoint <EndPoint>(), SendCallback, state);
LogAgent.Info(String.Format("发送数据-{0}-->>{1}", this.Listener.reactorType, this.Encoder.ByteEncode(message.ToArray())));
clientSocket.Receiving = true;
}
}
catch (Exception ex)
{
LogAgent.Error(ex.ToString());
CloseConnection(ex, clientSocket);
}
}
/// <summary>
/// 处理新任务
/// </summary>
private void ProcessNewTask()
{
try
{
var newTaskList = this.taskDocker.TaskList.Where(o => o.TaskState == TaskState.NewTask).ToList();
foreach (var task in newTaskList)
{
if (task.TaskState == TaskState.NewTask)
{
LogAgent.Info(String.Format("处理新任务:{0}", task.ToString()));
ProcessTask(task);
if (task.Dead)
{
task.Complete();
}
//else
//{
// this.connectionDocker.AddCase(task.GetRelatedProtocol());
//}
}
}
}
catch (Exception exception)
{
var m = exception.Message;
LogAgent.Error("处理新任务:" + m.ToString());
}
}
public void Stop(bool immediately = false)
{
if (!running)
{
throw new OperationCanceledException("ServiceBroker has already been signaled to Stop");
}
running = false;
notifications.CompleteAdding();
lock (lockWorkers)
{
// Kill all workers right away
if (immediately)
{
workers.ForEach(sw => sw.Cancel());
}
var all = (from sw in workers
select sw.WorkerTask).ToArray();
LogAgent.Info("Stopping: Waiting on Tasks");
Task.WaitAll(all);
LogAgent.Info("Stopping: Done Waiting on Tasks");
workers.Clear();
}
}
/// <summary>
/// 检查时间
/// </summary>
/// <param name="TimeSpan"></param>
/// <param name="response"></param>
/// <returns></returns>
public JsonResponse CheckLocalServerTime(long timeSpan, JsonResponse response)
{
if (!(response.data is Dictionary <string, object>))
{
LogAgent.Info("CheckLocalServerTime:" + JsonConvert.SerializeObject(response));
return(response);
}
Dictionary <string, object> Payload = response.data as Dictionary <string, object>;
if (Payload.ContainsKey("exp"))
{
long exp = Convert.ToInt64(Payload["exp"]);
if (timeSpan < exp)
{
response.code = JsonResponse.SuccessCode;
response.data = Payload;
response.msg = "校准成功";
return(response);
}
else
{
response.code = (int)ErrorCodeEnums.TokenExpired;
response.msg = ErrorCodeEnums.TokenExpired.GetEnumDescription();
LogAgent.Info(String.Format("注册码已过期:localExp:{0},ServerExp:{1}", exp, timeSpan));
if (File.Exists(this.LicensePath))
{
File.Delete(this.LicensePath);
LogAgent.Info("CheckAuthorize:删除文件" + this.LicensePath + " " + response.msg);
}
}
}
return(response);
}
/// <summary>
/// 用于输出参数化查询语句的SQL语句
/// </summary>
/// <param name="sSQL"></param>
/// <param name="t"></param>
/// <returns></returns>
public static string doGetSQL(string sSQL, DbParameter[] cmdParms)
{
string sSQLResult = sSQL;
try
{
foreach (var propertyInfo in cmdParms)
{
DbParameter obj = (DbParameter)propertyInfo;
if (obj == null || obj.Value == null)
{
sSQLResult = sSQLResult.Replace(obj.ParameterName, "null");
}
else
{
sSQLResult = sSQLResult.Replace(obj.ParameterName, obj.Value.ToString());
}
}
}
catch (Exception ex)
{
sSQLResult = "Export SQL Error:" + ex.ToString();
}
LogAgent.Info(String.Format("[SQL]:{0}", sSQLResult));
return(sSQLResult);
}
public void Close()
{
if (_serverState == 0)
{
return;
}
if (_serverState == -1)
{
return;
}
var oldValue = Interlocked.Exchange(ref _serverState, -1);
if (oldValue == -1)
{
return;
}
try
{
_server.Stop();
}
catch
{
}
LogAgent.Info("server closed");
}
/// <summary>
/// 执行带body体的POST请求。
/// </summary>
/// <param name="url">请求地址，含URL参数</param>
/// <param name="body">请求body体字节流</param>
/// <param name="contentType">body内容类型</param>
/// <param name="headerParams">请求头部参数</param>
/// <returns>HTTP响应</returns>
public string DoPostJson(BrowserPara browserPara)
{
LogAgent.Info("[Request]->Url:{0};Parameter:{1};Method:{2}", browserPara.Uri, browserPara.PostData, browserPara.Method.ToString());
string url = browserPara.Uri;
HttpWebRequest req = GetWebRequest(browserPara, "POST");
req.ContentType = browserPara.ContentType;
string boundary = DateTime.Now.Ticks.ToString("X"); // 随机分隔线
req.ContentType = "multipart/form-data;charset=utf-8;boundary=" + boundary;
System.IO.Stream reqStream = req.GetRequestStream();
byte[] itemBoundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "\r\n");
byte[] endBoundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "--\r\n");
reqStream.Write(endBoundaryBytes, 0, endBoundaryBytes.Length);
reqStream.Close();
HttpWebResponse rsp = (HttpWebResponse)req.GetResponse();
Encoding encoding = GetResponseEncoding(rsp);
string responseFromServer = GetResponseAsString(req, rsp, encoding);
LogAgent.Info(req.CookieContainer.GetCookieHeader(new Uri(browserPara.Uri)));
LogAgent.Info("[Response]->Url:{0};{1}", browserPara.Uri, responseFromServer);
return(responseFromServer);
}
/// <summary>
/// 移除任务
/// </summary>
/// <param name="connectionTask"></param>
/// <returns></returns>
public virtual bool RemoveTask(ConnectionTask connectionTask)
{
bool result = this.taskDocker.RemoveTask(connectionTask);
this.connectionDocker.SetCaseAsDead(connectionTask);
LogAgent.Info(String.Format("处理超时任务:{0}", connectionTask.ToString()));
return(result);
}
///// <summary>
/// 处理数据
/// </summary>
/// <param name="receiveState"></param>
private void ReceiveCallback(IAsyncResult ar)
{
var receiveState = (NetworkState)ar.AsyncState;
try
{
var received = ListenerSocket.EndReceiveFrom(ar, ref RemoteEndPoint);
if (received == 0)
{
return;
}
var remoteAddress = (IPEndPoint)RemoteEndPoint;
receiveState.RemoteHost = remoteAddress.ToNode(ReactorType.Udp);
INode node = receiveState.RemoteHost;
if (SocketMap.ContainsKey(receiveState.RemoteHost.nodeConfig.ToString()))
{
var connection = SocketMap[receiveState.RemoteHost.nodeConfig.ToString()];
node = connection.RemoteHost;
}
else
{
RefactorRequestChannel requestChannel = new RefactorProxyRequestChannel(this, node, "none");
SocketMap.Add(node.nodeConfig.ToString(), requestChannel);
}
receiveState.Buffer.WriteBytes(receiveState.RawBuffer, 0, received);
Decoder.Decode(ConnectionAdapter, receiveState.Buffer, out List <IByteBuf> decoded);
foreach (var message in decoded)
{
var networkData = NetworkData.Create(receiveState.RemoteHost, message);
LogAgent.Info(String.Format("Socket收到数据-->>{0}", this.Encoder.ByteEncode(networkData.Buffer)));
if (ConnectionAdapter is ReactorConnectionAdapter)
{
((ReactorConnectionAdapter)ConnectionAdapter).networkDataDocker.AddNetworkData(networkData);
((EventWaitHandle)((ReactorConnectionAdapter)ConnectionAdapter).protocolEvents[(int)ProtocolEvents.PortReceivedData]).Set();
}
}
//清除数据继续接收
receiveState.RawBuffer = new byte[receiveState.RawBuffer.Length];
ListenerSocket.BeginReceiveFrom(receiveState.RawBuffer, 0, receiveState.RawBuffer.Length, SocketFlags.None,
ref RemoteEndPoint, ReceiveCallback, receiveState);
}
catch //node disconnected
{
if (SocketMap.ContainsKey(receiveState.RemoteHost.nodeConfig.ToString()))
{
var connection = SocketMap[receiveState.RemoteHost.nodeConfig.ToString()];
CloseConnection(connection);
}
}
}
/// <summary>
/// 客户端关闭触发事件
/// </summary>
/// <param name="session"></param>
/// <param name="value"></param>
private void WebSocket_SessionClosed(WebSocketSession session, CloseReason value)
{
try
{
LogAgent.Info(Websocket.Name + string.Format(" Session Close:{0}, Path:{1}, IP:{2}", value.ToString(), session.Path, session.RemoteEndPoint));
}
catch (Exception e)
{
LogAgent.Info(string.Format("{0} Websocket_SessionClosed()", e.ToString()));
}
}
/// <summary>
/// 新消息收到事件
/// </summary>
/// <param name="session"></param>
/// <param name="value"></param>
private void WebSocket_NewMessageReceived(WebSocketSession session, string value)
{
try
{
LogAgent.Info(Websocket.Name + " ClientIP:" + session.RemoteEndPoint + "Receive:" + value.ToString());
}
catch (Exception e)
{
LogAgent.Info(string.Format("{0} Websocket_NewMessageReceived()", e.ToString()));
}
}
/// <summary>
/// 处理端口缓冲区收到的端口数据。
/// </summary>
protected virtual void ProcessReceivedData(NetworkData networkData)
{
string ProtocolTag = networkData.RemoteHost.TaskTag;
IConnection connection = this.connectionDocker.GetCase(ProtocolTag);
if (connection != null)
{
string content = connection.Encoder.ByteEncode(networkData.Buffer);
LogAgent.Info(String.Format("协议层消息处理【{0}】：{1}", networkData.RemoteHost.ToString(), content));
connection.StopReceive();
}
}
/// <summary>
/// 执行HTTP GET请求。
/// </summary>
/// <param name="url">请求地址</param>
/// <param name="textParams">请求文本参数</param>
/// <param name="headerParams">请求头部参数</param>
/// <returns>HTTP响应</returns>
public string DoGet(BrowserPara browserPara)
{
LogAgent.Info("[Request]->Url:{0};Parameter:{1};Method:{2}", browserPara.Uri, browserPara.PostData, browserPara.Method.ToString());
HttpWebRequest req = GetWebRequest(browserPara, "GET");
req.ContentType = "application/x-www-form-urlencoded;charset=utf-8";
HttpWebResponse rsp = (HttpWebResponse)req.GetResponse();
Encoding encoding = GetResponseEncoding(rsp);
string responseFromServer = GetResponseAsString(req, rsp, encoding);
LogAgent.Info("[Response]->Url:{0};{1}", browserPara.Uri, responseFromServer);
return(responseFromServer);
}
/// <summary>
/// 客户端新链接事件
/// </summary>
/// <param name="session"></param>
private void WebSocket_NewSessionConnected(WebSocketSession session)
{
try
{
LogAgent.Info(string.Format(Websocket.Name + " New Session Connected:{0}, Path:{1}, Host:{2}, IP:{3}",
session.SessionID.ToString(), session.Path, session.Host, session.RemoteEndPoint));
RaiseNewConnection(new WebSocketNotifications(session));
}
catch (Exception e)
{
LogAgent.Info(string.Format("{0} Websocket_NewSessionConnected()", e.ToString()));
}
}
/// <summary>
/// 处理响应的cookies
/// </summary>
/// <param name="cookies"></param>
public static void ProcessCookies(CookieCollection cookies)
{
foreach (Cookie cookie in cookies)
{
if (m_cookies.ContainsKey(cookie.Name))
{
//m_cookies[cookie.Name] = cookie.Value;
}
else
{
m_cookies.Add(cookie.Name, cookie.Value);
}
LogAgent.Info(cookie.Name + "==" + cookie.Value);
}
}
/// <summary>
/// 移除一个任务
/// </summary>
/// <param name="task">被移除的任务</param>
internal bool RemoveTask(ConnectionTask task)
{
bool result;
lock (taskListBlocking)
{
ConnectionTask connectionTask;
result = taskListBlocking.TryTake(out connectionTask, NetworkConstants.DefaultTaskInterval, task.cancellationToken);
}
if (result)
{
string LogMsg = string.Format("协议“{0}”中“{1}”任务已结束。", task.GetRelatedProtocol().Local.ToString(), task.Name);
LogAgent.Info(LogMsg);
}
return(result);
}
public static string HttpGet(BrowserPara browserPara)
{
try
{
LogAgent.Info("[Request]->Url:{0};Parameter:{1};Method:{2}", browserPara.Uri, browserPara.PostData, browserPara.Method.ToString());
HttpWebRequest request = WebRequest.Create(browserPara.Uri) as HttpWebRequest;
//每次请求绕过代理，解决第一次调用慢的问题
request.Proxy = null;
//使用已经保存的cookies
//多线程并发调用时默认2个http连接数限制的问题，讲其设为1000
ServicePoint currentServicePoint = request.ServicePoint;
currentServicePoint.ConnectionLimit = 1000;
if (browserPara.Headers != null)
{
foreach (var header in browserPara.Headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
string cookie = GetCookie();
if (!String.IsNullOrEmpty(cookie))
{
request.Headers.Add("Cookie", cookie);
}
string str;
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
using (Stream responseStream = response.GetResponseStream())
{
StreamReader reader = new StreamReader(responseStream, Encoding.UTF8);
str = reader.ReadToEnd();
}
ProcessResponseCookies(request, response);
request.Abort();
request = null;
}
LogAgent.Info("[Response]->Url:{0};{1}", browserPara.Uri, str);
return(str);
}
catch (Exception ex)
{
LogAgent.Error(ex.ToString());
}
return(String.Empty);
}
public JsonResponse Validate(string token, string OriginalStr)
{
JsonResponse jsonResponse = JsonResponse.Failed.Clone() as JsonResponse;
try
{
string json = Decrypt(token);
if (!String.IsNullOrEmpty(json))
{
Dictionary <string, object> Payload = JsonConvert.DeserializeObject <Dictionary <string, object> >(json);
if (Payload.ContainsKey("jti") && OriginalStr == Payload["jti"].ToString())
{
jsonResponse.code = JsonResponse.SuccessCode;
jsonResponse.data = Payload;
jsonResponse.msg = "激活成功";
}
else
{
jsonResponse.code = (int)ErrorCodeEnums.MacCodeKeyChange;
jsonResponse.msg = ErrorCodeEnums.MacCodeKeyChange.GetEnumDescription();
LogAgent.Info(String.Format("tokenKey:{0};LocalKey:{1}", OriginalStr, Payload["jti"].ToString()));
}
return(jsonResponse);
}
jsonResponse.msg = ErrorCodeEnums.SignatureKeyEmpty.GetEnumDescription();
jsonResponse.code = (int)ErrorCodeEnums.SignatureKeyEmpty;
}
catch (TokenExpiredException ex)
{
jsonResponse.msg = ErrorCodeEnums.TokenExpired.GetEnumDescription();
jsonResponse.code = (int)ErrorCodeEnums.TokenExpired;
LogAgent.Info(String.Format("token:{0};ExpiredTime:{1}", token, ex.Expiration));
}
catch (SignatureVerificationException)
{
jsonResponse.msg = ErrorCodeEnums.SignatureError.GetEnumDescription();
jsonResponse.code = (int)ErrorCodeEnums.SignatureError;
}
catch (Exception ex)
{
jsonResponse.msg = "该激活码不正确!";
LogAgent.Error(ex.ToString());
}
LogAgent.Info("Validate:" + token + ";result:" + jsonResponse.msg);
return(jsonResponse);
}
/// <summary>
/// 停止工作进程
/// </summary>
/// <param name="immediately"></param>
public void StopWorker(bool immediately = false)
{
lock (lockWorkers)
{
// Kill all workers right away
if (immediately)
{
workers.ForEach(sw => sw.Cancel());
}
var all = (from sw in workers
select sw.WorkerTask).ToArray();
LogAgent.Info("Stopping: Waiting on Tasks");
Task.WaitAll(all);
LogAgent.Info("Stopping: Done Waiting on Tasks");
workers.Clear();
}
}
/// <summary>
/// 校验服务器时间
/// </summary>
/// <param name="TimeSpan"></param>
/// <returns></returns>
public JsonResponse CheckAuthorizeServerTime(long TimeSpan)
{
JsonResponse jsonResponse = JsonResponse.Failed.Clone() as JsonResponse;
try
{
jsonResponse = CheckLocalAuthorize();
if (jsonResponse.ValidateResponses())
{
jsonResponse = CheckLocalServerTime(TimeSpan, jsonResponse);
}
}
catch (Exception ex)
{
LogAgent.Info(ex.ToString());
}
return(jsonResponse);
}
private void RegisterService(string serviceName, string actionName, object service, Type serviceType, MethodInfo methodInfo, IRpcSerializer rpcSerializer)
{
var typeArray = DynamicProxyHelper.GetParameterTypes(methodInfo.GetParameters());
if (typeArray.Length > 10)
{
throw new ArgumentException(string.Format("RegisterService error,service:{0},action:{1}, parameters count is not valid, max method parameter count is {2} ", serviceName, actionName, 10));
}
var parameterTupleType = CustomTuple.CreateType(typeArray);
var title = DynamicProxyHelper.FormatTitle(serviceName, actionName, typeArray, methodInfo.ReturnType);
var invocation = new Invocation(title, serviceType, methodInfo, parameterTupleType, rpcSerializer);
_invocationDictionary.TryAdd(invocation.Key, invocation);
LogAgent.Info(string.Format("RegisterService -> {0}", title));
}
/// <summary>
/// 执行HTTP POST请求。
/// </summary>
/// <param name="url">请求地址</param>
/// <param name="textParams">请求文本参数</param>
/// <param name="headerParams">请求头部参数</param>
/// <returns>HTTP响应</returns>
public string DoPost(BrowserPara browserPara)
{
LogAgent.Info("[Request]->Url:{0};Parameter:{1};Method:{2}", browserPara.Uri, browserPara.PostData, browserPara.Method.ToString());
string url = browserPara.Uri;
HttpWebRequest req = GetWebRequest(browserPara, "Post");
req.ContentType = browserPara.ContentType;
byte[] postData = Encoding.UTF8.GetBytes(browserPara.PostData);
System.IO.Stream reqStream = req.GetRequestStream();
reqStream.Write(postData, 0, postData.Length);
reqStream.Close();
HttpWebResponse rsp = (HttpWebResponse)req.GetResponse();
Encoding encoding = GetResponseEncoding(rsp);
string responseFromServer = GetResponseAsString(req, rsp, encoding);
LogAgent.Info("[Response]->Url:{0};{1}", browserPara.Uri, responseFromServer);
return(responseFromServer);
}
/// <summary>
/// 检查注册码是否正确
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public JsonResponse CheckAuthorize(string code)
{
JsonResponse result = VerifyCode(code);
if (result.ValidateResponses() || result.code == (int)ErrorCodeEnums.TokenExpired)
{
licenseSaveHandles.FinalCode = code;
SaveToFile();
}
else
{
if (File.Exists(this.LicensePath))
{
File.Delete(this.LicensePath);
LogAgent.Info("CheckAuthorize:删除文件" + this.LicensePath + " " + result.msg);
}
}
return(result);
}
/// <summary>
/// 用于输出参数化查询语句的SQL语句
/// </summary>
/// <param name="sSQL"></param>
/// <param name="t"></param>
/// <returns></returns>
public static string doGetSQL(string sSQL, DbParameter[] cmdParms)
{
string sSQLResult = sSQL;
try
{
foreach (var propertyInfo in cmdParms)
{
DbParameter obj = (DbParameter)propertyInfo;
sSQLResult = sSQLResult.Replace(obj.ParameterName, obj.Value.ToString());
}
}
catch
{
sSQLResult = "Export SQL Error";
}
LogAgent.Info(String.Format("[SQL]:{0}", sSQLResult));
return(sSQLResult);
}
/// <summary>
/// 获取菜单所有列表
/// </summary>
/// <param name="loginInfo"></param>
/// <returns></returns>
public PageResponse <UcLoginLog> GetUcLoginLogPageList(PageModel page, LogQueryForm logQueryForm)
{
try
{
RequestBase request = RequestBase.Get.Clone() as RequestBase;
request.SetValue("pageIndex", page.PageIndex, true);
request.SetValue("pageIndex", page.PageIndex);
request.SetValue("pageSize", page.PageSize);
request.SetValue("keywords", logQueryForm.keywords);
request.SetValue("queryNo", logQueryForm.queryNo);
request.SetValue("handleUser", logQueryForm.HandleUser);
request.Url = GetPageUrl;
return(sdkUtil.PostForResultVo <PageResponse <UcLoginLog> >(request));
}
catch (Exception ex)
{
LogAgent.Info(ex.ToString());
}
return(new PageResponse <UcLoginLog>());
}
/// <summary>
/// 处理端口缓冲区收到的端口数据。
/// </summary>
protected virtual void ProcessReceivedData(NetworkData networkData)
{
FrameBase frameBase = this.ParsingReceivedData(networkData.Buffer);
if (frameBase.Equals(FrameBase.ResultOfParsingFrame.ReceivingCompleted))
{
IConnection connection = this.GetConnection(frameBase);
if (connection != null && connection is RefactorRequestChannel)
{
connection.Receiving = false;
RefactorRequestChannel requestChannel = (RefactorRequestChannel)connection;
if (requestChannel.Sender.TotalSendTimes != NetworkConstants.WAIT_FOR_COMPLETE)
{
requestChannel.Sender.EndSend();
}
}
}
else
{
LogAgent.Info("丢弃非法数据-->>" + this.Encoder.ByteEncode(networkData.Buffer));
}
}
public void Close()
{
if (_serverState == 0)
{
return;
}
if (_serverState == -1)
{
return;
}
var oldValue = Interlocked.Exchange(ref _serverState, -1);
if (oldValue == -1)
{
return;
}
try
{
_server.Close();
}
catch
{
}
var clientTransportList = _clientTransportDictionary.Values.ToList();
foreach (var transport in clientTransportList)
{
transport.Close();
}
LogAgent.Info("server closed");
}
