Java Code Examples for org.apache.http.HttpStatus#SC_FORBIDDEN

@Override
public ActionResult execute() {
    String studentId = getNonNullRequestParamValue(Const.ParamsNames.STUDENT_ID);
    if (!studentId.equals(userInfo.id) && !isMasqueradeMode()) {
        return new JsonResult("You are not authorized to update this student's profile.",
                HttpStatus.SC_FORBIDDEN);
    }

    StudentProfileUpdateRequest updateRequest = getAndValidateRequestBody(StudentProfileUpdateRequest.class);

    try {
        StudentProfileAttributes studentProfile = sanitizeProfile(extractProfileData(studentId, updateRequest));
        logic.updateOrCreateStudentProfile(
                StudentProfileAttributes.updateOptionsBuilder(studentId)
                        .withShortName(studentProfile.shortName)
                        .withEmail(studentProfile.email)
                        .withGender(studentProfile.gender)
                        .withNationality(studentProfile.nationality)
                        .withInstitute(studentProfile.institute)
                        .withMoreInfo(studentProfile.moreInfo)
                        .build());
        return new JsonResult(Const.StatusMessages.STUDENT_PROFILE_EDITED, HttpStatus.SC_ACCEPTED);
    } catch (InvalidParametersException ipe) {
        return new JsonResult(ipe.getMessage(), HttpStatus.SC_BAD_REQUEST);
    }
}
 

private BuildInfo handleBuildInfoResponse(String appName, ObjectMapper mapper, CloseableHttpResponse response) throws IOException, HerokuDeployApiException {
    switch (response.getStatusLine().getStatusCode()) {
        case HttpStatus.SC_NOT_FOUND:
            throw new AppNotFoundException(String.format("App %s could not be found!", appName));

        case HttpStatus.SC_FORBIDDEN:
            throw new InsufficientAppPermissionsException(String.format("Could not access app %s: insufficient permissions", appName));

        case HttpStatus.SC_OK:
        case HttpStatus.SC_CREATED:
            HttpEntity responseEntity = response.getEntity();
            String responseStringBody = Util.readLinesFromInputStream(responseEntity.getContent()).collect(Collectors.joining());

            return mapper.readValue(responseStringBody, BuildInfo.class);

        default:
            throw new HerokuDeployApiException(String.format("Unexpected status code: %d!", response.getStatusLine().getStatusCode()));
    }
}
 

private void throwExceptionOnBadResponse( Response response ) throws FileSystemException {
  final int status = response.getStatus();
  switch ( status ) {
    case HttpStatus.SC_OK:
      logger.debug( "OK" );
      // response OK => do not throw exception and continue execution
      break;

    case HttpStatus.SC_UNAUTHORIZED:
    case HttpStatus.SC_FORBIDDEN:
    case HttpStatus.SC_MOVED_TEMPORARILY:
      logger.debug( "FORBIDDEN" );
      throw new FileSystemException( INVALID_USERNAME_OR_PASSWORD );

    default:
      logger.debug( "ERROR " + status );
      throw new FileSystemException( BAD_RESPONSE, status );
  }
}
 

private boolean disabledSkill403(CloseableHttpResponse response) throws IOException {
   if(response.getStatusLine().getStatusCode() != HttpStatus.SC_FORBIDDEN) {
      return false;
   }
   HttpEntity entity = null;
   try {
      entity = response.getEntity();
      Map<String, Object> body = JSON.fromJson(EntityUtils.toString(entity, StandardCharsets.UTF_8), ERR_TYPE);
      boolean disabled = StringUtils.equals("skill_not_enabled", (String) body.get("error"));
      if(disabled) {
         logger.warn("disabled skill due to 403 error with body {}", body);
      }
      return disabled;
   } finally {
      consumeQuietly(entity);
   }
}
 

@Override
public BackgroundException map(final IOException failure) {
    final StringBuilder buffer = new StringBuilder();
    if(failure instanceof GoogleJsonResponseException) {
        final GoogleJsonResponseException error = (GoogleJsonResponseException) failure;
        if(error.getDetails() != null) {
            this.append(buffer, error.getDetails().getMessage());
            switch(error.getDetails().getCode()) {
                case HttpStatus.SC_FORBIDDEN:
                    final List<GoogleJsonError.ErrorInfo> errors = error.getDetails().getErrors();
                    for(GoogleJsonError.ErrorInfo info : errors) {
                        if("usageLimits".equals(info.getDomain())) {
                            return new RetriableAccessDeniedException(buffer.toString(), Duration.ofSeconds(5), failure);
                        }
                    }
                    break;
            }
        }
    }
    if(failure instanceof HttpResponseException) {
        final HttpResponseException response = (HttpResponseException) failure;
        this.append(buffer, response.getStatusMessage());
        return new DefaultHttpResponseExceptionMappingService().map(new org.apache.http.client
            .HttpResponseException(response.getStatusCode(), buffer.toString()));
    }
    return super.map(failure);
}
 

public static SuccessResponse updateMemberRank(UpdateRankRequest updateRankRequest) {
    try {
        Request request = Request.Post(API_URL + "rank/update");
        request.addHeader(AUTH_HEADER_KEY, "Bearer " + Session.get().getApiToken());
        request.bodyString(GSON.toJson(updateRankRequest), ContentType.APPLICATION_JSON);
        HttpResponse response = Executor.newInstance(HttpUtil.getClient()).execute(request).returnResponse();

        if (response != null) {
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                byte[] bytes = EntityUtils.toByteArray(response.getEntity());
                return GSON.fromJson(new String(bytes), SuccessResponse.class);
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_FAILED_DEPENDENCY) {
                NotificationsUtil.showNotification("Clan", "You aren't allowed to update ranks");
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_NOT_FOUND) {
                NotificationsUtil.showNotification("Clan", "Unable to find clan/rank");
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_FORBIDDEN) {
                NotificationsUtil.showNotification("Clan", "Unable to find clan rank");
            } else {
                NotificationsUtil.showNotification("Clan", "Error updating clan");
            }
        }
        return null;
    } catch (IOException e) {
        logger.error("Error updating member clan rank", e);
        return null;
    }
}
 

public static ClanInfo updateRank(String loginName, String ingameName, ClanInfo clan, ClanRank.Status status, int world) {
    try {
        Request request = Request.Post(API_URL + "rank/update/id");
        request.addHeader(AUTH_HEADER_KEY, "Bearer " + Session.get().getApiToken());
        request.bodyString(GSON.toJson(new GetOrJoinClanRequest(
                clan.getClanId(),
                loginName,
                ingameName,
                clan.getName(),
                status,
                world
        )), ContentType.APPLICATION_JSON);
        HttpResponse response = Executor.newInstance(HttpUtil.getClient()).execute(request).returnResponse();

        if (response != null) {
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                byte[] bytes = EntityUtils.toByteArray(response.getEntity());
                return GSON.fromJson(new String(bytes), ClanInfo.class);
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_FAILED_DEPENDENCY) {
                NotificationsUtil.showNotification("Clan", "You have not yet been accepted into this clan");
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_NOT_FOUND) {
                NotificationsUtil.showNotification("Clan", "Unable to find clan");
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_FORBIDDEN) {
                NotificationsUtil.showNotification("Clan", "You have been banned from this clan");
            } else {
                NotificationsUtil.showNotification("Clan", "Error updating clan");
            }
        }
        return null;
    } catch (IOException e) {
        logger.error("Error updating clan rank", e);
        return null;
    }
}
 

public static ClanInfo join(String loginName, String ingameName, String clanName, long clanId, boolean useId, ClanRank.Status status, int world) {
    try {
        Request request = Request.Post(API_URL + "rank/update/" + (useId ? "id" : "name"));
        request.addHeader(AUTH_HEADER_KEY, "Bearer " + Session.get().getApiToken());
        request.bodyString(GSON.toJson(new GetOrJoinClanRequest(
                clanId,
                loginName,
                ingameName,
                clanName,
                status,
                world
        )), ContentType.APPLICATION_JSON);
        HttpResponse response = Executor.newInstance(HttpUtil.getClient()).execute(request).returnResponse();

        if (response != null) {
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                byte[] bytes = EntityUtils.toByteArray(response.getEntity());
                return GSON.fromJson(new String(bytes), ClanInfo.class);
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_FAILED_DEPENDENCY) {
                NotificationsUtil.showNotification("Clan", "You have not yet been accepted into this clan");
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_NOT_FOUND) {
                NotificationsUtil.showNotification("Clan", "Unable to find clan");
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_FORBIDDEN) {
                NotificationsUtil.showNotification("Clan", "You have been banned from this clan");
            } else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_EXPECTATION_FAILED) {
                NotificationsUtil.showNotification("Clan", "You have been denied access into this clan");
            } else {
                NotificationsUtil.showNotification("Clan", "Error joining clan");
            }
        }
        return null;
    } catch (IOException e) {
        logger.error("Error joining clan", e);
        return null;
    }
}
 

