Merge lp:~brianaker/gearmand/remove-function into lp:gearmand

[Brian Aker]

=== modified file 'libgearman-server/constants.h'
--- libgearman-server/constants.h	2013-05-07 11:07:18 +0000
+++ libgearman-server/constants.h	2013-07-07 00:24:31 +0000
@@ -137,6 +137,7 @@
                                                    void *add_context);
 
 typedef gearmand_error_t (gearmand_connection_add_fn)(gearman_server_con_st *con);
+typedef gearmand_error_t (gearmand_connection_remove_fn)(gearman_server_con_st *con);
 
 typedef void (gearman_log_server_fn)(const char *line, gearmand_verbose_t verbose,
                                      struct gearmand_thread_st *context);

=== modified file 'libgearman-server/gearmand.cc'
--- libgearman-server/gearmand.cc	2013-07-06 10:56:43 +0000
+++ libgearman-server/gearmand.cc	2013-07-07 00:24:31 +0000
@@ -316,13 +316,15 @@
 }
 
 gearmand_error_t gearmand_port_add(gearmand_st *gearmand, const char *port,
-                                   gearmand_connection_add_fn *function)
+                                   gearmand_connection_add_fn *function,
+                                   gearmand_connection_remove_fn* remove_)
 {
   assert(gearmand);
   gearmand->_port_list.resize(gearmand->_port_list.size() +1);
 
   strncpy(gearmand->_port_list.back().port, port, NI_MAXSERV);
-  gearmand->_port_list.back().add_fn= function;
+  gearmand->_port_list.back().add_fn(function);
+  gearmand->_port_list.back().remove_fn(remove_);
 
   return GEARMAND_SUCCESS;
 }
@@ -885,7 +887,7 @@
 
   gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "Accepted connection from %s:%s", host, port_str);
 
-  gearmand_error_t ret= gearmand_con_create(Gearmand(), fd, host, port_str, port->add_fn);
+  gearmand_error_t ret= gearmand_con_create(Gearmand(), fd, host, port_str, port);
   if (ret == GEARMAND_MEMORY_ALLOCATION_FAILURE)
   {
     gearmand_sockfd_close(fd);

=== modified file 'libgearman-server/gearmand.h'
--- libgearman-server/gearmand.h	2013-03-09 22:24:08 +0000
+++ libgearman-server/gearmand.h	2013-07-07 00:24:31 +0000
@@ -139,7 +139,8 @@
 GEARMAN_API
 gearmand_error_t gearmand_port_add(gearmand_st *gearmand,
                                    const char *port,
-                                   gearmand_connection_add_fn *function);
+                                   gearmand_connection_add_fn*,
+                                   gearmand_connection_remove_fn*);
 
 /**
  * Run the server instance.

=== modified file 'libgearman-server/gearmand_con.cc'
--- libgearman-server/gearmand_con.cc	2013-07-06 09:37:11 +0000
+++ libgearman-server/gearmand_con.cc	2013-07-07 00:24:31 +0000
@@ -53,6 +53,11 @@
  * Private declarations
  */
 
