public virtual IEnumerator<ITask> TransmitHandler(Transmit transmit)
{
LogInfo( transmit.Body.ToString() );
try
{
UsbUirtManager.Transmit(transmit);
// update state
//
_state.HasException = false;
_state.LastException = null;
}
catch (Exception exc)
{
// update state
//
_state.HasException = true;
_state.LastException = exc;
}
transmit.ResponsePort.Post(DefaultSubmitResponseType.Instance);
yield break;
}
private void ResetParameter(ref bool isFirstReceive, ref Transmit transmit, ref double dataSize, ref double receiveBytes)
{
isFirstReceive = true;
transmit = null;
dataSize = 0.0;
receiveBytes = 0.0;
}
//private UsbUirtManager()
//{
//}
//public UsbUirtManager Init()
//{
// if (UsbUirtManager.Instance == null)
// {
// UsbUirtManager.Instance = new UsbUirtManager();
// }
//}
public static void Transmit(Transmit transmit)
{
UsbUirtManager.Transmit(
transmit.Body.irCode,
transmit.Body.codeFormat,
transmit.Body.repeatCount,
transmit.Body.inactivityWaitTime);
}
public FlightDetectorModel(List <string> data, string hostName, int port, string anomalyCsvPath, string normalCsvPath)
{
this.AnomalyCsvPath = anomalyCsvPath;
this.NormalCsvPath = normalCsvPath;
this.data = data;
// this.fps = fps;
this.tr = new Transmit(hostName, port);
this.listSize = data.Count;
//the thread that teansmit the data
}
public override int ProcessTransmit(Transmit protocol)
{
// 查询 role 所在的 provider 并转发。
var transmits = new Dictionary <long, Transmit>();
// 如果 role 不在线，就根据 hash(roleId) 选择 provider 转发。
var transmitsHash = new Dictionary <int, Transmit>();
foreach (var target in protocol.Argument.Roles)
{
var provider = App.ProviderService.GetSocket(target.Value.ProviderSessionId);
if (null == provider)
{
var hash = target.Key.GetHashCode();
if (false == transmitsHash.TryGetValue(hash, out var transmitHash))
{
transmitHash = new Transmit();
transmitHash.Argument.ActionName = protocol.Argument.ActionName;
transmitHash.Argument.Sender = protocol.Argument.Sender;
transmitHash.Argument.ServiceNamePrefix = protocol.Argument.ServiceNamePrefix;
transmitsHash.Add(hash, transmitHash);
}
transmitHash.Argument.Roles.Add(target.Key, target.Value);
continue;
}
if (false == transmits.TryGetValue(target.Value.ProviderSessionId, out var transmit))
{
transmit = new Transmit();
transmit.Argument.ActionName = protocol.Argument.ActionName;
transmit.Argument.Sender = protocol.Argument.Sender;
transmit.Argument.ServiceNamePrefix = protocol.Argument.ServiceNamePrefix;
transmits.Add(target.Value.ProviderSessionId, transmit);
}
transmit.Argument.Roles.Add(target.Key, target.Value);
}
// 已经绑定的会话，查找连接并转发，忽略连接查找错误。
foreach (var transmit in transmits)
{
App.ProviderService.GetSocket(transmit.Key)?.Send(transmit.Value);
}
// 会话不存在，根据hash选择Provider并转发，忽略连接查找错误。
foreach (var transmitHash in transmitsHash)
{
if (App.gnet_Provider.ChoiceProvider(
protocol.Argument.ServiceNamePrefix, FirstModuleWithConfigTypeDefault,
transmitHash.Key, out var provider))
{
App.ProviderService.GetSocket(provider)?.Send(transmitHash.Value);
}
}
return(Zeze.Transaction.Procedure.Success);
}
/// <summary>
/// 转发数据
/// </summary>
/// <param name="transmit">传输对象</param>
/// <param name="data">数据包</param>
/// <param name="sendBytes">需要发送的字节数</param>
/// <param name="targetPort">发送目标端口</param>
private bool Forward(Transmit transmit, byte[] data, int sendBytes, int targetPort = -1)
{
if (clientCollection.ContainClient(transmit.SourceID) && clientCollection.ContainClient(transmit.TargetID))
{
List <Socket> sockets = clientCollection.GetClientSockets(transmit.TargetID);
List <int> ports = clientCollection.GetClientPorts(transmit.TargetID);
if (targetPort == -1)
{
try
{
if (sockets.Count < 1)
{
throw new ArgumentException("找不到客户端主端口");
}
sockets[0].Send(data, sendBytes, SocketFlags.None);
}
catch (Exception exception)
{
CloseClient(transmit.TargetID, false, exception);
return(false);
}
}
else
{
try
{
if (!ports.Contains(targetPort))
{
throw new ArgumentException("找不到客户端辅助端口");
}
foreach (Socket socket in sockets)
{
IPEndPoint ipEndPoint = (IPEndPoint)socket.RemoteEndPoint;
if (ipEndPoint.Port == targetPort)
{
socket.Send(data, sendBytes, SocketFlags.None);
break;
}
}
}
catch (Exception exception)
{
CloseClientPort(transmit.TargetID, targetPort, false, exception);
return(false);
}
}
ClientMessage?.Invoke(this, new ServerNotifyEventArgs($"{transmit.SourceID} Send {sendBytes} Bytes To {transmit.TargetID}"));
}
return(true);
}
private Transmit transmit; //接受AR窗体传过来的函数
public Export(Transmit translate, int Mul)
{
this.i_MutStep = Mul;
this.transmit = translate;
InitializeComponent();
for (int i = 0; i < i_MutStep; i++)
{
comboBox1.Items.Add(i + 1);
}
this.FormBorderStyle = FormBorderStyle.Fixed3D; //不允许放大缩小对话框
this.MaximizeBox = false; //不设置最大化图标
this.MinimizeBox = false; //不设置最小化图标
}
public void Init()
{
MyCreateSocket = new CreateSocket();
MyTransmit = new Transmit();
MyMessageControl = new MessageControl();
MyPostMessageThread = new PostMessageThread();
MyMessageControl.MessageControlParaInit();
MyPostMessageThread.PostMessageThreadParaInit();
MyCreateSocket.CreateSocketGetPoint(MyMessageControl);
MyTransmit.TransmitGetPoint(MyCreateSocket);
MyPostMessageThread.PostMessageThreadGetPoint(MyMessageControl, MyTransmit);
}
/// <summary>
/// 接收数据处理
/// </summary>
/// <param name="transmit">传输对象</param>
/// <param name="data">数据包</param>
/// <param name="effectiveBytes">数据有效字节</param>
private void ReceiveDataHandler(Transmit transmit, byte[] data, int effectiveBytes)
{
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
switch (transmit.DataType)
{
case DataType.Text:
ClientReceiveString?.Invoke(this, new ReceiveTextEventArgs(transmit.SourceID, transmit.Parameter));
break;
case DataType.Image:
ClientReceiveImage?.Invoke(this, new ReceiveFileEventArgs(transmit.SourceID, parameters[0], double.Parse(parameters[1]), data, effectiveBytes));
break;
case DataType.File:
ClientReceiveFile?.Invoke(this, new ReceiveFileEventArgs(transmit.SourceID, parameters[0], double.Parse(parameters[1]), data, effectiveBytes));
break;
}
}
public async Task GetState()
{
try
{
byte[] getStatusMessage = new byte[] {
0x81,
0x8A,
0x8B,
0x96
};
byte[] response = Transmit.SendMessage(IpAddress, getStatusMessage, false, true);
byte persistance = response[0];
byte bulbType = response[1];
byte powerState = response[2];
byte mode = response[3];
byte presetDelay = response[5];
byte red = response[6];
byte green = response[7];
byte blue = response[8];
byte warmWhite = response[9];
byte versionNumber = response[10];
byte coldWhite = response[11];
bulbColor = new BulbColor(red, green, blue, warmWhite, coldWhite);
bool isOn = (powerState == 0x24 ? true : false);
bool isRGBWW = (bulbType == 0x35 ? true : false);
bool isPersistant = (persistance == 0x31 ? true : false);
IsOn = isOn;
IsRGBWW = isRGBWW;
IsPersistant = isPersistant;
}
catch
{
}
}
/// <summary>
/// 接收请求处理
/// </summary>
/// <param name="transmit">传输对象</param>
private async void ReceiveRequestHandler(Transmit transmit)
{
switch (transmit.Parameter)
{
case "Client;AddSocket":
SocketResult socketResult = await socketManager.CreateConnectionAsync();
if (socketResult != null)
{
switch (socketResult.State)
{
case ConnectionState.Success:
Task task = Task.Run(() => SecondaryReceiver(socketResult.Socket));
break;
case ConnectionState.Failed:
break;
case ConnectionState.Timeout:
break;
case ConnectionState.Error:
break;
}
}
break;
case "Client;RequestResult":
RequestResult requestResult = transmit.Object as RequestResult;
if (requestResult != null)
{
ClientRequestResult?.Invoke(this, new RequestResultEventArgs(requestResult));
}
break;
}
}
private void ThrListen()
{
while (true) //we wait for a connection
{
var tcpclient = listener.AcceptTcpClient(); //if a connection exists, the server will accept it
Client client = new Client()
{
tcp = tcpclient, ns = tcpclient.GetStream()
};
Log($"@{port} Client Accepted. Handle {client.tcp.Client.Handle.ToInt64()}");
if (client.tcp.Connected) //while the client is connected, we look for incoming messages
{
bool connected = false;
for (int i = 0; i < 10; i++)
{
Transmit tr = ReadFromPeer(client.ns);
if (tr != null)
{
string addr = ((IPEndPoint)client.tcp.Client.RemoteEndPoint).Address.ToString();
Log($"First transmition recieved from {addr} {tr.ToString()}");
// int prt = ((IPEndPoint)client.tcp.Client.RemoteEndPoint).Port;
tr.ip = addr;
Ping ping = (Ping)tr;
if (ping != null)
{
string addrPort = addr + ":" + ping.port;
if (clientIPs.TryGetValue(addrPort, out Client client1))
{
client = client1;
}
else
{
//New client
lock (clients)
{
client.ip = addr;
client.port = ping.port;
client.LastTime = DateTime.Now;
clients.Add(client);
clientIPs.Add(addrPort, client);
HotPeers[addrPort] = false;
}
}
if (Respond(tr))
{
Log($"@{port} New client added. Name {client.name}, IP {client.ip}:{client.port}", ConsoleColor.Cyan);
connected = true;
}
else
{
lock (clients)
{
clients.Remove(client);
clientIPs.Remove(ping.ip + ":" + ping.port.ToString());
}
}
break;
}
else
{
Log($"Transmition recieved is not a ping.");
}
}
else
{
Log($"Transmition recieved is null. Retrying...");
}
}
if (connected)
{
Log($"Client Connected {client.ip} {client.name}");
}
else
{
Log($"Client not properly Connected. {client.ip} {client.name}");
}
}
}
}
public Transmit ReadFromPeer(NetworkStream ns)
{
int start;
int tries = 0;
ReadAgain:
for (int i = 1; i < 10; i++)
{
if (ns.DataAvailable)
{
goto ReadNow;
}
else
{
Sleep(500);
}
}
ns.Flush();
return(null);
ReadNow:
start = ns.ReadByte();
if (start == -1)
{
if (tries > 4)
{
Log("@ReadFromPeer : StartByte time out"); return(null);
}
tries++;
System.Threading.Thread.Sleep(100);
goto ReadAgain;
}
if (start != 42)
{
Log($"@{port}ReadFromPeer : StartByte is wrong");
ns.Flush();
return(null);
}
// ns.WriteByte(43);
for (int i = 1; i < 10; i++)
{
if (ns.DataAvailable)
{
goto ReadLenght;
}
else
{
Sleep(500);
}
}
ns.Flush();
return(null);
ReadLenght:
byte[] lengthBytes = new byte[4];
ns.Read(lengthBytes, 0, 4);
Int32 length = BitConverter.ToInt32(lengthBytes, 0);
byte[] transmitBytes = new byte[length];
ns.Read(transmitBytes, 0, length);
try
{
Newtonsoft.Json.Linq.JObject obj = (Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(Encoding.Unicode.GetString(transmitBytes));
Transmit tr = obj.ToObject <Transmit>();
return(tr.t switch
{
'T' => tr,
'P' => obj.ToObject <Ping>(),
'R' => obj.ToObject <Request>(),
'r' => obj.ToObject <Response>(),
'X' => obj.ToObject <ContentTransmit>(),
_ => null,
});
}
/// <summary>
/// 辅助接收器
/// </summary>
/// <param name="socket">客户端Socket对象</param>
private void SecondaryReceiver(Socket socket)
{
if (socket == null)
{
return;
}
byte[] dataBuffer = new byte[1024 * 1024]; //数据缓冲区
bool isFirstReceive = true; //是否为首次接收数据
Transmit transmit = null; //传输对象
double dataSize = 0.0; //数据总大小
double receiveBytes = 0.0; //已接收的字节数
while (true)
{
int readBytes = 0;
if (socket.Poll(15000000, SelectMode.SelectRead))
{
if (!ClientState)
{
break;
}
try
{
readBytes = socket.Receive(dataBuffer, dataBuffer.Length, SocketFlags.None);
if (readBytes == 0)
{
socketManager.CloseConnection(socket);
break;
}
}
catch
{
socketManager.CloseConnection(socket);
break;
}
}
else
{
socketManager.CloseConnection(socket);
break;
}
//首次接收数据
if (isFirstReceive)
{
isFirstReceive = false;
transmit = BytesConvert.BytesToObject(dataBuffer, readBytes, "MiniSocket.Transmitting") as Transmit;
if (transmit?.Parameter != null)
{
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
continue;
}
}
}
socketManager.CloseConnection(socket);
break;
}
receiveBytes += readBytes; //已接收到的数据累加
//判断已接收到的数据是否有效
if (receiveBytes > 0 && receiveBytes <= dataSize)
{
ReceiveDataHandler(transmit, dataBuffer, readBytes);
}
//判断是否接收完成或数据是否有误
if (receiveBytes == dataSize || (receiveBytes <= 0 || receiveBytes > dataSize))
{
socketManager.CloseConnection(socket);
break;
}
}
}
public override int ProcessTransmit(Transmit protocol)
{
App.Game_Login.Onlines.ProcessTransmit(protocol.Argument.Sender,
protocol.Argument.ActionName, protocol.Argument.Roles.Keys);
return(Procedure.Success);
}
public void PostMessageThreadGetPoint(MessageControlSpace.MessageControl MyMessageControl, Transmit MyTransmit)
{
this.m_MyMessageControl = MyMessageControl;
this.m_MyTransmit = MyTransmit;
}
/// <summary>
/// 接收数据
/// </summary>
/// <param name="socket">客户端Socket对象</param>
private void ReceiveMessage(Socket socket)
{
bool isMain = true; //是否为主端口
string clientID = string.Empty; //客户端ID
IPEndPoint clientIPEndPoint = (IPEndPoint)socket.RemoteEndPoint; //客户端网络终结点
bool isFirstConnection = true; //是否为首次连接
byte[] dataBuffer = new byte[1024 * 1024]; //缓冲区
bool isFirstReceive = true; //是否为首次接收数据
Transmit transmit = null; //传输对象
double dataSize = 0.0; //数据总大小
double receiveBytes = 0.0; //已接收的字节数
int targetPort = -1; //发送目标端口
while (true)
{
int readBytes = 0;
if (socket.Poll(-1, SelectMode.SelectRead) == true)
{
if (!ServerState)
{
break;
}
try
{
readBytes = socket.Receive(dataBuffer, dataBuffer.Length, SocketFlags.None);
if (readBytes == 0)
{
if (isMain)
{
CloseClient(clientID);
break;
}
CloseClientPort(clientID, clientIPEndPoint.Port);
break;
}
}
catch (Exception exception)
{
if (isMain)
{
CloseClient(clientID, false, exception);
break;
}
CloseClientPort(clientID, clientIPEndPoint.Port, false, exception);
break;
}
}
//首次连接
if (isFirstConnection)
{
isFirstConnection = false;
clientID = Encoding.UTF8.GetString(dataBuffer, 0, readBytes);
if (clientCollection.AddClient(clientID, clientIPEndPoint, socket))
{
ServerMessage?.Invoke(this, new ServerNotifyEventArgs($"客户端 {clientID}({clientIPEndPoint}) 已连接"));
}
else
{
if (!clientCollection.AddPort(clientID, clientIPEndPoint.Port, socket))
{
break;
}
isMain = false;
ServerMessage?.Invoke(this, new ServerNotifyEventArgs($"客户端 {clientID} 的 {clientIPEndPoint.Port} 端口已连接"));
}
socket.Send(new byte[] { 1 });
continue;
}
//首次接收数据
if (isFirstReceive)
{
isFirstReceive = false;
transmit = BytesConvert.BytesToObject(dataBuffer, readBytes, "MiniSocket.Transmitting") as Transmit;
if (transmit?.Parameter == null)
{
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
if (isMain)
{
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
switch (transmit.DataType)
{
case DataType.Text:
if (!Forward(transmit, dataBuffer, readBytes))
{
return;
}
break;
case DataType.Image:
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
if (!Forward(transmit, dataBuffer, readBytes))
{
return;
}
continue;
}
}
break;
case DataType.Request:
if (transmit.Parameter.StartsWith("Database"))
{
if (parameters.Length == 2)
{
var result = DatabaseRequest?.Invoke(this, new DatabaseEventArgs(parameters[1], transmit.Object))?.Result;
if (result != null)
{
transmit.Parameter = "Client;RequestResult";
transmit.Object = result;
byte[] buffer = BytesConvert.ObjectToBytes(transmit);
if (!Forward(transmit, buffer, buffer.Length))
{
return;
}
}
}
}
break;
}
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
if (transmit.DataType == DataType.File)
{
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
Transmit requestTransmit = new Transmit()
{
SourceID = transmit.SourceID,
TargetID = transmit.TargetID,
DataType = DataType.Request,
Parameter = "Client;AddSocket"
};
byte[] buffer = BytesConvert.ObjectToBytes(requestTransmit);
if (!Forward(requestTransmit, buffer, buffer.Length))
{
return;
}
Thread.Sleep(3000);
List <Socket> sockets = clientCollection.GetClientSockets(transmit.TargetID);
targetPort = ((IPEndPoint)sockets[sockets.Count - 1].RemoteEndPoint).Port;
if (!Forward(transmit, dataBuffer, readBytes, targetPort))
{
return;
}
continue;
}
}
}
CloseClientPort(clientID, clientIPEndPoint.Port);
return;
}
receiveBytes += readBytes; //已接收到的数据累加
//判断已接收到的数据是否有效
if (receiveBytes > 0 && receiveBytes <= dataSize)
{
if (!Forward(transmit, dataBuffer, readBytes, targetPort))
{
break;
}
}
//判断是否接收完成或数据是否有误
if (receiveBytes == dataSize || (receiveBytes <= 0 || receiveBytes > dataSize))
{
if (isMain)
{
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
CloseClientPort(clientID, clientIPEndPoint.Port);
break;
}
}
}
/// <summary>
/// 主接收器
/// </summary>
private void MainReceiver()
{
byte[] dataBuffer = new byte[1024 * 1024]; //数据缓冲区
bool isFirstReceive = true; //是否为首次接收数据
Transmit transmit = null; //传输对象
double dataSize = 0.0; //数据总大小
double receiveBytes = 0.0; //已接收的字节数
while (true)
{
int readBytes = 0;
if (clientSocket.Poll(-1, SelectMode.SelectRead))
{
if (!ClientState)
{
break;
}
try
{
readBytes = clientSocket.Receive(dataBuffer, dataBuffer.Length, SocketFlags.None);
if (readBytes == 0)
{
CloseClient();
ClientMessage?.Invoke(this, new ClientNotifyEventArgs("服务器断开连接"));
break;
}
}
catch (Exception exception)
{
CloseClient();
ClientMessage?.Invoke(this, new ClientNotifyEventArgs("服务器断开连接"));
ClientError?.Invoke(this, new ClientErrorEventArgs(exception, "服务器意外的断开连接"));
break;
}
}
//首次接收数据
if (isFirstReceive)
{
isFirstReceive = false;
transmit = BytesConvert.BytesToObject(dataBuffer, readBytes, "MiniSocket.Transmitting") as Transmit;
if (transmit?.Parameter != null)
{
switch (transmit.DataType)
{
case DataType.Text:
ReceiveDataHandler(transmit, null, 0);
break;
case DataType.Image:
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
continue;
}
}
break;
case DataType.Request:
ReceiveRequestHandler(transmit);
break;
}
}
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
receiveBytes += readBytes; //已接收到的数据累加
//判断已接收到的数据是否有效
if (receiveBytes > 0 && receiveBytes <= dataSize)
{
ReceiveDataHandler(transmit, dataBuffer, readBytes);
}
//判断是否接收完成或数据是否有误
if (receiveBytes == dataSize || (receiveBytes <= 0 || receiveBytes > dataSize))
{
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
}
}