@Override
public AuthenticationResponse handleResponse(final HttpResponse response) throws IOException {
    if(response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        Charset charset = HTTP.DEF_CONTENT_CHARSET;
        ContentType contentType = ContentType.get(response.getEntity());
        if(contentType != null) {
            if(contentType.getCharset() != null) {
                charset = contentType.getCharset();
            }
        }
        try {
            final JsonObject json = JsonParser.parseReader(new InputStreamReader(response.getEntity().getContent(), charset)).getAsJsonObject();
            final String token = json.getAsJsonPrimitive("token").getAsString();
            final String endpoint = json.getAsJsonPrimitive("endpoint").getAsString();
            return new AuthenticationResponse(response, token,
                    Collections.singleton(new Region(null, URI.create(endpoint), null, true)));
        }
        catch(JsonParseException e) {
            throw new IOException(e.getMessage(), e);
        }
    }
    else if(response.getStatusLine().getStatusCode() == HttpStatus.SC_UNAUTHORIZED
            || response.getStatusLine().getStatusCode() == HttpStatus.SC_FORBIDDEN) {
        throw new AuthorizationException(new Response(response));
    }
    throw new GenericException(new Response(response));
}
 

@Test
public void testInvalidCredentials_JSONRPC() throws Exception {
    HttpCallable c = new HttpCallable("json-rpc mixed", RPC_ENDPOINT, MIXED_JSONRPC, HttpStatus.SC_FORBIDDEN);
    Map<String, String> headers = new HashMap<String, String>();
    headers.put("X-Token-Username", "INVALID");
    String result = makeRequest(c, null, 0, "RPC", headers, null);

    // check result is OK
    assertTrue("Error returned: "+result, result.contains("error"));
    assertTrue("Error returned: "+result, result.contains("-32099"));
    assertTrue("Error returned: "+result, result.contains("DSC-0015"));
}
 

private static String handleResponse(HttpResponse response, String methodName, boolean retry, int executionCount,
                                     int retryCount, String uri) throws OnPremiseGatewayException {
    switch (response.getStatusLine().getStatusCode()) {
        case HttpStatus.SC_OK:
            return handleSuccessCase(response);

        case HttpStatus.SC_CREATED:
            return handleSuccessCase(response);

        case HttpStatus.SC_ACCEPTED:
            return handleSuccessCase(response);

        case HttpStatus.SC_NOT_FOUND:
            throw new OnPremiseGatewayException(NOT_FOUND_ERROR_MSG);

        case HttpStatus.SC_UNAUTHORIZED:
            throw new OnPremiseGatewayException(AUTH_ERROR_MSG);

        case HttpStatus.SC_FORBIDDEN:
            throw new OnPremiseGatewayException(AUTH_FORBIDDEN_ERROR_MSG);

        default:
            if (retry) {
                handleDefaultCaseWithRetry(executionCount, response, retryCount, methodName, uri);
            } else {
                throw new OnPremiseGatewayException(
                        methodName + " request failed for URI: " + uri + " with HTTP error code : " + response);
            }
    }
    return OnPremiseGatewayConstants.EMPTY_STRING;
}
 

