com.distkv.client.DistkvClient

Here are the examples of the java api com.distkv.client.DistkvClient taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

56 Examples 7

19 Source : MasterSlaveSynchronizationTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public void testIntPut(DistkvClient client0, DistkvClient client1) throws InvalidProtocolBufferException {
    client0.ints().put("int_k1", 1);
    replacedert.replacedertEquals(1, client0.ints().get("int_k1"));
    replacedert.replacedertEquals(1, client1.ints().get("int_k1"));
}

19 Source : MasterSlaveSynchronizationTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public void testListPut(DistkvClient client0, DistkvClient client1) {
    client0.lists().put("list_k1", ImmutableList.of("v1", "v2", "v3"));
    replacedert.replacedertEquals(ImmutableList.of("v1", "v2", "v3"), client0.lists().get("list_k1"));
    replacedert.replacedertEquals(ImmutableList.of("v2", "v3"), client0.lists().get("list_k1", 1, 3));
    replacedert.replacedertEquals(ImmutableList.of("v1", "v2", "v3"), client1.lists().get("list_k1"));
}

19 Source : MasterSlaveSynchronizationTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public void testDictPut(DistkvClient client0, DistkvClient client1) {
    Map<String, String> dict = new HashMap<>();
    dict.put("dict_k1", "v1");
    client0.dicts().put("m1", dict);
    Map<String, String> dict1 = client0.dicts().get("m1");
    replacedert.replacedertEquals(dict, dict1);
    Map<String, String> dict2 = client1.dicts().get("m1");
    replacedert.replacedertEquals(dict, dict2);
}

19 Source : MasterSlaveSynchronizationTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public void testSetPut(DistkvClient client0, DistkvClient client1) {
    Set<String> set = ImmutableSet.of("v1", "v2", "v3");
    client0.sets().put("set_k1", set);
    replacedert.replacedertEquals(set, client0.sets().get("set_k1"));
    replacedert.replacedertEquals(set, client1.sets().get("set_k1"));
}

19 Source : MasterSlaveSynchronizationTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public void testStrPut(DistkvClient client0, DistkvClient client1) throws InvalidProtocolBufferException {
    client0.strs().put("str_k1", "v1");
    replacedert.replacedertEquals("v1", client0.strs().get("str_k1"));
    replacedert.replacedertEquals("v1", client1.strs().get("str_k1"));
}

19 Source : PineRuntime.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public clreplaced PineRuntime {

    /**
     * The distkv sync client.
     */
    private DistkvClient distkvClient;

    public void init(String address) {
        distkvClient = new DefaultDistkvClient(address);
    }

    public void shutdown() {
        try {
            distkvClient.disconnect();
        } catch (DistkvException e) {
            throw new PineRuntimeShutdownFailedException(String.format("Failed shutdown the client : %s", e.getMessage()));
        }
    }

    public PineTopper newTopper() {
        return new PineTopperImpl(distkvClient);
    }

    public PineLiker newLiker() {
        return new PineLikerImpl(distkvClient);
    }

    public PineCache newCache(Long expireTime) {
        return new PineCacheImpl(distkvClient, expireTime);
    }
}

19 Source : PineTopperImpl.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public clreplaced PineTopperImpl extends AbstractPineHandle implements PineTopper {

    private static final String COMPONENT_TYPE = "TOPPER";

    private DistkvClient distkvClient;

    public PineTopperImpl(DistkvClient distkvClient) {
        super();
        this.distkvClient = distkvClient;
        // Construct an empty sorted-list to the store.
        distkvClient.slists().put(getKey(), new LinkedList<>());
    }

    @Override
    public void addMember(String memberName, int memberScore) {
        distkvClient.slists().putMember(getKey(), new SlistEnreplacedy(memberName, memberScore));
    }

    public void removeMember(String memberName) {
        distkvClient.slists().removeMember(getKey(), memberName);
    }

    public List<DistkvTuple<String, Integer>> top(int num) {
        try {
            LinkedList<SlistEnreplacedy> result = distkvClient.slists().top(getKey(), num);
            // Covert the result type.
            List<DistkvTuple<String, Integer>> ret = new ArrayList<>(result.size());
            for (SlistEnreplacedy enreplacedy : result) {
                ret.add(new DistkvTuple<>(enreplacedy.getMember(), enreplacedy.getScore()));
            }
            return ret;
        } catch (InvalidProtocolBufferException e) {
            // TODO(qwang): Refine this exception.
            throw new RuntimeException(e);
        }
    }

    /**
     * Get the member of the given name.
     *
     * @param memberName The name of the member that will be find.
     */
    @Override
    public TopperMember getMember(String memberName) {
        try {
            DistkvTuple<Integer, Integer> result = distkvClient.slists().getMember(getKey(), memberName);
            return new TopperMember(memberName, result.getSecond(), result.getFirst());
        } catch (InvalidProtocolBufferException e) {
            // TODO(qwang): Refine this exception.
            throw new RuntimeException(e);
        }
    }

    @Override
    protected String getComponentType() {
        return COMPONENT_TYPE;
    }
}

