2 +--------------------------------------------------------------------+
3 | libmemcached-awesome - C/C++ Client Library for memcached |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted under the terms of the BSD license. |
7 | You should have received a copy of the license in a bundled file |
8 | named LICENSE; in case you did not receive a copy you can review |
9 | the terms online at: https://opensource.org/licenses/BSD-3-Clause |
10 +--------------------------------------------------------------------+
11 | Copyright (c) 2006-2014 Brian Aker https://datadifferential.com/ |
12 | Copyright (c) 2020-2021 Michael Wallner https://awesome.co/ |
13 +--------------------------------------------------------------------+
26 #include "libmemcached/common.h"
27 #include "p9y/getopt.hpp"
29 class client_options {
32 struct extended_option {
35 std::function<bool(client_options &, extended_option &)> parse;
36 std::function<bool(const client_options &, const extended_option &, memcached_st *)> apply;
41 std::vector<extended_option> options;
42 std::vector<extended_option> defaults;
44 const char *prog_name;
45 const char *prog_vers;
46 const char *prog_desc;
47 const char *prog_argp;
49 client_options(const char *prg, const char *ver, const char *dsc, const char *arg = nullptr)
58 def("help", 'h', no_argument, "Print this help.")
59 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *) {
66 def("version", 'V', no_argument, "Print program version.")
67 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *) {
75 def("verbose", 'v', no_argument, "Print more informational output.")
76 .parse = [](client_options &opt, extended_option &) {
80 def("debug", 'd', no_argument, "Print output useful only for debugging.")
81 .parse = [](client_options &opt, extended_option &) {
86 def("quiet", 'q', no_argument, "Print no output, not even errors.")
87 .parse = [](client_options &opt, extended_option &) {
93 def("password", 'p', required_argument, "SASL password.");
94 def("username", 'u', required_argument, "SASL username.")
95 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
96 if (auto username = ext.arg) {
97 #if !LIBMEMCACHED_WITH_SASL_SUPPORT
99 if (!opt.isset("quiet")) {
101 << "SASL username '" << username << "' was supplied, but binary was not built with SASL support.\n";
106 if (MEMCACHED_SUCCESS
107 != memcached_set_sasl_auth_data(memc, username, opt.argof("password"))) {
108 if (!opt.isset("quiet")) {
109 std::cerr << memcached_last_error_message(memc);
119 def("binary", 'b', no_argument, "Use the binary memcached protocol.")
120 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
121 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, ext.set)) {
122 if(!opt.isset("quiet")) {
123 std::cerr << memcached_last_error_message(memc);
129 def("buffer", 'B', no_argument, "Buffer requests.")
130 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
131 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, ext.set)) {
132 if(!opt.isset("quiet")) {
133 std::cerr << memcached_last_error_message(memc);
139 def("non-blocking", 'n', no_argument, "Use non-blocking connections.")
140 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
141 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, ext.set)) {
142 if(!opt.isset("quiet")) {
143 std::cerr << memcached_last_error_message(memc);
149 def("tcp-nodelay", 'N', no_argument, "Disable Nagle's algorithm.")
150 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
151 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, ext.set)) {
152 if(!opt.isset("quiet")) {
153 std::cerr << memcached_last_error_message(memc);
159 def("servers", 's', required_argument, "List of servers to connect to.")
160 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
161 auto servers = ext.arg;
163 if (opt.isset("verbose")) {
164 std::cerr << "Checking environment for a server list in MEMCACHED_SERVERS.\n";
166 servers = getenv("MEMCACHED_SERVERS");
167 if (!servers || !*servers) {
168 if (!opt.isset("quiet")) {
169 std::cerr << "No servers provided.\n";
175 auto server_list = memcached_servers_parse(servers);
176 if (!server_list || !memcached_server_list_count(server_list)) {
177 if (!opt.isset("quiet")) {
178 std::cerr << "Invalid server list provided: '" << servers << "'\n";
181 memcached_server_list_free(server_list);
186 if (MEMCACHED_SUCCESS != memcached_server_push(memc, server_list)) {
187 if (!opt.isset("quiet")) {
188 std::cerr << memcached_last_error_message(memc);
190 memcached_server_list_free(server_list);
193 memcached_server_list_free(server_list);
196 def("hash", 'H', required_argument, "Key hashing method.")
197 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
199 std::string hash_wanted{ext.arg};
200 memcached_hash_t hash = MEMCACHED_HASH_DEFAULT;
202 std::transform(hash_wanted.begin(), hash_wanted.end(), hash_wanted.begin(), ::toupper);
204 if (opt.isset("verbose")) {
205 std::cerr << "Checking for hash '" << hash_wanted << "'.\n";
207 for (int h = MEMCACHED_HASH_DEFAULT; h < MEMCACHED_HASH_MAX; ++h) {
208 auto hash_type = static_cast<memcached_hash_t>(h);
209 std::string hash_string{libmemcached_string_hash(hash_type)};
211 if (hash_wanted.length() == hash_string.length()) {
212 auto ci = std::equal(hash_string.begin(), hash_string.end(), hash_wanted.begin(),
213 [](int a, int b) { return ::toupper(a) == b; });
220 if (hash == MEMCACHED_HASH_DEFAULT) {
221 if (!opt.isset("quiet")) {
222 std::cerr << "Could not find hash '" << hash_wanted << "'.\n";
225 if (MEMCACHED_SUCCESS != memcached_behavior_set_key_hash(memc, hash)) {
226 if (!opt.isset("quiet")) {
227 std::cerr << memcached_last_error_message(memc);
236 extended_option &def(option opt, std::string help) {
237 defaults.emplace_back(extended_option{opt, std::move(help), {}, {}, nullptr, false});
238 return defaults.back();
241 extended_option &def(const char *name, char flag, int has_arg, const char *help) {
242 return def(option{name, has_arg, nullptr, flag}, help);
245 extended_option &add(extended_option ext) {
246 options.emplace_back(std::move(ext));
247 return options.back();
250 extended_option &add(option opt, std::string help) {
251 options.emplace_back(extended_option{opt, std::move(help), nullptr, nullptr, nullptr, false});
252 return options.back();
255 extended_option &add(const char *name, char flag, int has_arg, const char *help) {
256 return add(option{name, has_arg, nullptr, flag}, help);
259 extended_option &get(const std::string &name) {
263 extended_option &get(int c) {
268 const extended_option &get(const std::string &name) const {
272 const extended_option &get(int c) const {
277 bool has(const std::string &name) const {
278 auto found = find(name);
279 return found != options.cend();
281 bool has(int c) const {
282 auto found = find(c);
283 return found != options.cend();
286 bool isset(const std::string &name) const {
287 return has(name) && get(name).set;
289 bool isset(int c) const {
290 return has(c) && get(c).set;
293 void unset(const std::string &name) {
300 void set(const std::string &name, bool set_ = true, char *optarg_ = nullptr) {
302 auto &opt = get(name);
307 void set(int c, bool set_ = true, char *optarg_ = nullptr) {
315 char *argof(const std::string &name) const {
317 return get(name).arg;
321 char *argof(int c) const {
328 const extended_option &operator[](const std::string &name) const {
331 const extended_option &operator[](int c) const {
335 void print_version() const;
336 void print_help() const;
338 bool parse(int argc, char *argv[], char ***argp = nullptr);
339 bool apply(memcached_st *memc);
342 using iterator = std::vector<extended_option>::iterator;
343 using const_iterator = std::vector<extended_option>::const_iterator;
344 using predicate = std::function<bool(const extended_option &ext)>;
346 const_iterator find(const predicate &pred) const {
347 return std::find_if(options.cbegin(), options.cend(), pred);
349 const_iterator find(const std::string &name) const {
350 return find([&name](const extended_option &ext) {
351 return ext.opt.name && ext.opt.name == name;
354 const_iterator find(int c) const {
355 return find([c](const extended_option &ext) {
356 return ext.opt.val == c || (c == 1 && ext.opt.val == '-');
360 iterator find(const predicate &pred) {
361 return std::find_if(options.begin(), options.end(), pred);
363 iterator find(const std::string &name) {
364 return find([&name](const extended_option &ext) {
365 return ext.opt.name && ext.opt.name == name;
368 iterator find(int c) {
369 return find([c](const extended_option &ext) {
370 return ext.opt.val == c || (c == 1 && ext.opt.val == '-');