AbstractMemCachedService NewMemCachedService(char * host, int port1, char* host2, int port2) {
AbstractMemCachedService abstractMemCachedService;
if ((abstractMemCachedService = malloc(sizeof(struct ConcreteMemCachedService)))) {
abstractMemCachedService->memc = memcached_create(NULL);
memcached_server_add(abstractMemCachedService->memc, host, port1);
abstractMemCachedService->memc2 = memcached_create(NULL);
memcached_server_add(abstractMemCachedService->memc2, host2, port2);
}
return abstractMemCachedService;
}
int main(int argc, char* argv[])
{
if(argc < 4) { usage(); }
char* host = argv[1];
unsigned short port = atoi(argv[2]);
if(port == 0) { usage(); }
uint32_t num = atoi(argv[3]);
if(num == 0) { usage(); }
memcached_st* mc = memcached_create(NULL);
if(mc == NULL) { pexit("memcached_create"); }
memcached_server_add(mc, host, port);
// memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
char kbuf[strlen(KEY_PREFIX) + 11];
char vbuf[strlen(VAL_PREFIX) + 11];
while(1) {
uint32_t i;
for(i=0; i < num; ++i) {
int klen = sprintf(kbuf, KEY_PREFIX "%d", i);
int vlen = sprintf(vbuf, VAL_PREFIX "%d", i);
printf("set '%s' = '%s'\n", kbuf, vbuf);
memcached_set(mc, kbuf, klen, vbuf, vlen, 0, 0);
}
for(i=0; i < num; ++i) {
int klen = sprintf(kbuf, KEY_PREFIX "%d", i);
int vlen = sprintf(vbuf, VAL_PREFIX "%d", i);
size_t vallen;
uint32_t flags;
memcached_return rc;
char* val = memcached_get(mc, kbuf, klen, &vallen, &flags, &rc);
if(!val) {
fprintf(stderr, "** key '%s' not found **\n", kbuf);
} else if(vallen != vlen || memcmp(val, vbuf, vlen) != 0) {
fprintf(stderr, "** key '%s' not match ** '", kbuf);
fwrite(val, vallen, 1, stderr);
fprintf(stderr, "'\n");
} else {
printf("get '%s' = '", kbuf);
fwrite(val, vallen, 1, stdout);
printf("'\n");
}
}
for(i=0; i < num; ++i) {
int klen = sprintf(kbuf, KEY_PREFIX "%d", i);
printf("delete '%s'\n", kbuf);
memcached_delete(mc, kbuf, klen, 0);
}
}
return 0;
}
bool libkv_libmemcached_add(libkv_t* x,
const char* hostname, unsigned int port)
{
kv_data* c = x->data;
return (c->err = memcached_server_add(c->st, hostname, port))
== MEMCACHED_SUCCESS;
}
static void parse_memcached_server(const json_t *obj)
{
const json_t *tmp;
const char *host;
int port = -1;
if (!json_is_object(obj))
return;
host = json_string_value(json_object_get(obj, "host"));
if (!host || !*host)
host = "127.0.0.1";
tmp = json_object_get(obj, "port");
if (json_is_integer(tmp)) {
port = json_integer_value(tmp);
if (port < 1 || port > 65535) {
applog(LOG_ERR, "invalid memcached port");
exit(1);
}
} else
port = 11211;
memcached_server_add(srv.mc, host, port);
}
memcached_protocol_t(const char *conn_str) {
memcached_create(&memcached);
// NOTE: we don't turn on noreply behavior because the stress
// client is designed to emulate real-world behavior, which
// commonly requires a reply. In order to do this properly we
// should pipeline sets according to batch factor, and then
// wait for store notifications for the batch.
//memcached_behavior_set(&memcached, MEMCACHED_BEHAVIOR_NOREPLY, 1);
// Parse the host string
char _host[MAX_HOST];
strncpy(_host, conn_str, MAX_HOST);
char *_port = NULL;
_port = strchr(_host, ':');
if(_port) {
*_port = '\0';
_port++;
} else {
fprintf(stderr, "Please use host string of the form host:port.\n");
exit(-1);
}
int port = atoi(_port);
// Connect to server
memcached_server_add(&memcached, _host, port);
}
Memc(in_port_t arg)
{
_memc= memcached_create(NULL);
if (_memc == NULL)
{
throw "memcached_create() failed";
}
memcached_server_add(_memc, "localhost", arg);
}
/* Make sure that I cant add a tcp server to a udp client */
static test_return_t add_tcp_server_udp_client_test(memcached_st *memc)
{
(void)memc;
#if 0
memcached_server_st server;
memcached_server_instance_st instance=
memcached_server_instance_by_position(memc, 0);
memcached_server_clone(&server, &memc->hosts[0]);
test_true(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
test_true(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
#endif
return TEST_SUCCESS;
}
bool c_Memcache::t_connect(CStrRef host, int port /*= 0*/,
int timeout /*= 0*/,
int timeoutms /*= 0*/) {
memcached_return_t ret;
if (!host.empty() && host[0] == '/') {
ret = memcached_server_add_unix_socket(&m_memcache, host.c_str());
} else {
ret = memcached_server_add(&m_memcache, host.c_str(), port);
}
return (ret == MEMCACHED_SUCCESS);
}
bool c_Memcache::t_connect(const String& host, int port /*= 0*/,
int timeout /*= 0*/,
int timeoutms /*= 0*/) {
memcached_return_t ret;
if (!host.empty() &&
!strncmp(host.c_str(), "unix://", sizeof("unix://") - 1)) {
const char *socket_path = host.substr(sizeof("unix://") - 1).c_str();
ret = memcached_server_add_unix_socket(&m_memcache, socket_path);
} else {
ret = memcached_server_add(&m_memcache, host.c_str(), port);
}
return (ret == MEMCACHED_SUCCESS);
}
static mrb_value mrb_memcached_server_add(mrb_state *mrb, mrb_value self)
{
mrb_memcached_data *data = DATA_PTR(self);
char *host;
mrb_int port;
memcached_return mrt;
mrb_get_args(mrb, "zi", &host, &port);
mrt = memcached_server_add(data->mst, host, port);
if (mrt != MEMCACHED_SUCCESS) {
// can't add server to memcached server list
mrb_raisef(mrb, E_RUNTIME_ERROR, "libmemcached error: %S"
, mrb_str_new_cstr(mrb, memcached_strerror(data->mst, mrt)));
}
return mrb_fixnum_value(mrt);
}
static bool HHVM_METHOD(Memcache, connect, const String& host, int port /*= 0*/,
int timeout /*= 0*/,
int timeoutms /*= 0*/) {
auto data = Native::data<MemcacheData>(this_);
memcached_return_t ret;
if (!host.empty() &&
!strncmp(host.c_str(), "unix://", sizeof("unix://") - 1)) {
const char *socket_path = host.substr(sizeof("unix://") - 1).c_str();
ret = memcached_server_add_unix_socket(&data->m_memcache, socket_path);
} else {
if (!isServerReachable(host, port)) {
return false;
}
ret = memcached_server_add(&data->m_memcache, host.c_str(), port);
}
return (ret == MEMCACHED_SUCCESS);
}
hashWrapper::hashWrapper(const std::string &config, const vecHostInfo &hosts)
{
this->pMemc = memcached(config.c_str(), config.length());
if(!this->pMemc )
throw MemcacheConstructionException();
serverCount = 0;
for(citerVecHostInfo host = hosts.begin(); host != hosts.end(); host++)
if(memcached_server_add(this->pMemc, (*host).first.c_str(), (*host).second) == MEMCACHED_SUCCESS)
serverCount++;
//
// Do not change ordering of options below; it is significant
//
memcached_behavior_set(this->pMemc, MEMCACHED_BEHAVIOR_KETAMA, 0);
memcached_behavior_set(this->pMemc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 0);
memcached_behavior_set(this->pMemc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_DEFAULT);
memcached_behavior_set(this->pMemc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT);
memcached_behavior_set(this->pMemc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_FNV1A_32);
this->hashType = HASHKIT_HASH_DEFAULT;
}
/// Gets the set of replicas to use for a read or write operation for the
/// specified key.
const std::vector<memcached_st*>& MemcachedStore::get_replicas(const std::string& key,
Op operation)
{
MemcachedStore::connection* conn = (connection*)pthread_getspecific(_thread_local);
if (conn == NULL)
{
// Create a new connection structure for this thread.
conn = new MemcachedStore::connection;
pthread_setspecific(_thread_local, conn);
conn->view_number = 0;
}
if (conn->view_number != _view_number)
{
// Either the view has changed or has not yet been set up, so set up the
// connection and replica structures for this thread.
for (size_t ii = 0; ii < conn->st.size(); ++ii)
{
memcached_free(conn->st[ii]);
conn->st[ii] = NULL;
}
pthread_rwlock_rdlock(&_view_lock);
LOG_DEBUG("Set up new view %d for thread", _view_number);
// Create a set of memcached_st's one per server.
conn->st.resize(_servers.size());
for (size_t ii = 0; ii < _servers.size(); ++ii)
{
// Create a new memcached_st for this server. Do not specify the server
// at this point as memcached() does not support IPv6 addresses.
LOG_DEBUG("Setting up server %d for connection %p (%s)", ii, conn, _options.c_str());
conn->st[ii] = memcached(_options.c_str(), _options.length());
LOG_DEBUG("Set up connection %p to server %s", conn->st[ii], _servers[ii].c_str());
// Switch to a longer connect timeout from here on.
memcached_behavior_set(conn->st[ii], MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 50);
// Connect to the server. The address is specified as either <IPv4 address>:<port>
// or [<IPv6 address>]:<port>. Look for square brackets to determine whether
// this is an IPv6 address.
std::vector<std::string> contact_details;
size_t close_bracket = _servers[ii].find(']');
if (close_bracket == _servers[ii].npos)
{
// IPv4 connection. Split the string on the colon.
Utils::split_string(_servers[ii], ':', contact_details);
if (contact_details.size() != 2)
{
LOG_ERROR("Malformed contact details %s", _servers[ii].c_str());
break;
}
}
else
{
// IPv6 connection. Split the string on ']', which removes any white
// space from the start and the end, then remove the '[' from the
// start of the IP addreess string and the start of the ';' from the start
// of the port string.
Utils::split_string(_servers[ii], ']', contact_details);
if ((contact_details.size() != 2) ||
(contact_details[0][0] != '[') ||
(contact_details[1][0] != ':'))
{
LOG_ERROR("Malformed contact details %s", _servers[ii].c_str());
break;
}
contact_details[0].erase(contact_details[0].begin());
contact_details[1].erase(contact_details[1].begin());
}
LOG_DEBUG("Setting server to IP address %s port %s",
contact_details[0].c_str(),
contact_details[1].c_str());
int port = atoi(contact_details[1].c_str());
memcached_server_add(conn->st[ii], contact_details[0].c_str(), port);
}
conn->read_replicas.resize(_vbuckets);
conn->write_replicas.resize(_vbuckets);
// Now set up the read and write replica sets.
for (int ii = 0; ii < _vbuckets; ++ii)
{
conn->read_replicas[ii].resize(_read_replicas[ii].size());
for (size_t jj = 0; jj < _read_replicas[ii].size(); ++jj)
{
conn->read_replicas[ii][jj] = conn->st[_read_replicas[ii][jj]];
}
conn->write_replicas[ii].resize(_write_replicas[ii].size());
for (size_t jj = 0; jj < _write_replicas[ii].size(); ++jj)
{
conn->write_replicas[ii][jj] = conn->st[_write_replicas[ii][jj]];
}
}
// Flag that we are in sync with the latest view.
conn->view_number = _view_number;
pthread_rwlock_unlock(&_view_lock);
}
// Hash the key and convert the hash to a vbucket.
int hash = memcached_generate_hash_value(key.data(), key.length(), MEMCACHED_HASH_MD5);
int vbucket = hash & (_vbuckets - 1);
LOG_DEBUG("Key %s hashes to vbucket %d via hash 0x%x", key.c_str(), vbucket, hash);
return (operation == Op::READ) ? conn->read_replicas[vbucket] : conn->write_replicas[vbucket];
}
/// Gets the set of replicas to use for a read or write operation for the
/// specified vbucket.
const std::vector<memcached_st*>& BaseMemcachedStore::get_replicas(int vbucket,
Op operation)
{
BaseMemcachedStore::connection* conn = (connection*)pthread_getspecific(_thread_local);
if (conn == NULL)
{
// Create a new connection structure for this thread.
conn = new BaseMemcachedStore::connection;
pthread_setspecific(_thread_local, conn);
conn->view_number = 0;
}
if (conn->view_number != _view_number)
{
// Either the view has changed or has not yet been set up, so set up the
// connection and replica structures for this thread.
for (std::map<std::string, memcached_st*>::iterator it = conn->st.begin();
it != conn->st.end();
it++)
{
memcached_free(it->second);
it->second = NULL;
}
pthread_rwlock_rdlock(&_view_lock);
TRC_DEBUG("Set up new view %d for thread", _view_number);
// Create a set of memcached_st's one per server.
for (size_t ii = 0; ii < _servers.size(); ++ii)
{
// Create a new memcached_st for this server. Do not specify the server
// at this point as memcached() does not support IPv6 addresses.
TRC_DEBUG("Setting up server %d for connection %p (%s)", ii, conn, _options.c_str());
conn->st[_servers[ii]] = memcached(_options.c_str(), _options.length());
TRC_DEBUG("Set up connection %p to server %s", conn->st[_servers[ii]], _servers[ii].c_str());
// Switch to a longer connect timeout from here on.
memcached_behavior_set(conn->st[_servers[ii]], MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, _max_connect_latency_ms);
std::string server;
int port;
if (Utils::split_host_port(_servers[ii], server, port))
{
TRC_DEBUG("Setting server to IP address %s port %d",
server.c_str(),
port);
memcached_server_add(conn->st[_servers[ii]], server.c_str(), port);
}
else
{
TRC_ERROR("Malformed host/port %s, skipping server", _servers[ii].c_str());
}
}
conn->read_replicas.resize(_vbuckets);
conn->write_replicas.resize(_vbuckets);
// Now set up the read and write replica sets.
for (int ii = 0; ii < _vbuckets; ++ii)
{
conn->read_replicas[ii].resize(_read_replicas[ii].size());
for (size_t jj = 0; jj < _read_replicas[ii].size(); ++jj)
{
conn->read_replicas[ii][jj] = conn->st[_read_replicas[ii][jj]];
}
conn->write_replicas[ii].resize(_write_replicas[ii].size());
for (size_t jj = 0; jj < _write_replicas[ii].size(); ++jj)
{
conn->write_replicas[ii][jj] = conn->st[_write_replicas[ii][jj]];
}
}
// Flag that we are in sync with the latest view.
conn->view_number = _view_number;
pthread_rwlock_unlock(&_view_lock);
}
return (operation == Op::READ) ? conn->read_replicas[vbucket] : conn->write_replicas[vbucket];
}
int main()
{
memcached_st *local_memc;
memcached_return rc;
local_memc = memcached_create(NULL);
unsigned int set= 1;
//memcached_behavior_set(local_memc, MEMCACHED_DISTRIBUTION_CONSISTENT, set);
memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, set);
//memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_KETAMA, set);
//memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, set);
rc = memcached_server_add(local_memc, "127.0.0.1", 11211);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11212);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11213);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11214);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11215);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
uint32_t num = memcached_server_count(local_memc);
printf("num:%d\n", num);
rc= memcached_flush(local_memc, 0);
if (!(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED))
{
fprintf(stderr, "memcached_flush:%d rc:%d\n", MEMCACHED_SUCCESS, rc);
char const *retVal = memcached_strerror(NULL, rc);
fprintf(stderr, "error memcached_flush:%s rc:%d\n", retVal, rc);
goto ERROR;
}
int i = 0;
//for(i = 0; i < 1; i++)
for(i = 0; i < 100000; i++)
{
char key[64];
char value[64];
snprintf(key, sizeof(key), "tkey_%05d", i);
snprintf(value, sizeof(value), "tvalue_%05d", i);
rc= memcached_set(local_memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0);
if (!(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED))
{
char const *retVal = memcached_strerror(NULL, rc);
fprintf(stderr, "error memcached_set .%s\n", retVal);
goto ERROR;
}
}
memcached_free(local_memc);
printf("success \n");
return 0;
ERROR:
printf("error \n");
return 1;
}
int main(int argc, char ** argv)
{
int key_num = 50000;
int bench_count = 1;
int binary_prot = 0;
char server[255] = "";
char port[8] = "11211";
int i;
memcached_st *mc;
int c;
pid = getpid();
if (argc == 1) usage();
while ((c = getopt(argc, argv, "m:k:c:h1b")) >= 0) {
switch (c) {
case 'm':
memcpy(server, optarg, strlen(optarg)+1);
for (i=0; server[i]!='\0'; i++) {
if (server[i] == ':') {
server[i]='\0';
break;
}
}
i++;
memcpy(port, optarg+i, strlen(optarg)-i+1);
break;
case 'k':
key_num = atoi(optarg);
break;
case 'c':
bench_count = atoi(optarg);
break;
case '1':
do_one_connection = 1;
break;
case 'b':
binary_prot = 1;
break;
case 'h':
case '?':
usage();
break;
default:
usage();
}
}
TRACE("server:port=%s:%d", server, atoi(port));
if (strcmp(server, "") == 0) usage();
printf("bench_count:%d key_num:%d\n", bench_count, key_num);
if (key_num >= DATA_MAX) die("key_num is too big.");
srand(time(NULL));
for (i=0; i<key_num; i++) {
sprintf(data[i], "%d",
abs(10000*(rand()/(RAND_MAX+1.0)))
);
TRACE2("[%d]%s", i, data[i]);
}
mc = memcached_create(NULL);
if (mc == NULL) die("memcached_create");
memcached_server_add(mc, server, atoi(port));
memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, binary_prot);
TRACE("%s","begin set");
for (i=0; i<bench_count; i++) {
do_set(mc, key_num);
}
TRACE("%s","end set");
TRACE("%s","begin get");
for (i=0; i<bench_count; i++) {
do_get(mc, key_num);
}
TRACE("%s","end get");
return 0;
}
int
main(int argc, char * const argv[])
{
memcached_st *mcd;
in_port_t port;
uint32_t weight;
int num_conns = 0;
int retval;
int code;
mcd = memcached_create(NULL);
if (!mcd)
{
fprintf(stderr, "memcached_create(NULL) : %s\n", strerror(errno));
return 1;
}
while ((code = getopt(argc, argv, "c:vh")) > 0)
{
memcached_return_t rc;
switch (code)
{
case 'c':
if (strncmp(optarg, "tcp://", 6) == 0)
{
parse_connection(optarg+6, &port, &weight);
rc = memcached_server_add_with_weight(mcd, optarg+6, port, weight);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "failed to add tcp://%s:%d/%u\n",
optarg+6, port, weight);
return 1;
}
}
else if (strncmp(optarg, "udp://", 6) == 0)
{
parse_connection(optarg+6, &port, &weight);
rc = memcached_server_add_udp_with_weight(mcd, optarg+6, port, weight);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "failed to add udp://%s:%d/%u\n",
optarg+6, port, weight);
return 1;
}
}
else if (strncmp(optarg, "unix://", 7) == 0)
{
parse_connection(optarg+7, NULL, &weight);
rc = memcached_server_add_unix_socket_with_weight(mcd, optarg+7, weight);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "failed to add unix://%s/%u\n",
optarg+7, weight);
return 1;
}
}
else
{
parse_connection(optarg, &port, &weight);
rc = memcached_server_add_with_weight(mcd, optarg, port, weight);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "failed to add tcp://%s:%d/%u\n",
optarg, port, weight);
return 1;
}
}
num_conns++;
break;
case 'v':
verbose = true;
break;
default:
fprintf(stderr,
"usage: %s [options] [<commands>]\n"
"\n"
"[options]\n"
" -c <server> server to be connected\n"
" [tcp://]<host>[:<port>][/<weight>]\n"
" udp://<host>[:<port>][/<weight>]\n"
" unix://<path>[/<weight>]\n"
"\n"
"[<command>]\n"
" get <key>\n"
" add <key> <value> [<expire> [<flags>]]\n"
" set <key> <value> [<expire> [<flags>]]\n"
" replace <key> <value> [<expire> [<flags>]]\n"
" append <key> <value> [<expire> [<flags>]]\n"
" prepend <key> <value> [<expire> [<flags>]]\n"
" cas <key> <value> <cas> [<expire> [<flags>]]\n"
" delete <key> [<expire>]\n"
" incr <key>\n"
" decr <key>\n"
" flush [<when>]\n"
" ----\n"
" simple_bench [<scale>]\n",
argv[0]);
return 1;
}
}
/*
* If no server specified, a default is implicitly used
*/
if (num_conns == 0)
{
if (memcached_server_add(mcd, "localhost", 11211) != MEMCACHED_SUCCESS)
{
fprintf(stderr, "failed to add tcp://localhost:11211\n");
return 1;
}
}
if (optind == argc)
{
char buffer[10240];
char **cmds = NULL;
int n_cmds = 0;
while(fgets(buffer, sizeof(buffer), stdin) != NULL)
{
char *tok = strtok(buffer, " \t\n");
int index = 0;
while (tok != NULL)
{
if (index == n_cmds)
{
n_cmds = (n_cmds ? 2 * n_cmds : 10);
cmds = realloc(cmds, sizeof(char *) * n_cmds);
if (!cmds)
{
fprintf(stderr, "realloc() failed: %d(%s)\n",
errno, strerror(errno));
return 1;
}
}
cmds[index++] = tok;
tok = strtok(NULL, " \t\n");
}
if (index == 0)
continue;
retval = exec_command(mcd, index, cmds);
if (retval != 0)
return retval;
}
}
else
{
retval = exec_command(mcd, argc - optind, argv + optind);
}
return retval;
}
int main(int argc, char ** argv)
{
struct memcached_st *mc;
memcached_return_t rc;
char key[32];
u_int32_t keylen;
char *val;
size_t value_len;
uint32_t flags;
struct timeval tv;
long microsec;
double elapsed_time;
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* Parse extra opts if any */
argv = np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
TRACE("%s",">>main");
// initialize
gettimeofday(&tv, NULL);
mc = memcached_create(NULL);
if (mc == NULL) {
printf("MEMCACHED %s: failed to memcached_create\n", _("CRITICAL"));
exit(EXIT_CRITICAL);
}
TRACE("[server]%s:%d", mc_host, (int)mc_port);
rc = memcached_server_add(mc, mc_host, (in_port_t)mc_port);
TRACE("[mc_server_add rv]%d", rc);
if (rc != MEMCACHED_SUCCESS) {
printf("MEMCACHED %s: failed to memcached_server_add (%d)\n", _("CRITICAL"), rc);
exit(EXIT_CRITICAL);
}
memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
srand(time(NULL) & getpid());
sprintf(key, "%d_%s", rand(), mc_host);
keylen = strlen(key);
TRACE("[key]%s[keylen]%d", key, keylen);
val = (char *)calloc(1, strlen(TEST_VAL)+1);
sprintf(val, "%s", TEST_VAL);
TRACE("[val]%s", val);
// set
TRACE("[expire]%d", mc_expire);
rc = memcached_set(mc, key, keylen, val, strlen(val), mc_expire, 0);
TRACE("[set rv]%d", rc);
if (rc != MEMCACHED_SUCCESS) {
printf("MEMCACHED %s: failed to set (%d)\n", _("CRITICAL"), rc);
exit(EXIT_CRITICAL);
}
free(val);
// get
val = (char *)memcached_get(mc, key, keylen, &value_len, &flags, &rc);
TRACE("[val]%s", val);
if (rc != MEMCACHED_SUCCESS) {
printf("MEMCACHED %s: failed to get after set\n", _("CRITICAL"));
exit(EXIT_CRITICAL);
}
free(val);
// delete
rc = memcached_delete(mc, key, keylen, 0);
TRACE("[delete rv]%d", rc);
if (rc != MEMCACHED_SUCCESS) {
printf("MEMCACHED %s: failed to delete (%d)\n", _("CRITICAL"), rc);
exit(EXIT_CRITICAL);
}
// get
val = (char *)memcached_get(mc, key, keylen, &value_len, &flags, &rc);
TRACE("[val]%s", val);
if (rc != MEMCACHED_NOTFOUND) {
printf("MEMCACHED %s: failed to get after delete\n", _("CRITICAL"));
exit(EXIT_CRITICAL);
}
free(val);
memcached_free(mc);
microsec = deltime(tv);
elapsed_time = (double)microsec / 1.0e6;
printf("MEMCACHED %s: %.3f seconds\n", _("OK"), elapsed_time);
return 0;
}
int main(int argc, char ** argv)
{
struct memcached_st *mc;
struct memcached_stat_st *stats;
memcached_return_t rc;
long cur_conn = -1;
int status;
char* status_msg;
struct timeval tv;
long microsec;
double elapsed_time;
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* Parse extra opts if any */
argv = np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
TRACE("%s",">>main");
// initialize
gettimeofday(&tv, NULL);
mc = memcached_create(NULL);
if (mc == NULL) {
printf("MEMCACHED %s: failed to memcached_create\n", _("CRITICAL"));
exit(EXIT_CRITICAL);
}
TRACE("[server]%s:%s", mc_host, mc_port);
rc = memcached_server_add(mc, mc_host, (in_port_t)mc_port);
TRACE("[mc_server_add rv]%d", rc);
if (rc != MEMCACHED_SUCCESS) {
printf("MEMCACHED %s: failed to memcached_server_add (%d)\n", _("CRITICAL"), rc);
exit(EXIT_CRITICAL);
}
memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
stats = memcached_stat(mc, NULL, &rc);
if (! stats) {
printf("MEMCACHED %s: failed to memcached_stats\n", _("CRITICAL"));
exit(EXIT_CRITICAL);
}
cur_conn = stats->curr_connections;
memcached_stat_free(mc, stats);
memcached_free(mc);
status = get_status(cur_conn, my_thresholds);
status_msg = _("CRITICAL");
if (status == STATE_OK) {
status_msg = _("OK");
} else if (status == STATE_WARNING) {
status_msg = _("WARNING");
} else if (status == STATE_CRITICAL) {
status_msg = _("CRITICAL");
}
microsec = deltime(tv);
elapsed_time = (double)microsec / 1.0e6;
printf("MEMCACHED %s: conn %ld, %.3f seconds\n", status_msg, cur_conn, elapsed_time);
return status;
}
