@Override
  public Object getResponseContent(HttpURLConnection conn) throws IOException, ClientException {
    Exception error = null;
    InputStream input;
    if (conn == null) {
      throw new ClientException("Network error", null);
    }
    try {
      input = conn.getInputStream();
    } catch (Exception e) {
      Log.w("AndroidClient", e.toString());
      error = e;
      input = conn.getErrorStream();
    }
    Map<String, List<String>> headerFields = conn.getHeaderFields();
    if (headerFields != null) {
      Log.i("Base", headerFields.toString());
    }
    if (input != null) {
      Log.i("Base", "class " + input.getClass().getName());
    }
    final int responseCode = conn.getResponseCode();
    if (responseCode == 404) throw new ClientException("Item not found", null);
    if (input != null
        && input.getClass().getName().startsWith("libcore.net.http.HttpResponseCache")) {
      input = new GZIPInputStream(input);
    }

    final StringBuilder builder = new StringBuilder();
    if (input != null) {
      final BufferedReader br = new BufferedReader(new InputStreamReader(input));
      try {
        String output;
        while ((output = br.readLine()) != null) builder.append(output);

      } finally {
        br.close();
      }
    }
    conn.disconnect();

    if (responseCode >= 300 || error != null)
      throw new ClientException(
          responseCode,
          (error != null ? error.getMessage() : "") + ", response: " + builder,
          error);

    if (builder.length() == 0) return null;
    try {
      if (conn.getContentType().contains(JSON_MIME_TYPE)) return new JSONObject(builder.toString());
    } catch (JSONException e) {
      throw new ClientException(e);
    }
    return builder.toString();
  }
  /**
   * Discover the content length and content type for an enclosure URL
   *
   * @param rssEnclosureURL URL for enclosure
   * @return String array containing the enclosure's content length and content type
   */
  protected String[] discoverEnclosureProperties(String rssEnclosureURL) {
    String[] enclosureProperties = new String[] {"", ""};

    try {
      if (!rssEnclosureURL.toLowerCase().startsWith("http://")) {
        if (_logger.isDebugEnabled()) {
          _logger.debug("RSS enclosure URL not an HTTP-accessible resource");
        }
      } else {
        URL enclosure = new URL(rssEnclosureURL);
        HttpURLConnection httpURLConnection = (HttpURLConnection) enclosure.openConnection();
        httpURLConnection.setRequestMethod("HEAD");
        httpURLConnection.connect();

        enclosureProperties[0] = Integer.toString(httpURLConnection.getContentLength());
        enclosureProperties[1] = httpURLConnection.getContentType();

        httpURLConnection.disconnect();
      }
    } catch (Exception e) {
      if (_logger.isErrorEnabled()) {
        _logger.error("Error retrieving enclosure properties", e);
      }
    }

    return enclosureProperties;
  }
