io.etcd.jetcd.KeyValue Java Examples

@Test
public void testUseEtcd() throws Exception {
    try (EtcdCluster etcd = EtcdClusterFactory.buildCluster(getClass().getSimpleName(), 3, false)) {
        etcd.start();
        try (Client client = Client.builder().endpoints(etcd.getClientEndpoints()).build()) {
            try (KV kvClient = client.getKVClient()) {
                ByteSequence key = bytesOf("test_key");
                ByteSequence value = bytesOf("test_value");
                kvClient.put(key, value).get();

                CompletableFuture<GetResponse> getFuture = kvClient.get(key);
                GetResponse response = getFuture.get();
                List<KeyValue> values = response.getKvs();
                assertThat(values.size()).isEqualTo(1);
                KeyValue value1 = values.get(0);
                assertThat(value1.getValue()).isEqualTo(value);
                assertThat(value1.getKey()).isEqualTo(key);
            }
        }
    }
}
 

/**
 * convert API watch event to client event.
 */
private static WatchEvent toEvent(Event event, ByteSequence namespace) {
    WatchEvent.EventType eventType;
    switch (event.getType()) {
        case DELETE:
            eventType = WatchEvent.EventType.DELETE;
            break;
        case PUT:
            eventType = WatchEvent.EventType.PUT;
            break;
        default:
            eventType = WatchEvent.EventType.UNRECOGNIZED;
    }

    return new WatchEvent(new KeyValue(event.getKv(), namespace), new KeyValue(event.getPrevKv(), namespace), eventType);
}
 

@Test
public void assertGetChildrenKeys() {
    io.etcd.jetcd.api.KeyValue keyValue1 = io.etcd.jetcd.api.KeyValue.newBuilder()
        .setKey(ByteString.copyFromUtf8("/key/key1/key1-1"))
        .setValue(ByteString.copyFromUtf8("value1")).build();
    io.etcd.jetcd.api.KeyValue keyValue2 = io.etcd.jetcd.api.KeyValue.newBuilder()
        .setKey(ByteString.copyFromUtf8("/key/key2"))
        .setValue(ByteString.copyFromUtf8("value3")).build();
    List<KeyValue> keyValues = Arrays.asList(new KeyValue(keyValue1, ByteSequence.EMPTY), new KeyValue(keyValue2, ByteSequence.EMPTY), 
            new KeyValue(keyValue1, ByteSequence.EMPTY));
    when(getResponse.getKvs()).thenReturn(keyValues);
    List<String> actual = centerRepository.getChildrenKeys("/key");
    assertThat(actual.size(), is(2));
    Iterator<String> iterator = actual.iterator();
    assertThat(iterator.next(), is("key1"));
    assertThat(iterator.next(), is("key2"));
}
 

private Set<ClientInfo> getClientInfos(KeyValue keyValue) {
    Set<ClientInfo> clientInfos;
    if (keyValue == null || keyValue.getValue() == null) {
        clientInfos = new HashSet<>();
    } else {
        clientInfos = new HashSet<>(JSON.parseArray(keyValue.getValue().toString(StandardCharsets.UTF_8), ClientInfo.class));
    }
    return clientInfos;
}
 

/**
 * @return previous key-value pairs.
 */
public synchronized List<KeyValue> getPrevKvs() {
    if (prevKvs == null) {
        prevKvs = getResponse().getPrevKvsList().stream().map(kv -> new KeyValue(kv, namespace))
            .collect(Collectors.toList());
    }

    return prevKvs;
}
 

/**
 * @return a list of key-value pairs matched by the range request.
 */
public synchronized List<KeyValue> getKvs() {
    if (kvs == null) {
        kvs = getResponse().getKvsList().stream().map(kv -> new KeyValue(kv, namespace)).collect(Collectors.toList());
    }

    return kvs;
}
 

@SneakyThrows({NoSuchFieldException.class, SecurityException.class})
private WatchResponse buildWatchResponse(final WatchEvent.EventType eventType) {
    WatchResponse watchResponse = new WatchResponse(mock(io.etcd.jetcd.api.WatchResponse.class), ByteSequence.EMPTY);
    List<WatchEvent> events = new ArrayList<>();
    io.etcd.jetcd.api.KeyValue keyValue1 = io.etcd.jetcd.api.KeyValue.newBuilder()
            .setKey(ByteString.copyFromUtf8("key1"))
            .setValue(ByteString.copyFromUtf8("value1")).build();
    KeyValue keyValue = new KeyValue(keyValue1, ByteSequence.EMPTY);
    events.add(new WatchEvent(keyValue, mock(KeyValue.class), eventType));
    FieldSetter.setField(watchResponse, watchResponse.getClass().getDeclaredField("events"), events);
    return watchResponse;
}
 

