Examples with SimpleChannelPromiseAggregator io.netty.handler.codec.http2.Http2CodecUtil.SimpleChannelPromiseAggregator used on opensource projects

Example 6 with SimpleChannelPromiseAggregator

use of io.netty.handler.codec.http2.Http2CodecUtil.SimpleChannelPromiseAggregator in project netty by netty.

the class DefaultHttp2ConnectionEncoder method writeSettingsAck.

@Override
public ChannelFuture writeSettingsAck(ChannelHandlerContext ctx, ChannelPromise promise) {
    if (outstandingRemoteSettingsQueue == null) {
        return frameWriter.writeSettingsAck(ctx, promise);
    }
    Http2Settings settings = outstandingRemoteSettingsQueue.poll();
    if (settings == null) {
        return promise.setFailure(new Http2Exception(INTERNAL_ERROR, "attempted to write a SETTINGS ACK with no " + " pending SETTINGS"));
    }
    SimpleChannelPromiseAggregator aggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    // Acknowledge receipt of the settings. We should do this before we process the settings to ensure our
    // remote peer applies these settings before any subsequent frames that we may send which depend upon
    // these new settings. See https://github.com/netty/netty/issues/6520.
    frameWriter.writeSettingsAck(ctx, aggregator.newPromise());
    // We create a "new promise" to make sure that status from both the write and the application are taken into
    // account independently.
    ChannelPromise applySettingsPromise = aggregator.newPromise();
    try {
        remoteSettings(settings);
        applySettingsPromise.setSuccess();
    } catch (Throwable e) {
        applySettingsPromise.setFailure(e);
        lifecycleManager.onError(ctx, true, e);
    }
    return aggregator.doneAllocatingPromises();
}

Example 7 with SimpleChannelPromiseAggregator

use of io.netty.handler.codec.http2.Http2CodecUtil.SimpleChannelPromiseAggregator in project netty by netty.

the class DefaultHttp2FrameWriter method writeFrame.

@Override
public ChannelFuture writeFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, ByteBuf payload, ChannelPromise promise) {
    SimpleChannelPromiseAggregator promiseAggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    try {
        verifyStreamOrConnectionId(streamId, STREAM_ID);
        ByteBuf buf = ctx.alloc().buffer(FRAME_HEADER_LENGTH);
        // Assume nothing below will throw until buf is written. That way we don't have to take care of ownership
        // in the catch block.
        writeFrameHeaderInternal(buf, payload.readableBytes(), frameType, flags, streamId);
        ctx.write(buf, promiseAggregator.newPromise());
    } catch (Throwable t) {
        try {
            payload.release();
        } finally {
            promiseAggregator.setFailure(t);
            promiseAggregator.doneAllocatingPromises();
        }
        return promiseAggregator;
    }
    try {
        ctx.write(payload, promiseAggregator.newPromise());
    } catch (Throwable t) {
        promiseAggregator.setFailure(t);
    }
    return promiseAggregator.doneAllocatingPromises();
}

Example 8 with SimpleChannelPromiseAggregator

use of io.netty.handler.codec.http2.Http2CodecUtil.SimpleChannelPromiseAggregator in project netty by netty.

the class DefaultHttp2FrameWriter method writeGoAway.

@Override
public ChannelFuture writeGoAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode, ByteBuf debugData, ChannelPromise promise) {
    SimpleChannelPromiseAggregator promiseAggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    try {
        verifyStreamOrConnectionId(lastStreamId, "Last Stream ID");
        verifyErrorCode(errorCode);
        int payloadLength = 8 + debugData.readableBytes();
        ByteBuf buf = ctx.alloc().buffer(GO_AWAY_FRAME_HEADER_LENGTH);
        // Assume nothing below will throw until buf is written. That way we don't have to take care of ownership
        // in the catch block.
        writeFrameHeaderInternal(buf, payloadLength, GO_AWAY, new Http2Flags(), 0);
        buf.writeInt(lastStreamId);
        buf.writeInt((int) errorCode);
        ctx.write(buf, promiseAggregator.newPromise());
    } catch (Throwable t) {
        try {
            debugData.release();
        } finally {
            promiseAggregator.setFailure(t);
            promiseAggregator.doneAllocatingPromises();
        }
        return promiseAggregator;
    }
    try {
        ctx.write(debugData, promiseAggregator.newPromise());
    } catch (Throwable t) {
        promiseAggregator.setFailure(t);
    }
    return promiseAggregator.doneAllocatingPromises();
}

Example 9 with SimpleChannelPromiseAggregator

use of io.netty.handler.codec.http2.Http2CodecUtil.SimpleChannelPromiseAggregator in project netty by netty.

the class HttpToHttp2ConnectionHandler method write.

/**
 * Handles conversion of {@link HttpMessage} and {@link HttpContent} to HTTP/2 frames.
 */
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
    if (!(msg instanceof HttpMessage || msg instanceof HttpContent)) {
        ctx.write(msg, promise);
        return;
    }
    boolean release = true;
    SimpleChannelPromiseAggregator promiseAggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    try {
        Http2ConnectionEncoder encoder = encoder();
        boolean endStream = false;
        if (msg instanceof HttpMessage) {
            final HttpMessage httpMsg = (HttpMessage) msg;
            // Provide the user the opportunity to specify the streamId
            currentStreamId = getStreamId(httpMsg.headers());
            // Add HttpScheme if it's defined in constructor and header does not contain it.
            if (httpScheme != null && !httpMsg.headers().contains(HttpConversionUtil.ExtensionHeaderNames.SCHEME.text())) {
                httpMsg.headers().set(HttpConversionUtil.ExtensionHeaderNames.SCHEME.text(), httpScheme.name());
            }
            // Convert and write the headers.
            Http2Headers http2Headers = HttpConversionUtil.toHttp2Headers(httpMsg, validateHeaders);
            endStream = msg instanceof FullHttpMessage && !((FullHttpMessage) msg).content().isReadable();
            writeHeaders(ctx, encoder, currentStreamId, httpMsg.headers(), http2Headers, endStream, promiseAggregator);
        }
        if (!endStream && msg instanceof HttpContent) {
            boolean isLastContent = false;
            HttpHeaders trailers = EmptyHttpHeaders.INSTANCE;
            Http2Headers http2Trailers = EmptyHttp2Headers.INSTANCE;
            if (msg instanceof LastHttpContent) {
                isLastContent = true;
                // Convert any trailing headers.
                final LastHttpContent lastContent = (LastHttpContent) msg;
                trailers = lastContent.trailingHeaders();
                http2Trailers = HttpConversionUtil.toHttp2Headers(trailers, validateHeaders);
            }
            // Write the data
            final ByteBuf content = ((HttpContent) msg).content();
            endStream = isLastContent && trailers.isEmpty();
            encoder.writeData(ctx, currentStreamId, content, 0, endStream, promiseAggregator.newPromise());
            release = false;
            if (!trailers.isEmpty()) {
                // Write trailing headers.
                writeHeaders(ctx, encoder, currentStreamId, trailers, http2Trailers, true, promiseAggregator);
            }
        }
    } catch (Throwable t) {
        onError(ctx, true, t);
        promiseAggregator.setFailure(t);
    } finally {
        if (release) {
            ReferenceCountUtil.release(msg);
        }
        promiseAggregator.doneAllocatingPromises();
    }
}