Java Code Examples for java.net.HttpURLConnection#HTTP_PARTIAL

public void testRequestWasSuccessful_unsuccessfulStatusCodes() {
  // 204 and 205 are considered unsuccessful in this case, and 206 should never happen. Also
  // test with some of the other common status codes (these are ones that our backend has
  // been known to return).
  final int[] statusCodes = {
    HttpURLConnection.HTTP_NO_CONTENT,
    HttpURLConnection.HTTP_RESET,
    HttpURLConnection.HTTP_PARTIAL,
    HttpURLConnection.HTTP_BAD_REQUEST,
    HttpURLConnection.HTTP_UNAUTHORIZED,
    HttpURLConnection.HTTP_FORBIDDEN,
    HttpURLConnection.HTTP_NOT_FOUND,
    HttpURLConnection.HTTP_NOT_ACCEPTABLE,
    HttpURLConnection.HTTP_INTERNAL_ERROR,
    HttpURLConnection.HTTP_BAD_GATEWAY,
    HttpURLConnection.HTTP_UNAVAILABLE,
    HttpURLConnection.HTTP_GATEWAY_TIMEOUT
  };
  for (int statusCode : statusCodes) {
    assertFalse(defaultSettingsSpiCall.requestWasSuccessful(statusCode));
  }
}
 

/** Use HTTP Range header for specifying offset. */
@Override
protected HttpURLConnection connect(final long offset,
    final boolean resolved) throws IOException {
  final HttpURLConnection conn = openConnection();
  conn.setRequestMethod("GET");
  if (offset != 0L) {
    conn.setRequestProperty("Range", "bytes=" + offset + "-");
  }
  conn.connect();

  //Expects HTTP_OK or HTTP_PARTIAL response codes.
  final int code = conn.getResponseCode();
  if (offset != 0L && code != HttpURLConnection.HTTP_PARTIAL) {
    throw new IOException("HTTP_PARTIAL expected, received " + code);
  } else if (offset == 0L && code != HttpURLConnection.HTTP_OK) {
    throw new IOException("HTTP_OK expected, received " + code);
  }
  return conn;
}
 

/** Use HTTP Range header for specifying offset. */
@Override
protected HttpURLConnection connect(final long offset,
    final boolean resolved) throws IOException {
  final HttpURLConnection conn = openConnection();
  conn.setRequestMethod("GET");
  if (offset != 0L) {
    conn.setRequestProperty("Range", "bytes=" + offset + "-");
  }
  conn.connect();

  //Expects HTTP_OK or HTTP_PARTIAL response codes.
  final int code = conn.getResponseCode();
  if (offset != 0L && code != HttpURLConnection.HTTP_PARTIAL) {
    throw new IOException("HTTP_PARTIAL expected, received " + code);
  } else if (offset == 0L && code != HttpURLConnection.HTTP_OK) {
    throw new IOException("HTTP_OK expected, received " + code);
  }
  return conn;
}
 

public static boolean isSupportRange(String fileUrl, String[] headers) throws MalformedURLException {
    int times = 2;
    URL url = new URL(fileUrl);
    HttpURLConnection conn = null;
    int code;
    while (times-- > 0) {
        try {
            conn = openConnection(url);
            conn.setUseCaches(false);
            conn.setRequestProperty("Range", "bytes=0-0");
            fillHeaders(conn, headers);
            conn.setInstanceFollowRedirects(true);
            HttpURLConnection.setFollowRedirects(true);
            conn.setConnectTimeout(2000);
            conn.setReadTimeout(1000);

            conn.connect();
            code = conn.getResponseCode();
            if (REDIRECTED_CODE.contains(code)) {
                fileUrl = conn.getHeaderField("Location");
                if (StringUtils.isNotBlank(fileUrl)) {
                    return isSupportRange(fileUrl, null);
                }
            }
            return code == HttpURLConnection.HTTP_PARTIAL;
        } catch (Exception e) {
            logger.warn("url:{} isSupportRange error", fileUrl, e);
        } finally {
            closeConn(conn);
            conn = null;
        }
    }
    return false;
}
 

