mirror
/
etcd-cpp-apiv3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace Tabs in sources and README with spaces. 

Signed-off-by: Tao He <sighingnow@gmail.com>
This commit is contained in:
Tao He 2022-04-08 20:49:56 +08:00
parent 56c7189f92
commit 680e8ad5c6
6 changed files with 141 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
README.md
View File

@ -580,28 +580,28 @@ void wait_for_connection(etcd::Client &client) {
// a loop for initialized a watcher with auto-restart capability // a loop for initialized a watcher with auto-restart capability
void initialize_watcher(const std::string& endpoints, void initialize_watcher(const std::string& endpoints,
const std::string& prefix, const std::string& prefix,
std::function<void(etcd::Response)> callback, std::function<void(etcd::Response)> callback,
std::shared_ptr<etcd::Watcher>& watcher) { std::shared_ptr<etcd::Watcher>& watcher) {
etcd::Client client(endpoints); etcd::Client client(endpoints);
wait_for_connection(client); wait_for_connection(client);
// Check if the failed one has been cancelled first // Check if the failed one has been cancelled first
if (watcher && watcher->Cancelled()) { if (watcher && watcher->Cancelled()) {
std::cout << "watcher's reconnect loop been cancelled" << std::endl; std::cout << "watcher's reconnect loop been cancelled" << std::endl;
return; return;
} }
watcher.reset(new etcd::Watcher(client, prefix, callback, true)); watcher.reset(new etcd::Watcher(client, prefix, callback, true));
// Note that lambda requires `mutable`qualifier. // Note that lambda requires `mutable`qualifier.
watcher->Wait([endpoints, prefix, callback, watcher->Wait([endpoints, prefix, callback,
/* By reference for renewing */ &watcher](bool cancelled) mutable { /* By reference for renewing */ &watcher](bool cancelled) mutable {
if (cancelled) { if (cancelled) {
std::cout << "watcher's reconnect loop stopped as been cancelled" << std::endl; std::cout << "watcher's reconnect loop stopped as been cancelled" << std::endl;
return; return;
} }
initialize_watcher(endpoints, prefix, callback, watcher); initialize_watcher(endpoints, prefix, callback, watcher);
}); });
} }
``` ```

46
etcd/v3/Transaction.hpp
View File

@ -5,13 +5,13 @@
#include <memory> #include <memory>
namespace etcdserverpb { namespace etcdserverpb {
class TxnRequest; class TxnRequest;
} }
namespace etcdv3 { namespace etcdv3 {
enum class CompareResult { enum class CompareResult {
EQUAL = 0, EQUAL = 0,
GREATER = 1, GREATER = 1,
LESS = 2, LESS = 2,
NOT_EQUAL = 3, NOT_EQUAL = 3,
@ -27,32 +27,32 @@ enum class CompareTarget {
class Transaction { class Transaction {
public: public:
Transaction(); Transaction();
Transaction(std::string const&); Transaction(std::string const&);
virtual ~Transaction(); virtual ~Transaction();
// Set a new key for different comparisons and /put/get/delete requests. // Set a new key for different comparisons and /put/get/delete requests.
void reset_key(std::string const& newkey); void reset_key(std::string const& newkey);
void init_compare(CompareResult, CompareTarget); void init_compare(CompareResult, CompareTarget);
void init_compare(std::string const &old_value, CompareResult, CompareTarget); void init_compare(std::string const &old_value, CompareResult, CompareTarget);
void init_compare(int64_t old_value, CompareResult, CompareTarget); void init_compare(int64_t old_value, CompareResult, CompareTarget);
void setup_basic_failure_operation(std::string const &key); void setup_basic_failure_operation(std::string const &key);
void setup_set_failure_operation(std::string const &key, std::string const &value, int64_t leaseid); void setup_set_failure_operation(std::string const &key, std::string const &value, int64_t leaseid);
void setup_basic_create_sequence(std::string const &key, std::string const &value, int64_t leaseid); void setup_basic_create_sequence(std::string const &key, std::string const &value, int64_t leaseid);
void setup_compare_and_swap_sequence(std::string const &valueToSwap, int64_t leaseid); void setup_compare_and_swap_sequence(std::string const &valueToSwap, int64_t leaseid);
void setup_delete_sequence(std::string const &key, std::string const &range_end, bool recursive); void setup_delete_sequence(std::string const &key, std::string const &range_end, bool recursive);
void setup_delete_failure_operation(std::string const &key, std::string const &range_end, bool recursive); void setup_delete_failure_operation(std::string const &key, std::string const &range_end, bool recursive);
void setup_compare_and_delete_operation(std::string const& key); void setup_compare_and_delete_operation(std::string const& key);
// update without `get` and no `prev_kv` returned // update without `get` and no `prev_kv` returned
void setup_put(std::string const &key, std::string const &value); void setup_put(std::string const &key, std::string const &value);
void setup_delete(std::string const &key); void setup_delete(std::string const &key);
std::unique_ptr<etcdserverpb::TxnRequest> txn_request; std::unique_ptr<etcdserverpb::TxnRequest> txn_request;
private: private:
std::string key; std::string key;
}; };
} }

6
src/Client.cpp
View File

@ -146,9 +146,9 @@ static std::string read_from_file(std::string const &filename) {
std::ifstream file(filename.c_str(), std::ios::in); std::ifstream file(filename.c_str(), std::ios::in);
if (file.is_open()) { if (file.is_open()) {
std::stringstream ss; std::stringstream ss;
ss << file.rdbuf (); ss << file.rdbuf ();
file.close (); file.close ();
return ss.str (); return ss.str ();
} }
return std::string{}; return std::string{};
} }

8
src/v3/AsyncLeaseAction.cpp
View File

@ -13,7 +13,7 @@ etcdv3::AsyncLeaseGrantAction::AsyncLeaseGrantAction(
etcdv3::ActionParameters const &param) etcdv3::ActionParameters const &param)
: etcdv3::Action(param) : etcdv3::Action(param)
{ {
LeaseGrantRequest leasegrant_request; LeaseGrantRequest leasegrant_request;
leasegrant_request.set_ttl(parameters.ttl); leasegrant_request.set_ttl(parameters.ttl);
// If ID is set to 0, etcd will choose an ID. // If ID is set to 0, etcd will choose an ID.
leasegrant_request.set_id(parameters.lease_id); leasegrant_request.set_id(parameters.lease_id);
@ -40,7 +40,7 @@ etcdv3::AsyncLeaseRevokeAction::AsyncLeaseRevokeAction(
etcdv3::ActionParameters const &param) etcdv3::ActionParameters const &param)
: etcdv3::Action(param) : etcdv3::Action(param)
{ {
LeaseRevokeRequest leaserevoke_request; LeaseRevokeRequest leaserevoke_request;
leaserevoke_request.set_id(parameters.lease_id); leaserevoke_request.set_id(parameters.lease_id);
response_reader = parameters.lease_stub->AsyncLeaseRevoke(&context, leaserevoke_request, &cq_); response_reader = parameters.lease_stub->AsyncLeaseRevoke(&context, leaserevoke_request, &cq_);
@ -162,7 +162,7 @@ etcdv3::AsyncLeaseTimeToLiveAction::AsyncLeaseTimeToLiveAction(
etcdv3::ActionParameters const &param) etcdv3::ActionParameters const &param)
: etcdv3::Action(param) : etcdv3::Action(param)
{ {
LeaseTimeToLiveRequest leasetimetolive_request; LeaseTimeToLiveRequest leasetimetolive_request;
leasetimetolive_request.set_id(parameters.lease_id); leasetimetolive_request.set_id(parameters.lease_id);
// FIXME: unsupported parameters: "keys" // FIXME: unsupported parameters: "keys"
// leasetimetolive_request.set_keys(parameters.keys); // leasetimetolive_request.set_keys(parameters.keys);
@ -189,7 +189,7 @@ etcdv3::AsyncLeaseLeasesAction::AsyncLeaseLeasesAction(
etcdv3::ActionParameters const &param) etcdv3::ActionParameters const &param)
: etcdv3::Action(param) : etcdv3::Action(param)
{ {
LeaseLeasesRequest leaseleases_request; LeaseLeasesRequest leaseleases_request;
response_reader = parameters.lease_stub->AsyncLeaseLeases(&context, leaseleases_request, &cq_); response_reader = parameters.lease_stub->AsyncLeaseLeases(&context, leaseleases_request, &cq_);
response_reader->Finish(&reply, &status, (void*)this); response_reader->Finish(&reply, &status, (void*)this);

182
src/v3/Transaction.cpp
View File

@ -13,11 +13,11 @@ namespace etcdv3 {
namespace detail { namespace detail {
static etcdserverpb::Compare::CompareResult to_compare_result(CompareResult r) { static etcdserverpb::Compare::CompareResult to_compare_result(CompareResult r) {
return static_cast<etcdserverpb::Compare::CompareResult>(static_cast<int>(r)); return static_cast<etcdserverpb::Compare::CompareResult>(static_cast<int>(r));
} }
static etcdserverpb::Compare::CompareTarget to_compare_target(CompareTarget t) { static etcdserverpb::Compare::CompareTarget to_compare_target(CompareTarget t) {
return static_cast<etcdserverpb::Compare::CompareTarget>(static_cast<int>(t)); return static_cast<etcdserverpb::Compare::CompareTarget>(static_cast<int>(t));
} }
} }
@ -25,176 +25,176 @@ static etcdserverpb::Compare::CompareTarget to_compare_target(CompareTarget t) {
} }
etcdv3::Transaction::Transaction() { etcdv3::Transaction::Transaction() {
txn_request.reset(new etcdserverpb::TxnRequest{}); txn_request.reset(new etcdserverpb::TxnRequest{});
} }
etcdv3::Transaction::Transaction(const std::string& key) : key(key) { etcdv3::Transaction::Transaction(const std::string& key) : key(key) {
txn_request.reset(new etcdserverpb::TxnRequest{}); txn_request.reset(new etcdserverpb::TxnRequest{});
} }
void etcdv3::Transaction::reset_key(std::string const& newkey) { void etcdv3::Transaction::reset_key(std::string const& newkey) {
key = newkey; key = newkey;
} }
void etcdv3::Transaction::init_compare(CompareResult result, CompareTarget target){ void etcdv3::Transaction::init_compare(CompareResult result, CompareTarget target){
Compare* compare = txn_request->add_compare(); Compare* compare = txn_request->add_compare();
compare->set_result(detail::to_compare_result(result)); compare->set_result(detail::to_compare_result(result));
compare->set_target(detail::to_compare_target(target)); compare->set_target(detail::to_compare_target(target));
compare->set_key(key); compare->set_key(key);
compare->set_version(0); compare->set_version(0);
} }
void etcdv3::Transaction::init_compare(std::string const& old_value, CompareResult result, CompareTarget target){ void etcdv3::Transaction::init_compare(std::string const& old_value, CompareResult result, CompareTarget target){
Compare* compare = txn_request->add_compare(); Compare* compare = txn_request->add_compare();
compare->set_result(detail::to_compare_result(result)); compare->set_result(detail::to_compare_result(result));
compare->set_target(detail::to_compare_target(target)); compare->set_target(detail::to_compare_target(target));
compare->set_key(key); compare->set_key(key);
compare->set_value(old_value); compare->set_value(old_value);
} }
void etcdv3::Transaction::init_compare(int64_t old_index, CompareResult result, CompareTarget target){ void etcdv3::Transaction::init_compare(int64_t old_index, CompareResult result, CompareTarget target){
Compare* compare = txn_request->add_compare(); Compare* compare = txn_request->add_compare();
compare->set_result(detail::to_compare_result(result)); compare->set_result(detail::to_compare_result(result));
compare->set_target(detail::to_compare_target(target)); compare->set_target(detail::to_compare_target(target));
compare->set_key(key); compare->set_key(key);
compare->set_mod_revision(old_index); compare->set_mod_revision(old_index);
} }
/** /**
* get key on failure * get key on failure
*/ */
void etcdv3::Transaction::setup_basic_failure_operation(std::string const& key) { void etcdv3::Transaction::setup_basic_failure_operation(std::string const& key) {
std::unique_ptr<RangeRequest> get_request(new RangeRequest()); std::unique_ptr<RangeRequest> get_request(new RangeRequest());
get_request->set_key(key); get_request->set_key(key);
RequestOp* req_failure = txn_request->add_failure(); RequestOp* req_failure = txn_request->add_failure();
req_failure->set_allocated_request_range(get_request.release()); req_failure->set_allocated_request_range(get_request.release());
} }
/** /**
* get key on failure, get key before put, modify and then get updated key * get key on failure, get key before put, modify and then get updated key
*/ */
void etcdv3::Transaction::setup_set_failure_operation(std::string const &key, std::string const &value, int64_t leaseid) { void etcdv3::Transaction::setup_set_failure_operation(std::string const &key, std::string const &value, int64_t leaseid) {
std::unique_ptr<PutRequest> put_request(new PutRequest()); std::unique_ptr<PutRequest> put_request(new PutRequest());
put_request->set_key(key); put_request->set_key(key);
put_request->set_value(value); put_request->set_value(value);
put_request->set_prev_kv(true); put_request->set_prev_kv(true);
put_request->set_lease(leaseid); put_request->set_lease(leaseid);
RequestOp* req_failure = txn_request->add_failure(); RequestOp* req_failure = txn_request->add_failure();
req_failure->set_allocated_request_put(put_request.release()); req_failure->set_allocated_request_put(put_request.release());
std::unique_ptr<RangeRequest> get_request(new RangeRequest()); std::unique_ptr<RangeRequest> get_request(new RangeRequest());
get_request->set_key(key); get_request->set_key(key);
req_failure = txn_request->add_failure(); req_failure = txn_request->add_failure();
req_failure->set_allocated_request_range(get_request.release()); req_failure->set_allocated_request_range(get_request.release());
} }
/** /**
* add key and then get new value of key * add key and then get new value of key
*/ */
void etcdv3::Transaction::setup_basic_create_sequence(std::string const& key, std::string const& value, int64_t leaseid) { void etcdv3::Transaction::setup_basic_create_sequence(std::string const& key, std::string const& value, int64_t leaseid) {
std::unique_ptr<PutRequest> put_request(new PutRequest()); std::unique_ptr<PutRequest> put_request(new PutRequest());
put_request->set_key(key); put_request->set_key(key);
put_request->set_value(value); put_request->set_value(value);
put_request->set_prev_kv(true); put_request->set_prev_kv(true);
put_request->set_lease(leaseid); put_request->set_lease(leaseid);
RequestOp* req_success = txn_request->add_success(); RequestOp* req_success = txn_request->add_success();
req_success->set_allocated_request_put(put_request.release()); req_success->set_allocated_request_put(put_request.release());
std::unique_ptr<RangeRequest> get_request(new RangeRequest()); std::unique_ptr<RangeRequest> get_request(new RangeRequest());
get_request->set_key(key); get_request->set_key(key);
req_success = txn_request->add_success(); req_success = txn_request->add_success();
req_success->set_allocated_request_range(get_request.release()); req_success->set_allocated_request_range(get_request.release());
} }
/** /**
* get key value then modify and get new value * get key value then modify and get new value
*/ */
void etcdv3::Transaction::setup_compare_and_swap_sequence(std::string const& value, int64_t leaseid) { void etcdv3::Transaction::setup_compare_and_swap_sequence(std::string const& value, int64_t leaseid) {
std::unique_ptr<PutRequest> put_request(new PutRequest()); std::unique_ptr<PutRequest> put_request(new PutRequest());
put_request->set_key(key); put_request->set_key(key);
put_request->set_value(value); put_request->set_value(value);
put_request->set_prev_kv(true); put_request->set_prev_kv(true);
put_request->set_lease(leaseid); put_request->set_lease(leaseid);
RequestOp* req_success = txn_request->add_success(); RequestOp* req_success = txn_request->add_success();
req_success->set_allocated_request_put(put_request.release()); req_success->set_allocated_request_put(put_request.release());
std::unique_ptr<RangeRequest> get_request(new RangeRequest()); std::unique_ptr<RangeRequest> get_request(new RangeRequest());
get_request->set_key(key); get_request->set_key(key);
req_success = txn_request->add_success(); req_success = txn_request->add_success();
req_success->set_allocated_request_range(get_request.release()); req_success->set_allocated_request_range(get_request.release());
} }
/** /**
* get key, delete * get key, delete
*/ */
void etcdv3::Transaction::setup_delete_sequence(std::string const &key, std::string const &range_end, bool recursive) { void etcdv3::Transaction::setup_delete_sequence(std::string const &key, std::string const &range_end, bool recursive) {
std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest()); std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest());
del_request->set_key(key); del_request->set_key(key);
del_request->set_prev_kv(true); del_request->set_prev_kv(true);
if(recursive) if(recursive)
{ {
del_request->set_range_end(range_end); del_request->set_range_end(range_end);
} }
RequestOp* req_success = txn_request->add_success(); RequestOp* req_success = txn_request->add_success();
req_success->set_allocated_request_delete_range(del_request.release()); req_success->set_allocated_request_delete_range(del_request.release());
} }
/** /**
* get key, delete * get key, delete
*/ */
void etcdv3::Transaction::setup_delete_failure_operation(std::string const &key, std::string const &range_end, bool recursive) { void etcdv3::Transaction::setup_delete_failure_operation(std::string const &key, std::string const &range_end, bool recursive) {
std::unique_ptr<RangeRequest> get_request(new RangeRequest()); std::unique_ptr<RangeRequest> get_request(new RangeRequest());
std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest()); std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest());
get_request.reset(new RangeRequest()); get_request.reset(new RangeRequest());
get_request->set_key(key); get_request->set_key(key);
if(recursive) if(recursive)
{ {
get_request->set_range_end(range_end); get_request->set_range_end(range_end);
get_request->set_sort_target(RangeRequest::SortTarget::RangeRequest_SortTarget_KEY); get_request->set_sort_target(RangeRequest::SortTarget::RangeRequest_SortTarget_KEY);
get_request->set_sort_order(RangeRequest::SortOrder::RangeRequest_SortOrder_ASCEND); get_request->set_sort_order(RangeRequest::SortOrder::RangeRequest_SortOrder_ASCEND);
} }
RequestOp* req_failure = txn_request->add_failure(); RequestOp* req_failure = txn_request->add_failure();
req_failure->set_allocated_request_range(get_request.release()); req_failure->set_allocated_request_range(get_request.release());
del_request.reset(new DeleteRangeRequest()); del_request.reset(new DeleteRangeRequest());
del_request->set_key(key); del_request->set_key(key);
if(recursive) if(recursive)
{ {
del_request->set_range_end(range_end); del_request->set_range_end(range_end);
} }
req_failure = txn_request->add_failure(); req_failure = txn_request->add_failure();
req_failure->set_allocated_request_delete_range(del_request.release()); req_failure->set_allocated_request_delete_range(del_request.release());
} }
void etcdv3::Transaction::setup_compare_and_delete_operation(std::string const& key) { void etcdv3::Transaction::setup_compare_and_delete_operation(std::string const& key) {
std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest()); std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest());
del_request->set_key(key); del_request->set_key(key);
del_request->set_prev_kv(true); del_request->set_prev_kv(true);
RequestOp* req_success = txn_request->add_success(); RequestOp* req_success = txn_request->add_success();
req_success->set_allocated_request_delete_range(del_request.release()); req_success->set_allocated_request_delete_range(del_request.release());
} }
void etcdv3::Transaction::setup_put(std::string const &key, std::string const &value) { void etcdv3::Transaction::setup_put(std::string const &key, std::string const &value) {
std::unique_ptr<PutRequest> put_request(new PutRequest()); std::unique_ptr<PutRequest> put_request(new PutRequest());
put_request->set_key(key); put_request->set_key(key);
put_request->set_value(value); put_request->set_value(value);
put_request->set_prev_kv(false); put_request->set_prev_kv(false);
RequestOp* req_success = txn_request->add_success(); RequestOp* req_success = txn_request->add_success();
req_success->set_allocated_request_put(put_request.release()); req_success->set_allocated_request_put(put_request.release());
} }
void etcdv3::Transaction::setup_delete(std::string const &key) { void etcdv3::Transaction::setup_delete(std::string const &key) {
std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest()); std::unique_ptr<DeleteRangeRequest> del_request(new DeleteRangeRequest());
del_request->set_key(key); del_request->set_key(key);
del_request->set_prev_kv(false); del_request->set_prev_kv(false);
RequestOp* req_success = txn_request->add_success(); RequestOp* req_success = txn_request->add_success();
req_success->set_allocated_request_delete_range(del_request.release()); req_success->set_allocated_request_delete_range(del_request.release());
} }
etcdv3::Transaction::~Transaction() { etcdv3::Transaction::~Transaction() {

20
tst/RewatchTest.cpp
View File

@ -39,28 +39,28 @@ void wait_for_connection(etcd::Client &client) {
} }
void initialize_watcher(const std::string& endpoints, void initialize_watcher(const std::string& endpoints,
const std::string& prefix, const std::string& prefix,
std::function<void(etcd::Response)> callback, std::function<void(etcd::Response)> callback,
std::shared_ptr<etcd::Watcher>& watcher) { std::shared_ptr<etcd::Watcher>& watcher) {
etcd::Client client(endpoints); etcd::Client client(endpoints);
wait_for_connection(client); wait_for_connection(client);
// Check if the failed one has been cancelled first // Check if the failed one has been cancelled first
if (watcher && watcher->Cancelled()) { if (watcher && watcher->Cancelled()) {
std::cout << "watcher's reconnect loop been cancelled" << std::endl; std::cout << "watcher's reconnect loop been cancelled" << std::endl;
return; return;
} }
watcher.reset(new etcd::Watcher(client, prefix, callback, true)); watcher.reset(new etcd::Watcher(client, prefix, callback, true));
// Note that lambda requires `mutable`qualifier. // Note that lambda requires `mutable`qualifier.
watcher->Wait([endpoints, prefix, callback, watcher->Wait([endpoints, prefix, callback,
/* By reference for renewing */ &watcher](bool cancelled) mutable { /* By reference for renewing */ &watcher](bool cancelled) mutable {
if (cancelled) { if (cancelled) {
std::cout << "watcher's reconnect loop stopped as been cancelled" << std::endl; std::cout << "watcher's reconnect loop stopped as been cancelled" << std::endl;
return; return;
} }
initialize_watcher(endpoints, prefix, callback, watcher); initialize_watcher(endpoints, prefix, callback, watcher);
}); });
} }
TEST_CASE("watch should can be re-established") TEST_CASE("watch should can be re-established")