public override void ChannelRead(IChannelHandlerContext context, object message) { var msg = message as Message; if (msg == null) { context.FireChannelRead(message); return; } if (msg.MessageType == MessageType.Request || msg.MessageType == MessageType.Notify) { //var data = msg.Data; //var str = Encoding.UTF8.GetString(data); //// Console.WriteLine(str); //var count = Interlocked.Increment(ref Count); ////Console.WriteLine("接收数据:" + (count)); //Logger.LogInformation("接收数据:" + count); //msg.MessageType = MessageType.Response; //context.Channel.WriteAsync(message).Wait(); Task.Run(async() => { await BusinessProcess(context, msg); }); } else { context.FireChannelRead(message); } }
public override void ChannelRead(IChannelHandlerContext context, object message) { var msg = message as Message; if (msg == null) { context.FireChannelRead(message); return; } if (msg.MessageType == MessageType.Response) { ResponseManage.Instance.SetResult(msg.RequestId, msg); /* * var data = msg.Data; * var str = Encoding.UTF8.GetString(data); * var count = Interlocked.Increment(ref Count); * // if(count % 10000==0 || count +10 >= 8000 * 10000) * Logger.LogInformation("接收数据:" + (count)); * //Console.WriteLine(str); */ } else { context.FireChannelRead(message); } }
public override void ChannelRead(IChannelHandlerContext context, object message) { SafeProcess(() => { var msg = (Message)message; if (msg.Type == MessageType.LoginResponse) { var result = CertifiedResult.FromMessage(msg); if (result.IsOK) { //认证成功 Online(context); context.FireChannelRead(msg); } else { //认证失败 ClientEvents.AsyncRaiseError(this.Client, new LoginFailedException(result.Info)); context.CloseAsync(); } } else { //不是登录认证的响应,那么交由下一个通道处理器 context.FireChannelRead(msg); } }, context); }
protected override void ChannelRead0(IChannelHandlerContext ctx, ISocksMessage msg) { switch (msg.Version()) { case SocksVersion.Socks4A: var socksV4CmdRequest = (ISocks4CommandRequest)msg; if (Equals(socksV4CmdRequest.Type, Socks4CommandType.Connect)) { ctx.Channel.Pipeline.AddLast(new SocksServerConnectHandler()); ctx.Channel.Pipeline.Remove(this); ctx.FireChannelRead(msg); } else { ctx.CloseAsync(); } break; case SocksVersion.Socks5: if (msg is ISocks5InitialRequest) { // auth support example //ctx.pipeline().addFirst(new Socks5PasswordAuthRequestDecoder()); //ctx.write(new DefaultSocks5AuthMethodResponse(Socks5AuthMethod.PASSWORD)); ctx.Channel.Pipeline.AddFirst(new Socks5CommandRequestDecoder()); ctx.WriteAsync(new DefaultSocks5InitialResponse(Socks5AuthMethod.NoAuth)); } else if (msg is ISocks5PasswordAuthRequest) { ctx.Channel.Pipeline.AddFirst(new Socks5CommandRequestDecoder()); ctx.WriteAsync(new DefaultSocks5PasswordAuthResponse(Socks5PasswordAuthStatus.Success)); } else if (msg is ISocks5CommandRequest) { var socks5CmdRequest = (ISocks5CommandRequest)msg; if (Equals(socks5CmdRequest.Type, Socks5CommandType.Connect)) { ctx.Channel.Pipeline.AddLast(new SocksServerConnectHandler()); ctx.Channel.Pipeline.Remove(this); ctx.FireChannelRead(msg); } else { ctx.CloseAsync(); } } else { ctx.CloseAsync(); } break; case SocksVersion.Unknown: ctx.CloseAsync(); break; } }
public override void ChannelRead(IChannelHandlerContext context, object message) { var data = message as IByteBuffer; if (data != null) { ThreadLocalObjectList output = ThreadLocalObjectList.NewInstance(); try { this.first = this.cumulation == null; if (this.first) { this.cumulation = data; } else { this.cumulation = this.cumulator(context.Allocator, this.cumulation, data); } this.CallDecode(context, this.cumulation, output); } catch (DecoderException) { throw; } catch (Exception ex) { throw new DecoderException(ex); } finally { if (this.cumulation != null && !this.cumulation.IsReadable()) { this.cumulation.Release(); this.cumulation = null; } int size = output.Count; this.decodeWasNull = size == 0; for (int i = 0; i < size; i++) { context.FireChannelRead(output[i]); } output.Return(); } } else { context.FireChannelRead(message); } }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="message"></param> public override void ChannelRead(IChannelHandlerContext context, object message) { var msg = (Message)message; //如果是握手应答消息,需要判断是否认证成功 if (msg.Header != null && msg.Header.Type == MessageType.LOGIN_RESP) { if (loginResponseHandler != null) { Task.Run(() => { var channelName = context.GetChannelName(); loginResponseHandler(channelName, msg.Body, msg.Header.Attachments).ContinueWith(t => { var loginResult = t.Result; if (loginResult == 0) { logger.LogInformation($"Login success. Local={context.GetLocalNetString()}, Remote={context.GetRemoteNetString()}, Message={msg}"); } else { logger.LogError($"Login failed. Local={context.GetLocalNetString()}, Remote={context.GetRemoteNetString()}, LoginResult={loginResult}"); //握手失败 context.CloseAsync(); } }); }); } else { var loginResult = msg.Body; if (loginResult.Length != 1 || loginResult[0] != (byte)0) { logger.LogError($"Login failed. Local={context.GetLocalNetString()}, Remote={context.GetRemoteNetString()}, LoginResult={loginResult[0]}"); //握手失败 context.CloseAsync(); } else { logger.LogInformation($"Login success. Local={context.GetLocalNetString()}, Remote={context.GetRemoteNetString()}, Message={msg}"); context.FireChannelRead(message); } } } else { context.FireChannelRead(message); } }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (message is IByteBuf) { var buf = (IByteBuf) message; var integer = buf.ReadInt(); if (ReleaseMessages) ReferenceCountUtil.SafeRelease(message); context.FireChannelRead(integer); } else { context.FireChannelRead(message); } }
/// <summary> /// The server should always correlate a response, if it can fire next pipeline, if not close the channel, /// If the message is not a response (IE Request/Broadcast) it should pass on to the next handler without attempting to correlate. /// </summary> /// <param name="ctx"></param> /// <param name="message"></param> protected override void ChannelRead0(IChannelHandlerContext ctx, ProtocolMessage message) { Logger.Verbose("Received {message}", message); if (message.TypeUrl.EndsWith(MessageTypes.Response.Name)) { if (_messageCorrelationManager.TryMatchResponse(message)) { ctx.FireChannelRead(message); } } else { ctx.FireChannelRead(message); } }
public override void ChannelRead(IChannelHandlerContext context, object message) { IByteBuffer buffer = (IByteBuffer)message; try { byte[] data = new byte[buffer.ReadableBytes]; buffer.GetBytes(buffer.ReaderIndex, data); string datajson = LZ4MessagePackSerializer.ToJson(data); var convertedMsg = _serializer.Deserialize <string, TransportMsg>(datajson); if (convertedMsg.ContentType == typeof(RemoteCallData).FullName) { convertedMsg.Content = _serializer.Deserialize <object, RemoteCallData>(convertedMsg.Content); } else if (convertedMsg.ContentType == typeof(RemoteCallBackData).FullName) { convertedMsg.Content = _serializer.Deserialize <object, RemoteCallBackData>(convertedMsg.Content); } context.FireChannelRead(convertedMsg); } finally { buffer.Release(); } }
public override void ChannelRead(IChannelHandlerContext context, object message) { var t = _thread; if (t is null) { _thread = Thread.CurrentThread; } else { Assert.Same(t, Thread.CurrentThread); } IByteBuffer m = (IByteBuffer)message; int count = m.ReadableBytes / 4; for (int j = 0; j < count; j++) { int actual = m.ReadInt(); int expected = _inCnt++; Assert.Equal(expected, actual); context.FireChannelRead(actual); } m.Release(); }
/// <param name="ctx"></param> /// <param name="msg"></param> public override void ChannelRead(IChannelHandlerContext ctx, object msg) { var release = true; try { if (msg is T msg1) { ChannelRead0(ctx, msg1); } else { release = false; ctx.FireChannelRead(msg); } } catch (Exception e) { Logger.Error(e, e.Message); } finally { if (_autoRelease && release) { ReferenceCountUtil.Release(msg); } } }
public override void ChannelRead(IChannelHandlerContext context, object msg) { bool release = true; try { if (msg is IPacket packet) { _messageRouter.Route(new RequestContext() { Request = packet }); } else { release = false; context.FireChannelRead(msg); } } finally { if (_autoRelease && release) { ReferenceCountUtil.Release(msg); } } }
/// <inheritdoc /> public override void ChannelRead(IChannelHandlerContext context, object message) { var buffer = message as IByteBuffer; if (buffer == null) { return; } var b = buffer.GetByte(buffer.ReaderIndex); switch (b) { case SocksProtocolVersion.Socks4A: context.Channel.Pipeline.Replace(this, nameof(Socks4ServerHandler), new Socks4ServerHandler()); break; case SocksProtocolVersion.Socks5: context.Channel.Pipeline.Replace(this, nameof(Socks5ServerHandler), new Socks5ServerHandler()); break; default: Logger.LogError("Unknow socks verion protocol."); break; } context.FireChannelRead(message); }
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output) { if (input is EmptyByteBuffer) { return; } if (input.GetLongLE(0) != 0) { context.FireChannelRead(input.Retain()); return; } input.SkipBytes(8); var messageId = input.ReadLongLE(); input.SkipBytes(4); var message = Serializer.Deserialize(input); Log.Debug($"#{ClientSettings.ClientSession.SessionId}: Recieve the message {message} with id: {messageId}"); output.Add(message); }
public override void ChannelRead(IChannelHandlerContext ctx, object msg) { bool release = true; try { if (this.AcceptInboundMessage(msg)) { I imsg = (I)msg; this.ChannelRead0(ctx, imsg); } else { release = false; ctx.FireChannelRead(msg); } } finally { if (autoRelease && release) { ReferenceCountUtil.Release(msg); } } }
public override void ChannelRead(IChannelHandlerContext context, object message) { SafeProcess(() => { var msg = (Message)message; if (msg.Type == MessageType.LoginResponse) { DisposeCancellation(); _heartBeatCancellation = new CancellationTokenSource(); //得到登录响应后,开始心跳 context.Executor.ScheduleAsync(RunHeartBeat, context, _delay, _heartBeatCancellation.Token); } else if (msg.Type == MessageType.HeartBeatResponse) { //得到回复后继续心跳 context.Executor.ScheduleAsync(RunHeartBeat, context, _delay, _heartBeatCancellation.Token); ClientEvents.AsyncRaiseHeartBeatReceived(this.Client, this.Client.ServerEndPoint); } else { context.FireChannelRead(message); } }, context); }
public override void ChannelRead(IChannelHandlerContext context, object message) { var buffer = (IByteBuffer)message; try { byte[] data = new byte[buffer.ReadableBytes]; buffer.GetBytes(buffer.ReaderIndex, data); _logger.Debug($"received msg is: {Encoding.UTF8.GetString(data)}"); var convertedMsg = JimuHelper.Deserialize <byte[], JimuTransportMsg>(data); if (convertedMsg.ContentType == typeof(JimuRemoteCallData).FullName) { convertedMsg.Content = JimuHelper.Deserialize <string, JimuRemoteCallData>(convertedMsg.Content.ToString()); } else if (convertedMsg.ContentType == typeof(JimuRemoteCallData).FullName) { convertedMsg.Content = JimuHelper.Deserialize <string, JimuRemoteCallResultData>(convertedMsg.Content.ToString()); } context.FireChannelRead(convertedMsg); } finally { buffer.Release(); } //base.ChannelRead(context, message); }
protected async void Decode(IChannelHandlerContext context, IByteBuffer message) { var buffer = message; while (buffer != null && buffer.ReadableBytes >= 4) { if (_readLength) { var endianBuffer = buffer.WithOrder(ByteOrder.BigEndian); _packetLength = endianBuffer.ReadInt(); _readLength = false; } if (buffer.ReadableBytes >= _packetLength) { var packet = buffer.ReadBytes(_packetLength).ToArray(); try { packet = Ionic.Zlib.ZlibStream.UncompressBuffer(packet); var json = Encoding.UTF8.GetString(packet); var data = JsonConvert.DeserializeObject(json); foreach (var node in (JObject)data) { Type contentType; var converted = await _packetsConverter.ConvertAsync(node.Key, node.Value, out contentType); if (contentType != null) { context.FireChannelRead(new Packet { Bytes = packet, CommandKey = node.Key, Content = converted, Data = data, ContentType = contentType }); } else { #pragma warning disable 4014 context.WriteAndFlushAsync(new { error = new { message = $"command not found: \"{node.Key}\"" } }); } } _readLength = true; } catch (Exception exception) { _logger.Error(exception); context.CloseAsync(); } } break; #pragma warning restore 4014 } }
public override void ChannelRead(IChannelHandlerContext context, object message) { var buffer = (IByteBuffer)message; try { byte[] data = new byte[buffer.ReadableBytes]; buffer.GetBytes(buffer.ReaderIndex, data); if (data.Length < 102400) { _logger.Debug($"recevied msg is: {Encoding.UTF8.GetString(data)}"); } else { _logger.Debug($"recevied msg is (bigger than 100k, we don't show it)"); } var convertedMsg = JimuHelper.Deserialize <byte[], JimuTransportMsg>(data); context.FireChannelRead(convertedMsg); //context.FireChannelRead(data); } catch (Exception ex) { _logger.Debug($"Deserialize msg failure"); context.WriteAndFlushAsync(Encoding.UTF8.GetBytes($"failure, {ex.ToStackTraceString()}")); } finally { buffer.Release(); } //base.ChannelRead(context, message); }
/// <inheritdoc/> public override void ChannelRead(IChannelHandlerContext ctx, object msg) { if (!(msg is IFullHttpResponse response)) { _ = ctx.FireChannelRead(msg); return; } try { if (!_handshaker.IsHandshakeComplete) { _handshaker.FinishHandshake(ctx.Channel, response); _ = _handshakePromise.TryComplete(); _ = ctx.FireUserEventTriggered(WebSocketClientProtocolHandler.ClientHandshakeStateEvent.HandshakeComplete); _ = ctx.Pipeline.Remove(this); return; } ThrowHelper.ThrowInvalidOperationException_WebSocketClientHandshaker(); } finally { _ = response.Release(); } }
public override void ChannelRead(IChannelHandlerContext context, object message) { var buffer = (IByteBuffer)message; var data = buffer.ToArray(); var transportMessage = _serializer.Deserialize<byte[], TransportMessage>(data); context.FireChannelRead(transportMessage); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="message"></param> public override void ChannelRead(IChannelHandlerContext context, object message) { var msg = (Message)message; RequestManager requestManager = null; if (serviceResponseHandler != null) { var channelName = context.GetChannelName(); requestManager = serviceResponseHandler(channelName); } //如果是服务响应消息,处理,其它消息透传 if (msg.Header != null && msg.Header.Type == MessageType.SERVICE_RESP) { logger.LogDebug($"Get request result. Local={context.GetLocalNetString()}, Remote={context.GetRemoteNetString()}"); if (requestManager != null) { requestManager.CompleteRequest(msg.Header.RequestId, msg); } } else { context.FireChannelRead(message); } }
/// <summary> /// Any broadcast message which is handled by this handler has already been signature checked. /// The <see cref="BroadcastHandler"/> will get the original inner message and pass it onto the handler /// in-charge of executing the RX handlers. /// </summary> /// <param name="ctx">The Channel handler context.</param> /// <param name="msg">The gossip message.</param> protected override void ChannelRead0(IChannelHandlerContext ctx, ProtocolMessage msg) { if (msg.IsBroadCastMessage()) { Logger.Verbose("Broadcast message {msg} received.", msg); var innerGossipMessageSigned = ProtocolMessage.Parser.ParseFrom(msg.Value); _broadcastManager.ReceiveAsync(innerGossipMessageSigned) .ConfigureAwait(false).GetAwaiter().GetResult(); ctx.FireChannelRead(innerGossipMessageSigned); return; } Logger.Verbose("Message {msg} was not a broadcast message.", msg); ctx.FireChannelRead(msg); }
public override void ChannelRead(IChannelHandlerContext ctx, object msg) { if (!(msg is IFullHttpResponse)) { ctx.FireChannelRead(msg); return; } var response = (IFullHttpResponse)msg; try { if (!this.handshaker.IsHandshakeComplete) { this.handshaker.FinishHandshake(ctx.Channel, response); ctx.FireUserEventTriggered(WebSocketClientProtocolHandler.ClientHandshakeStateEvent.HandshakeComplete); ctx.Channel.Pipeline.Remove(this); return; } throw new InvalidOperationException("WebSocketClientHandshaker should have been non finished yet"); } finally { response.Release(); } }
protected static void FireChannelRead(IChannelHandlerContext ctx, List <object> output, int numElements) { for (int i = 0; i < numElements; i++) { _ = ctx.FireChannelRead(output[i]); } }
/** * Dequeues one or many (or none) messages depending on the channel's auto * reading state and returns the number of messages that were consumed from * the internal queue. * * The {@code minConsume} argument is used to force {@code dequeue()} into * consuming that number of messages regardless of the channel's auto * reading configuration. * * @see #read(ChannelHandlerContext) * @see #channelRead(ChannelHandlerContext, Object) */ int Dequeue(IChannelHandlerContext ctx, int minConsume) { if (this.queue != null) { int consumed = 0; while ((consumed < minConsume || this.config.AutoRead) && this.queue.TryDequeue(out object msg)) { ++consumed; ctx.FireChannelRead(msg); } // We're firing a completion event every time one (or more) // messages were consumed and the queue ended up being drained // to an empty state. if (this.queue.IsEmpty && consumed > 0) { ctx.FireChannelReadComplete(); } return(consumed); } return(0); }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (_finished) { // Received a message after the connection has been established; pass through. _suppressChannelReadComplete = false; _ctx.FireChannelRead(message); } else { _suppressChannelReadComplete = true; Exception cause = null; try { var done = HandleResponse(_ctx, message); if (done) { SetConnectSuccess(); } } catch (Exception t) { cause = t; } finally { ReferenceCountUtil.Release(message); if (cause != null) { SetConnectFailure(cause); } } } }
public void RmiMessage(IChannelHandlerContext context, RmiMessage message, RecvContext recvContext) { var buffer = Unpooled.WrappedBuffer(message.Data); recvContext.Message = buffer; context.FireChannelRead(recvContext); }
/// <inheritdoc /> public override void HandlerRemoved(IChannelHandlerContext context) { if (_decodeState == STATE_CALLING_CHILD_DECODE) { _decodeState = STATE_HANDLER_REMOVED_PENDING; return; } IByteBuffer buf = _cumulation; if (buf is object) { // Directly set this to null so we are sure we not access it in any other method here anymore. _cumulation = null; _numReads = 0; int readable = buf.ReadableBytes; if (readable > 0) { _ = context.FireChannelRead(buf); _ = context.FireChannelReadComplete(); } else { _ = buf.Release(); } } HandlerRemovedInternal(context); }
public override void ChannelRead(IChannelHandlerContext context, object msg) { if (finished) { // Received a message after the connection has been established; pass through. suppressChannelReadComplete = false; context.FireChannelRead(msg); } else { suppressChannelReadComplete = true; Exception cause = null; try { bool done = handleResponse(context, msg); if (done) { setConnectSuccess(context); } } catch (Exception t) { cause = t; } finally { ReferenceCountUtil.Release(msg); if (cause != null) { ctx_c = context; ConnectFailure = cause; } } } }
private static void FireChannelRead(IChannelHandlerContext context, List <object> msgs, int numElements) { for (var i = 0; i < numElements; i++) { context.FireChannelRead(msgs[i]); } }
/** * Dequeues one or many (or none) messages depending on the channel's auto * reading state and returns the number of messages that were consumed from * the internal queue. * * The {@code minConsume} argument is used to force {@code dequeue()} into * consuming that number of messages regardless of the channel's auto * reading configuration. * * @see #read(ChannelHandlerContext) * @see #channelRead(ChannelHandlerContext, Object) */ private int Dequeue(IChannelHandlerContext ctx, int minConsume) { int consumed = 0; // fireChannelRead(...) may call ctx.read() and so this method may reentrance. Because of this we need to // check if queue was set to null in the meantime and if so break the loop. while (_queue is object && (consumed < minConsume || _config.IsAutoRead)) { if (!_queue.TryDequeue(out object msg) || msg is null) { break; } ++consumed; _ = ctx.FireChannelRead(msg); } // We're firing a completion event every time one (or more) // messages were consumed and the queue ended up being drained // to an empty state. if (_queue is object && _queue.IsEmpty) { _queue.Recycle(); _queue = null; if (consumed > 0) { _ = ctx.FireChannelReadComplete(); } } return(consumed); }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (++_actualReads == _expectedReads) { _signal.Signal(); } context.FireChannelRead(message); }
public override void ChannelRead(IChannelHandlerContext context, object message) { var packet = message as PublishPacket; if (packet != null) { IByteBuffer result = ApplyCompression(packet.Payload, CompressionMode.Decompress); packet.Payload = result; } context.FireChannelRead(message); }
public override void HandlerRemoved(IChannelHandlerContext context) { var buf = InternalBuffer; var readable = buf.ReadableBytes; if (readable > 0) { var bytes = buf.ReadBytes(readable); buf.Release(); context.FireChannelRead(bytes); } else { buf.Release(); } _cumulation = null; _numReads = 0; context.FireChannelReadComplete(); HandlerRemovedInternal(context); }
public override void ChannelInactive(IChannelHandlerContext ctx) { ThreadLocalObjectList output = ThreadLocalObjectList.Take(); try { if (this.cumulation != null) { this.CallDecode(ctx, this.cumulation, output); this.DecodeLast(ctx, this.cumulation, output); } else { this.DecodeLast(ctx, Unpooled.Empty, output); } } catch (DecoderException e) { throw e; } catch (Exception e) { throw new DecoderException(e); } finally { try { if (this.cumulation != null) { this.cumulation.Release(); this.cumulation = null; } int size = output.Count; for (int i = 0; i < size; i++) { ctx.FireChannelRead(output[i]); } if (size > 0) { // Something was read, call fireChannelReadComplete() ctx.FireChannelReadComplete(); } ctx.FireChannelInactive(); } finally { // recycle in all cases output.Return(); } } }
public virtual void ChannelRead(IChannelHandlerContext context, object message) => context.FireChannelRead(message);
public override void HandlerRemoved(IChannelHandlerContext context) { IByteBuffer buf = this.InternalBuffer; int readable = buf.ReadableBytes; if (readable > 0) { IByteBuffer bytes = buf.ReadBytes(readable); buf.Release(); context.FireChannelRead(bytes); } else { buf.Release(); } this.cumulation = null; context.FireChannelReadComplete(); this.HandlerRemovedInternal(context); }
public override void ChannelRead(IChannelHandlerContext context, object message) { var data = message as IByteBuffer; if (data != null) { ThreadLocalObjectList output = ThreadLocalObjectList.Take(); try { this.first = this.cumulation == null; if (this.first) { this.cumulation = data; } else { this.cumulation = this.cumulator(context.Allocator, this.cumulation, data); } this.CallDecode(context, this.cumulation, output); } catch (DecoderException) { throw; } catch (Exception ex) { throw new DecoderException(ex); } finally { if (this.cumulation != null && !this.cumulation.IsReadable()) { this.cumulation.Release(); this.cumulation = null; } int size = output.Count; this.decodeWasNull = size == 0; for (int i = 0; i < size; i++) { context.FireChannelRead(output[i]); } output.Return(); } } else { context.FireChannelRead(message); } }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (message == _upgradeMessage) { context.Pipeline.Remove(_decoder); return; } context.FireChannelRead(message); }
private static void FireChannelRead(IChannelHandlerContext context, List<object> msgs, int numElements) { for (var i = 0; i < numElements; i++) context.FireChannelRead(msgs[i]); }
public override void ChannelRead(IChannelHandlerContext context, object message) { context.FireChannelRead(first); context.FireChannelRead(second); }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (this.readerIdleTime.Ticks > 0 || this.allIdleTime.Ticks > 0) { this.reading = true; this.firstReaderIdleEvent = this.firstAllIdleEvent = true; } context.FireChannelRead(message); }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (++_actualReadCount == _expectedReadCount) _resetEvent.Set(); context.FireChannelRead(message); }
public override void ChannelRead(IChannelHandlerContext context, object message) { this.reading = true; context.FireChannelRead(message); }
public override void ChannelRead(IChannelHandlerContext context, object message) { this.throughput.Increment(); context.FireChannelRead(message); }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (message is IByteBuf) { var output = RecyclableArrayList.Take(); try { var data = (IByteBuf) message; _first = _cumulation == null; if (_first) { _cumulation = data; } else { _cumulation = _cumulator(context.Allocator, _cumulation, data); } CallDecode(context, _cumulation, output); } catch (DecoderException) { throw; } catch (Exception ex) { throw new DecoderException(ex); } finally { if (_cumulation != null && !_cumulation.IsReadable()) { _numReads = 0; _cumulation.Release(); _cumulation = null; } else if (++_numReads >= _discardAfterReads) { _numReads = 0; DiscardSomeReadBytes(); } var size = output.Count; _decodeWasNull = size == 0; FireChannelRead(context, output, size); output.Return(); } } else { // not a byte buffer? then we can't handle it. Forward it along context.FireChannelRead(message); } }
public override void ChannelRead(IChannelHandlerContext ctx, object message) { if (this.Logger.IsEnabled(this.InternalLevel)) { this.Logger.Log(this.InternalLevel, this.Format(ctx, "RECEIVED", message)); } ctx.FireChannelRead(message); }
public override void ChannelRead(IChannelHandlerContext context, object message) { if (message is IByteBuf) { ReadInstruction mode; var buf = (IByteBuf) message; mode = _instructions.Any() && buf.ReadableBytes > 4 ? _instructions.Dequeue() : ReadInstruction.Full; if (mode.Mode == ReadMode.Full) { var writeBuf = context.Allocator.Buffer(_cumulativeBuffer.ReadableBytes + buf.ReadableBytes) .WriteBytes(_cumulativeBuffer) .WriteBytes(buf); Assert.Equal(0, _cumulativeBuffer.ReadableBytes); // verify that we've fully drained the cumulative buffer _cumulativeBuffer.DiscardReadBytes(); context.FireChannelRead(writeBuf); } else { var originalBytes = buf.ReadableBytes; var partialReadBytes = mode.ReadBytes; var writeBuf = context.Allocator.Buffer(_cumulativeBuffer.ReadableBytes + partialReadBytes) .WriteBytes(_cumulativeBuffer) .WriteBytes(buf, partialReadBytes); Assert.Equal(0, _cumulativeBuffer.ReadableBytes); // verify that we've fully drained the cumulative buffer _cumulativeBuffer.DiscardReadBytes(); // store the rest partial read into the cumulative buffer _cumulativeBuffer.WriteBytes(buf, partialReadBytes, buf.ReadableBytes); Assert.Equal(partialReadBytes + _cumulativeBuffer.ReadableBytes, originalBytes); context.FireChannelRead(writeBuf); } } else { // move onto the next handler if this message is not an IByteBuf context.FireChannelRead(message); } }
public override void UserEventTriggered(IChannelHandlerContext context, object evt) { if (evt is FinishPartialReads) { if (_cumulativeBuffer.IsReadable()) { var writeBuf = context.Allocator.Buffer(_cumulativeBuffer.ReadableBytes) .WriteBytes(_cumulativeBuffer); context.FireChannelRead(writeBuf); } } }