X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fmemcached_storage.c;h=ea8b1d249b98d5d1189d4d151bf5191120f3f5b6;hb=f05cd5b77ca7b17440bfc7ed9f48f7c11d269767;hp=93bc140ae2175341c56c446935f5fa4a2420cee3;hpb=2b312deb8b7b3f662b492f94a13e673723387724;p=awesomized%2Flibmemcached diff --git a/libmemcached/memcached_storage.c b/libmemcached/memcached_storage.c index 93bc140a..ea8b1d24 100644 --- a/libmemcached/memcached_storage.c +++ b/libmemcached/memcached_storage.c @@ -39,7 +39,7 @@ static char *storage_op_string(memcached_storage_action verb) return "tosserror"; /* This is impossible, fixes issue for compiler warning in VisualStudio */ }; - return SET_OP; + /* NOTREACHED */ } static memcached_return memcached_send_binary(memcached_server_st* server, @@ -70,13 +70,14 @@ static inline memcached_return memcached_send(memcached_st *ptr, WATCHPOINT_ASSERT(!(value == NULL && value_length > 0)); - unlikely (key_length == 0) - return MEMCACHED_NO_KEY_PROVIDED; - + rc= memcached_validate_key_length(key_length, ptr->flags & MEM_BINARY_PROTOCOL); + unlikely (rc != MEMCACHED_SUCCESS) + return rc; + unlikely (ptr->number_of_hosts == 0) return MEMCACHED_NO_SERVERS; - if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) + if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) return MEMCACHED_BAD_KEY_PROVIDED; server_key= memcached_generate_hash(ptr, master_key, master_key_length); @@ -88,17 +89,30 @@ static inline memcached_return memcached_send(memcached_st *ptr, if (cas) write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "%s %s%.*s %u %llu %zu %llu\r\n", storage_op_string(verb), + "%s %s%.*s %u %llu %zu %llu%s\r\n", + storage_op_string(verb), ptr->prefix_key, (int)key_length, key, flags, (unsigned long long)expiration, value_length, - (unsigned long long)cas); + (unsigned long long)cas, + (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); else write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "%s %s%.*s %u %llu %zu\r\n", storage_op_string(verb), + "%s %s%.*s %u %llu %zu%s\r\n", + storage_op_string(verb), ptr->prefix_key, (int)key_length, key, flags, - (unsigned long long)expiration, value_length); + (unsigned long long)expiration, value_length, + (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); + + if (ptr->flags & MEM_USE_UDP && ptr->flags & MEM_BUFFER_REQUESTS) + { + size_t cmd_size= write_length + value_length + 2; + if (cmd_size > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH) + return MEMCACHED_WRITE_FAILURE; + if (cmd_size + ptr->hosts[server_key].write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) + memcached_io_write(&ptr->hosts[server_key], NULL, 0, 1); + } if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE) { @@ -106,10 +120,12 @@ static inline memcached_return memcached_send(memcached_st *ptr, goto error; } + /* Send command header */ rc= memcached_do(&ptr->hosts[server_key], buffer, write_length, 0); if (rc != MEMCACHED_SUCCESS) goto error; + /* Send command body */ if ((sent_length= memcached_io_write(&ptr->hosts[server_key], value, value_length, 0)) == -1) { rc= MEMCACHED_WRITE_FAILURE; @@ -127,6 +143,9 @@ static inline memcached_return memcached_send(memcached_st *ptr, goto error; } + if (ptr->flags & MEM_NOREPLY) + return (to_write == 0) ? MEMCACHED_BUFFERED : MEMCACHED_SUCCESS; + if (to_write == 0) return MEMCACHED_BUFFERED; @@ -320,6 +339,56 @@ memcached_return memcached_cas_by_key(memcached_st *ptr, return rc; } +static inline uint8_t get_com_code(memcached_storage_action verb, bool noreply) +{ + uint8_t ret; + + if (noreply) + switch (verb) + { + case SET_OP: + ret=PROTOCOL_BINARY_CMD_SETQ; + break; + case ADD_OP: + ret=PROTOCOL_BINARY_CMD_ADDQ; + break; + case CAS_OP: /* FALLTHROUGH */ + case REPLACE_OP: + ret=PROTOCOL_BINARY_CMD_REPLACEQ; + break; + case APPEND_OP: + ret=PROTOCOL_BINARY_CMD_APPENDQ; + break; + case PREPEND_OP: + ret=PROTOCOL_BINARY_CMD_PREPENDQ; + break; + } + else + switch (verb) + { + case SET_OP: + ret=PROTOCOL_BINARY_CMD_SET; + break; + case ADD_OP: + ret=PROTOCOL_BINARY_CMD_ADD; + break; + case CAS_OP: /* FALLTHROUGH */ + case REPLACE_OP: + ret=PROTOCOL_BINARY_CMD_REPLACE; + break; + case APPEND_OP: + ret=PROTOCOL_BINARY_CMD_APPEND; + break; + case PREPEND_OP: + ret=PROTOCOL_BINARY_CMD_PREPEND; + break; + } + + return ret; +} + + + static memcached_return memcached_send_binary(memcached_server_st* server, const char *key, size_t key_length, @@ -333,30 +402,10 @@ static memcached_return memcached_send_binary(memcached_server_st* server, char flush; protocol_binary_request_set request= {.bytes= {0}}; size_t send_length= sizeof(request.bytes); + bool noreply= server->root->flags & MEM_NOREPLY; request.message.header.request.magic= PROTOCOL_BINARY_REQ; - switch (verb) - { - case SET_OP: - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_SET; - break; - case ADD_OP: - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_ADD; - break; - case REPLACE_OP: - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_REPLACE; - break; - case APPEND_OP: - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_APPEND; - break; - case PREPEND_OP: - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_PREPEND; - break; - case CAS_OP: - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_REPLACE; - break; - } - + request.message.header.request.opcode= get_com_code(verb, noreply); request.message.header.request.keylen= htons((uint16_t)key_length); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; if (verb == APPEND_OP || verb == PREPEND_OP) @@ -375,6 +424,16 @@ static memcached_return memcached_send_binary(memcached_server_st* server, request.message.header.request.cas= htonll(cas); flush= ((server->root->flags & MEM_BUFFER_REQUESTS) && verb == SET_OP) ? 0 : 1; + + if ((server->root->flags & MEM_USE_UDP) && !flush) + { + size_t cmd_size= send_length + key_length + value_length; + if (cmd_size > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH) + return MEMCACHED_WRITE_FAILURE; + if (cmd_size + server->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) + memcached_io_write(server,NULL,0, 1); + } + /* write the header */ if ((memcached_do(server, (const char*)request.bytes, send_length, 0) != MEMCACHED_SUCCESS) || (memcached_io_write(server, key, key_length, 0) == -1) || @@ -383,10 +442,13 @@ static memcached_return memcached_send_binary(memcached_server_st* server, memcached_io_reset(server); return MEMCACHED_WRITE_FAILURE; } - + if (flush == 0) return MEMCACHED_BUFFERED; - + + if (noreply) + return MEMCACHED_SUCCESS; + return memcached_response(server, NULL, 0, NULL); }