Merge in packet update.

libgearman/client.cc

@@ -453,7 +453,7 @@ gearman_task_st *gearman_client_execute(gearman_client_st *client,
   if (not function_str or not function_length)
   {
     errno= EINVAL;
-    gearman_perror(&client->universal, "gearman_function_st was NULL");
+    gearman_perror(client->universal, "gearman_function_st was NULL");
     return NULL;
   }
   assert(function_str and function_length);
@@ -544,7 +544,7 @@ gearman_task_st *gearman_client_execute_reduce(gearman_client_st *client,
   if (not function_str or not function_length)
   {
     errno= EINVAL;
-    gearman_perror(&client->universal, "gearman_function_st was NULL");
+    gearman_perror(client->universal, "gearman_function_st was NULL");
     return NULL;
   }
   assert(function_str and function_length);

libgearman/connection.cc

@@ -41,10 +41,10 @@
  * @brief Connection Definitions
  */
 
-#include <config.h>
-
 #include <libgearman/common.h>
+
 #include <libgearman/connection.h>
+#include <libgearman/packet.hpp>
 #include <libgearman/universal.hpp>
 
 #include <assert.h>
@@ -77,7 +77,7 @@ static gearman_return_t gearman_connection_set_option(gearman_connection_st *con
  * @{
  */
 
-gearman_connection_st *gearman_connection_create(gearman_universal_st *gearman,
+gearman_connection_st *gearman_connection_create(gearman_universal_st &universal,
                                                  gearman_connection_st *connection,
                                                  gearman_connection_options_t *options)
 {
@@ -86,7 +86,7 @@ gearman_connection_st *gearman_connection_create(gearman_universal_st *gearman,
     connection= new (std::nothrow) gearman_connection_st;
     if (connection == NULL)
     {
-      gearman_perror(gearman, "gearman_connection_st new");
+      gearman_perror(universal, "gearman_connection_st new");
       return NULL;
     }
 
@@ -127,14 +127,14 @@ gearman_connection_st *gearman_connection_create(gearman_universal_st *gearman,
   connection->recv_buffer_size= 0;
   connection->recv_data_size= 0;
   connection->recv_data_offset= 0;
-  connection->universal= gearman;
+  connection->universal= &universal;
 
-  if (gearman->con_list != NULL)
-    gearman->con_list->prev= connection;
-  connection->next= gearman->con_list;
+  if (universal.con_list != NULL)
+    universal.con_list->prev= connection;
+  connection->next= universal.con_list;
   connection->prev= NULL;
-  gearman->con_list= connection;
-  gearman->con_count++;
+  universal.con_list= connection;
+  universal.con_count++;
 
   connection->context= NULL;
   connection->addrinfo= NULL;
@@ -150,8 +150,8 @@ gearman_connection_st *gearman_connection_create(gearman_universal_st *gearman,
 gearman_connection_st *gearman_connection_create_args(gearman_universal_st *gearman, gearman_connection_st *connection,
                                                       const char *host, in_port_t port)
 {
-  connection= gearman_connection_create(gearman, connection, NULL);
-  if (connection == NULL)
+  connection= gearman_connection_create(*gearman, connection, NULL);
+  if (not connection)
     return NULL;
 
   gearman_connection_set_host(connection, host, port);
@@ -162,9 +162,9 @@ gearman_connection_st *gearman_connection_create_args(gearman_universal_st *gear
 gearman_connection_st *gearman_connection_clone(gearman_universal_st *gearman, gearman_connection_st *connection,
                                                 const gearman_connection_st *from)
 {
-  connection= gearman_connection_create(gearman, connection, NULL);
+  connection= gearman_connection_create(*gearman, connection, NULL);
 
-  if (from == NULL || connection == NULL)
+  if (not from or  not connection)
     return connection;
 
   connection->options.ready= from->options.ready;
@@ -273,14 +273,14 @@ void gearman_connection_close(gearman_connection_st *connection)
     /* in case of death shutdown to avoid blocking at close() */
     if (shutdown(connection->fd, SHUT_RDWR) == SOCKET_ERROR && get_socket_errno() != ENOTCONN)
     {
-      gearman_perror(connection->universal, "shutdown");
+      gearman_perror(*connection->universal, "shutdown");
       assert(errno != ENOTSOCK);
       return;
     }
 
     if (closesocket(connection->fd) == SOCKET_ERROR)
     {
-      gearman_perror(connection->universal, "close");
+      gearman_perror(*connection->universal, "close");
     }
   }
 
@@ -536,7 +536,7 @@ gearman_return_t gearman_connection_flush(gearman_connection_st *connection)
       if (connection->fd == -1)
       {
         connection->state= GEARMAN_CON_UNIVERSAL_ADDRINFO;
-        gearman_perror(connection->universal, "socket");
+        gearman_perror(*connection->universal, "socket");
         return GEARMAN_ERRNO;
       }
 
@@ -576,7 +576,7 @@ gearman_return_t gearman_connection_flush(gearman_connection_st *connection)
           break;
         }
 
-        gearman_perror(connection->universal, "connect");
+        gearman_perror(*connection->universal, "connect");
         gearman_connection_close(connection);
         return GEARMAN_ERRNO;
       }
@@ -704,13 +704,13 @@ gearman_return_t gearman_connection_flush(gearman_connection_st *connection)
           {
             if (not (connection->options.ignore_lost_connection))
             {
-              gearman_perror(connection->universal, "lost connection to server during send");
+              gearman_perror(*connection->universal, "lost connection to server during send");
             }
             gearman_connection_close(connection);
             return GEARMAN_LOST_CONNECTION;
           }
 
-          gearman_perror(connection->universal, "send");
+          gearman_perror(*connection->universal, "send");
           gearman_connection_close(connection);
           return GEARMAN_ERRNO;
         }
@@ -756,8 +756,8 @@ gearman_packet_st *gearman_connection_recv(gearman_connection_st *connection,
       return NULL;
     }
 
-    connection->recv_packet= gearman_packet_create(connection->universal, packet);
-    if (connection->recv_packet == NULL)
+    connection->recv_packet= gearman_packet_create(*connection->universal, packet);
+    if (not connection->recv_packet)
     {
       *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
       return NULL;
@@ -957,15 +957,15 @@ size_t gearman_connection_read(gearman_connection_st *connection, void *data, si
       }
       else if (errno == EPIPE || errno == ECONNRESET || errno == EHOSTDOWN)
       {
-        if (! (connection->options.ignore_lost_connection))
+        if (not (connection->options.ignore_lost_connection))
         {
-          gearman_perror(connection->universal, "lost connection to server during read");
+          gearman_perror(*connection->universal, "lost connection to server during read");
         }
         *ret_ptr= GEARMAN_LOST_CONNECTION;
       }
       else
       {
-        gearman_perror(connection->universal, "read");
+        gearman_perror(*connection->universal, "read");
         *ret_ptr= GEARMAN_ERRNO;
       }
 
@@ -1016,7 +1016,7 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
                   socklen_t(sizeof(int)));
   if (ret == -1 && errno != EOPNOTSUPP)
   {
-    gearman_perror(connection->universal, "setsockopt(TCP_NODELAY)");
+    gearman_perror(*connection->universal, "setsockopt(TCP_NODELAY)");
     return GEARMAN_ERRNO;
   }
 
@@ -1026,7 +1026,7 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
                   socklen_t(sizeof(struct linger)));
   if (ret == -1)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_LINGER)");
+    gearman_perror(*connection->universal, "setsockopt(SO_LINGER)");
     return GEARMAN_ERRNO;
   }
 
@@ -1036,7 +1036,7 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
                   socklen_t(sizeof(struct timeval)));
   if (ret == -1 && errno != ENOPROTOOPT)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_SNDTIMEO)");
+    gearman_perror(*connection->universal, "setsockopt(SO_SNDTIMEO)");
     return GEARMAN_ERRNO;
   }
 
@@ -1044,7 +1044,7 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
                   socklen_t(sizeof(struct timeval)));
   if (ret == -1 && errno != ENOPROTOOPT)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_RCVTIMEO)");