@SneakyThrows({InterruptedException.class, ExecutionException.class})
@Override
public List<String> getChildrenKeys(final String key) {
    String prefix = key + "/";
    ByteSequence prefixByteSequence = ByteSequence.from(prefix, Charsets.UTF_8);
    GetOption getOption = GetOption.newBuilder().withPrefix(prefixByteSequence).withSortField(GetOption.SortTarget.KEY).withSortOrder(GetOption.SortOrder.ASCEND).build();
    List<KeyValue> keyValues = client.getKVClient().get(prefixByteSequence, getOption).get().getKvs();
    return keyValues.stream().map(e -> getSubNodeKeyName(prefix, e.getKey().toString(Charsets.UTF_8))).distinct().collect(Collectors.toList());
}
 

public WatchEvent(KeyValue keyValue, KeyValue prevKV, EventType eventType) {
    this.keyValue = keyValue;
    this.prevKV = prevKV;
    this.eventType = eventType;
}
 

public KeyValue getKeyValue() {
    return keyValue;
}
 

public KeyValue getPrevKV() {
    return prevKV;
}
 

public LeaderResponse(io.etcd.jetcd.api.LeaderResponse response, ByteSequence namespace) {
    super(response, response.getHeader());
    this.kv = new KeyValue(getResponse().getKv(), namespace);
}
 

/**
 * @return the key-value pair representing the latest leader update.
 */
public KeyValue getKv() {
    return kv;
}
 

@SneakyThrows({InterruptedException.class, ExecutionException.class})
@Override
public String get(final String key) {
    List<KeyValue> keyValues = client.getKVClient().get(ByteSequence.from(key, Charsets.UTF_8)).get().getKvs();
    return keyValues.isEmpty() ? null : keyValues.iterator().next().getValue().toString(Charsets.UTF_8);
}
 

/**
 * @return previous key-value pair.
 */
public KeyValue getPrevKv() {
    return new KeyValue(getResponse().getPrevKv(), namespace);
}
 

@Override
public String readSource() throws Exception {
    CompletableFuture<GetResponse> responseFuture = client.getKVClient().get(ByteSequence.from(key, charset));
    List<KeyValue> kvs = responseFuture.get().getKvs();
    return kvs.size() == 0 ? null : kvs.get(0).getValue().toString(charset);
}
 

/**
 * 注册Client列表更新监听
 *
 * @param binaryLogConfig
 * @param opLogEventHandlerFactory
 */
private void registerMetaDataWatcher(BinaryLogConfig binaryLogConfig, OpLogEventHandlerFactory opLogEventHandlerFactory) {

    String namespace = binaryLogConfig.getNamespace();
    String binLogClientSet = binaryLogConfig.getBinLogClientSet();

    Watch watchClient = etcdClient.getWatchClient();
    watchClient.watch(
            ByteSequence.from(etcdKeyPrefixUtil.withPrefix(namespace).concat(Constants.PATH_SEPARATOR).concat(binLogClientSet), StandardCharsets.UTF_8),
            WatchOption.newBuilder().withNoDelete(true).build(),
            new Watch.Listener() {
                @Override
                public void onNext(WatchResponse response) {
                    List<WatchEvent> eventList = response.getEvents();
                    for (WatchEvent event : eventList) {
                        if (WatchEvent.EventType.PUT.equals(event.getEventType())) {

                            KeyValue currentKV = event.getKeyValue();
                            Set<ClientInfo> currentClientInfoSet = getClientInfos(currentKV);

                            currentClientInfoSet
                                    .stream()
                                    .collect(Collectors.groupingBy(ClientInfo::getDatabaseEvent))
                                    .forEach(opLogEventHandlerFactory::updateClientBatch);
                        }
                    }
                }

                @Override
                public void onError(Throwable throwable) {
                    log.error("Watch clientInfo list change error.", throwable);
                }

                @Override
                public void onCompleted() {
                    log.info("Watch clientInfo list change completed.");
                }
            }
    );

}