19 Source : PineLikerTopic.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public clreplaced PineLikerTopic {

    private String topicName;

    private DistkvClient distkvClient;

    private PineLikerTopic() {
    }

    public String getTopicName() {
        return topicName;
    }

    private void setTopicName(String topicName) {
        this.topicName = topicName;
    }

    public DistkvClient getDistkvClient() {
        return distkvClient;
    }

    private void setDistkvClient(DistkvClient distkvClient) {
        this.distkvClient = distkvClient;
    }

    static clreplaced Builder {

        private PineLikerTopic pineLikerTopic;

        public Builder() {
            pineLikerTopic = new PineLikerTopic();
        }

        public Builder setTopicKey(String topicKey) {
            pineLikerTopic.setTopicName(topicKey);
            return this;
        }

        public Builder setDistkvClient(DistkvClient distkvClient) {
            pineLikerTopic.setDistkvClient(distkvClient);
            return this;
        }

        public PineLikerTopic build() {
            return pineLikerTopic;
        }
    }

    public void likesFrom(String likee) {
        try {
            distkvClient.sets().get(topicName);
        } catch (KeyNotFoundException e) {
            distkvClient.sets().put(topicName, new HashSet<>());
        }
        distkvClient.sets().pureplacedem(topicName, likee);
    }

    /**
     * Let people unlike the topic.
     * @param likee the unliked people.
     * @return false if this topic already did not exist,
     * true if the operation succeeded.
     */
    public boolean unlikesFrom(String likee) {
        try {
            distkvClient.sets().get(topicName);
        } catch (KeyNotFoundException e) {
            return false;
        }
        try {
            distkvClient.sets().removeItem(topicName, likee);
        } catch (SereplacedemNotFoundException e) {
            throw new PineLikerLikeeNotFoundException("This likee has never liked this topic");
        }
        return true;
    }

    public int count() {
        return distkvClient.sets().get(topicName).size();
    }
}

19 Source : PineLikerTopic.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

private void setDistkvClient(DistkvClient distkvClient) {
    this.distkvClient = distkvClient;
}

19 Source : PineLikerImpl.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public clreplaced PineLikerImpl extends AbstractPineHandle implements PineLiker {

    private static final String COMPONENT_TYPE = "LIKER";

    private DistkvClient distkvClient;

    public PineLikerImpl(DistkvClient distkvClient) {
        this.distkvClient = distkvClient;
    }

    protected String getComponentType() {
        return COMPONENT_TYPE;
    }

    @Override
    public PineLikerTopic topic(String topic) {
        return new PineLikerTopic.Builder().setTopicKey(getKey(topic)).setDistkvClient(distkvClient).build();
    }

    private String getKey(String topic) {
        return String.format("%s_%s", super.getKey(), topic);
    }
}

19 Source : PineCacheImpl.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public clreplaced PineCacheImpl extends AbstractPineHandle implements PineCache {

    private static final String COMPONENT_TYPE = "CACHE";

    private DistkvClient distkvClient;

    private Long defaultExpireTime;

    public PineCacheImpl(DistkvClient distkvClient, Long expireTime) {
        super();
        this.distkvClient = distkvClient;
        this.defaultExpireTime = expireTime;
    }

    protected String getComponentType() {
        return COMPONENT_TYPE;
    }

    @Override
    public void newItem(String item) {
        try {
            distkvClient.strs().get(item);
            distkvClient.expire(item, defaultExpireTime);
        } catch (KeyNotFoundException e) {
            distkvClient.strs().put(item, item);
            distkvClient.expire(item, defaultExpireTime);
        } catch (InvalidProtocolBufferException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Boolean isExpired(String item) {
        try {
            distkvClient.strs().get(item);
        } catch (KeyNotFoundException e) {
            return true;
        } catch (InvalidProtocolBufferException e) {
            throw new RuntimeException(e);
        }
        return false;
    }
}

19 Source : DistkvCommandExecutor.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public clreplaced DistkvCommandExecutor {

    DistkvClient distkvClient;

    public DistkvCommandExecutor(DistkvClient distkvClient) {
        this.distkvClient = distkvClient;
    }

    public String execute(DistkvParsedResult parsedResult) {
        switch(parsedResult.getRequestType()) {
            case STR_PUT:
                return CommandExecutorHandler.strPut(distkvClient, parsedResult);
            case STR_GET:
                return CommandExecutorHandler.strGet(distkvClient, parsedResult);
            case LIST_PUT:
                return CommandExecutorHandler.listPut(distkvClient, parsedResult);
            case LIST_GET:
                return CommandExecutorHandler.listGet(distkvClient, parsedResult);
            case LIST_LPUT:
                return CommandExecutorHandler.listLPut(distkvClient, parsedResult);
            case LIST_RPUT:
                return CommandExecutorHandler.listRPut(distkvClient, parsedResult);
            case LIST_REMOVE:
                return CommandExecutorHandler.listRemove(distkvClient, parsedResult);
            case LIST_MREMOVE:
                return CommandExecutorHandler.listMRemove(distkvClient, parsedResult);
            case SET_PUT:
                return CommandExecutorHandler.setPut(distkvClient, parsedResult);
            case SET_GET:
                return CommandExecutorHandler.setGet(distkvClient, parsedResult);
            case SET_PUT_ITEM:
                return CommandExecutorHandler.setPureplacedem(distkvClient, parsedResult);
            case SET_REMOVE_ITEM:
                return CommandExecutorHandler.setRemoveItem(distkvClient, parsedResult);
            case SET_EXISTS:
                return CommandExecutorHandler.setExists(distkvClient, parsedResult);
            case DICT_PUT:
                return CommandExecutorHandler.dictPut(distkvClient, parsedResult);
            case DICT_GET:
                return CommandExecutorHandler.dictGet(distkvClient, parsedResult);
            case DICT_PUT_ITEM:
                return CommandExecutorHandler.dictPureplacedem(distkvClient, parsedResult);
            case DICT_GET_ITEM:
                return CommandExecutorHandler.dictGereplacedem(distkvClient, parsedResult);
            case DICT_POP_ITEM:
                return CommandExecutorHandler.dictPopItem(distkvClient, parsedResult);
            case DICT_REMOVE_ITEM:
                return CommandExecutorHandler.dictRemoveItem(distkvClient, parsedResult);
            case SLIST_PUT:
                return CommandExecutorHandler.slistPut(distkvClient, parsedResult);
            case SLIST_TOP:
                return CommandExecutorHandler.slistTop(distkvClient, parsedResult);
            case SLIST_INCR_SCORE:
                return CommandExecutorHandler.slistIncrScore(distkvClient, parsedResult);
            case SLIST_PUT_MEMBER:
                return CommandExecutorHandler.slistPutMember(distkvClient, parsedResult);
            case SLIST_REMOVE_MEMBER:
                return CommandExecutorHandler.slistRemoveMember(distkvClient, parsedResult);
            case SLIST_GET_MEMBER:
                return CommandExecutorHandler.slistGetMember(distkvClient, parsedResult);
            case ACTIVE_NAMESPACE:
                return CommandExecutorHandler.activeNamespace(distkvClient, parsedResult);
            case DEACTIVE_NAMESPACE:
                return CommandExecutorHandler.deactiveNamespace(distkvClient, parsedResult);
            case INT_PUT:
                return CommandExecutorHandler.intPut(distkvClient, parsedResult);
            case INT_GET:
                return CommandExecutorHandler.intGet(distkvClient, parsedResult);
            case INT_INCR:
                return CommandExecutorHandler.intIncr(distkvClient, parsedResult);
            case DROP:
                return CommandExecutorHandler.drop(distkvClient, parsedResult);
            case EXPIRE:
                return CommandExecutorHandler.expire(distkvClient, parsedResult);
            case EXISTS:
                return CommandExecutorHandler.exists(distkvClient, parsedResult);
            case TTL:
                return CommandExecutorHandler.ttl(distkvClient, parsedResult);
            case EXIT:
                // User inputs `exit`, let's exit client immediately.
                System.out.println("bye bye ~");
                System.exit(0);
                return null;
            default:
                return null;
        }
    }
}

18 Source : MasterSlaveSynchronizationTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public void testSlistPut(DistkvClient client0, DistkvClient client1) throws InvalidProtocolBufferException {
    LinkedList<SlistEnreplacedy> list = new LinkedList<>();
    list.add(new SlistEnreplacedy("xswl", 9));
    list.add(new SlistEnreplacedy("wlll", 8));
    list.add(new SlistEnreplacedy("fw", 9));
    list.add(new SlistEnreplacedy("55", 6));
    client0.slists().put("slist_k1", list);
    LinkedList<SlistEnreplacedy> slist = client0.slists().top("slist_k1", 100);
    replacedert.replacedertEquals(slist.get(0).getMember(), "fw");
    replacedert.replacedertEquals(slist.get(1).getMember(), "xswl");
    LinkedList<SlistEnreplacedy> slist1 = client1.slists().top("slist_k1", 100);
    replacedert.replacedertEquals(slist1.get(0).getMember(), "fw");
    replacedert.replacedertEquals(slist1.get(1).getMember(), "xswl");
}

18 Source : DistkvCommandExecutorHandlerTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

@Test(singleThreaded = true)
public clreplaced DistkvCommandExecutorHandlerTest extends BaseTestSupplier {

    private static final String STATUS_OK = "ok";

    private DistkvClient distkvClient = null;

    @Test
    public void testMain() {
        distkvClient = newDistkvClient();
        try {
            final DistkvParser distkvParser = new DistkvParser();
            DistkvParsedResult distKVParsedResult = null;
            String command = null;
            // Test str.put
            command = "str.put str_k1 v1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.strPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'str.get'
            command = "str.get str_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.strGet(distkvClient, distKVParsedResult), "v1");
            // Test command 'drop'
            command = "drop str_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.drop(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'list.put'
            command = "list.put list_k1 v2 v1 v3";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.listPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'list.get'
            command = "list.get list_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.listGet(distkvClient, distKVParsedResult), "[v2, v1, v3]");
            // Test command 'list.lput'
            command = "list.lput list_k1 v4 v5";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.listLPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'list.rput'
            command = "list.rput list_k1 v6 v7";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.listRPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'list.listRemoveOne';
            command = "list.remove list_k1 0";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.listRemove(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'list.listRemoveRange'
            command = "list.remove list_k1 0 2";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.listRemove(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'list.mremove'
            command = "list.mremove list_k1 0 2";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.listMRemove(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'drop'
            command = "drop list_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.drop(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'set.put'
            command = "set.put set_k1 v1 v2 v3";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.setPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'set.get'
            command = "set.get set_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.setGet(distkvClient, distKVParsedResult), "{v1, v2, v3}");
            // Test command 'set.pureplacedem'
            command = "set.pureplacedem set_k1 v0";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.setPureplacedem(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'set.remove'
            command = "set.remove set_k1 v0";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.setRemoveItem(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'set.removeItem'
            command = "set.removeItem set_k1 v1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.setRemoveItem(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'set.exists'
            command = "set.exists set_k1 v1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.setExists(distkvClient, distKVParsedResult), "false");
            // Test command 'drop'
            command = "drop set_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.drop(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'dict.put'
            command = "dict.put dict_key k1 v1 k2 v2";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.dictPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'dict.get'
            command = "dict.get dict_key";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.dictGet(distkvClient, distKVParsedResult), "{ k1 : v1, k2 : v2}");
            // Test command 'dict.pureplacedem'
            command = "dict.pureplacedem dict_key k3 v3";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.dictPureplacedem(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'dict.gereplacedem'
            command = "dict.gereplacedem dict_key k3";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.dictGereplacedem(distkvClient, distKVParsedResult), "v3");
            // Test command 'dict.popItem'
            command = "dict.popItem dict_key k3";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.dictPopItem(distkvClient, distKVParsedResult), "v3");
            // Test command 'dict.removeItem'
            command = "dict.removeItem dict_key k2";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.dictRemoveItem(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'drop'
            command = "drop dict_key";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.drop(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'slist.put'
            command = "slist.put slist_k1 m1 12 m2 -2 m3 0";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.slistPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'slist.top'
            command = "slist.top slist_k1 2";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.slistTop(distkvClient, distKVParsedResult), "[(m1, 12), (m3, 0)]");
            // Test command 'slistIncrScoreDefault'
            command = "slist.incrScore slist_k1 m2";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.slistIncrScore(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'slistIncrScoreDelta'
            command = "slist.incrScore slist_k1 m1 10";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.slistIncrScore(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'slist.putMember'
            command = "slist.putMember slist_k1 m4 -3";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.slistPutMember(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'slist.removeMember'
            command = "slist.removeMember slist_k1 m4";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.slistRemoveMember(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'slist.getMember'
            command = "slist.getMember slist_k1 m2";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.slistGetMember(distkvClient, distKVParsedResult), "(m2, -1), 3rd");
            // Test command 'drop'
            command = "drop slist_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.drop(distkvClient, distKVParsedResult), STATUS_OK);
            // Test active namespace
            command = "active namespace a";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.activeNamespace(distkvClient, distKVParsedResult), STATUS_OK);
            // Test Deactive namespace
            command = "deactive namespace";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.deactiveNamespace(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'int.put'
            command = "int.put int_k1 12";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.intPut(distkvClient, distKVParsedResult), STATUS_OK);
            // Test command 'int.get'
            command = "int.get int_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.intGet(distkvClient, distKVParsedResult), String.valueOf(12));
            // Test command 'int.incr'
            command = "int.incr int_k1 -3";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.intIncr(distkvClient, distKVParsedResult), STATUS_OK);
            replacedert.replacedertEquals(CommandExecutorHandler.intGet(distkvClient, distkvParser.parse("int.get int_k1")), String.valueOf(9));
            command = "int.incr int_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.intIncr(distkvClient, distKVParsedResult), STATUS_OK);
            replacedert.replacedertEquals(CommandExecutorHandler.intGet(distkvClient, distkvParser.parse("int.get int_k1")), String.valueOf(10));
            // Test command 'int.drop'
            command = "drop int_k1";
            distKVParsedResult = distkvParser.parse(command);
            replacedert.replacedertEquals(CommandExecutorHandler.drop(distkvClient, distKVParsedResult), STATUS_OK);
        } finally {
            distkvClient.disconnect();
        }
    }

    @Test
    public void testListGetOne() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        String command = "list.put k1 v2 v1 v3 v4 v5 v7 v9";
        DistkvParsedResult distKVParsedResult = distkvParser.parse(command);
        CommandExecutorHandler.listPut(distkvClient, distKVParsedResult);
        // Test command 'list.get'
        command = "list.get k1 3";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.listGet(distkvClient, distKVParsedResult), "[v4]");
    }

    @Test
    public void testListGetRange() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        String command = "list.put k1 v2 v1 v3 v4 v5 v7 v9";
        DistkvParsedResult distKVParsedResult = distkvParser.parse(command);
        CommandExecutorHandler.listPut(distkvClient, distKVParsedResult);
        // Test command 'list.get'
        command = "list.get k1 3 5";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.listGet(distkvClient, distKVParsedResult), "[v4, v5]");
    }

    @Test
    public void expireStrTest() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "str.put str_k1 v1";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.strPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Expire operation.
        command = "expire str_k1 1000";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.expire(distkvClient, distKVParsedResult), STATUS_OK);
        // Test KeyNotFoundException.
        command = "str.get str_k1";
        final DistkvParsedResult finalDistKVParsedResult = distkvParser.parse(command);
        boolean result = RuntimeUtil.waitForCondition(() -> {
            try {
                CommandExecutorHandler.strGet(distkvClient, finalDistKVParsedResult);
                return false;
            } catch (KeyNotFoundException e) {
                return true;
            }
        }, 30 * 1000);
        replacedert.replacedertTrue(result);
    }

    @Test
    public void expireListTest() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "list.put list_k1 v2 v1 v3";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.listPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Expire operation.
        command = "expire list_k1 1000";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.expire(distkvClient, distKVParsedResult), STATUS_OK);
        // Test KeyNotFoundException.
        command = "list.get list_k1";
        final DistkvParsedResult finalDistKVParsedResult = distkvParser.parse(command);
        boolean result = RuntimeUtil.waitForCondition(() -> {
            try {
                CommandExecutorHandler.listGet(distkvClient, finalDistKVParsedResult);
                return false;
            } catch (KeyNotFoundException e) {
                return true;
            }
        }, 30 * 1000);
        replacedert.replacedertTrue(result);
    }

    @Test
    public void expireSetTest() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "set.put set_k1 v1 v2 v3";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.setPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Expire operation.
        command = "expire set_k1 1000";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.expire(distkvClient, distKVParsedResult), STATUS_OK);
        // Test KeyNotFoundException.
        command = "set.get set_k1";
        final DistkvParsedResult finalDistKVParsedResult = distkvParser.parse(command);
        boolean result = RuntimeUtil.waitForCondition(() -> {
            try {
                CommandExecutorHandler.setGet(distkvClient, finalDistKVParsedResult);
                return false;
            } catch (KeyNotFoundException e) {
                return true;
            }
        }, 30 * 1000);
        replacedert.replacedertTrue(result);
    }

    @Test
    public void expireDictTest() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "dict.put dict_key k1 v1 k2 v2";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.dictPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Expire operation.
        command = "expire dict_key 1000";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.expire(distkvClient, distKVParsedResult), STATUS_OK);
        // Test KeyNotFoundException.
        command = "dict.get dict_key";
        final DistkvParsedResult finalDistKVParsedResult = distkvParser.parse(command);
        boolean result = RuntimeUtil.waitForCondition(() -> {
            try {
                CommandExecutorHandler.dictGet(distkvClient, finalDistKVParsedResult);
                return false;
            } catch (KeyNotFoundException e) {
                return true;
            }
        }, 30 * 1000);
        replacedert.replacedertTrue(result);
    }

    @Test
    public void expireSlistTest() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "slist.put slist_k1 m1 12 m2 -2 m3 0";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.slistPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Expire operation.
        command = "expire slist_k1 1000";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.expire(distkvClient, distKVParsedResult), STATUS_OK);
        // Test KeyNotFoundException.
        command = "slist.top slist_k1 2";
        final DistkvParsedResult finalDistKVParsedResult = distkvParser.parse(command);
        boolean result = RuntimeUtil.waitForCondition(() -> {
            try {
                CommandExecutorHandler.slistTop(distkvClient, finalDistKVParsedResult);
                return false;
            } catch (KeyNotFoundException e) {
                return true;
            }
        }, 30 * 1000);
        replacedert.replacedertTrue(result);
    }

    @Test
    public void expireIntsTest() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "int.put int_k1 12";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.intPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Expire operation
        command = "expire int_k1 1000";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.expire(distkvClient, distKVParsedResult), STATUS_OK);
        // Test KeyNotFoundException.
        command = "int.get int_k1";
        final DistkvParsedResult finalDistKVParsedResult = distkvParser.parse(command);
        boolean result = RuntimeUtil.waitForCondition(() -> {
            try {
                CommandExecutorHandler.intGet(distkvClient, finalDistKVParsedResult);
                return false;
            } catch (KeyNotFoundException e) {
                return true;
            }
        }, 30 * 1000);
        replacedert.replacedertTrue(result);
    }

    @Test
    public void testExists() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "str.put str_k1 v1";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.strPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Exist operation.
        command = "exists str_k1";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.exists(distkvClient, distKVParsedResult), "true");
    }

    @Test
    public void testTtlNoExpire() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "str.put str_k1 v1";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.strPut(distkvClient, distKVParsedResult), STATUS_OK);
        // TTL whit no expire operation.
        command = "ttl str_k1";
        distKVParsedResult = distkvParser.parse(command);
        String timeToLive = CommandExecutorHandler.ttl(distkvClient, distKVParsedResult).replace(TimeUnit.MILLISECOND, "");
        replacedert.replacedertEquals(timeToLive, "-1");
    }

    @Test
    public void testTtlKeyNotFound() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        command = "ttl str_k1";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertThrows(KeyNotFoundException.clreplaced, () -> CommandExecutorHandler.ttl(distkvClient, distKVParsedResult));
    }

    @Test
    public void testTtlWithExpire() {
        distkvClient = newDistkvClient();
        final DistkvParser distkvParser = new DistkvParser();
        DistkvParsedResult distKVParsedResult;
        String command;
        // Put operation.
        command = "str.put str_k1 v1";
        distKVParsedResult = distkvParser.parse(command);
        replacedert.replacedertEquals(CommandExecutorHandler.strPut(distkvClient, distKVParsedResult), STATUS_OK);
        // Expire operation
        command = "expire str_k1 2000";
        distKVParsedResult = distkvParser.parse(command);
        CommandExecutorHandler.expire(distkvClient, distKVParsedResult);
        // TTL key not expire operation.
        command = "ttl str_k1";
        final DistkvParsedResult ttlParsedResult = distkvParser.parse(command);
        boolean ttlResult = RuntimeUtil.waitForCondition(() -> {
            String timeToLive = CommandExecutorHandler.ttl(distkvClient, ttlParsedResult).replace(TimeUnit.MILLISECOND, "");
            long result = Long.parseLong(timeToLive);
            return result < 2000 && result > 0;
        }, 1000);
        replacedert.replacedertTrue(ttlResult);
        // TTL key expire operation.
        command = "ttl str_k1";
        DistkvParsedResult finalDistKVParsedResult = distkvParser.parse(command);
        boolean result = RuntimeUtil.waitForCondition(() -> {
            try {
                CommandExecutorHandler.ttl(distkvClient, finalDistKVParsedResult);
                return false;
            } catch (KeyNotFoundException e) {
                return true;
            }
        }, 30 * 1000);
        replacedert.replacedertTrue(result);
    }
}

