Examples with Lock org.swisspush.gateleen.core.lock.Lock used on opensource projects

Example 1 with Lock

use of org.swisspush.gateleen.core.lock.Lock in project gateleen by swisspush.

the class QueueCircuitBreakerImplTest method setUp.

@Before
public void setUp() {
    vertx = Vertx.vertx();
    lock = Mockito.mock(Lock.class);
    Mockito.when(lock.acquireLock(Matchers.anyString(), Matchers.anyString(), Matchers.anyLong())).thenReturn(Future.succeededFuture(Boolean.TRUE));
    Mockito.when(lock.releaseLock(Matchers.anyString(), Matchers.anyString())).thenReturn(Future.succeededFuture(Boolean.TRUE));
    storage = Mockito.mock(ResourceStorage.class);
    queueCircuitBreakerStorage = Mockito.mock(QueueCircuitBreakerStorage.class);
    Mockito.when(queueCircuitBreakerStorage.setOpenCircuitsToHalfOpen()).thenReturn(Future.succeededFuture(0L));
    Mockito.when(queueCircuitBreakerStorage.popQueueToUnlock()).thenReturn(Future.succeededFuture("SomeQueue"));
    Mockito.when(queueCircuitBreakerStorage.unlockSampleQueues()).thenReturn(Future.succeededFuture(MultiType.EMPTY_MULTI));
    ruleProvider = new RuleProvider(vertx, "/path/to/routing/rules", storage, props);
    ruleToCircuitMapping = Mockito.mock(QueueCircuitBreakerRulePatternToCircuitMapping.class);
    configResourceManager = Mockito.mock(QueueCircuitBreakerConfigurationResourceManager.class);
    QueueCircuitBreakerConfigurationResource config = new QueueCircuitBreakerConfigurationResource();
    config.setOpenToHalfOpenTaskEnabled(true);
    config.setOpenToHalfOpenTaskInterval(1000);
    config.setUnlockQueuesTaskEnabled(true);
    config.setUnlockQueuesTaskInterval(1000);
    config.setUnlockSampleQueuesTaskEnabled(true);
    config.setUnlockSampleQueuesTaskInterval(1000);
    Mockito.when(configResourceManager.getConfigurationResource()).thenReturn(config);
    Handler<HttpServerRequest> queueCircuitBreakerHttpRequestHandler = Mockito.mock(Handler.class);
    queueCircuitBreaker = Mockito.spy(new QueueCircuitBreakerImpl(vertx, lock, Address.redisquesAddress(), queueCircuitBreakerStorage, ruleProvider, ruleToCircuitMapping, configResourceManager, queueCircuitBreakerHttpRequestHandler, 9999));
}

Example 2 with Lock

use of org.swisspush.gateleen.core.lock.Lock in project gateleen by swisspush.

the class RedisCacheStorageTest method setUp.

@Before
public void setUp() {
    vertx = Vertx.vertx();
    lock = Mockito.mock(Lock.class);
    Mockito.when(lock.acquireLock(anyString(), anyString(), anyLong())).thenReturn(Future.succeededFuture(Boolean.TRUE));
    Mockito.when(lock.releaseLock(anyString(), anyString())).thenReturn(Future.succeededFuture(Boolean.TRUE));
    redisCacheStorage = new RedisCacheStorage(vertx, lock, RedisAPI.api(new RedisClient(vertx, new RedisOptions())), 2000);
    jedis = new Jedis(new HostAndPort("localhost", 6379));
    try {
        jedis.flushAll();
    } catch (JedisConnectionException e) {
        org.junit.Assume.assumeNoException("Ignoring this test because no running redis is available. This is the case during release", e);
    }
}

Example 3 with Lock

use of org.swisspush.gateleen.core.lock.Lock 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 4 with Lock

use of org.swisspush.gateleen.core.lock.Lock in project gateleen by swisspush.