Beispiel #3
0
  /**
   * Fetch the provided URI, returning a {@link JarInputStream} if the response body is appropriate.
   *
   * <p>Protected to allow for mocking.
   *
   * @return the entity body as a stream, or null on failure.
   */
  @SuppressWarnings("static-method")
  @RobocopTarget
  protected JarInputStream fetchDistribution(URI uri, HttpURLConnection connection)
      throws IOException {
    final int status = connection.getResponseCode();

    Log.d(LOGTAG, "Distribution fetch: " + status);
    // We record HTTP statuses as 2xx, 3xx, 4xx, 5xx => 2, 3, 4, 5.
    final int value;
    if (status > 599 || status < 100) {
      Log.wtf(LOGTAG, "Unexpected HTTP status code: " + status);
      value = CODE_CATEGORY_STATUS_OUT_OF_RANGE;
    } else {
      value = status / 100;
    }

    Telemetry.addToHistogram(HISTOGRAM_CODE_CATEGORY, value);

    if (status != 200) {
      Log.w(LOGTAG, "Got status " + status + " fetching distribution.");
      Telemetry.addToHistogram(HISTOGRAM_CODE_CATEGORY, CODE_CATEGORY_FETCH_NON_SUCCESS_RESPONSE);
      return null;
    }

    final String contentType = connection.getContentType();
    if (contentType == null || !contentType.startsWith(EXPECTED_CONTENT_TYPE)) {
      Log.w(LOGTAG, "Malformed response: invalid Content-Type.");
      Telemetry.addToHistogram(HISTOGRAM_CODE_CATEGORY, CODE_CATEGORY_FETCH_INVALID_CONTENT_TYPE);
      return null;
    }

    return new JarInputStream(new BufferedInputStream(connection.getInputStream()), true);
  }
  public static String post(String url, byte[] body, String contentType) throws IOException {
    try {
      HttpURLConnection conn = openConnection(url);
      conn.setRequestMethod("POST");
      conn.setDoOutput(true);
      if (contentType != null) {
        conn.setRequestProperty("Content-Type", contentType);
      }
      conn.getOutputStream().write(body);

      if (conn.getResponseCode() != 200) {
        logger.error(
            "response error {},request {}",
            IOUtils.toString(conn.getErrorStream()),
            new String(body));
        return "";
      }

      contentType = conn.getContentType();
      String encoding = "utf-8";
      if (contentType != null && contentType.indexOf("charset=") > 0) {
        encoding = contentType.split("charset=")[1];
      }

      InputStream is = conn.getInputStream();
      byte[] resp = IOUtils.toByteArray(is);
      conn.disconnect();
      return new String(resp, encoding);
    } catch (MalformedURLException | URISyntaxException e) {
      logger.error("", e);
      return "";
    }
  }
Beispiel #5
0
  /**
   * This method will test the return type to make sure that it is between 200 (inclusive) and 300
   * (exclusive), i.e. that it is "successful". If it is not then it will throw an {@link
   * RequestFailureException} with the response code and message from the error stream.
   *
   * @param connection
   * @throws RequestFailureException
   * @throws IOException
   * @see HttpURLConnection#getResponseCode()
   * @see HttpURLConnection#getErrorStream()
   */
  private void testResponseCode(HttpURLConnection connection)
      throws RequestFailureException, IOException {
    int responseCode = connection.getResponseCode();
    if (responseCode < 200 || responseCode >= 300) {
      // Not one of the OK response codes so get the message off the error stream and throw an
      // exception
      InputStream errorStream = connection.getErrorStream();
      String errorStreamString = null;
      String message = null;
      if (errorStream != null) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        int read = -1;
        while ((read = errorStream.read()) != -1) {
          outputStream.write(read);
        }

        errorStreamString = outputStream.toString(getCharset(connection.getContentType()));
        // The content of the error stream coming from Massive seems to vary in structure (HTML,
        // JSON) see if it is is JSON and get a good message or use it as is
        message = parseErrorObject(errorStreamString);
      }
      throw new RequestFailureException(
          responseCode, message, connection.getURL(), errorStreamString);
    }
  }
 @Test
 public void changeBodyTest() throws Exception {
   HttpURLConnection httpCon =
       getConnection(
           "http://localhost:8080/test/application/api?__type=14&__moduleName=TestHttpContext&__methodName=changeBody");
   checkResponceCode(httpCon);
   assertEquals(httpCon.getContentLength(), 683);
   String type = httpCon.getContentType();
   String charset = "";
   String[] values = type.split(";");
   for (String value : values) {
     if (value.toLowerCase().startsWith("charset=")) {
       charset = value.substring("charset=".length());
     }
   }
   charset = charset.isEmpty() ? "utf-8" : charset;
   String text =
       new String(
           BinaryUtils.readStream(httpCon.getInputStream(), httpCon.getContentLength()), charset);
   assertEquals(
       text,
       "Фишер: \"В 1970 году в Бледе я принял участие в международном \n"
           + "блицтурнире. В партии с Петросяном мы то и дело обменивались шахами, причем он произносил \n"
           + "это слово по-русски, а я – по-английски. В момент, когда у обоих уже начали зависать флажки,\n"
           + "я вдруг сказал по-русски: \"Вам шах, гроссмейстер!\" Петросян настолько поразился, что на какой-то \n"
           + "момент забыл о флажке и просрочил время.");
 }
  @Test
  @RunAsClient
  public void testUpdateAssetFromAtomWithStateNotExist(@ArquillianResource URL baseURL)
      throws Exception {
    URL url = new URL(baseURL + "rest/packages/restPackage1/assets/model1");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());
    InputStream in = connection.getInputStream();
    assertNotNull(in);
    Document<Entry> doc = abdera.getParser().parse(in);
    Entry entry = doc.getRoot();

    // Update state
    ExtensibleElement metadataExtension = entry.getExtension(Translator.METADATA);
    ExtensibleElement stateExtension = metadataExtension.getExtension(Translator.STATE);
    stateExtension.<Element>getExtension(Translator.VALUE).setText("NonExistState");

    connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("PUT");
    connection.setRequestProperty("Content-type", MediaType.APPLICATION_ATOM_XML);
    connection.setDoOutput(true);
    entry.writeTo(connection.getOutputStream());
    assertEquals(500, connection.getResponseCode());
    connection.disconnect();
  }
