Merge lp:~j-pureftpd/gearmand/tokyo into lp:gearmand/1.0

[Frank Denis]

[Frank Denis (j-pureftpd)]

I'll keep working on it, and maybe add support for Tokyo Tyrant.

[Eric Day (eday)]

> I'll keep working on it, and maybe add support for Tokyo Tyrant.

This is great! I just have a few things when looking over the branch:

* Make GEARMAN_QUEUE_LIBTOKYOCABINET_DEFAULT_PREFIX a command line option. Rather than having a #define you set, specify --libtokyocabinet--prefix=PREFIX instead and use that. By default it can be empty. We like to avoid compile time options like this if at all possible (only use #define's for default values that can be overridden).

* Support priority. Right now it looks like this is just ignored, but it should be an easy fix to encode this into the key or pack into the value somehow. It would be nice to have the interface fully supported.

review: Needs Fixing

[Frank Denis (j-pureftpd)]

Hi Eric,

The prefix has been removed as it actually doesn't make any sense for a Tokyo Cabinet database.

Also, the storage is now using a btree instead of a hash table and properly supports priorities.

review: Needs Resubmitting

[lp:~j-pureftpd/gearmand/tokyo]

83. By j <j@linux> on 2009-12-03

Sync Tokyo branch with trunk #228

84. By j <j@linux> on 2009-12-03

Untab

85. By j <j@linux> on 2009-12-03

Spaces

86. By j <j@linux> on 2009-12-03

Switch Tokyocabinet databases to btrees instead of hashes.
This is slower and requires more storage space, but eventually it will
bring ordered processing and priority support.

87. By j <j@linux> on 2009-12-03

Prefixes don't make any sense with Tokyocabinet.

88. By j <j@linux> on 2009-12-03

Change the database format in order to handle priorities.
+ a bunch of small fixes.

89. By j <j@linux> on 2009-12-03

Fix computation of the function data length.

90. By j <j@linux> on 2009-12-03

Don't ignore errors

91. By j <j@linux> on 2009-12-03

Calling tcbdboptimize() after destacking the queue is a good way to
save space.

92. By Jedi/Sector One <j@ubuntu> on 2009-12-05

Sync with trunk#229

93. By j <j@linux> on 2010-01-12

Sync with trunk#230

94. By j <j@linux> on 2010-01-12

Sync with trunk#270

95. By j <j@linux> on 2010-01-12

Sync with trunk#309

96. By j <j@linux> on 2010-01-21

Sync to trunk #315

97. By j <j@linux> on 2010-01-21

Merge Clint's changes

[Frank Denis (j-pureftpd)]

The branch is kept up to date with the trunk.

May you review and merge it?

review: Needs Resubmitting

[Clint Byrum (clint-fewbar)]

I'd like to see it merged as well, as we're about to start using it in production and I'd rather not see it "fork" in any way.

One thing that needs to happen first though, is m5/pandora_have_libtokyocabinet.m4 needs to be fixed so that the configure step does not fail if tokyocabinet is missing. I believe that is a pandora bug.

=== modified file 'configure.ac'
--- configure.ac	2009-12-30 19:13:05 +0000
+++ configure.ac	2010-01-21 12:07:13 +0000
@@ -40,6 +40,7 @@
 PANDORA_HAVE_LIBMEMCACHED
 PANDORA_HAVE_MEMCACHED
 PANDORA_HAVE_LIBPQ
+PANDORA_HAVE_LIBTOKYOCABINET
 
 
 AC_CHECK_HEADERS(errno.h fcntl.h getopt.h netinet/tcp.h pwd.h signal.h)
@@ -72,5 +73,6 @@
 echo "   * Building with libdrizzle   $ac_cv_libdrizzle"
 echo "   * Building with libmemcached $ac_cv_libmemcached"
 echo "   * Building with libpq        $ac_cv_libpq"
+echo "   * Building with tokyocabinet $ac_cv_libtokyocabinet"
 echo ""
 echo "---"

=== modified file 'gearmand/gearmand.c'
--- gearmand/gearmand.c	2009-12-02 05:22:18 +0000
+++ gearmand/gearmand.c	2010-01-21 12:07:13 +0000
@@ -71,6 +71,10 @@
 #include <libgearman-server/queue_libpq.h>
 #endif
 
+#ifdef HAVE_LIBTOKYOCABINET
+#include <libgearman-server/queue_libtokyocabinet.h>
+#endif
+
 #include <libgearman-server/protocol_http.h>
 
 #define GEARMAND_LOG_REOPEN_TIME 60
@@ -189,6 +193,14 @@
     return 1;
   }
 #endif
+#ifdef HAVE_LIBTOKYOCABINET
+  if (gearman_server_queue_libtokyocabinet_conf(&conf) != GEARMAN_SUCCESS)
+  {
+    fprintf(stderr, "gearmand: gearman_queue_libtokyocabinet_conf: %s\n",
+            gearman_conf_error(&conf));
+    return 1;
+  }
+#endif
 
 #ifdef HAVE_LIBSQLITE3
   if (gearman_server_queue_libsqlite3_conf(&conf) != GEARMAN_SUCCESS)
@@ -378,6 +390,15 @@
     }
     else
 #endif
+#ifdef HAVE_LIBTOKYOCABINET
+    if (!strcmp(queue_type, "libtokyocabinet"))
+    {
+      ret= gearmand_queue_libtokyocabinet_init(_gearmand, &conf);
+      if (ret != GEARMAN_SUCCESS)
+        return 1;
+    }
+    else
+#endif        
     {
       fprintf(stderr, "gearmand: Unknown queue module: %s\n", queue_type);
       return 1;
@@ -422,6 +443,10 @@
     if (!strcmp(queue_type, "libpq"))
       gearmand_queue_libpq_deinit(_gearmand);
 #endif
+#ifdef HAVE_LIBTOKYOCABINET
+    if (!strcmp(queue_type, "libtokyocabinet"))
+      gearmand_queue_libtokyocabinet_deinit(_gearmand);
+#endif
   }
 
   while (gearman_conf_module_value(&module, &name, &value))

=== modified file 'libgearman-server/include.am'
--- libgearman-server/include.am	2009-12-31 00:20:39 +0000
+++ libgearman-server/include.am	2010-01-21 12:07:13 +0000
@@ -30,6 +30,11 @@
 QUEUE_LIBPQ_C= libgearman-server/queue_libpq.c
 endif
 
+if HAVE_LIBTOKYOCABINET
+QUEUE_LIBTOKYOCABINET_H= libgearman-server/queue_libtokyocabinet.h
+QUEUE_LIBTOKYOCABINET_C= libgearman-server/queue_libtokyocabinet.c
+endif
+
 noinst_LTLIBRARIES+= libgearman-server/libgearman-server.la
 
 
@@ -38,6 +43,7 @@
 	$(QUEUE_LIBMEMCACHED_H) \
 	$(QUEUE_LIBPQ_H) \
 	$(QUEUE_LIBSQLITE3_H) \
+	$(QUEUE_LIBTOKYOCABINET_H) \
 	libgearman-server/client.h \
 	libgearman-server/conf.h \
 	libgearman-server/conf_module.h \
@@ -62,6 +68,7 @@
 	$(QUEUE_LIBMEMCACHED_C) \
 	$(QUEUE_LIBPQ_C) \
 	$(QUEUE_LIBSQLITE3_C) \
+	$(QUEUE_LIBTOKYOCABINET_C) \
 	libgearman-server/client.c \
 	libgearman-server/conf.c \
 	libgearman-server/conf_module.c \
@@ -87,5 +94,6 @@
 	$(LTLIBMEMCACHED) \
 	$(LTLIBPQ) \
 	$(LTLIBSQLITE3) \
+	$(LTLIBTOKYOCABINET) \
 	libgearman/libgearman.la \
 	libgearman/libgearmancore.la

=== added file 'libgearman-server/queue_libtokyocabinet.c'
--- libgearman-server/queue_libtokyocabinet.c	1970-01-01 00:00:00 +0000
+++ libgearman-server/queue_libtokyocabinet.c	2010-01-21 12:07:13 +0000
@@ -0,0 +1,418 @@
+/**
+ * @file
+ * @brief Tokyo Cabinet Queue Storage Definitions
+ */
+
+#include "common.h"
+
+#include <libgearman-server/queue_libtokyocabinet.h>
+#include <tcutil.h>
+#include <tcbdb.h>
+
+/**
+ * @addtogroup gearman_queue_libtokyocabinet libtokyocabinet Queue Storage Functions
+ * @ingroup gearman_queue
+ * @{
+ */
+
+/*
+ * Private declarations
+ */
+
+/**
+ * Structure for libtokyocabinet specific data.
+ */
+typedef struct
+{
+  TCBDB *db;
+} gearman_queue_libtokyocabinet_st;
+
+/* Queue callback functions. */
+static gearman_return_t _libtokyocabinet_add(gearman_server_st *server, void *context,
+                                             const void *unique,
+                                             size_t unique_size,
+                                             const void *function_name,
+                                             size_t function_name_size,
+                                             const void *data, size_t data_size,
+                                             gearman_job_priority_t priority);
+static gearman_return_t _libtokyocabinet_flush(gearman_server_st *server, void *context);
+static gearman_return_t _libtokyocabinet_done(gearman_server_st *server, void *context,
+                                              const void *unique,
+                                              size_t unique_size, 
+                                              const void *function_name, 
+                                              size_t function_name_size);
+static gearman_return_t _libtokyocabinet_replay(gearman_server_st *server, void *context,
+                                                gearman_queue_add_fn *add_fn,
+                                                void *add_context);
+
+/*
+ * Public definitions
+ */
+
+gearman_return_t gearman_server_queue_libtokyocabinet_conf(gearman_conf_st *conf)
+{
+  gearman_conf_module_st *module;
+
+  module= gearman_conf_module_create(conf, NULL, "libtokyocabinet");
+  if (module == NULL)
+    return GEARMAN_MEMORY_ALLOCATION_FAILURE;
+
+  gearman_conf_module_add_option(module, "file", 0, "FILE_NAME",
+                                 "File name of the database.");
+  gearman_conf_module_add_option(module, "optimize", 0, "yes/no",
+                                 "Optimize database on open. [default=yes]");
+  return gearman_conf_return(conf);
+}
+
+gearman_return_t gearman_queue_libtokyocabinet_init(gearman_server_st *server,
+                                                    gearman_conf_st *conf)
+{
+  gearman_queue_libtokyocabinet_st *queue;
+  gearman_conf_module_st *module;
+  const char *name;
+  const char *value;
+  const char *opt_file= NULL;
+  const char *opt_optimize= NULL;
+
+  GEARMAN_SERVER_INFO(server, "Initializing libtokyocabinet module")
+
+  queue= calloc(1, sizeof(gearman_queue_libtokyocabinet_st));
+  if (queue == NULL)
+  {
+    GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init", "malloc")
+    return GEARMAN_MEMORY_ALLOCATION_FAILURE;
+  }
+
+  if ((queue->db= tcbdbnew()) == NULL)
+  {
+    free(queue);
+    GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init",
+                             "tcbdbnew")
+    return GEARMAN_QUEUE_ERROR;
+  }
+   
+  tcbdbsetdfunit(queue->db, 8);
+
+  /* Get module and parse the option values that were given. */
+  module= gearman_conf_module_find(conf, "libtokyocabinet");
+  if (module == NULL)
+  {
+    GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init",
+                              "modconf_module_find:NULL")
+    return GEARMAN_QUEUE_ERROR;
+  }
+
+  while (gearman_conf_module_value(module, &name, &value))
+  { 
+    if (!strcmp(name, "file"))
+      opt_file= value;
+    else if (!strcmp(name, "optimize"))
+      opt_optimize= value;
+    else
+    {
+      tcbdbdel(queue->db);
+      free(queue);
+      GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init",
+                               "Unknown argument: %s", name)
+      return GEARMAN_QUEUE_ERROR;
+    }
+  }
+     
+  if (opt_file == NULL)
+  {
+    GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init",
+                             "No --file given")
+    return GEARMAN_QUEUE_ERROR;
+  }
+
+#ifdef HAVE_EVENT_BASE_NEW
+  if (!tcbdbsetmutex(queue->db))
+  {
+    tcbdbdel(queue->db);
+    free(queue);
+
+    GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init",
+                             "tcbdbsetmutex")
+    return GEARMAN_QUEUE_ERROR;
+  }   
+#endif
+   
+  if (!tcbdbopen(queue->db, opt_file, BDBOWRITER | BDBOCREAT))
+  {
+    tcbdbdel(queue->db);
+    free(queue);
+
+    GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init",
+                             "tcbdbopen")
+
+    return GEARMAN_QUEUE_ERROR;
+  }
+
+  if (opt_optimize == NULL || !strcasecmp(opt_optimize, "yes"))
+  {
+    GEARMAN_SERVER_INFO(server, "libtokyocabinet optimizing database file");
+    if (!tcbdboptimize(queue->db, 0, 0, 0, -1, -1, UINT8_MAX))
+    {
+      tcbdbdel(queue->db);
+      free(queue);
+      GEARMAN_SERVER_ERROR_SET(server, "gearman_queue_libtokyocabinet_init",
+                               "tcbdboptimize")
+
+      return GEARMAN_QUEUE_ERROR;
+    }
+  }
+
+  gearman_server_set_queue_context(server, queue);
+
+  gearman_server_set_queue_add_fn(server, _libtokyocabinet_add);
+  gearman_server_set_queue_flush_fn(server, _libtokyocabinet_flush);
+  gearman_server_set_queue_done_fn(server, _libtokyocabinet_done);
+  gearman_server_set_queue_replay_fn(server, _libtokyocabinet_replay);   
+   
+  return GEARMAN_SUCCESS;
+}
+   
+gearman_return_t gearman_queue_libtokyocabinet_deinit(gearman_server_st *server)
+{
+  gearman_queue_libtokyocabinet_st *queue;
+
+  GEARMAN_SERVER_INFO(server, "Shutting down libtokyocabinet queue module");
+
+  queue= (gearman_queue_libtokyocabinet_st *)gearman_server_queue_context(server);
+  gearman_server_set_queue_context(server, NULL);
+  tcbdbdel(queue->db);
+
+  free(queue);
+
+  return GEARMAN_SUCCESS;
+}
+
+gearman_return_t gearmand_queue_libtokyocabinet_init(gearmand_st *gearmand,
+                                                     gearman_conf_st *conf)
+{
+  return gearman_queue_libtokyocabinet_init(&(gearmand->server), conf);
+}
+
+gearman_return_t gearmand_queue_libtokyocabinet_deinit(gearmand_st *gearmand)
+{
+  return gearman_queue_libtokyocabinet_deinit(&(gearmand->server));
+}
+
+/*
+ * Private definitions
+ */
+
+static gearman_return_t _libtokyocabinet_add(gearman_server_st *server, void *context,
+                                             const void *unique,
+                                             size_t unique_size,
+                                             const void *function_name,
+                                             size_t function_name_size,
+                                             const void *data, size_t data_size,
+                                             gearman_job_priority_t priority)
+{
+  gearman_queue_libtokyocabinet_st *queue= (gearman_queue_libtokyocabinet_st *)context;
+  bool rc;
+  TCXSTR *key;
+  TCXSTR *job_data;
+
+  GEARMAN_SERVER_DEBUG(server, "libtokyocabinet add: %.*s",
+                       (uint32_t)unique_size, (char *)unique);
+  
+  char key_str[GEARMAN_QUEUE_TOKYOCABINET_MAX_KEY_LEN];
+  size_t key_length= (size_t)snprintf(key_str, GEARMAN_QUEUE_TOKYOCABINET_MAX_KEY_LEN, "%.*s-%.*s",
+                               (int)function_name_size,
+                               (const char *)function_name, (int)unique_size,
+                               (const char *)unique);
+
+  key= tcxstrnew();
+  tcxstrcat(key, key_str, (int)key_length);
+
+  GEARMAN_SERVER_DEBUG(server, "libtokyocabinet key: %.*s", (int)key_length, key_str);
+
+  job_data= tcxstrnew();
+
+  tcxstrcat(job_data, (const char *)function_name, (int)function_name_size);
+  tcxstrcat(job_data, "\0", 1);
+  tcxstrcat(job_data, (const char *)unique, (int)unique_size);
+  tcxstrcat(job_data, "\0", 1);
+
+  switch (priority)
+  {
+   case GEARMAN_JOB_PRIORITY_HIGH:
+   case GEARMAN_JOB_PRIORITY_MAX:     
+     tcxstrcat2(job_data,"0");
+     break;
+   case GEARMAN_JOB_PRIORITY_LOW:
+     tcxstrcat2(job_data,"2");
+     break;
+   case GEARMAN_JOB_PRIORITY_NORMAL:
+   default:
+     tcxstrcat2(job_data,"1");
+  }
+
+  tcxstrcat(job_data, (const char *)data, (int)data_size);
+
+  rc= tcbdbput(queue->db, tcxstrptr(key), tcxstrsize(key),
+               tcxstrptr(job_data), tcxstrsize(job_data));
+
+  tcxstrdel(key);
+  tcxstrdel(job_data);
+
+  if (!rc)
+    return GEARMAN_QUEUE_ERROR;
+
+  return GEARMAN_SUCCESS;
+}
+
+static gearman_return_t _libtokyocabinet_flush(gearman_server_st *server,
+                                               void *context __attribute__((unused)))
+{
+  gearman_queue_libtokyocabinet_st *queue= (gearman_queue_libtokyocabinet_st *)context;
+   
+  GEARMAN_SERVER_DEBUG(server, "libtokyocabinet flush");
+  if (!tcbdbsync(queue->db))
+     return GEARMAN_QUEUE_ERROR;
+   
+  return GEARMAN_SUCCESS;
+}
+
+static gearman_return_t _libtokyocabinet_done(gearman_server_st *server, void *context,
+                                              const void *unique,
+                                              size_t unique_size, 
+                                              const void *function_name,
+                                              size_t function_name_size)
+{
+  gearman_queue_libtokyocabinet_st *queue= (gearman_queue_libtokyocabinet_st *)context;
+  bool rc;
+  TCXSTR *key;
+
+  (void) function_name;
+  (void) function_name_size;   
+  GEARMAN_SERVER_DEBUG(server, "libtokyocabinet add: %.*s",
+                       (uint32_t)unique_size, (char *)unique);
+  
+  char key_str[GEARMAN_QUEUE_TOKYOCABINET_MAX_KEY_LEN];
+  size_t key_length= (size_t)snprintf(key_str, GEARMAN_QUEUE_TOKYOCABINET_MAX_KEY_LEN, "%.*s-%.*s",
+                               (int)function_name_size,
+                               (const char *)function_name, (int)unique_size,
+                               (const char *)unique);
+
+  key= tcxstrnew();
+  tcxstrcat(key, key_str, (int)key_length);
+  rc= tcbdbout3(queue->db, tcxstrptr(key), tcxstrsize(key));
+  tcxstrdel(key);
+
+  if (!rc)
+    return GEARMAN_QUEUE_ERROR;
+
+  return GEARMAN_SUCCESS;
+}
+
+static gearman_return_t _callback_for_record(gearman_server_st *server,
+                                             TCXSTR *key, TCXSTR *data,
+                                             gearman_queue_add_fn *add_fn,
+                                             void *add_context)
+{
+  char *data_cstr;
+  size_t data_cstr_size;
+  const char *function;
+  size_t function_len;
+  char *unique;
+  size_t unique_len;
+  gearman_job_priority_t priority;
+  gearman_return_t gret;
+  
+  GEARMAN_SERVER_DEBUG(server, "replaying: %s", (char *) tcxstrptr(key));
+
+  data_cstr= (char *)tcxstrptr(data);
+  data_cstr_size= (size_t)tcxstrsize(data);
+
+  function= data_cstr;
+  function_len= strlen(function);
+
+  unique= data_cstr+function_len+1;
+  unique_len= strlen(unique); // strlen is only safe because tcxstrptr guarantees nul term
+
+  // +2 for nulls
+  data_cstr += unique_len+function_len+2;
+  data_cstr_size -= unique_len+function_len+2;
+
+  assert(unique);
+  assert(unique_len);
+  assert(function);
+  assert(function_len);
+
+  // single char for priority
+  if (*data_cstr == '2')
+    priority = GEARMAN_JOB_PRIORITY_LOW;
+  else if (*data_cstr == '0')
+    priority = GEARMAN_JOB_PRIORITY_HIGH;
+  else
+    priority = GEARMAN_JOB_PRIORITY_NORMAL;
+
+  ++data_cstr;
+  --data_cstr_size;
+
+  // data is freed later so we must make a copy
+  void *data_ptr= malloc(data_cstr_size);
+  if (data_ptr == NULL)
+  {
+    return GEARMAN_QUEUE_ERROR;
+  }
+  memcpy(data_ptr, data_cstr, data_cstr_size); 
+
+  gret = (*add_fn)(server, add_context, unique, unique_len,
+                   function, function_len,
+                   data_ptr, data_cstr_size,
+                   priority);
+
+  if (gret != GEARMAN_SUCCESS)
+  {
+     return gret;
+  }   
+  return GEARMAN_SUCCESS;
+}
+
+
+static gearman_return_t _libtokyocabinet_replay(gearman_server_st *server, void *context,
+                                                gearman_queue_add_fn *add_fn,
+                                                void *add_context)
+{
+  gearman_queue_libtokyocabinet_st *queue= (gearman_queue_libtokyocabinet_st *)context;
+  TCXSTR *key;
+  TCXSTR *data;
+  BDBCUR *cur;
+  gearman_return_t gret;
+  gearman_return_t tmp_gret;   
+   
+  GEARMAN_SERVER_INFO(server, "libtokyocabinet replay start")
+  
+  cur= tcbdbcurnew(queue->db);
+  if (!cur)
+    return GEARMAN_QUEUE_ERROR;
+
+  if (!tcbdbcurfirst(cur))
+  {
+    tcbdbcurdel(cur);
+    return GEARMAN_SUCCESS;
+  }
+  key= tcxstrnew();
+  data= tcxstrnew();
+  gret= GEARMAN_SUCCESS;
+  while (tcbdbcurrec(cur, key, data))
+  {     
+    tmp_gret= _callback_for_record(server, key, data, add_fn, add_context);
+    if (tmp_gret != GEARMAN_SUCCESS)
+    {
+      gret= GEARMAN_QUEUE_ERROR;
+      break;
+    }
+    if (!tcbdbcurnext(cur))
+      break;
+  }
+  tcxstrdel(key);
+  tcxstrdel(data);
+  tcbdbcurdel(cur);
+
+  return gret;
+}

=== added file 'libgearman-server/queue_libtokyocabinet.h'
--- libgearman-server/queue_libtokyocabinet.h	1970-01-01 00:00:00 +0000
+++ libgearman-server/queue_libtokyocabinet.h	2010-01-21 12:07:13 +0000
@@ -0,0 +1,62 @@
+/**
+ * @file
+ * @brief libtokyocabinet Queue Storage Declarations
+ */
+
+#ifndef __GEARMAN_QUEUE_LIBTOKYOCABINET_H__
+#define __GEARMAN_QUEUE_LIBTOKYOCABINET_H__
+
+/**
+ * It is unclear from tokyocabinet's public headers what, if any, limit there is. 4k seems sane.
+ */
+#define GEARMAN_QUEUE_TOKYOCABINET_MAX_KEY_LEN 4096
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup gearman_queue_libtokyocabinet libtokyocabinet Queue Storage Functions
+ * @ingroup gearman_queue
+ * @{
+ */
+
+/**
+ * Get module configuration options.
+ */
+GEARMAN_API
+gearman_return_t gearman_server_queue_libtokyocabinet_conf(gearman_conf_st *conf);
+
+/**
+ * Initialize the queue.
+ */
+GEARMAN_API    
+gearman_return_t gearman_queue_libtokyocabinet_init(gearman_server_st *server,
+                                                    gearman_conf_st *conf);
+
+/**
+ * De-initialize the queue.
+ */
+GEARMAN_API
+gearman_return_t gearman_queue_libtokyocabinet_deinit(gearman_server_st *server);
+
+/**
+ * Initialize the queue for a gearmand object.
+ */
+GEARMAN_API
+gearman_return_t gearmand_queue_libtokyocabinet_init(gearmand_st *gearmand,
+                                                     gearman_conf_st *conf);
+
+/**
+ * De-initialize the queue for a gearmand object.
+ */
+GEARMAN_API    
+gearman_return_t gearmand_queue_libtokyocabinet_deinit(gearmand_st *server);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GEARMAN_QUEUE_LIBTOKYOCABINET_H__ */

=== added file 'm4/pandora_have_libtokyocabinet.m4.moved'
--- m4/pandora_have_libtokyocabinet.m4.moved	1970-01-01 00:00:00 +0000
+++ m4/pandora_have_libtokyocabinet.m4.moved	2010-01-21 12:07:13 +0000
@@ -0,0 +1,35 @@
+dnl  Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([_PANDORA_SEARCH_LIBTOKYOCABINET],[
+  AC_REQUIRE([AC_LIB_PREFIX])
+
+  dnl --------------------------------------------------------------------
+  dnl  Check for libtokyocabinet
+  dnl --------------------------------------------------------------------
+
+  AC_LIB_HAVE_LINKFLAGS(tokyocabinet,,[
+    #include <tcutil.h>
+    #include <tcbdb.h>    
+  ], [
+    TCMAP *map;
+
+    map = tcmapnew();
+    tcmapdel(map);
+  ])
+  
+  AM_CONDITIONAL(HAVE_LIBTOKYOCABINET, [test "x${ac_cv_libtokyocabinet}" = "xyes"])
+  
+])
+
+AC_DEFUN([PANDORA_HAVE_LIBTOKYOCABINET],[
+  AC_REQUIRE([_PANDORA_SEARCH_LIBTOKYOCABINET])
+])
+
+AC_DEFUN([PANDORA_REQUIRE_LIBTOKYOCABINET],[
+  AC_REQUIRE([PANDORA_HAVE_LIBTOKYOCABINET])
+  AS_IF([test x$ac_cv_libtokyocabinet = xno],
+      AC_MSG_ERROR([libtokyocabbinet is required for ${PACKAGE}]))
+])