@Override
public BackgroundException map(final FailedRequestException e) {
    final StringBuilder buffer = new StringBuilder();
    if(null != e.getError()) {
        this.append(buffer, e.getError().getMessage());
    }
    switch(e.getStatusCode()) {
        case HttpStatus.SC_FORBIDDEN:
            if(null != e.getError()) {
                if(StringUtils.isNotBlank(e.getError().getCode())) {
                    switch(e.getError().getCode()) {
                        case "SignatureDoesNotMatch":
                            return new LoginFailureException(buffer.toString(), e);
                        case "InvalidAccessKeyId":
                            return new LoginFailureException(buffer.toString(), e);
                        case "InvalidClientTokenId":
                            return new LoginFailureException(buffer.toString(), e);
                        case "InvalidSecurity":
                            return new LoginFailureException(buffer.toString(), e);
                        case "MissingClientTokenId":
                            return new LoginFailureException(buffer.toString(), e);
                        case "MissingAuthenticationToken":
                            return new LoginFailureException(buffer.toString(), e);
                    }
                }
            }
    }
    if(e.getCause() instanceof IOException) {
        return new DefaultIOExceptionMappingService().map((IOException) e.getCause());
    }
    return new DefaultHttpResponseExceptionMappingService().map(new HttpResponseException(e.getStatusCode(), buffer.toString()));
}
 

protected String parseClientLoginResponse(HttpResponse response) throws
    AuthClientException, IOException {
    int status = response.getStatusLine().getStatusCode();
    if (status != HttpStatus.SC_OK && status != HttpStatus.SC_FORBIDDEN) {
        throw new AuthClientException("Unexpected ClientLogin HTTP status " + status);
    }

    String body = EntityUtils.toString(response.getEntity());
    Map<String, String> responseMap = parseClientLoginBody(body);

    if (status == HttpStatus.SC_OK) {
        String authToken = responseMap.get("Auth");
        if (authToken == null) {
            throw new AuthClientException("Auth token missing from ClientLogin response");
        }
        return authToken;
    } else {
        String message = "ClientLogin forbidden";
        // Base error code (eg. BadAuthentication)
        String error = responseMap.get("Error");
        if (error != null) {
            message += ": " + error;
        }
        // Additional error code, not usually present (eg. InvalidSecondFactor)
        String info = responseMap.get("Info");
        if (info != null) {
            message += " (" + info + ")";
        }
        throw new AuthClientException(message);
    }
}
 

@Override
public BackgroundException map(final ServiceException e) {
    if(e.getCause() instanceof ServiceException) {
        return this.map((ServiceException) e.getCause());
    }
    final StringBuilder buffer = new StringBuilder();
    if(StringUtils.isNotBlank(e.getErrorMessage())) {
        // S3 protocol message parsed from XML
        this.append(buffer, StringEscapeUtils.unescapeXml(e.getErrorMessage()));
    }
    else {
        this.append(buffer, e.getResponseStatus());
        this.append(buffer, e.getMessage());
    }
    switch(e.getResponseCode()) {
        case HttpStatus.SC_FORBIDDEN:
            if(StringUtils.isNotBlank(e.getErrorCode())) {
                switch(e.getErrorCode()) {
                    case "SignatureDoesNotMatch":
                    case "InvalidAccessKeyId":
                    case "InvalidClientTokenId":
                    case "InvalidSecurity":
                    case "MissingClientTokenId":
                    case "MissingAuthenticationToken":
                        return new LoginFailureException(buffer.toString(), e);
                }
            }
        case HttpStatus.SC_BAD_REQUEST:
            if(StringUtils.isNotBlank(e.getErrorCode())) {
                switch(e.getErrorCode()) {
                    case "RequestTimeout":
                        return new ConnectionTimeoutException(buffer.toString(), e);
                    case "ExpiredToken":
                    case "InvalidToken":
                        return new ExpiredTokenException(buffer.toString(), e);
                }
            }
    }
    if(e.getCause() instanceof IOException) {
        return new DefaultIOExceptionMappingService().map((IOException) e.getCause());
    }
    if(e.getCause() instanceof SAXException) {
        return new InteroperabilityException(buffer.toString(), e);
    }
    if(-1 == e.getResponseCode()) {
        return new InteroperabilityException(buffer.toString(), e);
    }
    return new DefaultHttpResponseExceptionMappingService().map(new HttpResponseException(e.getResponseCode(), buffer.toString()));
}
 

