public override void OnReceived(ITcpSession session, IDynamicBuffer dataBuffer)
{
int cmd = dataBuffer.Buffer[0];
MemoryStream ms = new MemoryStream(dataBuffer.Buffer, 1, dataBuffer.DataSize - 1);
switch (cmd)
{
case 1:
{
RpcCallData data = Serializer.Deserialize <RpcCallData>(ms);
ThreadPool.QueueUserWorkItem(CallFunc, new CallStatus()
{
Session = session, Data = data
});
}
break;
case 2:
{
var data = Serializer.Deserialize <RpcReturnData>(ms);
RpcFactory.GetInvoke(session.SessionId).ReturnData(data);
}
break;
default:
{
var data = Serializer.Deserialize <RpcErrorInfo>(ms);
RpcFactory.GetInvoke(session.SessionId).ReturnError(data);
}
break;
}
ms.Dispose();
}
internal HttpSession(LibNetworkConfig config, ITcpSession session, CancellationToken token)
{
_config = config;
_session = session;
_canceller = new CancellationTokenSource();
_token = token;
_closed = false;
last_response_time = new TimeSpan(DateTime.UtcNow.Ticks);
last_pulse_time = last_response_time;
Name = nameof(HttpSession);
Id = Guid.NewGuid();
Timeout = config.Http.SessionTimeout;
OnGET = delegate { return(Task.CompletedTask); };
OnDELETE = delegate { return(Task.CompletedTask); };
OnPUT = delegate { return(Task.CompletedTask); };
OnPOST = delegate { return(Task.CompletedTask); };
OnHEAD = delegate { return(Task.CompletedTask); };
OnPATCH = delegate { return(Task.CompletedTask); };
OnTRACE = delegate { return(Task.CompletedTask); };
OnOPTIONS = delegate { return(Task.CompletedTask); };
OnCONNECT = delegate { return(Task.CompletedTask); };
OnAnyValidRequest = delegate { return(Task.CompletedTask); };
OnInvalidRequest = delegate { return(Task.CompletedTask); };
OnTimeoutDisconnect = delegate { return(Task.CompletedTask); };
OnUnhandledException = delegate { return(Task.CompletedTask); };
}
public void AddSession(ITcpSession Session)
{
if (!_tcp_sessions.ContainsKey(Session.HashCode))
{
_tcp_sessions.Add(Session.HashCode, Session);
}
}
public void RemoveSession(ITcpSession Session)
{
if (_tcp_sessions.ContainsKey(Session.HashCode))
{
_tcp_sessions.Remove(Session.HashCode);
}
}
public void OnTransportWrite(ITcpSession session, ref WrappedWriter writer, WrappedArgs args)
{
var buffer = args.Value as byte[];
writer.Write(buffer);
writer.Write(this.symbol);
}
private void OnTcpServerMessage(ITcpSession session, byte[] data)
{
Message message = Message.Parse(data);
// Logger.trace($"OnTcpServerMessage(): message={message}");
// should route this message?
if (message.ShouldRoute())
{
OnElasticMessage(message);
return;
}
// message sender
Address sender = message.Sender;
// authorized peer?
ElasticAddress peer = Peers.Find(sender);
if (ReferenceEquals(peer, null))
{
Logger.warning($"Unauthorized peer!");
return;
}
// valid sign?
if (!message.Verify(sender))
{
Logger.warning($"Peer signature not verified!");
return;
}
// message handler invoke
OnMessage?.Invoke(peer, message);
}
private void OnHandleConnect(IAsyncResult ar)
{
bool connected = false;
try
{
_socket.EndConnect(ar);
connected = _socket.Connected;
}
catch (Exception e)
{
OnConnectFailed(e.Message);
return;
}
if (connected)
{
// new session for connected socket
_session = new TcpSession(Logger, _socket, _session_read_buffer_size)
{
OnStart = OnSessionStart,
OnStop = OnSessionClose,
OnMessage = OnSessionMessage,
OnWrite = OnSessionWrite
};
// start session
_session.Start();
}
else
{
OnConnectFailed("Not connected");
}
}
private void OnTcpMessageUnregister(ITcpSession session, Message message)
{
// unregister requested enode
ElasticAddress address = message.Value <string>("enode");
// verify message
PrivateKey nodeKey = MasterKey.CKD($"{address.Host}:{address.Port}");
if (!message.Verify(nodeKey.Address))
{
Logger.warning("Unverified message");
return;
}
// valid address?
if (nodeKey.Address != address.Address)
{
Logger.warning("Invalid address");
return;
}
// remove peer
Peers.Remove(address);
// sync all peers
SyncAllPeers();
}
private void OnTcpMessagePeek(ITcpSession session, Message message)
{
ElasticAddress address = message.Value <string>("enode");
// verify message
PrivateKey nodeKey = MasterKey.CKD($"{address.Host}:{address.Port}");
if (!message.Verify(nodeKey.Address))
{
Logger.warning("Unverified message");
return;
}
// valid address?
if (nodeKey.Address != address.Address)
{
Logger.warning("Invalid address");
return;
}
Message msg = new Message.Builder()
.Body(ACTION, ACTION_PEEK)
.Body("peers", Peers.Count)
.Build(MasterKey);
session?.Write(msg.ToBytes());
}
protected override bool Handle(CommandInfo commandInfo)
{
string command = commandInfo.CommandLine;
int start = commandInfo.ArgsPos;
var sessionId = 0;
if (!ParseItem(command, ref start, out sessionId))
{
return(false);
}
var numData = 0;
if (!ParseItem(command, ref start, out numData))
{
return(false);
}
_session = GetTcpSession(sessionId);
if (_session == null)
{
return(false);
}
SendResponse("Connect");
_session.BeginSend(numData);
return(true);
}
public void Push(ITcpSession item)
{
if (activeDict.TryRemove(item.SessionId, out item))
{
pool.Enqueue(item);
}
}
protected void CallProcess(ITcpSession session, RpcCallData data)
{
IServerController controller = rpcContainer.GetController(session.SessionId, data.Controller.ToLower());
if (controller.Session == null)
{
controller.Session = session;
}
try
{
string key = (data.Controller + ":" + data.Action).ToLower();
var method = rpcContainer.GetMethod(key);
object[] args = null;
if (data.Arguments != null && data.Arguments.Count > 0)
{
args = new object[data.Arguments.Count];
var types = GetParaTypeList(key);
for (int i = 0; i < data.Arguments.Count; i++)
{
var arg = data.Arguments[i];
MemoryStream stream = new MemoryStream(arg, 0, arg.Length);
var obj = Serializer.NonGeneric.Deserialize(types[i], stream);
args[i] = obj;
stream.Dispose();
}
}
object value = method.Invoke(controller, args);
RpcReturnData result = new RpcReturnData()
{
Id = data.Id
};
var ms = new MemoryStream();
Serializer.Serialize(ms, value);
byte[] bytes = new byte[ms.Position];
Buffer.BlockCopy(ms.GetBuffer(), 0, bytes, 0, bytes.Length);
result.Value = bytes;
ms.Position = 0;
ms.WriteByte(2);
Serializer.Serialize(ms, result);
byte[] rBytes = new byte[ms.Position];
Buffer.BlockCopy(ms.GetBuffer(), 0, rBytes, 0, rBytes.Length);
session.SendAsync(rBytes);
ms.Dispose();
}
catch (Exception e)
{
RpcErrorInfo error = new RpcErrorInfo()
{
Id = data.Id, Message = e.Message
};
var ms = new MemoryStream();
ms.WriteByte(0);
Serializer.Serialize(ms, error);
byte[] rBytes = new byte[ms.Position];
Buffer.BlockCopy(ms.GetBuffer(), 0, rBytes, 0, rBytes.Length);
session.SendAsync(rBytes);
ms.Dispose();
}
}
public override void OnReceived(ITcpSession session, IDynamicBuffer dataBuffer)
{
var result = new byte[dataBuffer.DataSize];
Buffer.BlockCopy(dataBuffer.Buffer, 0, result, 0, dataBuffer.DataSize);
//var txt= Encoding.UTF8.GetString(result);
session.SendAsync(data);
}
public override void OnReceived(ITcpSession session, IDynamicBuffer dataBuffer)
{
// var result = new byte[dataBuffer.DataSize];
//Buffer.BlockCopy(dataBuffer.Buffer, 0, result, 0, dataBuffer.DataSize);
//session.SessionData.Set("islogin", true);//设置登录状态
//var txt= Encoding.UTF8.GetString(result);
session.SendAsync(data);
}
public void CloseSession(ITcpSession sesseion)
{
if (OnDisConnect != null)
OnDisConnect(this, sesseion);
sesseion.Clear();//自清理
sessionPool.Push(sesseion);
OnlineList.TryRemove(sesseion.SessionId, out sesseion);
}
private void Register(ITcpSession session)
{
Message message = new Message.Builder()
.Body(ACTION, ACTION_REGISTER)
.Body("enode", NodeUrl.ToString())
.Build(NodeKey);
session?.Write(message.ToBytes());
}
public void SyncPeers(ITcpSession session, string[] catalogs)
{
Message message = new Message.Builder()
.Body(ACTION, ACTION_UPDATE)
.Body("peers", catalogs)
.Build(MasterKey);
session?.Write(message.ToBytes());
}
public override void OnReceived(ITcpSession session, IDynamicBuffer dataBuffer)
{
//Stream str = new MemoryStream();
// var result = new byte[dataBuffer.DataSize];
//Buffer.BlockCopy(dataBuffer.Buffer, 0, result, 0, dataBuffer.DataSize);
//session.SessionData.Set("islogin", true);//设置登录状态
//var txt= Encoding.UTF8.GetString(result);
session.SendAsync(data);
}
public override void OnConnected(ITcpSession session)
{
if (!RpcFactory.invokeDict.ContainsKey(session.SessionId))
{
var invoke = new RpcInvoke(session, rpcConfig.RemoteInvokeTimeout);
RpcFactory.invokeDict.TryAdd(session.SessionId, invoke);
}
session.SessionData.Set("proxyfactory",RpcFactory);
rpcContainer.CreateScope(session.SessionId);
}
public override void OnConnected(ITcpSession session)
{
if (!RpcFactory.invokeDict.ContainsKey(session.SessionId))
{
var invoke = new RpcInvoke(session, rpcConfig.RemoteInvokeTimeout);
RpcFactory.invokeDict.TryAdd(session.SessionId, invoke);
}
session.SessionData.Set("proxyfactory", RpcFactory);
rpcContainer.CreateScope(session.SessionId);
}
private void OnTcpMessageClear(ITcpSession session, Message message)
{
if (!message.Verify(MasterKey.Address))
{
Logger.warning("Unverified message!");
return;
}
Peers.Clear();
}
public void CloseSession(ITcpSession sesseion)
{
if (OnDisConnect != null)
{
OnDisConnect(this, sesseion);
}
sesseion.Clear();//自清理
sessionPool.Push(sesseion);
OnlineList.TryRemove(sesseion.SessionId, out sesseion);
}
protected override bool OnHandleData(string request, ref int pos)
{
var done = _dteDataSender.SendData(_session, request, ref pos);
if (done)
{
_session = null;
}
return(done);
}
public static T GetInstance <T>(this ITcpSession session, string impName = null) where T : class
{
if (session == null)
{
throw new Exception("session Can't be empty");
}
var proxy = GetProxy <T>(session, impName);
return(proxy.GetTransparentProxy() as T);
}
public void OnTransportRead(ITcpSession session, ref WrappedReader reader, WrappedArgs args)
{
this.buffers.Clear();
args.Value = this.buffers;
while (reader.TryFindPosition(this.symbol, out SequencePosition endPosition))
{
var buffer = reader.ReadBuffer(endPosition);
var length = buffer.Length - this.symbol.Length;
this.buffers.Add(buffer.Slice(buffer.Start, length));
}
}
public void OnTransportRead(ITcpSession session, ref WrappedReader reader, WrappedArgs args)
{
List <ReadOnlySequence <byte> > buffers = (List <ReadOnlySequence <byte> >)args.Value;
for (int i = 0; i < buffers.Count; i++)
{
session.Write(SocketConfig.message);
}
session.FlushAsync().NoAwait();
}
private void OnTcpMessageSync(ITcpSession session, Message message)
{
if (!message.Verify(MasterKey.Address))
{
Logger.warning("Unverified message");
return;
}
// 모든 클라이언트에 업데이트
SyncAllPeers(Peers.Peers);
}
private void OnSessionMessage(ITcpSession session, byte[] data)
{
try
{
OnMessage?.Invoke(session, data);
}
catch (Exception e)
{
Logger.error($"Exception! e={e.Message}");
session.Stop(-1);
}
}
public void OnTransportRead(ITcpSession session, ref WrappedReader reader, WrappedArgs args)
{
Console.WriteLine($"{nameof(TcpTestFilter_Client)}.{nameof(OnTransportRead)}");
List <ReadOnlySequence <byte> > buffers = (List <ReadOnlySequence <byte> >)args.Value;
for (int i = 0; i < buffers.Count; i++)
{
var buffer = buffers[i];
string str = System.Text.Encoding.UTF8.GetString(buffer.FirstSpan);
Console.WriteLine("收到》》" + str);
}
}
private void OnSessionWrite(ITcpSession session, byte[] data)
{
try
{
OnWrite?.Invoke(this, data);
}
catch (Exception e)
{
Logger.error($"OnWrite() exception! e={e.Message}");
session.Stop();
}
}
public void OnTransportWrite(ITcpSession session, ref WrappedWriter writer, WrappedArgs args)
{
var buffer = args.Value as byte[];
if (buffer.Length > this.maxPackLength)
{
throw new Exception("pack length error！！！" + buffer.Length);
}
writer.Write((int)buffer.Length);
writer.Write(buffer);
}
private void OnSessionStart(ITcpSession session)
{
try
{
OnConnected();
}
catch (Exception e)
{
Logger.error($"OnConnect() exception! e={e.Message}");
session.Stop();
}
}
private void OnSessionClose(ITcpSession session, int reason)
{
try
{
_connectState = ConnectState.Disconnected;
OnDisconnect?.Invoke(this, reason);
}
catch (Exception e)
{
Logger.error($"OnClose() exception! e={e.Message}");
}
}
public virtual bool OnTimeOut(ITcpSession session)
{
return true;
}
public virtual void Execute(ITcpSession session)
{
}
public void Push(ITcpSession item)
{
pool.Enqueue(item);
}
public override void OnReceived(ITcpSession session, IDynamicBuffer dataBuffer)
{
int cmd = dataBuffer.Buffer[0];
MemoryStream ms = new MemoryStream(dataBuffer.Buffer, 1, dataBuffer.DataSize - 1);
switch (cmd)
{
case 1:
{
RpcCallData data = Serializer.Deserialize<RpcCallData>(ms);
ThreadPool.QueueUserWorkItem(CallFunc, new CallStatus() { Session = session, Data = data });
}
break;
case 2:
{
var data = Serializer.Deserialize<RpcReturnData>(ms);
RpcFactory.GetInvoke(session.SessionId).ReturnData(data);
}
break;
default:
{
var data = Serializer.Deserialize<RpcErrorInfo>(ms);
RpcFactory.GetInvoke(session.SessionId).ReturnError(data);
}
break;
}
ms.Dispose();
}
public virtual void OnError(ITcpSession seseion, Exception error)
{
}
public override void OnDisConnect(ITcpSession session)
{
RpcFactory.GetInvoke(session.SessionId).DisConnect();
rpcContainer.DestroyScope(session.SessionId);
}
public void ReceiveCommond(ITcpSession session, ReceiveCommond cmd)
{
OnReceived(session, cmd);
}
protected void CallProcess(ITcpSession session, RpcCallData data)
{
IServerController controller = rpcContainer.GetController(session.SessionId,data.Controller.ToLower());
if (controller.Session==null)
{
controller.Session =session;
}
try
{
string key = (data.Controller + ":" + data.Action).ToLower();
var method = rpcContainer.GetMethod(key);
object[] args = null;
if (data.Arguments != null && data.Arguments.Count > 0)
{
args = new object[data.Arguments.Count];
var types = GetParaTypeList(key);
for (int i = 0; i < data.Arguments.Count; i++)
{
var arg = data.Arguments[i];
MemoryStream stream = new MemoryStream(arg, 0, arg.Length);
var obj = Serializer.NonGeneric.Deserialize(types[i], stream);
args[i] = obj;
stream.Dispose();
}
}
object value = method.Invoke(controller, args);
RpcReturnData result = new RpcReturnData() { Id = data.Id };
var ms = new MemoryStream();
Serializer.Serialize(ms, value);
byte[] bytes = new byte[ms.Position];
Buffer.BlockCopy(ms.GetBuffer(), 0, bytes, 0, bytes.Length);
result.Value = bytes;
ms.Position = 0;
ms.WriteByte(2);
Serializer.Serialize(ms, result);
byte[] rBytes = new byte[ms.Position];
Buffer.BlockCopy(ms.GetBuffer(), 0, rBytes, 0, rBytes.Length);
session.SendAsync(rBytes);
ms.Dispose();
}
catch (Exception e)
{
RpcErrorInfo error = new RpcErrorInfo() { Id = data.Id, Message = e.Message };
var ms = new MemoryStream();
ms.WriteByte(0);
Serializer.Serialize(ms, error);
byte[] rBytes = new byte[ms.Position];
Buffer.BlockCopy(ms.GetBuffer(), 0, rBytes, 0, rBytes.Length);
session.SendAsync(rBytes);
ms.Dispose();
}
}
public void Push(ITcpSession item)
{
if (activeDict.TryRemove(item.SessionId, out item))
pool.Enqueue(item);
}
public virtual void OnConnected(ITcpSession session)
{
}
public void Push(ITcpSession item)
{
pool.Push(item);
}
//当接收到命令包时触发
public virtual void OnReceived(ITcpSession session, IDynamicBuffer dataBuffer)
{
}
//断开连接事件
public virtual void OnDisConnect(ITcpSession session)
{
}
