Merge lp:~brianaker/gearmand/fixes-for-ssl-builds into lp:gearmand

[Brian Aker]

[lp:~brianaker/gearmand/fixes-for-ssl-builds]

824. By Brian Aker on 2013-07-11

OSX build fixes.

825. By Brian Aker on 2013-07-11

Additional OSX fix.

826. By Brian Aker on 2013-07-11

Fix additional OSX warnings.

=== modified file 'libgearman-1.0/constants.h'
--- libgearman-1.0/constants.h	2013-06-05 21:59:31 +0000
+++ libgearman-1.0/constants.h	2013-07-11 21:18:03 +0000
@@ -133,7 +133,8 @@
   GEARMAN_WORKER_TIMEOUT_RETURN=   (1 << 8),
   GEARMAN_WORKER_GRAB_ALL=         (1 << 9),
   GEARMAN_WORKER_SSL=              (1 << 10),
-  GEARMAN_WORKER_MAX=   (1 << 11)
+  GEARMAN_WORKER_IDENTIFIER=       (1 << 11),
+  GEARMAN_WORKER_MAX=   (1 << 12)
 } gearman_worker_options_t;
 
 /* Types. */

=== modified file 'libgearman-server/connection.cc'
--- libgearman-server/connection.cc	2013-06-26 23:50:02 +0000
+++ libgearman-server/connection.cc	2013-07-11 21:18:03 +0000
@@ -47,7 +47,8 @@
 
 #include <string.h>
 #include <errno.h>
-#include <assert.h>
+#include <cassert>
+#include <algorithm> 
 
 static gearman_server_con_st * _server_con_create(gearman_server_thread_st *thread, gearmand_con_st *dcon,
                                                   gearmand_error_t& ret);
@@ -313,16 +314,18 @@
   return con->id;
 }
 
