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

Example 1 with SimpleChannelPromiseAggregator

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

the class DefaultHttp2FrameWriter method writePing.

@Override
public ChannelFuture writePing(ChannelHandlerContext ctx, boolean ack, ByteBuf data, ChannelPromise promise) {
    boolean releaseData = true;
    SimpleChannelPromiseAggregator promiseAggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    try {
        verifyPingPayload(data);
        Http2Flags flags = ack ? new Http2Flags().ack(true) : new Http2Flags();
        ByteBuf buf = ctx.alloc().buffer(FRAME_HEADER_LENGTH);
        writeFrameHeaderInternal(buf, data.readableBytes(), PING, flags, 0);
        ctx.write(buf, promiseAggregator.newPromise());
        // Write the debug data.
        releaseData = false;
        ctx.write(data, promiseAggregator.newPromise());
    } catch (Throwable t) {
        if (releaseData) {
            data.release();
        }
        promiseAggregator.setFailure(t);
    }
    return promiseAggregator.doneAllocatingPromises();
}

Example 2 with SimpleChannelPromiseAggregator

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

the class DefaultHttp2FrameWriter method writeHeadersInternal.

private ChannelFuture writeHeadersInternal(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream, boolean hasPriority, int streamDependency, short weight, boolean exclusive, ChannelPromise promise) {
    ByteBuf headerBlock = null;
    SimpleChannelPromiseAggregator promiseAggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    try {
        verifyStreamId(streamId, STREAM_ID);
        if (hasPriority) {
            verifyStreamOrConnectionId(streamDependency, STREAM_DEPENDENCY);
            verifyPadding(padding);
            verifyWeight(weight);
        }
        // Encode the entire header block.
        headerBlock = ctx.alloc().buffer();
        headersEncoder.encodeHeaders(streamId, headers, headerBlock);
        Http2Flags flags = new Http2Flags().endOfStream(endStream).priorityPresent(hasPriority).paddingPresent(padding > 0);
        // Read the first fragment (possibly everything).
        int nonFragmentBytes = padding + flags.getNumPriorityBytes();
        int maxFragmentLength = maxFrameSize - nonFragmentBytes;
        ByteBuf fragment = headerBlock.readRetainedSlice(min(headerBlock.readableBytes(), maxFragmentLength));
        // Set the end of headers flag for the first frame.
        flags.endOfHeaders(!headerBlock.isReadable());
        int payloadLength = fragment.readableBytes() + nonFragmentBytes;
        ByteBuf buf = ctx.alloc().buffer(HEADERS_FRAME_HEADER_LENGTH);
        writeFrameHeaderInternal(buf, payloadLength, HEADERS, flags, streamId);
        writePaddingLength(buf, padding);
        if (hasPriority) {
            buf.writeInt(exclusive ? (int) (0x80000000L | streamDependency) : streamDependency);
            // Adjust the weight so that it fits into a single byte on the wire.
            buf.writeByte(weight - 1);
        }
        ctx.write(buf, promiseAggregator.newPromise());
        // Write the first fragment.
        ctx.write(fragment, promiseAggregator.newPromise());
        // Write out the padding, if any.
        if (paddingBytes(padding) > 0) {
            ctx.write(ZERO_BUFFER.slice(0, paddingBytes(padding)), promiseAggregator.newPromise());
        }
        if (!flags.endOfHeaders()) {
            writeContinuationFrames(ctx, streamId, headerBlock, promiseAggregator);
        }
    } catch (Http2Exception e) {
        promiseAggregator.setFailure(e);
    } catch (Throwable t) {
        promiseAggregator.setFailure(t);
        promiseAggregator.doneAllocatingPromises();
        PlatformDependent.throwException(t);
    } finally {
        if (headerBlock != null) {
            headerBlock.release();
        }
    }
    return promiseAggregator.doneAllocatingPromises();
}

Example 3 with SimpleChannelPromiseAggregator

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

the class DefaultHttp2FrameWriter method writePushPromise.

