X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fconnect.cc;h=6d9003770b039eaa30606d43280e2936e100dc44;hb=a83eb6704af40530cf38935cb30dd576af563e61;hp=6cad60d5ed4f942799d77f1edea8710e5725b1c7;hpb=3481bbb3f9e4f98c7b984b0f77ebeb468a7d486b;p=awesomized%2Flibmemcached diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc index 6cad60d5..6d900377 100644 --- a/libmemcached/connect.cc +++ b/libmemcached/connect.cc @@ -39,52 +39,55 @@ #include #include -#include -#include -static memcached_return_t connect_poll(memcached_server_st *server) +#ifndef SOCK_CLOEXEC +# define SOCK_CLOEXEC 0 +#endif + +#ifndef SOCK_NONBLOCK +# define SOCK_NONBLOCK 0 +#endif + +#ifndef FD_CLOEXEC +# define FD_CLOEXEC 0 +#endif + +#ifndef SO_NOSIGPIPE +# define SO_NOSIGPIPE 0 +#endif + +#ifndef TCP_NODELAY +# define TCP_NODELAY 0 +#endif + +#ifndef TCP_KEEPIDLE +# define TCP_KEEPIDLE 0 +#endif + +static memcached_return_t connect_poll(memcached_instance_st* server, const int connection_error) { struct pollfd fds[1]; fds[0].fd= server->fd; - fds[0].events= POLLOUT; + fds[0].events= server->events(); + fds[0].revents= 0; size_t loop_max= 5; if (server->root->poll_timeout == 0) { - return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT); + return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, + memcached_literal_param("The time to wait for a connection to be established was set to zero which produces a timeout to every call to poll().")); } while (--loop_max) // Should only loop on cases of ERESTART or EINTR { - int error= poll(fds, 1, server->root->connect_timeout); - switch (error) + int number_of; + if ((number_of= poll(fds, 1, server->root->connect_timeout)) == -1) { - case 1: - { - int err; - socklen_t len= sizeof (err); - if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0) - { - // We check the value to see what happened wth the socket. - if (err == 0) - { - return MEMCACHED_SUCCESS; - } - errno= err; - } - - return memcached_set_errno(*server, err, MEMCACHED_AT); - } - case 0: - { - return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT); - } - - default: // A real error occurred and we need to completely bail - switch (get_socket_errno()) + int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno + switch (local_errno) { -#ifdef TARGET_OS_LINUX +#ifdef __linux__ case ERESTART: #endif case EINTR: @@ -95,62 +98,107 @@ static memcached_return_t connect_poll(memcached_server_st *server) return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT); case EINVAL: - return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid")); + return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, + memcached_literal_param("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid")); default: // This should not happen - if (fds[0].revents & POLLERR) + break; + } + + assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor"); + server->reset_socket(); + server->state= MEMCACHED_SERVER_STATE_NEW; + + return memcached_set_errno(*server, local_errno, MEMCACHED_AT); + } + + if (number_of == 0) + { + if (connection_error == EINPROGRESS) + { + int err; + socklen_t len= sizeof(err); + if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == -1) { - int err; - socklen_t len= sizeof(err); - if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0) - { - if (err == 0) - { - // This should never happen, if it does? Punt. - continue; - } - errno= err; - } + return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getsockopt() error'ed while looking for error connect_poll(EINPROGRESS)")); } - int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno + // If Zero, my hero, we just fail to a generic MEMCACHED_TIMEOUT error + if (err != 0) + { + return memcached_set_errno(*server, err, MEMCACHED_AT, memcached_literal_param("getsockopt() found the error from poll() after connect() returned EINPROGRESS.")); + } + } + + return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("(number_of == 0)")); + } + + assert (number_of == 1); - assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor"); - (void)closesocket(server->fd); - server->fd= INVALID_SOCKET; - server->state= MEMCACHED_SERVER_STATE_NEW; + if (fds[0].revents & POLLERR or + fds[0].revents & POLLHUP or + fds[0].revents & POLLNVAL) + { + int err; + socklen_t len= sizeof (err); + if (getsockopt(fds[0].fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == -1) + { + return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getsockopt() errored while looking up error state from poll()")); + } - return memcached_set_errno(*server, local_errno, MEMCACHED_AT); + // We check the value to see what happened wth the socket. + if (err == 0) // Should not happen + { + return MEMCACHED_SUCCESS; } + errno= err; + + return memcached_set_errno(*server, err, MEMCACHED_AT, memcached_literal_param("getsockopt() found the error from poll() during connect.")); } + assert(fds[0].revents & POLLOUT); + + if (fds[0].revents & POLLOUT and connection_error == EINPROGRESS) + { + int err; + socklen_t len= sizeof(err); + if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == -1) + { + return memcached_set_errno(*server, errno, MEMCACHED_AT); + } + + if (err == 0) + { + return MEMCACHED_SUCCESS; + } + + return memcached_set_errno(*server, err, MEMCACHED_AT, memcached_literal_param("getsockopt() found the error from poll() after connect() returned EINPROGRESS.")); + } + + break; // We only have the loop setup for errno types that require restart } // This should only be possible from ERESTART or EINTR; - return memcached_set_errno(*server, get_socket_errno(), MEMCACHED_AT); + return memcached_set_errno(*server, connection_error, MEMCACHED_AT, memcached_literal_param("connect_poll() was exhausted")); } -static memcached_return_t set_hostinfo(memcached_server_st *server) +static memcached_return_t set_hostinfo(memcached_instance_st* server) { - if (server->address_info) - { - freeaddrinfo(server->address_info); - server->address_info= NULL; - server->address_info_next= NULL; - } + assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET); + server->clear_addrinfo(); - char str_port[NI_MAXSERV]; - int length= snprintf(str_port, NI_MAXSERV, "%u", (uint32_t)server->port); - if (length >= NI_MAXSERV or length < 0) + char str_port[MEMCACHED_NI_MAXSERV]= { 0 }; + errno= 0; + int length= snprintf(str_port, MEMCACHED_NI_MAXSERV, "%u", uint32_t(server->port())); + if (length >= MEMCACHED_NI_MAXSERV or length <= 0 or errno != 0) { - return MEMCACHED_FAILURE; + return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, + memcached_literal_param("snprintf(NI_MAXSERV)")); } struct addrinfo hints; memset(&hints, 0, sizeof(struct addrinfo)); -#if 0 - hints.ai_family= AF_INET; -#endif + hints.ai_family= AF_UNSPEC; if (memcached_is_udp(server->root)) { hints.ai_protocol= IPPROTO_UDP; @@ -162,39 +210,45 @@ static memcached_return_t set_hostinfo(memcached_server_st *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)) + assert(server->hostname()); + switch(errcode= getaddrinfo(server->hostname(), str_port, &hints, &server->address_info)) { case 0: + server->address_info_next= server->address_info; + server->state= MEMCACHED_SERVER_STATE_ADDRINFO; break; case EAI_AGAIN: return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode))); case EAI_SYSTEM: + server->clear_addrinfo(); return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)")); case EAI_BADFLAGS: + server->clear_addrinfo(); return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)")); case EAI_MEMORY: + server->clear_addrinfo(); return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)")); default: { + server->clear_addrinfo(); return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode))); } } - server->address_info_next= server->address_info; - server->state= MEMCACHED_SERVER_STATE_ADDRINFO; return MEMCACHED_SUCCESS; } -static inline void set_socket_nonblocking(memcached_server_st *server) +static inline void set_socket_nonblocking(memcached_instance_st* server) { -#ifdef WIN32 +#if defined(_WIN32) u_long arg= 1; if (ioctlsocket(server->fd, FIONBIO, &arg) == SOCKET_ERROR) { @@ -203,189 +257,244 @@ static inline void set_socket_nonblocking(memcached_server_st *server) #else int flags; - do - { - flags= fcntl(server->fd, F_GETFL, 0); - } while (flags == -1 && (errno == EINTR || errno == EAGAIN)); - - if (flags == -1) - { - memcached_set_errno(*server, errno, NULL); - } - else if ((flags & O_NONBLOCK) == 0) + if (SOCK_NONBLOCK == 0) { - int rval; - do { - rval= fcntl(server->fd, F_SETFL, flags | O_NONBLOCK); - } while (rval == -1 && (errno == EINTR or errno == EAGAIN)); + flags= fcntl(server->fd, F_GETFL, 0); + } while (flags == -1 && (errno == EINTR || errno == EAGAIN)); - if (rval == -1) + if (flags == -1) { memcached_set_errno(*server, errno, NULL); } + else if ((flags & O_NONBLOCK) == 0) + { + int rval; + + do + { + rval= fcntl(server->fd, F_SETFL, flags | O_NONBLOCK); + } while (rval == -1 && (errno == EINTR or errno == EAGAIN)); + + if (rval == -1) + { + memcached_set_errno(*server, errno, NULL); + } + } } #endif } -static void set_socket_options(memcached_server_st *server) +static bool set_socket_options(memcached_instance_st* server) { - assert_msg(server->fd != -1, "invalid socket was passed to set_socket_options()"); + assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()"); + +#ifdef HAVE_FCNTL + // If SOCK_CLOEXEC exists then we don't need to call the following + if (SOCK_CLOEXEC == 0) + { + if (FD_CLOEXEC != 0) + { + int flags; + do + { + flags= fcntl(server->fd, F_GETFD, 0); + } while (flags == -1 and (errno == EINTR or errno == EAGAIN)); + + if (flags != -1) + { + int rval; + do + { + rval= fcntl (server->fd, F_SETFD, flags | FD_CLOEXEC); + } while (rval == -1 && (errno == EINTR or errno == EAGAIN)); + // we currently ignore the case where rval is -1 + } + } + } +#endif if (memcached_is_udp(server->root)) { - return; + return true; } #ifdef HAVE_SNDTIMEO - if (server->root->snd_timeout) + if (server->root->snd_timeout > 0) { - int error; 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; - error= setsockopt(server->fd, SOL_SOCKET, SO_SNDTIMEO, - &waittime, (socklen_t)sizeof(struct timeval)); - WATCHPOINT_ASSERT(error == 0); + int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDTIMEO, + (char*)&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) { - int error; 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; - error= setsockopt(server->fd, SOL_SOCKET, SO_RCVTIMEO, - &waittime, (socklen_t)sizeof(struct timeval)); - WATCHPOINT_ASSERT(error == 0); + int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVTIMEO, + (char*)&waittime, (socklen_t)sizeof(struct timeval)); + (void)(error); + assert(error == 0); } #endif -#if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__) +#if defined(_WIN32) +#else +# if defined(SO_NOSIGPIPE) + if (SO_NOSIGPIPE) { 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 +# endif // SO_NOSIGPIPE +#endif // _WIN32 if (server->root->flags.no_block) { - int error; struct linger linger; linger.l_onoff= 1; linger.l_linger= 0; /* By default on close() just drop the socket */ - error= setsockopt(server->fd, SOL_SOCKET, SO_LINGER, - &linger, (socklen_t)sizeof(struct linger)); - WATCHPOINT_ASSERT(error == 0); + int error= setsockopt(server->fd, SOL_SOCKET, SO_LINGER, + (char*)&linger, (socklen_t)sizeof(struct linger)); + (void)(error); + assert(error == 0); } - if (server->root->flags.tcp_nodelay) + if (TCP_NODELAY) { - int flag= 1; - int error; + if (server->root->flags.tcp_nodelay) + { + int flag= 1; - error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY, - &flag, (socklen_t)sizeof(int)); - WATCHPOINT_ASSERT(error == 0); + int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY, + (char*)&flag, (socklen_t)sizeof(int)); + (void)(error); + assert(error == 0); + } } if (server->root->flags.tcp_keepalive) { int flag= 1; - int error; - error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE, - &flag, (socklen_t)sizeof(int)); - WATCHPOINT_ASSERT(error == 0); + int error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE, + (char*)&flag, (socklen_t)sizeof(int)); + (void)(error); + assert(error == 0); } -#ifdef TCP_KEEPIDLE - if (server->root->tcp_keepidle > 0) + if (TCP_KEEPIDLE) { - int error; - - error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE, - &server->root->tcp_keepidle, (socklen_t)sizeof(int)); - WATCHPOINT_ASSERT(error == 0); + if (server->root->tcp_keepidle > 0) + { + int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE, + (char*)&server->root->tcp_keepidle, (socklen_t)sizeof(int)); + (void)(error); + assert(error == 0); + } } -#endif if (server->root->send_size > 0) { - int error; - - error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF, - &server->root->send_size, (socklen_t)sizeof(int)); - WATCHPOINT_ASSERT(error == 0); + int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF, + (char*)&server->root->send_size, (socklen_t)sizeof(int)); + (void)(error); + assert(error == 0); } if (server->root->recv_size > 0) { - int error; - - error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF, - &server->root->recv_size, (socklen_t)sizeof(int)); - WATCHPOINT_ASSERT(error == 0); + int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF, + (char*)&server->root->recv_size, (socklen_t)sizeof(int)); + (void)(error); + assert(error == 0); } - /* libmemcached will always use nonblocking IO to avoid write deadlocks */ set_socket_nonblocking(server); + + return true; } -static memcached_return_t unix_socket_connect(memcached_server_st *server) +static memcached_return_t unix_socket_connect(memcached_instance_st* server) { -#ifndef WIN32 +#ifndef _WIN32 WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET); - if ((server->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0) - { - memcached_set_errno(*server, errno, NULL); - return MEMCACHED_CONNECTION_FAILURE; - } + do { + int type= SOCK_STREAM; + if (SOCK_CLOEXEC != 0) + { + type|= SOCK_CLOEXEC; + } - struct sockaddr_un servAddr; + if (SOCK_NONBLOCK != 0) + { + type|= SOCK_NONBLOCK; + } - memset(&servAddr, 0, sizeof (struct sockaddr_un)); - servAddr.sun_family= AF_UNIX; - strncpy(servAddr.sun_path, server->hostname, sizeof(servAddr.sun_path)); /* Copy filename */ + if ((server->fd= socket(AF_UNIX, type, 0)) == -1) + { + return memcached_set_errno(*server, errno, NULL); + } - do { - if (connect(server->fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) + struct sockaddr_un servAddr; + + memset(&servAddr, 0, sizeof (struct sockaddr_un)); + servAddr.sun_family= AF_UNIX; + if (strlen(server->hostname()) >= sizeof(servAddr.sun_path)) { + return memcached_set_error(*server, MEMCACHED_UNIX_SOCKET_PATH_TOO_BIG, MEMCACHED_AT); + } + strncpy(servAddr.sun_path, server->hostname(), sizeof(servAddr.sun_path)-1); /* Copy filename */ + + if (connect(server->fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) == -1) { switch (errno) { case EINPROGRESS: case EALREADY: + server->events(POLLOUT); + break; + case EINTR: + server->reset_socket(); continue; case EISCONN: /* We were spinning waiting on connect */ { - WATCHPOINT_ASSERT(0); // Programmer error - break; + assert(0); // Programmer error + server->reset_socket(); + continue; } default: WATCHPOINT_ERRNO(errno); - memcached_set_errno(*server, errno, MEMCACHED_AT); - return MEMCACHED_CONNECTION_FAILURE; + server->reset_socket(); + return memcached_set_errno(*server, errno, MEMCACHED_AT); } } } while (0); @@ -400,12 +509,12 @@ static memcached_return_t unix_socket_connect(memcached_server_st *server) #endif } -static memcached_return_t network_connect(memcached_server_st *server) +static memcached_return_t network_connect(memcached_instance_st* 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 +523,7 @@ static memcached_return_t network_connect(memcached_server_st *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)) { @@ -439,11 +531,8 @@ static memcached_return_t network_connect(memcached_server_st *server) } } - if (server->address_info_next == NULL) - { - server->address_info_next= server->address_info; - server->state= MEMCACHED_SERVER_STATE_ADDRINFO; - } + assert(server->address_info_next); + assert(server->address_info); /* Create the socket */ while (server->address_info_next and server->fd == INVALID_SOCKET) @@ -455,14 +544,31 @@ static memcached_return_t network_connect(memcached_server_st *server) continue; } - if ((server->fd= socket(server->address_info_next->ai_family, - server->address_info_next->ai_socktype, - server->address_info_next->ai_protocol)) < 0) + int type= server->address_info_next->ai_socktype; + if (SOCK_CLOEXEC != 0) + { + type|= SOCK_CLOEXEC; + } + + if (SOCK_NONBLOCK != 0) + { + type|= SOCK_NONBLOCK; + } + + server->fd= socket(server->address_info_next->ai_family, + type, + server->address_info_next->ai_protocol); + + if (int(server->fd) == SOCKET_ERROR) { return memcached_set_errno(*server, get_socket_errno(), NULL); } - set_socket_options(server); + if (set_socket_options(server) == false) + { + server->reset_socket(); + return MEMCACHED_CONNECTION_FAILURE; + } /* connect to server */ if ((connect(server->fd, server->address_info_next->ai_addr, server->address_info_next->ai_addrlen) != SOCKET_ERROR)) @@ -472,18 +578,23 @@ static memcached_return_t network_connect(memcached_server_st *server) } /* An error occurred */ - switch (get_socket_errno()) + int local_error= get_socket_errno(); + switch (local_error) { case ETIMEDOUT: timeout_error_occured= true; break; + case EAGAIN: +#if EWOULDBLOCK != EAGAIN case EWOULDBLOCK: +#endif case EINPROGRESS: // nonblocking mode - first return case EALREADY: // nonblocking mode - subsequent returns { + server->events(POLLOUT); server->state= MEMCACHED_SERVER_STATE_IN_PROGRESS; - memcached_return_t rc= connect_poll(server); + memcached_return_t rc= connect_poll(server, local_error); if (memcached_success(rc)) { @@ -505,17 +616,18 @@ static memcached_return_t network_connect(memcached_server_st *server) case EINTR: // Special case, we retry ai_addr WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET); - (void)closesocket(server->fd); - server->fd= INVALID_SOCKET; + server->reset_socket(); continue; + case ECONNREFUSED: + // Probably not running service + default: break; } WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET); - (void)closesocket(server->fd); - server->fd= INVALID_SOCKET; + server->reset_socket(); server->address_info_next= server->address_info_next->ai_next; } @@ -523,23 +635,20 @@ static memcached_return_t network_connect(memcached_server_st *server) if (timeout_error_occured) { - if (server->fd != INVALID_SOCKET) - { - (void)closesocket(server->fd); - server->fd= INVALID_SOCKET; - } + server->reset_socket(); } WATCHPOINT_STRING("Never got a good file descriptor"); if (memcached_has_current_error(*server)) { - return memcached_server_error_return(server); + return memcached_instance_error_return(server); } if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS) { - return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT); + return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, + memcached_literal_param("if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)")); } return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */ @@ -552,8 +661,11 @@ static memcached_return_t network_connect(memcached_server_st *server) Based on time/failure count fail the connect without trying. This prevents waiting in a state where we get caught spending cycles just waiting. */ -static memcached_return_t backoff_handling(memcached_server_write_instance_st server, bool& in_timeout) +static memcached_return_t backoff_handling(memcached_instance_st* server, bool& in_timeout) { + struct timeval curr_time; + bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0); + /* If we hit server_failure_limit then something is completely wrong about the server. @@ -568,7 +680,21 @@ static memcached_return_t backoff_handling(memcached_server_write_instance_st se if (_is_auto_eject_host(server->root)) { set_last_disconnected_host(server); - run_distribution((memcached_st *)server->root); + + // Retry dead servers if requested + if (_gettime_success and server->root->dead_timeout > 0) + { + server->next_retry= curr_time.tv_sec +server->root->dead_timeout; + + // We only retry dead servers once before assuming failure again + server->server_failure_counter= server->root->server_failure_limit -1; + } + + memcached_return_t rc; + if (memcached_failed(rc= run_distribution((memcached_st *)server->root))) + { + return memcached_set_error(*server, rc, MEMCACHED_AT, memcached_literal_param("Backoff handling failed during run_distribution")); + } return memcached_set_error(*server, MEMCACHED_SERVER_MARKED_DEAD, MEMCACHED_AT); } @@ -584,15 +710,13 @@ static memcached_return_t backoff_handling(memcached_server_write_instance_st se if (server->state == MEMCACHED_SERVER_STATE_IN_TIMEOUT) { - struct timeval curr_time; - bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0); - /* If next_retry is less then our current time, then we reset and try everything again. */ if (_gettime_success and server->next_retry < curr_time.tv_sec) { server->state= MEMCACHED_SERVER_STATE_NEW; + server->server_timeout_counter= 0; } else { @@ -605,8 +729,9 @@ static memcached_return_t backoff_handling(memcached_server_write_instance_st se return MEMCACHED_SUCCESS; } -memcached_return_t memcached_connect(memcached_server_write_instance_st server) +static memcached_return_t _memcached_connect(memcached_instance_st* server, const bool set_last_disconnected) { + assert(server); if (server->fd != INVALID_SOCKET) { return MEMCACHED_SUCCESS; @@ -627,6 +752,11 @@ memcached_return_t memcached_connect(memcached_server_write_instance_st server) return memcached_set_error(*server, MEMCACHED_INVALID_HOST_PROTOCOL, MEMCACHED_AT, memcached_literal_param("SASL is not supported for UDP connections")); } + if (server->hostname()[0] == '/') + { + server->type= MEMCACHED_CONNECTION_UNIX_SOCKET; + } + /* We need to clean up the multi startup piece */ switch (server->type) { @@ -634,6 +764,7 @@ memcached_return_t memcached_connect(memcached_server_write_instance_st server) case MEMCACHED_CONNECTION_TCP: rc= network_connect(server); +#if defined(LIBMEMCACHED_WITH_SASL_SUPPORT) if (LIBMEMCACHED_WITH_SASL_SUPPORT) { if (server->fd != INVALID_SOCKET and server->root->sasl.callbacks) @@ -642,11 +773,11 @@ memcached_return_t memcached_connect(memcached_server_write_instance_st server) if (memcached_failed(rc) and server->fd != INVALID_SOCKET) { WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET); - (void)closesocket(server->fd); - server->fd= INVALID_SOCKET; + server->reset_socket(); } } } +#endif break; case MEMCACHED_CONNECTION_UNIX_SOCKET: @@ -656,28 +787,38 @@ memcached_return_t memcached_connect(memcached_server_write_instance_st server) if (memcached_success(rc)) { - memcached_mark_server_as_clean(server); + server->mark_server_as_clean(); + memcached_version_instance(server); return rc; } - - set_last_disconnected_host(server); - if (memcached_has_current_error(*server)) - { - memcached_mark_server_for_timeout(server); - assert(memcached_failed(memcached_server_error_return(server))); - } - else + else if (set_last_disconnected) { - memcached_set_error(*server, rc, MEMCACHED_AT); - memcached_mark_server_for_timeout(server); - } + set_last_disconnected_host(server); + if (memcached_has_current_error(*server)) + { + memcached_mark_server_for_timeout(server); + assert(memcached_failed(memcached_instance_error_return(server))); + } + else + { + memcached_set_error(*server, rc, MEMCACHED_AT); + memcached_mark_server_for_timeout(server); + } - LIBMEMCACHED_MEMCACHED_CONNECT_END(); + LIBMEMCACHED_MEMCACHED_CONNECT_END(); - if (in_timeout) - { - return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT); + if (in_timeout) + { + char buffer[1024]; + int snprintf_length= snprintf(buffer, sizeof(buffer), "%s:%d", server->hostname(), int(server->port())); + return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT, buffer, snprintf_length); + } } return rc; } + +memcached_return_t memcached_connect(memcached_instance_st* server) +{ + return _memcached_connect(server, true); +}