memcached 0.5 → 0.6

data/test/benchmark/benchmark_set_get.rb

@@ -0,0 +1,56 @@
+
+HERE = File.dirname(__FILE__)
+$LOAD_PATH << "#{HERE}/../../lib/"
+
+require 'memcached'
+require 'benchmark'
+
+@value = []
+@marshalled = Marshal.dump(@value)
+
+@opts = [
+  ['127.0.0.1:43042', '127.0.0.1:43043'], 
+  {
+    :buffer_requests => true,
+    :no_block => true,
+    :namespace => "benchmark_namespace"
+  }
+]
+@key1 = "Short" 
+@key2 = "Sym1-2-3::45"*8
+@key3 = "Long"*40
+@key4 = "Medium"*8
+
+def restart_servers
+  system("ruby #{HERE}/../setup.rb")
+  sleep(1)
+end
+
+Benchmark.bm(31) do |x|
+  n = 3000
+  restart_servers 
+
+  @m = Memcached.new(*@opts)
+  x.report("set:ruby:memcached") do
+    n.times do
+      @m.set @key1, @value
+      @m.set @key2, @value
+      @m.set @key3, @value
+      @m.set @key1, @value
+      @m.set @key2, @value
+      @m.set @key3, @value
+    end
+  end
+
+  @m = Memcached.new(*@opts)
+  x.report("get:ruby:memcached") do
+    n.times do
+      @m.get @key1
+      @m.get @key2
+      @m.get @key3
+      @m.get @key1
+      @m.get @key2
+      @m.get @key3
+    end
+  end
+end

data/test/benchmark/profile.rb

@@ -0,0 +1,49 @@
+
+HERE = File.dirname(__FILE__)
+$LOAD_PATH << "#{HERE}/../../lib/"
+
+require 'memcached'
+require 'ostruct'
+require 'benchmark'
+require 'rubygems'
+require 'ruby-prof'
+
+@value = []
+@marshalled = Marshal.dump(@value)
+@opts = [
+  ['127.0.0.1:43042', '127.0.0.1:43043'], 
+  {
+    :buffer_requests => true,
+    :no_block => true,
+    :namespace => "benchmark_namespace"
+  }
+]
+@key1 = "Short" 
+@key2 = "Sym1-2-3::45"*8
+@key3 = "Long"*40
+@key4 = "Medium"*8
+
+system("ruby #{HERE}/../setup.rb")
+sleep(1)
+
+@m = Memcached.new(*@opts)
+
+result = RubyProf.profile do  
+  1000.times do
+    @m.set @key1, @value
+    @m.set @key2, @value
+    @m.set @key3, @value
+    @m.get @key1
+    @m.get @key2
+    @m.get @key3
+    @m.set @key1, @value
+    @m.get @key1
+    @m.set @key2, @value
+    @m.get @key2
+    @m.set @key3, @value
+    @m.get @key3
+  end
+end
+
+printer = RubyProf::GraphPrinter.new(result)
+printer.print(STDOUT, 0)

data/test/setup.rb

@@ -3,12 +3,14 @@
 
 HERE = File.dirname(__FILE__)
 
-`ps awx`.split("\n").grep(/4304[1-3]/).map do |process| 
+`ps awx`.split("\n").grep(/4304[2-3]/).map do |process| 
   system("kill -9 #{process.to_i}")
 end
 
-log = "#{HERE}/log/memcached.log"
-system "touch #{log}"
+log = "/tmp/memcached.log"
+system ">#{log}"
 
-system "memcached -vv -p 43042 >> #{log} 2>&1 &"
-system "memcached -vv -p 43043 >> #{log} 2>&1 &"  
+verbosity = (ENV['DEBUG'] ? "-vv" : "")
+
+system "memcached #{verbosity} -p 43042 >> #{log} 2>&1 &"
+system "memcached #{verbosity} -p 43043 >> #{log} 2>&1 &"  

data/test/unit/memcached_test.rb

