/// <summary>读取数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
if (!(message is Packet pk))
{
return(base.Read(context, message));
}
// 解码得到多个消息
var list = Decode(context, pk);
if (list == null)
{
return(null);
}
foreach (var msg in list)
{
// 把数据发送给后续处理器
var rs = base.Read(context, msg);
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(rs);
}
return(null);
}
/// <summary>读取数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
if (!(message is Packet pk))
{
return(base.Read(context, message));
}
// 解码得到消息
var msg = new HttpMessage();
msg.Read(pk);
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(msg);
//if (pk.ToStr(null, 0, 4) == "HTTP")
//{
// var response = new HttpResponse();
// if (!response.ParseHeader(pk)) return base.Read(context, message);
// // 匹配输入回调，让上层事件收到分包信息
// context.FireRead(response);
//}
//else
//{
// var request = new HttpRequest();
// if (!request.ParseHeader(pk)) return base.Read(context, message);
// // 匹配输入回调，让上层事件收到分包信息
// context.FireRead(request);
//}
return(null);
}
/// <summary>读取数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
if (!(message is Packet pk))
{
return(base.Read(context, message));
}
// 解码得到多个消息
var list = Decode(context, pk);
if (list == null)
{
return(null);
}
foreach (var msg in list)
{
if (UserPacket && msg is IMessage msg2)
{
message = msg2.Payload;
}
else
{
message = msg;
}
// 后续处理器，得到最终结果，匹配请求队列
var rs = base.Read(context, message);
if (msg is IMessage msg3)
{
// 匹配
if (msg3.Reply)
{
//!!! 处理结果的Packet需要拷贝一份，否则交给另一个线程使用会有冲突
if (rs is IMessage msg4 && msg4.Payload != null && msg4.Payload == msg3.Payload)
{
msg4.Payload = msg4.Payload.Clone();
}
Queue.Match(context.Owner, msg, rs, IsMatch);
}
}
else if (rs != null)
{
// 其它消息不考虑响应
Queue.Match(context.Owner, msg, rs, IsMatch);
}
// 匹配输入回调，让上层事件收到分包信息。
// 这里很可能处于网络IO线程，阻塞了下一个Tcp包的接收
context.FireRead(rs);
}
return(null);
}
/// <summary>读取数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
if (!(message is Packet pk))
{
return(base.Read(context, message));
}
// 是否Http请求
var ext = context.Owner as IExtend;
if (!(ext["Encoder"] is HttpEncoder))
{
if (!(pk[0] == 'G' && pk[1] == 'E' && pk[2] == 'T') &&
!(pk[0] == 'P' && pk[1] == 'O' && pk[2] == 'S' && pk[3] == 'T'))
{
return(base.Read(context, message));
}
ext["Encoder"] = new HttpEncoder();
}
// 解码得到消息
var msg = new HttpMessage();
msg.Read(pk);
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(msg);
//if (pk.ToStr(null, 0, 4) == "HTTP")
//{
// var response = new HttpResponse();
// if (!response.ParseHeader(pk)) return base.Read(context, message);
// // 匹配输入回调，让上层事件收到分包信息
// context.FireRead(response);
//}
//else
//{
// var request = new HttpRequest();
// if (!request.ParseHeader(pk)) return base.Read(context, message);
// // 匹配输入回调，让上层事件收到分包信息
// context.FireRead(request);
//}
return(null);
}
/// <summary>读取数据，返回结果作为下一个处理器消息</summary>
/// <remarks>
/// 最终处理器决定如何使用消息。
/// 处理得到单个消息时，调用一次下一级处理器，返回下级结果给上一级；
/// 处理得到多个消息时，调用多次下一级处理器，返回null给上一级；
/// </remarks>
/// <param name="context">上下文</param>
/// <param name="message">消息</param>
public virtual Object Read(IHandlerContext context, Object message)
{
if (Next != null)
{
return(Next.Read(context, message));
}
// 最后一个处理器，截断
if (context != null)
{
context.FireRead(message);
}
return(message);
}
/// <summary>读取数据，返回结果作为下一个处理器消息</summary>
/// <param name="context">上下文</param>
/// <param name="message">消息</param>
public virtual void Read(IHandlerContext context, Object message)
{
var rs = Head?.Read(context, message);
if (rs != null)
{
//context.Finish?.Invoke(rs);
// 处理消息
//var data = context.Data ?? new ReceivedEventArgs();
//data.Message = rs;
//context.Session.Receive(data);
context.FireRead(rs);
}
}
/// <summary>读取数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Read(IHandlerContext context, Object message)
{
if (!(message is Packet pk))
{
return(base.Read(context, message));
}
// 是否Http请求
var isGet = pk.Count >= 4 && pk[0] == 'G' && pk[1] == 'E' && pk[2] == 'T' && pk[3] == ' ';
var isPost = pk.Count >= 5 && pk[0] == 'P' && pk[1] == 'O' && pk[2] == 'S' && pk[3] == 'T' && pk[4] == ' ';
// 该连接第一包检查是否Http
var ext = context.Owner as IExtend;
if (!(ext["Encoder"] is HttpEncoder))
{
// 第一个请求必须是GET/POST，才执行后续操作
if (!isGet && !isPost)
{
return(base.Read(context, message));
}
ext["Encoder"] = new HttpEncoder();
}
// 检查是否有未完成消息
if (ext["Message"] is HttpMessage msg)
{
// 数据包拼接到上一个未完整消息中
if (msg.Payload == null)
{
msg.Payload = pk;
}
else
{
msg.Payload.Append(pk);
}
// 消息完整才允许上报
if (msg.ContentLength == 0 || msg.ContentLength > 0 && msg.Payload != null && msg.Payload.Total >= msg.ContentLength)
{
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(msg);
// 移除消息
ext["Message"] = null;
}
}
else
{
// 解码得到消息
msg = new HttpMessage();
if (!msg.Read(pk))
{
throw new XException("Http请求头不完整");
}
if (AllowParseHeader && !msg.ParseHeaders())
{
throw new XException("Http头部解码失败");
}
// GET请求一次性过来，暂时不支持头部被拆为多包的场景
if (isGet)
{
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(msg);
}
// POST可能多次，最典型的是头部和主体分离
else
{
// 消息完整才允许上报
if (msg.ContentLength == 0 || msg.ContentLength > 0 && msg.Payload != null && msg.Payload.Total >= msg.ContentLength)
{
// 匹配输入回调，让上层事件收到分包信息
context.FireRead(msg);
}
else
{
// 请求不完整，拷贝一份，避免缓冲区重用
if (msg.Header != null)
{
msg.Header = msg.Header.Clone();
}
if (msg.Payload != null)
{
msg.Payload = msg.Payload.Clone();
}
ext["Message"] = msg;
}
}
}
return(null);
}