-void gearman_server_con_set_id(gearman_server_con_st *con, char *id,
-                               size_t size)
+void gearman_server_con_set_id(gearman_server_con_st *con,
+                               const char *id,
+                               const size_t size)
 {
-  if (size >= GEARMAND_SERVER_CON_ID_SIZE)
-  {
-    size= GEARMAND_SERVER_CON_ID_SIZE - 1;
-  }
-
-  memcpy(con->id, id, size);
-  con->id[size]= 0;
+  size_t min_size= std::min(size, size_t(GEARMAND_SERVER_CON_ID_SIZE -1));
+
+  memcpy(con->id, id, min_size);
+  con->id[min_size]= 0;
+
+  gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
+                     "identifier set to %.*s", 
+                     min_size, con->id);
 }
 
 void gearman_server_con_free_worker(gearman_server_con_st *con,

=== modified file 'libgearman-server/connection.h'
--- libgearman-server/connection.h	2013-06-26 23:50:02 +0000
+++ libgearman-server/connection.h	2013-07-11 21:18:03 +0000
@@ -111,8 +111,8 @@
  * Set client id.
  */
 GEARMAN_API
-void gearman_server_con_set_id(gearman_server_con_st *con, char *id,
-                               size_t size);
+void gearman_server_con_set_id(gearman_server_con_st *con, const char *id,
+                               const size_t size);
 
 /**
  * Free server worker struction with name for a server connection.

=== modified file 'libgearman-server/gearmand.cc'
--- libgearman-server/gearmand.cc	2013-07-07 00:16:26 +0000
+++ libgearman-server/gearmand.cc	2013-07-11 21:18:03 +0000
@@ -861,15 +861,7 @@
     Gearmand()->ret= gearmand_perror(local_error, "accept");
     return;
   }
-  gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "accept() %d", fd);
-
-  {
-    int flags= 1;
-    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags)) == -1)
-    {
-      gearmand_perror(errno, "setsockopt(SO_KEEPALIVE)");
-    }
-  }
+  gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "accept() fd:%d", fd);
 
   /* 
     Since this is numeric, it should never fail. Even if it did we don't want to really error from it.
@@ -887,6 +879,14 @@
 
   gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "Accepted connection from %s:%s", host, port_str);
 
+  {
+    int flags= 1;
+    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags)) == -1)
+    {
+      gearmand_log_perror(GEARMAN_DEFAULT_LOG_PARAM, errno, "%s:%s setsockopt(SO_KEEPALIVE)", host, port_str);
+    }
+  }
+
   gearmand_error_t ret= gearmand_con_create(Gearmand(), fd, host, port_str, port);
   if (ret == GEARMAND_MEMORY_ALLOCATION_FAILURE)
   {
@@ -915,15 +915,10 @@
     return gearmand_fatal_perror(errno, "pipe(gearmand->wakeup_fd)");
   }
 
-  int returned_flags;
-  if ((returned_flags= fcntl(gearmand->wakeup_fd[0], F_GETFL, 0)) == -1)
-  {
-    return gearmand_fatal_perror(errno, "fcntl:F_GETFL");
-  }
-
-  if (fcntl(gearmand->wakeup_fd[0], F_SETFL, returned_flags | O_NONBLOCK) == -1)
-  {
-    return gearmand_fatal_perror(errno, "fcntl(F_SETFL)");
+  gearmand_error_t local_ret;
+  if ((local_ret= gearmand_sockfd_nonblock(gearmand->wakeup_fd[0])))
+  {
+    return local_ret;
   }
 #endif
 

=== modified file 'libgearman-server/gearmand_thread.cc'
--- libgearman-server/gearmand_thread.cc	2013-07-10 10:54:09 +0000
+++ libgearman-server/gearmand_thread.cc	2013-07-11 21:18:03 +0000
@@ -505,16 +505,10 @@
     return gearmand_perror(errno, "pipe");
   }
 
-  int ret= fcntl(thread->wakeup_fd[0], F_GETFL, 0);
-  if (ret == -1)
-  {
-    return gearmand_perror(errno, "fcntl(F_GETFL)");
-  }
-
-  ret= fcntl(thread->wakeup_fd[0], F_SETFL, ret | O_NONBLOCK);
-  if (ret == -1)
-  {
-    return gearmand_perror(errno, "fcntl(F_SETFL)");
+  gearmand_error_t local_ret;
+  if ((local_ret= gearmand_sockfd_nonblock(thread->gearmand().wakeup_fd[0])))
+  {
+    return local_ret;
   }
 #endif
 

=== modified file 'libgearman-server/io.cc'
--- libgearman-server/io.cc	2013-07-07 22:07:57 +0000
+++ libgearman-server/io.cc	2013-07-11 21:18:03 +0000
@@ -146,10 +146,7 @@
     if (read_size == 0)
     {
       ret= GEARMAND_LOST_CONNECTION;
-      gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, 
-                        "Peer connection has called close() %s:%s",
-                        connection->host(),
-                        connection->port());
+      gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "Peer connection has called close()");
       _connection_close(connection);
       return 0;
     }
@@ -177,10 +174,7 @@
       case EHOSTDOWN:
         {
           ret= GEARMAND_LOST_CONNECTION;
-          gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, 
-                            "Peer connection has called close() %s:%s",
-                            connection->host(),
-                            connection->port());
+          gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "Peer connection has called close()");
           _connection_close(connection);
           return 0;
         }
@@ -300,9 +294,7 @@
                   char errorString[80];
                   CyaSSL_ERR_error_string(err, errorString);
                   _connection_close(connection);
-                  return gearmand_log_gerror(GEARMAN_DEFAULT_LOG_PARAM, GEARMAND_LOST_CONNECTION, "%s:%s SSL failure(%s)",
-                                             connection->host(),
-                                             connection->port(),
+                  return gearmand_log_gerror(GEARMAN_DEFAULT_LOG_PARAM, GEARMAND_LOST_CONNECTION, "SSL failure(%s)",
                                              errorString);
                 }
             }
@@ -317,10 +309,8 @@
         if (write_size == 0) // detect infinite loop?
         {
           ++loop_counter;
-          gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "send() sent zero bytes of %u to peer %s:%s",
-                             uint32_t(connection->send_buffer_size),
-                             connection->host(),
-                             connection->port());
+          gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "send() sent zero bytes of %u",
+                             uint32_t(connection->send_buffer_size));
 
           if (loop_counter > 5)
           {
@@ -366,10 +356,8 @@
           return GEARMAND_ERRNO;
         }
 
-        gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "send() %u bytes to peer %s:%s",
-                           uint32_t(write_size),
-                           connection->host(),
-                           connection->port());
+        gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "send() %u bytes to peer",
+                           uint32_t(write_size));
 
         connection->send_buffer_size-= static_cast<size_t>(write_size);
         if (connection->send_state == gearmand_io_st::GEARMAND_CON_SEND_UNIVERSAL_FLUSH_DATA)
@@ -775,9 +763,7 @@
         }
         return ret;
       }
-      gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "%s:%s read %lu bytes",
-                         connection->host(),
-                         connection->port(),
+      gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "read %lu bytes",
                          (unsigned long)recv_size);
 
       connection->recv_buffer_size+= recv_size;
@@ -901,7 +887,6 @@
 
 static gearmand_error_t _io_setsockopt(gearmand_io_st &connection)
 {
-  gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "setsockopt() fd:%d", connection.fd);
   {
     int setting= 1;
     if (setsockopt(connection.fd, IPPROTO_TCP, TCP_NODELAY, &setting, (socklen_t)sizeof(int)) and errno != EOPNOTSUPP)
@@ -969,28 +954,39 @@
 
   if (SOCK_NONBLOCK == 0)
   {
-    int flags;
+    gearmand_error_t local_ret;
+    if ((local_ret= gearmand_sockfd_nonblock(connection.fd)))
+    {
+      return local_ret;
+    }
+  }
+
+  return GEARMAND_SUCCESS;
+}
+
+gearmand_error_t gearmand_sockfd_nonblock(const int& sockfd)
+{
+  int flags;
+  do
+  {
+    flags= fcntl(sockfd, F_GETFL, 0);
+  } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
+
+  if (flags == -1)
+  {
+    return gearmand_perror(errno, "fcntl(F_GETFL)");
+  }
+  else if ((flags & O_NONBLOCK) == 0)
+  {
+    int retval;
     do
     {
-      flags= fcntl(connection.fd, F_GETFL, 0);
-    } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
-
-    if (flags == -1)
-    {
-      return gearmand_perror(errno, "fcntl(F_GETFL)");
-    }
-    else if ((flags & O_NONBLOCK) == 0)
-    {
-      int retval;
-      do
-      {
-        retval= fcntl(connection.fd, F_SETFL, flags | O_NONBLOCK);
-      } while (retval == -1 and (errno == EINTR or errno == EAGAIN));
-
-      if (retval == -1)
-      {
-        return gearmand_perror(errno, "fcntl(F_SETFL)");
-      }
+      retval= fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
+    } while (retval == -1 and (errno == EINTR or errno == EAGAIN));
+
+    if (retval == -1)
+    {
+      return gearmand_perror(errno, "fcntl(F_SETFL)");
     }
   }
 
@@ -1016,7 +1012,7 @@
   }
   else
   {
-    gearmand_warning("gearmand_sockfd_close() called with an invalid socket");
+    gearmand_debug("gearmand_sockfd_close() called with an invalid socket, this was probably ok");
   }
 }
 

=== modified file 'libgearman-server/io.h'
--- libgearman-server/io.h	2013-03-09 22:03:25 +0000
+++ libgearman-server/io.h	2013-07-11 21:18:03 +0000
@@ -131,9 +131,11 @@
  */
 gearmand_error_t gearmand_io_set_revents(gearman_server_con_st *connection, short revents);
 
-void gearmand_sockfd_close(int& sockfd);
-
-void gearmand_pipe_close(int& sockfd);
+void gearmand_sockfd_close(int&);
+
+void gearmand_pipe_close(int&);
+
+gearmand_error_t gearmand_sockfd_nonblock(const int&);
 
 /** @} */
 

=== modified file 'libgearman-server/plugins/protocol/gear/protocol.cc'
--- libgearman-server/plugins/protocol/gear/protocol.cc	2013-07-10 10:54:09 +0000
+++ libgearman-server/plugins/protocol/gear/protocol.cc	2013-07-11 21:18:03 +0000
@@ -47,6 +47,7 @@
 #include <libgearman-server/common.h>
 #include <libgearman/strcommand.h>
 #include <libgearman-server/packet.h>
+#include "libgearman/strcommand.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -103,9 +104,9 @@
     return false;
   }
 
