15.6.3.3. Using libmemcached with C and C++

shell> tar xjf libmemcached-0.21.tar.gzshell> cd libmemcached-0.21shell> ./configureshell> makeshell> make install

#include <stdio.h>#include <string.h>#include <unistd.h>#include <libmemcached/memcached.h>int main(int argc, char *argv[]){  memcached_server_st *servers = NULL;  memcached_st *memc;  memcached_return rc;  char *key= "keystring";  char *value= "keyvalue";  memcached_server_st *memcached_servers_parse (char *server_strings);  memc= memcached_create(NULL);  servers= memcached_server_list_append(servers, "localhost", 11211, &rc);  rc= memcached_server_push(memc, servers);  if (rc == MEMCACHED_SUCCESS)    fprintf(stderr,"Added server successfully\n");  else    fprintf(stderr,"Couldn't add server: %s\n",memcached_strerror(memc, rc));  rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0);  if (rc == MEMCACHED_SUCCESS)    fprintf(stderr,"Key stored successfully\n");  else    fprintf(stderr,"Couldn't store key: %s\n",memcached_strerror(memc, rc));  return 0;}

shell> gcc -o memc_basic memc_basic.c -lmemcached

shell> memc_basicAdded server successfullyKey stored successfully

The base libmemcached functions let you create, destroy and clone the main memcached_st structure that is used to interface with the memcached servers. The main functions are defined below:

memcached_st *memcached_create (memcached_st *ptr);

Creates a new memcached_st structure for use with the other libmemcached API functions. You can supply an existing, static, memcached_st structure, or NULL to have a new structured allocated. Returns a pointer to the created structure, or NULL on failure.

void memcached_free (memcached_st *ptr);

Frees the structure and memory allocated to a previously created memcached_st structure.

memcached_st *memcached_clone(memcached_st *clone, memcached_st *source);

Clones an existing memcached structure from the specified source, copying the defaults and list of servers defined in the structure.

The libmemcached API uses a list of servers, stored within the memcached_server_st structure, to act as the list of servers used by the rest of the functions. To use memcached, you first create the server list, and then apply the list of servers to a valid libmemcached object.

Because the list of servers, and the list of servers within an active libmemcached object can be manipulated separately, you can update and manage server lists while an active libmemcached interface is running.

The functions for manipulating the list of servers within a memcached_st structure are:

memcached_return   memcached_server_add (memcached_st *ptr,                         char *hostname,                         unsigned int port);

Adds a server, using the given hostname and port into the memcached_st structure given in ptr.

memcached_return   memcached_server_add_unix_socket (memcached_st *ptr,                                     char *socket);

Adds a Unix socket to the list of servers configured in the memcached_st structure.

unsigned int memcached_server_count (memcached_st *ptr);

Returns a count of the number of configured servers within the memcached_st structure.

memcached_server_st *   memcached_server_list (memcached_st *ptr);

Returns an array of all the defined hosts within a memcached_st structure.

memcached_return   memcached_server_push (memcached_st *ptr,                          memcached_server_st *list);

Pushes an existing list of servers onto list of servers configured for a current memcached_st structure. This adds servers to the end of the existing list, and duplicates are not checked.

The memcached_server_st structure can be used to create a list of memcached servers which can then be applied individually to memcached_st structures.

memcached_server_st *   memcached_server_list_append (memcached_server_st *ptr,                                 char *hostname,                                 unsigned int port,                                 memcached_return *error);

Adds a server, with hostname and port, to the server list in ptr. The result code is handled by the error argument, which should point to an existing memcached_return variable. The function returns a pointer to the returned list.

unsigned int memcached_server_list_count (memcached_server_st *ptr);

Returns the number of the servers in the server list.

void memcached_server_list_free (memcached_server_st *ptr);

Frees the memory associated with a server list.

memcached_server_st *memcached_servers_parse (char *server_strings);

Parses a string containing a list of servers, where individual servers are separated by a comma, space, or both, and where individual servers are of the form server[:port]. The return value is a server list structure.

The set-related functions within libmemcached provide the same functionality as the core functions supported by the memcached protocol. The full definition for the different functions is the same for all the base functions (add, replace, prepend, append). For example, the function definition for memcached_set() is:

memcached_return   memcached_set (memcached_st *ptr,                  const char *key,                  size_t key_length,                  const char *value,                  size_t value_length,                  time_t expiration,                  uint32_t flags);

The ptr is the memcached_st structure. The key and key_length define the key name and length, and value and value_length the corresponding value and length. You can also set the expiration and optional flags. For more information, see Section 15.6.3.3.5, "Controlling libmemcached Behaviors".

This table outlines the remainder of the set-related libmemcached functions and the equivalent core functions supported by the memcached protocol.