Beispiel #8
0
 /**
  * 从Http连接的头信息中获得字符集
  *
  * @param conn HTTP连接对象
  * @return 字符集
  */
 private static String getCharsetFromConn(HttpURLConnection conn) {
   String charset = conn.getContentEncoding();
   if (charset == null || "".equals(charset.trim())) {
     String contentType = conn.getContentType();
     charset = RegexUtil.get("charset=(.*)", contentType, 1);
   }
   return charset;
 }
  @Override
  protected byte[] send(
      final byte[] request, final URL responderURL, final RequestOptions requestOptions)
      throws IOException {
    int size = request.length;
    HttpURLConnection httpUrlConnection;
    if (size <= MAX_LEN_GET && requestOptions.isUseHttpGetForRequest()) {
      String b64Request = Base64.toBase64String(request);
      String urlEncodedReq = URLEncoder.encode(b64Request, "UTF-8");
      StringBuilder urlBuilder = new StringBuilder();
      String baseUrl = responderURL.toString();
      urlBuilder.append(baseUrl);
      if (!baseUrl.endsWith("/")) {
        urlBuilder.append('/');
      }
      urlBuilder.append(urlEncodedReq);

      URL newURL = new URL(urlBuilder.toString());

      httpUrlConnection = (HttpURLConnection) newURL.openConnection();
      httpUrlConnection.setRequestMethod("GET");
    } else {
      httpUrlConnection = (HttpURLConnection) responderURL.openConnection();
      httpUrlConnection.setDoOutput(true);
      httpUrlConnection.setUseCaches(false);

      httpUrlConnection.setRequestMethod("POST");
      httpUrlConnection.setRequestProperty("Content-Type", CT_REQUEST);
      httpUrlConnection.setRequestProperty("Content-Length", java.lang.Integer.toString(size));
      OutputStream outputstream = httpUrlConnection.getOutputStream();
      outputstream.write(request);
      outputstream.flush();
    }

    InputStream inputstream = httpUrlConnection.getInputStream();
    if (httpUrlConnection.getResponseCode() != HttpURLConnection.HTTP_OK) {
      inputstream.close();
      throw new IOException(
          "bad response: "
              + httpUrlConnection.getResponseCode()
              + "  "
              + httpUrlConnection.getResponseMessage());
    }
    String responseContentType = httpUrlConnection.getContentType();
    boolean isValidContentType = false;
    if (responseContentType != null) {
      if (responseContentType.equalsIgnoreCase(CT_RESPONSE)) {
        isValidContentType = true;
      }
    }
    if (!isValidContentType) {
      inputstream.close();
      throw new IOException("bad response: mime type " + responseContentType + " not supported!");
    }

    return IoUtil.read(inputstream);
  }