the class ReducedPropagationManagerTest method testExpiredQueueProcessingDeleteAllQueueItemsAndDeleteLockOfQueueSuccess.

@Test
public void testExpiredQueueProcessingDeleteAllQueueItemsAndDeleteLockOfQueueSuccess(TestContext context) {
    Async async = context.async();
    JsonObject requestJsonObject = new HttpRequest(HttpMethod.PUT, "/my/uri", MultiMap.caseInsensitiveMultiMap(), null).toJsonObject();
    String expiredQueue = "myExpiredQueue";
    String managerQueue = MANAGER_QUEUE_PREFIX + expiredQueue;
    Mockito.when(reducedPropagationStorage.getQueueRequest(anyString())).thenReturn(Future.succeededFuture(requestJsonObject));
    Mockito.when(requestQueue.deleteAllQueueItems(eq(managerQueue), anyBoolean())).thenReturn(Future.succeededFuture());
    Mockito.when(requestQueue.enqueueFuture(any(), anyString())).thenReturn(Future.succeededFuture());
    Mockito.when(reducedPropagationStorage.removeQueueRequest(eq(expiredQueue))).thenReturn(Future.succeededFuture());
    Mockito.when(requestQueue.deleteAllQueueItems(eq(expiredQueue), anyBoolean())).thenReturn(Future.succeededFuture());
    vertx.eventBus().request(PROCESSOR_ADDRESS, expiredQueue, (Handler<AsyncResult<Message<JsonObject>>>) event -> {
        context.assertTrue(event.succeeded());
        context.assertEquals(OK, event.result().body().getString(STATUS));
        context.assertEquals("Successfully deleted lock and all queue items of queue myExpiredQueue", event.result().body().getString(MESSAGE));
        verify(reducedPropagationStorage, timeout(1000).times(1)).getQueueRequest(eq(expiredQueue));
        verify(requestQueue, timeout(1000).times(1)).deleteAllQueueItems(eq(managerQueue), eq(false));
        verify(requestQueue, timeout(1000).times(1)).enqueueFuture(any(), eq(managerQueue));
        verify(reducedPropagationStorage, timeout(1000).times(1)).removeQueueRequest(eq(expiredQueue));
        verify(requestQueue, timeout(1000).times(1)).deleteAllQueueItems(eq(expiredQueue), eq(true));
        async.complete();
    });
}

Example 5 with Lock

use of org.swisspush.gateleen.core.lock.Lock in project gateleen by swisspush.

the class ReducedPropagationManager method processExpiredQueues.

private void processExpiredQueues(String lockToken) {
    log.debug("Going to process expired queues");
    storage.removeExpiredQueues(System.currentTimeMillis()).onComplete(event -> {
        if (event.failed()) {
            log.error("Going to release lock because process expired queues failed. Cause: " + event.cause());
            releaseLock(this.lock, PROCESS_EXPIRED_QUEUES_LOCK, lockToken, log);
            return;
        }
        Response response = event.result();
        log.debug("Got {} expired queues to process", response.size());
        for (Response expiredQueue : response) {
            log.debug("About to notify a consumer to process expired queue '{}'", expiredQueue);
            vertx.eventBus().request(PROCESSOR_ADDRESS, expiredQueue.toString(), (Handler<AsyncResult<Message<JsonObject>>>) event1 -> {
                if (event1.failed()) {
                    log.error("Failed to process expired queue '{}'. Cause: {}", expiredQueue, event1.cause());
                    handleFailedQueueRetry(expiredQueue.toString());
                } else {
                    failedQueueRetries.remove(expiredQueue.toString());
                    if (!OK.equals(event1.result().body().getString(STATUS))) {
                        log.error("Failed to process expired queue '{}'. Message: {}", expiredQueue, event1.result().body().getString(MESSAGE));
                    } else {
                        if (log.isDebugEnabled()) {
                            log.debug(event1.result().body().getString(MESSAGE));
                        }
                    }
                }
            });
        }
    });
}