+    gearman_perror(*connection->universal, "setsockopt(SO_RCVTIMEO)");
     return GEARMAN_ERRNO;
   }
 
@@ -1052,7 +1052,7 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
   ret= setsockopt(connection->fd, SOL_SOCKET, SO_SNDBUF, &ret, socklen_t(sizeof(int)));
   if (ret == -1)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_SNDBUF)");
+    gearman_perror(*connection->universal, "setsockopt(SO_SNDBUF)");
     return GEARMAN_ERRNO;
   }
 
@@ -1064,7 +1064,7 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
     // This is not considered a fatal error 
     if (ret == -1)
     {
-      gearman_perror(connection->universal, "setsockopt(SO_NOSIGPIPE)");
+      gearman_perror(*connection->universal, "setsockopt(SO_NOSIGPIPE)");
     }
   }
 #endif
@@ -1073,21 +1073,21 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
   ret= setsockopt(connection->fd, SOL_SOCKET, SO_RCVBUF, &ret, socklen_t(sizeof(int)));
   if (ret == -1)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_RCVBUF)");
+    gearman_perror(*connection->universal, "setsockopt(SO_RCVBUF)");
     return GEARMAN_ERRNO;
   }
 
   ret= fcntl(connection->fd, F_GETFL, 0);
   if (ret == -1)
   {
-    gearman_perror(connection->universal, "fcntl(F_GETFL)");
+    gearman_perror(*connection->universal, "fcntl(F_GETFL)");
     return GEARMAN_ERRNO;
   }
 
   ret= fcntl(connection->fd, F_SETFL, ret | O_NONBLOCK);
   if (ret == -1)
   {
-    gearman_perror(connection->universal, "fcntl(F_SETFL)");
+    gearman_perror(*connection->universal, "fcntl(F_SETFL)");
     return GEARMAN_ERRNO;
   }
 

