public HttpPost createPostMethod(String url, Object postData) {
    try {
      byte[] rawData;

      if (postData instanceof byte[]) {
        rawData = (byte[]) postData;
      } else {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(postData);
        oos.close();
        rawData = baos.toByteArray();
      }

      InputStream is = new ByteArrayInputStream(rawData);

      HttpPost httpPost = new HttpPost(url);
      BasicHttpEntity entity = new BasicHttpEntity();
      entity.setContentType("application/octet-stream");
      entity.setContentLength(rawData.length);
      entity.setContent(is);
      httpPost.setEntity(entity);

      RequestConfig requestConfig =
          RequestConfig.copy(HAZELCAST_REQUEST_CONFIG)
              .setSocketTimeout(TIMEOUT)
              .setConnectTimeout(TIMEOUT)
              .setConnectionRequestTimeout(TIMEOUT)
              .build();
      httpPost.setConfig(requestConfig);
      return httpPost;
    } catch (IOException e) {
      throw new RuntimeException("Error POST-ing data", e);
    }
  }
  private static HttpEntity entityFromOkHttpResponse(Response response) throws IOException {
    BasicHttpEntity entity = new BasicHttpEntity();
    ResponseBody body = response.body();

    entity.setContent(body.byteStream());
    entity.setContentLength(body.contentLength());
    entity.setContentEncoding(response.header("Content-Encoding"));

    if (body.contentType() != null) {
      entity.setContentType(body.contentType().type());
    }
    return entity;
  }
예제 #3
0
 /**
  * Initializes an {@link HttpEntity} from the given {@link HttpURLConnection}.
  *
  * @param connection
  * @return an HttpEntity populated with data from <code>connection</code>.
  */
 private static HttpEntity entityFromConnection(HttpURLConnection connection) {
   BasicHttpEntity entity = new BasicHttpEntity();
   InputStream inputStream;
   try {
     inputStream = connection.getInputStream();
   } catch (IOException ioe) {
     inputStream = connection.getErrorStream();
   }
   entity.setContent(inputStream);
   entity.setContentLength(connection.getContentLength());
   entity.setContentEncoding(connection.getContentEncoding());
   entity.setContentType(connection.getContentType());
   return entity;
 }
예제 #4
0
 private static HttpEntity a(HttpURLConnection httpurlconnection) {
   BasicHttpEntity basichttpentity = new BasicHttpEntity();
   java.io.InputStream inputstream;
   try {
     inputstream = httpurlconnection.getInputStream();
   } catch (IOException ioexception) {
     ioexception = httpurlconnection.getErrorStream();
   }
   basichttpentity.setContent(inputstream);
   basichttpentity.setContentLength(httpurlconnection.getContentLength());
   basichttpentity.setContentEncoding(httpurlconnection.getContentEncoding());
   basichttpentity.setContentType(httpurlconnection.getContentType());
   return basichttpentity;
 }
 /**
  * Write the stream to a temporary storage and calculate the content length
  *
  * @param entity HTTPEntity
  * @param messageFormatter message formatter
  * @param msgContext current message context
  * @param format message format
  * @throws IOException if an exception occurred while writing data
  */
 private void setStreamAsTempData(
     BasicHttpEntity entity,
     MessageFormatter messageFormatter,
     MessageContext msgContext,
     OMOutputFormat format)
     throws IOException {
   TemporaryData serialized = new TemporaryData(256, 4096, "http-nio_", ".dat");
   OutputStream out = serialized.getOutputStream();
   try {
     messageFormatter.writeTo(msgContext, format, out, true);
   } finally {
     out.close();
   }
   msgContext.setProperty(NhttpConstants.SERIALIZED_BYTES, serialized);
   entity.setContentLength(serialized.getLength());
 }
