X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fserver.cc;h=b742f7ef1695cde1da2fe736b7b12e0dc120e609;hb=994f46883f309acc0b94b687565fd5a607a4ab34;hp=30cc611fcb39dbc648be7af0cb74a2ba60d5e27e;hpb=fd151d70d25ba4cae4f90a1e57435a8cc72e9c09;p=m6w6%2Flibmemcached diff --git a/libmemcached/server.cc b/libmemcached/server.cc index 30cc611f..b742f7ef 100644 --- a/libmemcached/server.cc +++ b/libmemcached/server.cc @@ -39,10 +39,10 @@ This is a partial implementation for fetching/creating memcached_server_st objects. */ #include -#include -static inline void _server_init(memcached_server_st *self, const memcached_st *root, - const char *hostname, in_port_t port, +static inline void _server_init(memcached_server_st *self, memcached_st *root, + const memcached_string_t& hostname, + in_port_t port, uint32_t weight, memcached_connection_t type) { self->options.is_shutting_down= false; @@ -50,10 +50,10 @@ static inline void _server_init(memcached_server_st *self, const memcached_st *r self->number_of_hosts= 0; self->cursor_active= 0; self->port= port; - self->cached_errno= 0; - self->fd= -1; + self->fd= INVALID_SOCKET; self->io_bytes_sent= 0; self->server_failure_counter= 0; + self->server_failure_counter_query_id= 0; self->weight= weight ? weight : 1; // 1 is the default weight value WATCHPOINT_SET(self->io_wait_count.read= 0); WATCHPOINT_SET(self->io_wait_count.write= 0); @@ -61,43 +61,41 @@ static inline void _server_init(memcached_server_st *self, const memcached_st *r self->micro_version= UINT8_MAX; self->minor_version= UINT8_MAX; self->type= type; + self->error_messages= NULL; self->read_ptr= self->read_buffer; - self->cached_server_error= NULL; self->read_buffer_length= 0; self->read_data_length= 0; self->write_buffer_offset= 0; self->address_info= NULL; self->address_info_next= NULL; - if (root) - { - self->next_retry= root->retry_timeout; - } - else - { - self->next_retry= 0; - } + self->state= MEMCACHED_SERVER_STATE_NEW; + self->next_retry= 0; self->root= root; - self->limit_maxbytes= 0; - if (hostname == NULL) + if (root) { - self->hostname[0]= 0; + self->version= ++root->server_info.version; } else { - strncpy(self->hostname, hostname, NI_MAXHOST - 1); + self->version= UINT_MAX; } + self->limit_maxbytes= 0; + memcpy(self->hostname, hostname.c_str, hostname.size); + self->hostname[hostname.size]= 0; } static memcached_server_st *_server_create(memcached_server_st *self, const memcached_st *memc) { if (self == NULL) { - self= (memcached_server_st *)libmemcached_malloc(memc, sizeof(memcached_server_st)); + self= libmemcached_xmalloc(memc, struct memcached_server_st); - if (! self) + if (self == NULL) + { return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */ + } self->options.is_allocated= true; } @@ -111,49 +109,58 @@ static memcached_server_st *_server_create(memcached_server_st *self, const memc return self; } -memcached_server_st *memcached_server_create_with(const memcached_st *memc, - memcached_server_write_instance_st self, - const char *hostname, in_port_t port, - uint32_t weight, memcached_connection_t type) +memcached_server_st *__server_create_with(memcached_st *memc, + memcached_server_write_instance_st self, + const memcached_string_t& hostname, + const in_port_t port, + uint32_t weight, + const memcached_connection_t type) { + if (memcached_is_valid_servername(hostname) == false) + { + memcached_set_error(*memc, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Invalid hostname provided")); + return NULL; + } + self= _server_create(self, memc); if (self == NULL) + { return NULL; + } - _server_init(self, memc, hostname, port, weight, type); - + _server_init(self, const_cast(memc), hostname, port, weight, type); - if (type == MEMCACHED_CONNECTION_UDP) - { + if (memc and memcached_is_udp(memc)) + { self->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH; memcached_io_init_udp_header(self, 0); } + if (memc) + { + memcached_connect_try(self); + } + return self; } -void memcached_server_free(memcached_server_st *self) +void __server_free(memcached_server_st *self) { - assert(self); memcached_quit_server(self, false); - if (self->cached_server_error) - free(self->cached_server_error); - if (self->address_info) + { freeaddrinfo(self->address_info); + self->address_info= NULL; + self->address_info_next= NULL; + } + + memcached_error_free(*self); if (memcached_is_allocated(self)) { - if (self->root) - { - libmemcached_free(self->root, self); - } - else - { - free(self); - } + libmemcached_free(self->root, self); } else { @@ -161,27 +168,39 @@ void memcached_server_free(memcached_server_st *self) } } +void memcached_server_free(memcached_server_st *self) +{ + if (self == NULL) + { + return; + } + + if (memcached_server_list_count(self)) + { + memcached_server_list_free(self); + return; + } + + __server_free(self); +} + /* If we do not have a valid object to clone from, we toss an error. */ memcached_server_st *memcached_server_clone(memcached_server_st *destination, - const memcached_server_st *source) + memcached_server_st *source) { /* We just do a normal create if source is missing */ - if (not source) - return NULL; - - destination= memcached_server_create_with(source->root, destination, - source->hostname, source->port, source->weight, - source->type); - if (destination != NULL) + if (source == NULL) { - destination->cached_errno= source->cached_errno; - - if (source->cached_server_error) - destination->cached_server_error= strdup(source->cached_server_error); + return NULL; } + memcached_string_t hostname= { memcached_string_make_from_cstr(source->hostname) }; + destination= __server_create_with(source->root, destination, + hostname, + source->port, source->weight, + source->type); return destination; } @@ -197,6 +216,7 @@ memcached_return_t memcached_server_cursor(const memcached_st *ptr, return rc; } + size_t errors= 0; for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { memcached_server_instance_st instance= @@ -204,61 +224,70 @@ memcached_return_t memcached_server_cursor(const memcached_st *ptr, for (uint32_t y= 0; y < number_of_callbacks; y++) { - unsigned int iferror; - - iferror= (*callback[y])(ptr, instance, context); + memcached_return_t ret= (*callback[y])(ptr, instance, context); - if (iferror) + if (memcached_failed(ret)) + { + errors++; continue; + } } } - return MEMCACHED_SUCCESS; + return errors ? MEMCACHED_SOME_ERRORS : MEMCACHED_SUCCESS; } memcached_return_t memcached_server_execute(memcached_st *ptr, memcached_server_execute_fn callback, void *context) { + if (callback == NULL) + { + return MEMCACHED_INVALID_ARGUMENTS; + } + + bool some_errors= false;; for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x); - unsigned int iferror= (*callback)(ptr, instance, context); - - if (iferror) - continue; + memcached_return_t rc= (*callback)(ptr, instance, context); + if (rc == MEMCACHED_INVALID_ARGUMENTS) + { + return rc; + } + else if (memcached_fatal(rc)) + { + some_errors= true; + } } + (void)some_errors; return MEMCACHED_SUCCESS; } -memcached_server_instance_st memcached_server_by_key(const memcached_st *ptr, +memcached_server_instance_st memcached_server_by_key(memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error) { - memcached_return_t rc; memcached_return_t unused; - if (not error) - error= &unused; - - if (memcached_failed(rc= initialize_const_query(ptr))) { - *error= rc; - return NULL; + error= &unused; } - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) + + memcached_return_t rc; + if (memcached_failed(rc= initialize_const_query(ptr))) { *error= rc; return NULL; } - if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) + if (memcached_failed((memcached_key_test(*ptr, (const char **)&key, &key_length, 1)))) { - *error= MEMCACHED_BAD_KEY_PROVIDED; + *error= memcached_last_error(ptr); return NULL; } @@ -270,10 +299,12 @@ memcached_server_instance_st memcached_server_by_key(const memcached_st *ptr, void memcached_server_error_reset(memcached_server_st *self) { WATCHPOINT_ASSERT(self); - if (not self) + if (self == NULL) + { return; + } - self->cached_server_error[0]= 0; + memcached_error_free(*self); } memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *self) @@ -285,31 +316,6 @@ memcached_server_instance_st memcached_server_get_last_disconnect(const memcache return self->last_disconnected_server; } -void memcached_server_list_free(memcached_server_list_st self) -{ - if (not self) - return; - - for (uint32_t x= 0; x < memcached_server_list_count(self); x++) - { - if (self[x].address_info) - { - freeaddrinfo(self[x].address_info); - self[x].address_info= NULL; - } - } - - const memcached_st *root= self->root; - if (root) - { - libmemcached_free(root, self); - } - else - { - free(self); - } -} - uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count) { WATCHPOINT_ASSERT(servers); @@ -328,7 +334,7 @@ uint32_t memcached_server_count(const memcached_st *self) return self->number_of_hosts; } -const char *memcached_server_name(memcached_server_instance_st self) +const char *memcached_server_name(const memcached_server_instance_st self) { WATCHPOINT_ASSERT(self); if (not self) @@ -337,7 +343,7 @@ const char *memcached_server_name(memcached_server_instance_st self) return self->hostname; } -in_port_t memcached_server_port(memcached_server_instance_st self) +in_port_t memcached_server_port(const memcached_server_instance_st self) { WATCHPOINT_ASSERT(self); if (not self) @@ -346,7 +352,7 @@ in_port_t memcached_server_port(memcached_server_instance_st self) return self->port; } -uint32_t memcached_server_response_count(memcached_server_instance_st self) +uint32_t memcached_server_response_count(const memcached_server_instance_st self) { WATCHPOINT_ASSERT(self); if (not self) @@ -355,8 +361,22 @@ uint32_t memcached_server_response_count(memcached_server_instance_st self) return self->cursor_active; } -const char *memcached_server_error(memcached_server_instance_st ptr) +const char *memcached_server_type(const memcached_server_instance_st ptr) { - return ptr ? ptr->cached_server_error : NULL; -} + if (ptr) + { + switch (ptr->type) + { + case MEMCACHED_CONNECTION_TCP: + return "TCP"; + + case MEMCACHED_CONNECTION_UDP: + return "UDP"; + + case MEMCACHED_CONNECTION_UNIX_SOCKET: + return "SOCKET"; + } + } + return "UNKNOWN"; +}