+void gearmand_con_st::close_socket()
+{
+  gearmand_sockfd_close(fd);
+}
+
 /**
  * @addtogroup gearmand_con_private Private Gearmand Connection Functions
  * @ingroup gearmand_con
@@ -70,19 +75,18 @@
 
   if (dcon->server_con == NULL)
   {
-    gearmand_sockfd_close(dcon->fd);
-
+    dcon->close_socket();
     return ret;
   }
 
-  if (dcon->add_fn)
+  if (dcon->port_st())
   {
-    ret= (*dcon->add_fn)(dcon->server_con);
+    ret= dcon->add_fn(dcon->server_con);
     if (gearmand_failed(ret))
     {
       gearman_server_con_free(dcon->server_con);
 
-      gearmand_sockfd_close(dcon->fd);
+      dcon->close_socket();
 
       return ret;
     }
@@ -93,6 +97,20 @@
   return GEARMAND_SUCCESS;
 }
 
+gearmand_error_t gearmand_con_st::add_fn(gearman_server_con_st* con_st_)
+{
+  assert(_port_st);
+  assert(con_st_);
+  return _port_st->add_fn(con_st_);
+}
+
+gearmand_error_t gearmand_con_st::remove_fn(gearman_server_con_st* con_st_)
+{
+  assert(_port_st);
+  assert(con_st_);
+  return _port_st->remove_fn(con_st_);
+}
+
 void _con_ready(int, short events, void *arg)
 {
   gearmand_con_st *dcon= (gearmand_con_st *)(arg);
@@ -515,9 +533,9 @@
   return server_job;
 }
 
-gearmand_error_t gearmand_con_create(gearmand_st *gearmand, int fd,
+gearmand_error_t gearmand_con_create(gearmand_st *gearmand, int& fd,
                                      const char *host, const char *port,
-                                     gearmand_connection_add_fn *add_fn)
+                                     struct gearmand_port_st* port_st_)
 {
   gearmand_con_st *dcon;
 
@@ -545,12 +563,11 @@
   dcon->next= NULL;
   dcon->prev= NULL;
   dcon->server_con= NULL;
-  dcon->add_fn= NULL;
   strncpy(dcon->host, host, NI_MAXHOST);
   dcon->host[NI_MAXHOST -1]= 0;
   strncpy(dcon->port, port, NI_MAXSERV);
   dcon->port[NI_MAXSERV -1]= 0;
-  dcon->add_fn= add_fn;
+  dcon->_port_st= port_st_;
 
   /* If we are not threaded, just add the connection now. */
   if (gearmand->threads == 0)
@@ -660,7 +677,7 @@
 
   GEARMAND_LIST__DEL(dcon->thread->dcon, dcon);
 
-  gearmand_sockfd_close(dcon->fd);
+  dcon->close_socket();
 
   if (Gearmand()->free_dcon_count < GEARMAND_MAX_FREE_SERVER_CON)
   {

=== modified file 'libgearman-server/gearmand_con.h'
--- libgearman-server/gearmand_con.h	2013-03-21 07:40:50 +0000
+++ libgearman-server/gearmand_con.h	2013-07-07 00:24:31 +0000
@@ -74,9 +74,9 @@
  * @return Pointer to an allocated gearmand structure.
  */
 GEARMAN_API
-gearmand_error_t gearmand_con_create(gearmand_st *gearmand, int fd,
-                                     const char *host, const char *port,
-                                     gearmand_connection_add_fn *add_fn);
+gearmand_error_t gearmand_con_create(gearmand_st *gearmand, int&,
+                                     const char *host, const char*,
+                                     struct gearmand_port_st*);
 
 bool gearman_server_job_cancel(gearman_server_st& server,
                                const char *job_handle,

=== modified file 'libgearman-server/gearmand_thread.cc'
--- libgearman-server/gearmand_thread.cc	2013-07-06 10:56:43 +0000
+++ libgearman-server/gearmand_thread.cc	2013-07-07 00:24:31 +0000
@@ -339,7 +339,7 @@
     {
       gearmand_con_st* dcon= thread->dcon_add_list;
       thread->dcon_add_list= dcon->next;
-      gearmand_sockfd_close(dcon->fd);
+      dcon->close_socket();
       delete dcon;
     }
 

=== modified file 'libgearman-server/io.cc'
--- libgearman-server/io.cc	2013-07-06 11:00:30 +0000
+++ libgearman-server/io.cc	2013-07-07 00:24:31 +0000
@@ -74,6 +74,7 @@
     if (connection->root and connection->root->_ssl)
     {
       CyaSSL_shutdown(connection->root->_ssl);
+      CyaSSL_free(connection->root->_ssl);
       connection->root->_ssl= NULL;
     }
 #endif

=== modified file 'libgearman-server/plugins/protocol/gear/protocol.cc'
--- libgearman-server/plugins/protocol/gear/protocol.cc	2013-07-06 20:11:54 +0000
+++ libgearman-server/plugins/protocol/gear/protocol.cc	2013-07-07 00:24:31 +0000
@@ -314,6 +314,11 @@
 
 static Geartext gear_context;
 
+static gearmand_error_t _gear_con_remove(gearman_server_con_st*)
+{
+  return GEARMAND_SUCCESS;
+}
+
 static gearmand_error_t _gear_con_add(gearman_server_con_st *connection)
 {
 #if defined(HAVE_CYASSL) && HAVE_CYASSL
@@ -436,7 +441,7 @@
   }
 #endif
 
-  rc= gearmand_port_add(gearmand, _port.c_str(), _gear_con_add);
+  rc= gearmand_port_add(gearmand, _port.c_str(), _gear_con_add, _gear_con_remove);
 
   return rc;
 }

=== modified file 'libgearman-server/plugins/protocol/http/protocol.cc'
--- libgearman-server/plugins/protocol/http/protocol.cc	2013-05-12 01:03:50 +0000
+++ libgearman-server/plugins/protocol/http/protocol.cc	2013-07-07 00:24:31 +0000
@@ -633,6 +633,11 @@
   std::vector<char> content;
 };
 