Beispiel #10
0
  /**
   * 从Http连接的头信息中获得字符集
   *
   * @param conn HTTP连接对象
   * @return 字符集
   */
  public static String getCharset(HttpURLConnection conn) {
    if (conn == null) {
      return null;
    }

    String charset = conn.getContentEncoding();
    if (StrUtil.isBlank(charset)) {
      charset = ReUtil.get(CHARSET_PATTERN, conn.getContentType(), 1);
    }
    return charset;
  }
  /**
   * Downloads a file from a URL
   *
   * @param fileURL HTTP URL of the file to be downloaded
   * @param saveDir path of the directory to save the file
   * @throws IOException
   */
  public static void downloadFile(String fileURL, String saveDir, int id) throws IOException {
    URL url = new URL(fileURL);
    HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
    int responseCode = httpConn.getResponseCode();

    // always check HTTP response code first
    if (responseCode == HttpURLConnection.HTTP_OK) {
      String fileName = "";
      // Map<String, List<String>> responceHeader = httpConn.getHeaderFields();
      String disposition = httpConn.getHeaderField("Content-Disposition");
      String contentType = httpConn.getContentType();
      int contentLength = httpConn.getContentLength();

      if (disposition != null) {
        // extracts file name from header field
        int index = disposition.indexOf("filename=");
        if (index > 0) {
          fileName = disposition.substring(index + 10, disposition.length() - 1);
        }
      } else {
        // extracts file name from URL
        fileName = fileURL.substring(fileURL.lastIndexOf("/") + 1, fileURL.length());
      }

      // System.out.println("Content-Type = " + contentType);
      System.out.println("Content-Disposition = " + disposition);
      // System.out.println("Content-Length = " + contentLength);
      fileName = "id_" + id + "_" + fileName;
      System.out.println("fileName = " + fileName);

      // opens input stream from the HTTP connection
      InputStream inputStream = httpConn.getInputStream();
      String saveFilePath = saveDir + File.separator + fileName;

      // opens an output stream to save into file
      FileOutputStream outputStream = new FileOutputStream(saveFilePath);

      int bytesRead = -1;
      byte[] buffer = new byte[BUFFER_SIZE];
      while ((bytesRead = inputStream.read(buffer)) != -1) {
        outputStream.write(buffer, 0, bytesRead);
      }

      outputStream.close();
      inputStream.close();

      System.out.println("File downloaded\n");
    } else {
      System.out.println("No file to download. Server replied HTTP code: " + responseCode);
    }
    httpConn.disconnect();
  }
  /**
   * Retrieves the asset at the given URL on the CaaS server and returns it in Base64
   *
   * @param (@link String) assetURL
   * @return (@link Response) base64 encoded image
   *     <p>Path for method: "<server address>/CAAS_Hybrid/adapters/CaaS/asset?assetURL={assetURL}"
   */
  @GET
  @Path("/asset")
  public Response CAASAssetRequest(@QueryParam("assetURL") String assetURL)
      throws IOException, URISyntaxException {

    if (SERVER == null) {
      connect();
    }
    return Response.ok(
            new ByteArrayInputStream(IOUtils.toByteArray(openStream(SERVER + assetURL))),
            urlConnection.getContentType())
        .build();
  }
 @Test
 @RunAsClient
 public void testGetAssetBinary(@ArquillianResource URL baseURL) throws Exception {
   URL url = new URL(baseURL, "rest/packages/restPackage1/assets/model1/binary");
   HttpURLConnection connection = (HttpURLConnection) url.openConnection();
   connection.setRequestProperty(
       "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
   connection.setRequestMethod("GET");
   connection.setRequestProperty("Accept", MediaType.APPLICATION_OCTET_STREAM);
   connection.connect();
   assertEquals(200, connection.getResponseCode());
   assertEquals(MediaType.APPLICATION_OCTET_STREAM, connection.getContentType());
   // logger.log(LogLevel, getContent(connection));
 }
 @Test
 @RunAsClient
 public void testGetAssetAsJaxB(@ArquillianResource URL baseURL) throws Exception {
   URL url = new URL(baseURL, "rest/packages/restPackage1/assets/model1");
   HttpURLConnection connection = (HttpURLConnection) url.openConnection();
   connection.setRequestProperty(
       "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
   connection.setRequestMethod("GET");
   connection.setRequestProperty("Accept", MediaType.APPLICATION_XML);
   connection.connect();
   assertEquals(200, connection.getResponseCode());
   assertEquals(MediaType.APPLICATION_XML, connection.getContentType());
   System.out.println(IOUtils.toString(connection.getInputStream()));
 }
 /**
  * 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;
 }
Beispiel #16
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;
 }
  @Test
  public void testPush_UnpackError_TruncatedPack() throws Exception {
    StringBuilder sb = new StringBuilder();
    sb.append(ObjectId.zeroId().name());
    sb.append(' ');
    sb.append(a_blob.name());
    sb.append(' ');
    sb.append("refs/objects/A");
    sb.append('\0');
    sb.append("report-status");

    ByteArrayOutputStream reqbuf = new ByteArrayOutputStream();
    PacketLineOut reqpck = new PacketLineOut(reqbuf);
    reqpck.writeString(sb.toString());
    reqpck.end();

    packHeader(reqbuf, 1);

    byte[] reqbin = reqbuf.toByteArray();

    URL u = new URL(remoteURI.toString() + "/git-receive-pack");
    HttpURLConnection c = (HttpURLConnection) u.openConnection();
    try {
      c.setRequestMethod("POST");
      c.setDoOutput(true);
      c.setRequestProperty("Content-Type", GitSmartHttpTools.RECEIVE_PACK_REQUEST_TYPE);
      c.setFixedLengthStreamingMode(reqbin.length);
      OutputStream out = c.getOutputStream();
      try {
        out.write(reqbin);
      } finally {
        out.close();
      }

      assertEquals(200, c.getResponseCode());
      assertEquals(GitSmartHttpTools.RECEIVE_PACK_RESULT_TYPE, c.getContentType());

      InputStream rawin = c.getInputStream();
      try {
        PacketLineIn pckin = new PacketLineIn(rawin);
        assertEquals("unpack error " + JGitText.get().packfileIsTruncated, pckin.readString());
        assertEquals("ng refs/objects/A n/a (unpacker error)", pckin.readString());
        assertSame(PacketLineIn.END, pckin.readString());
      } finally {
        rawin.close();
      }
    } finally {
      c.disconnect();
    }
  }
 protected static void checkContentType(HttpURLConnection conn, byte[] data)
     throws UnrecoverableDownloadException {
   String contentType = conn.getContentType();
   if (contentType != null) {
     contentType = contentType.toLowerCase();
     if (!contentType.startsWith("image/")) {
       if (log.isTraceEnabled() && contentType.startsWith("text/")) {
         log.trace("Content (" + contentType + "): " + new String(data));
       }
       throw new UnrecoverableDownloadException(
           "Content type of the loaded image is unknown: " + contentType,
           UnrecoverableDownloadException.ERROR_CODE_CONTENT_TYPE);
     }
   }
 }
  protected void parseHeaders(HttpURLConnection httpConnection) {
    String mediaType = null;

    String contentType = httpConnection.getContentType();
    int indexOfSemicolon = contentType.indexOf(';');

    if (indexOfSemicolon != -1) {
      mediaType = contentType.substring(0, indexOfSemicolon).trim();

      String parameter = contentType.substring(indexOfSemicolon + 1).trim();
      if (parameter.startsWith("charset="))
        withDefaultEncoding(parameter.substring(parameter.indexOf('=') + 1).trim());
    } else mediaType = contentType.trim();

    getBindings().wDefValue("mediaType", mediaType);
  }
 @Test
 @RunAsClient
 public void testGetAssetSource(@ArquillianResource URL baseURL) throws Exception {
   URL url = new URL(baseURL, "rest/packages/restPackage1/assets/model1/source");
   HttpURLConnection connection = (HttpURLConnection) url.openConnection();
   connection.setRequestProperty(
       "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
   connection.setRequestMethod("GET");
   connection.setRequestProperty("Accept", MediaType.TEXT_PLAIN);
   connection.connect();
   assertEquals(200, connection.getResponseCode());
   assertEquals(MediaType.TEXT_PLAIN, connection.getContentType());
   String result = IOUtils.toString(connection.getInputStream());
   assertTrue(result.indexOf("declare Album2") >= 0);
   assertTrue(result.indexOf("genre2: String") >= 0);
 }
Beispiel #21
0
    // set up url, method, header, cookies
    private void setupFromConnection(HttpURLConnection conn, Connection.Response previousResponse)
        throws IOException {
      method = Connection.Method.valueOf(conn.getRequestMethod());
      url = conn.getURL();
      statusCode = conn.getResponseCode();
      statusMessage = conn.getResponseMessage();
      contentType = conn.getContentType();

      Map<String, List<String>> resHeaders = conn.getHeaderFields();
      processResponseHeaders(resHeaders);

      // if from a redirect, map previous response cookies into this response
      if (previousResponse != null) {
        for (Map.Entry<String, String> prevCookie : previousResponse.cookies().entrySet()) {
          if (!hasCookie(prevCookie.getKey())) cookie(prevCookie.getKey(), prevCookie.getValue());
        }
      }
    }
  /**
   * 执行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;
  }
Beispiel #23
0
  public static String getResponse(String url) throws IOException {
    try {
      HttpURLConnection conn = openConnection(url);
      String contentType = conn.getContentType();
      String encoding = "utf-8";
      if (contentType != null && contentType.indexOf("charset=") > 0) {
        encoding = contentType.split("charset=")[1];
      }

      InputStream is = conn.getInputStream();
      byte[] resp = IOUtils.toByteArray(is);
      conn.disconnect();
      return new String(resp, encoding);
    } catch (MalformedURLException | URISyntaxException e) {
      logger.error("", e);
      return "";
    }
  }
 /** {@inheritDoc } */
 @Override
 public String getContent() throws IOException, IllegalStateException {
   URL link = new URL(url);
   HttpURLConnection con = (HttpURLConnection) link.openConnection();
   if (con.getResponseCode() == 200) {
     BufferedReader buff =
         new BufferedReader(new InputStreamReader(con.getInputStream(), Charset.forName("UTF-8")));
     return readAll(buff);
   } else {
     BufferedReader buff =
         new BufferedReader(new InputStreamReader(con.getErrorStream(), Charset.forName("UTF-8")));
     if (con.getContentType().contains("json")) {
       throw new IllegalStateException(readAll(buff));
     } else {
       throw new IOException(readAll(buff));
     }
   }
 }
  @Test
  @RunAsClient
  public void testGetAssetAsAtom(@ArquillianResource URL baseURL) throws Exception {
    URL url = new URL(baseURL, "rest/packages/restPackage1/assets/model1");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());
    // System.out.println(getContent(connection));

    InputStream in = connection.getInputStream();
    assertNotNull(in);
    Document<Entry> doc = abdera.getParser().parse(in);
    Entry entry = doc.getRoot();
    assertEquals(
        baseURL.getPath() + "rest/packages/restPackage1/assets/model1",
        entry.getBaseUri().getPath());
    assertEquals("model1", entry.getTitle());
    assertNotNull(entry.getPublished());
    assertNotNull(entry.getAuthor().getName());
    assertEquals("desc for model1", entry.getSummary());
    // assertEquals(MediaType.APPLICATION_OCTET_STREAM_TYPE.getType(),
    // entry.getContentMimeType().getPrimaryType());
    assertEquals(
        baseURL.getPath() + "rest/packages/restPackage1/assets/model1/binary",
        entry.getContentSrc().getPath());

    ExtensibleElement metadataExtension = entry.getExtension(Translator.METADATA);
    ExtensibleElement archivedExtension = metadataExtension.getExtension(Translator.ARCHIVED);
    assertEquals("false", archivedExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement stateExtension = metadataExtension.getExtension(Translator.STATE);
    assertEquals("Draft", stateExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement formatExtension = metadataExtension.getExtension(Translator.FORMAT);
    assertEquals("model.drl", formatExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement uuidExtension = metadataExtension.getExtension(Translator.UUID);
    assertNotNull(uuidExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement categoryExtension = metadataExtension.getExtension(Translator.CATEGORIES);
    assertEquals(
        "AssetPackageResourceTestCategory", categoryExtension.getSimpleExtension(Translator.VALUE));
  }
  @Test
  public void testDoGet() throws Exception {
    System.out.println("doGet");

    HttpURLConnection con = null;
    try {
      con = (HttpURLConnection) new URL("http://" + getHost() + "/lenna.jpg").openConnection();
      con.setRequestMethod("GET");
      con.connect();

      assertEquals(HttpURLConnection.HTTP_OK, con.getResponseCode());
      assertTrue(con.getContentLength() > 1);
      assertEquals("image/jpeg", con.getContentType());
    } finally {
      if (con != null) {
        con.disconnect();
      }
    }
  }
 @Override
 public InputStream openInputStream() throws RepositoryException {
   try {
     HttpURLConnection conn =
         getRepository()
             .getResourceHTTPConnection(getLocation().getPath(), EntryStreamType.BLOB, false);
     conn.setDoOutput(false);
     conn.setDoInput(true);
     try {
       mimeType = conn.getContentType();
       return conn.getInputStream();
     } catch (IOException e) {
       throw new RepositoryException(
           "Cannot download object: " + conn.getResponseCode() + ": " + conn.getResponseMessage(),
           e);
     }
   } catch (IOException e) {
     throw new RepositoryException("Cannot open connection to '" + getLocation() + "': " + e, e);
   }
 }
Beispiel #28
0
 private void readResponseHeaders(HttpURLConnection conn) {
   info.disposition = conn.getHeaderField("Content-Disposition");
   info.location = conn.getHeaderField("Content-Location");
   info.mimeType = DLUtil.normalizeMimeType(conn.getContentType());
   final String transferEncoding = conn.getHeaderField("Transfer-Encoding");
   if (TextUtils.isEmpty(transferEncoding)) {
     try {
       info.totalBytes = Integer.parseInt(conn.getHeaderField("Content-Length"));
       LogUtils.e("安装包的大小:" + info.totalBytes);
     } catch (NumberFormatException e) {
       info.totalBytes = -1;
     }
   } else {
     info.totalBytes = -1;
   }
   if (info.totalBytes == -1
       && (TextUtils.isEmpty(transferEncoding) || !transferEncoding.equalsIgnoreCase("chunked")))
     throw new RuntimeException("Can not obtain size of download file.");
   if (TextUtils.isEmpty(info.fileName))
     info.fileName = DLUtil.obtainFileName(info.realUrl, info.disposition, info.location);
 }
 /**
  * Returns true if the content type of the resource pointed by sourceString is an image.
  *
  * @param sourceString the original image link.
  * @return true if the content type of the resource pointed by sourceString is an image.
  */
 @Override
 public boolean isDirectImage(String sourceString) {
   boolean isDirectImage = false;
   try {
     URL url = new URL(sourceString);
     String protocol = url.getProtocol();
     if (protocol.equals("http") || protocol.equals("https")) {
       HttpURLConnection connection = (HttpURLConnection) url.openConnection();
       isDirectImage = connection.getContentType().contains("image");
       connection.disconnect();
     } else if (protocol.equals("ftp")) {
       if (sourceString.endsWith(".png")
           || sourceString.endsWith(".jpg")
           || sourceString.endsWith(".gif")) {
         isDirectImage = true;
       }
     }
   } catch (Exception e) {
     logger.debug("Failed to retrieve content type information for" + sourceString, e);
   }
   return isDirectImage;
 }
  Response readResponse(HttpURLConnection connection) throws IOException {
    int status = connection.getResponseCode();
    String reason = connection.getResponseMessage();

    List<Header> headers = new ArrayList<Header>();
    for (Map.Entry<String, List<String>> field : connection.getHeaderFields().entrySet()) {
      String name = field.getKey();
      for (String value : field.getValue()) {
        headers.add(new Header(name, value));
      }
    }

    String mimeType = connection.getContentType();
    int length = connection.getContentLength();
    InputStream stream;
    if (status >= 400) {
      stream = connection.getErrorStream();
    } else {
      stream = connection.getInputStream();
    }
    TypedInput responseBody = new TypedInputStream(mimeType, length, stream);
    return new Response(status, reason, headers, responseBody);
  }