Example usage for io.vertx.core.http HttpMethod GET

Introduction

In this page you can find the example usage for io.vertx.core.http HttpMethod GET.

Prototype

HttpMethod GET

To view the source code for io.vertx.core.http HttpMethod GET.

Click Source Link

Usage

From source file:io.flowly.auth.router.UserRouter.java

License:Open Source License

public UserRouter(Vertx vertx, JWTAuth authProvider, Router router) {
    super(vertx, authProvider, router, "/user/*");

    prepareLoginRoute(vertx, router);/* www  . j a  v  a  2 s  .  co  m*/

    prepareSearchRoute("/user/search", LocalAddresses.SEARCH_USER, "Unable to search for users.");
    prepareRoute(HttpMethod.POST, "/user/create", LocalAddresses.CREATE_USER, "Unable to create user.", false);
    prepareRoute(HttpMethod.POST, "/user/update", LocalAddresses.UPDATE_USER, "Unable to update user.", false);
    prepareRoute(HttpMethod.GET, "/user/get", LocalAddresses.GET_USER, "Unable to get user.", true);
}

---

From source file:io.flowly.core.router.BaseRouter.java

License:Open Source License

protected void prepareSearchRoute(String path, String address, String errorMessage) {
    router.route(HttpMethod.GET, path).handler(requestHandler -> {
        try {//from w ww.j av  a  2s.  com
            eventBus.<JsonArray>send(address, getSearchArgs(requestHandler), reply -> {
                JsonArray results = reply.result().body();

                if (results != null) {
                    writeSuccessResponse(requestHandler, results.encode(), true);
                } else {
                    writeErrorResponse(requestHandler, errorMessage);
                }
            });
        } catch (Exception ex) {
            logger.error(errorMessage, ex);
            writeErrorResponse(requestHandler, errorMessage);
        }
    });
}

---

From source file:io.flowly.webapp.AppServer.java

License:Open Source License

@Override
public void start(Future<Void> startFuture) throws Exception {
    HttpServer server = vertx.createHttpServer();
    Router router = Router.router(vertx);

    StaticHandler staticHandler = StaticHandler.create().setWebRoot(APP_ROOT);

    router.routeWithRegex(HttpMethod.GET, STATIC_FILES_PATTERN).handler(staticHandler);

    FlowApiRouter apiRouter = new FlowApiRouter(vertx);
    router.mountSubRouter("/api", apiRouter.getRouter());

    // TODO: Configure port.
    server.requestHandler(router::accept).listen(8080);
    startFuture.complete();//from   w  ww  .  j a v a  2 s.c o m
}

---

From source file:io.flowly.webapp.FlowApiRouter.java

License:Open Source License

private void prepareGetInboxRoute(Router api, Vertx vertx) {
    Route getInboxRoute = api.route(HttpMethod.GET, "/inbox/:subjectId").produces(JSON_CONTENT_TYPE);
    getInboxRoute.handler(routingContext -> {
        String subjectId = routingContext.request().getParam(ObjectKeys.SUBJECT_ID);
        logger.info("Get inbox request received: " + subjectId);

        JsonObject args = new JsonObject();
        args.put(ObjectKeys.SUBJECT_ID, subjectId);

        String pageNumber = routingContext.request().getParam(ObjectKeys.PAGE_NUMBER);
        if (pageNumber != null) {
            args.put(ObjectKeys.PAGE_NUMBER, Integer.parseInt(pageNumber));
        }/* w  ww. java  2  s  .c om*/

        String pageSize = routingContext.request().getParam(ObjectKeys.PAGE_SIZE);
        if (pageSize != null) {
            args.put(ObjectKeys.PAGE_SIZE, Integer.parseInt(pageSize));
        }

        vertx.eventBus().send(ClusterAddresses.GET_USER_INBOX, args, reply -> {
            JsonObject inbox = (JsonObject) reply.result().body();
            writeResponse(routingContext, inbox.encode());
        });
    });
}

---

From source file:io.flowly.webapp.FlowApiRouter.java

License:Open Source License

private void prepareGetFlowTaskRoute(Router api, Vertx vertx) {
    Route getFlowTaskRoute = api.route(HttpMethod.GET, "/flow/task/get/:taskId");
    getFlowTaskRoute.handler(routingContext -> {
        Long taskId = Long.parseLong(routingContext.request().getParam(ObjectKeys.TASK_ID));

        logger.info("Get flow task request received: " + taskId);

        vertx.eventBus().send(ClusterAddresses.GET_FLOW_INSTANCE_TASK, taskId, reply -> {
            writeResponse(routingContext, ((JsonObject) reply.result().body()).encode());
        });// ww w.j a v a  2  s  .com
    });
}

---

From source file:io.flowly.webapp.FlowApiRouter.java