public boolean isServerCanceled(int responseCode, boolean isAlreadyProceed) {
    if (responseCode != HttpURLConnection.HTTP_PARTIAL
            && responseCode != HttpURLConnection.HTTP_OK) {
        return true;
    }

    if (responseCode == HttpURLConnection.HTTP_OK && isAlreadyProceed) {
        return true;
    }

    return false;
}
 

private static boolean isAcceptRange(@NonNull DownloadConnection.Connected connected)
        throws IOException {
    if (connected.getResponseCode() == HttpURLConnection.HTTP_PARTIAL) return true;

    final String acceptRanges = connected.getResponseHeaderField(ACCEPT_RANGES);
    return "bytes".equals(acceptRanges);
}
 

private void sendMessage(String url, Message msg, MimeBodyPart securedData, String retries) throws Exception {
    URL urlObj = new URL(url);
    InternetHeaders ih = getHttpHeaders(msg, securedData);
    msg.setAttribute(NetAttribute.MA_DESTINATION_IP, urlObj.getHost());
    msg.setAttribute(NetAttribute.MA_DESTINATION_PORT, Integer.toString(urlObj.getPort()));

    if (logger.isInfoEnabled()) {
        logger.info("Connecting to: " + url + msg.getLogMsgID());
    }

    Map<String, String> httpOptions = getHttpOptions();
    httpOptions.put(HTTPUtil.PARAM_HTTP_USER, msg.getPartnership().getAttribute(HTTPUtil.PARAM_HTTP_USER));
    httpOptions.put(HTTPUtil.PARAM_HTTP_PWD, msg.getPartnership().getAttribute(HTTPUtil.PARAM_HTTP_PWD));
    long maxSize = msg.getPartnership().getNoChunkedMaxSize();
    ResponseWrapper resp = HTTPUtil.execRequest(HTTPUtil.Method.POST, url, ih.getAllHeaders(), null, securedData.getInputStream(), httpOptions, maxSize);
    if (logger.isInfoEnabled()) {
        logger.info("Message sent and response received in " + resp.getTransferTimeMs() + "ms" + msg.getLogMsgID());
    }

    // Check the HTTP Response code
    int rc = resp.getStatusCode();
    if ((rc != HttpURLConnection.HTTP_OK) && (rc != HttpURLConnection.HTTP_CREATED) && (rc != HttpURLConnection.HTTP_ACCEPTED) && (rc != HttpURLConnection.HTTP_PARTIAL) && (rc != HttpURLConnection.HTTP_NO_CONTENT)) {
        msg.setLogMsg("Error sending message. URL: " + url + " ::: Response Code: " + rc + " " + resp.getStatusPhrase() + " ::: Response Message: " + resp.getBody().toString());
        logger.error(msg);
        throw new HttpResponseException(url, rc, resp.getStatusPhrase());
    }
    // So far so good ...
    processResponse(msg, resp);
}
 

public static boolean isAcceptRange(int responseCode, FileDownloadConnection connection) {
    if (responseCode == HttpURLConnection.HTTP_PARTIAL
            || responseCode == FileDownloadConnection.RESPONSE_CODE_FROM_OFFSET) return true;

    final String acceptRanges = connection.getResponseHeaderField("Accept-Ranges");
    return "bytes".equals(acceptRanges);
}
 

private InputStream readData(int offset, int length) throws IOException{
    HttpURLConnection conn = (HttpURLConnection) zipUrl.openConnection();
    conn.setDoOutput(false);
    conn.setUseCaches(false);
    conn.setInstanceFollowRedirects(false);
    String range = "-";
    if (offset != Integer.MAX_VALUE){
        range = offset + range;
    }
    if (length != Integer.MAX_VALUE){
        if (offset != Integer.MAX_VALUE){
            range = range + (offset + length - 1);
        }else{
            range = range + length;
        }
    }

    conn.setRequestProperty("Range", "bytes=" + range);
    conn.connect();
    if (conn.getResponseCode() == HttpURLConnection.HTTP_PARTIAL){
        return conn.getInputStream();
    }else if (conn.getResponseCode() == HttpURLConnection.HTTP_OK){
        throw new IOException("Your server does not support HTTP feature Content-Range. Please contact your server administrator.");
    }else{
        throw new IOException(conn.getResponseCode() + " " + conn.getResponseMessage());
    }
}
 

