private void customize(Http2Protocol protocol) { Compression compression = this.compression; protocol.setCompression("on"); protocol.setCompressionMinSize(getMinResponseSize(compression)); protocol.setCompressibleMimeType(getMimeTypes(compression)); if (this.compression.getExcludedUserAgents() != null) { protocol.setNoCompressionUserAgents(getExcludedUserAgents()); } }
private void customizeSsl(Connector connector) { new SslConnectorCustomizer(getSsl(), getSslStoreProvider()).customize(connector); if (getHttp2() != null && getHttp2().isEnabled()) { connector.addUpgradeProtocol(new Http2Protocol()); } }
@Override public void endRequestBodyFrame(int streamId) throws Http2Exception { Stream stream = getStream(streamId, true); stream.getInputBuffer().onDataAvailable(); }
@Override protected final void prepareResponse() throws IOException { response.setCommitted(true); if (handler.hasAsyncIO() && handler.getProtocol().getUseSendfile()) { prepareSendfile(); } prepareHeaders(request, response, sendfileData == null, handler.getProtocol(), stream); stream.writeHeaders(); }
private void processStreamOnContainerThread(Stream stream) { StreamProcessor streamProcessor = new StreamProcessor(this, stream, adapter, socketWrapper); streamProcessor.setSslSupport(sslSupport); processStreamOnContainerThread(streamProcessor, SocketEvent.OPEN_READ); }
@Override public ByteBuffer startRequestBodyFrame(int streamId, int payloadSize) throws Http2Exception { Stream stream = getStream(streamId, true); stream.checkState(FrameType.DATA); stream.receivedData(payloadSize); return stream.getInputByteBuffer(); }
@Override public void incrementWindowSize(int streamId, int increment) throws Http2Exception { if (streamId == 0) { incrementWindowSize(increment); } else { Stream stream = getStream(streamId, true); stream.checkState(FrameType.WINDOW_UPDATE); stream.incrementWindowSize(increment); } }
private void writeHuffmanEncodableValue(ByteBuffer target, String headerName, String val) { if (hpackHeaderFunction.shouldUseHuffman(headerName, val)) { if (!HPackHuffman.encode(target, val, false)) { writeValueString(target, val); } } else { writeValueString(target, val); } }
@Override protected final void setRequestBody(ByteChunk body) { stream.getInputBuffer().insertReplayedBody(body); try { stream.receivedEndOfStream(); } catch (ConnectionException e) { // Exception will not be thrown in this case } }
StreamProcessor(Http2UpgradeHandler handler, Stream stream, Adapter adapter, SocketWrapperBase<?> socketWrapper) { super(adapter, stream.getCoyoteRequest(), stream.getCoyoteResponse()); this.handler = handler; this.stream = stream; setSocketWrapper(socketWrapper); }
protected HpackEncoder getHpackEncoder() { if (hpackEncoder == null) { hpackEncoder = new HpackEncoder(); } // Ensure latest agreed table size is used hpackEncoder.setMaxTableSize(remoteSettings.getHeaderTableSize()); return hpackEncoder; }
@Override public void reset(int streamId, long errorCode) throws Http2Exception { Stream stream = getStream(streamId, true); stream.checkState(FrameType.RST); stream.receiveReset(errorCode); }
void writeHeaders(Stream stream, int pushedStreamId, MimeHeaders mimeHeaders, boolean endOfStream, int payloadSize) throws IOException { // This ensures the Stream processing thread has control of the socket. synchronized (socketWrapper) { doWriteHeaders(stream, pushedStreamId, mimeHeaders, endOfStream, payloadSize); } if (endOfStream) { stream.sentEndOfStream(); } }
@Override public HpackDecoder getHpackDecoder() { if (hpackDecoder == null) { hpackDecoder = new HpackDecoder(localSettings.getHeaderTableSize()); } return hpackDecoder; }
protected void readUnknownFrame(int streamId, FrameType frameType, int flags, int payloadSize, ByteBuffer buffer) throws IOException { try { swallow(streamId, payloadSize, false, buffer); } catch (ConnectionException e) { // Will never happen because swallow() is called with mustBeZero set // to false } output.swallowed(streamId, frameType, flags, payloadSize); }
@Override protected void processSocketEvent(SocketEvent event, boolean dispatch) { if (dispatch) { handler.processStreamOnContainerThread(this, event); } else { this.process(event); } }
@Override public final void end() throws IOException { closed = true; flush(true); writeTrailers(); }
private void closeIdleStreams(int newMaxActiveRemoteStreamId) throws Http2Exception { for (int i = maxActiveRemoteStreamId + 2; i < newMaxActiveRemoteStreamId; i += 2) { Stream stream = getStream(i, false); if (stream != null) { stream.closeIfIdle(); } } maxActiveRemoteStreamId = newMaxActiveRemoteStreamId; }
private void customizeSsl(Connector connector) { new SslConnectorCustomizer(getSsl(), getSslStoreProvider()).customize(connector); if (getHttp2() != null && getHttp2().isEnabled()) { connector.addUpgradeProtocol(new Http2Protocol()); } }
connector.addUpgradeProtocol(new Http2Protocol());