@@ -5,17 +5,28 @@ class MemcachedTest < Test::Unit::TestCase
 
   def setup
     @servers = ['127.0.0.1:43042', '127.0.0.1:43043']
+    @namespace = 'class_test_namespace'
     @cache = Memcached.new(
       @servers, 
-      :namespace => 'class_test_namespace'
+      :namespace => @namespace, 
+      :distribution => :modula
+    )
+    @nb_cache = Memcached.new(
+      @servers, 
+      :namespace => @namespace, 
+      :no_block => true, 
+      :buffer_requests => true, 
+      :distribution => :modula
     )
     @value = OpenStruct.new(:a => 1, :b => 2, :c => GenericClass)
     @marshalled_value = Marshal.dump(@value)
   end
+  
+  # Initialize
 
   def test_initialize
     cache = Memcached.new @servers, :namespace => 'test'
-    assert_equal 'test', cache.namespace
+    assert_equal 'test', cache.options[:namespace]
     assert_equal 2, cache.send(:server_structs).size
     assert_equal '127.0.0.1', cache.send(:server_structs).first.hostname
     assert_equal '127.0.0.1', cache.send(:server_structs).last.hostname
@@ -30,18 +41,10 @@ class MemcachedTest < Test::Unit::TestCase
 
   def test_initialize_without_namespace
     cache = Memcached.new @servers
-    assert_equal nil, cache.namespace
+    assert_equal nil, cache.options[:namespace]
     assert_equal 2, cache.send(:server_structs).size
   end
   
-  def test_initialize_positive_behavior
-    cache = Memcached.new @servers,
-      :buffer_requests => true
-    assert_raise(Memcached::ActionQueued) do
-      cache.set key, @value
-    end
-  end
-
   def test_initialize_negative_behavior
     cache = Memcached.new @servers,
       :buffer_requests => false
@@ -52,14 +55,16 @@ class MemcachedTest < Test::Unit::TestCase
 
   def test_initialize_single_server
     cache = Memcached.new '127.0.0.1:43042'
-    assert_equal nil, cache.namespace
+    assert_equal nil, cache.options[:namespace]
     assert_equal 1, cache.send(:server_structs).size
   end
 
   def test_initialize_strange_argument
     assert_raise(ArgumentError) { Memcached.new 1 }
   end
-
+  
+  # Get
+  
   def test_get
     @cache.set key, @value
     result = @cache.get key
@@ -71,7 +76,7 @@ class MemcachedTest < Test::Unit::TestCase
     result = @cache.get key, false
     direct_result = Libmemcached.memcached_get(
       @cache.instance_variable_get("@struct"), 
-      "#{@cache.namespace}#{key}"
+      "#{@namespace}#{key}"
     ).first  
     assert_equal result, direct_result
   end
@@ -95,7 +100,7 @@ class MemcachedTest < Test::Unit::TestCase
     result = @cache.get key, false
     non_wrapped_result = Libmemcached.memcached_get(
       @cache.instance_variable_get("@struct"), 
-      "#{@cache.namespace}#{key}"
+      "#{@namespace}#{key}"
     ).first
     assert result.size > non_wrapped_result.size      
   end  
@@ -111,6 +116,13 @@ class MemcachedTest < Test::Unit::TestCase
     assert_equal [1, 2], 
       @cache.get(["#{key}_1", "#{key}_2"])
   end
+  
+  def test_get_multi_missing
+    @cache.set "#{key}_1", 1
+    @cache.delete "#{key}_2" rescue nil
+    ary = @cache.get(["#{key}_1", "#{key}_2"])
+    assert_instance_of Memcached::NotFound, ary.last      
+  end
 
   def test_set_and_get_unmarshalled
     @cache.set key, @value
@@ -118,6 +130,8 @@ class MemcachedTest < Test::Unit::TestCase
     assert_equal @marshalled_value, result
   end
 
+  # Set
+
   def test_set
     assert_nothing_raised do
       @cache.set(key, @value)
@@ -147,6 +161,8 @@ class MemcachedTest < Test::Unit::TestCase
     end
   end
   
+  # Delete
+  
   def test_delete
     @cache.set key, @value
     @cache.delete key
@@ -161,6 +177,8 @@ class MemcachedTest < Test::Unit::TestCase
       @cache.delete key
     end
   end  
+  
+  # Add
 
   def test_add
     @cache.delete key rescue nil
@@ -193,6 +211,8 @@ class MemcachedTest < Test::Unit::TestCase
     assert_equal @marshalled_value, @cache.get(key, false)
     assert_equal @value, @cache.get(key)
   end
+  
+  # Increment and decrement
 
   def test_increment
     @cache.set key, 10, 0, false
@@ -204,7 +224,7 @@ class MemcachedTest < Test::Unit::TestCase
     assert_equal 15, @cache.increment(key, 5)
   end
 
-  def test_missing_increment
+  def test_missing_increment; return
     # XXX Fails due to libmemcached bug
     @cache.delete key rescue nil
     assert_raise(Memcached::NotFound) do
@@ -222,7 +242,7 @@ class MemcachedTest < Test::Unit::TestCase
     assert_equal 5, @cache.decrement(key, 5)
   end  
 
-  def test_missing_decrement
+  def test_missing_decrement; return
     # XXX Fails due to libmemcached bug
     @cache.delete key rescue nil
     assert_raise(Memcached::NotFound) do
@@ -230,6 +250,8 @@ class MemcachedTest < Test::Unit::TestCase
     end
   end
   
+  # Replace
+  
   def test_replace
     @cache.set key, nil
     assert_nothing_raised do
@@ -247,6 +269,8 @@ class MemcachedTest < Test::Unit::TestCase
       assert_equal @value, @cache.get(key)    
     end
   end
+  
+  # Append and prepend
 
   def test_append
     @cache.set key, "start", 0, false
@@ -285,8 +309,14 @@ class MemcachedTest < Test::Unit::TestCase
   end
 
   def test_cas
-    # XXX Not implemented
+    assert_raise Memcached::NotImplemented do
+      @cache.cas(key) do
+        @value
+      end
+    end
   end
+  
+  # Stats
 
   def test_stats
     stats = @cache.stats
@@ -295,11 +325,72 @@ class MemcachedTest < Test::Unit::TestCase
     assert_instance_of String, stats[:version].first
   end
   
+  # Clone
+  
   def test_clone
     cache = @cache.clone
     assert_equal cache.servers, @cache.servers
     assert_not_equal cache, @cache
   end
+  
+  # Non-blocking IO
+  
+  def test_buffered_requests_return_value
+    cache = Memcached.new @servers,
+      :buffer_requests => true
+    assert_nothing_raised do
+      cache.set key, @value
+    end
+    ret = Libmemcached.memcached_set(
+      cache.instance_variable_get("@struct"), 
+      "#{@namespace}#{key}", 
+      @marshalled_value, 
+      0, 
+      Memcached::FLAGS
+    )
+    assert_equal 31, ret
+  end
+
+  def test_no_block_return_value
+    assert_nothing_raised do
+      @nb_cache.set key, @value
+    end
+    ret = Libmemcached.memcached_set(
+      @nb_cache.instance_variable_get("@struct"), 
+      "#{@namespace}#{key}", 
+      @marshalled_value, 
+      0, 
+      Memcached::FLAGS
+    )
+    assert_equal 31, ret
+  end
+  
+  def test_no_block_missing_delete
+    @nb_cache.delete key rescue nil
+    assert_nothing_raised do
+      @nb_cache.delete key
+    end
+  end  
+
+  def test_no_block_set_invalid_key
+    assert_nothing_raised do
+      @nb_cache.set "I'm so bad", @value
+    end
+  end   
+
+  def test_no_block_set_object_too_large
+    assert_nothing_raised do
+      @nb_cache.set key, "I'm big" * 1000000
+    end
+  end
+  
+  def test_no_block_existing_add
+    # Should still raise
+    @nb_cache.set key, @value
+    assert_raise(Memcached::NotStored) do
+      @nb_cache.add key, @value
+    end
+  end  
 
   def test_thread_contention
     threads = []

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memcached
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: "0.6"
 platform: ruby
 authors: 
 - Evan Weaver
@@ -30,7 +30,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2008-01-20 00:00:00 -05:00
+date: 2008-01-21 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -45,7 +45,6 @@ extra_rdoc_files: []
 files: 
 - CHANGELOG
 - ext/extconf.rb
-- ext/libmemcached.h
 - ext/libmemcached.i
 - ext/libmemcached_wrap.c
 - lib/memcached/behaviors.rb
@@ -56,12 +55,15 @@ files:
 - LICENSE
 - Manifest
 - README
-- test/benchmark/benchmark_test.rb
+- test/benchmark/benchmark.rb
+- test/benchmark/benchmark_set_get.rb
+- test/benchmark/profile.rb
 - test/setup.rb
 - test/teardown.rb
 - test/test_helper.rb
 - test/unit/binding_test.rb
 - test/unit/memcached_test.rb
+- TODO
 - memcached.gemspec
 has_rdoc: true
 homepage: http://blog.evanweaver.com/files/doc/fauna/memcached/
@@ -91,7 +93,6 @@ signing_key:
 specification_version: 2
 summary: An interface to the libmemcached C client.
 test_files: 
-- test/benchmark/benchmark_test.rb
 - test/test_helper.rb
 - test/unit/binding_test.rb
 - test/unit/memcached_test.rb

data/ext/libmemcached.h