private InputStream readData(int offset, int length) throws IOException{
    HttpURLConnection conn = (HttpURLConnection) zipUrl.openConnection();
    conn.setDoOutput(false);
    conn.setUseCaches(false);
    conn.setInstanceFollowRedirects(false);
    String range = "-";
    if (offset != Integer.MAX_VALUE){
        range = offset + range;
    }
    if (length != Integer.MAX_VALUE){
        if (offset != Integer.MAX_VALUE){
            range = range + (offset + length - 1);
        }else{
            range = range + length;
        }
    }

    conn.setRequestProperty("Range", "bytes=" + range);
    conn.connect();
    if (conn.getResponseCode() == HttpURLConnection.HTTP_PARTIAL){
        return conn.getInputStream();
    }else if (conn.getResponseCode() == HttpURLConnection.HTTP_OK){
        throw new IOException("Your server does not support HTTP feature Content-Range. Please contact your server administrator.");
    }else{
        throw new IOException(conn.getResponseCode() + " " + conn.getResponseMessage());
    }
}
 

private void setResumeSupportedOrNot() {
    isResumeSupported = (responseCode == HttpURLConnection.HTTP_PARTIAL);
}
 

private boolean sendAsyncMDN(MessageMDN mdn, String url, DispositionType disposition, Map<Object, Object> options) throws OpenAS2Exception {

        Message msg = mdn.getMessage();
        try {
            // Create a HTTP connection
            if (logger.isDebugEnabled()) {
                logger.debug("ASYNC MDN attempting connection to: " + url + mdn.getMessage().getLogMsgID());
            }
            long maxSize = msg.getPartnership().getNoChunkedMaxSize();
            Map<String, String> httpOptions = getHttpOptions();
            httpOptions.put(HTTPUtil.PARAM_HTTP_USER, msg.getPartnership().getAttribute(HTTPUtil.PARAM_HTTP_USER));
            httpOptions.put(HTTPUtil.PARAM_HTTP_PWD, msg.getPartnership().getAttribute(HTTPUtil.PARAM_HTTP_PWD));
            ResponseWrapper resp = HTTPUtil.execRequest(HTTPUtil.Method.POST, url, mdn.getHeaders().getAllHeaders(), null, mdn.getData().getInputStream(), httpOptions, maxSize);

            int respCode = resp.getStatusCode();
            // Check the HTTP Response code
            if ((respCode != HttpURLConnection.HTTP_OK) && (respCode != HttpURLConnection.HTTP_CREATED) && (respCode != HttpURLConnection.HTTP_ACCEPTED) && (respCode != HttpURLConnection.HTTP_PARTIAL) && (respCode != HttpURLConnection.HTTP_NO_CONTENT)) {
                if (logger.isErrorEnabled()) {
                    msg.setLogMsg("Error sending AsyncMDN [" + disposition.toString() + "] HTTP response code: " + respCode);
                    logger.error(msg);
                }
                throw new HttpResponseException(url, respCode, resp.getStatusPhrase());
            }

            if (logger.isInfoEnabled()) {
                logger.info("sent AsyncMDN [" + disposition.toString() + "] OK " + msg.getLogMsgID());
            }

            // log & store mdn into backup folder.
            getSession().getProcessor().handle(StorageModule.DO_STOREMDN, msg, null);
            // Log significant msg state
            msg.setOption("STATE", Message.MSG_STATE_MSG_RXD_MDN_SENT_OK);
            msg.trackMsgState(getSession());

        } catch (HttpResponseException hre) {
            // Resend if the HTTP Response has an error code
            logger.warn("HTTP exception sending ASYNC MDN: " + org.openas2.logging.Log.getExceptionMsg(hre) + msg.getLogMsgID(), hre);
            hre.terminate();
            resend(msg, hre);
            // Log significant msg state
            msg.setOption("STATE", Message.MSG_STATE_MDN_SENDING_EXCEPTION);
            msg.trackMsgState(getSession());
            return false;
        } catch (IOException ioe) {
            logger.warn("IO exception sending ASYNC MDN: " + org.openas2.logging.Log.getExceptionMsg(ioe) + msg.getLogMsgID(), ioe);
            // Resend if a network error occurs during transmission
            WrappedException wioe = new WrappedException(ioe);
            wioe.addSource(OpenAS2Exception.SOURCE_MESSAGE, msg);
            wioe.terminate();

            resend(msg, wioe);
            // Log significant msg state
            msg.setOption("STATE", Message.MSG_STATE_MDN_SENDING_EXCEPTION);
            msg.trackMsgState(getSession());
            return false;
        } catch (Exception e) {
            logger.warn("Unexpected exception sending ASYNC MDN: " + org.openas2.logging.Log.getExceptionMsg(e) + msg.getLogMsgID(), e);
            // Propagate error if it can't be handled by a resend
            // log & store mdn into backup folder.
            getSession().getProcessor().handle(StorageModule.DO_STOREMDN, msg, null);
            // Log significant msg state
            msg.setOption("STATE", Message.MSG_STATE_MDN_SENDING_EXCEPTION);
            msg.trackMsgState(getSession());
            throw new WrappedException(e);
        }
        return true;
    }
 

@Override
public void run() {
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

    FileDownloadConnection connection = null;
    final long beginOffset = connectTask.getProfile().currentOffset;
    boolean isConnected = false;
    do {

        try {
            if (paused) {
                return;
            }

            isConnected = false;
            connection = connectTask.connect();
            final int code = connection.getResponseCode();

            if (FileDownloadLog.NEED_LOG) {
                FileDownloadLog
                        .d(this, "the connection[%d] for %d, is connected %s with code[%d]",
                                connectionIndex, downloadId, connectTask.getProfile(), code);
            }

            if (code != HttpURLConnection.HTTP_PARTIAL && code != HttpURLConnection.HTTP_OK) {
                throw new SocketException(FileDownloadUtils.
                        formatString(
                                "Connection failed with request[%s] response[%s] "
                                        + "http-state[%d] on task[%d-%d], which is changed"
                                        + " after verify connection, so please try again.",
                                connectTask.getRequestHeader(),
                                connection.getResponseHeaderFields(),
                                code, downloadId, connectionIndex));
            }

            isConnected = true;
            final FetchDataTask.Builder builder = new FetchDataTask.Builder();

            if (paused) return;
            fetchDataTask = builder
                    .setDownloadId(downloadId)
                    .setConnectionIndex(connectionIndex)
                    .setCallback(callback)
                    .setHost(this)
                    .setWifiRequired(isWifiRequired)
                    .setConnection(connection)
                    .setConnectionProfile(this.connectTask.getProfile())
                    .setPath(path)
                    .build();

            fetchDataTask.run();

            if (paused) fetchDataTask.pause();
            break;

        } catch (IllegalAccessException | IOException | FileDownloadGiveUpRetryException
                | IllegalArgumentException e) {
            if (callback.isRetry(e)) {
                if (isConnected && fetchDataTask == null) {
                    // connected but create fetch data task failed, give up directly.
                    FileDownloadLog.w(this, "it is valid to retry and connection is valid but"
                            + " create fetch-data-task failed, so give up directly with %s", e);
                    callback.onError(e);
                    break;
                } else {
                    if (fetchDataTask != null) {
                        //update currentOffset in ConnectionProfile
                        final long downloadedOffset = getDownloadedOffset();
                        if (downloadedOffset > 0) {
                            connectTask.updateConnectionProfile(downloadedOffset);
                        }
                    }
                    callback.onRetry(e);
                }
            } else {
                callback.onError(e);
                break;
            }

        } finally {
            if (connection != null) connection.ending();
        }
    } while (true);

}
 