-  void notify(gearman_server_con_st *)
+  void notify(gearman_server_con_st* connection)
   {
-    gearmand_info("Gear connection disconnected");
+    gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "Gear connection disconnected: %s:%s", connection->host(), connection->port());
   }
 
   size_t unpack(gearmand_packet_st *packet,
@@ -257,6 +258,24 @@
                          int(packet->arg_size[0]),
                          packet->arg[0]);
     }
+    else if (packet->command == GEARMAN_COMMAND_WORK_EXCEPTION)
+    {
+      gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
+                         "GEAR gearmand_command_t: %s handle: %.*s exception: %.*s",
+                         gearman_strcommand(packet->command),
+                         int(packet->arg_size[0]),
+                         packet->arg[0],
+                         int(packet->data_size),
+                         packet->data);
+    }
+    else if (packet->command == GEARMAN_COMMAND_SET_CLIENT_ID)
+    {
+      gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
+                         "GEAR gearmand_command_t: %s identifier: %.*s",
+                         gearman_strcommand(packet->command),
+                         int(packet->arg_size[0]),
+                         packet->arg[0]);
+    }
     else
     {
       gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
@@ -353,9 +372,13 @@
                                    cyassl_error_buffer, cyassl_error);
       }
     }
-    gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "GearSSL connection made: %d", connection->con.fd);
+    gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "GearSSL connection made: %s:%s", connection->host(), connection->port());
   }
+  else
 #endif
+  {
+    gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "Gear connection made: %s:%s", connection->host(), connection->port());
+  }
 
   connection->set_protocol(&gear_context);
 

=== modified file 'libgearman-server/server.cc'
--- libgearman-server/server.cc	2013-07-10 10:54:09 +0000
+++ libgearman-server/server.cc	2013-07-11 21:18:03 +0000
@@ -545,7 +545,7 @@
       long timeout= strtol(strtol_buffer, &endptr, 10);
       if (timeout == LONG_MIN or timeout == LONG_MAX or errno != 0)
       {
-        return gearmand_log_perror(GEARMAN_DEFAULT_LOG_PARAM, errno, "GEARMAN_COMMAND_CAN_DO_TIMEOUT:strtol");
+        return gearmand_log_perror(GEARMAN_DEFAULT_LOG_PARAM, errno, "GEARMAN_COMMAND_CAN_DO_TIMEOUT:strtol: %s", strtol_buffer);
       }
 
       gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, "Registering function: %.*s with timeout %dl",
@@ -1042,7 +1042,10 @@
     }
     else if (command == GEARMAN_COMMAND_WORK_EXCEPTION)
     {
-      gearmand_debug("Sending GEARMAN_COMMAND_WORK_EXCEPTION");
+      gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
+                         "%s:%s GEARMAN_COMMAND_WORK_EXCEPTION: %.*s",
+                         server_client->con->host(), server_client->con->port(),
+                         int(packet->data_size), packet->data);
     }
 
     uint8_t *data;

=== modified file 'libgearman-server/struct/gearmand_thread.h'
--- libgearman-server/struct/gearmand_thread.h	2013-07-06 10:56:43 +0000
+++ libgearman-server/struct/gearmand_thread.h	2013-07-11 21:18:03 +0000
@@ -37,7 +37,7 @@
 
 #pragma once
 
