private void _server_OnReceive(object currentObj, byte[] data)
{
var ut = (WSUserToken)(currentObj);
try
{
if (!ut.IsHandSharked)
{
byte[] resData = null;
var result = ut.GetReplayHandShake(data, out resData);
if (result)
{
_server.SendAsync(ut.ID, resData);
ut.IsHandSharked = true;
lock (_locker)
Clients.Add(ut.ID);
OnConnected?.Invoke(ut.ID);
}
}
else
{
var coder = (WSCoder)ut.Unpacker;
coder.Unpack(data, (d) =>
{
var wsProtocal = (WSProtocal)d;
switch (wsProtocal.Type)
{
case (byte)WSProtocalType.Close:
ReplyClose(ut.ID, wsProtocal);
break;
case (byte)WSProtocalType.Ping:
ReplyPong(ut.ID, wsProtocal);
break;
case (byte)WSProtocalType.Binary:
case (byte)WSProtocalType.Text:
case (byte)WSProtocalType.Cont:
OnMessage?.Invoke(ut.ID, (WSProtocal)d);
break;
case (byte)WSProtocalType.Pong:
break;
default:
var error = string.Format("收到未定义的Opcode={0}", d.Type);
break;
}
}, (h) => { }, null);
}
}
catch (Exception ex)
{
LogHelper.Error("WServer.OnReceive.Error", ex);
_server.Disconnecte(ut.ID);
}
}
private void _udpServer_OnReceive(ISession currentSession, byte[] data)
{
Parallel.ForEach(_cache.Keys, (id) =>
{
try
{
_udpServer.SendAsync(id, data);
}
catch { }
});
}
private async void HandleRequest(string sessionID, byte[] data)
{
DnsRequestMessage request = null;
try
{
request = DnsRequestMessage.FromArray(data);
OnEvent(OnRequested, new RequestedEventArgs(request, data));
IResponse response = await _coder.Code(request);
OnEvent(OnResponded, new RespondedEventArgs(request, response, data));
_udpServer.SendAsync(sessionID, response.ToArray());
}
catch (SocketException e) { OnError(e); }
catch (ArgumentException e) { OnError(e); }
catch (IndexOutOfRangeException e) { OnError(e); }
catch (OperationCanceledException e) { OnError(e); }
catch (IOException e) { OnError(e); }
catch (ObjectDisposedException e) { OnError(e); }
catch (ResponseException e)
{
IResponse response = e.Response;
if (response == null)
{
response = DnsResponseMessage.FromRequest(request);
}
try
{
_udpServer.SendAsync(sessionID, response.ToArray());
}
catch (SocketException) { }
catch (OperationCanceledException) { }
finally { OnError(e); }
}
}
private void _udpServer_OnReceive(ISession currentSession, byte[] data)
{
var userToken = (IUserToken)currentSession;
Parallel.ForEach(_cache.Keys, (id) =>
{
try
{
//if (id != userToken.ID)
_udpServer.SendAsync(id, data);
}
catch { }
});
}
void BaseReply(string id, ProtocalType protocalType, byte[] data)
{
var p = new BaseSocketProtocal();
p.Type = (byte)protocalType;
p.Content = data;
if (p.Content != null)
{
p.BodyLength = p.Content.Length;
}
else
{
p.BodyLength = 0;
}
_udpServer.SendAsync(id, p.ToBytes());
}
/// <summary>
/// SendAsync
/// </summary>
/// <param name="id"></param>
/// <param name="baseSocketProtocal"></param>
protected void SendAsync(string id, BaseSocketProtocal baseSocketProtocal)
{
_udpServer.SendAsync(id, baseSocketProtocal.ToBytes());
}
/// <summary>
/// 回复
/// </summary>
/// <param name="userToken"></param>
/// <param name="msg"></param>
internal void Reply(IUserToken userToken, RSocketMsg msg)
{
var data = ((RUnpacker)userToken.Unpacker).Encode(msg);
_server.SendAsync(userToken.ID, data);
}
private void _classificationBatcher_OnBatched(string id, byte[] data)
{
_server.SendAsync(id, data);
}
public void Send(IUserToken userToken, byte[] data)
{
_serverSokcet.SendAsync(userToken.ID, data);
}
/// <summary>
/// SendAsync
/// </summary>
/// <param name="id"></param>
/// <param name="data"></param>
public void SendAsync(string id, byte[] data)
{
_serverSokcet.SendAsync(id, data);
}
public void SendAsync(string id, JT808Package jT808Package)
{
_serverSokcet.SendAsync(id, new JT808Serializer().Serialize(jT808Package));
}