/**
 * Map from HTTP status code to reason description.
 * Sentry HTTP breadcrumbs expect a text description of the HTTP status-code.
 * This function implements a look-up table with a default value for unknown status-codes.
 * @param statusCode an integer HTTP status code, expected to be in the range [200,505].
 * @return a non-empty string in all cases.
 */
private static String httpReason(int statusCode) {
    switch (statusCode) {
        // 2xx
        case HttpURLConnection.HTTP_OK: return "OK";
        case HttpURLConnection.HTTP_CREATED: return "Created";
        case HttpURLConnection.HTTP_ACCEPTED: return "Accepted";
        case HttpURLConnection.HTTP_NOT_AUTHORITATIVE: return "Non-Authoritative Information";
        case HttpURLConnection.HTTP_NO_CONTENT: return "No Content";
        case HttpURLConnection.HTTP_RESET: return "Reset Content";
        case HttpURLConnection.HTTP_PARTIAL: return "Partial Content";

        // 3xx
        case HttpURLConnection.HTTP_MULT_CHOICE: return "Multiple Choices";
        case HttpURLConnection.HTTP_MOVED_PERM: return "Moved Permanently";
        case HttpURLConnection.HTTP_MOVED_TEMP: return "Temporary Redirect";
        case HttpURLConnection.HTTP_SEE_OTHER: return "See Other";
        case HttpURLConnection.HTTP_NOT_MODIFIED: return "Not Modified";
        case HttpURLConnection.HTTP_USE_PROXY: return "Use Proxy";

        // 4xx
        case HttpURLConnection.HTTP_BAD_REQUEST: return "Bad Request";
        case HttpURLConnection.HTTP_UNAUTHORIZED: return "Unauthorized";
        case HttpURLConnection.HTTP_PAYMENT_REQUIRED: return "Payment Required";
        case HttpURLConnection.HTTP_FORBIDDEN: return "Forbidden";
        case HttpURLConnection.HTTP_NOT_FOUND: return "Not Found";
        case HttpURLConnection.HTTP_BAD_METHOD: return "Method Not Allowed";
        case HttpURLConnection.HTTP_NOT_ACCEPTABLE: return "Not Acceptable";
        case HttpURLConnection.HTTP_PROXY_AUTH: return "Proxy Authentication Required";
        case HttpURLConnection.HTTP_CLIENT_TIMEOUT: return "Request Time-Out";
        case HttpURLConnection.HTTP_CONFLICT: return "Conflict";
        case HttpURLConnection.HTTP_GONE: return "Gone";
        case HttpURLConnection.HTTP_LENGTH_REQUIRED: return "Length Required";
        case HttpURLConnection.HTTP_PRECON_FAILED: return "Precondition Failed";
        case HttpURLConnection.HTTP_ENTITY_TOO_LARGE: return "Request Entity Too Large";
        case HttpURLConnection.HTTP_REQ_TOO_LONG: return "Request-URI Too Large";
        case HttpURLConnection.HTTP_UNSUPPORTED_TYPE: return "Unsupported Media Type";

        // 5xx
        case HttpURLConnection.HTTP_INTERNAL_ERROR: return "Internal Server Error";
        case HttpURLConnection.HTTP_NOT_IMPLEMENTED: return "Not Implemented";
        case HttpURLConnection.HTTP_BAD_GATEWAY: return "Bad Gateway";
        case HttpURLConnection.HTTP_UNAVAILABLE: return "Service Unavailable";
        case HttpURLConnection.HTTP_GATEWAY_TIMEOUT: return "Gateway Timeout";
        case HttpURLConnection.HTTP_VERSION: return "Version Not Supported";

        default: return "unknown";
    }
}