@Override protected Deferred<HttpResponse> defer(ClientRequestContext ctx, HttpRequest req) throws Exception { return new Deferred<HttpResponse>() { private final CompletableFuture<HttpResponse> responseFuture = new CompletableFuture<>(); private final HttpResponse res = HttpResponse.from(responseFuture); @Override public HttpResponse response() { return res; } @Override public void delegate(HttpResponse response) { responseFuture.complete(response); } @Override public void close(Throwable cause) { responseFuture.completeExceptionally(cause); } }; } }
private static HttpResponse respond(CompletableFuture<HttpResponse> future, Disposable disposable) { final HttpResponse response = HttpResponse.from(future); response.completionFuture().exceptionally(cause -> { disposable.dispose(); return null; }); return response; } }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { return HttpResponse.from(serve0(ctx, req)); }
@Override protected final HttpResponse doPost(ServiceRequestContext ctx, HttpRequest req) { return HttpResponse.from(req.aggregate() .thenApply(this::echo) .exceptionally(CompletionActions::log)); }
@Override protected HttpResponse doPut(ServiceRequestContext ctx, HttpRequest req) throws Exception { return HttpResponse.from( updateHealthStatus(ctx, req).thenApply(HttpResponse::of) .exceptionally(HttpResponse::ofFailure)); }
@Override protected HttpResponse doExecute(ClientRequestContext ctx, HttpRequest req) throws Exception { final boolean hasInitialAuthority = !isNullOrEmpty(req.headers().authority()); final CompletableFuture<HttpResponse> responseFuture = new CompletableFuture<>(); final HttpResponse res = HttpResponse.from(responseFuture); final HttpRequestDuplicator reqDuplicator = new HttpRequestDuplicator(req, 0, ctx.eventLoop()); doExecute0(ctx, reqDuplicator, req, res, responseFuture, hasInitialAuthority); return res; }
private static ServerBuilder configureService(ServerBuilder sb, HttpHandler httpHandler, DataBufferFactoryWrapper<?> factoryWrapper, @Nullable String serverHeader) { final ArmeriaHttpHandlerAdapter handler = new ArmeriaHttpHandlerAdapter(httpHandler, factoryWrapper); return sb.service(PathMapping.ofCatchAll(), (ctx, req) -> { final CompletableFuture<HttpResponse> future = new CompletableFuture<>(); final HttpResponse response = HttpResponse.from(future); final Disposable disposable = handler.handle(ctx, req, future, serverHeader).subscribe(); response.completionFuture().whenComplete((unused, cause) -> { if (cause != null) { logger.debug("{} Response stream has been cancelled.", ctx, cause); disposable.dispose(); } }); return response; }); }
@Override @SuppressWarnings("unchecked") public HttpResponse convertResponse(ServiceRequestContext ctx, HttpHeaders headers, @Nullable Object result, HttpHeaders trailingHeaders) throws Exception { final CompletableFuture<?> f; if (result instanceof Publisher) { f = collectFrom((Publisher<Object>) result); } else if (result instanceof Stream) { f = collectFrom((Stream<Object>) result, ctx.blockingTaskExecutor()); } else { return ResponseConverterFunction.fallthrough(); } assert f != null; return HttpResponse.from(f.handle((aggregated, cause) -> { if (cause != null) { return exceptionHandler.handleException(ctx, ctx.request(), cause); } try { return responseConverter.convertResponse(ctx, headers, aggregated, trailingHeaders); } catch (Exception e) { return exceptionHandler.handleException(ctx, ctx.request(), e); } })); } }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final SamlServiceFunction func = serviceMap.get(req.path()); if (func == null) { return HttpResponse.of(HttpStatus.BAD_REQUEST); } final CompletionStage<AggregatedHttpMessage> f; if (portConfigHolder.isDone()) { f = req.aggregate(); } else { f = portConfigHolder.future().thenCompose(unused -> req.aggregate()); } return HttpResponse.from(f.handle((msg, cause) -> { if (cause != null) { return HttpResponse.of(HttpStatus.BAD_REQUEST); } final SamlPortConfig portConfig = portConfigHolder.config().get(); if (portConfig.scheme().isTls() != ctx.sessionProtocol().isTls()) { return HttpResponse.of(HttpStatus.BAD_REQUEST); } // Use user-specified hostname if it exists. // If there's no hostname set by a user, the default virtual hostname will be used. final String defaultHostname = firstNonNull(sp.hostname(), ctx.virtualHost().defaultHostname()); return func.serve(ctx, msg, defaultHostname, portConfig); })); }
final HttpResponse res = HttpResponse.from(responseFuture); ctx.logBuilder().serializationFormat(serializationFormat); ctx.logBuilder().deferRequestContent();
if (sloResEndpoint == null) { return HttpResponse.from(sloHandler.logoutSucceeded(ctx, msg, messageContext) .thenApply(unused -> HttpResponse.of(HttpStatus.OK))); try { final HttpResponse response = respond(logoutResponse, sloResEndpoint); return HttpResponse.from(sloHandler.logoutSucceeded(ctx, msg, messageContext) .thenApply(unused -> response)); } catch (SamlException e) { ctx, logoutRequest.getID(), e); final HttpResponse response = fail(ctx, logoutRequest, sloResEndpoint); return HttpResponse.from(sloHandler.logoutFailed(ctx, msg, e) .thenApply(unused -> response));
return HttpResponse.from( ((CompletionStage<?>) result) .thenApply(object -> convertResponse(ctx, req, newHeaders, object,
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { return HttpResponse.from(AuthorizerUtil.authorize(authorizer, ctx, req).handleAsync((result, cause) -> { try { if (cause == null) { if (result != null) { return result ? successHandler.authSucceeded(delegate(), ctx, req) : failureHandler.authFailed(delegate(), ctx, req, null); } cause = AuthorizerUtil.newNullResultException(authorizer); } return failureHandler.authFailed(delegate(), ctx, req, cause); } catch (Exception e) { return Exceptions.throwUnsafely(e); } }, ctx.contextAwareEventLoop())); } }
return HttpResponse.from(responseFuture);
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { return HttpResponse.from(authorizer.authorize(ctx, req).handle((result, cause) -> { if (cause == null && result) { return HttpResponse.from(f.thenApply(idp -> { if (idp == null) { throw new RuntimeException("cannot find a suitable identity provider from configurations");
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { return HttpResponse.from(CompletableFuture.supplyAsync(() -> { final AggregatedHttpMessage msg = req.aggregate().join(); final String sessionId = AuthTokenExtractors.OAUTH2.apply(msg.headers()).accessToken(); if (!WRONG_SESSION_ID.equals(sessionId)) { logoutSessionPropagator.apply(sessionId).join(); } return HttpResponse.of(HttpStatus.OK); }, ctx.blockingTaskExecutor())); } }
@Override protected HttpResponse doPost(ServiceRequestContext ctx, HttpRequest req) throws Exception { return HttpResponse.from( req.aggregate() .thenApply(msg -> AuthTokenExtractors.OAUTH2.apply(msg.headers())) .thenCompose(token -> { final String sessionId = token.accessToken(); return executor.execute(Command.removeSession(sessionId)); }) .thenApply(unused -> HttpResponse.of(HttpStatus.OK)) .exceptionally(cause -> HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause))); } }
@Override protected HttpResponse doPost(ServiceRequestContext ctx, HttpRequest req) throws Exception { return HttpResponse.from( req.aggregate() .thenApply(msg -> AuthTokenExtractors.OAUTH2.apply(msg.headers())) .thenCompose(token -> { final String sessionId = token.accessToken(); return executor.execute(Command.removeSession(sessionId)); }) .thenApply(unused -> HttpResponse.of(HttpStatus.OK)) .exceptionally(cause -> HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause))); } }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final SamlServiceFunction func = serviceMap.get(req.path()); if (func == null) { return HttpResponse.of(HttpStatus.BAD_REQUEST); } final CompletionStage<AggregatedHttpMessage> f; if (portConfigHolder.isDone()) { f = req.aggregate(); } else { f = portConfigHolder.future().thenCompose(unused -> req.aggregate()); } return HttpResponse.from(f.handle((msg, cause) -> { if (cause != null) { return HttpResponse.of(HttpStatus.BAD_REQUEST); } final SamlPortConfig portConfig = portConfigHolder.config().get(); if (portConfig.scheme().isTls() != ctx.sessionProtocol().isTls()) { return HttpResponse.of(HttpStatus.BAD_REQUEST); } // Use user-specified hostname if it exists. // If there's no hostname set by a user, the default virtual hostname will be used. final String defaultHostname = firstNonNull(sp.hostname(), ctx.virtualHost().defaultHostname()); return func.serve(ctx, msg, defaultHostname, portConfig); })); }
/** * POST /projects/{projectName}/repositories/{repoName}/delete/revisions/{revision}{path} * Deletes a file. */ @Post("regex:/projects/(?<projectName>[^/]+)/repositories/(?<repoName>[^/]+)" + "/delete/revisions/(?<revision>[^/]+)(?<path>/.*$)") @RequiresWritePermission public HttpResponse deleteFile(@Param("projectName") String projectName, @Param("repoName") String repoName, @Param("revision") String revision, @Param("path") String path, AggregatedHttpMessage message, ServiceRequestContext ctx) { final CommitMessageDto commitMessage; try { final JsonNode node = Jackson.readTree(message.content().toStringUtf8()); commitMessage = Jackson.convertValue(node.get("commitMessage"), CommitMessageDto.class); } catch (IOException e) { throw new IllegalArgumentException("invalid data to be parsed", e); } final CompletableFuture<?> future = push(projectName, repoName, new Revision(revision), AuthUtil.currentAuthor(ctx), commitMessage.getSummary(), commitMessage.getDetail().getContent(), Markup.valueOf(commitMessage.getDetail().getMarkup()), Change.ofRemoval(path)); return HttpResponse.from(future.thenApply(unused -> HttpResponse.of(HttpStatus.OK))); }