private int computeStatus(int status) {
    switch (status) { 
        case HttpStatus.SC_FORBIDDEN:
        case HttpStatus.SC_METHOD_NOT_ALLOWED:
        case HttpStatus.SC_BAD_REQUEST:
        case HttpStatus.SC_UNAUTHORIZED:
        case HttpStatus.SC_PAYMENT_REQUIRED:
        case HttpStatus.SC_NOT_FOUND:
        case HttpStatus.SC_NOT_ACCEPTABLE:
        case HttpStatus.SC_PROXY_AUTHENTICATION_REQUIRED:
        case HttpStatus.SC_REQUEST_TIMEOUT:
        case HttpStatus.SC_CONFLICT:
        case HttpStatus.SC_GONE:
        case HttpStatus.SC_LENGTH_REQUIRED:
        case HttpStatus.SC_PRECONDITION_FAILED:
        case HttpStatus.SC_REQUEST_TOO_LONG:
        case HttpStatus.SC_REQUEST_URI_TOO_LONG:
        case HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE:
        case HttpStatus.SC_REQUESTED_RANGE_NOT_SATISFIABLE:
        case HttpStatus.SC_EXPECTATION_FAILED:
        case HttpStatus.SC_INSUFFICIENT_SPACE_ON_RESOURCE:
        case HttpStatus.SC_METHOD_FAILURE:
        case HttpStatus.SC_UNPROCESSABLE_ENTITY:
        case HttpStatus.SC_LOCKED:
        case HttpStatus.SC_FAILED_DEPENDENCY:
        case HttpStatus.SC_INTERNAL_SERVER_ERROR:
        case HttpStatus.SC_NOT_IMPLEMENTED:
        case HttpStatus.SC_BAD_GATEWAY:
        case HttpStatus.SC_SERVICE_UNAVAILABLE:
        case HttpStatus.SC_GATEWAY_TIMEOUT:
        case HttpStatus.SC_HTTP_VERSION_NOT_SUPPORTED:
        case HttpStatus.SC_INSUFFICIENT_STORAGE:
            return 0;
        case HttpStatus.SC_CONTINUE:
        case HttpStatus.SC_SWITCHING_PROTOCOLS:
        case HttpStatus.SC_PROCESSING:
        case HttpStatus.SC_OK:
        case HttpStatus.SC_CREATED:
        case HttpStatus.SC_ACCEPTED:
        case HttpStatus.SC_NON_AUTHORITATIVE_INFORMATION:
        case HttpStatus.SC_NO_CONTENT:
        case HttpStatus.SC_RESET_CONTENT:
        case HttpStatus.SC_PARTIAL_CONTENT:
        case HttpStatus.SC_MULTI_STATUS:
        case HttpStatus.SC_MULTIPLE_CHOICES:
        case HttpStatus.SC_MOVED_PERMANENTLY:
        case HttpStatus.SC_MOVED_TEMPORARILY:
        case HttpStatus.SC_SEE_OTHER:
        case HttpStatus.SC_NOT_MODIFIED:
        case HttpStatus.SC_USE_PROXY:
        case HttpStatus.SC_TEMPORARY_REDIRECT:
            return 1;
        default : 
            return 1;
    }
}
 

private synchronized void doHeartbeat() throws BazaarManagerException
{
    log.info( "Heartbeat - START" );

    inProgress = true;

    lastSentMillis = System.currentTimeMillis();

    fastModeLeft--;

    try
    {
        String url = path + RandomStringUtils.randomNumeric( 7 );

        RestResult<HeartbeatResponseDto> restResult = restClient.post( url, null, HeartbeatResponseDto.class );

        if ( RestClient.CONNECTION_EXCEPTION_MARKER.equals( restResult.getError() ) )
        {
            throw new IllegalStateException( RestClient.CONNECTION_EXCEPTION_MARKER );
        }

        if ( !restResult.isSuccess() )
        {
            if ( restResult.getStatus() == HttpStatus.SC_FORBIDDEN && !isRegisteredWithBazaar() )
            {
                log.warn( "Local peer {} is not registered with Bazaar, deleting registration record from db",
                        peerId );

                bazaarManager.getConfigDataService().deleteConfig( peerId );
            }
            else
            {
                throw new BazaarManagerException( "Error to send heartbeat: " + restResult.getError() );
            }
        }

        HeartbeatResponseDto dto = restResult.getEntity();

        processStateLinks( dto.getStateLinks() );
    }
    catch ( Exception e )
    {
        throw new BazaarManagerException( e.getMessage(), e );
    }
    finally
    {
        inProgress = false;
    }

    log.info( "Heartbeat - END" );
}
 

