下面列出了java.net.HttpURLConnection#HTTP_UNAVAILABLE 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
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));
}
}
/**
* Verifies that an attempt to open a command consumer fails if the peer
* rejects to open a receiver link.
*
* @param ctx The test context.
*/
@Test
public void testCreateCommandConsumerFailsIfPeerRejectsLink(final VertxTestContext ctx) {
final Handler<CommandContext> commandHandler = VertxMockSupport.mockHandler();
final ServerErrorException ex = new ServerErrorException(HttpURLConnection.HTTP_UNAVAILABLE);
when(connection.createReceiver(
anyString(),
any(ProtonQoS.class),
any(ProtonMessageHandler.class),
anyInt(),
anyBoolean(),
VertxMockSupport.anyHandler()))
.thenReturn(Future.failedFuture(ex));
commandConsumerFactory.createCommandConsumer(tenantId, deviceId, commandHandler, null, null)
.onComplete(ctx.failing(t -> {
ctx.verify(() -> assertThat(((ServiceInvocationException) t).getErrorCode()).isEqualTo(HttpURLConnection.HTTP_UNAVAILABLE));
ctx.completeNow();
}));
}
private static MqttConnectReturnCode getConnectReturnCode(final Throwable e) {
if (e instanceof MqttConnectionException) {
return ((MqttConnectionException) e).code();
} else if (e instanceof ServiceInvocationException) {
switch (((ServiceInvocationException) e).getErrorCode()) {
case HttpURLConnection.HTTP_UNAUTHORIZED:
case HttpURLConnection.HTTP_NOT_FOUND:
return MqttConnectReturnCode.CONNECTION_REFUSED_BAD_USER_NAME_OR_PASSWORD;
case HttpURLConnection.HTTP_UNAVAILABLE:
return MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE;
default:
return MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED;
}
} else {
return MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED;
}
}
private SaslOutcome getSaslOutcomeForErrorStatus(final int status) {
final SaslOutcome saslOutcome;
switch (status) {
case HttpURLConnection.HTTP_BAD_REQUEST:
case HttpURLConnection.HTTP_UNAUTHORIZED:
// failed due to an authentication error
saslOutcome = SaslOutcome.PN_SASL_AUTH;
break;
case HttpURLConnection.HTTP_INTERNAL_ERROR:
// failed due to a system error
saslOutcome = SaslOutcome.PN_SASL_SYS;
break;
case HttpURLConnection.HTTP_UNAVAILABLE:
// failed due to a transient error
saslOutcome = SaslOutcome.PN_SASL_TEMP;
break;
default:
if (status >= 400 && status < 500) {
// client error
saslOutcome = SaslOutcome.PN_SASL_PERM;
} else {
saslOutcome = SaslOutcome.PN_SASL_TEMP;
}
}
return saslOutcome;
}
private ServiceInvocationException getServiceInvocationException(final Throwable error) {
if (error instanceof ServiceInvocationException) {
return (ServiceInvocationException) error;
} else if (error instanceof ReplyException) {
final ReplyException ex = (ReplyException) error;
switch (ex.failureType()) {
case TIMEOUT:
return new ServerErrorException(
HttpURLConnection.HTTP_UNAVAILABLE,
"request could not be processed at the moment");
default:
return new ServerErrorException(HttpURLConnection.HTTP_INTERNAL_ERROR);
}
} else {
return new ServerErrorException(HttpURLConnection.HTTP_INTERNAL_ERROR);
}
}
/**
* Verifies that the handler returns the status code conveyed in a
* failed {@code AuthProvider} invocation in the response.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testHandleFailsWithStatusCodeFromAuthProvider() {
// GIVEN an auth handler configured with an auth provider that
// fails with a 503 error code during authentication
final ServiceInvocationException error = new ServerErrorException(HttpURLConnection.HTTP_UNAVAILABLE);
doAnswer(invocation -> {
final Handler handler = invocation.getArgument(1);
handler.handle(Future.failedFuture(error));
return null;
}).when(authProvider).authenticate(any(JsonObject.class), any(Handler.class));
// WHEN trying to authenticate a request using the HTTP BASIC scheme
final String authorization = new StringBuffer()
.append("BASIC ")
.append(Base64.getEncoder().encodeToString("user:password".getBytes(StandardCharsets.UTF_8)))
.toString();
final MultiMap headers = mock(MultiMap.class);
when(headers.get(eq(HttpHeaders.AUTHORIZATION))).thenReturn(authorization);
final HttpServerRequest req = mock(HttpServerRequest.class);
when(req.headers()).thenReturn(headers);
final HttpServerResponse resp = mock(HttpServerResponse.class);
final RoutingContext ctx = mock(RoutingContext.class);
when(ctx.request()).thenReturn(req);
when(ctx.response()).thenReturn(resp);
authHandler.handle(ctx);
// THEN the request context is failed with the 503 error code
verify(ctx).fail(error);
}
@JsonIgnore
default int getSuggestedHTTPStatusCode() {
switch (getResult()) {
case OK:
case WARNING:
return HttpURLConnection.HTTP_OK;
case UNKNOWN:
default:
case UNAVAILABLE:
case ERROR:
case CRITICAL:
case MAINTENANCE:
return HttpURLConnection.HTTP_UNAVAILABLE;
}
}
@Test
public void testThrottledRequest() throws Exception {
final String rawResponse = loadTestFile("Throttled.xml");
final ResponseData response = new ResponseData(HttpURLConnection.HTTP_UNAVAILABLE, rawResponse);
try {
Parser.marshalXML(ErrorResponse.class, response);
Assert.fail();
} catch (AmazonServiceException e) {
Assert.assertEquals(e.getResponseXml(), rawResponse);
Assert.assertEquals(e.getStatusCode(), HttpURLConnection.HTTP_UNAVAILABLE);
Assert.assertEquals(e.getErrorCode(), "RequestThrottled");
Assert.assertEquals(e.getRequestId(), "d702fd8e-206f-4da4-95e0-1e7422474077");
}
}
private void getVisitCookie(String url, String ua) throws IOException {
URL connUrl = new URL(url);
mGetMainConn = (HttpURLConnection) connUrl.openConnection();
mGetMainConn.setRequestMethod("GET");
mGetMainConn.setConnectTimeout(CONN_TIMEOUT);
mGetMainConn.setReadTimeout(CONN_TIMEOUT);
mGetMainConn.setRequestProperty("user-agent",ua);
mGetMainConn.setRequestProperty("accept",ACCEPT);
mGetMainConn.setRequestProperty("referer", url);
if (mCookieList!=null&&mCookieList.size()>0){
mGetMainConn.setRequestProperty("cookie", ConvertUtil.listToString(mCookieList));
}
mGetMainConn.setUseCaches(false);
mGetMainConn.connect();
switch (mGetMainConn.getResponseCode()){
case HttpURLConnection.HTTP_OK:
if (mCookieList == null || mCookieList.size() == 0){
mCookieList = mCookieManager.getCookieStore().getCookies();
checkCookie(mCookieList);
}
canVisit = true;
break;
case HttpURLConnection.HTTP_MOVED_PERM:
case HttpURLConnection.HTTP_MOVED_TEMP:
hasNewUrl = true;
break;
case HttpURLConnection.HTTP_FORBIDDEN:
case HttpURLConnection.HTTP_UNAVAILABLE:
break;
default:
LogUtil.e("MainUrl","UnCatch Http code: "+mGetMainConn.getResponseCode());
break;
}
}
public byte[] send(byte[] request) {
// TODO back-off policy?
while (true) {
try {
final HttpURLConnection connection = openConnection();
connection.setRequestMethod("POST");
connection.setDoInput(true);
connection.setDoOutput(true);
try (DataOutputStream wr = new DataOutputStream(connection.getOutputStream())) {
wr.write(request);
wr.flush();
wr.close();
}
final int responseCode = connection.getResponseCode();
final InputStream inputStream;
if (responseCode == HttpURLConnection.HTTP_UNAVAILABLE) {
// Could be sitting behind a load-balancer, try again.
continue;
} else if (responseCode != HttpURLConnection.HTTP_OK) {
inputStream = connection.getErrorStream();
if (inputStream == null) {
// HTTP Transport exception that resulted in no content coming back
throw new RuntimeException("Failed to read data from the server: HTTP/" + responseCode);
}
} else {
inputStream = connection.getInputStream();
}
return AvaticaUtils.readFullyToBytes(inputStream);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
private void failConnectionAttempt(final Throwable connectionFailureCause, final Handler<AsyncResult<HonoConnection>> connectionHandler) {
log.info("stopping connection attempt to server [{}:{}, role: {}] due to terminal error",
connectionFactory.getHost(),
connectionFactory.getPort(),
connectionFactory.getServerRole(),
connectionFailureCause);
final ServiceInvocationException serviceInvocationException;
if (connectionFailureCause == null) {
serviceInvocationException = new ServerErrorException(HttpURLConnection.HTTP_UNAVAILABLE,
"failed to connect");
} else if (connectionFailureCause instanceof AuthenticationException) {
// wrong credentials?
serviceInvocationException = new ClientErrorException(HttpURLConnection.HTTP_UNAUTHORIZED,
"failed to authenticate with server");
} else if (connectionFailureCause instanceof MechanismMismatchException) {
serviceInvocationException = new ClientErrorException(HttpURLConnection.HTTP_UNAUTHORIZED,
"no suitable SASL mechanism found for authentication with server");
} else if (connectionFailureCause instanceof SSLException) {
serviceInvocationException = new ClientErrorException(HttpURLConnection.HTTP_BAD_REQUEST,
"TLS handshake with server failed: " + connectionFailureCause.getMessage(), connectionFailureCause);
} else {
serviceInvocationException = new ServerErrorException(HttpURLConnection.HTTP_UNAVAILABLE,
"failed to connect", connectionFailureCause);
}
connectionHandler.handle(Future.failedFuture(serviceInvocationException));
}
/**
* Verifies that the handler returns the status code conveyed in a
* failed Tenant service invocation in the response.
*
* @param ctx The vert.x test context.
* @throws SSLPeerUnverifiedException if the client certificate cannot be determined.
*/
@Test
public void testHandleFailsWithStatusCodeFromAuthProvider(final VertxTestContext ctx) throws SSLPeerUnverifiedException {
// GIVEN an auth handler configured with an auth provider that
// fails with a 503 error code during authentication
final ServiceInvocationException error = new ServerErrorException(HttpURLConnection.HTTP_UNAVAILABLE);
when(clientAuth.validateClientCertificate(any(Certificate[].class), (SpanContext) any())).thenReturn(Future.failedFuture(error));
// WHEN trying to authenticate a request that contains a client certificate
final X509Certificate clientCert = getClientCertificate("CN=device", "CN=tenant");
final SSLSession sslSession = mock(SSLSession.class);
when(sslSession.getPeerCertificates()).thenReturn(new X509Certificate[] { clientCert });
final MqttEndpoint endpoint = mock(MqttEndpoint.class);
when(endpoint.isSsl()).thenReturn(true);
when(endpoint.sslSession()).thenReturn(sslSession);
final MqttContext context = MqttContext.fromConnectPacket(endpoint);
authHandler.authenticateDevice(context)
// THEN the request context is failed with the 503 error code
.onComplete(ctx.failing(t -> {
ctx.verify(() -> {
assertThat(t).isEqualTo(error);
});
ctx.completeNow();
}));
}
public void testError()
{
for(int i = 0; i < 600; ++i)
{
RuntimeException e = OsmApiErrorFactory.createError(i, "test", "description");
if(i >= 400 && i < 500) assertTrue(e instanceof OsmApiException);
else assertTrue(e instanceof OsmConnectionException);
switch(i)
{
case HttpURLConnection.HTTP_UNAVAILABLE:
assertTrue(e instanceof OsmServiceUnavailableException);
break;
case HttpURLConnection.HTTP_NOT_FOUND:
case HttpURLConnection.HTTP_GONE:
assertTrue(e instanceof OsmNotFoundException);
break;
case HttpURLConnection.HTTP_FORBIDDEN:
assertTrue(e instanceof OsmAuthorizationException);
break;
case HttpURLConnection.HTTP_CONFLICT:
assertTrue(e instanceof OsmConflictException);
break;
case HttpURLConnection.HTTP_BAD_REQUEST:
assertTrue(e instanceof OsmBadUserInputException);
break;
}
}
}
public MetricRegistryJson fetchLatestAggregatedMetrics(
PipelineConfiguration pipelineConfiguration,
RuleDefinitionsJson ruleDefJson,
List<Stage.ConfigIssue> issues
) {
// fetch last persisted metrics for the following counters, timers, meters and histograms
MetricRegistryJson metricRegistryJson = buildMetricRegistryJson(pipelineConfiguration, ruleDefJson);
client = ClientBuilder.newBuilder().build();
client.register(new CsrfProtectionFilter("CSRF"));
client.register(GZipEncoder.class);
target = client.target(targetUrl);
Entity<MetricRegistryJson> metricRegistryJsonEntity = Entity.json(metricRegistryJson);
String errorResponseMessage = null;
int delaySecs = 1;
int attempts = 0;
// Wait for a few random seconds before starting the stopwatch
int waitSeconds = new Random().nextInt(60);
try {
Thread.sleep(waitSeconds * 1000);
} catch (InterruptedException e) {
// No-op
}
while (attempts < retryAttempts || retryAttempts == -1) {
if (attempts > 0) {
delaySecs = delaySecs * 2;
delaySecs = Math.min(delaySecs, 60);
LOG.warn("DPM fetchLatestAggregatedMetrics attempt '{}', waiting for '{}' seconds before retrying ...",
attempts, delaySecs);
StatsUtil.sleep(delaySecs);
}
attempts++;
Response response = null;
try {
response = target
.queryParam("jobId", jobId)
.queryParam("pipelineId", pipelineId)
.queryParam("pipelineVersion", pipelineVersion)
.request()
.header(SSOConstants.X_REST_CALL, SSOConstants.SDC_COMPONENT_NAME)
.header(SSOConstants.X_APP_AUTH_TOKEN, authToken.replaceAll("(\\r|\\n)", ""))
.header(SSOConstants.X_APP_COMPONENT_ID, appComponentId)
.post(metricRegistryJsonEntity);
if (response.getStatus() == HttpURLConnection.HTTP_OK) {
metricRegistryJson = response.readEntity(MetricRegistryJson.class);
break;
} else if (response.getStatus() == HttpURLConnection.HTTP_UNAVAILABLE) {
errorResponseMessage = "Error requesting latest stats from time-series app: DPM unavailable";
LOG.warn(errorResponseMessage);
metricRegistryJson = null;
} else if (response.getStatus() == HttpURLConnection.HTTP_FORBIDDEN) {
errorResponseMessage = response.readEntity(String.class);
LOG.error(Utils.format(Errors.STATS_02.getMessage(), errorResponseMessage));
metricRegistryJson = null;
break;
} else {
errorResponseMessage = response.readEntity(String.class);
LOG.warn("Error requesting latest stats from time-series app, HTTP status '{}': {}",
response.getStatus(), errorResponseMessage);
metricRegistryJson = null;
}
} catch (Exception ex) {
errorResponseMessage = ex.toString();
LOG.warn("Error requesting latest stats from time-series app : {}", ex.toString());
metricRegistryJson = null;
} finally {
if (response != null) {
response.close();
}
}
}
if (metricRegistryJson == null) {
issues.add(
context.createConfigIssue(
Groups.STATS.getLabel(),
"targetUrl",
Errors.STATS_02,
errorResponseMessage
)
);
}
return metricRegistryJson;
}
/**
* Translates the specified HTTP status code into a storage exception.
*
* @param statusCode
* The HTTP status code returned by the operation.
* @param statusDescription
* A <code>String</code> that represents the status description.
* @param inner
* An <code>Exception</code> object that represents a reference to the initial exception, if one exists.
*
* @return A <code>StorageException</code> object that represents translated exception.
**/
protected static StorageException translateFromHttpStatus(final int statusCode, final String statusDescription,
final Exception inner) {
String errorCode;
switch (statusCode) {
case HttpURLConnection.HTTP_FORBIDDEN:
errorCode = StorageErrorCode.ACCESS_DENIED.toString();
break;
case HttpURLConnection.HTTP_GONE:
case HttpURLConnection.HTTP_NOT_FOUND:
errorCode = StorageErrorCode.RESOURCE_NOT_FOUND.toString();
break;
case 416:
case HttpURLConnection.HTTP_BAD_REQUEST:
// 416: RequestedRangeNotSatisfiable - No corresponding enum in HttpURLConnection
errorCode = StorageErrorCode.BAD_REQUEST.toString();
break;
case HttpURLConnection.HTTP_PRECON_FAILED:
case HttpURLConnection.HTTP_NOT_MODIFIED:
errorCode = StorageErrorCode.CONDITION_FAILED.toString();
break;
case HttpURLConnection.HTTP_CONFLICT:
errorCode = StorageErrorCode.RESOURCE_ALREADY_EXISTS.toString();
break;
case HttpURLConnection.HTTP_UNAVAILABLE:
errorCode = StorageErrorCode.SERVER_BUSY.toString();
break;
case HttpURLConnection.HTTP_GATEWAY_TIMEOUT:
errorCode = StorageErrorCode.SERVICE_TIMEOUT.toString();
break;
case HttpURLConnection.HTTP_INTERNAL_ERROR:
errorCode = StorageErrorCode.SERVICE_INTERNAL_ERROR.toString();
break;
case HttpURLConnection.HTTP_NOT_IMPLEMENTED:
errorCode = StorageErrorCode.NOT_IMPLEMENTED.toString();
break;
case HttpURLConnection.HTTP_BAD_GATEWAY:
errorCode = StorageErrorCode.BAD_GATEWAY.toString();
break;
case HttpURLConnection.HTTP_VERSION:
errorCode = StorageErrorCode.HTTP_VERSION_NOT_SUPPORTED.toString();
break;
default:
errorCode = null;
}
if (errorCode == null) {
return null;
} else {
return new StorageException(errorCode, statusDescription, statusCode, null, inner);
}
}
private void getVisitCookie() throws IOException, InterruptedException {
ConnUrl = new URL(mUrl);
mGetMainConn = (HttpURLConnection) ConnUrl.openConnection();
mGetMainConn.setRequestMethod("GET");
mGetMainConn.setConnectTimeout(CONN_TIMEOUT);
mGetMainConn.setReadTimeout(CONN_TIMEOUT);
if (!TextUtils.isEmpty(mUser_agent)){
mGetMainConn.setRequestProperty("user-agent",mUser_agent);
}
mGetMainConn.setRequestProperty("accept",ACCEPT);
mGetMainConn.setRequestProperty("referer", mUrl);
if (mCookieList!=null&&mCookieList.size()>0){
mGetMainConn.setRequestProperty("cookie",listToString(mCookieList));
}
mGetMainConn.setUseCaches(false);
mGetMainConn.connect();
switch (mGetMainConn.getResponseCode()){
case HttpURLConnection.HTTP_OK:
e("MainUrl","visit website success");
mCookieList = mCookieManager.getCookieStore().getCookies();
checkCookie(mCookieList);
return;
case HttpURLConnection.HTTP_MOVED_PERM:
case HttpURLConnection.HTTP_MOVED_TEMP:
hasNewUrl = true;
mUrl = mGetMainConn.getHeaderField("Location");
mCookieList = mCookieManager.getCookieStore().getCookies();
checkCookie(mCookieList);
e("MainUrl","HTTP 301 :"+mUrl);
return;
case HttpURLConnection.HTTP_FORBIDDEN:
e("MainUrl","IP block or cookie err");
return;
case HttpURLConnection.HTTP_UNAVAILABLE:
InputStream mInputStream = mCheckConn.getErrorStream();
BufferedReader mBufferedReader = new BufferedReader(new InputStreamReader(mInputStream));
StringBuilder sb = new StringBuilder();
String str;
while ((str = mBufferedReader.readLine()) != null){
sb.append(str);
}
mInputStream.close();
mBufferedReader.close();
mCookieList = mCookieManager.getCookieStore().getCookies();
str = sb.toString();
getCheckAnswer(str);
break;
default:
e("MainUrl","UnCatch Http code: "+mGetMainConn.getHeaderField("Location"));
break;
}
}
private void sendUpdate(List<SDCMetricsJson> sdcMetricsJsonList) throws StageException {
int delaySecs = 1;
int attempts = 0;
while (attempts < retryAttempts || retryAttempts == -1) {
if (attempts > 0) {
delaySecs = delaySecs * 2;
delaySecs = Math.min(delaySecs, 60);
LOG.warn("Post attempt '{}', waiting for '{}' seconds before retrying ...",
attempts, delaySecs);
StatsUtil.sleep(delaySecs);
}
attempts++;
Response response = null;
try {
response = target.request()
.header(SSOConstants.X_REST_CALL, SSOConstants.SDC_COMPONENT_NAME)
.header(SSOConstants.X_APP_AUTH_TOKEN, sdcAuthToken.replaceAll("(\\r|\\n)", ""))
.header(SSOConstants.X_APP_COMPONENT_ID, sdcId)
.post(
Entity.json(
sdcMetricsJsonList
)
);
if (response.getStatus() == HttpURLConnection.HTTP_OK) {
return;
} else if (response.getStatus() == HttpURLConnection.HTTP_UNAVAILABLE) {
LOG.warn("Error writing to time-series app: DPM unavailable");
// retry
} else if (response.getStatus() == HttpURLConnection.HTTP_FORBIDDEN) {
// no retry in this case
String errorResponseMessage = response.readEntity(String.class);
LOG.error(Utils.format(Errors.HTTP_02.getMessage(), errorResponseMessage));
throw new StageException(Errors.HTTP_02, errorResponseMessage);
} else {
String responseMessage = response.readEntity(String.class);
LOG.error(Utils.format(Errors.HTTP_02.getMessage(), responseMessage));
//retry
}
} catch (Exception ex) {
LOG.error(Utils.format(Errors.HTTP_02.getMessage(), ex.toString(), ex));
// retry
} finally {
if (response != null) {
response.close();
}
}
}
// no success after retry
throw new StageException(Errors.HTTP_03, retryAttempts);
}
/**
* 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";
}
}
/**
* Constructor.
*
* @param msg human readable message
* @param cause reason for this exception
*/
public GenieServerUnavailableException(final String msg, final Throwable cause) {
super(HttpURLConnection.HTTP_UNAVAILABLE, msg, cause);
}
/**
* Constructor.
*
* @param msg human readable message
*/
public GenieServerUnavailableException(final String msg) {
super(HttpURLConnection.HTTP_UNAVAILABLE, msg);
}