keycloakjar.org.apache.hc.core5.http.impl.nio.ClientHttp1StreamDuplexer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of camunda-platform-7-keycloak-all Show documentation
Show all versions of camunda-platform-7-keycloak-all Show documentation
Camunda 7 Keycloak Identity Provider Plugin including all transitive dependencies
/*
* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* {
private final HttpProcessor httpProcessor;
private final ConnectionReuseStrategy connectionReuseStrategy;
private final Http1Config http1Config;
private final Http1StreamListener streamListener;
private final Queue pipeline;
private final Http1StreamChannel outputChannel;
private volatile ClientHttp1StreamHandler outgoing;
private volatile ClientHttp1StreamHandler incoming;
public ClientHttp1StreamDuplexer(
final ProtocolIOSession ioSession,
final HttpProcessor httpProcessor,
final Http1Config http1Config,
final CharCodingConfig charCodingConfig,
final ConnectionReuseStrategy connectionReuseStrategy,
final NHttpMessageParser incomingMessageParser,
final NHttpMessageWriter outgoingMessageWriter,
final ContentLengthStrategy incomingContentStrategy,
final ContentLengthStrategy outgoingContentStrategy,
final Http1StreamListener streamListener) {
super(ioSession, http1Config, charCodingConfig, incomingMessageParser, outgoingMessageWriter,
incomingContentStrategy, outgoingContentStrategy);
this.httpProcessor = Args.notNull(httpProcessor, "HTTP processor");
this.http1Config = http1Config != null ? http1Config : Http1Config.DEFAULT;
this.connectionReuseStrategy = connectionReuseStrategy != null ? connectionReuseStrategy :
DefaultConnectionReuseStrategy.INSTANCE;
this.streamListener = streamListener;
this.pipeline = new ConcurrentLinkedQueue<>();
this.outputChannel = new Http1StreamChannel() {
@Override
public void close() {
shutdownSession(CloseMode.IMMEDIATE);
}
@Override
public void submit(
final HttpRequest request,
final boolean endStream,
final FlushMode flushMode) throws HttpException, IOException {
if (streamListener != null) {
streamListener.onRequestHead(ClientHttp1StreamDuplexer.this, request);
}
commitMessageHead(request, endStream, flushMode);
}
@Override
public void suspendOutput() throws IOException {
suspendSessionOutput();
}
@Override
public void requestOutput() {
requestSessionOutput();
}
@Override
public Timeout getSocketTimeout() {
return getSessionTimeout();
}
@Override
public void setSocketTimeout(final Timeout timeout) {
setSessionTimeout(timeout);
}
@Override
public int write(final ByteBuffer src) throws IOException {
return streamOutput(src);
}
@Override
public void complete(final List trailers) throws IOException {
endOutputStream(trailers);
}
@Override
public boolean isCompleted() {
return isOutputCompleted();
}
@Override
public boolean abortGracefully() throws IOException {
final MessageDelineation messageDelineation = endOutputStream(null);
return messageDelineation != MessageDelineation.MESSAGE_HEAD;
}
@Override
public void activate() throws HttpException, IOException {
}
};
}
@Override
void terminate(final Exception exception) {
if (incoming != null) {
incoming.failed(exception);
incoming.releaseResources();
incoming = null;
}
if (outgoing != null) {
outgoing.failed(exception);
outgoing.releaseResources();
outgoing = null;
}
for (;;) {
final ClientHttp1StreamHandler handler = pipeline.poll();
if (handler != null) {
handler.failed(exception);
handler.releaseResources();
} else {
break;
}
}
}
@Override
void disconnected() {
if (incoming != null) {
if (!incoming.isCompleted()) {
incoming.failed(new ConnectionClosedException());
}
incoming.releaseResources();
incoming = null;
}
if (outgoing != null) {
if (!outgoing.isCompleted()) {
outgoing.failed(new ConnectionClosedException());
}
outgoing.releaseResources();
outgoing = null;
}
for (;;) {
final ClientHttp1StreamHandler handler = pipeline.poll();
if (handler != null) {
handler.failed(new ConnectionClosedException());
handler.releaseResources();
} else {
break;
}
}
}
@Override
void updateInputMetrics(final HttpResponse response, final BasicHttpConnectionMetrics connMetrics) {
if (response.getCode() >= HttpStatus.SC_OK) {
connMetrics.incrementRequestCount();
}
}
@Override
void updateOutputMetrics(final HttpRequest request, final BasicHttpConnectionMetrics connMetrics) {
connMetrics.incrementRequestCount();
}
@Override
protected boolean handleIncomingMessage(final HttpResponse response) throws HttpException {
if (incoming == null) {
incoming = pipeline.poll();
}
if (incoming == null) {
throw new HttpException("Unexpected response");
}
return MessageSupport.canResponseHaveBody(incoming.getRequestMethod(), response);
}
@Override
protected ContentDecoder createContentDecoder(
final long len,
final ReadableByteChannel channel,
final SessionInputBuffer buffer,
final BasicHttpTransportMetrics metrics) throws HttpException {
if (len >= 0) {
return new LengthDelimitedDecoder(channel, buffer, metrics, len);
} else if (len == ContentLengthStrategy.CHUNKED) {
return new ChunkDecoder(channel, buffer, http1Config, metrics);
} else {
return new IdentityDecoder(channel, buffer, metrics);
}
}
@Override
protected boolean handleOutgoingMessage(final HttpRequest request) throws HttpException {
return true;
}
@Override
protected ContentEncoder createContentEncoder(
final long len,
final WritableByteChannel channel,
final SessionOutputBuffer buffer,
final BasicHttpTransportMetrics metrics) throws HttpException {
final int chunkSizeHint = http1Config.getChunkSizeHint() >= 0 ? http1Config.getChunkSizeHint() : 2048;
if (len >= 0) {
return new LengthDelimitedEncoder(channel, buffer, metrics, len, chunkSizeHint);
} else if (len == ContentLengthStrategy.CHUNKED) {
return new ChunkEncoder(channel, buffer, metrics, chunkSizeHint);
} else {
throw new LengthRequiredException();
}
}
@Override
boolean inputIdle() {
return incoming == null;
}
@Override
boolean outputIdle() {
return outgoing == null && pipeline.isEmpty();
}
@Override
void outputEnd() throws HttpException, IOException {
if (outgoing != null) {
if (outgoing.isCompleted()) {
outgoing.releaseResources();
}
outgoing = null;
}
}
@Override
void execute(final RequestExecutionCommand executionCommand) throws HttpException, IOException {
final AsyncClientExchangeHandler exchangeHandler = executionCommand.getExchangeHandler();
final HttpCoreContext context = HttpCoreContext.adapt(executionCommand.getContext());
context.setAttribute(HttpCoreContext.SSL_SESSION, getSSLSession());
context.setAttribute(HttpCoreContext.CONNECTION_ENDPOINT, getEndpointDetails());
final ClientHttp1StreamHandler handler = new ClientHttp1StreamHandler(
outputChannel,
httpProcessor,
http1Config,
connectionReuseStrategy,
exchangeHandler,
context);
pipeline.add(handler);
outgoing = handler;
if (handler.isOutputReady()) {
handler.produceOutput();
}
}
@Override
boolean isOutputReady() {
return outgoing != null && outgoing.isOutputReady();
}
@Override
void produceOutput() throws HttpException, IOException {
if (outgoing != null) {
outgoing.produceOutput();
}
}
@Override
void consumeHeader(final HttpResponse response, final EntityDetails entityDetails) throws HttpException, IOException {
if (streamListener != null) {
streamListener.onResponseHead(this, response);
}
Asserts.notNull(incoming, "Response stream handler");
incoming.consumeHeader(response, entityDetails);
}
@Override
void consumeData(final ByteBuffer src) throws HttpException, IOException {
Asserts.notNull(incoming, "Response stream handler");
incoming.consumeData(src);
}
@Override
void updateCapacity(final CapacityChannel capacityChannel) throws HttpException, IOException {
Asserts.notNull(incoming, "Response stream handler");
incoming.updateCapacity(capacityChannel);
}
@Override
void dataEnd(final List trailers) throws HttpException, IOException {
Asserts.notNull(incoming, "Response stream handler");
incoming.dataEnd(trailers);
}
@Override
void inputEnd() throws HttpException, IOException {
if (incoming != null && incoming.isResponseFinal()) {
if (streamListener != null) {
streamListener.onExchangeComplete(this, isOpen());
}
if (incoming.isCompleted()) {
incoming.releaseResources();
}
incoming = null;
}
}
@Override
boolean handleTimeout() {
return outgoing != null && outgoing.handleTimeout();
}
@Override
void appendState(final StringBuilder buf) {
super.appendState(buf);
super.appendState(buf);
buf.append(", incoming=[");
if (incoming != null) {
incoming.appendState(buf);
}
buf.append("], outgoing=[");
if (outgoing != null) {
outgoing.appendState(buf);
}
buf.append("], pipeline=");
buf.append(pipeline.size());
}
@Override
public String toString() {
final StringBuilder buf = new StringBuilder();
buf.append("[");
appendState(buf);
buf.append("]");
return buf.toString();
}
}