293 lines
9.9 KiB
C++
293 lines
9.9 KiB
C++
#ifndef __ETCD_CLIENT_HPP__
|
|
#define __ETCD_CLIENT_HPP__
|
|
|
|
#include "etcd/Response.hpp"
|
|
|
|
#include <string>
|
|
|
|
#include "proto/rpc.grpc.pb.h"
|
|
#include "proto/v3lock.grpc.pb.h"
|
|
#include <grpc++/grpc++.h>
|
|
|
|
using etcdserverpb::Auth;
|
|
using etcdserverpb::KV;
|
|
using etcdserverpb::Lease;
|
|
using etcdserverpb::Watch;
|
|
using v3lockpb::Lock;
|
|
|
|
namespace etcdv3 {
|
|
class Transaction;
|
|
}
|
|
|
|
namespace etcd {
|
|
class Watcher;
|
|
|
|
/**
|
|
* Client is responsible for maintaining a connection towards an etcd server.
|
|
* Etcd operations can be reached via the methods of the client.
|
|
*/
|
|
class Client {
|
|
public:
|
|
/**
|
|
* Constructs an etcd client object.
|
|
*
|
|
* @param etcd_url is the url of the etcd server to connect to, like
|
|
* "http://127.0.0.1:2379", or multiple url, seperated by ',' or ';'.
|
|
* @param load_balancer is the load balance strategy, can be one of
|
|
* round_robin/pick_first/grpclb/xds.
|
|
*/
|
|
Client(std::string const &etcd_url,
|
|
std::string const &load_balancer = "round_robin");
|
|
|
|
/**
|
|
* Constructs an etcd client object.
|
|
*
|
|
* @param etcd_url is the url of the etcd server to connect to, like
|
|
* "http://127.0.0.1:2379", or multiple url, seperated by ',' or ';'.
|
|
* @param username username of etcd auth
|
|
* @param password password of etcd auth
|
|
* @param load_balancer is the load balance strategy, can be one of
|
|
* round_robin/pick_first/grpclb/xds.
|
|
*/
|
|
Client(std::string const &etcd_url, std::string const &username,
|
|
std::string const &password,
|
|
std::string const &load_balancer = "round_robin");
|
|
|
|
/**
|
|
* Sends a get request to the etcd server
|
|
* @param key is the key to be read
|
|
*/
|
|
pplx::task<Response> get(std::string const &key);
|
|
|
|
/**
|
|
* Sets the value of a key. The key will be modified if already exists or
|
|
* created if it does not exists.
|
|
* @param key is the key to be created or modified
|
|
* @param value is the new value to be set
|
|
*/
|
|
pplx::task<Response> set(std::string const &key, std::string const &value,
|
|
int ttl = 0);
|
|
|
|
/**
|
|
* Sets the value of a key. The key will be modified if already exists or
|
|
* created if it does not exists.
|
|
* @param key is the key to be created or modified
|
|
* @param value is the new value to be set
|
|
* @param leaseId is the lease attached to the key
|
|
*/
|
|
pplx::task<Response> set(std::string const &key, std::string const &value,
|
|
int64_t leaseId);
|
|
|
|
/**
|
|
* Creates a new key and sets it's value. Fails if the key already exists.
|
|
* @param key is the key to be created
|
|
* @param value is the value to be set
|
|
*/
|
|
pplx::task<Response> add(std::string const &key, std::string const &value,
|
|
int ttl = 0);
|
|
|
|
/**
|
|
* Creates a new key and sets it's value. Fails if the key already exists.
|
|
* @param key is the key to be created
|
|
* @param value is the value to be set
|
|
* @param leaseId is the lease attached to the key
|
|
*/
|
|
pplx::task<Response> add(std::string const &key, std::string const &value,
|
|
int64_t leaseId);
|
|
|
|
/**
|
|
* Modifies an existing key. Fails if the key does not exists.
|
|
* @param key is the key to be modified
|
|
* @param value is the new value to be set
|
|
*/
|
|
pplx::task<Response> modify(std::string const &key, std::string const &value,
|
|
int ttl = 0);
|
|
|
|
/**
|
|
* Modifies an existing key. Fails if the key does not exists.
|
|
* @param key is the key to be modified
|
|
* @param value is the new value to be set
|
|
* @param leaseId is the lease attached to the key
|
|
*/
|
|
pplx::task<Response> modify(std::string const &key, std::string const &value,
|
|
int64_t leaseId);
|
|
|
|
/**
|
|
* Modifies an existing key only if it has a specific value. Fails if the key
|
|
* does not exists or the original value differs from the expected one.
|
|
* @param key is the key to be modified
|
|
* @param value is the new value to be set
|
|
* @param old_value is the value to be replaced
|
|
*/
|
|
pplx::task<Response> modify_if(std::string const &key,
|
|
std::string const &value,
|
|
std::string const &old_value, int ttl = 0);
|
|
|
|
/**
|
|
* Modifies an existing key only if it has a specific value. Fails if the key
|
|
* does not exists or the original value differs from the expected one.
|
|
* @param key is the key to be modified
|
|
* @param value is the new value to be set
|
|
* @param old_value is the value to be replaced
|
|
* @param leaseId is the lease attached to the key
|
|
*/
|
|
pplx::task<Response> modify_if(std::string const &key,
|
|
std::string const &value,
|
|
std::string const &old_value, int64_t leaseId);
|
|
|
|
/**
|
|
* Modifies an existing key only if it has a specific modification index
|
|
* value. Fails if the key does not exists or the modification index of the
|
|
* previous value differs from the expected one.
|
|
* @param key is the key to be modified
|
|
* @param value is the new value to be set
|
|
* @param old_index is the expected index of the original value
|
|
*/
|
|
pplx::task<Response> modify_if(std::string const &key,
|
|
std::string const &value, int old_index,
|
|
int ttl = 0);
|
|
|
|
/**
|
|
* Modifies an existing key only if it has a specific modification index
|
|
* value. Fails if the key does not exists or the modification index of the
|
|
* previous value differs from the expected one.
|
|
* @param key is the key to be modified
|
|
* @param value is the new value to be set
|
|
* @param old_index is the expected index of the original value
|
|
* @param leaseId is the lease attached to the key
|
|
*/
|
|
pplx::task<Response> modify_if(std::string const &key,
|
|
std::string const &value, int old_index,
|
|
int64_t leaseId);
|
|
|
|
/**
|
|
* Removes a single key. The key has to point to a plain, non directory entry.
|
|
* @param key is the key to be deleted
|
|
*/
|
|
pplx::task<Response> rm(std::string const &key);
|
|
|
|
/**
|
|
* Removes a single key but only if it has a specific value. Fails if the key
|
|
* does not exists or the its value differs from the expected one.
|
|
* @param key is the key to be deleted
|
|
*/
|
|
pplx::task<Response> rm_if(std::string const &key,
|
|
std::string const &old_value);
|
|
|
|
/**
|
|
* Removes an existing key only if it has a specific modification index value.
|
|
* Fails if the key does not exists or the modification index of it differs
|
|
* from the expected one.
|
|
* @param key is the key to be deleted
|
|
* @param old_index is the expected index of the existing value
|
|
*/
|
|
pplx::task<Response> rm_if(std::string const &key, int old_index);
|
|
|
|
/**
|
|
* Gets a directory listing of the directory identified by the key.
|
|
* @param key is the key to be listed
|
|
*/
|
|
pplx::task<Response> ls(std::string const &key);
|
|
|
|
/**
|
|
* Gets a directory listing of the directory identified by the key.
|
|
* @param key is the key to be listed
|
|
* @param limit is the size limit of results to be listed, we don't use
|
|
* default parameters to ensure backwards binary compatibility.
|
|
*/
|
|
pplx::task<Response> ls(std::string const &key, size_t const limit);
|
|
|
|
/**
|
|
* Removes a directory node. Fails if the parent directory dos not exists or
|
|
* not a directory.
|
|
* @param key is the directory to be created to be listed
|
|
* @param recursive if true then delete a whole subtree, otherwise deletes
|
|
* only an empty directory.
|
|
*/
|
|
pplx::task<Response> rmdir(std::string const &key, bool recursive = false);
|
|
|
|
/**
|
|
* Watches for changes of a key or a subtree. Please note that if you watch
|
|
* e.g. "/testdir" and a new key is created, like "/testdir/newkey" then no
|
|
* change happened in the value of
|
|
* "/testdir" so your watch will not detect this. If you want to detect
|
|
* addition and deletion of directory entries then you have to do a recursive
|
|
* watch.
|
|
* @param key is the value or directory to be watched
|
|
* @param recursive if true watch a whole subtree
|
|
*/
|
|
pplx::task<Response> watch(std::string const &key, bool recursive = false);
|
|
|
|
/**
|
|
* Watches for changes of a key or a subtree from a specific index. The index
|
|
* value can be in the "past".
|
|
* @param key is the value or directory to be watched
|
|
* @param fromIndex the first index we are interested in
|
|
* @param recursive if true watch a whole subtree
|
|
*/
|
|
pplx::task<Response> watch(std::string const &key, int fromIndex,
|
|
bool recursive = false);
|
|
|
|
/**
|
|
* Grants a lease.
|
|
* @param ttl is the time to live of the lease (in seconds)
|
|
*/
|
|
pplx::task<Response> leasegrant(int ttl);
|
|
|
|
/**
|
|
* Gets the list of existing leases
|
|
*/
|
|
pplx::task<Response> listleases();
|
|
|
|
/**
|
|
* Renews a lease.
|
|
* @param lease_id is the id of of the lease
|
|
*/
|
|
pplx::task<Response> leasekeepalive(int64_t lease_id);
|
|
|
|
/**
|
|
* Revokes a lease.
|
|
* @param lease_id is the id of of the lease
|
|
*/
|
|
pplx::task<Response> leaserevoke(int64_t lease_id);
|
|
|
|
/**
|
|
* Gets the TTL of an existing lease
|
|
* @param lease_id is the id of of the lease
|
|
*/
|
|
pplx::task<Response> leasettl(int64_t lease_id, bool keys);
|
|
|
|
/**
|
|
* Gains a lock at a key.
|
|
* @param key is the key to be used to request the lock.
|
|
*/
|
|
pplx::task<Response> lock(std::string const &key);
|
|
|
|
/**
|
|
* Releases a lock at a key.
|
|
* @param key is the lock key to release.
|
|
*/
|
|
pplx::task<Response> unlock(std::string const &key);
|
|
|
|
/**
|
|
* Execute a etcd transaction.
|
|
* @param txn is the transaction object to be executed.
|
|
*/
|
|
pplx::task<Response> txn(etcdv3::Transaction const &txn);
|
|
|
|
private:
|
|
std::shared_ptr<grpc::Channel> channel;
|
|
std::string auth_token;
|
|
std::unique_ptr<KV::Stub> kvServiceStub;
|
|
std::unique_ptr<Watch::Stub> watchServiceStub;
|
|
std::unique_ptr<Lease::Stub> leaseServiceStub;
|
|
std::unique_ptr<Lock::Stub> lockServiceStub;
|
|
|
|
friend class Watcher;
|
|
friend class KeepAlive;
|
|
};
|
|
|
|
} // namespace etcd
|
|
|
|
#endif
|