-class gearmand_st;
+struct gearmand_st;
 
 struct gearmand_thread_st
 {
@@ -61,4 +61,9 @@
   pthread_mutex_t lock;
 
   gearmand_thread_st(gearmand_st&);
+
+  gearmand_st& gearmand()
+  {
+    return _gearmand;
+  }
 };

=== modified file 'libgearman-server/thread.cc'
--- libgearman-server/thread.cc	2013-07-06 20:11:54 +0000
+++ libgearman-server/thread.cc	2013-07-11 21:18:03 +0000
@@ -45,6 +45,7 @@
 #include "libgearman-server/common.h"
 
 #include <libgearman/command.h>
+#include "libgearman/strcommand.h"
 
 #ifdef __cplusplus
 # include <cassert>
@@ -308,10 +309,8 @@
     }
 
     gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
-                       "Received %s %s:%u",
-                       gearmand_strcommand(&con->packet->packet),
-                       con->_host == NULL ? "-" : con->_host,
-                       con->_port == NULL ? "-" : con->_port);
+                       "Received %s",
+                       gearmand_strcommand(&con->packet->packet));
 
     /* We read a complete packet. */
     if (Server->flags.threaded)
@@ -355,10 +354,8 @@
     }
 
     gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM, 
-                       "Sent %s to %s:%d",
-                       gearman_command_info(con->io_packet_list->packet.command)->name,
-                       con->_host == NULL ? "-" : con->_host,
-                       con->_port == NULL ? "-" : con->_port);
+                       "Sent %s",
+                       gearman_strcommand(con->io_packet_list->packet.command));
 
     gearman_server_io_packet_remove(con);
   }

=== modified file 'libgearman/check.h'
--- libgearman/check.h	2013-07-10 10:54:09 +0000
+++ libgearman/check.h	2013-07-11 21:18:03 +0000
@@ -65,6 +65,11 @@
   {
   }
 
+  const gearman_string_t& option() const
+  {
+    return _option;
+  }
+
   gearman_return_t success(gearman_connection_st* con);
 
 private:

