Examples with BaseStatusListener org.redisson.api.listener.BaseStatusListener used on opensource projects

Example 1 with BaseStatusListener

use of org.redisson.api.listener.BaseStatusListener in project redisson by redisson.

the class RedissonTopicTest method testStatus.

@Test
public void testStatus() throws InterruptedException {
    RedissonClient redisson = BaseTest.createInstance();
    final RTopic<Message> topic1 = redisson.getTopic("topic1");
    final CountDownLatch l = new CountDownLatch(1);
    int listenerId = topic1.addListener(new BaseStatusListener() {

        @Override
        public void onSubscribe(String channel) {
            Assert.assertEquals("topic1", channel);
            l.countDown();
        }
    });
    Thread.sleep(500);
    int listenerId2 = topic1.addListener(new BaseStatusListener() {

        @Override
        public void onUnsubscribe(String channel) {
            Assert.assertEquals("topic1", channel);
            l.countDown();
        }
    });
    topic1.removeListener(listenerId);
    topic1.removeListener(listenerId2);
    Assert.assertTrue(l.await(5, TimeUnit.SECONDS));
}

Example 2 with BaseStatusListener

use of org.redisson.api.listener.BaseStatusListener in project redisson by redisson.

the class QueueTransferTask method start.

public void start() {
    RTopic schedulerTopic = getTopic();
    statusListenerId = schedulerTopic.addListener(new BaseStatusListener() {

        @Override
        public void onSubscribe(String channel) {
            pushTask();
        }
    });
    messageListenerId = schedulerTopic.addListener(Long.class, new MessageListener<Long>() {

        @Override
        public void onMessage(CharSequence channel, Long startTime) {
            scheduleTask(startTime);
        }
    });
}

Example 3 with BaseStatusListener

use of org.redisson.api.listener.BaseStatusListener in project redisson by redisson.

the class LocalCacheListener method add.

public void add(Map<?, ?> cache) {
    this.cache = cache;
    invalidationTopic = RedissonTopic.createRaw(LocalCachedMessageCodec.INSTANCE, commandExecutor, getInvalidationTopicName());
    if (options.getReconnectionStrategy() != ReconnectionStrategy.NONE) {
        reconnectionListenerId = invalidationTopic.addListener(new BaseStatusListener() {

            @Override
            public void onSubscribe(String channel) {
                if (options.getReconnectionStrategy() == ReconnectionStrategy.CLEAR) {
                    cache.clear();
                }
                if (options.getReconnectionStrategy() == ReconnectionStrategy.LOAD && // check if instance has already been used
                lastInvalidate > 0) {
                    loadAfterReconnection();
                }
            }
        });
    }
    if (options.getSyncStrategy() != SyncStrategy.NONE) {
        syncListenerId = invalidationTopic.addListener(Object.class, new MessageListener<Object>() {

            @Override
            public void onMessage(CharSequence channel, Object msg) {
                if (msg instanceof LocalCachedMapDisable) {
                    LocalCachedMapDisable m = (LocalCachedMapDisable) msg;
                    String requestId = m.getRequestId();
                    Set<CacheKey> keysToDisable = new HashSet<CacheKey>();
                    for (byte[] keyHash : ((LocalCachedMapDisable) msg).getKeyHashes()) {
                        CacheKey key = new CacheKey(keyHash);
                        keysToDisable.add(key);
                    }
                    disableKeys(requestId, keysToDisable, m.getTimeout());
                    RedissonTopic topic = RedissonTopic.createRaw(LocalCachedMessageCodec.INSTANCE, commandExecutor, RedissonObject.suffixName(name, requestId + DISABLED_ACK_SUFFIX));
                    topic.publishAsync(new LocalCachedMapDisableAck());
                }
                if (msg instanceof LocalCachedMapEnable) {
                    LocalCachedMapEnable m = (LocalCachedMapEnable) msg;
                    for (byte[] keyHash : m.getKeyHashes()) {
                        CacheKey key = new CacheKey(keyHash);
                        disabledKeys.remove(key, m.getRequestId());
                    }
                }
                if (msg instanceof LocalCachedMapClear) {
                    LocalCachedMapClear clearMsg = (LocalCachedMapClear) msg;
                    if (!Arrays.equals(clearMsg.getExcludedId(), instanceId)) {
                        cache.clear();
                        if (clearMsg.isReleaseSemaphore()) {
                            RSemaphore semaphore = getClearSemaphore(clearMsg.getRequestId());
                            semaphore.releaseAsync();
                        }
                    }
                }
                if (msg instanceof LocalCachedMapInvalidate) {
                    LocalCachedMapInvalidate invalidateMsg = (LocalCachedMapInvalidate) msg;
                    if (!Arrays.equals(invalidateMsg.getExcludedId(), instanceId)) {
                        for (byte[] keyHash : invalidateMsg.getKeyHashes()) {
                            CacheKey key = new CacheKey(keyHash);
                            cache.remove(key);
                        }
                    }
                }
                if (msg instanceof LocalCachedMapUpdate) {
                    LocalCachedMapUpdate updateMsg = (LocalCachedMapUpdate) msg;
                    if (!Arrays.equals(updateMsg.getExcludedId(), instanceId)) {
                        for (LocalCachedMapUpdate.Entry entry : updateMsg.getEntries()) {
                            ByteBuf keyBuf = Unpooled.wrappedBuffer(entry.getKey());
                            ByteBuf valueBuf = Unpooled.wrappedBuffer(entry.getValue());
                            try {
                                updateCache(keyBuf, valueBuf);
                            } catch (IOException e) {
                                log.error("Can't decode map entry", e);
                            } finally {
                                keyBuf.release();
                                valueBuf.release();
                            }
                        }
                    }
                }
                if (options.getReconnectionStrategy() == ReconnectionStrategy.LOAD) {
                    lastInvalidate = System.currentTimeMillis();
                }
            }
        });
        String disabledKeysName = RedissonObject.suffixName(name, DISABLED_KEYS_SUFFIX);
        RListMultimapCache<LocalCachedMapDisabledKey, String> multimap = new RedissonListMultimapCache<LocalCachedMapDisabledKey, String>(null, codec, commandExecutor, disabledKeysName);
        for (LocalCachedMapDisabledKey key : multimap.readAllKeySet()) {
            Set<CacheKey> keysToDisable = new HashSet<CacheKey>();
            for (String hash : multimap.getAll(key)) {
                CacheKey cacheKey = new CacheKey(ByteBufUtil.decodeHexDump(hash));
                keysToDisable.add(cacheKey);
            }
            disableKeys(key.getRequestId(), keysToDisable, key.getTimeout());
        }
    }
}