write() — netty Function Reference

Architecture documentation for the write() function in AbstractHttp2StreamChannel.java from the netty codebase.

Function java Buffer Allocators calls 3 called by 3

Entity Profile

Buffer→ Allocators→ write() — netty Function Reference

Dependency Diagram

graph TD
  5ca6305e_9bed_80cc_f434_630ca5d3db99["write()"]
  2656dcfe_5cdb_7c7d_bc25_312393fe2e05["Http2ChannelUnsafe"]
  5ca6305e_9bed_80cc_f434_630ca5d3db99 -->|defined in| 2656dcfe_5cdb_7c7d_bc25_312393fe2e05
  d1852798_fa63_e599_ba38_fd438d68223e["ChannelFuture()"]
  d1852798_fa63_e599_ba38_fd438d68223e -->|calls| 5ca6305e_9bed_80cc_f434_630ca5d3db99
  215b8316_feb5_500b_88f8_49eff0eac336["close()"]
  215b8316_feb5_500b_88f8_49eff0eac336 -->|calls| 5ca6305e_9bed_80cc_f434_630ca5d3db99
  17bb5ba9_6675_72af_80ec_e5f5d89f1f8c["flush()"]
  17bb5ba9_6675_72af_80ec_e5f5d89f1f8c -->|calls| 5ca6305e_9bed_80cc_f434_630ca5d3db99
  6defa2f0_deaf_b8bb_9379_f478807d197e["isActive()"]
  5ca6305e_9bed_80cc_f434_630ca5d3db99 -->|calls| 6defa2f0_deaf_b8bb_9379_f478807d197e
  32a7a18d_d75e_ca41_7a57_2a5032b066d3["writeComplete()"]
  5ca6305e_9bed_80cc_f434_630ca5d3db99 -->|calls| 32a7a18d_d75e_ca41_7a57_2a5032b066d3
  6ba5f11e_f430_02ca_f64c_f9a7338904bf["writeHttp2StreamFrame()"]
  5ca6305e_9bed_80cc_f434_630ca5d3db99 -->|calls| 6ba5f11e_f430_02ca_f64c_f9a7338904bf
  style 5ca6305e_9bed_80cc_f434_630ca5d3db99 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

codec-http2/src/main/java/io/netty/handler/codec/http2/AbstractHttp2StreamChannel.java lines 1002–1062

        @Override
        public void write(Object msg, final ChannelPromise promise) {
            // After this point its not possible to cancel a write anymore.
            if (!promise.setUncancellable()) {
                ReferenceCountUtil.release(msg);
                return;
            }

            if (!isActive() ||
                    // Once the outbound side was closed we should not allow header / data frames
                    outboundClosed && (msg instanceof Http2HeadersFrame || msg instanceof Http2DataFrame)) {
                ReferenceCountUtil.release(msg);
                promise.setFailure(new ClosedChannelException());
                return;
            }

            try {
                if (msg instanceof Http2StreamFrame) {
                    Http2StreamFrame frame = validateStreamFrame((Http2StreamFrame) msg).stream(stream());
                    if (msg instanceof Http2WindowUpdateFrame) {
                        Http2WindowUpdateFrame updateFrame = (Http2WindowUpdateFrame) msg;
                        if (config.autoStreamFlowControl) {
                            ReferenceCountUtil.release(msg);
                            promise.setFailure(new UnsupportedOperationException(
                                    Http2StreamChannelOption.AUTO_STREAM_FLOW_CONTROL + " is set to false"));
                            return;
                        }
                        try {
                            ObjectUtil.checkInRange(updateFrame.windowSizeIncrement(), 0,
                                    flowControlledBytes, "windowSizeIncrement");
                        } catch (RuntimeException e) {
                            ReferenceCountUtil.release(updateFrame);
                            promise.setFailure(e);
                            return;
                        }
                        flowControlledBytes -= updateFrame.windowSizeIncrement();
                        if (parentContext().isRemoved()) {
                            ReferenceCountUtil.release(msg);
                            promise.setFailure(new ClosedChannelException());
                            return;
                        }
                        ChannelFuture f = writeWindowUpdateFrame(updateFrame);
                        if (f.isDone()) {
                            writeComplete(f, promise);
                        } else {
                            f.addListener(future -> writeComplete(future, promise));
                        }
                    } else {
                        writeHttp2StreamFrame(frame, promise);
                    }
                } else {
                    String msgStr = msg.toString();
                    ReferenceCountUtil.release(msg);
                    promise.setFailure(new IllegalArgumentException(
                            "Message must be an " + StringUtil.simpleClassName(Http2StreamFrame.class) +
                                    ": " + msgStr));
                }
            } catch (Throwable t) {
                promise.tryFailure(t);
            }
        }