下面列出了怎么用javax.ws.rs.ServiceUnavailableException的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public Optional<Account> authenticate(String bearerToken) {
Response response = client.target(publicAuthUrl).request()
.header(AUTHORIZATION, "Bearer " + bearerToken)
.accept(MediaType.APPLICATION_JSON)
.get();
if (response.getStatus() == OK.getStatusCode()) {
return readAccountFromResponse(response);
} else if (response.getStatus() == UNAUTHORIZED.getStatusCode()) {
response.close();
return Optional.empty();
} else {
response.close();
logger.warn("Unexpected status code " + response.getStatus() + " from auth.");
throw new ServiceUnavailableException();
}
}
/**
* {@inheritDoc}
*/
@Override
public Response toResponse(final ServiceUnavailableException exception) {
if (L.isDebugEnabled()) {
L.debug(R.getString("D-REST-JERSEY-MAPPER#0011"));
}
ErrorMessage error = ErrorMessages.create(exception)
.id()
.code(ErrorCode.SERVICE_UNAVAILABLE.code())
.resolve()
.get();
L.error(error.log(), exception);
return Response.status(exception.getResponse().getStatusInfo())
.entity(error)
.type(MediaType.APPLICATION_JSON)
.build();
}
@HiveWebsocketAuth
@PreAuthorize("permitAll")
public void processLogin(JsonObject request, WebSocketSession session) throws IOException {
JwtRequestVO loginRequest = new JwtRequestVO();
if (request.get("login") != null) {
loginRequest.setLogin(request.get("login").getAsString());
}
if (request.get("password") != null) {
loginRequest.setPassword(request.get("password").getAsString());
}
String loginRequestStr = gson.toJson(loginRequest);
JwtTokenVO jwtToken = null;
try {
jwtToken = httpRestHelper.post(authBaseUrl + "/token", loginRequestStr, JwtTokenVO.class, null);
} catch (ServiceUnavailableException e) {
throw new HiveException(e.getMessage(), SC_SERVICE_UNAVAILABLE);
}
WebSocketResponse response = new WebSocketResponse();
response.addValue("accessToken", jwtToken.getAccessToken());
response.addValue("refreshToken", jwtToken.getRefreshToken());
clientHandler.sendMessage(request, response, session);
}
@HiveWebsocketAuth
@PreAuthorize("isAuthenticated() and hasPermission(null, 'MANAGE_TOKEN')")
public void processTokenCreate(JsonObject request, WebSocketSession session) throws IOException {
JsonObject payload = request.get(Constants.PAYLOAD).getAsJsonObject();
if (payload == null) {
logger.warn("JwtToken: payload was not found");
throw new HiveException(Messages.PAYLOAD_NOT_FOUND, SC_BAD_REQUEST);
}
hiveValidator.validate(payload);
String jwtTokenStr = (String) session.getAttributes().get(WebSocketAuthenticationManager.SESSION_ATTR_JWT_TOKEN);
JwtTokenVO jwtToken = null;
try {
jwtToken = httpRestHelper.post(authBaseUrl + "/token/create", payload.toString(), JwtTokenVO.class, jwtTokenStr);
} catch (ServiceUnavailableException e) {
throw new HiveException(e.getMessage(), SC_SERVICE_UNAVAILABLE);
}
WebSocketResponse response = new WebSocketResponse();
response.addValue("accessToken", jwtToken.getAccessToken());
response.addValue("refreshToken", jwtToken.getRefreshToken());
clientHandler.sendMessage(request, response, session);
}
@HiveWebsocketAuth
@PreAuthorize("permitAll")
public void processRefresh(JsonObject request, WebSocketSession session) throws IOException {
if (request.get("refreshToken") == null) {
logger.warn("JwtToken: payload was not found");
throw new HiveException(Messages.PAYLOAD_NOT_FOUND, SC_BAD_REQUEST);
}
JwtRefreshTokenVO refreshTokenVO = new JwtRefreshTokenVO();
refreshTokenVO.setRefreshToken(request.get("refreshToken").getAsString());
String refreshTokenStr = gson.toJson(refreshTokenVO);
JwtTokenVO jwtToken = null;
try {
jwtToken = httpRestHelper.post(authBaseUrl + "/token/refresh", refreshTokenStr, JwtTokenVO.class, null);
} catch (ServiceUnavailableException e) {
throw new HiveException(e.getMessage(), SC_SERVICE_UNAVAILABLE);
}
WebSocketResponse response = new WebSocketResponse();
response.addValue("accessToken", jwtToken.getAccessToken());
clientHandler.sendMessage(request, response, session);
}
@Override
public void filter(ContainerRequestContext context) {
if (LoadDetectFilter.isWhiteAPI(context)) {
return;
}
HugeConfig config = this.configProvider.get();
int maxWorkerThreads = config.get(ServerOptions.MAX_WORKER_THREADS);
WorkLoad load = this.loadProvider.get();
// There will be a thread doesn't work, dedicated to statistics
if (load.incrementAndGet() >= maxWorkerThreads) {
throw new ServiceUnavailableException(String.format(
"The server is too busy to process the request, " +
"you can config %s to adjust it or try again later",
ServerOptions.MAX_WORKER_THREADS.name()));
}
long minFreeMemory = config.get(ServerOptions.MIN_FREE_MEMORY);
long allocatedMem = Runtime.getRuntime().totalMemory() -
Runtime.getRuntime().freeMemory();
long presumableFreeMem = (Runtime.getRuntime().maxMemory() -
allocatedMem) / Bytes.MB;
if (presumableFreeMem < minFreeMemory) {
gcIfNeeded();
throw new ServiceUnavailableException(String.format(
"The server available memory %s(MB) is below than " +
"threshold %s(MB) and can't process the request, " +
"you can config %s to adjust it or try again later",
presumableFreeMem, minFreeMemory,
ServerOptions.MIN_FREE_MEMORY.name()));
}
}
protected void handleTimeout() {
if (timeoutHandler != null) {
timeoutHandler.handleTimeout(this);
}
if (done)
return;
resume(new ServiceUnavailableException());
}
private URI getProductServiceUri() {
ServiceInstance serviceInstance = loadBalancer.choose(PRODUCT_SERVICE);
if (serviceInstance == null) {
throw new ServiceUnavailableException("Service unavailable");
}
return serviceInstance.getUri();
}
@Test
void failedDueToUnknownError() {
final Zonky z = harmlessZonky();
final PowerTenant auth = mockTenant(z, false);
final RecommendedLoan r = mockLoanDescriptor().recommend(Money.from(200))
.get();
final Exception thrown = new ServiceUnavailableException();
doThrow(thrown).when(z)
.invest(notNull(), anyInt());
final InvestingSession t = new InvestingSession(Collections.emptySet(), auth);
assertThatThrownBy(() -> t.accept(r)).isSameAs(thrown);
verify(auth, never()).setKnownBalanceUpperBound(any());
}
public PulsarAdminException getApiException(Throwable e) {
if (e instanceof PulsarAdminException) {
return (PulsarAdminException) e;
} else if (e instanceof ServiceUnavailableException) {
if (e.getCause() instanceof java.net.ConnectException) {
return new ConnectException(e.getCause());
} else {
return new PulsarAdminException((ServerErrorException) e);
}
} else if (e instanceof WebApplicationException) {
// Handle 5xx exceptions
if (e instanceof ServerErrorException) {
ServerErrorException see = (ServerErrorException) e;
return new ServerSideErrorException(see, e.getMessage());
} else if (e instanceof ClientErrorException) {
// Handle 4xx exceptions
ClientErrorException cee = (ClientErrorException) e;
int statusCode = cee.getResponse().getStatus();
switch (statusCode) {
case 401:
case 403:
return new NotAuthorizedException(cee);
case 404:
return new NotFoundException(cee);
case 405:
return new NotAllowedException(cee);
case 409:
return new ConflictException(cee);
case 412:
return new PreconditionFailedException(cee);
default:
return new PulsarAdminException(cee);
}
} else {
return new PulsarAdminException((WebApplicationException) e);
}
} else {
return new PulsarAdminException(e);
}
}
@Override
public void sendDummyMessageToQueue(String type) {
Optional<MessageSender> messageSender = messageSenderProvider.getMessageSender();
if (!messageSender.isPresent()) {
throw new ServiceUnavailableException();
} else {
if (type != null && type.equals("status")) {
buildStatusChangedEventNotifier.fire(
new DefaultBuildStatusChangedEvent(newBuild(), BuildStatus.CANCELLED, BuildStatus.CANCELLED));
} else {
messageSender.get().sendToTopic("Test Message.");
}
}
}
@GET
@Path("/unavailable")
public Book getBookRootUnavailable() {
if (unavailableCounter++ < 4) {
throw new ServiceUnavailableException();
}
return new Book("root", 124L);
}
public synchronized void handleTimeout() {
if (!resumedByApplication) {
if (pendingTimeout != null) {
setAsyncResponseOnExchange();
cont.suspend(pendingTimeout);
pendingTimeout = null;
} else if (timeoutHandler != null) {
timeoutHandler.handleTimeout(this);
} else {
cont.setObject(new ServiceUnavailableException());
}
}
}
@Test
public void testToFromSimpleString() {
Date retry = new Date();
ServiceUnavailableException ex = new ServiceUnavailableException(retry);
Date retry2 = ex.getRetryTime(new Date());
assertEquals(HttpUtils.toHttpDate(retry), HttpUtils.toHttpDate(retry2));
}
@Override
public void register(PluginReqisterQuery pluginReqisterQuery, PluginUpdate pluginUpdate, String authorization,
@Suspended final AsyncResponse asyncResponse) {
hiveValidator.validate(pluginUpdate);
try {
HivePrincipal principal = (HivePrincipal) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
pluginRegisterService.register(principal.getUser().getId(), pluginReqisterQuery, pluginUpdate, authorization)
.thenAccept(asyncResponse::resume);
} catch (ServiceUnavailableException e) {
logger.warn(HEALTH_CHECK_FAILED);
asyncResponse.resume(ResponseFactory.response(BAD_REQUEST,
new ErrorResponse(BAD_REQUEST.getStatusCode(), HEALTH_CHECK_FAILED)));
}
}
private JwtTokenVO createPluginTokens(String topicName, String authorization) {
JwtPluginPayload jwtPluginPayload = new JwtPluginPayload(Collections.singleton(MANAGE_PLUGIN.getId()), topicName, null, null);
JwtTokenVO jwtToken = null;
try {
jwtToken = httpRestHelper.post(authBaseUrl + "/token/plugin/create", gson.toJson(jwtPluginPayload), JwtTokenVO.class, authorization);
} catch (ServiceUnavailableException e) {
logger.error("Authentication service is not available");
throw new HiveException(e.getMessage(), SERVICE_UNAVAILABLE.getStatusCode());
}
return jwtToken;
}
@Path("/plain-service-unavailable")
@POST public void plainServiceUnavailable() {
throw new ServiceUnavailableException();
}
@Test(expected = ServiceUnavailableException.class)
public void shouldThrow_ifUnknownResponse() {
when(mockResponse.getStatus()).thenReturn(NOT_FOUND.getStatusCode());
accountAuthenticator.authenticate(bearerToken);
}
@Test
public void gracefulShutdown()
throws Exception
{
Id attemptId = startSleepTask();
server.terminateProcess();
Instant terminateStartedAt = Instant.now();
// server started termination but it should be alive at most 5 seconds.
int aliveCount = 0;
while (true) {
Instant loopStartedAt = Instant.now();
if (loopStartedAt.isAfter(terminateStartedAt.plus(Duration.ofMinutes(10)))) {
throw new IllegalStateException("Server didn't shutdown within 10 minutes");
}
try {
client.getSessionAttempt(attemptId);
aliveCount++;
}
catch (Exception ex) {
// if REST API fails, the cause should be 503 Service Unavailable or
// connection refused.
if (ex instanceof ProcessingException) {
assertThat(ex.getCause(), instanceOf(ConnectException.class));
break;
}
else {
assertThat(ex, instanceOf(ServiceUnavailableException.class));
break;
}
}
// sleep for 1 second
long sleepMillis = Duration.between(Instant.now(), loopStartedAt.plusSeconds(1)).toMillis();
if (sleepMillis > 0) {
Thread.sleep(sleepMillis);
}
}
// all running tasks should be done
assertThat(Files.exists(root().resolve("done.out")), is(true));
// but waiting tasks should not start
assertThat(Files.exists(root().resolve("after_sleep.out")), is(false));
// REST API should be alive for a while
assertThat(aliveCount, greaterThan(3));
assertThat(server.outUtf8(), containsString("Waiting for completion of 2 running tasks..."));
assertThat(server.outUtf8(), containsString("Closing HTTP listening sockets"));
TestUtils.expect(Duration.ofMinutes(5), () -> !server.isProcessAlive());
assertThat(server.outUtf8(), containsString("Shutting down HTTP worker threads"));
assertThat(server.outUtf8(), containsString("Shutting down system"));
assertThat(server.outUtf8(), containsString("Shutdown completed"));
}
@GET
public EmptyTest exception() {
throw new ServiceUnavailableException("service");
}