@Override
public ChannelFuture writePushPromise(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding, ChannelPromise promise) {
    ByteBuf headerBlock = null;
    SimpleChannelPromiseAggregator promiseAggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    try {
        verifyStreamId(streamId, STREAM_ID);
        verifyStreamId(promisedStreamId, "Promised Stream ID");
        verifyPadding(padding);
        // Encode the entire header block into an intermediate buffer.
        headerBlock = ctx.alloc().buffer();
        headersEncoder.encodeHeaders(streamId, headers, headerBlock);
        // Read the first fragment (possibly everything).
        Http2Flags flags = new Http2Flags().paddingPresent(padding > 0);
        // INT_FIELD_LENGTH is for the length of the promisedStreamId
        int nonFragmentLength = INT_FIELD_LENGTH + padding;
        int maxFragmentLength = maxFrameSize - nonFragmentLength;
        ByteBuf fragment = headerBlock.readRetainedSlice(min(headerBlock.readableBytes(), maxFragmentLength));
        flags.endOfHeaders(!headerBlock.isReadable());
        int payloadLength = fragment.readableBytes() + nonFragmentLength;
        ByteBuf buf = ctx.alloc().buffer(PUSH_PROMISE_FRAME_HEADER_LENGTH);
        writeFrameHeaderInternal(buf, payloadLength, PUSH_PROMISE, flags, streamId);
        writePaddingLength(buf, padding);
        // Write out the promised stream ID.
        buf.writeInt(promisedStreamId);
        ctx.write(buf, promiseAggregator.newPromise());
        // Write the first fragment.
        ctx.write(fragment, promiseAggregator.newPromise());
        // Write out the padding, if any.
        if (paddingBytes(padding) > 0) {
            ctx.write(ZERO_BUFFER.slice(0, paddingBytes(padding)), promiseAggregator.newPromise());
        }
        if (!flags.endOfHeaders()) {
            writeContinuationFrames(ctx, streamId, headerBlock, promiseAggregator);
        }
    } catch (Http2Exception e) {
        promiseAggregator.setFailure(e);
    } catch (Throwable t) {
        promiseAggregator.setFailure(t);
        promiseAggregator.doneAllocatingPromises();
        PlatformDependent.throwException(t);
    } finally {
        if (headerBlock != null) {
            headerBlock.release();
        }
    }
    return promiseAggregator.doneAllocatingPromises();
}

Example 4 with SimpleChannelPromiseAggregator

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

the class DefaultHttp2FrameWriter method writeData.

