Examples with Codec org.redisson.client.codec.Codec used on opensource projects

Example 21 with Codec

use of org.redisson.client.codec.Codec in project redisson by redisson.

the class RedissonReactiveSubscription method pUnsubscribe.

@Override
public Mono<Void> pUnsubscribe(ByteBuffer... patterns) {
    monosListener.acquire();
    return Mono.defer(() -> {
        List<CompletableFuture<?>> futures = new ArrayList<>(patterns.length);
        for (ByteBuffer channel : patterns) {
            ChannelName cn = toChannelName(channel);
            CompletableFuture<Codec> f = subscribeService.unsubscribe(cn, PubSubType.PUNSUBSCRIBE);
            f = f.whenComplete((res, e) -> {
                synchronized (RedissonReactiveSubscription.this.patterns) {
                    Collection<PubSubConnectionEntry> entries = RedissonReactiveSubscription.this.patterns.get(cn);
                    entries.stream().filter(en -> en.hasListeners(cn)).forEach(ee -> RedissonReactiveSubscription.this.patterns.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 22 with Codec

use of org.redisson.client.codec.Codec in project redisson by redisson.

the class RedissonSessionManager method startInternal.

@Override
protected void startInternal() throws LifecycleException {
    super.startInternal();
    redisson = buildClient();
    final ClassLoader applicationClassLoader;
    if (getContext().getLoader().getClassLoader() != null) {
        applicationClassLoader = getContext().getLoader().getClassLoader();
    } else if (Thread.currentThread().getContextClassLoader() != null) {
        applicationClassLoader = Thread.currentThread().getContextClassLoader();
    } else {
        applicationClassLoader = getClass().getClassLoader();
    }
    Codec codec = redisson.getConfig().getCodec();
    try {
        codecToUse = codec.getClass().getConstructor(ClassLoader.class, codec.getClass()).newInstance(applicationClassLoader, codec);
    } catch (Exception e) {
        throw new LifecycleException(e);
    }
    Pipeline pipeline = getContext().getPipeline();
    synchronized (pipeline) {
        if (readMode == ReadMode.REDIS) {
            Optional<Valve> res = Arrays.stream(pipeline.getValves()).filter(v -> v.getClass() == UsageValve.class).findAny();
            if (res.isPresent()) {
                ((UsageValve) res.get()).incUsage();
            } else {
                pipeline.addValve(new UsageValve());
            }
        }
        if (updateMode == UpdateMode.AFTER_REQUEST) {
            Optional<Valve> res = Arrays.stream(pipeline.getValves()).filter(v -> v.getClass() == UpdateValve.class).findAny();
            if (res.isPresent()) {
                ((UpdateValve) res.get()).incUsage();
            } else {
                pipeline.addValve(new UpdateValve());
            }
        }
    }
    if (readMode == ReadMode.MEMORY && this.broadcastSessionUpdates || broadcastSessionEvents) {
        RTopic updatesTopic = getTopic();
        messageListener = new MessageListener<AttributeMessage>() {

            @Override
            public void onMessage(CharSequence channel, AttributeMessage msg) {
                try {
                    if (msg.getNodeId().equals(nodeId)) {
                        return;
                    }
                    RedissonSession session = (RedissonSession) RedissonSessionManager.super.findSession(msg.getSessionId());
                    if (session != null) {
                        if (msg instanceof SessionDestroyedMessage) {
                            session.expire();
                        }
                        if (msg instanceof AttributeRemoveMessage) {
                            for (String name : ((AttributeRemoveMessage) msg).getNames()) {
                                session.superRemoveAttributeInternal(name, true);
                            }
                        }
                        if (msg instanceof AttributesClearMessage) {
                            RedissonSessionManager.super.remove(session, false);
                        }
                        if (msg instanceof AttributesPutAllMessage) {
                            AttributesPutAllMessage m = (AttributesPutAllMessage) msg;
                            Map<String, Object> attrs = m.getAttrs(codecToUse.getMapValueDecoder());
                            session.load(attrs);
                        }
                        if (msg instanceof AttributeUpdateMessage) {
                            AttributeUpdateMessage m = (AttributeUpdateMessage) msg;
                            session.superSetAttribute(m.getName(), m.getValue(codecToUse.getMapValueDecoder()), true);
                        }
                    } else {
                        if (msg instanceof SessionCreatedMessage) {
                            Session s = findSession(msg.getSessionId());
                            if (s == null) {
                                throw new IllegalStateException("Unable to find session: " + msg.getSessionId());
                            }
                        }
                        if (msg instanceof SessionDestroyedMessage) {
                            Session s = findSession(msg.getSessionId(), false);
                            if (s == null) {
                                throw new IllegalStateException("Unable to find session: " + msg.getSessionId());
                            }
                            s.expire();
                            RSet<String> set = getNotifiedNodes(msg.getSessionId());
                            set.add(nodeId);
                        }
                    }
                } catch (Exception e) {
                    log.error("Unable to handle topic message", e);
                }
            }
        };
        updatesTopic.addListener(AttributeMessage.class, messageListener);
    }
    setState(LifecycleState.STARTING);
}

Example 23 with Codec

use of org.redisson.client.codec.Codec in project redisson by redisson.

the class CommandAsyncService method evalAsync.

private <T, R> RFuture<R> evalAsync(NodeSource nodeSource, boolean readOnlyMode, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, boolean noRetry, Object... params) {
    if (isEvalCacheActive() && evalCommandType.getName().equals("EVAL")) {
        CompletableFuture<R> mainPromise = new CompletableFuture<>();
        Object[] pps = copy(params);
        CompletableFuture<R> promise = new CompletableFuture<>();
        String sha1 = calcSHA(script);
        RedisCommand cmd;
        if (readOnlyMode && evalShaROSupported.get()) {
            cmd = new RedisCommand(evalCommandType, "EVALSHA_RO");
        } else {
            cmd = new RedisCommand(evalCommandType, "EVALSHA");
        }
        List<Object> args = new ArrayList<Object>(2 + keys.size() + params.length);
        args.add(sha1);
        args.add(keys.size());
        args.addAll(keys);
        args.addAll(Arrays.asList(params));
        RedisExecutor<T, R> executor = new RedisExecutor<>(readOnlyMode, nodeSource, codec, cmd, args.toArray(), promise, false, connectionManager, objectBuilder, referenceType, noRetry);
        executor.execute();
        promise.whenComplete((res, e) -> {
            if (e != null) {
                if (e.getMessage().startsWith("ERR unknown command")) {
                    evalShaROSupported.set(false);
                    free(pps);
                    RFuture<R> future = evalAsync(nodeSource, readOnlyMode, codec, evalCommandType, script, keys, noRetry, params);
                    transfer(future.toCompletableFuture(), mainPromise);
                } else if (e.getMessage().startsWith("NOSCRIPT")) {
                    RFuture<String> loadFuture = loadScript(executor.getRedisClient(), script);
                    loadFuture.whenComplete((r, ex) -> {
                        if (ex != null) {
                            free(pps);
                            mainPromise.completeExceptionally(ex);
                            return;
                        }
                        List<Object> newargs = new ArrayList<Object>(2 + keys.size() + params.length);
                        newargs.add(sha1);
                        newargs.add(keys.size());
                        newargs.addAll(keys);
                        newargs.addAll(Arrays.asList(pps));
                        NodeSource ns = nodeSource;
                        if (ns.getRedisClient() == null) {
                            ns = new NodeSource(nodeSource, executor.getRedisClient());
                        }
                        RFuture<R> future = async(readOnlyMode, ns, codec, cmd, newargs.toArray(), false, noRetry);
                        transfer(future.toCompletableFuture(), mainPromise);
                    });
                } else {
                    free(pps);
                    mainPromise.completeExceptionally(e);
                }
                return;
            }
            free(pps);
            mainPromise.complete(res);
        });
        return new CompletableFutureWrapper<>(mainPromise);
    }
    List<Object> args = new ArrayList<Object>(2 + keys.size() + params.length);
    args.add(script);
    args.add(keys.size());
    args.addAll(keys);
    args.addAll(Arrays.asList(params));
    return async(readOnlyMode, nodeSource, codec, evalCommandType, args.toArray(), false, noRetry);
}

Example 24 with Codec

use of org.redisson.client.codec.Codec in project redisson by redisson.

the class CommandAsyncService method async.

public <V, R> RFuture<R> async(boolean readOnlyMode, NodeSource source, Codec codec, RedisCommand<V> command, Object[] params, boolean ignoreRedirect, boolean noRetry) {
    if (readOnlyMode && command.getName().equals("SORT") && !sortRoSupported.get()) {
        readOnlyMode = false;
    } else if (readOnlyMode && command.getName().equals("SORT") && sortRoSupported.get()) {
        RedisCommand cmd = new RedisCommand("SORT_RO", command.getReplayMultiDecoder());
        CompletableFuture<R> mainPromise = createPromise();
        RedisExecutor<V, R> executor = new RedisExecutor<>(readOnlyMode, source, codec, cmd, params, mainPromise, ignoreRedirect, connectionManager, objectBuilder, referenceType, noRetry);
        executor.execute();
        CompletableFuture<R> result = new CompletableFuture<>();
        mainPromise.whenComplete((r, e) -> {
            if (e != null && e.getMessage().startsWith("ERR unknown command")) {
                sortRoSupported.set(false);
                RFuture<R> future = async(false, source, codec, command, params, ignoreRedirect, noRetry);
                transfer(future.toCompletableFuture(), result);
                return;
            }
            transfer(mainPromise, result);
        });
        return new CompletableFutureWrapper<>(result);
    }
    CompletableFuture<R> mainPromise = createPromise();
    RedisExecutor<V, R> executor = new RedisExecutor<>(readOnlyMode, source, codec, command, params, mainPromise, ignoreRedirect, connectionManager, objectBuilder, referenceType, noRetry);
    executor.execute();
    return new CompletableFutureWrapper<>(mainPromise);
}

Example 25 with Codec

use of org.redisson.client.codec.Codec in project redisson by redisson.

the class RedissonCodecTest method testAvro.

@Test
public void testAvro() throws IOException {
    AvroMapper am = new AvroMapper();
    AvroSchema schema = am.schemaFor(TestObject.class);
    Codec avroCodec = new AvroJacksonCodec(TestObject.class, schema);
    Config config = createConfig();
    config.setCodec(avroCodec);
    RedissonClient redisson = Redisson.create(config);
    RBucket<TestObject> b = redisson.getBucket("bucket");
    b.set(new TestObject("1", "2"));
    assertThat(b.get()).isEqualTo(new TestObject("1", "2"));
}