Examples with CacheHandler org.swisspush.gateleen.cache.CacheHandler used on opensource projects

Example 1 with CacheHandler

use of org.swisspush.gateleen.cache.CacheHandler in project gateleen by swisspush.

the class RunConfig method buildRoutingContextHandler.

/**
 * Builds a handler for {@link RoutingContext}s with a "default" behaviour.
 */
public Handler<RoutingContext> buildRoutingContextHandler() {
    // add refreshables
    if (propertyHandler != null) {
        if (router != null) {
            propertyHandler.addRefreshable(router);
        }
        if (schedulerResourceManager != null) {
            propertyHandler.addRefreshable(schedulerResourceManager);
        }
    }
    return new Handler<RoutingContext>() {

        @Override
        public void handle(final RoutingContext ctx) {
            HttpServerRequest request = ctx.request();
            if (!request.headers().contains("x-rp-unique_id")) {
                request.headers().set("x-rp-unique_id", new UUID(random.nextLong(), random.nextLong()).toString().replace("-", ""));
            }
            request.exceptionHandler(exception -> LoggerFactory.getLogger(verticleClass).trace("Exception in client", exception));
            logRequest(request);
            if (qosHandler != null && qosHandler.handle(request)) {
                return;
            }
            if (corsHandler != null) {
                corsHandler.handle(request);
                if (corsHandler.isOptionsRequest(request)) {
                    return;
                }
            }
            if (contentTypeConstraintHandler != null && contentTypeConstraintHandler.handle(request)) {
                return;
            }
            if (authorizer != null) {
                authorizer.authorize(request).onComplete(event -> {
                    if (event.succeeded() && event.result()) {
                        handleRequest(request);
                    } else if (event.failed()) {
                        ResponseStatusCodeLogUtil.info(request, StatusCode.INTERNAL_SERVER_ERROR, RunConfig.class);
                        request.response().setStatusCode(StatusCode.INTERNAL_SERVER_ERROR.getStatusCode());
                        request.response().setStatusMessage(StatusCode.INTERNAL_SERVER_ERROR.getStatusMessage());
                        request.response().end(event.cause().getMessage());
                    }
                });
            } else {
                handleRequest(request);
            }
        }

        private void handleRequest(final HttpServerRequest request) {
            if (request.path().equals(SERVER_ROOT + "/cleanup")) {
                QueuingHandler.cleanup(vertx);
                request.response().end();
                return;
            }
            if (PackingHandler.isPacked(request)) {
                request.bodyHandler(new PackingHandler(request, new QueuingHandler(vertx, redisAPI, request, monitoringHandler)));
            } else {
                if (QueuingHandler.isQueued(request)) {
                    setISO8601Timestamps(request);
                    request.bodyHandler(new QueuingHandler(vertx, redisAPI, request, monitoringHandler));
                } else {
                    if (cacheHandler != null && cacheHandler.handle(request)) {
                        return;
                    }
                    if (copyResourceHandler != null && copyResourceHandler.handle(request)) {
                        return;
                    }
                    if (request.path().startsWith(SERVER_ROOT + "/queuing/")) {
                        queueBrowser.handle(request);
                        return;
                    }
                    if (hookHandler != null && hookHandler.handle(request)) {
                        return;
                    }
                    if (eventBusHandler != null && eventBusHandler.handle(request)) {
                        return;
                    }
                    if (kafkaHandler != null && kafkaHandler.handle(request)) {
                        return;
                    }
                    if (validationHandler != null && validationHandler.isToValidate(request)) {
                        validationHandler.handle(request);
                        return;
                    }
                    if (loggingResourceManager != null && loggingResourceManager.handleLoggingResource(request)) {
                        return;
                    }
                    if (configurationResourceManager != null && configurationResourceManager.handleConfigurationResource(request)) {
                        return;
                    }
                    if (validationResourceManager != null && validationResourceManager.handleValidationResource(request)) {
                        return;
                    }
                    if (schedulerResourceManager != null && schedulerResourceManager.handleSchedulerResource(request)) {
                        return;
                    }
                    if (queueCircuitBreakerConfigurationResourceManager != null && queueCircuitBreakerConfigurationResourceManager.handleConfigurationResource(request)) {
                        return;
                    }
                    if (propertyHandler != null && propertyHandler.handle(request)) {
                        return;
                    }
                    if (zipExtractHandler != null && zipExtractHandler.handle(request)) {
                        return;
                    }
                    if (delegateHandler != null && delegateHandler.handle(request)) {
                        return;
                    }
                    if (customHttpResponseHandler != null && customHttpResponseHandler.handle(request)) {
                        return;
                    }
                    if (userProfileHandler != null && userProfileHandler.isUserProfileRequest(request)) {
                        userProfileHandler.handle(request);
                    } else if (roleProfileHandler != null && roleProfileHandler.isRoleProfileRequest(request)) {
                        roleProfileHandler.handle(request);
                    } else if (expansionHandler != null && expansionHandler.isZipRequest(request)) {
                        expansionHandler.handleZipRecursion(request);
                    } else if (expansionHandler != null && expansionHandler.isExpansionRequest(request)) {
                        expansionHandler.handleExpansionRecursion(request);
                    } else if (deltaHandler != null && deltaHandler.isDeltaRequest(request)) {
                        setISO8601Timestamps(request);
                        deltaHandler.handle(request, router);
                    } else if (mergeHandler != null && mergeHandler.handle(request)) {
                        return;
                    } else {
                        setISO8601Timestamps(request);
                        router.route(request);
                    }
                }
            }
        }
    };
}

