public MCConnectionContext(ConnectionContext ctx, IPacketQueue packetQueue)
{
PacketQueue = packetQueue;
_underlyingCtx = ctx;
_mcDuplexPipe = new MCDuplexPipe(_underlyingCtx.Transport);
Items["state"] = MCConnectionStage.Handshaking;
Items["isLocal"] = false;
}
// readonly UdpClient udpClient = new UdpClient(10000);
public Worker(ILogger <Worker> logger, IRedisDataAccessor _redis, IPacketQueue queue)
{
_logger = logger;
logger.LogInformation("entry worker");
redisDataAccessor = _redis;
db = _redis.Connection().GetDatabase();
packetQueue = queue;
}
/// <summary>加入请求队列</summary>
/// <param name="request">请求的数据</param>
/// <param name="remote">远程</param>
/// <param name="msTimeout">超时取消时间</param>
public virtual Task <Packet> Add(Packet request, IPEndPoint remote, Int32 msTimeout)
{
if (Queue == null)
{
Queue = new DefaultPacketQueue();
}
return(Queue.Add(this, request, remote, msTimeout));
}
/// <summary>创建粘包处理实例，内含缓冲区，不同会话不能共用</summary>
/// <returns></returns>
public virtual IPacket Create()
{
if (_queue == null)
{
_queue = new MyQueue();
}
return(new DefaultPacket {
Queue = _queue
});
}
public void HandlePacket(MCConnectionContext ctx, IPacketReader reader, IPacketQueue packetQueue, int id)
{
var packet = _resolver.GetReadablePacket(id, ctx);
if (packet == null)
{
_logger.LogInformation($"Unknown {ctx.ConnectionStage.AsString()} Packet {id:x2}");
return;
}
packet.Read(reader);
packet.Process(_logger, ctx, _serviceProvider);
}
/// <summary>创建粘包处理实例，内含缓冲区，不同会话不能共用</summary>
/// <returns></returns>
public virtual IPacket Create()
{
if (_queue == null)
{
_queue = new DefaultPacketQueue();
}
return(new PacketProvider
{
Offset = Offset,
Size = Size,
Expire = Expire,
Queue = _queue
});
}
public ConsumeDataService(IPacketQueue packetQueue, EventPublisherWorker eventPublisherWorker, ILogger <ConsumeDataService> logger)
{
queue = packetQueue;
_worker = eventPublisherWorker;
this.logger = logger;
}
public PacketQueueRepository()
{
IncomingPacketQueue = new PacketQueue();
HandleInBandPacketQueue = new PacketQueue();
HandleOutOfBandPacketQueue = new PacketQueue();
}
public FrostbiteClient() : base() {
this.PacketQueue = new PacketQueue();
this.PacketSerializer = new FrostbitePacketSerializer();
}
public Worker(ILogger <Worker> logger, IPacketQueue packetQueue, EventPublisherWorker eventPublisherWorker)
{
_logger = logger;
this.packetQueue = packetQueue;
this._worker = eventPublisherWorker;
}
public void Register(IPacketQueue queue)
{
_packetQueues.Add(new WeakReference <IPacketQueue>(queue));
}
public MqttHostService(IPacketQueue packetQueue, ILogger <MqttHostService> logger)
{
queue = packetQueue;
this.logger = logger;
}
public QueueReceiverWorker(ILogger <QueueReceiverWorker> _logger, IPacketQueue queue)
{
mqttSubscriber = new PeiuMqttSubscriber(_logger, queue);
this._logger = _logger;
}
public ConsumeDataService(IPacketQueue packetQueue)
{
queue = packetQueue;
}
private void HandlePacket(ReadOnlySequence <byte> buffer, MCConnectionContext ctx, IPacketQueue packetQueue)
{
var reader = _packetReaderFactory.CreateReader(buffer);
var length = reader.ReadVarInt();
if (length > reader.Buffer.Length || length < 1 /* 1 = small ID but no fields*/)
{
_logger.LogCritical($"Read Invalid length {length:X}. Aborting");
ctx.Abort();
return;
}
var lengthLength = buffer.Length - reader.Buffer.Length;
reader = new MCPacketReader(reader.Buffer.Slice(0, length));
var id = reader.ReadVarInt();
using var packetIdScope = _logger.BeginScope($"Packet ID: {id:x2}");
_packetHandler.HandlePacket(ctx, reader, packetQueue, id);
// NOT IDEAL, but easiest
var packetSize = length + lengthLength;
ctx.Transport.Input.AdvanceTo(buffer.GetPosition(packetSize));
_metrics.Measure.Histogram.Update(MetricsRegistry.ReadPacketSize, packetSize);
}
public DaegunSubscriberWorker(IPacketQueue packetQueue)
{
this.queue = packetQueue;
this.Initialize();
}
public MqttHostService(IPacketQueue packetQueue)
{
queue = packetQueue;
}
public PeiuMqttSubscriber(ILogger _logger, IPacketQueue queue)
{
logger = _logger;
packetQueue = queue;
}
