How to use

HttpChannel

in

org.eclipse.jetty.client

private void abort(Throwable failure)
{
  for (HttpChannel channel : activeChannels)
  {
    HttpExchange exchange = channel.getHttpExchange();
    if (exchange != null)
      exchange.getRequest().abort(failure);
  }
  activeChannels.clear();
  HttpChannel channel = idleChannels.poll();
  while (channel!=null)
  {
    channel.destroy();
    channel = idleChannels.poll();
  }
}

@Override
public String toString()
{
  return String.format("%s[send=%s,recv=%s]",
      super.toString(),
      sender,
      receiver);
}

public boolean abort(HttpExchange exchange, Throwable requestFailure, Throwable responseFailure)
{
  boolean requestAborted = false;
  if (requestFailure != null)
    requestAborted = getHttpSender().abort(exchange, requestFailure);
  boolean responseAborted = false;
  if (responseFailure != null)
    responseAborted = abortResponse(exchange, responseFailure);
  return requestAborted || responseAborted;
}

    getHttpChannel().abortResponse(exchange, failure);
result = channel.exchangeTerminating(exchange, result);
HttpDestination destination = getHttpChannel().getHttpDestination();
boolean ordered = destination.getHttpClient().isStrictEventOrdering();
if (!ordered)
  channel.exchangeTerminated(exchange, result);
if (LOG.isDebugEnabled())
  LOG.debug("Request/Response {}: {}", failure == null ? "succeeded" : "failed", result);
destination.getResponseNotifier().notifyComplete(conversation.getResponseListeners(), result);
if (ordered)
  channel.exchangeTerminated(exchange, result);

public void send()
{
  HttpExchange exchange = getHttpExchange();
  if (exchange != null)
  {
    HttpRequest request = exchange.getRequest();
    long timeoutAt = request.getTimeoutAt();
    if (timeoutAt != -1)
    {
      exchange.getResponseListeners().add(_totalTimeout);
      _totalTimeout.schedule(request, timeoutAt);
    }
    send(exchange);
  }
}

protected HttpExchange getHttpExchange()
{
  return channel.getHttpExchange();
}

if (channel.associate(exchange))
  channel.send();
  result = null;
  channel.release();
  result = new SendFailure(new HttpRequestException("Could not associate request to connection", request), false);

private void terminateResponse(HttpExchange exchange, Result result)
{
  HttpResponse response = exchange.getResponse();
  if (LOG.isDebugEnabled())
    LOG.debug("Response complete {}", response);
  if (result != null)
  {
    result = channel.exchangeTerminating(exchange, result);
    boolean ordered = getHttpDestination().getHttpClient().isStrictEventOrdering();
    if (!ordered)
      channel.exchangeTerminated(exchange, result);
    if (LOG.isDebugEnabled())
      LOG.debug("Request/Response {}: {}", failure == null ? "succeeded" : "failed", result);
    List<Response.ResponseListener> listeners = exchange.getConversation().getResponseListeners();
    ResponseNotifier notifier = getHttpDestination().getResponseNotifier();
    notifier.notifyComplete(listeners, result);
    if (ordered)
      channel.exchangeTerminated(exchange, result);
  }
}

protected HttpDestination getHttpDestination()
{
  return channel.getHttpDestination();
}

@Override
public void exchangeTerminated(HttpExchange exchange, Result result)
{
  super.exchangeTerminated(exchange, result);
  if (result.isSucceeded())
  {
    release();
  }
  else
  {
    Stream stream = getStream();
    if (stream != null)
      stream.reset(new ResetFrame(stream.getId(), ErrorCode.CANCEL_STREAM_ERROR.code), new ReleaseCallback());
    else
      release();
  }
}

public void exchangeTerminated(HttpExchange exchange, Result result)
{
  disassociate(exchange);
}

protected void close(Throwable failure)
{
  if (closed.compareAndSet(false, true))
  {
    getHttpDestination().close(this);
    abort(failure);
    session.close(ErrorCode.NO_ERROR.code, failure.getMessage(), Callback.NOOP);
    
    HttpChannel channel = idleChannels.poll();
    while (channel!=null)
    {
      channel.destroy();
      channel = idleChannels.poll();
    }
  }
}

boolean aborted = channel.abort(this, abortRequest ? failure : null, abortResponse ? failure : null);
if (LOG.isDebugEnabled())
  LOG.debug("Aborted ({}) while active {}: {}", aborted, this, failure);

protected HttpExchange getHttpExchange()
{
  return channel.getHttpExchange();
}

private void executeAbort(HttpExchange exchange, Throwable failure)
{
  try
  {
    Executor executor = getHttpChannel().getHttpDestination().getHttpClient().getExecutor();
    executor.execute(() -> abort(exchange, failure));
  }
  catch (RejectedExecutionException x)
  {
    if (LOG.isDebugEnabled())
      LOG.debug(x);
    abort(exchange, failure);
  }
}

@Override
public void exchangeTerminated(HttpExchange exchange, Result result)
  super.exchangeTerminated(exchange, result);

  @Override
  public String toString()
  {
    return String.format("%s@%x(exchange=%s)", getClass().getSimpleName(), hashCode(), getHttpExchange());
  }
}

@Override
public String toString()
{
  return String.format("%s[send=%s,recv=%s]",
      super.toString(),
      sender,
      receiver);
}

protected boolean beginToHeaders(HttpExchange exchange)
{
  if (!updateRequestState(RequestState.BEGIN, RequestState.TRANSIENT))
    return false;
  Request request = exchange.getRequest();
  if (LOG.isDebugEnabled())
    LOG.debug("Request headers {}{}{}", request, System.lineSeparator(), request.getHeaders().toString().trim());
  RequestNotifier notifier = getHttpChannel().getHttpDestination().getRequestNotifier();
  notifier.notifyHeaders(request);
  if (updateRequestState(RequestState.TRANSIENT, RequestState.HEADERS))
    return true;
  terminateRequest(exchange);
  return false;
}

protected boolean someToContent(HttpExchange exchange, ByteBuffer content)
{
  RequestState current = requestState.get();
  switch (current)
  {
    case COMMIT:
    case CONTENT:
    {
      if (!updateRequestState(current, RequestState.TRANSIENT))
        return false;
      Request request = exchange.getRequest();
      if (LOG.isDebugEnabled())
        LOG.debug("Request content {}{}{}", request, System.lineSeparator(), BufferUtil.toDetailString(content));
      RequestNotifier notifier = getHttpChannel().getHttpDestination().getRequestNotifier();
      notifier.notifyContent(request, content);
      if (updateRequestState(RequestState.TRANSIENT, RequestState.CONTENT))
        return true;
      terminateRequest(exchange);
      return false;
    }
    default:
    {
      return false;
    }
  }
}