Example 2 with CacheHandler

use of org.swisspush.gateleen.cache.CacheHandler in project gateleen by swisspush.

the class AbstractTest method setupBeforeClass.

/**
 * Starts redis before the test classes are instantiated.
 */
@BeforeClass
public static void setupBeforeClass(TestContext context) {
    Async async = context.async();
    vertx = Vertx.vertx();
    jedis = new Jedis("localhost", REDIS_PORT, 10000);
    jedis.flushAll();
    final JsonObject info = new JsonObject();
    final LocalHttpClient selfClient = new LocalHttpClient(vertx);
    props.putAll(RunConfig.buildRedisProps("localhost", REDIS_PORT));
    String redisHost = (String) props.get("redis.host");
    Integer redisPort = (Integer) props.get("redis.port");
    props.put(ExpansionHandler.MAX_EXPANSION_LEVEL_HARD_PROPERTY, "100");
    props.put(ExpansionHandler.MAX_EXPANSION_LEVEL_SOFT_PROPERTY, "4");
    RunConfig.deployModules(vertx, AbstractTest.class, props, success -> {
        if (success) {
            RedisClient redisClient = new RedisClient(vertx, new RedisOptions().setConnectionString("redis://" + redisHost + ":" + redisPort));
            RedisAPI redisAPI = RedisAPI.api(redisClient);
            ResourceStorage storage = new EventBusResourceStorage(vertx.eventBus(), Address.storageAddress() + "-main");
            MonitoringHandler monitoringHandler = new MonitoringHandler(vertx, storage, PREFIX);
            ConfigurationResourceManager configurationResourceManager = new ConfigurationResourceManager(vertx, storage);
            String eventBusConfigurationResource = SERVER_ROOT + "/admin/v1/hookconfig";
            EventBusHandler eventBusHandler = new EventBusHandler(vertx, SERVER_ROOT + "/event/v1/", SERVER_ROOT + "/event/v1/sock/", "event-", "channels/([^/]+).*", configurationResourceManager, eventBusConfigurationResource);
            eventBusHandler.setEventbusBridgePingInterval(RunConfig.EVENTBUS_BRIDGE_PING_INTERVAL);
            LoggingResourceManager loggingResourceManager = new LoggingResourceManager(vertx, storage, SERVER_ROOT + "/admin/v1/logging");
            UserProfileHandler userProfileHandler = new UserProfileHandler(vertx, storage, RunConfig.buildUserProfileConfiguration());
            RoleProfileHandler roleProfileHandler = new RoleProfileHandler(vertx, storage, SERVER_ROOT + "/roles/v1/([^/]+)/profile");
            qosHandler = new QoSHandler(vertx, storage, SERVER_ROOT + "/admin/v1/qos", props, PREFIX);
            Lock lock = new RedisBasedLock(redisClient);
            QueueClient queueClient = new QueueClient(vertx, monitoringHandler);
            ReducedPropagationManager reducedPropagationManager = new ReducedPropagationManager(vertx, new RedisReducedPropagationStorage(redisAPI), queueClient, lock);
            reducedPropagationManager.startExpiredQueueProcessing(1000);
            hookHandler = new HookHandler(vertx, selfClient, storage, loggingResourceManager, monitoringHandler, SERVER_ROOT + "/users/v1/%s/profile", ROOT + "/server/hooks/v1/", queueClient, false, reducedPropagationManager);
            propertyHandler = new PropertyHandler(ROOT, props);
            schedulerResourceManager = new SchedulerResourceManager(vertx, redisAPI, storage, monitoringHandler, SERVER_ROOT + "/admin/v1/schedulers");
            ResetMetricsController resetMetricsController = new ResetMetricsController(vertx);
            resetMetricsController.registerResetMetricsControlMBean(JMX_DOMAIN, PREFIX);
            LogController logController = new LogController();
            logController.registerLogConfiguratorMBean(JMX_DOMAIN);
            ZipExtractHandler zipExtractHandler = new ZipExtractHandler(selfClient);
            DelegateHandler delegateHandler = new DelegateHandler(vertx, selfClient, storage, monitoringHandler, DELEGATE_ROOT, props, null);
            MergeHandler mergeHandler = new MergeHandler(selfClient);
            cacheHandler = new CacheHandler(new DefaultCacheDataFetcher(new ClientRequestCreator(selfClient)), new RedisCacheStorage(vertx, lock, redisAPI, 60000), SERVER_ROOT + "/cache");
            customHttpResponseHandler = new CustomHttpResponseHandler(RETURN_HTTP_STATUS_ROOT);
            // ------
            RuleProvider ruleProvider = new RuleProvider(vertx, RULES_ROOT, storage, props);
            QueueCircuitBreakerRulePatternToCircuitMapping rulePatternToCircuitMapping = new QueueCircuitBreakerRulePatternToCircuitMapping();
            QueueCircuitBreakerConfigurationResourceManager queueCircuitBreakerConfigurationResourceManager = new QueueCircuitBreakerConfigurationResourceManager(vertx, storage, SERVER_ROOT + "/admin/v1/circuitbreaker");
            QueueCircuitBreakerStorage queueCircuitBreakerStorage = new RedisQueueCircuitBreakerStorage(redisAPI);
            QueueCircuitBreakerHttpRequestHandler requestHandler = new QueueCircuitBreakerHttpRequestHandler(vertx, queueCircuitBreakerStorage, SERVER_ROOT + "/queuecircuitbreaker/circuit");
            QueueCircuitBreaker queueCircuitBreaker = new QueueCircuitBreakerImpl(vertx, lock, Address.redisquesAddress(), queueCircuitBreakerStorage, ruleProvider, rulePatternToCircuitMapping, queueCircuitBreakerConfigurationResourceManager, requestHandler, CIRCUIT_BREAKER_REST_API_PORT);
            new QueueProcessor(vertx, selfClient, monitoringHandler, queueCircuitBreaker);
            final QueueBrowser queueBrowser = new QueueBrowser(vertx, SERVER_ROOT + "/queuing", Address.redisquesAddress(), monitoringHandler);
            new CustomRedisMonitor(vertx, redisAPI, "main", "rest-storage", 10).start();
            Router router = new Router(vertx, storage, props, loggingResourceManager, monitoringHandler, selfClient, SERVER_ROOT, SERVER_ROOT + "/admin/v1/routing/rules", SERVER_ROOT + "/users/v1/%s/profile", info, STORAGE_PORT, (Handler<Void>) aVoid -> {
                System.out.println("Router initialized!");
                hookHandler.init();
                delegateHandler.init();
            });
            router.enableRoutingConfiguration(configurationResourceManager, SERVER_ROOT + "/admin/v1/routing/config");
            System.setProperty("org.swisspush.gateleen.addcorsheaders", "true");
            RunConfig runConfig = RunConfig.with().cacheHandler(cacheHandler).corsHandler(new CORSHandler()).deltaHandler(new DeltaHandler(redisAPI, selfClient, ruleProvider)).expansionHandler(new ExpansionHandler(vertx, storage, selfClient, props, ROOT, RULES_ROOT)).hookHandler(hookHandler).qosHandler(qosHandler).copyResourceHandler(new CopyResourceHandler(selfClient, SERVER_ROOT + "/v1/copy")).eventBusHandler(eventBusHandler).roleProfileHandler(roleProfileHandler).userProfileHandler(userProfileHandler).loggingResourceManager(loggingResourceManager).configurationResourceManager(configurationResourceManager).queueCircuitBreakerConfigurationResourceManager(queueCircuitBreakerConfigurationResourceManager).schedulerResourceManager(schedulerResourceManager).propertyHandler(propertyHandler).zipExtractHandler(zipExtractHandler).delegateHandler(delegateHandler).mergeHandler(mergeHandler).customHttpResponseHandler(customHttpResponseHandler).build(vertx, redisAPI, AbstractTest.class, router, monitoringHandler, queueBrowser);
            Handler<RoutingContext> routingContextHandlerrNew = runConfig.buildRoutingContextHandler();
            selfClient.setRoutingContexttHandler(routingContextHandlerrNew);
            mainServer = vertx.createHttpServer();
            io.vertx.ext.web.Router vertxRouter = io.vertx.ext.web.Router.router(vertx);
            eventBusHandler.install(vertxRouter);
            vertxRouter.route().handler(routingContextHandlerrNew);
            mainServer.requestHandler(vertxRouter);
            mainServer.listen(MAIN_PORT, event -> {
                if (event.succeeded()) {
                    async.complete();
                } else {
                    context.fail("Server not listening on port " + MAIN_PORT);
                }
            });
        }
    });
    async.awaitSuccess();
}

