public override void channelRead(ChannelHandlerContext ctx, Object msg) { Channel child = (Channel)msg; child.pipeline().addLast(childHandler); childGroup.register(child); }
protected internal override void decode(ChannelHandlerContext ctx, ByteBuf @in, IList <object> @out) { if (@in.readableBytes() > 0) { throw new System.InvalidOperationException("Not expecting any data here"); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: protected void encode(io.netty.channel.ChannelHandlerContext ctx, org.neo4j.causalclustering.core.consensus.RaftMessages_ClusterIdAwareMessage msg, java.util.List<Object> out) throws Exception protected internal override void Encode(ChannelHandlerContext ctx, Org.Neo4j.causalclustering.core.consensus.RaftMessages_ClusterIdAwareMessage msg, IList <object> @out) { @out.Add(msg); Handler replicatedContentHandler = new Handler(this, @out, ctx.alloc()); msg.message().dispatch(replicatedContentHandler); }
/// <exception cref="System.Exception"/> public override void MessageReceived(ChannelHandlerContext ctx, MessageEvent e) { RpcInfo info = (RpcInfo)e.GetMessage(); RpcCall call = (RpcCall)info.Header(); EndPoint remoteAddress = info.RemoteAddress(); if (Log.IsTraceEnabled()) { Log.Trace(program + " procedure #" + call.GetProcedure()); } if (this.progNumber != call.GetProgram()) { Log.Warn("Invalid RPC call program " + call.GetProgram()); SendAcceptedReply(call, remoteAddress, RpcAcceptedReply.AcceptState.ProgUnavail, ctx); return; } int ver = call.GetVersion(); if (ver < lowProgVersion || ver > highProgVersion) { Log.Warn("Invalid RPC call version " + ver); SendAcceptedReply(call, remoteAddress, RpcAcceptedReply.AcceptState.ProgMismatch, ctx); return; } HandleInternal(ctx, info); }
/// <summary> /// .NET-specific decoding handler for incoming UDP messages. /// </summary> public override void Read(ChannelHandlerContext ctx, object msg) { var dgram = msg as DatagramPacket; if (dgram == null) { ctx.FireRead(msg); return; } var buf = dgram.Content; var sender = dgram.Sender; var recipient = dgram.Recipient; try { var decoder = new Decoder(_signatureFactory); bool finished = decoder.Decode(ctx, buf, recipient, sender); if (finished) { // prepare finish ctx.FireRead(decoder.PrepareFinish()); } else { Logger.Warn("Did not get the complete packet!"); } } catch (Exception ex) { Logger.Error("Error in UDP decoding.", ex); throw; } }
public override void ExceptionCaught(ChannelHandlerContext ctx, Exception cause) { if (_failed || IsShuttingDown(ctx)) { return; } _failed = true; // log only the first exception to not pollute the log try { // Netty throws a NativeIoException on connection reset - directly importing that class // caused a host of linking errors, because it depends on JNI to work. Hence, we just // test on the message we know we'll get. if (Exceptions.contains(cause, e => e.Message.contains("Connection reset by peer"))) { _log.warn("Fatal error occurred when handling a client connection, " + "remote peer unexpectedly closed connection: %s", ctx.channel()); } else { _log.error("Fatal error occurred when handling a client connection: " + ctx.channel(), cause); } } finally { ctx.close(); } }
public override void MessageReceived(ChannelHandlerContext ctx, MessageEvent e) { ChannelBuffer buf = (ChannelBuffer)e.GetMessage(); // Read reply if (!ValidMessageLength(buf.ReadableBytes())) { e.GetChannel().Close(); return; } // handling fragment header for TCP, 4 bytes. byte[] fragmentHeader = Arrays.CopyOfRange(buf.Array(), 0, 4); int fragmentSize = XDR.FragmentSize(fragmentHeader); bool isLast = XDR.IsLastFragment(fragmentHeader); System.Diagnostics.Debug.Assert((fragmentSize == 28 && isLast == true)); XDR xdr = new XDR(); xdr.WriteFixedOpaque(Arrays.CopyOfRange(buf.Array(), 4, buf.ReadableBytes())); RpcReply reply = RpcReply.Read(xdr); if (reply.GetState() == RpcReply.ReplyState.MsgAccepted) { RpcAcceptedReply acceptedReply = (RpcAcceptedReply)reply; Handle(acceptedReply, xdr); } else { RpcDeniedReply deniedReply = (RpcDeniedReply)reply; Handle(deniedReply); } e.GetChannel().Close(); }
protected internal override void Decode(ChannelHandlerContext ctx, object msg, IList <object> @out) { if (msg is ReplicatedContent) { _replicatedContents.AddLast(( ReplicatedContent )msg); } else if (msg is RaftLogEntryTermsDecoder.RaftLogEntryTerms) { foreach (long term in ((RaftLogEntryTermsDecoder.RaftLogEntryTerms)msg).Terms()) { _raftLogEntryTerms.AddLast(term); } } else if (msg is RaftMessageDecoder.ClusterIdAwareMessageComposer) { if (_messageComposer != null) { throw new System.InvalidOperationException("Received raft message header. Pipeline already contains message header waiting to build."); } _messageComposer = (RaftMessageDecoder.ClusterIdAwareMessageComposer)msg; } else { throw new System.InvalidOperationException("Unexpected object in the pipeline: " + msg); } if (_messageComposer != null) { Optional <Org.Neo4j.causalclustering.core.consensus.RaftMessages_ClusterIdAwareMessage> clusterIdAwareMessage = _messageComposer.maybeCompose(_clock, _raftLogEntryTerms, _replicatedContents); clusterIdAwareMessage.ifPresent(message => { Clear(message); @out.Add(message); }); } }
public override void channelRead(ChannelHandlerContext ctx, Object msg) { bool release = true; try { if (acceptInboundMessage(msg)) { I imsg = (I)msg; channelRead0(ctx, imsg); } else { release = false; ctx.fireChannelRead(msg); } } finally { if (autoRelease && release) { // ReferenceCountUtil.release(msg); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: protected void decode(io.netty.channel.ChannelHandlerContext ctx, io.netty.buffer.ByteBuf msg, java.util.List<Object> out) throws Exception protected internal override void Decode(ChannelHandlerContext ctx, ByteBuf msg, IList <object> @out) { long txId = msg.readLong(); StoreId storeId = StoreIdMarshal.INSTANCE.unmarshal(new NetworkReadableClosableChannelNetty4(msg)); @out.Add(new TxPullRequest(txId, storeId)); }
/// <exception cref="System.Exception"/> public override void ExceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) { Org.Jboss.Netty.Channel.Channel ch = e.GetChannel(); Exception cause = e.GetCause(); if (cause is TooLongFrameException) { this.SendError(ctx, HttpResponseStatus.BadRequest); return; } else { if (cause is IOException) { if (cause is ClosedChannelException) { ShuffleHandler.Log.Debug("Ignoring closed channel error", cause); return; } string message = cause.Message.ToString(); if (ShuffleHandler.IgnorableErrorMessage.Matcher(message).Matches()) { ShuffleHandler.Log.Debug("Ignoring client socket close", cause); return; } } } ShuffleHandler.Log.Error("Shuffle error: ", cause); if (ch.IsConnected()) { ShuffleHandler.Log.Error("Shuffle error " + e); this.SendError(ctx, HttpResponseStatus.InternalServerError); } }
/// <exception cref="System.Exception"/> public override void ExceptionCaught(ChannelHandlerContext ctx, Exception cause) { Exception e = cause is Exception ? (Exception)cause : new Exception(cause); string output = JsonUtil.ToJsonString(e); ByteBuf content = Unpooled.WrappedBuffer(Sharpen.Runtime.GetBytesForString(output , Charsets.Utf8)); DefaultFullHttpResponse resp = new DefaultFullHttpResponse(HttpVersion.Http11, HttpResponseStatus .InternalServerError, content); resp.Headers().Set(HttpHeaders.Names.ContentType, WebHdfsHandler.ApplicationJsonUtf8 ); if (e is ArgumentException) { resp.SetStatus(HttpResponseStatus.BadRequest); } else { if (e is FileNotFoundException) { resp.SetStatus(HttpResponseStatus.NotFound); } } resp.Headers().Set(HttpHeaders.Names.ContentLength, resp.Content().ReadableBytes( )); resp.Headers().Set(HttpHeaders.Names.Connection, HttpHeaders.Values.Close); ctx.Write(resp).AddListener(ChannelFutureListener.Close); }
/// <exception cref="System.Exception"/> public override void ChannelIdle(ChannelHandlerContext ctx, IdleStateEvent e) { if (e.GetState() == IdleState.AllIdle) { e.GetChannel().Close(); } }
protected internal override void Decode(ChannelHandlerContext ctx, ByteBuf @in, IList <object> @out) { // Will use the first five bytes to detect a protocol. if (@in.readableBytes() < 5) { return; } if (DetectSsl(@in)) { EnableSsl(ctx); } else if (IsHttp(@in)) { SwitchToWebsocket(ctx); } else if (IsBoltPreamble(@in)) { SwitchToSocket(ctx); } else { // TODO: send a alert_message for a ssl connection to terminate the handshake @in.clear(); ctx.close(); } }
private void SwitchToWebsocket(ChannelHandlerContext ctx) { ChannelPipeline p = ctx.pipeline(); p.addLast(new HttpServerCodec(), new HttpObjectAggregator(MAX_WEBSOCKET_HANDSHAKE_SIZE), new WebSocketServerProtocolHandler("/", null, false, MAX_WEBSOCKET_FRAME_SIZE), new WebSocketFrameAggregator(MAX_WEBSOCKET_FRAME_SIZE), new WebSocketFrameTranslator(), NewHandshaker()); p.remove(this); }
private void SwitchToSocket(ChannelHandlerContext ctx) { ChannelPipeline p = ctx.pipeline(); p.addLast(NewHandshaker()); p.remove(this); }
public override void channelInactive(ChannelHandlerContext ctx) { if (_outerInstance.closeHandler != null) { _outerInstance.closeHandler.run(); } ctx.fireChannelInactive(); }
public override void ChannelInactive(ChannelHandlerContext ctx) { if (proxiedChannel != null) { proxiedChannel.Close(); proxiedChannel = null; } }
protected internal override void Decode(ChannelHandlerContext ctx, ByteBuf msg, IList <object> @out) { int ordinal = msg.readInt(); long latestTxid = msg.readLong(); CatchupResult status = Enum.GetValues(typeof(CatchupResult))[ordinal]; @out.Add(new TxStreamFinishedResponse(status, latestTxid)); }
public RpcInfo(RpcMessage header, ChannelBuffer data, ChannelHandlerContext channelContext , Org.Jboss.Netty.Channel.Channel channel, EndPoint remoteAddress) { this.header = header; this.data = data; this.channel = channel; this.remoteAddress = remoteAddress; }
private void EnableSsl(ChannelHandlerContext ctx) { ChannelPipeline p = ctx.pipeline(); p.addLast(_sslCtx.newHandler(ctx.alloc())); p.addLast(new TransportSelectionHandler(_boltChannel, null, _encryptionRequired, true, _logging, _boltProtocolFactory)); p.remove(this); }
public override void ExceptionCaught(ChannelHandlerContext ctx, Exception cause) { ReleaseDfsResources(); DefaultHttpResponse resp = ExceptionHandler.ExceptionCaught(cause); resp.Headers().Set(HttpHeaders.Names.Connection, HttpHeaders.Values.Close); ctx.WriteAndFlush(response).AddListener(ChannelFutureListener.Close); }
public _ChannelFutureListener_115(SimpleHttpProxyHandler _enclosing, ChannelHandlerContext ctx, HttpRequest req, IO.Netty.Channel.Channel client) { this._enclosing = _enclosing; this.ctx = ctx; this.req = req; this.client = client; }
private static ChannelHandlerContext ChannelHandlerContextMock() { Channel channel = mock(typeof(Channel)); ChannelHandlerContext context = mock(typeof(ChannelHandlerContext)); when(context.channel()).thenReturn(channel); return(context); }
public override void channelActive(ChannelHandlerContext ctx) { // This method will be invoked only if this handler was added // before channelActive() event is fired. If a user adds this handler // after the channelActive() event, initialize() will be called by beforeAdd(). initialize(ctx); base.channelActive(ctx); }
public override void channelReadComplete(ChannelHandlerContext ctx) { if ((readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) && reading) { lastReadTime = ticksInNanos(); reading = false; } ctx.fireChannelReadComplete(); }
public override void channelRead(ChannelHandlerContext ctx, Object msg) { if (readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) { reading = true; firstReaderIdleEvent = firstAllIdleEvent = true; } ctx.fireChannelRead(msg); }
public override void channelRegistered(ChannelHandlerContext ctx) { // Initialize early if channel is active already. if (ctx.channel().isActive()) { initialize(ctx); } base.channelRegistered(ctx); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void writeComplete(org.jboss.netty.channel.ChannelHandlerContext ctx, org.jboss.netty.channel.WriteCompletionEvent e) throws Exception public override void WriteComplete(ChannelHandlerContext ctx, WriteCompletionEvent e) { if (LastException != null) { outerInstance.msgLog.Error("Recovered from:", LastException); LastException = null; } base.WriteComplete(ctx, e); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void channelDisconnected(org.jboss.netty.channel.ChannelHandlerContext ctx, org.jboss.netty.channel.ChannelStateEvent e) throws Exception public override void ChannelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) { base.ChannelDisconnected(ctx, e); if (!ctx.Channel.Connected) { TryToCloseChannel(ctx.Channel); } }
public virtual void Read(ChannelHandlerContext ctx, object msg) { // do nothing by default // can be overridden }
public virtual void UserEventTriggered(ChannelHandlerContext ctx, object evt) { // do nothing by default // can be overridden }