Examples with CancellableDependency org.apache.hc.core5.concurrent.CancellableDependency used on opensource projects

Example 1 with CancellableDependency

use of org.apache.hc.core5.concurrent.CancellableDependency in project httpcomponents-core by apache.

the class AbstractH2StreamMultiplexer method processPendingCommands.

private void processPendingCommands() throws IOException, HttpException {
    while (streamMap.size() < remoteConfig.getMaxConcurrentStreams()) {
        final Command command = ioSession.poll();
        if (command == null) {
            break;
        }
        if (command instanceof ShutdownCommand) {
            final ShutdownCommand shutdownCommand = (ShutdownCommand) command;
            if (shutdownCommand.getType() == CloseMode.IMMEDIATE) {
                for (final Iterator<Map.Entry<Integer, H2Stream>> it = streamMap.entrySet().iterator(); it.hasNext(); ) {
                    final Map.Entry<Integer, H2Stream> entry = it.next();
                    final H2Stream stream = entry.getValue();
                    stream.cancel();
                }
                streamMap.clear();
                connState = ConnectionHandshake.SHUTDOWN;
            } else {
                if (connState.compareTo(ConnectionHandshake.ACTIVE) <= 0) {
                    final RawFrame goAway = frameFactory.createGoAway(processedRemoteStreamId, H2Error.NO_ERROR, "Graceful shutdown");
                    commitFrame(goAway);
                    connState = streamMap.isEmpty() ? ConnectionHandshake.SHUTDOWN : ConnectionHandshake.GRACEFUL_SHUTDOWN;
                }
            }
            break;
        } else if (command instanceof PingCommand) {
            final PingCommand pingCommand = (PingCommand) command;
            final AsyncPingHandler handler = pingCommand.getHandler();
            pingHandlers.add(handler);
            final RawFrame ping = frameFactory.createPing(handler.getData());
            commitFrame(ping);
        } else if (command instanceof ExecutableCommand) {
            final int streamId = generateStreamId();
            final H2StreamChannelImpl channel = new H2StreamChannelImpl(streamId, true, initInputWinSize, initOutputWinSize);
            final ExecutableCommand executableCommand = (ExecutableCommand) command;
            final H2StreamHandler streamHandler = createLocallyInitiatedStream(executableCommand, channel, httpProcessor, connMetrics);
            final H2Stream stream = new H2Stream(channel, streamHandler, false);
            streamMap.put(streamId, stream);
            if (streamListener != null) {
                final int initInputWindow = stream.getInputWindow().get();
                streamListener.onInputFlowControl(this, streamId, initInputWindow, initInputWindow);
                final int initOutputWindow = stream.getOutputWindow().get();
                streamListener.onOutputFlowControl(this, streamId, initOutputWindow, initOutputWindow);
            }
            if (stream.isOutputReady()) {
                stream.produceOutput();
            }
            final CancellableDependency cancellableDependency = executableCommand.getCancellableDependency();
            if (cancellableDependency != null) {
                cancellableDependency.setDependency(stream::abort);
            }
            if (!outputQueue.isEmpty()) {
                return;
            }
        }
    }
}

Example 2 with CancellableDependency

use of org.apache.hc.core5.concurrent.CancellableDependency in project httpcomponents-core by apache.

the class H2MultiplexingRequester method execute.

private void execute(final AsyncClientExchangeHandler exchangeHandler, final HandlerFactory<AsyncPushConsumer> 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<IOSession>() {

                @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<? extends Header> 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);
    }
}