18 Source : DistkvBenchmarkTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static void strPutStressTest(DistkvClient client) throws InvalidProtocolBufferException {
    Thread thread = Thread.currentThread();
    long id = thread.getId();
    String name = Thread.currentThread().getName();
    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        client.strs().put(name + i, "com/distkv/" + i);
    }
    String as = client.strs().get(name + 59999);
    long end = System.currentTimeMillis();
    String str = "This is Dsitkv Str put test. I'm thread-" + id + " and waste time =" + (end - start) + "; the result is " + "com/dsitkv/test59999".equals(as);
    System.out.println(str);
}

18 Source : DistkvBenchmarkTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static void benchmarkTest(DistkvClient client) throws InvalidProtocolBufferException {
    strPutStressTest(client);
    client.disconnect();
}

17 Source : DistkvCommandLineToolStarter.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static void main(String[] args) {
    DistkvCommandLineToolStarter distkvCommandLineToolStarter = new DistkvCommandLineToolStarter();
    JCommander jcommander = JCommander.newBuilder().addObject(distkvCommandLineToolStarter).build();
    jcommander.setProgramName(PROGRAM_NAME);
    try {
        jcommander.parse(args);
    } catch (ParameterException e) {
        jcommander.usage();
        return;
    }
    if (HELP) {
        jcommander.usage();
        return;
    }
    if (VERSION) {
        System.out.println(DEFAULT_VERSION);
        return;
    }
    DistkvClient distkvClient = null;
    try {
        distkvClient = new DefaultDistkvClient(String.format("distkv://%s", ADDRESS));
    } catch (Exception e) {
        System.out.println(String.format("Failed to connect to distkv server, %s, " + "please check your input.", ADDRESS));
        return;
    }
    try {
        new DistkvCommandLineToolStarter().loop(distkvClient);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

17 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String deactiveNamespace(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    if (distkvClient.getActivedNamespace() == null) {
        return "Namespace has not been activated";
    }
    distkvClient.deactiveNamespace();
    return STATUS_OK;
}

16 Source : DistkvStrBenchmark.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

@State(Scope.Thread)
@BenchmarkMode({ Mode.Throughput, Mode.AverageTime })
public clreplaced DistkvStrBenchmark {

    private static final String PROTOCOL = "distkv://127.0.0.1:8082";

    private static final String KEY_STR_SYNC = "k-str-sync";

    private static final String KEY_STR_ASYNC = "k-str-async";

    private static final String VALUE_STR_SYNC = "v-sync";

    private static final String VALUE_STR_ASYNC = "v-async";

    private DistkvAsyncClient asyncClient;

    private DistkvClient client;

    @Setup
    public void init() {
        TestUtil.startRpcServer(8082);
        asyncClient = new DefaultAsyncClient(PROTOCOL);
        client = new DefaultDistkvClient(PROTOCOL);
        client.strs().put(KEY_STR_SYNC, VALUE_STR_SYNC);
        asyncClient.strs().put(KEY_STR_ASYNC, VALUE_STR_ASYNC);
    }

    @TearDown
    public void close() {
        asyncClient.disconnect();
        client.disconnect();
        TestUtil.stopProcess(TestUtil.getProcess());
    }

    @Benchmark
    public void testSyncGet(Blackhole blackhole) throws InvalidProtocolBufferException {
        blackhole.consume(client.strs().get(KEY_STR_SYNC));
    }

    @Benchmark
    public void testAsyncGet(Blackhole blackhole) {
        blackhole.consume(asyncClient.strs().get(KEY_STR_ASYNC));
    }

    @Benchmark
    public void testPut() {
        String randomStr = RandomStringUtils.random(5);
        client.strs().put(randomStr, randomStr);
    }

    @Benchmark
    public void testAsyncPut() {
        String randomStr = RandomStringUtils.random(5);
        asyncClient.strs().put(randomStr, randomStr);
    }
}

16 Source : MasterSlaveSynchronizationTest.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

@Test(singleThreaded = true)
public void mainTest() throws InterruptedException, InvalidProtocolBufferException {
    System.out.println(String.format("\n==================== Running the test method: %s.%s", "TestMasterSlaveSync", "mainTest"));
    DistkvNodesManager nodesManager = new DistkvNodesManager(3);
    nodesManager.startAllMetaServers();
    TimeUnit.SECONDS.sleep(1);
    MasterSlaveSyncTestUtil.startAGroupOfStoreServers();
    TimeUnit.SECONDS.sleep(3);
    final DistkvClient[] client0 = { null };
    final DistkvClient[] client1 = { null };
    RuntimeUtil.waitForCondition(() -> {
        try {
            client0[0] = new DefaultDistkvClient(String.format("distkv://127.0.0.1:%d", 8091));
            client1[0] = new DefaultDistkvClient(String.format("distkv://127.0.0.1:%d", 8092));
            return true;
        } catch (Exception e) {
            return false;
        }
    }, 2 * 60 * 1000);
    try {
        // test
        testStrPut(client0[0], client1[0]);
        testListPut(client0[0], client1[0]);
        testSetPut(client0[0], client1[0]);
        testDictPut(client0[0], client1[0]);
        testSlistPut(client0[0], client1[0]);
        testIntPut(client0[0], client1[0]);
    } catch (Exception e) {
        replacedert.fail();
    } finally {
        MasterSlaveSyncTestUtil.stopAGroupOfStoreServers();
        nodesManager.stopAllMetaServers();
    }
    System.out.println("m-s sync test over");
}

16 Source : DistkvCommandLineToolStarter.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

private void loop(DistkvClient distkvClient) throws IOException {
    DistkvParser distkvParser = new DistkvParser();
    DistkvCommandExecutor distkvCommandExecutor = new DistkvCommandExecutor(distkvClient);
    Completer strPutCompleter = new ArgumentCompleter(new StringsCompleter("str.put"), new StringsCompleter("*"), new StringsCompleter("*"), NullCompleter.INSTANCE);
    Completer strGetCompleter = new ArgumentCompleter(new StringsCompleter("str.get"), new StringsCompleter("*"), new StringsCompleter("*"), NullCompleter.INSTANCE);
    Completer allCompleters = new AggregateCompleter(strPutCompleter, strGetCompleter);
    Terminal terminal = TerminalBuilder.builder().system(true).build();
    LineReader lineReader = LineReaderBuilder.builder().terminal(terminal).completer(allCompleters).build();
    final String prompt = "dkv-cli >";
    while (true) {
        String result = null;
        String line;
        line = lineReader.readLine(prompt);
        try {
            DistkvParsedResult parsedResult = distkvParser.parse(line);
            result = distkvCommandExecutor.execute(parsedResult);
        } catch (DictKeyNotFoundException e) {
            result = ("errorCode: " + e.getErrorCode() + ";\n Detail: " + e.getMessage());
        } catch (DistkvListIndexOutOfBoundsException e) {
            result = ("errorCode: " + e.getErrorCode() + ";\n Detail: " + e.getMessage());
        } catch (KeyNotFoundException e) {
            result = ("errorCode: " + e.getErrorCode() + ";\n Detail: " + e.getMessage());
        } catch (SlistMemberNotFoundException e) {
            result = ("errorCode: " + e.getErrorCode() + ";\n Detail: " + e.getMessage());
        } catch (SlistTopNumIsNonNegativeException e) {
            result = ("errorCode: " + e.getErrorCode() + ";\n Detail: " + e.getMessage());
        } catch (DistkvException e) {
            result = ("errorCode: " + e.getErrorCode() + ";\n Detail: " + e.getMessage());
        }
        System.out.println(PROMPT_STRING + result);
    }
}

16 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String ttl(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    DistkvRequest request = parsedResult.getRequest();
    return distkvClient.ttl(request.getKey()) + TimeUnit.MILLISECOND;
}

15 Source : DistkvSetBenchmark.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

@State(Scope.Thread)
@BenchmarkMode({ Mode.Throughput, Mode.AverageTime })
public clreplaced DistkvSetBenchmark {

    private static final String PROTOCOL = "distkv://127.0.0.1:8082";

    private static final String KEY_SET_SYNC = "k-set-sync";

    private static final String KEY_SET_ASYNC = "k-set-async";

    private DistkvAsyncClient asyncClient;

    private DistkvClient client;

    private Set<String> dummyData;

    @Setup
    public void init() {
        TestUtil.startRpcServer(8082);
        dummyData = ImmutableSet.of(RandomStringUtils.random(5), RandomStringUtils.random(5), RandomStringUtils.random(5));
        asyncClient = new DefaultAsyncClient(PROTOCOL);
        client = new DefaultDistkvClient(PROTOCOL);
        client.sets().put(KEY_SET_SYNC, dummyData);
        asyncClient.sets().put(KEY_SET_ASYNC, dummyData);
    }

    @TearDown
    public void close() {
        client.disconnect();
        asyncClient.disconnect();
        TestUtil.stopProcess(TestUtil.getProcess());
    }

    @Benchmark
    public void testAsyncGet(Blackhole blackhole) {
        blackhole.consume(asyncClient.sets().get(KEY_SET_ASYNC));
    }

    @Benchmark
    public void testSyncGet(Blackhole blackhole) {
        blackhole.consume(client.sets().get(KEY_SET_SYNC));
    }

    @Benchmark
    public void testSyncPut(Blackhole blackhole) {
        String randomStr = RandomStringUtils.random(5);
        client.sets().put(randomStr, dummyData);
    }

    @Benchmark
    public void testAsyncPut() {
        String randomStr = RandomStringUtils.random(5);
        asyncClient.sets().put(randomStr, dummyData);
    }

    @Benchmark
    public void testPureplacedem() {
        String randomStr = RandomStringUtils.random(5);
        client.sets().pureplacedem(KEY_SET_SYNC, randomStr);
    }

    @Benchmark
    public void testAsyncPureplacedem(Blackhole blackhole) {
        String randomStr = RandomStringUtils.random(5);
        blackhole.consume(asyncClient.sets().pureplacedem(KEY_SET_SYNC, randomStr));
    }
}

15 Source : DistkvListBenchmark.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

@State(Scope.Thread)
@BenchmarkMode({ Mode.Throughput, Mode.AverageTime })
public clreplaced DistkvListBenchmark {

    private static final String PROTOCOL = "distkv://127.0.0.1:8082";

    private static final String KEY_LIST_SYNC = "k-list-sync";

    private static final String KEY_LIST_ASYNC = "k-list-async";

    private DistkvAsyncClient asyncClient;

    private DistkvClient client;

    private List<String> dummyData;

    @Setup
    public void init() {
        TestUtil.startRpcServer(8082);
        dummyData = ImmutableList.of(RandomStringUtils.random(5), RandomStringUtils.random(5), RandomStringUtils.random(5));
        asyncClient = new DefaultAsyncClient(PROTOCOL);
        client = new DefaultDistkvClient(PROTOCOL);
        client.lists().put(KEY_LIST_SYNC, dummyData);
        asyncClient.lists().put(KEY_LIST_ASYNC, dummyData);
    }

    @TearDown
    public void close() {
        asyncClient.disconnect();
        client.disconnect();
        TestUtil.stopProcess(TestUtil.getProcess());
    }

    @Benchmark
    public void testSyncGet(Blackhole blackhole) {
        blackhole.consume(client.lists().get(KEY_LIST_SYNC));
    }

    @Benchmark
    public void testAsyncGet(Blackhole blackhole) {
        blackhole.consume(asyncClient.lists().get(KEY_LIST_ASYNC));
    }

    @Benchmark
    public void testPut() {
        String randomStr = RandomStringUtils.random(5);
        client.lists().put(randomStr, dummyData);
    }

    @Benchmark
    public void testAsyncPut() {
        String randomStr = RandomStringUtils.random(5);
        asyncClient.lists().put(randomStr, dummyData);
    }

    @Benchmark
    public void testLPut() {
        client.lists().lput(KEY_LIST_SYNC, dummyData);
    }

    @Benchmark
    public void testAsyncLPut() {
        asyncClient.lists().lput(KEY_LIST_ASYNC, dummyData);
    }
}

15 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String slistRemoveMember(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SlistRemoveMemberRequest slistRemoveMemberRequest = request.getRequest().unpack(SlistRemoveMemberRequest.clreplaced);
        distkvClient.slists().removeMember(request.getKey(), slistRemoveMemberRequest.getMember());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

15 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String strGet(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        return distkvClient.strs().get(request.getKey());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
}

15 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String intGet(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        return String.valueOf(distkvClient.ints().get(request.getKey()));
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
}

15 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String drop(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    DistkvRequest request = parsedResult.getRequest();
    distkvClient.drop(request.getKey());
    return STATUS_OK;
}

15 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String activeNamespace(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    DistkvRequest request = parsedResult.getRequest();
    distkvClient.activeNamespace(request.getNamespace());
    return STATUS_OK;
}

15 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String strPut(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        StrPutRequest strPutRequest = request.getRequest().unpack(StrPutRequest.clreplaced);
        distkvClient.strs().put(request.getKey(), strPutRequest.getValue());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

14 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String listGet(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        ListGetRequest listGetRequest = request.getRequest().unpack(ListGetRequest.clreplaced);
        List<String> list = null;
        if (listGetRequest.getType() == ListProtocol.GetType.GET_ALL) {
            list = distkvClient.lists().get(request.getKey());
        } else if (listGetRequest.getType() == ListProtocol.GetType.GET_ONE) {
            list = distkvClient.lists().get(request.getKey(), listGetRequest.getIndex());
        } else if (listGetRequest.getType() == ListProtocol.GetType.GET_RANGE) {
            list = distkvClient.lists().get(request.getKey(), listGetRequest.getFrom(), listGetRequest.getEnd());
        }
        return list == null ? null : list.toString();
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
}

14 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String dictPopItem(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        DictPopItemRequest dictPopItemRequest = request.getRequest().unpack(DictPopItemRequest.clreplaced);
        return distkvClient.dicts().popItem(request.getKey(), dictPopItemRequest.gereplacedemKey());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
}

14 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String setRemoveItem(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SetRemoveItemRequest setRemoveItemRequest = request.getRequest().unpack(SetRemoveItemRequest.clreplaced);
        distkvClient.sets().removeItem(request.getKey(), setRemoveItemRequest.gereplacedemValue());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

14 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String exists(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    DistkvRequest request = parsedResult.getRequest();
    return String.valueOf(distkvClient.exists(request.getKey()));
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String setPureplacedem(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SetPureplacedemRequest setPureplacedemRequest = request.getRequest().unpack(SetPureplacedemRequest.clreplaced);
        distkvClient.sets().pureplacedem(request.getKey(), setPureplacedemRequest.gereplacedemValue());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String listPut(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        ListPutRequest listPutRequest = request.getRequest().unpack(ListPutRequest.clreplaced);
        distkvClient.lists().put(request.getKey(), listPutRequest.getValuesList());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String slistIncrScore(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SlistIncrScoreRequest slistIncrScoreRequest = request.getRequest().unpack(SlistIncrScoreRequest.clreplaced);
        distkvClient.slists().incrScore(request.getKey(), slistIncrScoreRequest.getMember(), slistIncrScoreRequest.getDelta());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String listLPut(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        ListLPutRequest listLPutRequest = request.getRequest().unpack(ListLPutRequest.clreplaced);
        distkvClient.lists().lput(request.getKey(), listLPutRequest.getValuesList());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String dictRemoveItem(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        DictRemoveItemRequest dictRemoveItemRequest = request.getRequest().unpack(DictRemoveItemRequest.clreplaced);
        distkvClient.dicts().removeItem(request.getKey(), dictRemoveItemRequest.gereplacedemKey());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String setExists(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SetExistsRequest setExistsRequest = request.getRequest().unpack(SetExistsRequest.clreplaced);
        return String.valueOf(distkvClient.sets().exists(request.getKey(), setExistsRequest.getEnreplacedy()));
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String listMRemove(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        ListMRemoveRequest listMRemoveRequest = request.getRequest().unpack(ListMRemoveRequest.clreplaced);
        distkvClient.lists().mremove(request.getKey(), listMRemoveRequest.getIndexesList());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String slistPut(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SlistPutRequest slistPutRequest = request.getRequest().unpack(SlistPutRequest.clreplaced);
        final LinkedList<SlistEnreplacedy> sortedListEnreplacediesResult = new LinkedList<>();
        final List<SlistProtocol.SlistEnreplacedy> sortedListEnreplacedies = slistPutRequest.getListList();
        for (SlistProtocol.SlistEnreplacedy sortedListEnreplacedy : sortedListEnreplacedies) {
            final String sortedListEnreplacedyMember = sortedListEnreplacedy.getMember();
            final int sortedListEnreplacedyScore = sortedListEnreplacedy.getScore();
            sortedListEnreplacediesResult.add(new SlistEnreplacedy(sortedListEnreplacedyMember, sortedListEnreplacedyScore));
        }
        distkvClient.slists().put(request.getKey(), sortedListEnreplacediesResult);
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String slistPutMember(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SlistPutMemberRequest slistPutMemberRequest = request.getRequest().unpack(SlistPutMemberRequest.clreplaced);
        final String member = slistPutMemberRequest.getMember();
        final int score = slistPutMemberRequest.getScore();
        distkvClient.slists().putMember(request.getKey(), new SlistEnreplacedy(member, score));
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String dictGereplacedem(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        DictGereplacedemRequest dictGereplacedemRequest = request.getRequest().unpack(DictGereplacedemRequest.clreplaced);
        return distkvClient.dicts().gereplacedem(request.getKey(), dictGereplacedemRequest.gereplacedemKey());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String setPut(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SetPutRequest setPutRequest = request.getRequest().unpack(SetPutRequest.clreplaced);
        distkvClient.sets().put(request.getKey(), new HashSet<>(setPutRequest.getValuesList()));
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String listRPut(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        ListRPutRequest listRPutRequest = request.getRequest().unpack(ListRPutRequest.clreplaced);
        distkvClient.lists().rput(request.getKey(), listRPutRequest.getValuesList());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String intIncr(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        IntIncrRequest intIncrRequest = request.getRequest().unpack(IntIncrRequest.clreplaced);
        distkvClient.ints().incr(request.getKey(), intIncrRequest.getDelta());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String setGet(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    DistkvRequest request = parsedResult.getRequest();
    final StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("{");
    Set<String> set = distkvClient.sets().get(request.getKey());
    boolean first = true;
    for (final String element : set) {
        if (first) {
            first = false;
        } else {
            stringBuilder.append(", ");
        }
        stringBuilder.append(element);
    }
    stringBuilder.append("}");
    return stringBuilder.toString();
}

13 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String intPut(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        IntPutRequest intPutRequest = request.getRequest().unpack(IntPutRequest.clreplaced);
        distkvClient.ints().put(request.getKey(), intPutRequest.getValue());
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
    return STATUS_OK;
}

12 Source : CommandExecutorHandler.java
with BSD 3-Clause "New" or "Revised" License
from distkv-project

public static String slistTop(DistkvClient distkvClient, DistkvParsedResult parsedResult) {
    try {
        DistkvRequest request = parsedResult.getRequest();
        SlistTopRequest slistTopRequest = request.getRequest().unpack(SlistTopRequest.clreplaced);
        final StringBuilder stringBuilder = new StringBuilder();
        LinkedList<SlistEnreplacedy> listEnreplacedies = distkvClient.slists().top(request.getKey(), slistTopRequest.getCount());
        boolean first = true;
        stringBuilder.append("[");
        for (final SlistEnreplacedy enreplacedy : listEnreplacedies) {
            if (first) {
                first = false;
            } else {
                stringBuilder.append(", ");
            }
            stringBuilder.append("(");
            stringBuilder.append(enreplacedy.getMember());
            stringBuilder.append(", ");
            stringBuilder.append(enreplacedy.getScore());
            stringBuilder.append(")");
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    } catch (InvalidProtocolBufferException e) {
        throw new DistkvException(e.toString());
    }
}

See More Examples