=== modified file 'libgearman/client.cc'
--- libgearman/client.cc	2013-07-10 10:54:09 +0000
+++ libgearman/client.cc	2013-07-11 21:18:03 +0000
@@ -1744,36 +1744,32 @@
 
 gearman_return_t gearman_client_run_block_tasks(Client* client, gearman_task_st* exit_task)
 {
-  {
-    if (client->task_list == NULL) // We are immediatly successful if all tasks are completed
-    {
-      return GEARMAN_SUCCESS;
-    }
-
-    gearman_return_t rc;
-    {
-      PUSH_BLOCKING(client->universal);
-
-      rc= _client_run_tasks(client->shell(), exit_task);
-    }
-
-    if (gearman_failed(rc))
-    {
-      if (rc == GEARMAN_COULD_NOT_CONNECT)
-      {
-        gearman_reset(client->universal);
-      }
-
-      if (client->universal.error_code() != rc and rc != GEARMAN_COULD_NOT_CONNECT)
-      {
-        assert(client->universal.error_code() == rc);
-      }
-    }
-
-    return rc;
-  }
-
-  return GEARMAN_INVALID_ARGUMENT;
+  if (client->task_list == NULL) // We are immediatly successful if all tasks are completed
+  {
+    return GEARMAN_SUCCESS;
+  }
+
+  gearman_return_t rc;
+  {
+    PUSH_BLOCKING(client->universal);
+
+    rc= _client_run_tasks(client->shell(), exit_task);
+  }
+
+  if (gearman_failed(rc))
+  {
+    if (rc == GEARMAN_COULD_NOT_CONNECT)
+    {
+      gearman_reset(client->universal);
+    }
+
+    if (client->universal.error_code() != rc and rc != GEARMAN_COULD_NOT_CONNECT)
+    {
+      assert(client->universal.error_code() == rc);
+    }
+  }
+
+  return rc;
 }
 
 /*

=== modified file 'libgearman/client.hpp'
--- libgearman/client.hpp	2013-07-08 09:58:12 +0000
+++ libgearman/client.hpp	2013-07-11 21:18:03 +0000
@@ -47,7 +47,7 @@
 
 namespace {
 
-inline void all_PRINTER(const char *line, gearman_verbose_t verbose, void*)
+inline void all_client_PRINTER(const char *line, gearman_verbose_t verbose, void*)
 {
   fprintf(stderr, "%s:%d %s(%s)\n", __FILE__, __LINE__, gearman_verbose_name(verbose), line);
 }
@@ -67,7 +67,6 @@
       throw std::runtime_error("gearman_client_create() failed");
     }
     enable_logging();
-
     enable_ssl();
   }
 
@@ -95,6 +94,7 @@
 
     gearman_client_add_server(_client, "localhost", arg);
 
+    enable_logging();
     enable_ssl();
   }
 
@@ -117,7 +117,7 @@
   { 
     if (getenv("YATL_CLIENT_LOGGING"))
     {
-      gearman_log_fn *func= all_PRINTER;
+      gearman_log_fn *func= all_client_PRINTER;
       gearman_client_set_log_fn(_client, func, NULL, GEARMAN_VERBOSE_ERROR);
     }
   }

=== modified file 'libgearman/function/function_v2.cc'
--- libgearman/function/function_v2.cc	2013-07-05 22:06:45 +0000
+++ libgearman/function/function_v2.cc	2013-07-11 21:18:03 +0000
@@ -59,6 +59,7 @@
     job->_error_code= GEARMAN_SUCCESS;
     return GEARMAN_FUNCTION_SHUTDOWN;
 
+  case GEARMAN_WORK_EXCEPTION:
   case GEARMAN_FATAL:
     job->_error_code= GEARMAN_FATAL;
     return GEARMAN_FUNCTION_FATAL;
@@ -91,7 +92,6 @@
   case GEARMAN_WORK_DATA:
   case GEARMAN_WORK_WARNING:
   case GEARMAN_WORK_STATUS:
-  case GEARMAN_WORK_EXCEPTION:
   case GEARMAN_NOT_CONNECTED:
   case GEARMAN_COULD_NOT_CONNECT:
   case GEARMAN_SEND_IN_PROGRESS:
@@ -123,5 +123,6 @@
     break;
   }
 
+  gearman_gerror(job->universal(), GEARMAN_INVALID_ARGUMENT);
   return GEARMAN_FUNCTION_INVALID_ARGUMENT;
 }

=== modified file 'libgearman/interface/universal.hpp'
--- libgearman/interface/universal.hpp	2013-07-08 09:58:12 +0000
+++ libgearman/interface/universal.hpp	2013-07-11 21:18:03 +0000
@@ -265,6 +265,10 @@
   ~gearman_universal_st();
 
   void identifier(const char *identifier_, const size_t identifier_size_);
+  bool has_identifier() const
+  {
+    return _identifier;
+  }
 };
 
 static inline bool gearman_universal_is_non_blocking(gearman_universal_st &self)

=== modified file 'libgearman/interface/worker.hpp'
--- libgearman/interface/worker.hpp	2013-07-05 22:06:45 +0000
+++ libgearman/interface/worker.hpp	2013-07-11 21:18:03 +0000
@@ -127,6 +127,11 @@
     universal.options._ssl= ssl_;
   }
 
+  bool has_identifier() const
+  {
+    return universal.has_identifier();
+  }
+
   const char* error() const
   {
     return universal.error();

=== modified file 'libgearman/job.cc'
--- libgearman/job.cc	2013-07-08 00:50:39 +0000
+++ libgearman/job.cc	2013-07-11 21:18:03 +0000
@@ -68,6 +68,16 @@
     gearman_string_append(reducer_function, gearman_string_param(reducer_function_name));
   }
 
+  const char* name() const
+  {
+    if (reducer_function)
+    {
+      return reducer_function->c_str();
+    }
+
+    return "__UNKNOWN";
+  }
+
   ~gearman_job_reducer_st() 
   {
     gearman_client_free(client);
@@ -79,7 +89,8 @@
     client= gearman_client_create(NULL);
     if (client)
     {
-
+      gearman_universal_clone(client->impl()->universal, universal, false);
+#if 0
       if (universal._namespace)
       {
         gearman_client_set_namespace(client, 
@@ -94,6 +105,7 @@
           return false;
         }
       }
+#endif
 
       return true;
     }
@@ -415,7 +427,7 @@
         gearman_return_t rc= job->reducer->complete();
         if (gearman_failed(rc))
         {
-          return gearman_error(job->universal(), rc, "The reducer's complete() returned an error");
+          return gearman_universal_set_error(job->universal(), rc, GEARMAN_AT, "%s couldn't call complete()", job->reducer->name());
         }
 
         const gearman_vector_st *reduced_value= job->reducer->result.string();
@@ -472,6 +484,11 @@
 {
   if (job)
   {
+    if (exception == NULL or exception_size == 0)
+    {
+      return gearman_error(job->universal(), GEARMAN_INVALID_ARGUMENT, "No exception was provided");
+    }
+
     if (job->finished() == false)
     {
       if (job->options.work_in_use == false)

=== modified file 'libgearman/strcommand.h'
--- libgearman/strcommand.h	2012-03-31 06:09:14 +0000
+++ libgearman/strcommand.h	2013-07-11 21:18:03 +0000
@@ -37,4 +37,12 @@
 
 #pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 const char *gearman_strcommand(gearman_command_t command);
+
+#ifdef __cplusplus
+}
+#endif

=== modified file 'libgearman/universal.cc'
--- libgearman/universal.cc	2013-07-10 10:54:09 +0000
+++ libgearman/universal.cc	2013-07-11 21:18:03 +0000
@@ -105,6 +105,8 @@
 
   (void)gearman_universal_set_option(destination, GEARMAN_UNIVERSAL_NON_BLOCKING, source.options.non_blocking);
 
+  destination.ssl(source.ssl());
+
   destination.timeout= source.timeout;
 
   destination._namespace= gearman_string_clone(source._namespace);
@@ -374,6 +376,11 @@
       return gearman_gerror(universal, GEARMAN_SHUTDOWN);
     }
 
+    if (read_length == -1)
+    {
+      gearman_perror(universal, "read() from shutdown pipe");
+    }
+
 #if 0
     perror("shudown read");
 #endif

=== modified file 'libgearman/worker.cc'
--- libgearman/worker.cc	2013-07-08 00:50:39 +0000
+++ libgearman/worker.cc	2013-07-11 21:18:03 +0000
@@ -39,6 +39,7 @@
 #include "gear_config.h"
 
 #include <libgearman/common.h>
+#include "libgearman/uuid.hpp"
 #include <libgearman/function/base.hpp>
 #include <libgearman/function/make.hpp>
 
@@ -258,6 +259,8 @@
       options|= int(GEARMAN_WORKER_TIMEOUT_RETURN);
     if (worker->ssl())
       options|= int(GEARMAN_WORKER_SSL);
+    if (worker->has_identifier())
+      options|= int(GEARMAN_WORKER_IDENTIFIER);
 
     return gearman_worker_options_t(options);
   }
@@ -276,6 +279,7 @@
       GEARMAN_WORKER_GRAB_ALL,
       GEARMAN_WORKER_TIMEOUT_RETURN,
       GEARMAN_WORKER_SSL,
+      GEARMAN_WORKER_IDENTIFIER,
       GEARMAN_WORKER_MAX
     };
 
@@ -333,6 +337,14 @@
     {
       worker->ssl(true);
     }
+
+    if (options & GEARMAN_WORKER_IDENTIFIER)
+    {
+      char uuid_buffer[GEARMAN_MAX_IDENTIFIER];
+      size_t length= GEARMAN_MAX_IDENTIFIER;
+      safe_uuid_generate(uuid_buffer, length);
+      worker->universal.identifier(uuid_buffer, length);
+    }
   }
 }
 
@@ -369,9 +381,9 @@
       worker->options.grab_all= false;
     }
 
-    if (options & GEARMAN_WORKER_SSL)
+    if (options & GEARMAN_WORKER_IDENTIFIER)
     {
-      worker->ssl(false);
+      worker->universal.identifier(NULL, 0);
     }
   }
 }
@@ -1240,77 +1252,73 @@
                                                 uint32_t timeout,
                                                 void *context)
 {
+  const void *args[2];
+  size_t args_size[2];
+
+  if (function_length == 0 or function_name == NULL or function_length > GEARMAN_FUNCTION_MAX_SIZE)
   {
-    const void *args[2];
-    size_t args_size[2];
-
-    if (function_length == 0 or function_name == NULL or function_length > GEARMAN_FUNCTION_MAX_SIZE)
-    {
-      if (function_length > GEARMAN_FUNCTION_MAX_SIZE)
-      {
-        gearman_error(worker->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
-      } 
-      else
-      {
-        gearman_error(worker->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
-      }
-
-      return GEARMAN_INVALID_ARGUMENT;
-    }
-
-    _worker_function_st *function= make(worker->universal._namespace, function_name, function_length, function_arg, context);
-    if (function == NULL)
-    {
-      gearman_perror(worker->universal, "_worker_function_st::new()");
-      return GEARMAN_MEMORY_ALLOCATION_FAILURE;
-    }
-
-    gearman_return_t ret;
-    if (timeout > 0)
-    {
-      char timeout_buffer[11];
-      snprintf(timeout_buffer, sizeof(timeout_buffer), "%u", timeout);
-      args[0]= function->name();
-      args_size[0]= function->length() + 1;
-      args[1]= timeout_buffer;
-      args_size[1]= strlen(timeout_buffer);
-      ret= gearman_packet_create_args(worker->universal, function->packet(),
-                                      GEARMAN_MAGIC_REQUEST,
-                                      GEARMAN_COMMAND_CAN_DO_TIMEOUT,
-                                      args, args_size, 2);
-    }
+    if (function_length > GEARMAN_FUNCTION_MAX_SIZE)
+    {
+      gearman_error(worker->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
+    } 
     else
     {
-      args[0]= function->name();
-      args_size[0]= function->length();
-      ret= gearman_packet_create_args(worker->universal, function->packet(),
-                                      GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CAN_DO,
-                                      args, args_size, 1);
-    }
-
-    if (gearman_failed(ret))
-    {
-      delete function;
-
-      return ret;
-    }
-
-    if (worker->function_list)
-    {
-      worker->function_list->prev= function;
-    }
-
-    function->next= worker->function_list;
-    function->prev= NULL;
-    worker->function_list= function;
-    worker->function_count++;
-
-    worker->options.change= true;
-
-    return GEARMAN_SUCCESS;
-  }
-
-  return GEARMAN_INVALID_ARGUMENT;
+      gearman_error(worker->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
+    }
+
+    return GEARMAN_INVALID_ARGUMENT;
+  }
+
+  _worker_function_st *function= make(worker->universal._namespace, function_name, function_length, function_arg, context);
+  if (function == NULL)
+  {
+    gearman_perror(worker->universal, "_worker_function_st::new()");
+    return GEARMAN_MEMORY_ALLOCATION_FAILURE;
+  }
+
+  gearman_return_t ret;
+  if (timeout > 0)
+  {
+    char timeout_buffer[11];
+    snprintf(timeout_buffer, sizeof(timeout_buffer), "%u", timeout);
+    args[0]= function->name();
+    args_size[0]= function->length() + 1;
+    args[1]= timeout_buffer;
+    args_size[1]= strlen(timeout_buffer);
+    ret= gearman_packet_create_args(worker->universal, function->packet(),
+                                    GEARMAN_MAGIC_REQUEST,
+                                    GEARMAN_COMMAND_CAN_DO_TIMEOUT,
+                                    args, args_size, 2);
+  }
+  else
+  {
+    args[0]= function->name();
+    args_size[0]= function->length();
+    ret= gearman_packet_create_args(worker->universal, function->packet(),
+                                    GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CAN_DO,
+                                    args, args_size, 1);
+  }
+
+  if (gearman_failed(ret))
+  {
+    delete function;
+
+    return ret;
+  }
+
+  if (worker->function_list)
+  {
+    worker->function_list->prev= function;
+  }
+
+  function->next= worker->function_list;
+  function->prev= NULL;
+  worker->function_list= function;
+  worker->function_count++;
+
+  worker->options.change= true;
+
+  return GEARMAN_SUCCESS;
 }
 
 static void _worker_function_free(Worker* worker,
@@ -1354,8 +1362,16 @@
 {
   if (worker_shell and worker_shell->impl())
   {
+    Worker* worker= worker_shell->impl();
     gearman_string_t option= { option_arg, option_arg_size };
-    return gearman_request_option(worker_shell->impl()->universal, option);
+
+    if (gearman_success(gearman_server_option(worker->universal, option)))
+    {
+      if (gearman_request_option(worker->universal, option))
+      {
+        return true;
+      }
+    }
   }
 
   return false;

=== modified file 'libgearman/worker.hpp'
--- libgearman/worker.hpp	2013-07-06 00:33:10 +0000
+++ libgearman/worker.hpp	2013-07-11 21:18:03 +0000
@@ -43,6 +43,15 @@
 
 #include <stdexcept>
 
+namespace {
+
+inline void all_worker_PRINTER(const char *line, gearman_verbose_t verbose, void*)
+{
+  fprintf(stderr, "%s:%d WORKER %s(%s)\n", __FILE__, __LINE__, gearman_verbose_name(verbose), line);
+}
+
+}
+
 namespace org { namespace gearmand { namespace libgearman {
 
 class Worker {
@@ -55,6 +64,7 @@
     {
       throw std::runtime_error("gearman_worker_create() failed");
     }
+    enable_logging();
 
     enable_ssl();
   }
@@ -67,6 +77,8 @@
     {
       throw std::runtime_error("gearman_worker_create() failed");
     }
+    enable_logging();
+
     gearman_worker_add_server(_worker, "localhost", arg);
 
     enable_ssl();
@@ -87,6 +99,15 @@
     gearman_worker_free(_worker);
   }
 
+  void enable_logging()
+  { 
+    if (getenv("YATL_WORKER_LOGGING"))
+    {
+      gearman_log_fn *func= all_worker_PRINTER;
+      gearman_worker_set_log_fn(_worker, func, NULL, GEARMAN_VERBOSE_ERROR);
+    }
+  }
+
   void enable_ssl()
   { 
     if (getenv("GEARMAND_CA_CERTIFICATE"))

=== modified file 'tests/libgearman-1.0/gearman_execute_partition.cc'
--- tests/libgearman-1.0/gearman_execute_partition.cc	2013-07-10 10:54:09 +0000
+++ tests/libgearman-1.0/gearman_execute_partition.cc	2013-07-11 21:18:03 +0000
@@ -55,7 +55,7 @@
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
-#define WORKER_FUNCTION_NAME "client_test"
+#define WORKER_FUNCTION_NAME "partition_client_test"
 #define WORKER_SPLIT_FUNCTION_NAME "split_worker"
 
 test_return_t partition_SETUP(void *object)
@@ -105,7 +105,7 @@
 
   // Test client as NULL
   gearman_task_st *task= gearman_execute_by_partition(NULL,
-                                                      test_literal_param("split_worker"),
+                                                      test_literal_param(WORKER_SPLIT_FUNCTION_NAME),
                                                       test_literal_param(WORKER_FUNCTION_NAME),
                                                       NULL, 0,  // unique
                                                       NULL,
@@ -141,7 +141,7 @@
   gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt"));
 
   gearman_task_st *task= gearman_execute_by_partition(client,
-                                                      test_literal_param("split_worker"),
+                                                      test_literal_param(WORKER_SPLIT_FUNCTION_NAME),
                                                       test_literal_param(WORKER_FUNCTION_NAME),
                                                       NULL, 0,  // unique
                                                       NULL,
@@ -151,7 +151,7 @@
   gearman_result_st *result= gearman_task_result(task);
   ASSERT_TRUE(result);
   const char *value= gearman_result_value(result);
-  test_truth(value);
+  ASSERT_TRUE(value);
   ASSERT_EQ(18UL, gearman_result_size(result));
 
   gearman_task_free(task);
@@ -171,14 +171,14 @@
   gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt mapper_fail"));
 
   gearman_task_st *task= gearman_execute_by_partition(client,
-                                                      test_literal_param("split_worker"),
+                                                      test_literal_param(WORKER_SPLIT_FUNCTION_NAME),
                                                       gearman_string_param_cstr(worker_function),
                                                       NULL, 0,  // unique
                                                       NULL,
                                                       &workload, 0);
   test_true(task);
 
-  ASSERT_EQ(GEARMAN_WORK_FAIL, gearman_task_return(task));
+  ASSERT_EQ(GEARMAN_WORK_EXCEPTION, gearman_task_return(task));
 
   gearman_task_free(task);
   gearman_client_task_free_all(client);
@@ -196,7 +196,7 @@
   gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt fail"));
 
   gearman_task_st *task= gearman_execute_by_partition(client,
-                                                      test_literal_param("split_worker"),
+                                                      test_literal_param(WORKER_SPLIT_FUNCTION_NAME),
                                                       gearman_string_param_cstr(worker_function),
                                                       NULL, 0,  // unique
                                                       NULL,
@@ -224,7 +224,7 @@
   gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt"));
 
   gearman_task_st *task= gearman_execute(client,
-                                         test_literal_param("split_worker"),
+                                         test_literal_param(WORKER_SPLIT_FUNCTION_NAME),
                                          NULL, 0,  // unique
                                          NULL,
                                          &workload, 0);

=== modified file 'tests/protocol.cc'
--- tests/protocol.cc	2013-06-27 22:23:44 +0000
+++ tests/protocol.cc	2013-07-11 21:18:03 +0000
@@ -70,6 +70,7 @@
 
   gearman_universal_st universal;
   gearman_set_log_fn(universal, error_logger, NULL, GEARMAN_VERBOSE_ERROR);
+  universal.ssl(libtest::is_ssl());
 
   gearman_packet_st message;
 
@@ -111,6 +112,7 @@
 
   gearman_universal_st universal;
   gearman_set_log_fn(universal, error_logger, NULL, GEARMAN_VERBOSE_ERROR);
+  universal.ssl(libtest::is_ssl());
 
   gearman_packet_st message;
 
@@ -152,6 +154,7 @@
 
   gearman_universal_st universal;
   gearman_set_log_fn(universal, error_logger, NULL, GEARMAN_VERBOSE_ERROR);
+  universal.ssl(libtest::is_ssl());
 
   gearman_packet_st message;
 

=== modified file 'tests/start_worker.cc'
--- tests/start_worker.cc	2013-05-07 09:50:42 +0000
+++ tests/start_worker.cc	2013-07-11 21:18:03 +0000
@@ -165,16 +165,9 @@
     gearman_worker_set_namespace(&worker, context->namespace_key.c_str(), context->namespace_key.length());
   }
 
-  // Check for a working server by "asking" it for an option
+  // Set worker id
   {
-    size_t count= 5;
-    bool success= false;
-    while (--count and success == false)
-    {
-      success= gearman_worker_set_server_option(&worker, test_literal_param("exceptions"));
-    }
-
-    if (success == false)
+    if (gearman_failed(gearman_worker_set_identifier(&worker, gearman_literal_param("start_worker"))))
     {
       Out << "gearman_worker_set_server_option() failed";
       context->fail();
@@ -182,6 +175,14 @@
     }
   }
 
+  // Check for a working server by pinging it with echo
+  if (gearman_failed(gearman_worker_echo(&worker, gearman_literal_param("start_worker"))))
+  {
+    Out << "gearman_worker_set_server_option() failed";
+    context->fail();
+    return;
+  }
+
   if (gearman_failed(gearman_worker_define_function(&worker,
                                                     context->function_name.c_str(), context->function_name.length(),
                                                     context->worker_fn,

=== modified file 'tests/workers/v2/split.cc'
--- tests/workers/v2/split.cc	2012-10-29 20:00:10 +0000
+++ tests/workers/v2/split.cc	2013-07-11 21:18:03 +0000
@@ -62,16 +62,16 @@
   {
     if (int(workload[x]) == 0 or int(workload[x]) == int(' '))
     {
-      if ((workload +x -chunk_begin) == 11 and not memcmp(chunk_begin, test_literal_param("mapper_fail")))
+      if ((workload +x -chunk_begin) == 11 and memcmp(chunk_begin, test_literal_param("mapper_fail") == 0))
       {
-        return GEARMAN_FAIL;
+        return gearman_job_send_exception(job, test_literal_param("Error occured on purpose"));
       }
 
       // NULL Chunk
       gearman_return_t rc= gearman_job_send_data(job, chunk_begin, workload +x -chunk_begin);
       if (gearman_failed(rc))
       {
-        return GEARMAN_FAIL;
+        return gearman_job_send_exception(job, test_literal_param("gearman_job_send_data() failed"));
       }
 
       chunk_begin= workload +x +1;
@@ -82,16 +82,15 @@
   {
     if ((size_t(workload +workload_size) -size_t(chunk_begin) ) == 11 and not memcmp(chunk_begin, test_literal_param("mapper_fail")))
     {
-      return GEARMAN_FAIL;
+      return gearman_job_send_exception(job, test_literal_param("Error occured on purpose"));
     }
 
     gearman_return_t rc= gearman_job_send_data(job, chunk_begin, size_t(workload +workload_size) -size_t(chunk_begin));
     if (gearman_failed(rc))
     {
-      return GEARMAN_FAIL;
+      return gearman_job_send_exception(job, test_literal_param("gearman_job_send_data() failed"));
     }
   }
 
   return GEARMAN_SUCCESS;
 }
-