License:Open Source License

private void prepareGetFlowsRoute(Router api, Vertx vertx) {
    Route getFlowsRoute = api.route(HttpMethod.GET, "/flows").produces(JSON_CONTENT_TYPE);
    getFlowsRoute.handler(routingContext -> {
        String subjectId = routingContext.request().getParam(ObjectKeys.SUBJECT_ID);
        logger.info("Get flows request received: " + subjectId);

        vertx.eventBus().send(ClusterAddresses.GET_USER_FLOWS, subjectId, reply -> {
            JsonArray flows = (JsonArray) reply.result().body();
            writeResponse(routingContext, flows.encode());
        });//from   www .  j  av a2 s  .c o m
    });
}

---

From source file:io.gravitee.am.gateway.handler.vertx.handler.oauth2.OAuth2Router.java

License:Apache License

public Router route(AuthProvider userAuthProvider) {
    // Create the OAuth 2.0 router
    final Router router = Router.router(vertx);

    // create authentication handlers
    final AuthProvider clientAuthProvider = new AuthProvider(new ClientAuthenticationProvider(clientService));

    final AuthHandler clientAuthHandler = ChainAuthHandler.create()
            .append(ClientCredentialsAuthHandler.create(clientAuthProvider.getDelegate()))
            .append(ClientBasicAuthHandler.create(clientAuthProvider.getDelegate()));

    final AuthHandler userAuthHandler = RedirectAuthHandler.create(userAuthProvider.getDelegate(),
            '/' + domain.getPath() + "/login");

    // create other handlers
    final AuthorizationRequestParseHandler authorizationRequestParseHandler = AuthorizationRequestParseHandler
            .create(domain);//w w  w .  jav a2s.com

    // Bind OAuth2 endpoints
    Handler<RoutingContext> authorizeEndpoint = new AuthorizationEndpointHandler(authorizationCodeService,
            tokenGranter, clientService, approvalService, domain);
    Handler<RoutingContext> authorizeApprovalEndpoint = new AuthorizationApprovalEndpointHandler(
            authorizationCodeService, tokenGranter, approvalService, clientService);
    Handler<RoutingContext> tokenEndpoint = new TokenEndpointHandler(tokenGranter);
    Handler<RoutingContext> userApprovalEndpoint = new UserApprovalEndpointHandler(clientService, scopeService,
            thymeleafTemplateEngine);

    // Check_token is provided only for backward compatibility and must be remove in the future
    Handler<RoutingContext> checkTokenEndpoint = new CheckTokenEndpointHandler();
    ((CheckTokenEndpointHandler) checkTokenEndpoint).setTokenService(tokenService);

    Handler<RoutingContext> introspectionEndpoint = new IntrospectionEndpointHandler();
    ((IntrospectionEndpointHandler) introspectionEndpoint).setIntrospectionService(introspectionService);

    // Revocation token endpoint
    Handler<RoutingContext> revocationTokenEndpoint = new RevocationTokenEndpointHandler(
            revocationTokenService);

    // declare oauth2 routes
    router.route(HttpMethod.GET, "/authorize").handler(authorizationRequestParseHandler)
            .handler(userAuthHandler).handler(authorizeEndpoint);
    router.route(HttpMethod.POST, "/authorize").handler(userAuthHandler).handler(authorizeApprovalEndpoint);
    router.route(HttpMethod.POST, "/token").handler(clientAuthHandler).handler(tokenEndpoint);
    router.route(HttpMethod.POST, "/check_token").consumes(MediaType.APPLICATION_FORM_URLENCODED)
            .handler(clientAuthHandler).handler(checkTokenEndpoint);
    router.route(HttpMethod.POST, "/introspect").consumes(MediaType.APPLICATION_FORM_URLENCODED)
            .handler(clientAuthHandler).handler(introspectionEndpoint);
    router.route(HttpMethod.POST, "/revoke").consumes(MediaType.APPLICATION_FORM_URLENCODED)
            .handler(clientAuthHandler).handler(revocationTokenEndpoint);
    router.route(HttpMethod.GET, "/confirm_access").handler(userApprovalEndpoint);
    router.route(HttpMethod.GET, "/error").handler(new ErrorHandlerEndpoint(thymeleafTemplateEngine));

    return router;
}

---

From source file:io.gravitee.am.gateway.handler.vertx.handler.oidc.OIDCRouter.java

License:Apache License