libgearman/connection.h

@@ -86,22 +86,6 @@ enum gearman_con_universal_t {
 
 #ifdef GEARMAN_CORE
 
-/**
- * Initialize a connection structure. Always check the return value even if
- * passing in a pre-allocated structure. Some other initialization may have
- * failed.
- *
- * @param[in] gearman Structure previously initialized with gearman_create() or
- *  gearman_clone().
- * @param[in] connection Caller allocated structure, or NULL to allocate one.
- * @return On success, a pointer to the (possibly allocated) structure. On
- *  failure this will be NULL.
- */
-GEARMAN_INTERNAL_API
-gearman_connection_st *gearman_connection_create(gearman_universal_st *gearman,
-                                                 gearman_connection_st *connection,
-                                                 gearman_connection_options_t *options);
-
 /**
  * Create a connection structure with the given host and port.
  *

libgearman/connection.hpp

@@ -38,6 +38,8 @@
 
 #pragma once
 
+#include <libgearman/connection.h>
+
 struct gearman_connection_st
 {
   struct {
@@ -77,3 +79,14 @@ struct gearman_connection_st
   char send_buffer[GEARMAN_SEND_BUFFER_SIZE];
   char recv_buffer[GEARMAN_RECV_BUFFER_SIZE];
 };
+
+/**
+ * Initialize a connection structure. Always check the return value even if
+ * passing in a pre-allocated structure. Some other initialization may have
+ * failed.
+ */
+
+GEARMAN_INTERNAL_API
+gearman_connection_st *gearman_connection_create(gearman_universal_st &universal,
+                                                 gearman_connection_st *connection,
+                                                 gearman_connection_options_t *options);

libgearman/include.am

@@ -44,6 +44,7 @@ noinst_HEADERS+= \
 		 libgearman/common.h \
 		 libgearman/connection.hpp \
 		 libgearman/log.h \
+		 libgearman/packet.hpp \
 		 libgearman/result.hpp \
 		 libgearman/strcommand.h \
 		 libgearman/unique.h \

libgearman/packet.cc

@@ -42,7 +42,10 @@
  */
 
 #include <libgearman/common.h>
+#include <libgearman/universal.hpp>
 #include <libgearman/command.h>
+#include <libgearman/packet.hpp>
+
 #include <cassert>
 #include <cerrno>
 #include <cstdlib>
@@ -96,7 +99,7 @@ inline static gearman_return_t packet_create_arg(gearman_packet_st *packet,
     void *new_args= realloc(packet->args, packet->args_size + arg_size);
     if (not new_args)
     {
-      gearman_perror(packet->universal, "packet realloc");
+      gearman_perror(*packet->universal, "packet realloc");
       return GEARMAN_MEMORY_ALLOCATION_FAILURE;
     }
 
@@ -138,15 +141,15 @@ inline static gearman_return_t packet_create_arg(gearman_packet_st *packet,
  * Public Definitions
  */
 
-gearman_packet_st *gearman_packet_create(gearman_universal_st *gearman,
+gearman_packet_st *gearman_packet_create(gearman_universal_st &universal,
                                          gearman_packet_st *packet)
 {
-  if (packet == NULL)
+  if (not packet)
   {
     packet= new (std::nothrow) gearman_packet_st;
     if (packet == NULL)
     {
-      gearman_perror(gearman, "gearman_packet_st malloc");
+      gearman_perror(universal, "gearman_packet_st malloc");
       errno= ENOMEM;
       return NULL;
     }
@@ -165,16 +168,16 @@ gearman_packet_st *gearman_packet_create(gearman_universal_st *gearman,
   packet->argc= 0;
   packet->args_size= 0;
   packet->data_size= 0;
-  packet->universal= gearman;
+  packet->universal= &universal;
 
-  if (not (gearman->options.dont_track_packets))
+  if (not (universal.options.dont_track_packets))
   {
-    if (gearman->packet_list != NULL)
-      gearman->packet_list->prev= packet;
-    packet->next= gearman->packet_list;
+    if (universal.packet_list != NULL)
+      universal.packet_list->prev= packet;
+    packet->next= universal.packet_list;
     packet->prev= NULL;
-    gearman->packet_list= packet;
-    gearman->packet_count++;
+    universal.packet_list= packet;
+    universal.packet_count++;
   }
 
   packet->args= NULL;
@@ -197,7 +200,7 @@ gearman_return_t gearman_packet_create_args(gearman_universal_st *gearman,
                                             const size_t args_size[],
                                             size_t args_count)
 {
-  packet= gearman_packet_create(gearman, packet);
+  packet= gearman_packet_create(*gearman, packet);
   if (not packet)
   {
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;

libgearman/packet.h

@@ -107,20 +107,6 @@ typedef size_t (gearman_packet_unpack_fn)(gearman_packet_st *packet,
 extern GEARMAN_INTERNAL_API
 gearman_command_info_st gearman_command_info_list[GEARMAN_COMMAND_MAX];
 
-
-/**
- * Initialize a packet structure.
- *
- * @param[in] gearman Structure previously initialized with gearman_create() or
- *  gearman_clone().
- * @param[in] packet Caller allocated structure, or NULL to allocate one.
- * @return On success, a pointer to the (possibly allocated) structure. On
- *  failure this will be NULL.
- */
-GEARMAN_INTERNAL_API
-gearman_packet_st *gearman_packet_create(gearman_universal_st *gearman,
-                                         gearman_packet_st *packet);
-
 /**
  * Free a packet structure.
  *

libgearman/packet.hpp

@@ -0,0 +1,42 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Gearmand client and server library.
+ *
+ *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#pragma once
+
+GEARMAN_LOCAL
+gearman_packet_st *gearman_packet_create(gearman_universal_st &, gearman_packet_st *packet);

libgearman/task.cc

@@ -42,6 +42,7 @@
  */
 
 #include <libgearman/common.h>
+#include <libgearman/universal.hpp>
 #include <libgearman/connection.h>
 #include <libgearman/packet.h>
 
@@ -62,7 +63,7 @@ gearman_task_st *gearman_task_internal_create(gearman_client_st *client, gearman
     task= new (std::nothrow) gearman_task_st;
     if (task == NULL)
     {
-      gearman_perror(&client->universal, "gearman_task_st new");
+      gearman_perror(client->universal, "gearman_task_st new");
       return NULL;
     }
 

libgearman/universal.cc

@@ -178,7 +178,7 @@ gearman_return_t gearman_wait(gearman_universal_st *universal)
     pfds= static_cast<pollfd*>(realloc(universal->pfds, universal->con_count * sizeof(struct pollfd)));
     if (pfds == NULL)
     {
-      gearman_perror(universal, "pollfd realloc");
+      gearman_perror(*universal, "pollfd realloc");
       return GEARMAN_MEMORY_ALLOCATION_FAILURE;
     }
 
@@ -216,7 +216,7 @@ gearman_return_t gearman_wait(gearman_universal_st *universal)
       if (errno == EINTR)
         continue;
 
-      gearman_perror(universal, "poll");
+      gearman_perror(*universal, "poll");
       return GEARMAN_ERRNO;
     }
 
@@ -469,24 +469,24 @@ void gearman_universal_set_error(gearman_universal_st *universal,
   }
 }
 
-void gearman_universal_set_perror(const char *position, gearman_universal_st *universal, const char *message)
+void gearman_universal_set_perror(const char *position, gearman_universal_st &self, const char *message)
 {
-  universal->error.rc= GEARMAN_ERRNO;
-  universal->error.last_errno= errno;
+  self.error.rc= GEARMAN_ERRNO;
+  self.error.last_errno= errno;
 
   const char *errmsg_ptr;
   char errmsg[GEARMAN_MAX_ERROR_SIZE]; 
   errmsg[0]= 0; 
 
 #ifdef STRERROR_R_CHAR_P
-  errmsg_ptr= strerror_r(universal->error.last_errno, errmsg, sizeof(errmsg));
+  errmsg_ptr= strerror_r(self.error.last_errno, errmsg, sizeof(errmsg));
 #else
-  strerror_r(universal->error.last_errno, errmsg, sizeof(errmsg));
+  strerror_r(self.error.last_errno, errmsg, sizeof(errmsg));
   errmsg_ptr= errmsg;
 #endif
 
   char final[GEARMAN_MAX_ERROR_SIZE];
   snprintf(final, sizeof(final), "%s(%s)", message, errmsg_ptr);
 
-  gearman_universal_set_error(universal, GEARMAN_ERRNO, position, final);
+  gearman_universal_set_error(&self, GEARMAN_ERRNO, position, final);
 }