@Override
public Map<String, String> handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
	StatusLine statusLine = response.getStatusLine();
	if (statusLine.getStatusCode() >= 300) {
		int statusCode = statusLine.getStatusCode();
		if (statusCode == HttpStatus.SC_FORBIDDEN
			&& (sp == ServiceProvider.Sina
				|| sp == ServiceProvider.NetEase)) {
			//在使用XAuth认证方式下，若用户名或密码错误，新浪、网易的响应是403，搜狐的是401，统一为401
			statusCode = HttpStatus.SC_UNAUTHORIZED;
		}
		
		if (sp == ServiceProvider.Tencent
			&& HttpStatus.SC_BAD_REQUEST == statusCode
			&& "Bad Request: Unsupported parameter".equals(statusLine.getReasonPhrase())){
			statusCode = LibResultCode.OAUTH_TIMESTAMP_REFUSED;
		}
		
		throw new LibRuntimeException(statusCode);
	}

	Map<String, String> resultMap = new HashMap<String, String>();
	HttpEntity entity = response.getEntity();
	final String responseString = EntityUtils.toString(entity);

	Logger.debug("FormEncodedResponseHandler : {}", responseString);

	Scanner scanner = new Scanner(responseString);
	scanner.useDelimiter("&");
	while (scanner.hasNext()) {
           final String[] nameValue = scanner.next().split("=");
           if (nameValue.length == 0 || nameValue.length > 2){
           	 throw new LibRuntimeException(LibResultCode.E_PARAM_ERROR, "", "Bad Parameter", ServiceProvider.None);
           }

           final String name = nameValue[0];
           String value = null;
           if (nameValue.length == 2){
           	value = nameValue[1];
           }
           resultMap.put(name, value);
       }
	return resultMap;
}
 

public NotAllowedException(String s) {
    super(HttpStatus.SC_FORBIDDEN, ErrCode, s);
}
 

public static FetchStatus mapHttpStatusToFetchStatus(int httpStatus) {
    switch (httpStatus) {
        case HttpStatus.SC_OK:
            return FetchStatus.FETCHED;

        case HttpStatus.SC_FORBIDDEN:
            return FetchStatus.HTTP_FORBIDDEN;

        case HttpStatus.SC_UNAUTHORIZED:
        case HttpStatus.SC_PROXY_AUTHENTICATION_REQUIRED:
            return FetchStatus.HTTP_UNAUTHORIZED;

        case HttpStatus.SC_NOT_FOUND:
            return FetchStatus.HTTP_NOT_FOUND;

        case HttpStatus.SC_GONE:
            return FetchStatus.HTTP_GONE;

        case HttpStatus.SC_TEMPORARY_REDIRECT:
        case HttpStatus.SC_MOVED_TEMPORARILY:
        case HttpStatus.SC_SEE_OTHER:
            return FetchStatus.HTTP_TOO_MANY_REDIRECTS;

        case HttpStatus.SC_MOVED_PERMANENTLY:
            return FetchStatus.HTTP_MOVED_PERMANENTLY;

        default:
            if (httpStatus < 300) {
                LOGGER.warn("Invalid HTTP status for exception: " + httpStatus);
                return FetchStatus.HTTP_SERVER_ERROR;
            } else if (httpStatus < 400) {
                return FetchStatus.HTTP_REDIRECTION_ERROR;
            } else if (httpStatus < 500) {
                return FetchStatus.HTTP_CLIENT_ERROR;
            } else if (httpStatus < 600) {
                return FetchStatus.HTTP_SERVER_ERROR;
            } else {
                LOGGER.warn("Unknown status: " + httpStatus);
                return FetchStatus.HTTP_SERVER_ERROR;
            }
    }
}
 

/**
 * HttpResponseException with 403 forbidden status.
 *
 * @param message exception message
 */
public HttpForbiddenException(String message) {
    super(HttpStatus.SC_FORBIDDEN, message);
}