Re-enable code that checks for options immediatly.

Fix clocktime call.

configure.ac

@@ -205,7 +205,6 @@ AC_CHECK_FUNCS([strtol])
 AC_CHECK_FUNCS([strtoul])
 AC_CHECK_FUNCS([uname])
 AC_CHECK_FUNCS([atexit])
-AC_CHECK_FUNCS([clock_gettime])
 AC_CHECK_FUNCS([getcwd])
 AC_CHECK_FUNCS([strstr])
 AC_CHECK_FUNC([setsockopt],[],[AC_CHECK_LIB([socket],[setsockopt])])
@@ -216,9 +215,15 @@ AX_DLOPEN
 
 # Check for -lrt
 AC_CHECK_LIB([rt],[clock_gettime],
-             [AC_SUBST([RT_LIB],[-lrt])
-             AC_DEFINE([HAVE_LIBRT],[1],[Have clock_gettime])
-             ])
+             [AX_SAVE_FLAGS
+              LIBS="$LIB -lrt"
+              AC_CHECK_FUNCS([clock_gettime])
+              AX_RESTORE_FLAGS
+
+              AC_SUBST([RT_LIB],[-lrt])
+              AC_DEFINE([HAVE_LIBRT],[1],[Have -lrt])
+             ],
+             [AC_CHECK_FUNCS([clock_gettime])])
 
 # Check for -lm
 LT_LIB_M

libgearman-1.0/limits.h

@@ -49,6 +49,7 @@
 #define GEARMAN_MAXIMUM_INTEGER_DISPLAY_LENGTH 20
 #define GEARMAN_MAX_COMMAND_ARGS 8
 #define GEARMAN_MAX_ECHO_SIZE (UINT32_MAX -GEARMAN_ARGS_BUFFER_SIZE)
+#define GEARMAN_MAX_OPTION_SIZE (UINT32_MAX -GEARMAN_ARGS_BUFFER_SIZE)
 #define GEARMAN_MAX_ERROR_SIZE 2048
 #define GEARMAN_MAX_IDENTIFIER 254
 #define GEARMAN_MAX_UNIQUE_SIZE 64

libgearman-server/gearmand_thread.cc

@@ -60,8 +60,8 @@ namespace
 #if defined(HAVE_PTHREAD_TIMEDJOIN_NP) && HAVE_PTHREAD_TIMEDJOIN_NP
 bool fill_timespec(struct timespec& ts)
 {
-#if defined(HAVE_LIBRT) && HAVE_LIBRT
-  if (HAVE_LIBRT) // This won't be called on OSX, etc,...
+#if defined(HAVE_CLOCK_GETTIME) && HAVE_CLOCK_GETTIME
+  if (HAVE_CLOCK_GETTIME) // This won't be called on OSX, etc,...
   {
     if (clock_gettime(CLOCK_REALTIME, &ts) == -1) 
     {

libgearman-server/plugins/protocol/gear/protocol.cc

@@ -254,8 +254,8 @@ public:
                          "GEAR length: %" PRIu64 " gearmand_command_t: %s option: %.*s",
                          uint64_t(packet->data_size),
                          gearman_strcommand(packet->command),
-                         int(packet->data_size),
-                         packet->data);
+                         int(packet->arg_size[0]),
+                         packet->arg[0]);
     }
     else
     {
@@ -277,12 +277,21 @@ public:
     if (packet->command == GEARMAN_COMMAND_ECHO_RES)
     {
       gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
-                         "GEAR length: %" PRIu64 " gearmand_command_t: %s echo: %.*",
+                         "GEAR length: %" PRIu64 " gearmand_command_t: %s echo: %.*s",
                          uint64_t(packet->data_size),
                          gearman_strcommand(packet->command),
                          int(packet->data_size),
                          packet->data);
     }
