2 +--------------------------------------------------------------------+
3 | libmemcached - 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 Michael Wallner <mike@php.net> |
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
98 if (!opt.isset("quiet")) {
100 << "SASL username was supplied, but binary was not built with SASL support.\n";
105 if (MEMCACHED_SUCCESS
106 != memcached_set_sasl_auth_data(memc, username, opt.argof("password"))) {
107 if (!opt.isset("quiet")) {
108 std::cerr << memcached_last_error_message(memc);
118 def("binary", 'b', no_argument, "Use the binary memcached protocol.")
119 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
120 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, ext.set)) {
121 if(!opt.isset("quiet")) {
122 std::cerr << memcached_last_error_message(memc);
128 def("buffer", 'B', no_argument, "Buffer requests.")
129 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
130 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, ext.set)) {
131 if(!opt.isset("quiet")) {
132 std::cerr << memcached_last_error_message(memc);
138 def("non-blocking", 'n', no_argument, "Use non-blocking connections.")
139 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
140 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, ext.set)) {
141 if(!opt.isset("quiet")) {
142 std::cerr << memcached_last_error_message(memc);
148 def("tcp-nodelay", 'N', no_argument, "Disable Nagle's algorithm.")
149 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
150 if (MEMCACHED_SUCCESS != memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, ext.set)) {
151 if(!opt.isset("quiet")) {
152 std::cerr << memcached_last_error_message(memc);
158 def("servers", 's', required_argument, "List of servers to connect to.")
159 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
160 auto servers = ext.arg;
162 if (opt.isset("verbose")) {
163 std::cerr << "Checking environment for a server list in MEMCACHED_SERVERS.\n";
165 servers = getenv("MEMCACHED_SERVERS");
166 if (!servers || !*servers) {
167 if (!opt.isset("quiet")) {
168 std::cerr << "No servers provided.\n";
174 auto server_list = memcached_servers_parse(servers);
175 if (!server_list || !memcached_server_list_count(server_list)) {
176 if (!opt.isset("quiet")) {
177 std::cerr << "Invalid server list provided: '" << servers << "'\n";
180 memcached_server_list_free(server_list);
185 if (MEMCACHED_SUCCESS != memcached_server_push(memc, server_list)) {
186 if (!opt.isset("quiet")) {
187 std::cerr << memcached_last_error_message(memc);
189 memcached_server_list_free(server_list);
192 memcached_server_list_free(server_list);
195 def("hash", 'H', required_argument, "Key hashing method.")
196 .apply = [](const client_options &opt, const extended_option &ext, memcached_st *memc) {
198 std::string hash_wanted{ext.arg};
199 memcached_hash_t hash = MEMCACHED_HASH_DEFAULT;
201 std::transform(hash_wanted.begin(), hash_wanted.end(), hash_wanted.begin(), ::toupper);
203 if (opt.isset("verbose")) {
204 std::cerr << "Checking for hash '" << hash_wanted << "'.\n";
206 for (int h = MEMCACHED_HASH_DEFAULT; h < MEMCACHED_HASH_MAX; ++h) {
207 auto hash_type = static_cast<memcached_hash_t>(h);
208 std::string hash_string{libmemcached_string_hash(hash_type)};
210 if (hash_wanted.length() == hash_string.length()) {
211 auto ci = std::equal(hash_string.begin(), hash_string.end(), hash_wanted.begin(),
212 [](int a, int b) { return ::toupper(a) == b; });
219 if (hash == MEMCACHED_HASH_DEFAULT) {
220 if (!opt.isset("quiet")) {
221 std::cerr << "Could not find hash '" << hash_wanted << "'.\n";
224 if (MEMCACHED_SUCCESS != memcached_behavior_set_key_hash(memc, hash)) {
225 if (!opt.isset("quiet")) {
226 std::cerr << memcached_last_error_message(memc);
235 extended_option &def(option opt, std::string help) {
236 defaults.emplace_back(extended_option{opt, std::move(help), {}, {}, nullptr, false});
237 return defaults.back();
240 extended_option &def(const char *name, char flag, int has_arg, const char *help) {
241 return def(option{name, has_arg, nullptr, flag}, help);
244 extended_option &add(extended_option ext) {
245 options.emplace_back(std::move(ext));
246 return options.back();
249 extended_option &add(option opt, std::string help) {
250 options.emplace_back(extended_option{opt, std::move(help), nullptr, nullptr, nullptr, false});
251 return options.back();
254 extended_option &add(const char *name, char flag, int has_arg, const char *help) {
255 return add(option{name, has_arg, nullptr, flag}, help);
258 extended_option &get(const std::string &name) {
262 extended_option &get(int c) {
267 const extended_option &get(const std::string &name) const {
271 const extended_option &get(int c) const {
276 bool has(const std::string &name) const {
277 auto found = find(name);
278 return found != options.cend();
280 bool has(int c) const {
281 auto found = find(c);
282 return found != options.cend();
285 bool isset(const std::string &name) const {
286 return has(name) && get(name).set;
288 bool isset(int c) const {
289 return has(c) && get(c).set;
292 void unset(const std::string &name) {
299 void set(const std::string &name, bool set_ = true, char *optarg_ = nullptr) {
301 auto &opt = get(name);
306 void set(int c, bool set_ = true, char *optarg_ = nullptr) {
314 char *argof(const std::string &name) const {
316 return get(name).arg;
320 char *argof(int c) const {
327 const extended_option &operator[](const std::string &name) const {
330 const extended_option &operator[](int c) const {
334 void print_version() const;
335 void print_help() const;
337 bool parse(int argc, char *argv[], char ***argp = nullptr);
338 bool apply(memcached_st *memc);
341 using iterator = std::vector<extended_option>::iterator;
342 using const_iterator = std::vector<extended_option>::const_iterator;
343 using predicate = std::function<bool(const extended_option &ext)>;
345 const_iterator find(const predicate &pred) const {
346 return std::find_if(options.cbegin(), options.cend(), pred);
348 const_iterator find(const std::string &name) const {
349 return find([&name](const extended_option &ext) {
350 return ext.opt.name && ext.opt.name == name;
353 const_iterator find(int c) const {
354 return find([c](const extended_option &ext) {
355 return ext.opt.val == c || (c == 1 && ext.opt.val == '-');
359 iterator find(const predicate &pred) {
360 return std::find_if(options.begin(), options.end(), pred);
362 iterator find(const std::string &name) {
363 return find([&name](const extended_option &ext) {
364 return ext.opt.name && ext.opt.name == name;
367 iterator find(int c) {
368 return find([c](const extended_option &ext) {
369 return ext.opt.val == c || (c == 1 && ext.opt.val == '-');