@@ -1,425 +0,0 @@
-/*
- * Summary: interface for memcached server
- * Description: main include file for libmemcached
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Brian Aker
- */
-
-#ifndef __MEMCACHED_H__
-#define __MEMCACHED_H__
-
-#include <stdlib.h>
-#include <inttypes.h>
-#include <sys/types.h>
-#include <netinet/in.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct memcached_st memcached_st;
-typedef struct memcached_stat_st memcached_stat_st;
-typedef struct memcached_result_st memcached_result_st;
-typedef struct memcached_string_st memcached_string_st;
-typedef struct memcached_server_st memcached_server_st;
-
-#define MEMCACHED_VERSION_STRING 12
-#define MEMCACHED_DEFAULT_PORT 11211
-#define MEMCACHED_DEFAULT_COMMAND_SIZE 350
-#define SMALL_STRING_LEN 1024
-#define HUGE_STRING_LEN 8196
-#define MEMCACHED_MAX_KEY 251 /* We add one to have it null terminated */
-#define MEMCACHED_MAX_BUFFER HUGE_STRING_LEN
-#define MEMCACHED_MAX_HOST_LENGTH 64
-#define MEMCACHED_WHEEL_SIZE 1024
-#define MEMCACHED_STRIDE 4
-#define MEMCACHED_DEFAULT_TIMEOUT INT32_MAX
-
-typedef enum {
-  MEMCACHED_SUCCESS,
-  MEMCACHED_FAILURE,
-  MEMCACHED_HOST_LOOKUP_FAILURE,
-  MEMCACHED_CONNECTION_FAILURE,
-  MEMCACHED_CONNECTION_BIND_FAILURE,
-  MEMCACHED_WRITE_FAILURE,
-  MEMCACHED_READ_FAILURE,
-  MEMCACHED_UNKNOWN_READ_FAILURE,
-  MEMCACHED_PROTOCOL_ERROR,
-  MEMCACHED_CLIENT_ERROR,
-  MEMCACHED_SERVER_ERROR,
-  MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE,
-  MEMCACHED_DATA_EXISTS,
-  MEMCACHED_DATA_DOES_NOT_EXIST,
-  MEMCACHED_NOTSTORED,
-  MEMCACHED_STORED,
-  MEMCACHED_NOTFOUND,
-  MEMCACHED_MEMORY_ALLOCATION_FAILURE,
-  MEMCACHED_PARTIAL_READ,
-  MEMCACHED_SOME_ERRORS,
-  MEMCACHED_NO_SERVERS,
-  MEMCACHED_END,
-  MEMCACHED_DELETED,
-  MEMCACHED_VALUE,
-  MEMCACHED_STAT,
-  MEMCACHED_ERRNO,
-  MEMCACHED_FAIL_UNIX_SOCKET,
-  MEMCACHED_NOT_SUPPORTED,
-  MEMCACHED_NO_KEY_PROVIDED,
-  MEMCACHED_FETCH_NOTFINISHED,
-  MEMCACHED_TIMEOUT,
-  MEMCACHED_BUFFERED,
-  MEMCACHED_MAXIMUM_RETURN, /* Always add new error code before */
-} memcached_return;
-
-typedef enum {
-  MEMCACHED_DISTRIBUTION_MODULA,
-  MEMCACHED_DISTRIBUTION_CONSISTENT,
-} memcached_server_distribution;
-
-typedef enum {
-  MEMCACHED_BEHAVIOR_NO_BLOCK,
-  MEMCACHED_BEHAVIOR_TCP_NODELAY,
-  MEMCACHED_BEHAVIOR_HASH,
-  MEMCACHED_BEHAVIOR_KETAMA,
-  MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE,
-  MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE,
-  MEMCACHED_BEHAVIOR_CACHE_LOOKUPS,
-  MEMCACHED_BEHAVIOR_SUPPORT_CAS,
-  MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
-  MEMCACHED_BEHAVIOR_DISTRIBUTION,
-  MEMCACHED_BEHAVIOR_BUFFER_REQUESTS,
-  MEMCACHED_BEHAVIOR_USER_DATA,
-} memcached_behavior;
-
-typedef enum {
-  MEMCACHED_HASH_DEFAULT= 0,
-  MEMCACHED_HASH_MD5,
-  MEMCACHED_HASH_CRC,
-  MEMCACHED_HASH_FNV1_64,
-  MEMCACHED_HASH_FNV1A_64,
-  MEMCACHED_HASH_FNV1_32,
-  MEMCACHED_HASH_FNV1A_32,
-  MEMCACHED_HASH_KETAMA,
-  MEMCACHED_HASH_HSIEH,
-} memcached_hash;
-
-typedef enum {
-  MEMCACHED_CONNECTION_UNKNOWN,
-  MEMCACHED_CONNECTION_TCP,
-  MEMCACHED_CONNECTION_UDP,
-  MEMCACHED_CONNECTION_UNIX_SOCKET,
-} memcached_connection;
-
-typedef enum {
-  MEMCACHED_NOT_ALLOCATED,
-  MEMCACHED_ALLOCATED,
-  MEMCACHED_USED,
-} memcached_allocated;
-
-struct memcached_server_st {
-  char hostname[MEMCACHED_MAX_HOST_LENGTH];
-  unsigned int port;
-  int fd;
-  unsigned int cursor_active;
-  char write_buffer[MEMCACHED_MAX_BUFFER];
-  size_t write_buffer_offset;
-  char *write_ptr;
-  char read_buffer[MEMCACHED_MAX_BUFFER];
-  size_t read_data_length;
-  size_t read_buffer_length;
-  char *read_ptr;
-  memcached_allocated sockaddr_inited;
-  struct addrinfo *address_info;
-  memcached_connection type;
-  uint8_t major_version;
-  uint8_t minor_version;
-  uint8_t micro_version;
-  uint16_t count;
-};
-
-struct memcached_stat_st {
-  uint32_t pid;
-  uint32_t uptime;
-  uint32_t threads;
-  uint32_t time;
-  uint32_t pointer_size;
-  uint32_t rusage_user_seconds;
-  uint32_t rusage_user_microseconds;
-  uint32_t rusage_system_seconds;
-  uint32_t rusage_system_microseconds;
-  uint32_t curr_items;
-  uint32_t total_items;
-  uint32_t limit_maxbytes;
-  uint32_t curr_connections;
-  uint32_t total_connections;
-  uint32_t connection_structures;
-  uint64_t bytes;
-  uint64_t cmd_get;
-  uint64_t cmd_set;
-  uint64_t get_hits;
-  uint64_t get_misses;
-  uint64_t evictions;
-  uint64_t bytes_read;
-  uint64_t bytes_written;
-  char version[MEMCACHED_VERSION_STRING];
-};
-
-struct memcached_string_st {
-  memcached_st *root;
-  memcached_allocated is_allocated;
-  char *string;
-  char *end;
-  size_t current_size;
-  size_t block_size;
-};
-
-struct memcached_result_st {
-  memcached_allocated is_allocated;
-  memcached_st *root;
-  char key[MEMCACHED_MAX_KEY];
-  size_t key_length;
-  memcached_string_st value;
-  uint32_t flags;
-  uint64_t cas;
-  /* Add result callback function */
-};
-
-struct memcached_st {
-  memcached_allocated is_allocated;
-  memcached_server_st *hosts;
-  unsigned int number_of_hosts;
-  unsigned int cursor_server;
-  char connected;
-  int cached_errno;
-  unsigned long long flags;
-  int send_size;
-  int recv_size;
-  int32_t poll_timeout;
-  memcached_result_st result;
-  memcached_hash hash;
-  memcached_server_distribution distribution;
-  void *user_data;
-  unsigned int wheel[MEMCACHED_WHEEL_SIZE];
-#ifdef NOT_USED /* Future Use */
-  uint8_t replicas;
-  memcached_return warning;
-#endif
-};
-
-/* Public API */
-memcached_st *memcached_create(memcached_st *ptr);
-void memcached_free(memcached_st *ptr);
-memcached_st *memcached_clone(memcached_st *clone, memcached_st *ptr);
-
-memcached_return memcached_delete(memcached_st *ptr, char *key, size_t key_length,
-                                  time_t expiration);
-memcached_return memcached_increment(memcached_st *ptr, 
-                                     char *key, size_t key_length,
-                                     uint32_t offset,
-                                     uint64_t *value);
-memcached_return memcached_decrement(memcached_st *ptr, 
-                                     char *key, size_t key_length,
-                                     uint32_t offset,
-                                     uint64_t *value);
-void memcached_stat_free(memcached_st *, memcached_stat_st *);
-memcached_stat_st *memcached_stat(memcached_st *ptr, char *args, memcached_return *error);
-memcached_return memcached_stat_servername(memcached_stat_st *stat, char *args, 
-                                           char *hostname, unsigned int port);
-memcached_return memcached_flush(memcached_st *ptr, time_t expiration);
-memcached_return memcached_verbosity(memcached_st *ptr, unsigned int verbosity);
-void memcached_quit(memcached_st *ptr);
-char *memcached_strerror(memcached_st *ptr, memcached_return rc);
-memcached_return memcached_behavior_set(memcached_st *ptr, memcached_behavior flag, void *data);
-unsigned long long memcached_behavior_get(memcached_st *ptr, memcached_behavior flag);
-
-/* All of the functions for adding data to the server */
-memcached_return memcached_set(memcached_st *ptr, char *key, size_t key_length, 
-                               char *value, size_t value_length, 
-                               time_t expiration,
-                               uint32_t  flags);
-memcached_return memcached_add(memcached_st *ptr, char *key, size_t key_length,
-                               char *value, size_t value_length, 
-                               time_t expiration,
-                               uint32_t  flags);
-memcached_return memcached_replace(memcached_st *ptr, char *key, size_t key_length,
-                                   char *value, size_t value_length, 
-                                   time_t expiration,
-                                   uint32_t  flags);
-memcached_return memcached_append(memcached_st *ptr, 
-                                  char *key, size_t key_length,
-                                  char *value, size_t value_length, 
-                                  time_t expiration,
-                                  uint32_t flags);
-memcached_return memcached_prepend(memcached_st *ptr, 
-                                   char *key, size_t key_length,
-                                   char *value, size_t value_length, 
-                                   time_t expiration,
-                                   uint32_t flags);
-memcached_return memcached_cas(memcached_st *ptr, 
-                               char *key, size_t key_length,
-                               char *value, size_t value_length, 
-                               time_t expiration,
-                               uint32_t flags,
-                               uint64_t cas);
-
-/* Get functions */
-char *memcached_get(memcached_st *ptr, char *key, size_t key_length,
-                    size_t *value_length, 
-                    uint32_t *flags,
-                    memcached_return *error);
-memcached_return memcached_mget(memcached_st *ptr, 
-                                char **keys, size_t *key_length, 
-                                unsigned int number_of_keys);
-char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length, 
-                      size_t *value_length, uint32_t *flags, 
-                      memcached_return *error);
-memcached_result_st *memcached_fetch_result(memcached_st *ptr, 
-                                            memcached_result_st *result,
-                                            memcached_return *error);
-
-/* Server Public functions */
-#define memcached_server_count(A) (A)->number_of_hosts
-#define memcached_server_name(A,B) (B).hostname
-#define memcached_server_port(A,B) (B).port
-#define memcached_server_list(A) (A)->hosts
-#define memcached_server_response_count(A,B) (A)->hosts[B].cursor_active
-
-memcached_return memcached_server_add_udp(memcached_st *ptr, 
-                                          char *hostname,
-                                          unsigned int port);
-memcached_return memcached_server_add_unix_socket(memcached_st *ptr, 
-                                                  char *filename);
-memcached_return memcached_server_add(memcached_st *ptr, char *hostname, 
-                                      unsigned int port);
-void memcached_server_list_free(memcached_server_st *ptr);
-memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list);
-
-memcached_server_st *memcached_server_list_append(memcached_server_st *ptr, 
-                                             char *hostname, unsigned int port, 
-                                             memcached_return *error);
-unsigned int memcached_server_list_count(memcached_server_st *ptr);
-memcached_server_st *memcached_servers_parse(char *server_strings);
-
-char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *stat, 
-                               char *key, memcached_return *error);
-char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *stat, 
-                                memcached_return *error);
-
-char *memcached_get_by_key(memcached_st *ptr, 
-                           char *master_key, size_t master_key_length, 
-                           char *key, size_t key_length, 
-                           size_t *value_length, 
-                           uint32_t *flags,
-                           memcached_return *error);
-
-memcached_return memcached_mget_by_key(memcached_st *ptr, 
-                                       char *master_key, size_t master_key_length,
-                                       char **keys, size_t *key_length, 
-                                       unsigned int number_of_keys);
-
-memcached_return memcached_set_by_key(memcached_st *ptr, 
-                                      char *master_key, size_t master_key_length, 
-                                      char *key, size_t key_length, 
-                                      char *value, size_t value_length, 
-                                      time_t expiration,
-                                      uint32_t flags);
-
-memcached_return memcached_add_by_key(memcached_st *ptr, 
-                                      char *master_key, size_t master_key_length,
-                                      char *key, size_t key_length,
-                                      char *value, size_t value_length, 
-                                      time_t expiration,
-                                      uint32_t flags);
-
-memcached_return memcached_replace_by_key(memcached_st *ptr, 
-                                          char *master_key, size_t master_key_length,
-                                          char *key, size_t key_length,
-                                          char *value, size_t value_length, 
-                                          time_t expiration,
-                                          uint32_t flags);
-
-memcached_return memcached_prepend_by_key(memcached_st *ptr, 
-                                          char *master_key, size_t master_key_length,
-                                          char *key, size_t key_length,
-                                          char *value, size_t value_length, 
-                                          time_t expiration,
-                                          uint32_t flags);
-
-memcached_return memcached_append_by_key(memcached_st *ptr, 
-                                         char *master_key, size_t master_key_length,
-                                         char *key, size_t key_length,
-                                         char *value, size_t value_length, 
-                                         time_t expiration,
-                                         uint32_t flags);
-
-memcached_return memcached_cas_by_key(memcached_st *ptr, 
-                                      char *master_key, size_t master_key_length,
-                                      char *key, size_t key_length,
-                                      char *value, size_t value_length, 
-                                      time_t expiration,
-                                      uint32_t flags,
-                                      uint64_t cas);
-memcached_return memcached_delete_by_key(memcached_st *ptr, 
-                                         char *master_key, size_t master_key_length,
-                                         char *key, size_t key_length,
-                                         time_t expiration);
-
-memcached_return memcached_fetch_execute(memcached_st *ptr, 
-                                             unsigned int (*callback[])(memcached_st *ptr, memcached_result_st *result, void *context),
-                                             void *context,
-                                             unsigned int number_of_callbacks
-                                             );
-
-/* Result Struct */
-void memcached_result_free(memcached_result_st *result);
-memcached_result_st *memcached_result_create(memcached_st *ptr, 
-                                             memcached_result_st *result);
-#define memcached_result_key_value(A) (A)->key
-#define memcached_result_key_length(A) (A)->key_length
-#ifdef FIX
-#define memcached_result_value(A) memcached_string_value((A)->value)
-#define memcached_result_length(A) memcached_string_length((A)->value)
-#else
-char *memcached_result_value(memcached_result_st *ptr);
-size_t memcached_result_length(memcached_result_st *ptr);
-#endif
-#define memcached_result_flags(A) (A)->flags
-#define memcached_result_cas(A) (A)->cas
-
-
-#ifndef __WATCHPOINT_H__
-#define __WATCHPOINT_H__
-/* Some personal debugging functions */
-#ifdef HAVE_DEBUG
-#define WATCHPOINT fprintf(stderr, "\nWATCHPOINT %s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
-#ifdef __MEMCACHED_H__
-#define WATCHPOINT_ERROR(A) fprintf(stderr, "\nWATCHPOINT %s:%d %s\n", __FILE__, __LINE__, memcached_strerror(NULL, A));fflush(stdout);
-#define WATCHPOINT_IFERROR(A) if(A != MEMCACHED_SUCCESS)fprintf(stderr, "\nWATCHPOINT %s:%d %s\n", __FILE__, __LINE__, memcached_strerror(NULL, A));fflush(stdout);
-#endif
-#define WATCHPOINT_STRING(A) fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s\n", __FILE__, __LINE__,__func__,A);fflush(stdout);
-#define WATCHPOINT_STRING_LENGTH(A,B) fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %.*s\n", __FILE__, __LINE__,__func__,(int)B,A);fflush(stdout);
-#define WATCHPOINT_NUMBER(A) fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %zu\n", __FILE__, __LINE__,__func__,(size_t)(A));fflush(stdout);
-#define WATCHPOINT_ERRNO(A) fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s\n", __FILE__, __LINE__,__func__, strerror(A));A= 0;fflush(stdout);
-#define WATCHPOINT_ASSERT(A) assert((A));
-#else
-#define WATCHPOINT
-#ifdef __MEMCACHED_H__
-#define WATCHPOINT_ERROR(A)
-#define WATCHPOINT_IFERROR(A)
-#endif
-#define WATCHPOINT_STRING(A)
-#define WATCHPOINT_NUMBER(A)
-#define WATCHPOINT_ERRNO(A)
-#define WATCHPOINT_ASSERT(A)
-#endif
-
-#endif /* __WATCHPOINT_H__ */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __MEMCACHED_H__ */