+    else if (packet->command == GEARMAN_COMMAND_OPTION_RES)
+    {
+      gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
+                         "GEAR length: %" PRIu64 " gearmand_command_t: %s option: %.*s",
+                         uint64_t(packet->data_size),
+                         gearman_strcommand(packet->command),
+                         int(packet->arg_size[0]),
+                         packet->arg[0]);
+    }
     else
     {
       gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,

libgearman-server/server.cc

@@ -72,11 +72,13 @@
  * Queue an error packet.
  */
 static gearmand_error_t _server_error_packet(gearman_server_con_st *server_con,
-                                             gearman_return_t error_code, const char *error_string)
+                                             gearman_return_t client_return_code, const char *error_string)
 {
-  const char* error_code_string= gearman_strerror(error_code);
+  const char* error_code_string= gearman_strerror(client_return_code);
   error_code_string+= 8;
 
+  gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "%s:%s", gearman_strerror(client_return_code), error_string);
+
   return gearman_server_io_packet_add(server_con, false, GEARMAN_MAGIC_RESPONSE,
                                       GEARMAN_COMMAND_ERROR, error_code_string,
                                       (size_t)(strlen(error_code_string) + 1),
@@ -818,7 +820,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
                          server_job->function->function_name_size, server_job->function->function_name, server_job->function->function_name_size);
       if (server_job == NULL)
       {
-        return _server_error_packet(server_con, GEARMAN_NO_JOBS, "Job given in work result not found");
+        return _server_error_packet(server_con, GEARMAN_NO_JOBS, "An exception was received for a job that does not exist");
       }
 
       /* Queue the exception packet for all clients. */

libgearman/check.cc

@@ -93,19 +93,21 @@ gearman_return_t CancelCheck::success(gearman_connection_st* con)
     if (con->_packet.argc)
     {
       gearman_return_t maybe_server_error= string2return_code(static_cast<char *>(con->_packet.arg[0]), int(con->_packet.arg_size[0]));
-
       if (maybe_server_error == GEARMAN_MAX_RETURN)
       {
         maybe_server_error= GEARMAN_SERVER_ERROR;
       }
 
-      return gearman_universal_set_error(_universal, maybe_server_error, GEARMAN_AT, "%.*s:%.*s",
+      return gearman_universal_set_error(_universal, maybe_server_error, GEARMAN_AT, "%s:%s %.*s:%.*s",
+                                         con->host(), con->service(),
                                          con->_packet.arg_size[0], con->_packet.arg[0],
                                          con->_packet.arg_size[1], con->_packet.arg[1]
                                         );
     }
 
-    return gearman_error(_universal, GEARMAN_SERVER_ERROR, "server lacks support for client's to cancel a job");
+    return gearman_universal_set_error(_universal, GEARMAN_SERVER_ERROR, GEARMAN_AT, "%s:%s lacks support for client's to cancel a job",
+                                       con->host(), con->service()
+                                      );
   }
 
   return GEARMAN_SUCCESS;
@@ -118,20 +120,24 @@ gearman_return_t OptionCheck::success(gearman_connection_st* con)
     if (con->_packet.argc)
     {
       gearman_return_t maybe_server_error= string2return_code(static_cast<char *>(con->_packet.arg[0]), int(con->_packet.arg_size[0]));
-
       if (maybe_server_error == GEARMAN_MAX_RETURN)
       {
         maybe_server_error= GEARMAN_INVALID_SERVER_OPTION;
       }
 
-      return gearman_universal_set_error(_universal, maybe_server_error, GEARMAN_AT, "%d: %.*s:%.*s", con->_packet.argc,
-                                         con->_packet.arg_size[0], con->_packet.arg[0],
-                                         con->_packet.arg_size[1], con->_packet.arg[1]
+      return gearman_universal_set_error(_universal, maybe_server_error, GEARMAN_AT, "%s:%s Invalid option %.*s",
+                                         con->host(), con->service(),
+                                         con->_packet.arg_size[0], con->_packet.arg[0]
                                         );
     }
 
-    return gearman_error(_universal, GEARMAN_INVALID_SERVER_OPTION, "invalid server option");
+    return gearman_universal_set_error(_universal, GEARMAN_INVALID_SERVER_OPTION, GEARMAN_AT, "%s:%s Invalid option %.*s",
+                                       con->host(), con->service(),
+                                       con->_packet.arg_size[0], con->_packet.arg[0]
+                                      );
   }
 