public Router route() {
    // Create the OpenID Connect router
    final Router router = Router.router(vertx);

    // OpenID Provider Configuration Information Endpoint
    Handler<RoutingContext> openIDProviderConfigurationEndpoint = new ProviderConfigurationEndpoint();
    ((ProviderConfigurationEndpoint) openIDProviderConfigurationEndpoint).setDiscoveryService(discoveryService);
    router.route(HttpMethod.GET, "/.well-known/openid-configuration")
            .handler(openIDProviderConfigurationEndpoint);

    // UserInfo Endpoint
    Handler<RoutingContext> userInfoEndpoint = new UserInfoEndpoint(userService);
    Handler<RoutingContext> userInfoRequestParseHandler = new UserInfoRequestParseHandler(tokenService);
    router.route("/userinfo").handler(CorsHandler.newInstance(corsHandler()));
    router.route(HttpMethod.GET, "/userinfo").handler(userInfoRequestParseHandler).handler(userInfoEndpoint);
    router.route(HttpMethod.POST, "/userinfo").consumes(MediaType.APPLICATION_FORM_URLENCODED)
            .handler(userInfoRequestParseHandler).handler(userInfoEndpoint);

    // OpenID Provider JWK Set
    Handler<RoutingContext> openIDProviderJWKSetEndpoint = new ProviderJWKSetEndpoint();
    ((ProviderJWKSetEndpoint) openIDProviderJWKSetEndpoint).setJwkSetService(jwkSetService);
    router.route(HttpMethod.GET, "/.well-known/jwks.json").handler(openIDProviderJWKSetEndpoint);

    return router;
}

---

From source file:io.gravitee.fetcher.http.HttpFetcher.java

License:Apache License

private CompletableFuture<Buffer> fetchContent() {
    CompletableFuture<Buffer> future = new VertxCompletableFuture<>(vertx);

    URI requestUri = URI.create(httpFetcherConfiguration.getUrl());
    boolean ssl = HTTPS_SCHEME.equalsIgnoreCase(requestUri.getScheme());

    final HttpClientOptions options = new HttpClientOptions().setSsl(ssl).setTrustAll(true).setMaxPoolSize(1)
            .setKeepAlive(false).setTcpKeepAlive(false).setConnectTimeout(httpClientTimeout);

    if (httpFetcherConfiguration.isUseSystemProxy()) {
        ProxyOptions proxyOptions = new ProxyOptions();
        proxyOptions.setType(ProxyType.valueOf(httpClientProxyType));
        if (HTTPS_SCHEME.equals(requestUri.getScheme())) {
            proxyOptions.setHost(httpClientProxyHttpsHost);
            proxyOptions.setPort(httpClientProxyHttpsPort);
            proxyOptions.setUsername(httpClientProxyHttpsUsername);
            proxyOptions.setPassword(httpClientProxyHttpsPassword);
        } else {// w w w .  j  a v  a2 s  .  c  o  m
            proxyOptions.setHost(httpClientProxyHttpHost);
            proxyOptions.setPort(httpClientProxyHttpPort);
            proxyOptions.setUsername(httpClientProxyHttpUsername);
            proxyOptions.setPassword(httpClientProxyHttpPassword);
        }
        options.setProxyOptions(proxyOptions);
    }

    final HttpClient httpClient = vertx.createHttpClient(options);

    final int port = requestUri.getPort() != -1 ? requestUri.getPort()
            : (HTTPS_SCHEME.equals(requestUri.getScheme()) ? 443 : 80);

    try {
        HttpClientRequest request = httpClient.request(HttpMethod.GET, port, requestUri.getHost(),
                requestUri.toString());

        request.setTimeout(httpClientTimeout);

        request.handler(response -> {
            if (response.statusCode() == HttpStatusCode.OK_200) {
                response.bodyHandler(buffer -> {
                    future.complete(buffer);

                    // Close client
                    httpClient.close();
                });
            } else {
                future.complete(null);
            }
        });

        request.exceptionHandler(event -> {
            try {
                future.completeExceptionally(event);

                // Close client
                httpClient.close();
            } catch (IllegalStateException ise) {
                // Do not take care about exception when closing client
            }
        });

        request.end();
    } catch (Exception ex) {
        logger.error("Unable to fetch content using HTTP", ex);
        future.completeExceptionally(ex);
    }

    return future;
}

---

From source file:io.gravitee.gateway.http.vertx.VertxHttpClient.java

License:Apache License

private HttpMethod convert(io.gravitee.common.http.HttpMethod httpMethod) {
    switch (httpMethod) {
    case CONNECT:
        return HttpMethod.CONNECT;
    case DELETE:/*  w ww . j  av a 2 s  .  c  o  m*/
        return HttpMethod.DELETE;
    case GET:
        return HttpMethod.GET;
    case HEAD:
        return HttpMethod.HEAD;
    case OPTIONS:
        return HttpMethod.OPTIONS;
    case PATCH:
        return HttpMethod.PATCH;
    case POST:
        return HttpMethod.POST;
    case PUT:
        return HttpMethod.PUT;
    case TRACE:
        return HttpMethod.TRACE;
    }

    return null;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• »