io.etcd.jetcd.lease.LeaseKeepAliveResponse Java Examples

@Override
public long getLease(String leaseName, long leaseTTL) throws Exception{

    Lease lease = etcdClient.getLeaseClient();
    long leaseId = lease.grant(leaseTTL).get().getID();

    lease.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
        @Override
        public void onNext(LeaseKeepAliveResponse value) {
            logger.debug("{} lease keeps alive for [{}]s:", leaseName, value.getTTL());
        }

        @Override
        public void onError(Throwable t) {
            logger.debug("{} lease renewal Exception!", leaseName, t.fillInStackTrace());
        }

        @Override
        public void onCompleted() {
            logger.info("{} lease completed!", leaseName);
        }
    });

    return leaseId;
}
 

/**
 * acquire etcd lease and keep lease avtive
 *
 * @return
 * @throws InterruptedException
 * @throws ExecutionException
 */
private long acquireActiveLease() throws InterruptedException, ExecutionException {
    long leaseId = leaseClient.grant(leaseTTL).get().getID();
    logger.debug("LeaderSelector get leaseId:[{}] and ttl:[{}]", leaseId, leaseTTL);
    this.leaseCloser = leaseClient.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
        @Override
        public void onNext(LeaseKeepAliveResponse value) {
            logger.debug("LeaderSelector lease keeps alive for [{}]s:", value.getTTL());
        }

        @Override
        public void onError(Throwable t) {
            logger.debug("LeaderSelector lease renewal Exception!", t.fillInStackTrace());
            cancelTask();
        }

        @Override
        public void onCompleted() {
            logger.info("LeaderSelector lease renewal completed! start canceling task.");
            cancelTask();
        }
    });
    return leaseId;
}
 

private synchronized void processKeepAliveResponse(io.etcd.jetcd.api.LeaseKeepAliveResponse leaseKeepAliveResponse) {
    if (this.closed) {
        return;
    }

    final long leaseID = leaseKeepAliveResponse.getID();
    final long ttl = leaseKeepAliveResponse.getTTL();
    final KeepAlive ka = this.keepAlives.get(leaseID);

    if (ka == null) {
        // return if the corresponding keep alive has closed.
        return;
    }

    if (ttl > 0) {
        long nextKeepAlive = System.currentTimeMillis() + ttl * 1000 / 3;
        ka.setNextKeepAlive(nextKeepAlive);
        ka.setDeadLine(System.currentTimeMillis() + ttl * 1000);
        ka.onNext(leaseKeepAliveResponse);
    } else {
        // lease expired; close all keep alive
        this.removeKeepAlive(leaseID);
        ka.onError(newEtcdException(ErrorCode.NOT_FOUND, "etcdserver: requested lease not found"));
    }
}
 

@Override
public CompletableFuture<LeaseKeepAliveResponse> keepAliveOnce(long leaseId) {
    CompletableFuture<LeaseKeepAliveResponse> future = new CompletableFuture<>();

    StreamObserver<LeaseKeepAliveRequest> requestObserver = Observers.observe(
        this.leaseStub::leaseKeepAlive,
        response -> future.complete(new LeaseKeepAliveResponse(response)),
        throwable -> future.completeExceptionally(toEtcdException(throwable)));

    // cancel grpc stream when leaseKeepAliveResponseCompletableFuture completes.
    CompletableFuture<LeaseKeepAliveResponse> answer = future
        .whenCompleteAsync((val, throwable) -> requestObserver.onCompleted(), connectionManager.getExecutorService());

    requestObserver.onNext(LeaseKeepAliveRequest.newBuilder().setID(leaseId).build());

    return answer;
}
 

/**
 * 发送心跳到 etcd, 表明该host是活着的
 */
private void keepAlive() {
    Executors.newSingleThreadExecutor().submit(
            () -> {
                try {
                    lease.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
                        @Override
                        public void onNext(LeaseKeepAliveResponse value) {

                        }

                        @Override
                        public void onError(Throwable t) {

                        }

                        @Override
                        public void onCompleted() {

                        }
                    });
                    log.info("KeepAlive lease:" + leaseId + "; Hex format:" + Long.toHexString(leaseId));
                } catch (Exception e) {
                    log.error(e.getMessage(), e);
                }
            }
    );
}
 

@Test
public void testKeepAliveOnce() throws ExecutionException, InterruptedException {
    long leaseID = leaseClient.grant(2).get().getID();
    kvClient.put(KEY, VALUE, PutOption.newBuilder().withLeaseId(leaseID).build()).get();
    assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(1);
    LeaseKeepAliveResponse rp = leaseClient.keepAliveOnce(leaseID).get();
    assertThat(rp.getTTL()).isGreaterThan(0);
}
 

public void addObserver(StreamObserver<LeaseKeepAliveResponse> observer) {
    this.observers.add(observer);
}
 

public void removeObserver(StreamObserver<LeaseKeepAliveResponse> listener) {
    this.observers.remove(listener);
    if (this.observers.isEmpty()) {
        removeKeepAlive(leaseId);
    }
}
 

@Override
public void onNext(io.etcd.jetcd.api.LeaseKeepAliveResponse response) {
    for (StreamObserver<LeaseKeepAliveResponse> observer : observers) {
        observer.onNext(new LeaseKeepAliveResponse(response));
    }
}
 

@Override
public void onError(Throwable throwable) {
    for (StreamObserver<LeaseKeepAliveResponse> observer : observers) {
        observer.onError(toEtcdException(throwable));
    }
}
 

/**
 * keep alive one lease only once.
 *
 * @param  leaseId id of lease to keep alive once
 * @return         The keep alive response
 */
CompletableFuture<LeaseKeepAliveResponse> keepAliveOnce(long leaseId);
 

/**
 * keep the given lease alive forever.
 *
 * @param  leaseId  lease to be keep alive forever.
 * @param  observer the observer
 * @return          a KeepAliveListener that listens for KeepAlive responses.
 */
CloseableClient keepAlive(long leaseId, StreamObserver<LeaseKeepAliveResponse> observer);