+static gearmand_error_t _http_con_remove(gearman_server_con_st*)
+{
+  return GEARMAND_SUCCESS;
+}
+
 static gearmand_error_t _http_con_add(gearman_server_con_st *connection)
 {
   gearmand_info("HTTP connection made");
@@ -666,7 +671,7 @@
 gearmand_error_t HTTP::start(gearmand_st *gearmand)
 {
   gearmand_info("Initializing HTTP");
-  return gearmand_port_add(gearmand, _port.c_str(), _http_con_add);
+  return gearmand_port_add(gearmand, _port.c_str(), _http_con_add, _http_con_remove);
 }
 
 } // namespace protocol

=== modified file 'libgearman-server/struct/gearmand_con.h'
--- libgearman-server/struct/gearmand_con.h	2011-12-08 17:53:07 +0000
+++ libgearman-server/struct/gearmand_con.h	2013-07-07 00:24:31 +0000
@@ -45,9 +45,20 @@
   gearmand_con_st *next;
   gearmand_con_st *prev;
   gearman_server_con_st *server_con;
-  gearmand_connection_add_fn *add_fn;
   struct event event;
   char host[NI_MAXHOST];
   char port[NI_MAXSERV];
+  struct gearmand_port_st* _port_st;
+
+  struct gearmand_port_st* port_st()
+  {
+    return _port_st;
+  }
+
+  gearmand_error_t add_fn(gearman_server_con_st*);
+
+  gearmand_error_t remove_fn(gearman_server_con_st*);
+
+  void close_socket();
 };
 

=== modified file 'libgearman-server/struct/io.h'
--- libgearman-server/struct/io.h	2013-07-06 09:37:11 +0000
+++ libgearman-server/struct/io.h	2013-07-07 00:24:31 +0000
@@ -97,6 +97,8 @@
 
   const char* host() const;
   const char* port() const;
+
+  void close_socket();
 };
 
 namespace gearmand { namespace protocol {class Context; } }

=== modified file 'libgearman-server/struct/port.h'
--- libgearman-server/struct/port.h	2013-01-13 12:23:14 +0000
+++ libgearman-server/struct/port.h	2013-07-07 00:24:31 +0000
@@ -43,13 +43,18 @@
 {
   char port[NI_MAXSERV];
   uint32_t listen_count;
-  gearmand_connection_add_fn *add_fn;
+
+private:
+  gearmand_connection_add_fn *_add_fn;
+  gearmand_connection_remove_fn *_remove_fn;
+
+public:
   int *listen_fd;
   struct event *listen_event;
 
   gearmand_port_st() :
     listen_count(0),
-    add_fn(NULL),
+    _add_fn(NULL),
     listen_fd(NULL),
     listen_event(NULL)
   {
@@ -68,5 +73,25 @@
       free(listen_event);
     }
   }
+
+  gearmand_error_t add_fn(gearman_server_con_st* con)
+  {
+    return (*_add_fn)(con);
+  }
+
+  gearmand_error_t remove_fn(gearman_server_con_st* con)
+  {
+    return (*_remove_fn)(con);
+  }
+
+  void add_fn(gearmand_connection_add_fn* add_fn_)
+  {
+    _add_fn= add_fn_;
+  }
+
+  void remove_fn(gearmand_connection_remove_fn* remove_fn_)
+  {
+    _remove_fn= remove_fn_;
+  }
 };
 

=== modified file 'libgearman/connection.cc'
--- libgearman/connection.cc	2013-07-06 20:11:54 +0000
+++ libgearman/connection.cc	2013-07-07 00:24:31 +0000
@@ -294,51 +294,50 @@
   if (_ssl)
   {
 #if defined(HAVE_CYASSL) && HAVE_CYASSL
+    CyaSSL_shutdown(_ssl);
     CyaSSL_free(_ssl);
     _ssl= NULL;
 #endif
   }
 
-  if (fd == INVALID_SOCKET)
-  {
-    return;
-  }
-
-  /* in case of death shutdown to avoid blocking at close_socket() */
-  if (shutdown(fd, SHUT_RDWR) == SOCKET_ERROR && get_socket_errno() != ENOTCONN)
-  { }
-  else
-  {
-    if (closesocket(fd) == SOCKET_ERROR)
+  if (fd != INVALID_SOCKET)
+  {
+    /* in case of death shutdown to avoid blocking at close_socket() */
+    if (shutdown(fd, SHUT_RDWR) == SOCKET_ERROR && get_socket_errno() != ENOTCONN)
     { }
+    else
+    {
+      if (closesocket(fd) == SOCKET_ERROR)
+      { }
+    }
+
+    state= GEARMAN_CON_UNIVERSAL_CONNECT;
+    fd= INVALID_SOCKET;
+    events= 0;
+    revents= 0;
+
+    send_state= GEARMAN_CON_SEND_STATE_NONE;
+    send_buffer_ptr= send_buffer;
+    send_buffer_size= 0;
+    send_data_size= 0;
+    send_data_offset= 0;
+
+    recv_state= GEARMAN_CON_RECV_UNIVERSAL_NONE;
+    free_recv_packet();
+
+    recv_buffer_ptr= recv_buffer;
+    recv_buffer_size= 0;
+
+    options.server_options_sent= false;
+
+    // created_id_next is incremented for every outbound packet (except status).
+    // created_id is incremented for every response packet received, and also when
+    // no packets are received due to an error. There are lots of such error paths
+    // and it seems simpler to just reset these both to zero when a connection is
+    // 'closed'.
+    created_id= 0;
+    created_id_next= 0;
   }
-
-  state= GEARMAN_CON_UNIVERSAL_CONNECT;
-  fd= INVALID_SOCKET;
-  events= 0;
-  revents= 0;
-
-  send_state= GEARMAN_CON_SEND_STATE_NONE;
-  send_buffer_ptr= send_buffer;
-  send_buffer_size= 0;
-  send_data_size= 0;
-  send_data_offset= 0;
-
-  recv_state= GEARMAN_CON_RECV_UNIVERSAL_NONE;
-  free_recv_packet();
-
-  recv_buffer_ptr= recv_buffer;
-  recv_buffer_size= 0;
-
-  options.server_options_sent= false;
-
-  // created_id_next is incremented for every outbound packet (except status).
-  // created_id is incremented for every response packet received, and also when
-  // no packets are received due to an error. There are lots of such error paths
-  // and it seems simpler to just reset these both to zero when a connection is
-  // 'closed'.
-  created_id= 0;
-  created_id_next= 0;
 }
 
 void gearman_connection_st::free_recv_packet()