+  // @todo mark option set for connection
+
   return GEARMAN_SUCCESS;
 }

libgearman/check.h

@@ -59,15 +59,17 @@ private:
 
 class OptionCheck : public Check {
 public:
-  OptionCheck(gearman_universal_st& universal_):
-    _universal(universal_)
-    {
-    }
+  OptionCheck(gearman_universal_st& universal_, gearman_string_t& option_):
+    _universal(universal_),
+    _option(option_)
+  {
+  }
 
   gearman_return_t success(gearman_connection_st* con);
 
 private:
-  gearman_universal_st& _universal;
+    gearman_universal_st& _universal;
+    gearman_string_t& _option;
 };
 
 class CancelCheck : public Check {

libgearman/client.cc

@@ -1806,15 +1806,20 @@ bool gearman_client_set_server_option(gearman_client_st *client_shell, const cha
 {
   if (client_shell and client_shell->impl())
   {
+    Client* client= client_shell->impl();
     gearman_string_t option= { option_arg, option_arg_size };
-    if (gearman_request_option(client_shell->impl()->universal, option))
+
+    if (gearman_success(gearman_server_option(client->universal, option)))
     {
-      if (strcmp("exceptions", option_arg) == 0)
+      if (gearman_request_option(client->universal, option))
       {
-        client_shell->impl()->options.exceptions= true;
-      }
+        if (strncmp("exceptions", option_arg, sizeof("exceptions")) == 0)
+        {
+          client->options.exceptions= true;
+        }
 
-      return true;
+        return true;
+      }
     }
   }
 

libgearman/connection.cc

@@ -49,6 +49,8 @@
 #include "libgearman/interface/push.hpp"
 #include "libgearman/log.hpp"
 
+#include "libgearman/protocol/option.h"
+
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
@@ -425,11 +427,8 @@ gearman_return_t gearman_connection_st::send_packet(const gearman_packet_st& pac
          head= head->next)
     {
       gearman_packet_st message;
-      const void *args[]= { (const void*)head->value() };
-      size_t args_size[]= { head->size() };
-      gearman_return_t ret= gearman_packet_create_args(universal, message, GEARMAN_MAGIC_REQUEST,
-                                                       GEARMAN_COMMAND_OPTION_REQ, args, args_size, 1);
-
+      gearman_string_t option= { (const char*)head->value(), head->size() };
+      gearman_return_t ret=  libgearman::protocol::option(universal, message, option);
       if (gearman_failed(ret))
       {
         assert(universal.error_code());
@@ -439,7 +438,7 @@ gearman_return_t gearman_connection_st::send_packet(const gearman_packet_st& pac
       }
 
       PUSH_BLOCKING(universal);
-      OptionCheck check(universal);
+      OptionCheck check(universal, option);
       ret= _send_packet(message, true);
       if (gearman_failed(ret))
       {

libgearman/execute.cc

@@ -259,20 +259,18 @@ gearman_task_st *gearman_execute_by_partition(gearman_client_st *client_shell,
                            NULL);
   }
 
-  if (task == NULL)
+  if (task)
   {
-    return NULL;
+    do {
+      gearman_return_t rc;
+      if (gearman_failed(rc= gearman_client_run_tasks(client->shell())))
+      {
+        gearman_gerror(client->universal, rc);
+        gearman_task_free(task);
+        return NULL;
+      }
+    } while (gearman_continue(gearman_task_return(task)));
   }
 
-  do {
-    gearman_return_t rc;
-    if (gearman_failed(rc= gearman_client_run_tasks(client->shell())))
-    {
-      gearman_gerror(client->universal, rc);
-      gearman_task_free(task);
-      return NULL;
-    }
-  } while (gearman_continue(gearman_task_return(task)));
-
   return task;
 }