@Override
public ChannelFuture writeData(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding, boolean endStream, ChannelPromise promise) {
    final SimpleChannelPromiseAggregator promiseAggregator = new SimpleChannelPromiseAggregator(promise, ctx.channel(), ctx.executor());
    ByteBuf frameHeader = null;
    try {
        verifyStreamId(streamId, STREAM_ID);
        verifyPadding(padding);
        int remainingData = data.readableBytes();
        Http2Flags flags = new Http2Flags();
        flags.endOfStream(false);
        flags.paddingPresent(false);
        // Fast path to write frames of payload size maxFrameSize first.
        if (remainingData > maxFrameSize) {
            frameHeader = ctx.alloc().buffer(FRAME_HEADER_LENGTH);
            writeFrameHeaderInternal(frameHeader, maxFrameSize, DATA, flags, streamId);
            do {
                // Write the header.
                ctx.write(frameHeader.retainedSlice(), promiseAggregator.newPromise());
                // Write the payload.
                ctx.write(data.readRetainedSlice(maxFrameSize), promiseAggregator.newPromise());
                remainingData -= maxFrameSize;
            // Stop iterating if remainingData == maxFrameSize so we can take care of reference counts below.
            } while (remainingData > maxFrameSize);
        }
        if (padding == 0) {
            // Write the header.
            if (frameHeader != null) {
                frameHeader.release();
                frameHeader = null;
            }
            ByteBuf frameHeader2 = ctx.alloc().buffer(FRAME_HEADER_LENGTH);
            flags.endOfStream(endStream);
            writeFrameHeaderInternal(frameHeader2, remainingData, DATA, flags, streamId);
            ctx.write(frameHeader2, promiseAggregator.newPromise());
            // Write the payload.
            ByteBuf lastFrame = data.readSlice(remainingData);
            data = null;
            ctx.write(lastFrame, promiseAggregator.newPromise());
        } else {
            if (remainingData != maxFrameSize) {
                if (frameHeader != null) {
                    frameHeader.release();
                    frameHeader = null;
                }
            } else {
                remainingData -= maxFrameSize;
                // Write the header.
                ByteBuf lastFrame;
                if (frameHeader == null) {
                    lastFrame = ctx.alloc().buffer(FRAME_HEADER_LENGTH);
                    writeFrameHeaderInternal(lastFrame, maxFrameSize, DATA, flags, streamId);
                } else {
                    lastFrame = frameHeader.slice();
                    frameHeader = null;
                }
                ctx.write(lastFrame, promiseAggregator.newPromise());
                // Write the payload.
                lastFrame = data.readableBytes() != maxFrameSize ? data.readSlice(maxFrameSize) : data;
                data = null;
                ctx.write(lastFrame, promiseAggregator.newPromise());
            }
            do {
                int frameDataBytes = min(remainingData, maxFrameSize);
                int framePaddingBytes = min(padding, max(0, maxFrameSize - 1 - frameDataBytes));
                // Decrement the remaining counters.
                padding -= framePaddingBytes;
                remainingData -= frameDataBytes;
                // Write the header.
                ByteBuf frameHeader2 = ctx.alloc().buffer(DATA_FRAME_HEADER_LENGTH);
                flags.endOfStream(endStream && remainingData == 0 && padding == 0);
                flags.paddingPresent(framePaddingBytes > 0);
                writeFrameHeaderInternal(frameHeader2, framePaddingBytes + frameDataBytes, DATA, flags, streamId);
                writePaddingLength(frameHeader2, framePaddingBytes);
                ctx.write(frameHeader2, promiseAggregator.newPromise());
                // Write the payload.
                if (data != null) {
                    // Make sure Data is not null
                    if (remainingData == 0) {
                        ByteBuf lastFrame = data.readSlice(frameDataBytes);
                        data = null;
                        ctx.write(lastFrame, promiseAggregator.newPromise());
                    } else {
                        ctx.write(data.readRetainedSlice(frameDataBytes), promiseAggregator.newPromise());
                    }
                }
                // Write the frame padding.
                if (paddingBytes(framePaddingBytes) > 0) {
                    ctx.write(ZERO_BUFFER.slice(0, paddingBytes(framePaddingBytes)), promiseAggregator.newPromise());
                }
            } while (remainingData != 0 || padding != 0);
        }
    } catch (Throwable cause) {
        if (frameHeader != null) {
            frameHeader.release();
        }
        // necessary above because we internally allocate frameHeader.
        try {
            if (data != null) {
                data.release();
            }
        } finally {
            promiseAggregator.setFailure(cause);
            promiseAggregator.doneAllocatingPromises();
        }
        return promiseAggregator;
    }
    return promiseAggregator.doneAllocatingPromises();
}

Example 5 with SimpleChannelPromiseAggregator

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

the class Http2ConnectionHandlerTest method canSendGoAwayUsingVoidPromise.

@Test
public void canSendGoAwayUsingVoidPromise() throws Exception {
    handler = newHandler();
    ByteBuf data = dummyData();
    long errorCode = Http2Error.INTERNAL_ERROR.code();
    handler = newHandler();
    final Throwable cause = new RuntimeException("fake exception");
    doAnswer(new Answer<ChannelFuture>() {

        @Override
        public ChannelFuture answer(InvocationOnMock invocation) throws Throwable {
            ChannelPromise promise = invocation.getArgument(4);
            assertFalse(promise.isVoid());
            // This is what DefaultHttp2FrameWriter does... I hate mocking :-(.
            SimpleChannelPromiseAggregator aggregatedPromise = new SimpleChannelPromiseAggregator(promise, channel, ImmediateEventExecutor.INSTANCE);
            aggregatedPromise.newPromise();
            aggregatedPromise.doneAllocatingPromises();
            return aggregatedPromise.setFailure(cause);
        }
    }).when(frameWriter).writeGoAway(any(ChannelHandlerContext.class), anyInt(), anyLong(), any(ByteBuf.class), any(ChannelPromise.class));
    handler.goAway(ctx, STREAM_ID, errorCode, data, newVoidPromise(channel));
    verify(pipeline).fireExceptionCaught(cause);
}