Examples with PubSubConnectionEntry org.redisson.pubsub.PubSubConnectionEntry used on opensource projects

Example 1 with PubSubConnectionEntry

use of org.redisson.pubsub.PubSubConnectionEntry in project redisson by redisson.

the class RedissonPatternTopic method removeAllListeners.

@Override
public void removeAllListeners() {
    AsyncSemaphore semaphore = subscribeService.getSemaphore(channelName);
    acquire(semaphore);
    PubSubConnectionEntry entry = subscribeService.getPubSubEntry(channelName);
    if (entry == null) {
        semaphore.release();
        return;
    }
    if (entry.hasListeners(channelName)) {
        subscribeService.unsubscribe(PubSubType.PUNSUBSCRIBE, channelName).toCompletableFuture().join();
    }
    semaphore.release();
}

Example 2 with PubSubConnectionEntry

use of org.redisson.pubsub.PubSubConnectionEntry in project redisson by redisson.

the class RedissonTopic method removeAllListeners.

@Override
public void removeAllListeners() {
    AsyncSemaphore semaphore = subscribeService.getSemaphore(channelName);
    acquire(semaphore);
    PubSubConnectionEntry entry = subscribeService.getPubSubEntry(channelName);
    if (entry == null) {
        semaphore.release();
        return;
    }
    if (entry.hasListeners(channelName)) {
        subscribeService.unsubscribe(PubSubType.UNSUBSCRIBE, channelName).toCompletableFuture().join();
    }
    semaphore.release();
}

Example 3 with PubSubConnectionEntry

use of org.redisson.pubsub.PubSubConnectionEntry in project redisson by redisson.

the class RedissonReactiveSubscription method receive.

@Override
public Flux<Message<ByteBuffer, ByteBuffer>> receive() {
    if (flux.get() != null) {
        return flux.get();
    }
    Flux<Message<ByteBuffer, ByteBuffer>> f = Flux.create(emitter -> {
        emitter.onRequest(n -> {
            monosListener.addListener(() -> {
                BaseRedisPubSubListener listener = new BaseRedisPubSubListener() {

                    @Override
                    public void onPatternMessage(CharSequence pattern, CharSequence channel, Object message) {
                        if (!patterns.containsKey(new ChannelName(pattern.toString()))) {
                            return;
                        }
                        emitter.next(new PatternMessage<>(ByteBuffer.wrap(pattern.toString().getBytes()), ByteBuffer.wrap(channel.toString().getBytes()), ByteBuffer.wrap((byte[]) message)));
                    }

                    @Override
                    public void onMessage(CharSequence channel, Object msg) {
                        if (!channels.containsKey(new ChannelName(channel.toString()))) {
                            return;
                        }
                        emitter.next(new ChannelMessage<>(ByteBuffer.wrap(channel.toString().getBytes()), ByteBuffer.wrap((byte[]) msg)));
                    }
                };
                disposable = () -> {
                    for (Entry<ChannelName, PubSubConnectionEntry> entry : channels.entrySet()) {
                        entry.getValue().removeListener(entry.getKey(), listener);
                    }
                    for (Entry<ChannelName, Collection<PubSubConnectionEntry>> entry : patterns.entrySet()) {
                        for (PubSubConnectionEntry pubSubConnectionEntry : entry.getValue()) {
                            pubSubConnectionEntry.removeListener(entry.getKey(), listener);
                        }
                    }
                };
                for (Entry<ChannelName, PubSubConnectionEntry> entry : channels.entrySet()) {
                    entry.getValue().addListener(entry.getKey(), listener);
                }
                for (Entry<ChannelName, Collection<PubSubConnectionEntry>> entry : patterns.entrySet()) {
                    for (PubSubConnectionEntry pubSubConnectionEntry : entry.getValue()) {
                        pubSubConnectionEntry.addListener(entry.getKey(), listener);
                    }
                }
                emitter.onDispose(disposable);
            });
        });
    });
    if (flux.compareAndSet(null, f)) {
        return f;
    }
    return flux.get();
}

Example 4 with PubSubConnectionEntry

use of org.redisson.pubsub.PubSubConnectionEntry in project redisson by redisson.

the class RedissonReactiveSubscription method unsubscribe.

@Override
public Mono<Void> unsubscribe(ByteBuffer... channels) {
    monosListener.acquire();
    return Mono.defer(() -> {
        List<CompletableFuture<?>> futures = new ArrayList<>(channels.length);
        for (ByteBuffer channel : channels) {
            ChannelName cn = toChannelName(channel);
            CompletableFuture<Codec> f = subscribeService.unsubscribe(cn, PubSubType.UNSUBSCRIBE);
            f = f.whenComplete((res, e) -> {
                synchronized (RedissonReactiveSubscription.this.channels) {
                    PubSubConnectionEntry entry = RedissonReactiveSubscription.this.channels.get(cn);
                    if (!entry.hasListeners(cn)) {
                        RedissonReactiveSubscription.this.channels.remove(cn);
                    }
                }
            });
            futures.add(f);
        }
        CompletableFuture<Void> future = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        future = future.whenComplete((r, e) -> {
            monosListener.release();
        });
        return Mono.fromFuture(future);
    });
}

Example 5 with PubSubConnectionEntry

use of org.redisson.pubsub.PubSubConnectionEntry in project redisson by redisson.

the class RedissonReactiveSubscription method pSubscribe.

@Override
public Mono<Void> pSubscribe(ByteBuffer... patterns) {
    monosListener.acquire();
    return Mono.defer(() -> {
        List<CompletableFuture<?>> futures = new ArrayList<>();
        for (ByteBuffer channel : patterns) {
            ChannelName cn = toChannelName(channel);
            CompletableFuture<Collection<PubSubConnectionEntry>> f = subscribeService.psubscribe(cn, ByteArrayCodec.INSTANCE, subscriptionListener);
            f = f.whenComplete((res, e) -> RedissonReactiveSubscription.this.patterns.put(cn, res));
            futures.add(f);
        }
        CompletableFuture<Void> future = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        future = future.whenComplete((r, e) -> {
            monosListener.release();
        });
        return Mono.fromFuture(future);
    });
}