The by_key methods add two further arguments that define the master key, to be used and applied during the hashing stage for selecting the servers. You can see this in the following definition:

memcached_return   memcached_set_by_key(memcached_st *ptr,                        const char *master_key,                        size_t master_key_length,                        const char *key,                        size_t key_length,                        const char *value,                        size_t value_length,                        time_t expiration,                        uint32_t flags);

All the functions return a value of type memcached_return, which you can compare against the MEMCACHED_SUCCESS constant.

The libmemcached functions provide both direct access to a single item, and a multiple-key request mechanism that provides much faster responses when fetching a large number of keys simultaneously.

The main get-style function, which is equivalent to the generic get() is memcached_get(). This function returns a string pointer, pointing to the value associated with the specified key.

char *memcached_get (memcached_st *ptr,                     const char *key, size_t key_length,                     size_t *value_length,                     uint32_t *flags,                     memcached_return *error);

A multi-key get, memcached_mget(), is also available. Using a multiple key get operation is much quicker to do in one block than retrieving the key values with individual calls to memcached_get(). To start the multi-key get, call memcached_mget():

memcached_return    memcached_mget (memcached_st *ptr,                    char **keys, size_t *key_length,                    unsigned int number_of_keys);

The return value is the success of the operation. The keys parameter should be an array of strings containing the keys, and key_length an array containing the length of each corresponding key. number_of_keys is the number of keys supplied in the array.

To fetch the individual values, use memcached_fetch() to get each corresponding value.

char *memcached_fetch (memcached_st *ptr,                       const char *key, size_t *key_length,                       size_t *value_length,                       uint32_t *flags,                       memcached_return *error);

The function returns the key value, with the key, key_length and value_length parameters being populated with the corresponding key and length information. The function returns NULL when there are no more values to be returned. A full example, including the populating of the key data and the return of the information is provided here.

#include <stdio.h>#include <sstring.h>#include <unistd.h>#include <libmemcached/memcached.h>int main(int argc, char *argv[]){  memcached_server_st *servers = NULL;  memcached_st *memc;  memcached_return rc;  char *keys[]= {"huey", "dewey", "louie"};  size_t key_length[3];  char *values[]= {"red", "blue", "green"};  size_t value_length[3];  unsigned int x;  uint32_t flags;  char return_key[MEMCACHED_MAX_KEY];  size_t return_key_length;  char *return_value;  size_t return_value_length;  memc= memcached_create(NULL);  servers= memcached_server_list_append(servers, "localhost", 11211, &rc);  rc= memcached_server_push(memc, servers);  if (rc == MEMCACHED_SUCCESS)    fprintf(stderr,"Added server successfully\n");  else    fprintf(stderr,"Couldn't add server: %s\n",memcached_strerror(memc, rc));  for(x= 0; x < 3; x++)    {      key_length[x] = strlen(keys[x]);      value_length[x] = strlen(values[x]);      rc= memcached_set(memc, keys[x], key_length[x], values[x],                        value_length[x], (time_t)0, (uint32_t)0);      if (rc == MEMCACHED_SUCCESS)        fprintf(stderr,"Key %s stored successfully\n",keys[x]);      else        fprintf(stderr,"Couldn't store key: %s\n",memcached_strerror(memc, rc));    }  rc= memcached_mget(memc, keys, key_length, 3);  if (rc == MEMCACHED_SUCCESS)    {      while ((return_value= memcached_fetch(memc, return_key, &return_key_length,                                            &return_value_length, &flags, &rc)) != NULL)        {          if (rc == MEMCACHED_SUCCESS)            {              fprintf(stderr,"Key %s returned %s\n",return_key, return_value);            }        }    }  return 0;}

Running the above application produces the following output:

shell> memc_multi_fetchAdded server successfullyKey huey stored successfullyKey dewey stored successfullyKey louie stored successfullyKey huey returned redKey dewey returned blueKey louie returned green

The behavior of libmemcached can be modified by setting one or more behavior flags. These can either be set globally, or they can be applied during the call to individual functions. Some behaviors also accept an additional setting, such as the hashing mechanism used when selecting servers.

To set global behaviors:

memcached_return   memcached_behavior_set (memcached_st *ptr,                           memcached_behavior flag,                           uint64_t data);

To get the current behavior setting:

uint64_t   memcached_behavior_get (memcached_st *ptr,                           memcached_behavior flag);

The following table describes libmemcached behavior flags.

In addition to the main C library interface, libmemcached also includes a number of command-line utilities that can be useful when working with and debugging memcached applications.

All of the command-line tools accept a number of arguments, the most critical of which is servers, which specifies the list of servers to connect to when returning information.

The main tools are: