keycloakjar.org.apache.hc.core5.http2.impl.nio.bootstrap.H2MultiplexingRequester 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
* ioSessionDecorator,
final Callback exceptionCallback,
final IOSessionListener sessionListener,
final Resolver addressResolver,
final TlsStrategy tlsStrategy) {
super(eventHandlerFactory, ioReactorConfig, ioSessionDecorator, exceptionCallback, sessionListener,
ShutdownCommand.GRACEFUL_IMMEDIATE_CALLBACK, DefaultAddressResolver.INSTANCE);
this.connPool = new H2ConnPool(this, addressResolver, tlsStrategy);
}
public void closeIdle(final TimeValue idleTime) {
connPool.closeIdle(idleTime);
}
public Set getRoutes() {
return connPool.getRoutes();
}
public TimeValue getValidateAfterInactivity() {
return connPool.getValidateAfterInactivity();
}
public void setValidateAfterInactivity(final TimeValue timeValue) {
connPool.setValidateAfterInactivity(timeValue);
}
public Cancellable execute(
final AsyncClientExchangeHandler exchangeHandler,
final HandlerFactory pushHandlerFactory,
final Timeout timeout,
final HttpContext context) {
Args.notNull(exchangeHandler, "Exchange handler");
Args.notNull(timeout, "Timeout");
Args.notNull(context, "Context");
final CancellableExecution cancellableExecution = new CancellableExecution();
execute(exchangeHandler, pushHandlerFactory, cancellableExecution, timeout, context);
return cancellableExecution;
}
public Cancellable execute(
final AsyncClientExchangeHandler exchangeHandler,
final Timeout timeout,
final HttpContext context) {
return execute(exchangeHandler, null, timeout, context);
}
private void execute(
final AsyncClientExchangeHandler exchangeHandler,
final HandlerFactory pushHandlerFactory,
final CancellableDependency cancellableDependency,
final Timeout timeout,
final HttpContext context) {
Args.notNull(exchangeHandler, "Exchange handler");
Args.notNull(timeout, "Timeout");
Args.notNull(context, "Context");
try {
exchangeHandler.produceRequest((request, entityDetails, httpContext) -> {
final String scheme = request.getScheme();
final URIAuthority authority = request.getAuthority();
if (authority == null) {
throw new ProtocolException("Request authority not specified");
}
final HttpHost target = new HttpHost(scheme, authority);
connPool.getSession(target, timeout, new FutureCallback() {
@Override
public void completed(final IOSession ioSession) {
ioSession.enqueue(new RequestExecutionCommand(new AsyncClientExchangeHandler() {
@Override
public void releaseResources() {
exchangeHandler.releaseResources();
}
@Override
public void produceRequest(final RequestChannel channel, final HttpContext httpContext) throws HttpException, IOException {
channel.sendRequest(request, entityDetails, httpContext);
}
@Override
public int available() {
return exchangeHandler.available();
}
@Override
public void produce(final DataStreamChannel channel) throws IOException {
exchangeHandler.produce(channel);
}
@Override
public void consumeInformation(final HttpResponse response, final HttpContext httpContext) throws HttpException, IOException {
exchangeHandler.consumeInformation(response, httpContext);
}
@Override
public void consumeResponse(
final HttpResponse response, final EntityDetails entityDetails, final HttpContext httpContext) throws HttpException, IOException {
exchangeHandler.consumeResponse(response, entityDetails, httpContext);
}
@Override
public void updateCapacity(final CapacityChannel capacityChannel) throws IOException {
exchangeHandler.updateCapacity(capacityChannel);
}
@Override
public void consume(final ByteBuffer src) throws IOException {
exchangeHandler.consume(src);
}
@Override
public void streamEnd(final List trailers) throws HttpException, IOException {
exchangeHandler.streamEnd(trailers);
}
@Override
public void cancel() {
exchangeHandler.cancel();
}
@Override
public void failed(final Exception cause) {
exchangeHandler.failed(cause);
}
}, pushHandlerFactory, cancellableDependency, context), Command.Priority.NORMAL);
if (!ioSession.isOpen()) {
exchangeHandler.failed(new ConnectionClosedException());
}
}
@Override
public void failed(final Exception ex) {
exchangeHandler.failed(ex);
}
@Override
public void cancelled() {
exchangeHandler.cancel();
}
});
}, context);
} catch (final IOException | HttpException ex) {
exchangeHandler.failed(ex);
}
}
public final Future execute(
final AsyncRequestProducer requestProducer,
final AsyncResponseConsumer responseConsumer,
final HandlerFactory pushHandlerFactory,
final Timeout timeout,
final HttpContext context,
final FutureCallback callback) {
Args.notNull(requestProducer, "Request producer");
Args.notNull(responseConsumer, "Response consumer");
Args.notNull(timeout, "Timeout");
final ComplexFuture future = new ComplexFuture<>(callback);
final AsyncClientExchangeHandler exchangeHandler = new BasicClientExchangeHandler<>(
requestProducer,
responseConsumer,
new FutureContribution(future) {
@Override
public void completed(final T result) {
future.completed(result);
}
});
execute(exchangeHandler, pushHandlerFactory, future, timeout, context != null ? context : HttpCoreContext.create());
return future;
}
public final Future execute(
final AsyncRequestProducer requestProducer,
final AsyncResponseConsumer responseConsumer,
final Timeout timeout,
final HttpContext context,
final FutureCallback callback) {
return execute(requestProducer, responseConsumer, null, timeout, context, callback);
}
public final Future execute(
final AsyncRequestProducer requestProducer,
final AsyncResponseConsumer responseConsumer,
final Timeout timeout,
final FutureCallback callback) {
return execute(requestProducer, responseConsumer, null, timeout, null, callback);
}
@Internal
public H2ConnPool getConnPool() {
return connPool;
}
}