public void Send(NpcSocketMsg msg)
{
if (SocketState == SocketState.Connected)
{
if (!_ignoreList.Contains(msg.MsgType))
{
_msgQueue.Enqueue(msg);
Console.WriteLine($"{DateTime.Now} {msg.MsgType} -----------{ServerId} Send Wait");
}
else
{
var writer = new SocketBufferWriter();
writer.WriteString(msg);
Send(writer.Finish());
}
}
//if (SocketState == SocketState.Connected)
//{
// if (!_ignoreList.Contains(msg.MsgType))
// {
// _msgQueue.Enqueue(msg);
// }
// var writer = new SocketBufferWriter();
// writer.WriteString(msg);
// Send(writer.Finish());
// if (!_ignoreList.Contains(msg.MsgType))
// {
// Console.WriteLine($"{DateTime.Now} {msg.MsgType} -----------{ServerId} Send Finish");
// }
//}
}
public void Send(NpcSocketMsg msg)
{
if (SocketState == SocketState.Connected)
{
var writer = new SocketBufferWriter();
writer.WriteString(msg);
Send(writer.Finish());
if (!_ignoreList.Contains(msg.MsgType))
{
//Console.WriteLine($"{DateTime.Now} {msg.MsgType} -----------{ServerId} Send Finish");
}
}
}
private static void GetFromServer(IEnumerable <int> serverList = null)
{
var clientSockets = serverList != null && serverList.Any() ? _clientSockets.Where(x => serverList.Contains(x.ServerId)) : _clientSockets;
for (var index = clientSockets.Count() - 1; index >= 0; index--)
{
var clientSocket = _clientSockets[index];
var successMsg = new NpcSocketMsg
{
MsgType = NpcSocketMsgType.List,
};
clientSocket.Send(successMsg);
}
}
private void Heart(object state)
{
if (_isSocketTry)
{
if ((DateTime.Now - _lastTime).TotalSeconds > 30)
{
_isSocketTry = false;
}
return;
}
if (SocketState == SocketState.Connected)
{
if (_lastTime != default(DateTime) && (DateTime.Now - _lastTime).TotalSeconds > 10)
{
Console.WriteLine("超时");
SocketState = SocketState.Close;
return;
}
try
{
var msg = new NpcSocketMsg
{
MsgType = NpcSocketMsgType.Heart,
};
var writer = new SocketBufferWriter();
writer.WriteString(msg);
var s = writer.Finish();
Send(s);
}
catch (Exception ex)
{
_isNormal = false;
SocketState = SocketState.Fail;
Log.Error($"Heart Error, {ex.Message}, {ex.StackTrace}");
}
}
else
{
Connect();
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try
{
_lastTime = DateTime.Now;
var ts = (Socket)ar.AsyncState;
var rEnd = ts.EndReceive(ar);
if (rEnd > 0)
{
var partBytes = new byte[rEnd];
Array.Copy(_mBuffer, 0, partBytes, 0, rEnd);
//在此次可以对data进行按需处理
var mHeader = Encoding.UTF8.GetString(partBytes.Take(2).ToArray());
if (mHeader == SocketBufferReader.Header)
{
_reader = new SocketBufferReader();
partBytes = partBytes.Skip(2).ToArray();
_reader.MDataLength = BitConverter.ToInt32(partBytes.Take(4).ToArray(), 0);
partBytes = partBytes.Skip(4).ToArray();
}
if (_reader != null)
{
_reader.SocketBufferReaderAdd(partBytes);
if (_reader.IsValid)
{
var data = _reader.ReadString();
Task.Run(() =>
{
var msg = JsonConvert.DeserializeObject <NpcSocketMsg>(data);
if (!_ignoreList.Contains(msg.MsgType))
{
Send(new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = NpcSocketMsgType.ReceiveSuccess
});
//Console.WriteLine($"{DateTime.Now} {msg.MsgType} -----------Receive Done");
}
NpcSocketMsg responseMsg = null;
List <DeviceInfo> devicesList;
var dataErrResult = new DataErrResult();
switch (msg.MsgType)
{
case NpcSocketMsgType.Heart:
//responseMsg = new NpcSocketMsg
//{
// MsgType = NpcSocketMsgType.HeartSuccess,
//};
break;
case NpcSocketMsgType.HeartSuccess:
//Console.WriteLine("连接正常");
if (_isNormal == false)
{
_isNormal = true;
Log.Info("连接Gate正常");
}
break;
case NpcSocketMsgType.List:
//设备列表
responseMsg = new NpcSocketMsg
{
MsgType = msg.MsgType,
Body = ClientManager.GetDevices().ToJSON()
};
break;
case NpcSocketMsgType.Add:
devicesList = JsonConvert.DeserializeObject <List <DeviceInfo> >(msg.Body);
dataErrResult.datas.AddRange(ClientManager.AddClient(devicesList));
responseMsg = new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = msg.MsgType,
Body = dataErrResult.ToJSON()
};
break;
case NpcSocketMsgType.Delete:
devicesList = JsonConvert.DeserializeObject <List <DeviceInfo> >(msg.Body);
dataErrResult.datas.AddRange(ClientManager.DelClient(devicesList));
responseMsg = new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = msg.MsgType,
Body = dataErrResult.ToJSON()
};
break;
case NpcSocketMsgType.Update:
devicesList = JsonConvert.DeserializeObject <List <DeviceInfo> >(msg.Body);
dataErrResult.datas.AddRange(ClientManager.UpdateClient(devicesList));
responseMsg = new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = msg.MsgType,
Body = dataErrResult.ToJSON()
};
break;
case NpcSocketMsgType.Storage:
devicesList = JsonConvert.DeserializeObject <List <DeviceInfo> >(msg.Body);
dataErrResult.datas.AddRange(ClientManager.SetStorage(devicesList));
responseMsg = new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = msg.MsgType,
Body = dataErrResult.ToJSON()
};
break;
case NpcSocketMsgType.Frequency:
devicesList = JsonConvert.DeserializeObject <List <DeviceInfo> >(msg.Body);
dataErrResult.datas.AddRange(ClientManager.SetFrequency(devicesList));
responseMsg = new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = msg.MsgType,
Body = dataErrResult.ToJSON()
};
break;
case NpcSocketMsgType.SendBack:
devicesList = JsonConvert.DeserializeObject <List <DeviceInfo> >(msg.Body);
var messageResult = new MessageResult();
messageResult.messages.AddRange(ClientManager.SendMessageBack(devicesList));
responseMsg = new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = msg.MsgType,
Body = messageResult.ToJSON()
};
break;
case NpcSocketMsgType.UpgradeClient:
var upgradeInfos = JsonConvert.DeserializeObject <UpgradeInfos>(msg.Body);
Console.WriteLine($"{DateTime.Now} {msg.MsgType} {upgradeInfos.Infos.Select(x => x.DeviceId).ToJSON()} -----------{ServerId} Deal");
switch (upgradeInfos.Type)
{
case 1:
dataErrResult.datas.AddRange(ClientManager.UpgradeScript(upgradeInfos.Infos));
break;
case 2:
dataErrResult.datas.AddRange(ClientManager.UpgradeFirmware(upgradeInfos.Infos));
break;
case 3:
dataErrResult.datas.AddRange(upgradeInfos.Infos.Select(x => new DeviceErr(x.DeviceId, Error.ParamError)));
break;
default:
dataErrResult.datas.AddRange(upgradeInfos.Infos.Select(x => new DeviceErr(x.DeviceId, Error.ParamError)));
break;
}
responseMsg = new NpcSocketMsg
{
Guid = msg.Guid,
MsgType = NpcSocketMsgType.UpgradeClientBack,
Body = dataErrResult.ToJSON()
};
break;
default:
break;
}
if (responseMsg != null)
{
//Console.WriteLine($"{DateTime.Now} {msg.MsgType} -----------send done");
Send(responseMsg);
}
});
_reader = null;
}
ReceiveData();
//_socket.BeginReceive(_mBuffer, 0, _mBuffer.Length, 0, new AsyncCallback(ReceiveCallback), null);
}
}
}
catch (Exception ex)
{
Log.Error($"ReceiveCallback Error, {ex.Message}, {ex.StackTrace}");
_isNormal = false;
SocketState = SocketState.Close;
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try
{
var ts = (Socket)ar.AsyncState;
var rEnd = ts.EndReceive(ar);
if (rEnd > 0)
{
var partBytes = new byte[rEnd];
Array.Copy(_mBuffer, 0, partBytes, 0, rEnd);
//在此次可以对data进行按需处理
var mHeader = Encoding.UTF8.GetString(partBytes.Take(2).ToArray());
if (mHeader == SocketBufferReader.Header)
{
_reader = new SocketBufferReader();
partBytes = partBytes.Skip(2).ToArray();
_reader.MDataLength = BitConverter.ToInt32(partBytes.Take(4).ToArray(), 0);
partBytes = partBytes.Skip(4).ToArray();
}
if (_reader != null)
{
_reader.SocketBufferReaderAdd(partBytes);
if (_reader.IsValid)
{
var data = _reader.ReadString();
Task.Run(() =>
{
var msg = JsonConvert.DeserializeObject <NpcSocketMsg>(data);
if (!_ignoreList.Contains(msg.MsgType))
{
Console.WriteLine($"{DateTime.Now} {msg.Guid} {msg.MsgType} -----------{ServerId} Receive");
}
NpcSocketMsg responseMsg = null;
switch (msg.MsgType)
{
case NpcSocketMsgType.ReceiveSuccess:
if (_msgQueue.TryPeek(out var firstMsg) && firstMsg.Guid == msg.Guid)
{
_msgQueue.TryDequeue(out _);
}
break;
case NpcSocketMsgType.Heart:
responseMsg = new NpcSocketMsg
{
MsgType = NpcSocketMsgType.HeartSuccess,
};
break;
case NpcSocketMsgType.HeartSuccess:
//Console.WriteLine("连接正常");
break;
case NpcSocketMsgType.List:
LastReceiveTime = DateTime.Now;
DeviceInfos = JsonConvert.DeserializeObject <List <DeviceInfo> >(msg.Body);
if (DeviceInfos.Any())
{
ServerId = DeviceInfos.First().ServerId;
}
break;
//case NpcSocketMsgType.Add:
//case NpcSocketMsgType.Delete:
//case NpcSocketMsgType.Storage:
//case NpcSocketMsgType.Frequency:
//case NpcSocketMsgType.SendBack:
// break;
default:
ServerManager.NpcSocketMsgs.TryAdd(msg.Guid, msg);
break;
}
if (responseMsg != null)
{
if (!_ignoreList.Contains(msg.MsgType))
{
Console.WriteLine($"{DateTime.Now} {msg.Guid} {msg.MsgType} -----------{ServerId} Send");
}
Send(responseMsg);
}
});
_reader = null;
}
ReceiveData();
//Socket.BeginReceive(_mBuffer, 0, _mBuffer.Length, 0, new AsyncCallback(ReceiveCallback), null);
}
}
}
catch (Exception ex)
{
Log.Error($"ReceiveCallback Error, {ex.Message}, {ex.StackTrace}");
SocketState = SocketState.Close;
}
}
private static IEnumerable <Tuple <int, string> > SocketResponseStr(IEnumerable <DeviceInfo> dealList, string urlKey, string funName)
{
var res = new List <Tuple <int, string> >();
IEnumerable <DeviceInfo> devicesList;
//不存在设备列表
var notExistList = dealList.Where(x => !_clients.ContainsKey(x.DeviceId));
//存在设备列表
devicesList = dealList.Where(x => _clients.ContainsKey(x.DeviceId));
if (notExistList.Any())
{
res.AddRange(notExistList.Select(device => new Tuple <int, string>(device.DeviceId, string.Empty)));
}
if (devicesList.Any())
{
foreach (var device in devicesList)
{
device.ServerId = _clients[device.DeviceId].ServerId;
}
}
var clientSockets = _clientSockets.Where(x => x.SocketState == SocketState.Connected).GroupBy(x => x.ServerId)
.ToDictionary(x => x.Key, x => x.First());
//根据serverId分组
foreach (var deviceGroup in devicesList.GroupBy(x => x.ServerId))
{
var serverId = deviceGroup.Key;
var devices = devicesList.Where(x => x.ServerId == serverId);
//检查serverId是否存在
if (!clientSockets.ContainsKey(serverId))
{
res.AddRange(devices.Select(device => new Tuple <int, string>(device.DeviceId, string.Empty)));
continue;
}
var clientSocket = clientSockets[serverId];
var guid = StringHelper.CreateGuid();
switch (urlKey)
{
case "batchSendBack":
var msg = new NpcSocketMsg
{
Guid = guid,
MsgType = NpcSocketMsgType.SendBack,
Body = devices.ToJSON()
};
clientSocket.Send(msg);
break;
}
var t = 0;
NpcSocketMsg npcSocketMsg = null;
while (true)
{
if (NpcSocketMsgs.ContainsKey(guid))
{
npcSocketMsg = NpcSocketMsgs[guid];
NpcSocketMsgs.Remove(guid, out _);
break;
}
if (t > _tryCount)
{
break;
}
t++;
Thread.Sleep(1);
}
if (npcSocketMsg != null)
{
try
{
var result = JsonConvert.DeserializeObject <MessageResult>(npcSocketMsg.Body);
res.AddRange(result.messages);
}
catch (Exception e)
{
res.AddRange(devices.Select(device => new Tuple <int, string>(device.DeviceId, string.Empty)));
Log.ErrorFormat("{0} Res:{1}, Error:{2}", funName, npcSocketMsg.Body, e.Message);
}
}
else
{
res.AddRange(devices.Select(device => new Tuple <int, string>(device.DeviceId, string.Empty)));
}
}
return(res);
}
private static IEnumerable <DeviceErr> SocketResponseErr(UpgradeInfos upgradeInfos)
{
var res = new List <DeviceErr>();
//不存在设备列表
res.AddRange(upgradeInfos.Infos.Where(x => !_clients.ContainsKey(x.DeviceId)).Select(y => new DeviceErr(y.DeviceId, Error.DeviceNotExist)));
var leftInfos = upgradeInfos.Infos.Where(x => _clients.ContainsKey(x.DeviceId));
if (leftInfos.Any())
{
var devicesList = _clients.Values.Where(x => leftInfos.Any(y => y.DeviceId == x.DeviceId));
var clientSockets = _clientSockets.Where(x => x.SocketState == SocketState.Connected).GroupBy(x => x.ServerId)
.ToDictionary(x => x.Key, x => x.First());
//根据serverId分组
foreach (var deviceGroup in devicesList.GroupBy(x => x.ServerId))
{
var serverId = deviceGroup.Key;
var devices = devicesList.Where(x => x.ServerId == serverId);
//检查serverId是否存在
if (!clientSockets.ContainsKey(serverId))
{
res.AddRange(devices.Select(device => new DeviceErr(device.DeviceId, Error.NpcServerNotExist)));
continue;
}
var serverClientInfo = leftInfos.Where(x => devices.Any(y => x.DeviceId == y.DeviceId));
var clientSocket = clientSockets[serverId];
var guid = StringHelper.CreateGuid();
var msgType = NpcSocketMsgType.UpgradeClient;
var funName = msgType.ToString();
var msg = new NpcSocketMsg
{
Guid = guid,
MsgType = msgType,
Body = new UpgradeInfos {
Type = upgradeInfos.Type, Infos = serverClientInfo.ToList()
}.ToJSON()
};
Console.WriteLine($"{DateTime.Now} {msg.MsgType} {(serverClientInfo.Select(x => x.DeviceId).ToJSON())} -----------{serverId} Send");
clientSocket.Send(msg);
var t = 0;
var sw = Stopwatch.StartNew();
NpcSocketMsg npcSocketMsg = null;
while (sw.ElapsedMilliseconds < _tryCount)
{
if (NpcSocketMsgs.ContainsKey(guid))
{
npcSocketMsg = NpcSocketMsgs[guid];
NpcSocketMsgs.TryRemove(guid, out _);
break;
}
//if (t > _tryCount)
//{
// break;
//}
//t++;
Thread.Sleep(1);
}
if (npcSocketMsg != null)
{
try
{
var result = JsonConvert.DeserializeObject <DataErrResult>(npcSocketMsg.Body);
res.AddRange(result.datas);
}
catch (Exception e)
{
res.AddRange(devices.Select(device => new DeviceErr(device.DeviceId, Error.AnalysisFail)));
Log.ErrorFormat("{0} Res:{1}, Error:{2}", funName, npcSocketMsg.Body, e.Message);
}
}
else
{
res.AddRange(devices.Select(device => new DeviceErr(device.DeviceId, Error.Fail)));
}
}
if (res.Any(x => x.errno == Error.Success))
{
GetFromServer(clientSockets.Keys);
}
//if (res.Any(x => x.errno == Error.Success))
//{
// switch (upgradeInfos.Type)
// {
// case 1:
// foreach (var r in res)
// {
// _clients[r.DeviceId].DeviceState = DeviceState.UpgradeScript;
// }
// break;
// case 2:
// foreach (var r in res)
// {
// _clients[r.DeviceId].DeviceState = DeviceState.UpgradeFirmware;
// }
// break;
// case 3:
// break;
// default:
// break;
// }
//}
}
return(res);
}
private static IEnumerable <DeviceErr> SocketResponseErr(IEnumerable <DeviceInfo> dealList, string urlKey, string funName, bool isAdd = false)
{
var res = new List <DeviceErr>();
IEnumerable <DeviceInfo> devicesList;
if (isAdd)
{
//不存在设备列表
devicesList = dealList.Where(x => !_clients.ContainsKey(x.DeviceId));
//存在设备列表
var existList = _clients.Values.Where(x => dealList.Any(y => y.DeviceId == x.DeviceId));
if (existList.Any())
{
res.AddRange(existList.Select(device => new DeviceErr(device.DeviceId, Error.DeviceIsExist)));
}
}
else
{
//不存在设备列表
var notExistList = dealList.Where(x => !_clients.ContainsKey(x.DeviceId));
//存在设备列表
devicesList = _clients.Values.Where(x => dealList.Any(y => y.DeviceId == x.DeviceId));
if (notExistList.Any())
{
res.AddRange(notExistList.Select(device => new DeviceErr(device.DeviceId, Error.DeviceNotExist)));
}
}
if (funName.Contains("Storage"))
{
foreach (var device in devicesList)
{
device.Storage = dealList.First(x => x.DeviceId == device.DeviceId).Storage;
}
}
else if (funName.Contains("Frequency"))
{
foreach (var device in devicesList)
{
device.Monitoring = dealList.First(x => x.DeviceId == device.DeviceId).Monitoring;
device.Frequency = dealList.First(x => x.DeviceId == device.DeviceId).Frequency;
if (!dealList.First(x => x.DeviceId == device.DeviceId).Instruction.IsNullOrEmpty())
{
device.Instruction = dealList.First(x => x.DeviceId == device.DeviceId).Instruction;
}
}
}
else if (funName.Contains("Update"))
{
foreach (var device in devicesList)
{
device.Ip = dealList.First(x => x.DeviceId == device.DeviceId).Ip;
device.Port = dealList.First(x => x.DeviceId == device.DeviceId).Port;
}
}
var clientSockets = _clientSockets.Where(x => x.SocketState == SocketState.Connected).GroupBy(x => x.ServerId)
.ToDictionary(x => x.Key, x => x.First());
//根据serverId分组
foreach (var deviceGroup in devicesList.GroupBy(x => x.ServerId))
{
var serverId = deviceGroup.Key;
var devices = devicesList.Where(x => x.ServerId == serverId);
//检查serverId是否存在
if (!clientSockets.ContainsKey(serverId))
{
res.AddRange(devices.Select(device => new DeviceErr(device.DeviceId, Error.NpcServerNotExist)));
continue;
}
var clientSocket = clientSockets[serverId];
var guid = StringHelper.CreateGuid();
var msgType = NpcSocketMsgType.Default;
switch (urlKey)
{
case "batchAddDevice":
msgType = NpcSocketMsgType.Add;
break;
case "batchDelDevice":
msgType = NpcSocketMsgType.Delete;
break;
case "batchUpdateDevice":
msgType = NpcSocketMsgType.Update;
break;
case "batchSetStorage":
msgType = NpcSocketMsgType.Storage;
break;
case "batchSetFrequency":
msgType = NpcSocketMsgType.Frequency;
break;
}
if (msgType != NpcSocketMsgType.Default)
{
var msg = new NpcSocketMsg
{
Guid = guid,
MsgType = msgType,
Body = devices.ToJSON()
};
clientSocket.Send(msg);
var t = 0;
NpcSocketMsg npcSocketMsg = null;
while (true)
{
if (NpcSocketMsgs.ContainsKey(guid))
{
npcSocketMsg = NpcSocketMsgs[guid];
NpcSocketMsgs.Remove(guid, out _);
break;
}
if (t > _tryCount)
{
break;
}
t++;
Thread.Sleep(1);
}
if (npcSocketMsg != null)
{
try
{
var result = JsonConvert.DeserializeObject <DataErrResult>(npcSocketMsg.Body);
res.AddRange(result.datas);
ServerConfig.ApiDb.Execute("UPDATE npc_proxy_link SET `Storage` = @Storage , `Monitoring` = @Monitoring, `Frequency` = @Frequency, `Instruction` = @Instruction WHERE `DeviceId` = @DeviceId;", devicesList);
}
catch (Exception e)
{
res.AddRange(devices.Select(device => new DeviceErr(device.DeviceId, Error.AnalysisFail)));
Log.ErrorFormat("{0} Res:{1}, Error:{2}", funName, npcSocketMsg.Body, e.Message);
}
}
else
{
res.AddRange(devices.Select(device => new DeviceErr(device.DeviceId, Error.Fail)));
}
}
}
return(res);
}