예제 #6
0
    @Override
    public void run() {
      super.run();
      try {
        ParcelFileDescriptor[] descriptors = ParcelFileDescriptor.createPipe();
        parcelRead = new ParcelFileDescriptor(descriptors[0]);
        parcelWrite = new ParcelFileDescriptor(descriptors[1]);

        mediaRecorder.setOutputFile(parcelWrite.getFileDescriptor());

        cameraSurface.getHolder().addCallback(CameraActivity.this);

        is = new ParcelFileDescriptor.AutoCloseInputStream(parcelRead);

        // This will skip the MPEG4 header if this step fails we can't stream anything :(

        byte[] mpegHeader = {'m', 'd', 'a', 't'};
        byte[] headerBuffer = new byte[mpegHeader.length];
        try {
          byte mpegHeaderBuffer[] = new byte[4];
          // Skip all atoms preceding mdat atom
          do {
            is.read(headerBuffer);
          } while (!Arrays.equals(mpegHeader, headerBuffer));
        } catch (IOException e) {
          Log.e("ERROR", "Couldn't skip mp4 header :/");
          throw e;
        }

        Log.d("SPRINKLER", "MPEG HEADER SKIPPED");

        HttpPost post =
            new HttpPost("http://" + SERVER_ADDRESS + ":" + SERVER_PORT + "/emit?channel=prueba");
        BasicHttpEntity httpEntity = new BasicHttpEntity();
        httpEntity.setChunked(true);
        httpEntity.setContentLength(-1);
        httpEntity.setContent(is);

        post.setEntity(httpEntity);

        HttpClient client = new DefaultHttpClient();
        client.execute(post);

      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  @Test
  public void testGetContentLength() throws Exception {
    String input = "0123456789";
    BasicHttpEntity basic;
    PartiallyRepeatableHttpEntity replay;

    basic = new BasicHttpEntity();
    basic.setContent(new ByteArrayInputStream(input.getBytes(UTF8)));
    replay = new PartiallyRepeatableHttpEntity(basic, 5);
    assertThat(replay.getContentLength(), is(-1L));

    basic = new BasicHttpEntity();
    basic.setContent(new ByteArrayInputStream(input.getBytes(UTF8)));
    basic.setContentLength(input.length());
    replay = new PartiallyRepeatableHttpEntity(basic, 5);
    assertThat(replay.getContentLength(), is(10L));
  }
예제 #8
0
  /**
   * 执行HTTP请求之后获取到的数据流.
   *
   * @param connection
   * @return
   */
  private HttpEntity entityFromURLConnwction(HttpURLConnection connection) {
    BasicHttpEntity entity = new BasicHttpEntity();
    InputStream inputStream;
    try {
      inputStream = connection.getInputStream();
    } catch (IOException e) {
      e.printStackTrace();
      inputStream = connection.getErrorStream();
    }

    // TODO : GZIP
    entity.setContent(inputStream);
    entity.setContentLength(connection.getContentLength());
    entity.setContentEncoding(connection.getContentEncoding());
    entity.setContentType(connection.getContentType());

    return entity;
  }
예제 #9
0
 public HttpResponse put(
     String cType,
     String accountSid,
     String authToken,
     String timestamp,
     String url,
     DefaultHttpClient httpclient,
     EncryptUtil encryptUtil,
     String body)
     throws Exception {
   HttpPut httpPut = new HttpPut(url);
   httpPut.setHeader("Accept", cType);
   httpPut.setHeader("Content-Type", cType + ";charset=utf-8");
   String src = accountSid + ":" + timestamp;
   String auth = encryptUtil.base64Encoder(src);
   httpPut.setHeader("Authorization", auth);
   logger.info(body);
   BasicHttpEntity requestBody = new BasicHttpEntity();
   requestBody.setContent(new ByteArrayInputStream(body.getBytes("UTF-8")));
   requestBody.setContentLength(body.getBytes("UTF-8").length);
   httpPut.setEntity(requestBody);
   HttpResponse response = httpclient.execute(httpPut);
   return response;
 }
  /**
   * Send the passed in response message, asynchronously
   *
   * @param msgContext the message context to be sent
   * @throws AxisFault on error
   */
  private void sendAsyncResponse(MessageContext msgContext) throws AxisFault {

    int contentLength = extractContentLength(msgContext);

    // remove unwanted HTTP headers (if any from the current message)
    removeUnwantedHeaders(msgContext);
    Map transportHeaders = (Map) msgContext.getProperty(MessageContext.TRANSPORT_HEADERS);

    ServerWorker worker = (ServerWorker) msgContext.getProperty(Constants.OUT_TRANSPORT_INFO);
    HttpResponse response = worker.getResponse();

    OMOutputFormat format = NhttpUtil.getOMOutputFormat(msgContext);
    MessageFormatter messageFormatter =
        MessageFormatterDecoratorFactory.createMessageFormatterDecorator(msgContext);
    Boolean noEntityBody = (Boolean) msgContext.getProperty(NhttpConstants.NO_ENTITY_BODY);
    if (noEntityBody == null || Boolean.FALSE == noEntityBody) {
      response.setHeader(
          HTTP.CONTENT_TYPE,
          messageFormatter.getContentType(msgContext, format, msgContext.getSoapAction()));
    } else if (Boolean.TRUE == noEntityBody) {
      ((BasicHttpEntity) response.getEntity()).setChunked(false);
      ((BasicHttpEntity) response.getEntity()).setContentLength(0);

      // Since HTTP HEAD request doesn't contain message body content length of the is set to be 0.
      // To handle
      // content length 0 while serving head method, content length of the backend response is set
      // as the content
      // as synapse cannot calculate content length without providing message body.
      if (transportHeaders.get(NhttpConstants.HTTP_REQUEST_METHOD) != null
          && NhttpConstants.HTTP_HEAD.equals(
              transportHeaders.get(NhttpConstants.HTTP_REQUEST_METHOD))
          && transportHeaders.get(NhttpConstants.ORIGINAL_CONTENT_LEN) != null) {

        ((BasicHttpEntity) response.getEntity())
            .setContentLength(
                Long.parseLong(
                    String.valueOf(transportHeaders.get(NhttpConstants.ORIGINAL_CONTENT_LEN))));
        transportHeaders.remove(NhttpConstants.ORIGINAL_CONTENT_LEN);
        transportHeaders.remove(NhttpConstants.HTTP_REQUEST_METHOD);
      }
    }
    response.setStatusCode(determineHttpStatusCode(msgContext, response));

    // Override the Standard Reason Phrase
    if (msgContext.getProperty(NhttpConstants.HTTP_REASON_PHRASE) != null
        && !msgContext.getProperty(NhttpConstants.HTTP_REASON_PHRASE).equals("")) {
      response.setReasonPhrase(
          msgContext.getProperty(NhttpConstants.HTTP_REASON_PHRASE).toString());
    }

    // set any transport headers
    if (transportHeaders != null && !transportHeaders.values().isEmpty()) {
      Iterator iter = transportHeaders.keySet().iterator();
      while (iter.hasNext()) {
        Object header = iter.next();
        Object value = transportHeaders.get(header);
        if (value != null && header instanceof String && value instanceof String) {
          response.addHeader((String) header, (String) value);

          String excessProp = NhttpConstants.EXCESS_TRANSPORT_HEADERS;

          Map map = (Map) msgContext.getProperty(excessProp);
          if (map != null && map.get(header) != null) {
            log.debug(
                "Number of excess values for "
                    + header
                    + " header is : "
                    + ((Collection) (map.get(header))).size());

            for (Iterator iterator = map.keySet().iterator(); iterator.hasNext(); ) {
              String key = (String) iterator.next();

              for (String excessVal : (Collection<String>) map.get(key)) {
                if (header.equals(key)) {
                  response.addHeader((String) header, (String) excessVal);
                }
              }
            }
          }
        }
      }
    }

    boolean forceContentLength =
        msgContext.isPropertyTrue(NhttpConstants.FORCE_HTTP_CONTENT_LENGTH);
    boolean forceContentLengthCopy =
        msgContext.isPropertyTrue(NhttpConstants.COPY_CONTENT_LENGTH_FROM_INCOMING);

    BasicHttpEntity entity = (BasicHttpEntity) response.getEntity();

    MetricsCollector lstMetrics = worker.getServiceHandler().getMetrics();
    try {
      if (forceContentLength) {
        entity.setChunked(false);
        if (forceContentLengthCopy && contentLength > 0) {
          entity.setContentLength(contentLength);
        } else {
          setStreamAsTempData(entity, messageFormatter, msgContext, format);
        }
      }

      worker.getServiceHandler().commitResponse(worker.getConn(), response);
      lstMetrics.reportResponseCode(response.getStatusLine().getStatusCode());
      OutputStream out = worker.getOutputStream();

      /*
       * if this is a dummy message to handle http 202 case with non-blocking IO
       * write an empty byte array as body
       */
      if (msgContext.isPropertyTrue(NhttpConstants.SC_ACCEPTED) || Boolean.TRUE == noEntityBody) {
        out.write(new byte[0]);
      } else {
        if (forceContentLength) {
          if (forceContentLengthCopy && contentLength > 0) {
            messageFormatter.writeTo(msgContext, format, out, false);
          } else {
            writeMessageFromTempData(out, msgContext);
          }
        } else {
          messageFormatter.writeTo(msgContext, format, out, false);
        }
      }
      out.close();
      if (lstMetrics != null) {
        lstMetrics.incrementMessagesSent();
      }

    } catch (ProtocolException e) {
      log.error(e + " (Synapse may be trying to send an exact response more than once )");
    } catch (HttpException e) {
      if (lstMetrics != null) {
        lstMetrics.incrementFaultsSending();
      }
      handleException(
          "Unexpected HTTP protocol error sending response to : " + worker.getRemoteAddress(), e);
    } catch (ConnectionClosedException e) {
      if (lstMetrics != null) {
        lstMetrics.incrementFaultsSending();
      }
      log.warn("Connection closed by client : " + worker.getRemoteAddress());
    } catch (IllegalStateException e) {
      if (lstMetrics != null) {
        lstMetrics.incrementFaultsSending();
      }
      log.warn("Connection closed by client : " + worker.getRemoteAddress());
    } catch (IOException e) {
      if (lstMetrics != null) {
        lstMetrics.incrementFaultsSending();
      }
      handleException("IO Error sending response message to : " + worker.getRemoteAddress(), e);
    } catch (Exception e) {
      if (lstMetrics != null) {
        lstMetrics.incrementFaultsSending();
      }
      handleException(
          "General Error sending response message to : " + worker.getRemoteAddress(), e);
    }

    InputStream is = worker.getIs();
    if (is != null) {
      try {
        is.close();
      } catch (IOException ignore) {
      }
    }
  }