Example 3 with CacheHandler

use of org.swisspush.gateleen.cache.CacheHandler in project gateleen by swisspush.

the class Server method start.

@Override
public void start() {
    final LocalHttpClient selfClient = new LocalHttpClient(vertx);
    final JsonObject info = new JsonObject();
    final Map<String, Object> props = RunConfig.buildRedisProps("localhost", defaultRedisPort);
    /*
         * Just for demonstration purposes. In real-life use a request header name to group the requests
         * and set it as vm option like -Dorg.swisspush.request.rule.property=MY_HEADER_NAME
         */
    System.setProperty(MonitoringHandler.REQUEST_PER_RULE_PROPERTY, "x-appid");
    try {
        String externalConfig = System.getProperty("org.swisspush.config.dir") + "/config.properties";
        Resource externalConfigResource = new FileSystemResource(externalConfig);
        if (externalConfigResource.exists()) {
            log.info("Merging external config {}", externalConfig);
            props.putAll(RunConfig.subMap(new ResourcePropertySource(externalConfigResource).getSource(), "redis."));
        } else {
            log.info("No external config found under {}", externalConfig);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    String redisHost = (String) props.get("redis.host");
    Integer redisPort = (Integer) props.get("redis.port");
    props.put(ExpansionHandler.MAX_EXPANSION_LEVEL_HARD_PROPERTY, "100");
    props.put(ExpansionHandler.MAX_EXPANSION_LEVEL_SOFT_PROPERTY, "50");
    RunConfig.deployModules(vertx, Server.class, props, success -> {
        if (success) {
            redisClient = new RedisClient(vertx, new RedisOptions().setConnectionString("redis://" + redisHost + ":" + redisPort));
            redisApi = RedisAPI.api(redisClient);
            new CustomRedisMonitor(vertx, redisApi, "main", "rest-storage", 10).start();
            storage = new EventBusResourceStorage(vertx.eventBus(), Address.storageAddress() + "-main");
            corsHandler = new CORSHandler();
            RuleProvider ruleProvider = new RuleProvider(vertx, RULES_ROOT, storage, props);
            deltaHandler = new DeltaHandler(redisApi, selfClient, ruleProvider, true);
            expansionHandler = new ExpansionHandler(ruleProvider, selfClient, props, ROOT);
            copyResourceHandler = new CopyResourceHandler(selfClient, SERVER_ROOT + "/v1/copy");
            monitoringHandler = new MonitoringHandler(vertx, storage, PREFIX, SERVER_ROOT + "/monitoring/rpr");
            Lock lock = new RedisBasedLock(redisClient);
            cacheStorage = new RedisCacheStorage(vertx, lock, redisApi, 20 * 1000);
            cacheDataFetcher = new DefaultCacheDataFetcher(new ClientRequestCreator(selfClient));
            cacheHandler = new CacheHandler(cacheDataFetcher, cacheStorage, SERVER_ROOT + "/cache");
            qosHandler = new QoSHandler(vertx, storage, SERVER_ROOT + "/admin/v1/qos", props, PREFIX);
            qosHandler.enableResourceLogging(true);
            configurationResourceManager = new ConfigurationResourceManager(vertx, storage);
            configurationResourceManager.enableResourceLogging(true);
            eventBusHandler = new EventBusHandler(vertx, SERVER_ROOT + "/event/v1/", SERVER_ROOT + "/event/v1/sock/", "event/channels/", "channels/([^/]+).*", configurationResourceManager, SERVER_ROOT + "/admin/v1/hookconfig");
            eventBusHandler.setEventbusBridgePingInterval(RunConfig.EVENTBUS_BRIDGE_PING_INTERVAL);
            loggingResourceManager = new LoggingResourceManager(vertx, storage, SERVER_ROOT + "/admin/v1/logging");
            loggingResourceManager.enableResourceLogging(true);
            ContentTypeConstraintRepository repository = new ContentTypeConstraintRepository();
            contentTypeConstraintHandler = new ContentTypeConstraintHandler(configurationResourceManager, repository, SERVER_ROOT + "/admin/v1/contentTypeConstraints", Arrays.asList(new PatternHolder("application/json"), new PatternHolder("application/x-www-form-urlencoded")));
            contentTypeConstraintHandler.initialize();
            userProfileHandler = new UserProfileHandler(vertx, storage, RunConfig.buildUserProfileConfiguration());
            userProfileHandler.enableResourceLogging(true);
            roleProfileHandler = new RoleProfileHandler(vertx, storage, SERVER_ROOT + "/roles/v1/([^/]+)/profile");
            roleProfileHandler.enableResourceLogging(true);
            QueueClient queueClient = new QueueClient(vertx, monitoringHandler);
            reducedPropagationManager = new ReducedPropagationManager(vertx, new RedisReducedPropagationStorage(redisApi), queueClient, lock);
            reducedPropagationManager.startExpiredQueueProcessing(5000);
            hookHandler = new HookHandler(vertx, selfClient, storage, loggingResourceManager, monitoringHandler, SERVER_ROOT + "/users/v1/%s/profile", SERVER_ROOT + "/hooks/v1/", queueClient, false, reducedPropagationManager);
            hookHandler.enableResourceLogging(true);
            authorizer = new Authorizer(vertx, storage, SERVER_ROOT + "/security/v1/", ROLE_PATTERN, ROLE_PREFIX, props);
            authorizer.enableResourceLogging(true);
            validationResourceManager = new ValidationResourceManager(vertx, storage, SERVER_ROOT + "/admin/v1/validation");
            validationResourceManager.enableResourceLogging(true);
            validationSchemaProvider = new DefaultValidationSchemaProvider(vertx, new ClientRequestCreator(selfClient), Duration.ofSeconds(30));
            validator = new Validator(storage, ROOT + "/schemas/apis/", validationSchemaProvider);
            validationHandler = new ValidationHandler(validationResourceManager, selfClient, validator);
            KafkaProducerRepository kafkaProducerRepository = new KafkaProducerRepository(vertx);
            KafkaMessageSender kafkaMessageSender = new KafkaMessageSender();
            KafkaMessageValidator messageValidator = new KafkaMessageValidator(validationResourceManager, validator);
            kafkaHandler = new KafkaHandler(configurationResourceManager, messageValidator, kafkaProducerRepository, kafkaMessageSender, SERVER_ROOT + "/admin/v1/kafka/topicsConfig", SERVER_ROOT + "/streaming/");
            kafkaHandler.initialize();
            schedulerResourceManager = new SchedulerResourceManager(vertx, redisApi, storage, monitoringHandler, SERVER_ROOT + "/admin/v1/schedulers");
            schedulerResourceManager.enableResourceLogging(true);
            zipExtractHandler = new ZipExtractHandler(selfClient);
            delegateHandler = new DelegateHandler(vertx, selfClient, storage, monitoringHandler, SERVER_ROOT + "/admin/v1/delegates/", props, null);
            delegateHandler.enableResourceLogging(true);
            customHttpResponseHandler = new CustomHttpResponseHandler(RETURN_HTTP_STATUS_ROOT);
            router = Router.builder().withServerPath(SERVER_ROOT).withRulesPath(SERVER_ROOT + "/admin/v1/routing/rules").withUserProfilePath(SERVER_ROOT + "/users/v1/%s/profile").withVertx(vertx).withSelfClient(selfClient).withStorage(storage).withStoragePort(storagePort).withInfo(info).withMonitoringHandler(monitoringHandler).withLoggingResourceManager(loggingResourceManager).withResourceLogging(true).withRoutingConfiguration(configurationResourceManager, SERVER_ROOT + "/admin/v1/routing/config").withHttpClientFactory(this::createHttpClientForRouter).addDoneHandler(aVoid -> {
                hookHandler.init();
                delegateHandler.init();
            }).build();
            QueueCircuitBreakerRulePatternToCircuitMapping rulePatternToCircuitMapping = new QueueCircuitBreakerRulePatternToCircuitMapping();
            queueCircuitBreakerConfigurationResourceManager = new QueueCircuitBreakerConfigurationResourceManager(vertx, storage, SERVER_ROOT + "/admin/v1/circuitbreaker");
            queueCircuitBreakerConfigurationResourceManager.enableResourceLogging(true);
            QueueCircuitBreakerStorage queueCircuitBreakerStorage = new RedisQueueCircuitBreakerStorage(redisApi);
            QueueCircuitBreakerHttpRequestHandler requestHandler = new QueueCircuitBreakerHttpRequestHandler(vertx, queueCircuitBreakerStorage, SERVER_ROOT + "/queuecircuitbreaker/circuit");
            QueueCircuitBreaker queueCircuitBreaker = new QueueCircuitBreakerImpl(vertx, lock, Address.redisquesAddress(), queueCircuitBreakerStorage, ruleProvider, rulePatternToCircuitMapping, queueCircuitBreakerConfigurationResourceManager, requestHandler, circuitBreakerPort);
            new QueueProcessor(vertx, selfClient, monitoringHandler, queueCircuitBreaker);
            final QueueBrowser queueBrowser = new QueueBrowser(vertx, SERVER_ROOT + "/queuing", Address.redisquesAddress(), monitoringHandler);
            LogController logController = new LogController();
            logController.registerLogConfiguratorMBean(JMX_DOMAIN);
            ResetMetricsController resetMetricsController = new ResetMetricsController(vertx);
            resetMetricsController.registerResetMetricsControlMBean(JMX_DOMAIN, PREFIX);
            RunConfig runConfig = RunConfig.with().authorizer(authorizer).validationResourceManager(validationResourceManager).validationHandler(validationHandler).cacheHandler(cacheHandler).corsHandler(corsHandler).deltaHandler(deltaHandler).expansionHandler(expansionHandler).hookHandler(hookHandler).qosHandler(qosHandler).copyResourceHandler(copyResourceHandler).eventBusHandler(eventBusHandler).kafkaHandler(kafkaHandler).roleProfileHandler(roleProfileHandler).userProfileHandler(userProfileHandler).loggingResourceManager(loggingResourceManager).configurationResourceManager(configurationResourceManager).queueCircuitBreakerConfigurationResourceManager(queueCircuitBreakerConfigurationResourceManager).schedulerResourceManager(schedulerResourceManager).zipExtractHandler(zipExtractHandler).delegateHandler(delegateHandler).customHttpResponseHandler(customHttpResponseHandler).contentTypeConstraintHandler(contentTypeConstraintHandler).build(vertx, redisApi, Server.class, router, monitoringHandler, queueBrowser);
            Handler<RoutingContext> routingContextHandlerrNew = runConfig.buildRoutingContextHandler();
            selfClient.setRoutingContexttHandler(routingContextHandlerrNew);
            HttpServerOptions options = new HttpServerOptions();
            // till vertx2 100-continues was performed automatically (per default),
            // since vertx3 it is off per default.
            options.setHandle100ContinueAutomatically(true);
            mainServer = vertx.createHttpServer(options);
            io.vertx.ext.web.Router vertxRouter = io.vertx.ext.web.Router.router(vertx);
            eventBusHandler.install(vertxRouter);
            vertxRouter.route().handler(routingContextHandlerrNew);
            mainServer.requestHandler(vertxRouter);
            mainServer.listen(mainPort);
        }
    });
}

Example 4 with CacheHandler

use of org.swisspush.gateleen.cache.CacheHandler in project gateleen by swisspush.

the class CacheHandlerTest method testOnlyGETRequestsWithCacheControlHeadersAreHandled.

@Test
public void testOnlyGETRequestsWithCacheControlHeadersAreHandled(TestContext context) {
    when(cacheStorage.cachedRequest(anyString())).thenReturn(Future.succeededFuture(Optional.of(bufferFromJson(new JsonObject()))));
    HttpServerResponse response = spy(new Response());
    Request putRequest = new Request(HttpMethod.PUT, "/some/path", MultiMap.caseInsensitiveMultiMap(), response);
    context.assertFalse(cacheHandler.handle(putRequest));
    Request getRequestNoHeaders = new Request(HttpMethod.GET, "/some/path", MultiMap.caseInsensitiveMultiMap(), response);
    context.assertFalse(cacheHandler.handle(getRequestNoHeaders));
    MultiMap headers = MultiMap.caseInsensitiveMultiMap();
    headers.add("foo", "bar");
    Request getRequestOtherHeaders = new Request(HttpMethod.GET, "/some/path", headers, response);
    context.assertFalse(cacheHandler.handle(getRequestOtherHeaders));
    headers = MultiMap.caseInsensitiveMultiMap();
    headers.add(DEFAULT_CACHE_CONTROL_HEADER, "max-age=120");
    Request getRequestWithCacheControlHeaders = new Request(HttpMethod.GET, "/some/path", headers, response);
    context.assertTrue(cacheHandler.handle(getRequestWithCacheControlHeaders));
    // custom cache control header
    cacheHandler = new CacheHandler(dataFetcher, cacheStorage, "/playground/server/cache", "x-cache-control");
    headers = new HeadersMultiMap();
    headers.add("x-cache-control", "max-age=120");
    Request getRequestWithCustomCacheControlHeaders = new Request(HttpMethod.GET, "/some/path", headers, response);
    context.assertTrue(cacheHandler.handle(getRequestWithCustomCacheControlHeaders));
}