Esempio n. 1
0
  /**
   * @param response The response to parse
   * @return A HttpResponse object made by consuming the response of the given HttpMethod.
   * @throws IOException when problems occur processing the body content
   */
  private HttpResponse makeResponse(org.apache.http.HttpResponse response) throws IOException {
    HttpResponseBuilder builder = new HttpResponseBuilder();

    if (response.getAllHeaders() != null) {
      for (Header h : response.getAllHeaders()) {
        if (h.getName() != null) builder.addHeader(h.getName(), h.getValue());
      }
    }

    HttpEntity entity = response.getEntity();

    if (maxObjSize > 0 && entity != null && entity.getContentLength() > maxObjSize) {
      return HttpResponse.badrequest("Exceeded maximum number of bytes - " + maxObjSize);
    }

    byte[] responseBytes = (entity == null) ? null : toByteArraySafe(entity);

    return builder
        .setHttpStatusCode(response.getStatusLine().getStatusCode())
        .setResponse(responseBytes)
        .create();
  }
  private void runAssertions(final HttpResponseBuilder result, final ResponseParseState context) {
    Assert.assertEquals(200, result.getStatusCode());
    Assert.assertEquals("OK", result.getReasonPhrase());
    Assert.assertSame(Protocols.HTTP_1_1, result.getProtocol());

    Assert.assertEquals(
        "www.somehost.net", result.getResponseHeaders().getFirst(new HttpString("Host")));
    Assert.assertEquals(
        "some value", result.getResponseHeaders().getFirst(new HttpString("OtherHeader")));
    Assert.assertEquals("another", result.getResponseHeaders().getFirst(new HttpString("Hostee")));
    Assert.assertEquals(
        "a", result.getResponseHeaders().getFirst(new HttpString("Accept-garbage")));
    Assert.assertEquals(4, result.getResponseHeaders().getHeaderNames().size());

    Assert.assertEquals(ResponseParseState.PARSE_COMPLETE, context.state);
  }
Esempio n. 3
0
    public void handleEvent(StreamSourceChannel channel) {

      HttpResponseBuilder builder = pendingResponse;
      final Pooled<ByteBuffer> pooled = bufferPool.allocate();
      final ByteBuffer buffer = pooled.getResource();
      boolean free = true;

      try {

        if (builder == null) {
          // read ready when no request pending
          buffer.clear();
          try {
            int res = channel.read(buffer);
            if (res == -1) {
              UndertowLogger.CLIENT_LOGGER.debugf(
                  "Connection to %s was closed by the target server", connection.getPeerAddress());
              IoUtils.safeClose(HttpClientConnection.this);
            } else if (res != 0) {
              UndertowLogger.CLIENT_LOGGER.debugf(
                  "Target server %s sent unexpected data when no request pending, closing connection",
                  connection.getPeerAddress());
              IoUtils.safeClose(HttpClientConnection.this);
            }
            // otherwise it is a spurious notification
          } catch (IOException e) {
            if (UndertowLogger.CLIENT_LOGGER.isDebugEnabled()) {
              UndertowLogger.CLIENT_LOGGER.debugf(e, "Connection closed with IOException");
            }
            safeClose(connection);
          }
          return;
        }
        final ResponseParseState state = builder.getParseState();
        int res;
        do {
          buffer.clear();
          try {
            res = channel.read(buffer);
          } catch (IOException e) {
            if (UndertowLogger.CLIENT_LOGGER.isDebugEnabled()) {
              UndertowLogger.CLIENT_LOGGER.debugf(e, "Connection closed with IOException");
            }
            safeClose(channel);
            return;
          }

          if (res == 0) {
            if (!channel.isReadResumed()) {
              channel.getReadSetter().set(this);
              channel.resumeReads();
            }
            return;
          } else if (res == -1) {
            channel.suspendReads();
            IoUtils.safeClose(HttpClientConnection.this);
            try {
              final StreamSinkChannel requestChannel = connection.getSinkChannel();
              requestChannel.shutdownWrites();
              // will return false if there's a response queued ahead of this one, so we'll set up a
              // listener then
              if (!requestChannel.flush()) {
                requestChannel
                    .getWriteSetter()
                    .set(ChannelListeners.flushingChannelListener(null, null));
                requestChannel.resumeWrites();
              }
              // Cancel the current active request
              currentRequest.setFailed(new IOException(MESSAGES.connectionClosed()));
            } catch (IOException e) {
              if (UndertowLogger.CLIENT_LOGGER.isDebugEnabled()) {
                UndertowLogger.CLIENT_LOGGER.debugf(
                    e, "Connection closed with IOException when attempting to shut down reads");
              }
              IoUtils.safeClose(channel);
              // Cancel the current active request
              currentRequest.setFailed(e);
              return;
            }
            return;
          }

          buffer.flip();

          HttpResponseParser.INSTANCE.handle(buffer, state, builder);
          if (buffer.hasRemaining()) {
            free = false;
            pushBackStreamSourceConduit.pushBack(pooled);
          }

        } while (!state.isComplete());

        final ClientResponse response = builder.build();

        String connectionString = response.getResponseHeaders().getFirst(CONNECTION);

        // check if an upgrade worked
        if (anyAreSet(HttpClientConnection.this.state, UPGRADE_REQUESTED)) {
          if ((connectionString == null || !UPGRADE.equalToString(connectionString))
              && !response.getResponseHeaders().contains(UPGRADE)) {
            // just unset the upgrade requested flag
            HttpClientConnection.this.state &= ~UPGRADE_REQUESTED;
          }
        }

        if (connectionString != null) {
          if (HttpString.tryFromString(connectionString).equals(Headers.CLOSE)) {
            HttpClientConnection.this.state |= CLOSE_REQ;
          }
        }

        if (builder.getStatusCode() == 100) {
          pendingResponse = new HttpResponseBuilder();
          currentRequest.setContinueResponse(response);
        } else {
          prepareResponseChannel(response, currentRequest);
          channel.getReadSetter().set(null);
          channel.suspendReads();
          pendingResponse = null;
          currentRequest.setResponse(response);
        }

      } catch (Exception e) {
        UndertowLogger.CLIENT_LOGGER.exceptionProcessingRequest(e);
        IoUtils.safeClose(connection);
        currentRequest.setFailed(new IOException(e));
      } finally {
        if (free) pooled.free();
      }
    }