/// <summary>
///
/// </summary>
/// <param name="values"></param>
/// <param name="fun"></param>
public void Write(byte[] values, byte fun)
{
try
{
var buffer = pooledByteBufAllocator.DirectBuffer(values.Length + 1);
buffer.WriteByte(fun);
Marshal.Copy(values, 0, buffer.AddressOfPinnedMemory() + 1, values.Length);
buffer.SetWriterIndex(values.Length + 1);
mContext?.WriteAndFlushAsync(buffer);
}
catch
{
}
}
/// <summary>
///
/// </summary>
/// <param name="values"></param>
public void Write(IChannelHandlerContext mContext, IByteBuffer values)
{
try
{
mContext?.WriteAndFlushAsync(values);
}
catch
{
}
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
if (message is int)
{
var i = (int) message;
State = State.ReceiveMessages(i);
// echo the reply back to the client
context.WriteAndFlushAsync(i);
}
}
/// <summary>
///
/// </summary>
/// <param name="mContext"></param>
/// <param name="values"></param>
/// <param name="offset"></param>
/// <param name="len"></param>
/// <param name="fun"></param>
public void Write(IChannelHandlerContext mContext, byte[] values, int offset, int len, byte fun)
{
try
{
var buffer = BufferManager.Manager.Allocate(len + 1);
buffer.WriteByte(fun);
Marshal.Copy(values, offset, buffer.AddressOfPinnedMemory() + 1, len);
buffer.SetWriterIndex(len + 1);
mContext?.WriteAndFlushAsync(buffer);
}
catch
{
}
}
/// <summary>
///
/// </summary>
/// <param name="mContext"></param>
/// <param name="value"></param>
/// <param name="len"></param>
/// <param name="fun"></param>
public unsafe void Write(IChannelHandlerContext mContext, IntPtr value, int len, byte fun)
{
try
{
var buffer = BufferManager.Manager.Allocate(len + 1);
buffer.WriteByte(fun);
Buffer.MemoryCopy((void *)(value), (void *)(buffer.AddressOfPinnedMemory() + 1), len, len);
buffer.SetWriterIndex(len + 1);
mContext?.WriteAndFlushAsync(buffer);
}
catch
{
}
}
protected override void ChannelRead0(IChannelHandlerContext ctx, IByteBuffer msg)
{
_bytesRead += msg.ReadableBytes;
if (_bytesRead >= _expectedBytes)
{
// We write a reply and immediately close our end of the socket.
IByteBuffer buf = ctx.Allocator.Buffer(_expectedBytes);
buf.SetWriterIndex(buf.WriterIndex + _expectedBytes);
ctx.WriteAndFlushAsync(buf).ContinueWith(t =>
{
ctx.Channel.CloseAsync().ContinueWith(task =>
{
// This is a bit racy but there is no better way how to handle this in Java11.
// The problem is that on close() the underlying FD will not actually be closed directly
// but the close will be done after the Selector did process all events. Because of
// this we will need to give it a bit time to ensure the FD is actual closed before we
// count down the latch and try to write.
_followerCloseLatch.SafeSignal();
//ctx.Channel.EventLoop.Schedule(() => _followerCloseLatch.SafeSignal(), TimeSpan.FromMilliseconds(200));
}, TaskContinuationOptions.ExecuteSynchronously);
}, TaskContinuationOptions.ExecuteSynchronously);
}
}
protected override void ChannelRead0(IChannelHandlerContext ctx, object msg)
{
var ctssc = serverContext.Channel as CustHttpSocketChannel;
if (ctssc == null || !ctssc.Active)
{
throw new Exception("服务端链路失效");
}
var clientChannel = ctx.Channel as CustHttpSocketChannel;
if (clientChannel == null || !clientChannel.ChannelMata.tags.ContainsKey("channelKey"))
{
return;
}
clientChannel.outMapPort.ins_serverProcessCount();
var bb = (msg as IByteBuffer);
bb.Retain(); //计数加1
var count = bb.ReadableBytes;
object outobj = null;
if (clientChannel.ChannelMata.tags.ContainsKey("readStart"))
{
DateTime end = DateTime.Now;
if (clientChannel.ChannelMata.tags.TryGetValue("readStart", out outobj) && outobj != null)
{
DateTime begin = (DateTime)outobj;
clientChannel.outMapPort.add_msec_ServerProcess((long)(end - begin).TotalMilliseconds);
}
clientChannel.ChannelMata.tags.TryRemove("readStart", out outobj);
}
clientChannel.outMapPort.addSendBytes(bb.ReadableBytes);
Console.WriteLine(clientChannel.outMapPort.toJson());
serverContext.WriteAndFlushAsync(msg);
}
public override void UserEventTriggered(IChannelHandlerContext context, object evt)
{
base.UserEventTriggered(context, evt);
if (evt is IdleStateEvent)
{
var e = evt as IdleStateEvent;
switch (e.State)
{
//长期没收到服务器推送数据
case IdleState.ReaderIdle:
{
//可以重新连接
if (!context.Channel.Active)
{
context.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8007));
}
}
break;
//长期未向服务器发送数据
case IdleState.WriterIdle:
{
//发送心跳包
byte[] messageBytes = Encoding.UTF8.GetBytes("heartbeat");
context.WriteAndFlushAsync(messageBytes);
}
break;
//All
case IdleState.AllIdle:
{
}
break;
}
}
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
input.MarkReaderIndex();
if (input.ReadableBytes < 6)
{
return;
}
byte delimeter = input.ReadByte();
input.ResetReaderIndex();
if (delimeter == 60)
{
context.WriteAndFlushAsync(Unpooled.CopiedBuffer(PolicyRequest));
}
else
{
input.MarkReaderIndex();
int length = input.ReadInt();
if (input.ReadableBytes < length)
{
input.ResetReaderIndex();
return;
}
IByteBuffer buffer = input.ReadBytes(length);
if (length < 0)
{
return;
}
ClientPacket clientMessage = new ClientPacket(buffer.ReadBytes(length));
output.Add(clientMessage);
}
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
var sender = ((UdpMessage)message).Sender;
if (message is Message msg)
{
// var json = JsonConvert.SerializeObject(msg,Formatting.None);
GkParser.ParseCore(ref msg);
Logger.Info($"收到设备消息, msg:{msg.Bodies[0].IdType.ToString()}");
// MsgBuilder.BuildResp(context, msg);
var header = msg.Header;
var body = msg.Bodies[0];
if (IdType.HeartBeat.Equals(body.IdType) && HeartBeatType.Online.Equals(body.HeartBeatInfo.HeartBeatType))
{
//下发查询设备类型指令
var content = MsgBuilder.BuildContent(IdType.ReadDeviceInfo, MsgType.Configure, OpsType.ReadCommand,
0, 1, null);
var cmd = MsgBuilder.BuildMessage(header.Src, header.Dst, header.Ver, false, 1, 0, content);
var buffer = Unpooled.WrappedBuffer(cmd);
var packet = new DatagramPacket(buffer, sender);
context.WriteAndFlushAsync(packet);
}
}
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
if (!(message is Envelope envelope))
{
Log.Error("Envelope is null");
return;
}
if (envelope.Ping == null)
{
Log.Error("Ping is null");
return;
}
Log.Info("Received ping: {0}", envelope.Ping.Data);
var response = new Envelope {
Pong = new Pong {
Data = envelope.Ping.Data
}
};
context.WriteAndFlushAsync(response);
}
public override void ChannelActive(IChannelHandlerContext ctx)
{
DefaultFullHttpRequest upgradeRequest =
new DefaultFullHttpRequest(DotNetty.Codecs.Http.HttpVersion.Http11, HttpMethod.Get, "/", Unpooled.Empty);
// Set HOST header as the remote peer may require it.
var remote = (IPEndPoint)ctx.Channel.RemoteAddress;
//String hostString = remote.getHostString();
//if (hostString == null)
//{
// hostString = remote.getAddress().getHostAddress();
//}
upgradeRequest.Headers.Set(HttpHeaderNames.Host, _self._targetHost + ':' + remote.Port);
ctx.WriteAndFlushAsync(upgradeRequest);
ctx.FireChannelActive();
// Done with this handler, remove it from the pipeline.
ctx.Pipeline.Remove(this);
_self.ConfigureEndOfPipeline(ctx.Pipeline);
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
var buffer = message as IByteBuffer;
if (buffer != null)
{
string receiveData = buffer.ToString(Encoding.UTF8);
Console.WriteLine(receiveData);
TransportMessage transportMessage =
Newtonsoft.Json.JsonConvert.DeserializeObject <TransportMessage>(receiveData);
if (transportMessage.TransoprtType == TransoprtType.Init)
{
string responseData = "ok";
transportMessage.TransoprtType = TransoprtType.Ans;
transportMessage.Message = responseData;
}
if (transportMessage.TransoprtType == TransoprtType.Request)
{
string responseData = Handle?.Invoke(transportMessage.Message);
transportMessage.TransoprtType = TransoprtType.Response;
transportMessage.Message = responseData;
}
else
{
string responseData = "不需要处理的";
transportMessage.TransoprtType = TransoprtType.Response;
transportMessage.Message = responseData;
}
string responseMessage = Newtonsoft.Json.JsonConvert.SerializeObject(transportMessage);
IByteBuffer byteBuffer = Unpooled.Buffer(256);
byte[] messageBytes = Encoding.UTF8.GetBytes(responseMessage);
byteBuffer.WriteBytes(messageBytes);
context.WriteAndFlushAsync(byteBuffer);
}
}
protected override void ChannelRead0(IChannelHandlerContext contex, string msg)
{
string response;
bool close = false;
if (string.IsNullOrEmpty(msg))
{
response = "Please type something.\r\n";
}
else if (string.Equals("bye", msg, StringComparison.OrdinalIgnoreCase))
{
response = "Have a good day!\r\n";
close = true;
}
else if (_poker.IsGameStarted == false)
{
response = "Waiting for player\r\n";
}
else
{
//group.WriteAndFlushAsync(broadcast, new EveryOneBut(contex.Channel.Id));
response = _poker.LaunchPoker(msg.Trim().ToUpper(), contex.Channel.RemoteAddress.ToString());
if (response.StartsWith("ACTION:"))
{
_group.WriteAndFlushAsync(response, new EveryOneBut(contex.Channel.Id));
}
}
Task waitClose = contex.WriteAndFlushAsync(response);
if (close)
{
Task.WaitAll(waitClose);
contex.CloseAsync();
}
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
var req = message as ConfigCenterServiceRequest;
if (req == null)
{
}
var reqContext = _pool.Rent();
reqContext.Connection = _manager.GetConnection(context.Channel.Id.AsLongText());
reqContext.Request = req;
processRequest(reqContext);
context.WriteAndFlushAsync(reqContext.Response);
reqContext.Response.ResponseCode = ResponseCode.Suceessed;
reqContext.Response.ResponseId = 0;
reqContext.Response.Result = null;
reqContext.Response.Message = string.Empty;
_pool.Recycle(reqContext);
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
input.MarkReaderIndex();
if (input.ReadableBytes < 1)
{
return;
}
byte delimiter = input.ReadByte();
input.ResetReaderIndex();
if (delimiter == 0x3C)
{
var policy = "<?xml version=\"1.0\"?>\r\n"
+ "<!DOCTYPE cross-domain-policy SYSTEM \"/xml/dtds/cross-domain-policy.dtd\">\r\n"
+ "<cross-domain-policy>\r\n"
+ "<allow-access-from domain=\"*\" to-ports=\"*\" />\r\n"
+ "</cross-domain-policy>\0)";
context.WriteAndFlushAsync(Unpooled.CopiedBuffer(Encoding.Default.GetBytes(policy)));
}
else
{
context.Channel.Pipeline.Remove(this);
}
}
public async Task WriteAsync(string messageId, JimuRemoteCallResultData resultMessage)
{
try
{
_logger.Debug($"finish handling msg: {messageId}");
var data = JimuHelper.Serialize <byte[]>(new JimuTransportMsg(messageId, resultMessage));
if (data.Length < 102400)
{
_logger.Debug($"resp msg is: {Encoding.UTF8.GetString(data)}");
}
else
{
_logger.Debug($"resp msg is (bigger than 100k, we don't show it)");
}
var buffer = Unpooled.Buffer(data.Length, data.Length);
buffer.WriteBytes(data);
await _channel.WriteAndFlushAsync(buffer);
}
catch (Exception ex)
{
_logger.Error("throw exception when response msg: " + messageId, ex);
}
}
public async Task ConnAck(IChannelHandlerContext context, ConnAckPacket packet)
{
await context.WriteAndFlushAsync(packet);
}
public async Task PingResp(IChannelHandlerContext context, PingRespPacket packet)
{
await context.WriteAndFlushAsync(packet);
}
protected override void ChannelRead0(IChannelHandlerContext context, IByteBuffer input)
{
if (_logger.IsTrace)
{
_logger.Trace($"Channel read {nameof(NettyHandshakeHandler)} from {context.Channel.RemoteAddress}");
}
if (_role == HandshakeRole.Recipient)
{
if (_logger.IsTrace)
{
_logger.Trace($"AUTH received from {context.Channel.RemoteAddress}");
}
byte[] authData = new byte[input.ReadableBytes];
input.ReadBytes(authData);
Packet ack = _service.Ack(_handshake, new Packet(authData));
//_p2PSession.RemoteNodeId = _remoteId;
if (_logger.IsTrace)
{
_logger.Trace($"Sending ACK to {RemoteId} @ {context.Channel.RemoteAddress}");
}
IByteBuffer buffer = PooledByteBufferAllocator.Default.Buffer();
buffer.WriteBytes(ack.Data);
context.WriteAndFlushAsync(buffer);
}
else
{
if (_logger.IsTrace)
{
_logger.Trace($"Received ACK from {RemoteId} @ {context.Channel.RemoteAddress}");
}
byte[] ackData = new byte[input.ReadableBytes];
input.ReadBytes(ackData);
_service.Agree(_handshake, new Packet(ackData));
}
_initCompletionSource?.SetResult(input);
_session.Handshake(_handshake.RemoteNodeId);
FrameCipher frameCipher = new FrameCipher(_handshake.Secrets.AesSecret);
FrameMacProcessor macProcessor = new FrameMacProcessor(_session.RemoteNodeId, _handshake.Secrets);
if (_role == HandshakeRole.Recipient)
{
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(LengthFieldBasedFrameDecoder)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast("enc-handshake-dec", new LengthFieldBasedFrameDecoder(ByteOrder.BigEndian, ushort.MaxValue, 0, 2, 0, 0, true));
}
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(ReadTimeoutHandler)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new ReadTimeoutHandler(TimeSpan.FromSeconds(30))); // read timeout instead of session monitoring
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(ZeroFrameDecoder)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new ZeroFrameDecoder(frameCipher, macProcessor, _logManager));
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(ZeroFrameEncoder)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new ZeroFrameEncoder(frameCipher, macProcessor, _logManager));
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(ZeroFrameMerger)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new ZeroFrameMerger(_logManager));
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(ZeroPacketSplitter)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new ZeroPacketSplitter(_logManager));
PacketSender packetSender = new PacketSender(_serializationService, _logManager);
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(PacketSender)} for {_session.RemoteNodeId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(packetSender);
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(ZeroNettyP2PHandler)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
ZeroNettyP2PHandler handler = new ZeroNettyP2PHandler(_session, _logManager);
context.Channel.Pipeline.AddLast(_group, handler);
handler.Init(packetSender, context);
if (_logger.IsTrace)
{
_logger.Trace($"Removing {nameof(NettyHandshakeHandler)}");
}
context.Channel.Pipeline.Remove(this);
if (_logger.IsTrace)
{
_logger.Trace($"Removing {nameof(LengthFieldBasedFrameDecoder)}");
}
context.Channel.Pipeline.Remove <LengthFieldBasedFrameDecoder>();
}
public Task WriteAndFlushAsync(object message) => _ctx.WriteAndFlushAsync(message);
public static async Task WriteMessageAsync(IChannelHandlerContext context, object message, Func<IChannelHandlerContext, Exception, bool> exceptionHandler)
{
try
{
await context.WriteAndFlushAsync(message);
}
catch (Exception ex)
{
if (!exceptionHandler(context, ex))
{
throw;
}
}
}
bool Upgrade(IChannelHandlerContext ctx, IFullHttpRequest request)
{
// Select the best protocol based on those requested in the UPGRADE header.
IList <ICharSequence> requestedProtocols = SplitHeader(request.Headers.Get(HttpHeaderNames.Upgrade, null));
int numRequestedProtocols = requestedProtocols.Count;
IUpgradeCodec upgradeCodec = null;
ICharSequence upgradeProtocol = null;
for (int i = 0; i < numRequestedProtocols; i++)
{
ICharSequence p = requestedProtocols[i];
IUpgradeCodec c = this.upgradeCodecFactory.NewUpgradeCodec(p);
if (c != null)
{
upgradeProtocol = p;
upgradeCodec = c;
break;
}
}
if (upgradeCodec == null)
{
// None of the requested protocols are supported, don't upgrade.
return(false);
}
// Make sure the CONNECTION header is present.
if (!request.Headers.TryGet(HttpHeaderNames.Connection, out ICharSequence connectionHeader))
{
return(false);
}
// Make sure the CONNECTION header contains UPGRADE as well as all protocol-specific headers.
ICollection <AsciiString> requiredHeaders = upgradeCodec.RequiredUpgradeHeaders;
IList <ICharSequence> values = SplitHeader(connectionHeader);
if (!AsciiString.ContainsContentEqualsIgnoreCase(values, HttpHeaderNames.Upgrade) ||
!AsciiString.ContainsAllContentEqualsIgnoreCase(values, requiredHeaders))
{
return(false);
}
// Ensure that all required protocol-specific headers are found in the request.
foreach (AsciiString requiredHeader in requiredHeaders)
{
if (!request.Headers.Contains(requiredHeader))
{
return(false);
}
}
// Prepare and send the upgrade response. Wait for this write to complete before upgrading,
// since we need the old codec in-place to properly encode the response.
IFullHttpResponse upgradeResponse = CreateUpgradeResponse(upgradeProtocol);
if (!upgradeCodec.PrepareUpgradeResponse(ctx, request, upgradeResponse.Headers))
{
return(false);
}
// Create the user event to be fired once the upgrade completes.
var upgradeEvent = new UpgradeEvent(upgradeProtocol, request);
IUpgradeCodec finalUpgradeCodec = upgradeCodec;
ctx.WriteAndFlushAsync(upgradeResponse).ContinueWith(t =>
{
try
{
if (t.Status == TaskStatus.RanToCompletion)
{
// Perform the upgrade to the new protocol.
this.sourceCodec.UpgradeFrom(ctx);
finalUpgradeCodec.UpgradeTo(ctx, request);
// Notify that the upgrade has occurred. Retain the event to offset
// the release() in the finally block.
ctx.FireUserEventTriggered(upgradeEvent.Retain());
// Remove this handler from the pipeline.
ctx.Channel.Pipeline.Remove(this);
}
else
{
ctx.Channel.CloseAsync();
}
}
finally
{
// Release the event if the upgrade event wasn't fired.
upgradeEvent.Release();
}
}, TaskContinuationOptions.ExecuteSynchronously);
return(true);
}
/// <summary>
/// The ChannelReadComplete executes after the entire ChannelPipeline has been executed.
/// </summary>
public override void ChannelReadComplete(IChannelHandlerContext ctx)
{
ctx.WriteAndFlushAsync($"Your message contained {MessageLenght} chars." + System.Environment.NewLine);
ctx.FireChannelReadComplete();
}
protected override void ChannelRead0(IChannelHandlerContext ctx, object msg) => ctx.WriteAndFlushAsync(new DefaultFullHttpResponse(HttpVersion.Http11, HttpResponseStatus.OK, true, true));
public async Task WriteAndFlushAsync(ServerPacket serverPacket) => await _ctx.WriteAndFlushAsync(serverPacket);
public override void ChannelRead(IChannelHandlerContext context, object message)
{
context.WriteAndFlushAsync(message);
}
public async Task SendAndFlushAsync(TransportMessage message)
{
var buffer = Unpooled.WrappedBuffer(message.Encode());
await _channelContext.WriteAndFlushAsync(buffer);
}
private Task SubscribeAsync(IChannelHandlerContext context)
{
var message = new SubscribePacket(GetNextPacketId(), new SubscriptionRequest(SubscribeFilter, Qos));
return(context.WriteAndFlushAsync(message));
}
/// <summary>
/// 主动和被动与服务器断开后触发
/// </summary>
/// <param name="context"></param>
public override void ChannelInactive(IChannelHandlerContext context)
{
Console.WriteLine("与服务器连接断开触发重连" + DateTime.Now.ToLongTimeString());
context.WriteAndFlushAsync(this.initialMessage);
base.ChannelInactive(context);
}
public static async Task WriteMessageAsync(IChannelHandlerContext context, object message)
{
await context.WriteAndFlushAsync(message);
if (message is PublishPacket)
{
PerformanceCounters.PublishPacketsSentPerSecond.Increment();
}
PerformanceCounters.PacketsSentPerSecond.Increment();
}
public override void ChannelActive(IChannelHandlerContext context)
{
context.WriteAndFlushAsync(this.initialMessage);
}
public async Task SendAndFlushAsync(TransportMessage message)
{
var response = await WriteResponse(message);
await _context.WriteAndFlushAsync(response);
}
protected override void ChannelRead0(IChannelHandlerContext context, IByteBuffer message)
{
if (_logger.IsTrace)
{
_logger.Trace($"Channel read {nameof(NettyHandshakeHandler)} from {context.Channel.RemoteAddress}");
}
if (message is IByteBuffer byteBuffer)
{
if (_role == HandshakeRole.Recipient)
{
if (_logger.IsTrace)
{
_logger.Trace($"AUTH received from {context.Channel.RemoteAddress}");
}
byte[] authData = new byte[byteBuffer.ReadableBytes];
byteBuffer.ReadBytes(authData);
Packet ack = _service.Ack(_handshake, new Packet(authData));
//_p2PSession.RemoteNodeId = _remoteId;
if (_logger.IsTrace)
{
_logger.Trace($"Sending ACK to {RemoteId} @ {context.Channel.RemoteAddress}");
}
_buffer.WriteBytes(ack.Data);
context.WriteAndFlushAsync(_buffer);
}
else
{
if (_logger.IsTrace)
{
_logger.Trace($"Received ACK from {RemoteId} @ {context.Channel.RemoteAddress}");
}
byte[] ackData = new byte[byteBuffer.ReadableBytes];
byteBuffer.ReadBytes(ackData);
_service.Agree(_handshake, new Packet(ackData));
}
_initCompletionSource?.SetResult(message);
_session.Handshake(_handshake.RemoteNodeId);
FrameCipher frameCipher = new FrameCipher(_handshake.Secrets.AesSecret);
FrameMacProcessor macProcessor = new FrameMacProcessor(_session.RemoteNodeId, _handshake.Secrets);
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(NettyFrameDecoder)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new NettyFrameDecoder(frameCipher, macProcessor, _logger));
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(NettyFrameEncoder)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new NettyFrameEncoder(frameCipher, macProcessor, _logger));
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(NettyFrameMerger)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new NettyFrameMerger(_logger));
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(NettyPacketSplitter)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(new NettyPacketSplitter());
PacketSender packetSender = new PacketSender(_logManager);
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(PacketSender)} for {_session.RemoteNodeId} @ {context.Channel.RemoteAddress}");
}
context.Channel.Pipeline.AddLast(packetSender);
if (_logger.IsTrace)
{
_logger.Trace($"Registering {nameof(NettyP2PHandler)} for {RemoteId} @ {context.Channel.RemoteAddress}");
}
NettyP2PHandler handler = new NettyP2PHandler(_session, _logger);
context.Channel.Pipeline.AddLast(_group, handler);
handler.Init(packetSender, context);
if (_logger.IsTrace)
{
_logger.Trace($"Removing {nameof(NettyHandshakeHandler)}");
}
context.Channel.Pipeline.Remove(this);
if (_logger.IsTrace)
{
_logger.Trace($"Removing {nameof(LengthFieldBasedFrameDecoder)}");
}
context.Channel.Pipeline.Remove <LengthFieldBasedFrameDecoder>();
}
else
{
if (_logger.IsError)
{
_logger.Error($"DIFFERENT TYPE OF DATA {message.GetType()}");
}
}
}
public override void ChannelActive(IChannelHandlerContext context)
{
context.WriteAndFlushAsync(this.initialMessage);
}