All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.redisson.command.CommandReactiveService Maven / Gradle / Ivy

    /**
 * Copyright 2016 Nikita Koksharov
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.redisson.command;

import java.util.Collection;
import java.util.List;
import java.util.function.Supplier;

import org.reactivestreams.Publisher;
import org.redisson.SlotCallback;
import org.redisson.api.RFuture;
import org.redisson.client.RedisClient;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.connection.ConnectionManager;
import org.redisson.connection.MasterSlaveEntry;

import reactor.core.publisher.Flux;

/**
 *
 * @author Nikita Koksharov
 *
 */
public class CommandReactiveService extends CommandAsyncService implements CommandReactiveExecutor {

    public CommandReactiveService(ConnectionManager connectionManager) {
        super(connectionManager);
    }

    @Override
    public  Publisher evalWriteAllReactive(final RedisCommand command, final SlotCallback callback, final String script, final List keys, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return evalWriteAllAsync(command, callback, script, keys, params);
            };
        });
    }

    @Override
    public  Publisher reactive(Supplier> supplier) {
        return Flux.create(emitter -> {
            emitter.onRequest(n -> {
                supplier.get().whenComplete((v, e) -> {
                    if (e != null) {
                        emitter.error(e);
                        return;
                    } 
                    if (v != null) {
                        emitter.next(v);
                    }
                    emitter.complete();
                });
            });
        });
    }

    @Override
    public  Publisher> readAllReactive(final RedisCommand command, final Object ... params) {
        return reactive(new Supplier>>() {
            @Override
            public RFuture> get() {
                return readAllAsync(command, params);
            };
        });
    }

    @Override
    public  Publisher readRandomReactive(final RedisCommand command, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return readRandomAsync(command, params);
            };
        });
    }

    @Override
    public  Publisher readReactive(final RedisClient client, final String name, final Codec codec, final RedisCommand command, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return readAsync(client, name, codec, command, params);
            };
        });
    }

    @Override
    public  Publisher writeReactive(String key, RedisCommand command, Object ... params) {
        return writeReactive(key, connectionManager.getCodec(), command, params);
    }

    @Override
    public  Publisher writeReactive(final String key, final Codec codec, final RedisCommand command, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return writeAsync(key, codec, command, params);
            };
        });
    }

    @Override
    public  Publisher writeReactive(final MasterSlaveEntry entry, final Codec codec, final RedisCommand command, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return writeAsync(entry, codec, command, params);
            };
        });
    }

    @Override
    public  Publisher readReactive(String key, RedisCommand command, Object ... params) {
        return readReactive(key, connectionManager.getCodec(), command, params);
    }

    @Override
    public  Publisher readReactive(final String key, final Codec codec, final RedisCommand command, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return readAsync(key, codec, command, params);
            };
        });
    }

    @Override
    public  Publisher evalReadReactive(final String key, final Codec codec, final RedisCommand evalCommandType,
            final String script, final List keys, final Object... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return evalReadAsync(key, codec, evalCommandType, script, keys, params);
            };
        });
    }

    @Override
    public  Publisher evalWriteReactive(final String key, final Codec codec, final RedisCommand evalCommandType,
            final String script, final List keys, final Object... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return evalWriteAsync(key, codec, evalCommandType, script, keys, params);
            };
        });
    }

    @Override
    public  Publisher writeAllReactive(final RedisCommand command, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return writeAllAsync(command, params);
            }   
        });
    }

    @Override
    public  Publisher writeAllReactive(final RedisCommand command, final SlotCallback callback, final Object ... params) {
        return reactive(new Supplier>() {
            @Override
            public RFuture get() {
                return writeAllAsync(command, callback, params);
            };
        });
    }


}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy