Speed up host lookup for cases where we don't need to do it, or where it ends up...

[awesomized/libmemcached] / libmemcached / connect.cc

diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index 647ea03bceade3eb4fc87780ebec4988d94bbf0b..5d180d185e0208004270c707887a51499e26b91b 100644 (file)
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -173,7 +173,8 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
     hints.ai_protocol= IPPROTO_TCP;
   }
 
-  server->address_info= NULL;
+  assert(server->address_info == NULL);
+  assert(server->address_info_next == NULL);
   int errcode;
   switch(errcode= getaddrinfo(server->hostname, str_port, &hints, &server->address_info))
   {
@@ -181,19 +182,49 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
     break;
 
   case EAI_AGAIN:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
 
   case EAI_SYSTEM:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
 
   case EAI_BADFLAGS:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
 
   case EAI_MEMORY:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
 
   default:
     {
+      if (server->address_info)
+      {
+        freeaddrinfo(server->address_info);
+        server->address_info= NULL;
+        server->address_info_next= NULL;
+      }
       return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
     }
   }
@@ -250,29 +281,31 @@ static void set_socket_options(org::libmemcached::Instance* server)
   }
 
 #ifdef HAVE_SNDTIMEO
-  if (server->root->snd_timeout)
+  if (server->root->snd_timeout > 0)
   {
     struct timeval waittime;
 
-    waittime.tv_sec= 0;
-    waittime.tv_usec= server->root->snd_timeout;
+    waittime.tv_sec= server->root->snd_timeout / 1000000;
+    waittime.tv_usec= server->root->snd_timeout % 1000000;
 
     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDTIMEO,
-                      &waittime, (socklen_t)sizeof(struct timeval));
+                          &waittime, (socklen_t)sizeof(struct timeval));
+    (void)error;
     assert(error == 0);
   }
 #endif
 
 #ifdef HAVE_RCVTIMEO
-  if (server->root->rcv_timeout)
+  if (server->root->rcv_timeout > 0)
   {
     struct timeval waittime;
 
-    waittime.tv_sec= 0;
-    waittime.tv_usec= server->root->rcv_timeout;
+    waittime.tv_sec= server->root->rcv_timeout / 1000000;
+    waittime.tv_usec= server->root->rcv_timeout % 1000000;
 
     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVTIMEO,
                           &waittime, (socklen_t)sizeof(struct timeval));
+    (void)(error);
     assert(error == 0);
   }
 #endif
@@ -283,11 +316,14 @@ static void set_socket_options(org::libmemcached::Instance* server)
     int set= 1;
     int error= setsockopt(server->fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int));
 
+    assert(error == 0);
+
     // This is not considered a fatal error
     if (error == -1)
     {
-      WATCHPOINT_ERRNO(get_socket_errno());
+#if 0
       perror("setsockopt(SO_NOSIGPIPE)");
+#endif
     }
   }
 #endif
@@ -300,6 +336,7 @@ static void set_socket_options(org::libmemcached::Instance* server)
     linger.l_linger= 0; /* By default on close() just drop the socket */
     int error= setsockopt(server->fd, SOL_SOCKET, SO_LINGER,
                           &linger, (socklen_t)sizeof(struct linger));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -309,6 +346,7 @@ static void set_socket_options(org::libmemcached::Instance* server)
 
     int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY,
                           &flag, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -318,6 +356,7 @@ static void set_socket_options(org::libmemcached::Instance* server)
 
     int error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE,
                       &flag, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -326,6 +365,7 @@ static void set_socket_options(org::libmemcached::Instance* server)
   {
     int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE,
                           &server->root->tcp_keepidle, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 #endif
@@ -334,6 +374,7 @@ static void set_socket_options(org::libmemcached::Instance* server)
   {
     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF,
                           &server->root->send_size, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -341,6 +382,7 @@ static void set_socket_options(org::libmemcached::Instance* server)
   {
     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF,
                           &server->root->recv_size, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -405,7 +447,7 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
   bool timeout_error_occured= false;
 
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
-  WATCHPOINT_ASSERT(server->cursor_active == 0);
+  WATCHPOINT_ASSERT(server->cursor_active_ == 0);
 
   /*
     We want to check both of these because if address_info_next has been fully tried, we want to do a new lookup to make sure we have picked up on any new DNS information.
@@ -414,24 +456,7 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
   {
     WATCHPOINT_ASSERT(server->state == MEMCACHED_SERVER_STATE_NEW);
     server->address_info_next= NULL;
-    memcached_return_t rc;
-    uint32_t counter= 5;
-    while (--counter)
-    {
-      if ((rc= set_hostinfo(server)) != MEMCACHED_TIMEOUT)
-      {
-        break;
-      }
-
-#ifndef WIN32
-      struct timespec dream, rem;
-
-      dream.tv_nsec= 1000;
-      dream.tv_sec= 0;
-
-      nanosleep(&dream, &rem);
-#endif
-    }
+    memcached_return_t rc= set_hostinfo(server);
 
     if (memcached_failed(rc))
     {
@@ -641,6 +666,7 @@ static memcached_return_t backoff_handling(org::libmemcached::Instance* server,
 
 static memcached_return_t _memcached_connect(org::libmemcached::Instance* server, const bool set_last_disconnected)
 {
+  assert(server);
   if (server->fd != INVALID_SOCKET)
   {
     return MEMCACHED_SUCCESS;
@@ -696,6 +722,7 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server
   if (memcached_success(rc))
   {
     server->mark_server_as_clean();
+    memcached_version_instance(server);
     return rc;
   }
   else if (set_last_disconnected)
@@ -727,6 +754,11 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server
 
 memcached_return_t memcached_connect_try(org::libmemcached::Instance* server)
 {
+  if (server and server->root and server->root->state.is_parsing)
+  {
+    return MEMCACHED_SUCCESS;
+  }
+
   return _memcached_connect(server, false);
 }