1328 lines
56 KiB
Python
1328 lines
56 KiB
Python
# -*- coding:utf-8 -*-
|
|
# Copyright (c) 2010-2012 OpenStack Foundation
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
"""Tests for swift.common.utils"""
|
|
from collections import defaultdict
|
|
import errno
|
|
import io
|
|
import logging
|
|
import six
|
|
import socket
|
|
import time
|
|
import unittest
|
|
from uuid import uuid4
|
|
import os
|
|
|
|
import mock
|
|
from six.moves.configparser import NoSectionError, NoOptionError
|
|
|
|
from eventlet import GreenPool, sleep, Queue
|
|
from eventlet.pools import Pool
|
|
from eventlet.green import ssl
|
|
|
|
from swift.common import memcached
|
|
from swift.common.memcached import MemcacheConnectionError
|
|
from swift.common.utils import md5, human_readable
|
|
from mock import patch, MagicMock
|
|
from test.debug_logger import debug_logger
|
|
|
|
|
|
class MockedMemcachePool(memcached.MemcacheConnPool):
|
|
def __init__(self, mocks):
|
|
Pool.__init__(self, max_size=2)
|
|
self.mocks = mocks
|
|
# setting this for the eventlet workaround in the MemcacheConnPool
|
|
self._parent_class_getter = super(memcached.MemcacheConnPool, self).get
|
|
|
|
def create(self):
|
|
return self.mocks.pop(0)
|
|
|
|
|
|
class ExplodingMockMemcached(object):
|
|
should_explode = True
|
|
exploded = False
|
|
|
|
def sendall(self, string):
|
|
if self.should_explode:
|
|
self.exploded = True
|
|
raise socket.error(errno.EPIPE, os.strerror(errno.EPIPE))
|
|
|
|
def readline(self):
|
|
if self.should_explode:
|
|
self.exploded = True
|
|
raise socket.error(errno.EPIPE, os.strerror(errno.EPIPE))
|
|
return b'STORED\r\n'
|
|
|
|
def read(self, size):
|
|
if self.should_explode:
|
|
self.exploded = True
|
|
raise socket.error(errno.EPIPE, os.strerror(errno.EPIPE))
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
|
|
TOO_BIG_KEY = md5(
|
|
b'too-big', usedforsecurity=False).hexdigest().encode('ascii')
|
|
|
|
|
|
class MockMemcached(object):
|
|
# See https://github.com/memcached/memcached/blob/master/doc/protocol.txt
|
|
# In particular, the "Storage commands" section may be interesting.
|
|
|
|
def __init__(self):
|
|
self.inbuf = b''
|
|
self.outbuf = b''
|
|
self.cache = {}
|
|
self.down = False
|
|
self.exc_on_delete = False
|
|
self.read_return_none = False
|
|
self.read_return_empty_str = False
|
|
self.close_called = False
|
|
|
|
def sendall(self, string):
|
|
if self.down:
|
|
raise Exception('mock is down')
|
|
self.inbuf += string
|
|
while b'\n' in self.inbuf:
|
|
cmd, self.inbuf = self.inbuf.split(b'\n', 1)
|
|
parts = cmd.split()
|
|
cmd_name = parts[0].decode('ascii').lower()
|
|
handler = getattr(self, 'handle_%s' % cmd_name, None)
|
|
if handler:
|
|
handler(*parts[1:])
|
|
else:
|
|
raise ValueError('Unhandled command: %s' % parts[0])
|
|
|
|
def handle_set(self, key, flags, exptime, num_bytes, noreply=b''):
|
|
self.cache[key] = flags, exptime, self.inbuf[:int(num_bytes)]
|
|
self.inbuf = self.inbuf[int(num_bytes) + 2:]
|
|
if noreply != b'noreply':
|
|
if key == TOO_BIG_KEY:
|
|
self.outbuf += b'SERVER_ERROR object too large for cache\r\n'
|
|
else:
|
|
self.outbuf += b'STORED\r\n'
|
|
|
|
def handle_add(self, key, flags, exptime, num_bytes, noreply=b''):
|
|
value = self.inbuf[:int(num_bytes)]
|
|
self.inbuf = self.inbuf[int(num_bytes) + 2:]
|
|
if key in self.cache:
|
|
if noreply != b'noreply':
|
|
self.outbuf += b'NOT_STORED\r\n'
|
|
else:
|
|
self.cache[key] = flags, exptime, value
|
|
if noreply != b'noreply':
|
|
self.outbuf += b'STORED\r\n'
|
|
|
|
def handle_delete(self, key, noreply=b''):
|
|
if self.exc_on_delete:
|
|
raise Exception('mock is has exc_on_delete set')
|
|
if key in self.cache:
|
|
del self.cache[key]
|
|
if noreply != b'noreply':
|
|
self.outbuf += b'DELETED\r\n'
|
|
elif noreply != b'noreply':
|
|
self.outbuf += b'NOT_FOUND\r\n'
|
|
|
|
def handle_get(self, *keys):
|
|
for key in keys:
|
|
if key in self.cache:
|
|
val = self.cache[key]
|
|
self.outbuf += b' '.join([
|
|
b'VALUE',
|
|
key,
|
|
val[0],
|
|
str(len(val[2])).encode('ascii')
|
|
]) + b'\r\n'
|
|
self.outbuf += val[2] + b'\r\n'
|
|
self.outbuf += b'END\r\n'
|
|
|
|
def handle_incr(self, key, value, noreply=b''):
|
|
if key in self.cache:
|
|
current = self.cache[key][2]
|
|
new_val = str(int(current) + int(value)).encode('ascii')
|
|
self.cache[key] = self.cache[key][:2] + (new_val, )
|
|
self.outbuf += new_val + b'\r\n'
|
|
else:
|
|
self.outbuf += b'NOT_FOUND\r\n'
|
|
|
|
def handle_decr(self, key, value, noreply=b''):
|
|
if key in self.cache:
|
|
current = self.cache[key][2]
|
|
new_val = str(int(current) - int(value)).encode('ascii')
|
|
if new_val[:1] == b'-': # ie, val is negative
|
|
new_val = b'0'
|
|
self.cache[key] = self.cache[key][:2] + (new_val, )
|
|
self.outbuf += new_val + b'\r\n'
|
|
else:
|
|
self.outbuf += b'NOT_FOUND\r\n'
|
|
|
|
def readline(self):
|
|
if self.read_return_empty_str:
|
|
return b''
|
|
if self.read_return_none:
|
|
return None
|
|
if self.down:
|
|
raise Exception('mock is down')
|
|
if b'\n' in self.outbuf:
|
|
response, self.outbuf = self.outbuf.split(b'\n', 1)
|
|
return response + b'\n'
|
|
|
|
def read(self, size):
|
|
if self.down:
|
|
raise Exception('mock is down')
|
|
if len(self.outbuf) >= size:
|
|
response = self.outbuf[:size]
|
|
self.outbuf = self.outbuf[size:]
|
|
return response
|
|
|
|
def close(self):
|
|
self.close_called = True
|
|
pass
|
|
|
|
|
|
class TestMemcached(unittest.TestCase):
|
|
"""Tests for swift.common.memcached"""
|
|
|
|
def setUp(self):
|
|
self.logger = debug_logger()
|
|
|
|
def test_logger_kwarg(self):
|
|
server_socket = '%s:%s' % ('[::1]', 11211)
|
|
client = memcached.MemcacheRing([server_socket])
|
|
self.assertIs(client.logger, logging.getLogger())
|
|
|
|
client = memcached.MemcacheRing([server_socket], logger=self.logger)
|
|
self.assertIs(client.logger, self.logger)
|
|
|
|
def test_tls_context_kwarg(self):
|
|
with patch('swift.common.memcached.socket.socket'):
|
|
server = '%s:%s' % ('[::1]', 11211)
|
|
client = memcached.MemcacheRing([server])
|
|
self.assertIsNone(client._client_cache[server]._tls_context)
|
|
|
|
context = mock.Mock()
|
|
client = memcached.MemcacheRing([server], tls_context=context)
|
|
self.assertIs(client._client_cache[server]._tls_context, context)
|
|
|
|
key = uuid4().hex.encode('ascii')
|
|
list(client._get_conns(key))
|
|
context.wrap_socket.assert_called_once()
|
|
|
|
def test_get_conns(self):
|
|
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
sock1.bind(('127.0.0.1', 0))
|
|
sock1.listen(1)
|
|
sock1ipport = '%s:%s' % sock1.getsockname()
|
|
sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
sock2.bind(('127.0.0.1', 0))
|
|
sock2.listen(1)
|
|
orig_port = memcached.DEFAULT_MEMCACHED_PORT
|
|
try:
|
|
sock2ip, memcached.DEFAULT_MEMCACHED_PORT = sock2.getsockname()
|
|
sock2ipport = '%s:%s' % (sock2ip, memcached.DEFAULT_MEMCACHED_PORT)
|
|
# We're deliberately using sock2ip (no port) here to test that the
|
|
# default port is used.
|
|
memcache_client = memcached.MemcacheRing([sock1ipport, sock2ip],
|
|
logger=self.logger)
|
|
one = two = True
|
|
while one or two: # Run until we match hosts one and two
|
|
key = uuid4().hex.encode('ascii')
|
|
for conn in memcache_client._get_conns(key):
|
|
if 'b' not in getattr(conn[1], 'mode', ''):
|
|
self.assertIsInstance(conn[1], (
|
|
io.RawIOBase, io.BufferedIOBase))
|
|
peeripport = '%s:%s' % conn[2].getpeername()
|
|
self.assertTrue(peeripport in (sock1ipport, sock2ipport))
|
|
if peeripport == sock1ipport:
|
|
one = False
|
|
if peeripport == sock2ipport:
|
|
two = False
|
|
self.assertEqual(len(memcache_client._errors[sock1ipport]), 0)
|
|
self.assertEqual(len(memcache_client._errors[sock2ip]), 0)
|
|
finally:
|
|
memcached.DEFAULT_MEMCACHED_PORT = orig_port
|
|
|
|
def test_get_conns_v6(self):
|
|
if not socket.has_ipv6:
|
|
return
|
|
try:
|
|
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
|
|
sock.bind(('::1', 0, 0, 0))
|
|
sock.listen(1)
|
|
sock_addr = sock.getsockname()
|
|
server_socket = '[%s]:%s' % (sock_addr[0], sock_addr[1])
|
|
memcache_client = memcached.MemcacheRing([server_socket],
|
|
logger=self.logger)
|
|
key = uuid4().hex.encode('ascii')
|
|
for conn in memcache_client._get_conns(key):
|
|
peer_sockaddr = conn[2].getpeername()
|
|
peer_socket = '[%s]:%s' % (peer_sockaddr[0], peer_sockaddr[1])
|
|
self.assertEqual(peer_socket, server_socket)
|
|
self.assertEqual(len(memcache_client._errors[server_socket]), 0)
|
|
finally:
|
|
sock.close()
|
|
|
|
def test_get_conns_v6_default(self):
|
|
if not socket.has_ipv6:
|
|
return
|
|
try:
|
|
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
|
|
sock.bind(('::1', 0))
|
|
sock.listen(1)
|
|
sock_addr = sock.getsockname()
|
|
server_socket = '[%s]:%s' % (sock_addr[0], sock_addr[1])
|
|
server_host = '[%s]' % sock_addr[0]
|
|
memcached.DEFAULT_MEMCACHED_PORT = sock_addr[1]
|
|
memcache_client = memcached.MemcacheRing([server_host],
|
|
logger=self.logger)
|
|
key = uuid4().hex.encode('ascii')
|
|
for conn in memcache_client._get_conns(key):
|
|
peer_sockaddr = conn[2].getpeername()
|
|
peer_socket = '[%s]:%s' % (peer_sockaddr[0], peer_sockaddr[1])
|
|
self.assertEqual(peer_socket, server_socket)
|
|
self.assertEqual(len(memcache_client._errors[server_host]), 0)
|
|
finally:
|
|
sock.close()
|
|
|
|
def test_get_conns_bad_v6(self):
|
|
with self.assertRaises(ValueError):
|
|
# IPv6 address with missing [] is invalid
|
|
server_socket = '%s:%s' % ('::1', 11211)
|
|
memcached.MemcacheRing([server_socket], logger=self.logger)
|
|
|
|
def test_get_conns_hostname(self):
|
|
with patch('swift.common.memcached.socket.getaddrinfo') as addrinfo:
|
|
try:
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
sock.bind(('127.0.0.1', 0))
|
|
sock.listen(1)
|
|
sock_addr = sock.getsockname()
|
|
fqdn = socket.getfqdn()
|
|
server_socket = '%s:%s' % (fqdn, sock_addr[1])
|
|
addrinfo.return_value = [(socket.AF_INET,
|
|
socket.SOCK_STREAM, 0, '',
|
|
('127.0.0.1', sock_addr[1]))]
|
|
memcache_client = memcached.MemcacheRing([server_socket],
|
|
logger=self.logger)
|
|
key = uuid4().hex.encode('ascii')
|
|
for conn in memcache_client._get_conns(key):
|
|
peer_sockaddr = conn[2].getpeername()
|
|
peer_socket = '%s:%s' % (peer_sockaddr[0],
|
|
peer_sockaddr[1])
|
|
self.assertEqual(peer_socket,
|
|
'127.0.0.1:%d' % sock_addr[1])
|
|
self.assertEqual(len(memcache_client._errors[server_socket]),
|
|
0)
|
|
finally:
|
|
sock.close()
|
|
|
|
def test_get_conns_hostname6(self):
|
|
with patch('swift.common.memcached.socket.getaddrinfo') as addrinfo:
|
|
try:
|
|
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
|
|
sock.bind(('::1', 0))
|
|
sock.listen(1)
|
|
sock_addr = sock.getsockname()
|
|
fqdn = socket.getfqdn()
|
|
server_socket = '%s:%s' % (fqdn, sock_addr[1])
|
|
addrinfo.return_value = [(socket.AF_INET6,
|
|
socket.SOCK_STREAM, 0, '',
|
|
('::1', sock_addr[1]))]
|
|
memcache_client = memcached.MemcacheRing([server_socket],
|
|
logger=self.logger)
|
|
key = uuid4().hex.encode('ascii')
|
|
for conn in memcache_client._get_conns(key):
|
|
peer_sockaddr = conn[2].getpeername()
|
|
peer_socket = '[%s]:%s' % (peer_sockaddr[0],
|
|
peer_sockaddr[1])
|
|
self.assertEqual(peer_socket, '[::1]:%d' % sock_addr[1])
|
|
self.assertEqual(len(memcache_client._errors[server_socket]),
|
|
0)
|
|
finally:
|
|
sock.close()
|
|
|
|
def test_set_get_json(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
cache_key = md5(b'some_key',
|
|
usedforsecurity=False).hexdigest().encode('ascii')
|
|
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
self.assertEqual(memcache_client.get('some_key'), [1, 2, 3])
|
|
# See JSON_FLAG
|
|
self.assertEqual(mock.cache, {cache_key: (b'2', b'0', b'[1, 2, 3]')})
|
|
|
|
memcache_client.set('some_key', [4, 5, 6])
|
|
self.assertEqual(memcache_client.get('some_key'), [4, 5, 6])
|
|
self.assertEqual(mock.cache, {cache_key: (b'2', b'0', b'[4, 5, 6]')})
|
|
|
|
memcache_client.set('some_key', ['simple str', 'utf8 str éà'])
|
|
# As per http://wiki.openstack.org/encoding,
|
|
# we should expect to have unicode
|
|
self.assertEqual(
|
|
memcache_client.get('some_key'), ['simple str', u'utf8 str éà'])
|
|
self.assertEqual(mock.cache, {cache_key: (
|
|
b'2', b'0', b'["simple str", "utf8 str \\u00e9\\u00e0"]')})
|
|
|
|
memcache_client.set('some_key', [1, 2, 3], time=20)
|
|
self.assertEqual(mock.cache, {cache_key: (b'2', b'20', b'[1, 2, 3]')})
|
|
|
|
sixtydays = 60 * 24 * 60 * 60
|
|
esttimeout = time.time() + sixtydays
|
|
memcache_client.set('some_key', [1, 2, 3], time=sixtydays)
|
|
_junk, cache_timeout, _junk = mock.cache[cache_key]
|
|
self.assertAlmostEqual(float(cache_timeout), esttimeout, delta=1)
|
|
|
|
def test_set_error(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
memcache_client.set('too-big', [1, 2, 3])
|
|
self.assertEqual(
|
|
self.logger.get_lines_for_level('error'),
|
|
['Error setting value in memcached: 1.2.3.4:11211: '
|
|
'SERVER_ERROR object too large for cache'])
|
|
|
|
def test_get_failed_connection_mid_request(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
self.assertEqual(memcache_client.get('some_key'), [1, 2, 3])
|
|
self.assertEqual(list(mock.cache.values()),
|
|
[(b'2', b'0', b'[1, 2, 3]')])
|
|
|
|
# Now lets return an empty string, and make sure we aren't logging
|
|
# the error.
|
|
fake_stdout = six.StringIO()
|
|
# force the logging through the DebugLogger instead of the nose
|
|
# handler. This will use stdout, so we can assert that no stack trace
|
|
# is logged.
|
|
with patch("sys.stdout", fake_stdout):
|
|
mock.read_return_empty_str = True
|
|
self.assertIsNone(memcache_client.get('some_key'))
|
|
log_lines = self.logger.get_lines_for_level('error')
|
|
self.assertIn('Error talking to memcached', log_lines[0])
|
|
self.assertFalse(log_lines[1:])
|
|
self.assertNotIn("Traceback", fake_stdout.getvalue())
|
|
|
|
def test_incr(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
self.assertEqual(memcache_client.incr('some_key', delta=5), 5)
|
|
self.assertEqual(memcache_client.get('some_key'), b'5')
|
|
self.assertEqual(memcache_client.incr('some_key', delta=5), 10)
|
|
self.assertEqual(memcache_client.get('some_key'), b'10')
|
|
self.assertEqual(memcache_client.incr('some_key', delta=1), 11)
|
|
self.assertEqual(memcache_client.get('some_key'), b'11')
|
|
self.assertEqual(memcache_client.incr('some_key', delta=-5), 6)
|
|
self.assertEqual(memcache_client.get('some_key'), b'6')
|
|
self.assertEqual(memcache_client.incr('some_key', delta=-15), 0)
|
|
self.assertEqual(memcache_client.get('some_key'), b'0')
|
|
mock.read_return_none = True
|
|
self.assertRaises(memcached.MemcacheConnectionError,
|
|
memcache_client.incr, 'some_key', delta=-15)
|
|
self.assertTrue(mock.close_called)
|
|
|
|
def test_incr_failed_connection_mid_request(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
self.assertEqual(memcache_client.incr('some_key', delta=5), 5)
|
|
self.assertEqual(memcache_client.get('some_key'), b'5')
|
|
self.assertEqual(memcache_client.incr('some_key', delta=5), 10)
|
|
self.assertEqual(memcache_client.get('some_key'), b'10')
|
|
|
|
# Now lets return an empty string, and make sure we aren't logging
|
|
# the error.
|
|
fake_stdout = six.StringIO()
|
|
# force the logging through the DebugLogger instead of the nose
|
|
# handler. This will use stdout, so we can assert that no stack trace
|
|
# is logged.
|
|
with patch("sys.stdout", fake_stdout):
|
|
mock.read_return_empty_str = True
|
|
self.assertRaises(memcached.MemcacheConnectionError,
|
|
memcache_client.incr, 'some_key', delta=1)
|
|
log_lines = self.logger.get_lines_for_level('error')
|
|
self.assertIn('Error talking to memcached', log_lines[0])
|
|
self.assertFalse(log_lines[1:])
|
|
self.assertNotIn('Traceback', fake_stdout.getvalue())
|
|
|
|
def test_incr_w_timeout(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
cache_key = md5(b'some_key',
|
|
usedforsecurity=False).hexdigest().encode('ascii')
|
|
|
|
memcache_client.incr('some_key', delta=5, time=55)
|
|
self.assertEqual(memcache_client.get('some_key'), b'5')
|
|
self.assertEqual(mock.cache, {cache_key: (b'0', b'55', b'5')})
|
|
|
|
memcache_client.delete('some_key')
|
|
self.assertIsNone(memcache_client.get('some_key'))
|
|
|
|
fiftydays = 50 * 24 * 60 * 60
|
|
esttimeout = time.time() + fiftydays
|
|
memcache_client.incr('some_key', delta=5, time=fiftydays)
|
|
self.assertEqual(memcache_client.get('some_key'), b'5')
|
|
_junk, cache_timeout, _junk = mock.cache[cache_key]
|
|
self.assertAlmostEqual(float(cache_timeout), esttimeout, delta=1)
|
|
|
|
memcache_client.delete('some_key')
|
|
self.assertIsNone(memcache_client.get('some_key'))
|
|
|
|
memcache_client.incr('some_key', delta=5)
|
|
self.assertEqual(memcache_client.get('some_key'), b'5')
|
|
self.assertEqual(mock.cache, {cache_key: (b'0', b'0', b'5')})
|
|
|
|
memcache_client.incr('some_key', delta=5, time=55)
|
|
self.assertEqual(memcache_client.get('some_key'), b'10')
|
|
self.assertEqual(mock.cache, {cache_key: (b'0', b'0', b'10')})
|
|
|
|
def test_decr(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
self.assertEqual(memcache_client.decr('some_key', delta=5), 0)
|
|
self.assertEqual(memcache_client.get('some_key'), b'0')
|
|
self.assertEqual(memcache_client.incr('some_key', delta=15), 15)
|
|
self.assertEqual(memcache_client.get('some_key'), b'15')
|
|
self.assertEqual(memcache_client.decr('some_key', delta=4), 11)
|
|
self.assertEqual(memcache_client.get('some_key'), b'11')
|
|
self.assertEqual(memcache_client.decr('some_key', delta=15), 0)
|
|
self.assertEqual(memcache_client.get('some_key'), b'0')
|
|
mock.read_return_none = True
|
|
self.assertRaises(memcached.MemcacheConnectionError,
|
|
memcache_client.decr, 'some_key', delta=15)
|
|
|
|
def test_retry(self):
|
|
memcache_client = memcached.MemcacheRing(
|
|
['1.2.3.4:11211', '1.2.3.5:11211'], logger=self.logger)
|
|
mock1 = ExplodingMockMemcached()
|
|
mock2 = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock2, mock2)])
|
|
memcache_client._client_cache['1.2.3.5:11211'] = MockedMemcachePool(
|
|
[(mock1, mock1), (mock1, mock1)])
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
self.assertEqual(mock1.exploded, True)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
])
|
|
|
|
self.logger.clear()
|
|
mock1.exploded = False
|
|
self.assertEqual(memcache_client.get('some_key'), [1, 2, 3])
|
|
self.assertEqual(mock1.exploded, True)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
])
|
|
# Check that we really did call create() twice
|
|
self.assertEqual(memcache_client._client_cache['1.2.3.5:11211'].mocks,
|
|
[])
|
|
|
|
def test_error_limiting(self):
|
|
memcache_client = memcached.MemcacheRing(
|
|
['1.2.3.4:11211', '1.2.3.5:11211'], logger=self.logger)
|
|
mock1 = ExplodingMockMemcached()
|
|
mock2 = ExplodingMockMemcached()
|
|
mock2.should_explode = False
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock2, mock2)] * 12)
|
|
memcache_client._client_cache['1.2.3.5:11211'] = MockedMemcachePool(
|
|
[(mock1, mock1)] * 12)
|
|
|
|
for _ in range(12):
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
# twelfth one skips .5 because of error limiting and goes straight
|
|
# to .4
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
] * 11 + [
|
|
'Error limiting server 1.2.3.5:11211'
|
|
])
|
|
self.logger.clear()
|
|
|
|
mock2.should_explode = True
|
|
for _ in range(12):
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
# as we keep going, eventually .4 gets error limited, too
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.4:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
] * 10 + [
|
|
'Error talking to memcached: 1.2.3.4:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
'Error limiting server 1.2.3.4:11211',
|
|
'All memcached servers error-limited',
|
|
])
|
|
self.logger.clear()
|
|
|
|
# continued requests just keep bypassing memcache
|
|
for _ in range(12):
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'All memcached servers error-limited',
|
|
] * 12)
|
|
self.logger.clear()
|
|
|
|
# and get()s are all a "cache miss"
|
|
self.assertIsNone(memcache_client.get('some_key'))
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'All memcached servers error-limited',
|
|
])
|
|
|
|
def test_error_disabled(self):
|
|
memcache_client = memcached.MemcacheRing(
|
|
['1.2.3.4:11211'], logger=self.logger, error_limit_time=0)
|
|
mock1 = ExplodingMockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock1, mock1)] * 20)
|
|
|
|
for _ in range(20):
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
# twelfth one skips .5 because of error limiting and goes straight
|
|
# to .4
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.4:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
] * 20)
|
|
|
|
def test_error_raising(self):
|
|
memcache_client = memcached.MemcacheRing(
|
|
['1.2.3.4:11211'], logger=self.logger, error_limit_time=0)
|
|
mock1 = ExplodingMockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock1, mock1)] * 20)
|
|
|
|
# expect exception when requested...
|
|
with self.assertRaises(MemcacheConnectionError):
|
|
memcache_client.set('some_key', [1, 2, 3], raise_on_error=True)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.4:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
])
|
|
self.logger.clear()
|
|
|
|
with self.assertRaises(MemcacheConnectionError):
|
|
memcache_client.get('some_key', raise_on_error=True)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.4:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
])
|
|
self.logger.clear()
|
|
|
|
# ...but default is no exception
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.4:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
])
|
|
self.logger.clear()
|
|
|
|
memcache_client.get('some_key')
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.4:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
])
|
|
|
|
def test_error_limiting_custom_config(self):
|
|
def do_calls(time_step, num_calls, **memcache_kwargs):
|
|
self.logger.clear()
|
|
memcache_client = memcached.MemcacheRing(
|
|
['1.2.3.5:11211'], logger=self.logger,
|
|
**memcache_kwargs)
|
|
mock1 = ExplodingMockMemcached()
|
|
memcache_client._client_cache['1.2.3.5:11211'] = \
|
|
MockedMemcachePool([(mock1, mock1)] * num_calls)
|
|
|
|
for n in range(num_calls):
|
|
with mock.patch.object(memcached.time, 'time',
|
|
return_value=time_step * n):
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
|
|
# with default error_limit_time of 60, one call per 5 secs, twelfth one
|
|
# triggers error limit
|
|
do_calls(5, 12)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
] * 10 + [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
'Error limiting server 1.2.3.5:11211',
|
|
'All memcached servers error-limited',
|
|
])
|
|
|
|
# with default error_limit_time of 60, one call per 6 secs, error limit
|
|
# is not triggered
|
|
do_calls(6, 20)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
] * 20)
|
|
|
|
# with error_limit_time of 66, one call per 6 secs, twelfth one
|
|
# triggers error limit
|
|
do_calls(6, 12, error_limit_time=66)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
] * 10 + [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
'Error limiting server 1.2.3.5:11211',
|
|
'All memcached servers error-limited',
|
|
])
|
|
|
|
# with error_limit_time of 70, one call per 6 secs, error_limit_count
|
|
# of 11, 13th call triggers error limit
|
|
do_calls(6, 13, error_limit_time=70, error_limit_count=11)
|
|
self.assertEqual(self.logger.get_lines_for_level('error'), [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
] * 11 + [
|
|
'Error talking to memcached: 1.2.3.5:11211: '
|
|
'[Errno 32] Broken pipe',
|
|
'Error limiting server 1.2.3.5:11211',
|
|
'All memcached servers error-limited',
|
|
])
|
|
|
|
def test_delete(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
self.assertEqual(memcache_client.get('some_key'), [1, 2, 3])
|
|
memcache_client.delete('some_key')
|
|
self.assertIsNone(memcache_client.get('some_key'))
|
|
|
|
def test_multi(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
|
|
memcache_client.set_multi(
|
|
{'some_key1': [1, 2, 3], 'some_key2': [4, 5, 6]}, 'multi_key')
|
|
self.assertEqual(
|
|
memcache_client.get_multi(('some_key2', 'some_key1'), 'multi_key'),
|
|
[[4, 5, 6], [1, 2, 3]])
|
|
for key in (b'some_key1', b'some_key2'):
|
|
key = md5(key, usedforsecurity=False).hexdigest().encode('ascii')
|
|
self.assertIn(key, mock.cache)
|
|
_junk, cache_timeout, _junk = mock.cache[key]
|
|
self.assertEqual(cache_timeout, b'0')
|
|
|
|
memcache_client.set_multi(
|
|
{'some_key1': [1, 2, 3], 'some_key2': [4, 5, 6]}, 'multi_key',
|
|
time=20)
|
|
for key in (b'some_key1', b'some_key2'):
|
|
key = md5(key, usedforsecurity=False).hexdigest().encode('ascii')
|
|
_junk, cache_timeout, _junk = mock.cache[key]
|
|
self.assertEqual(cache_timeout, b'20')
|
|
|
|
fortydays = 50 * 24 * 60 * 60
|
|
esttimeout = time.time() + fortydays
|
|
memcache_client.set_multi(
|
|
{'some_key1': [1, 2, 3], 'some_key2': [4, 5, 6]}, 'multi_key',
|
|
time=fortydays)
|
|
for key in (b'some_key1', b'some_key2'):
|
|
key = md5(key, usedforsecurity=False).hexdigest().encode('ascii')
|
|
_junk, cache_timeout, _junk = mock.cache[key]
|
|
self.assertAlmostEqual(float(cache_timeout), esttimeout, delta=1)
|
|
self.assertEqual(memcache_client.get_multi(
|
|
('some_key2', 'some_key1', 'not_exists'), 'multi_key'),
|
|
[[4, 5, 6], [1, 2, 3], None])
|
|
|
|
# Now lets simulate a lost connection and make sure we don't get
|
|
# the index out of range stack trace when it does
|
|
mock_stderr = six.StringIO()
|
|
not_expected = "IndexError: list index out of range"
|
|
with patch("sys.stderr", mock_stderr):
|
|
mock.read_return_empty_str = True
|
|
self.assertEqual(memcache_client.get_multi(
|
|
('some_key2', 'some_key1', 'not_exists'), 'multi_key'),
|
|
None)
|
|
self.assertFalse(not_expected in mock_stderr.getvalue())
|
|
|
|
def test_multi_delete(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211',
|
|
'1.2.3.5:11211'],
|
|
logger=self.logger)
|
|
mock1 = MockMemcached()
|
|
mock2 = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock1, mock1)] * 2)
|
|
memcache_client._client_cache['1.2.3.5:11211'] = MockedMemcachePool(
|
|
[(mock2, mock2)] * 2)
|
|
|
|
# MemcacheRing will put 'some_key0' on server 1.2.3.5:11211 and
|
|
# 'some_key1' and 'multi_key' on '1.2.3.4:11211'
|
|
memcache_client.set_multi(
|
|
{'some_key0': [1, 2, 3], 'some_key1': [4, 5, 6]}, 'multi_key')
|
|
self.assertEqual(
|
|
memcache_client.get_multi(('some_key1', 'some_key0'), 'multi_key'),
|
|
[[4, 5, 6], [1, 2, 3]])
|
|
for key in (b'some_key0', b'some_key1'):
|
|
key = md5(key, usedforsecurity=False).hexdigest().encode('ascii')
|
|
self.assertIn(key, mock1.cache)
|
|
_junk, cache_timeout, _junk = mock1.cache[key]
|
|
self.assertEqual(cache_timeout, b'0')
|
|
|
|
memcache_client.set('some_key0', [7, 8, 9])
|
|
self.assertEqual(memcache_client.get('some_key0'), [7, 8, 9])
|
|
key = md5(b'some_key0',
|
|
usedforsecurity=False).hexdigest().encode('ascii')
|
|
self.assertIn(key, mock2.cache)
|
|
|
|
# Delete 'some_key0' with server_key='multi_key'
|
|
memcache_client.delete('some_key0', server_key='multi_key')
|
|
self.assertEqual(memcache_client.get_multi(
|
|
('some_key0', 'some_key1'), 'multi_key'),
|
|
[None, [4, 5, 6]])
|
|
|
|
# 'some_key0' have to be available on 1.2.3.5:11211
|
|
self.assertEqual(memcache_client.get('some_key0'), [7, 8, 9])
|
|
self.assertIn(key, mock2.cache)
|
|
|
|
def test_serialization(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
self.assertEqual(memcache_client.get('some_key'), [1, 2, 3])
|
|
self.assertEqual(len(mock.cache), 1)
|
|
key = next(iter(mock.cache))
|
|
self.assertEqual(mock.cache[key][0], b'2') # JSON_FLAG
|
|
# Pretend we've got some really old pickle data in there
|
|
mock.cache[key] = (b'1',) + mock.cache[key][1:]
|
|
self.assertIsNone(memcache_client.get('some_key'))
|
|
|
|
def test_connection_pooling(self):
|
|
with patch('swift.common.memcached.socket') as mock_module:
|
|
def mock_getaddrinfo(host, port, family=socket.AF_INET,
|
|
socktype=socket.SOCK_STREAM, proto=0,
|
|
flags=0):
|
|
return [(family, socktype, proto, '', (host, port))]
|
|
|
|
mock_module.getaddrinfo = mock_getaddrinfo
|
|
|
|
# patch socket, stub socket.socket, mock sock
|
|
mock_sock = mock_module.socket.return_value
|
|
|
|
# track clients waiting for connections
|
|
connected = []
|
|
connections = Queue()
|
|
errors = []
|
|
|
|
def wait_connect(addr):
|
|
connected.append(addr)
|
|
sleep(0.1) # yield
|
|
val = connections.get()
|
|
if val is not None:
|
|
errors.append(val)
|
|
|
|
mock_sock.connect = wait_connect
|
|
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
connect_timeout=10,
|
|
logger=self.logger)
|
|
# sanity
|
|
self.assertEqual(1, len(memcache_client._client_cache))
|
|
for server, pool in memcache_client._client_cache.items():
|
|
self.assertEqual(2, pool.max_size)
|
|
|
|
# make 10 requests "at the same time"
|
|
p = GreenPool()
|
|
for i in range(10):
|
|
p.spawn(memcache_client.set, 'key', 'value')
|
|
for i in range(3):
|
|
sleep(0.1)
|
|
self.assertEqual(2, len(connected))
|
|
|
|
# give out a connection
|
|
connections.put(None)
|
|
|
|
# at this point, only one connection should have actually been
|
|
# created, the other is in the creation step, and the rest of the
|
|
# clients are not attempting to connect. we let this play out a
|
|
# bit to verify.
|
|
for i in range(3):
|
|
sleep(0.1)
|
|
self.assertEqual(2, len(connected))
|
|
|
|
# finish up, this allows the final connection to be created, so
|
|
# that all the other clients can use the two existing connections
|
|
# and no others will be created.
|
|
connections.put(None)
|
|
connections.put('nono')
|
|
self.assertEqual(2, len(connected))
|
|
p.waitall()
|
|
self.assertEqual(2, len(connected))
|
|
self.assertEqual(0, len(errors),
|
|
"A client was allowed a third connection")
|
|
connections.get_nowait()
|
|
self.assertTrue(connections.empty())
|
|
|
|
def test_connection_pool_timeout(self):
|
|
connections = defaultdict(Queue)
|
|
pending = defaultdict(int)
|
|
served = defaultdict(int)
|
|
|
|
class MockConnectionPool(memcached.MemcacheConnPool):
|
|
def get(self):
|
|
pending[self.host] += 1
|
|
conn = connections[self.host].get()
|
|
pending[self.host] -= 1
|
|
return conn
|
|
|
|
def put(self, *args, **kwargs):
|
|
connections[self.host].put(*args, **kwargs)
|
|
served[self.host] += 1
|
|
|
|
with mock.patch.object(memcached, 'MemcacheConnPool',
|
|
MockConnectionPool):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211',
|
|
'1.2.3.5:11211'],
|
|
io_timeout=0.5,
|
|
pool_timeout=0.1,
|
|
logger=self.logger)
|
|
|
|
# Hand out a couple slow connections to 1.2.3.5, leaving 1.2.3.4
|
|
# fast. All ten (10) clients should try to talk to .5 first, and
|
|
# then move on to .4, and we'll assert all that below.
|
|
mock_conn = MagicMock(), MagicMock()
|
|
mock_conn[0].readline = lambda: b'STORED\r\n'
|
|
mock_conn[1].sendall = lambda x: sleep(0.2)
|
|
connections['1.2.3.5'].put(mock_conn)
|
|
connections['1.2.3.5'].put(mock_conn)
|
|
|
|
mock_conn = MagicMock(), MagicMock()
|
|
mock_conn[0].readline = lambda: b'STORED\r\n'
|
|
connections['1.2.3.4'].put(mock_conn)
|
|
connections['1.2.3.4'].put(mock_conn)
|
|
|
|
p = GreenPool()
|
|
for i in range(10):
|
|
p.spawn(memcache_client.set, 'key', 'value')
|
|
|
|
# Wait for the dust to settle.
|
|
p.waitall()
|
|
|
|
self.assertEqual(pending['1.2.3.5'], 8)
|
|
self.assertEqual(len(memcache_client._errors['1.2.3.5:11211']), 8)
|
|
self.assertEqual(
|
|
self.logger.get_lines_for_level('error'),
|
|
['Timeout getting a connection to memcached: 1.2.3.5:11211'] * 8)
|
|
self.assertEqual(served['1.2.3.5'], 2)
|
|
self.assertEqual(pending['1.2.3.4'], 0)
|
|
self.assertEqual(len(memcache_client._errors['1.2.3.4:11211']), 0)
|
|
self.assertEqual(served['1.2.3.4'], 8)
|
|
|
|
# and we never got more put in that we gave out
|
|
self.assertEqual(connections['1.2.3.5'].qsize(), 2)
|
|
self.assertEqual(connections['1.2.3.4'].qsize(), 2)
|
|
|
|
def test_connection_slow_connect(self):
|
|
with patch('swift.common.memcached.socket') as mock_module:
|
|
def mock_getaddrinfo(host, port, family=socket.AF_INET,
|
|
socktype=socket.SOCK_STREAM, proto=0,
|
|
flags=0):
|
|
return [(family, socktype, proto, '', (host, port))]
|
|
|
|
mock_module.getaddrinfo = mock_getaddrinfo
|
|
|
|
# patch socket, stub socket.socket, mock sock
|
|
mock_sock = mock_module.socket.return_value
|
|
|
|
def wait_connect(addr):
|
|
# slow connect gives Timeout Exception
|
|
sleep(1)
|
|
|
|
# patch connect method
|
|
mock_sock.connect = wait_connect
|
|
|
|
memcache_client = memcached.MemcacheRing(
|
|
['1.2.3.4:11211'], connect_timeout=0.1)
|
|
|
|
# sanity
|
|
self.assertEqual(1, len(memcache_client._client_cache))
|
|
for server, pool in memcache_client._client_cache.items():
|
|
self.assertEqual(2, pool.max_size)
|
|
|
|
# try to get connect and no connection found
|
|
# so it will result in StopIteration
|
|
conn_generator = memcache_client._get_conns(b'key')
|
|
with self.assertRaises(StopIteration):
|
|
next(conn_generator)
|
|
|
|
self.assertEqual(1, mock_sock.close.call_count)
|
|
|
|
def test_item_size_warning_threshold(self):
|
|
mock = MockMemcached()
|
|
mocked_pool = MockedMemcachePool([(mock, mock)] * 2)
|
|
|
|
def do_test(d, threshold, should_warn, error=False):
|
|
self.logger.clear()
|
|
try:
|
|
memcache_client = memcached.MemcacheRing(
|
|
['1.2.3.4:11211'], item_size_warning_threshold=threshold,
|
|
logger=self.logger)
|
|
memcache_client._client_cache['1.2.3.4:11211'] = mocked_pool
|
|
memcache_client.set('some_key', d, serialize=False)
|
|
warning_lines = self.logger.get_lines_for_level('warning')
|
|
if should_warn:
|
|
self.assertIn(
|
|
'Item size larger than warning threshold: '
|
|
'%d (%s) >= %d (%s)' % (
|
|
len(d), human_readable(len(d)), threshold,
|
|
human_readable(threshold)),
|
|
warning_lines[0])
|
|
else:
|
|
self.assertFalse(warning_lines)
|
|
except ValueError as err:
|
|
if not err:
|
|
self.fail(err)
|
|
else:
|
|
self.assertIn(
|
|
'Config option must be a number, greater than 0, '
|
|
'less than 100, not "%s".' % threshold,
|
|
str(err))
|
|
|
|
data = '1' * 100
|
|
# let's start with something easy, say warning at 80
|
|
for data_size, warn in ((79, False), (80, True), (81, True),
|
|
(99, True), (100, True)):
|
|
do_test(data[:data_size], 80, warn)
|
|
|
|
# if we set the threshold to -1 will turn off the warning
|
|
for data_size, warn in ((79, False), (80, False), (81, False),
|
|
(99, False), (100, False)):
|
|
do_test(data[:data_size], -1, warn)
|
|
|
|
# Changing to 0 should warn on everything
|
|
for data_size, warn in ((0, True), (1, True), (50, True),
|
|
(99, True), (100, True)):
|
|
do_test(data[:data_size], 0, warn)
|
|
|
|
# Let's do a big number
|
|
do_test('1' * 2048576, 1000000, True)
|
|
|
|
def test_operations_timing_stats(self):
|
|
memcache_client = memcached.MemcacheRing(['1.2.3.4:11211'],
|
|
logger=self.logger)
|
|
mock = MockMemcached()
|
|
memcache_client._client_cache['1.2.3.4:11211'] = MockedMemcachePool(
|
|
[(mock, mock)] * 2)
|
|
|
|
with patch('time.time',) as mock_time:
|
|
mock_time.return_value = 1000.99
|
|
memcache_client.set('some_key', [1, 2, 3])
|
|
last_stats = self.logger.log_dict['timing_since'][-1]
|
|
self.assertEqual('memcached.set.timing', last_stats[0][0])
|
|
self.assertEqual(last_stats[0][1], 1000.99)
|
|
mock_time.return_value = 2000.99
|
|
self.assertEqual(memcache_client.get('some_key'), [1, 2, 3])
|
|
last_stats = self.logger.log_dict['timing_since'][-1]
|
|
self.assertEqual('memcached.get.timing', last_stats[0][0])
|
|
self.assertEqual(last_stats[0][1], 2000.99)
|
|
mock_time.return_value = 3000.99
|
|
self.assertEqual(memcache_client.decr('decr_key', delta=5), 0)
|
|
last_stats = self.logger.log_dict['timing_since'][-1]
|
|
self.assertEqual('memcached.decr.timing', last_stats[0][0])
|
|
self.assertEqual(last_stats[0][1], 3000.99)
|
|
mock_time.return_value = 4000.99
|
|
self.assertEqual(memcache_client.incr('decr_key', delta=5), 5)
|
|
last_stats = self.logger.log_dict['timing_since'][-1]
|
|
self.assertEqual('memcached.incr.timing', last_stats[0][0])
|
|
self.assertEqual(last_stats[0][1], 4000.99)
|
|
mock_time.return_value = 5000.99
|
|
memcache_client.set_multi(
|
|
{'some_key1': [1, 2, 3], 'some_key2': [4, 5, 6]}, 'multi_key')
|
|
last_stats = self.logger.log_dict['timing_since'][-1]
|
|
self.assertEqual('memcached.set_multi.timing', last_stats[0][0])
|
|
self.assertEqual(last_stats[0][1], 5000.99)
|
|
mock_time.return_value = 6000.99
|
|
self.assertEqual(
|
|
memcache_client.get_multi(
|
|
('some_key2', 'some_key1'),
|
|
'multi_key'),
|
|
[[4, 5, 6],
|
|
[1, 2, 3]])
|
|
last_stats = self.logger.log_dict['timing_since'][-1]
|
|
self.assertEqual('memcached.get_multi.timing', last_stats[0][0])
|
|
self.assertEqual(last_stats[0][1], 6000.99)
|
|
mock_time.return_value = 7000.99
|
|
memcache_client.delete('some_key')
|
|
last_stats = self.logger.log_dict['timing_since'][-1]
|
|
self.assertEqual('memcached.delete.timing', last_stats[0][0])
|
|
self.assertEqual(last_stats[0][1], 7000.99)
|
|
|
|
|
|
class ExcConfigParser(object):
|
|
|
|
def read(self, path):
|
|
raise Exception('read called with %r' % path)
|
|
|
|
|
|
class EmptyConfigParser(object):
|
|
|
|
def read(self, path):
|
|
return False
|
|
|
|
|
|
def get_config_parser(memcache_servers='1.2.3.4:5',
|
|
memcache_max_connections='4',
|
|
section='memcache',
|
|
item_size_warning_threshold='75'):
|
|
_srvs = memcache_servers
|
|
_maxc = memcache_max_connections
|
|
_section = section
|
|
_warn_threshold = item_size_warning_threshold
|
|
|
|
class SetConfigParser(object):
|
|
|
|
def items(self, section_name):
|
|
if section_name != section:
|
|
raise NoSectionError(section_name)
|
|
return {
|
|
'memcache_servers': memcache_servers,
|
|
'memcache_max_connections': memcache_max_connections
|
|
}
|
|
|
|
def read(self, path):
|
|
return True
|
|
|
|
def get(self, section, option):
|
|
if _section == section:
|
|
if option == 'memcache_servers':
|
|
if _srvs == 'error':
|
|
raise NoOptionError(option, section)
|
|
return _srvs
|
|
elif option in ('memcache_max_connections',
|
|
'max_connections'):
|
|
if _maxc == 'error':
|
|
raise NoOptionError(option, section)
|
|
return _maxc
|
|
elif option == 'item_size_warning_threshold':
|
|
if _warn_threshold == 'error':
|
|
raise NoOptionError(option, section)
|
|
return _warn_threshold
|
|
else:
|
|
raise NoOptionError(option, section)
|
|
else:
|
|
raise NoSectionError(option)
|
|
|
|
return SetConfigParser
|
|
|
|
|
|
def start_response(*args):
|
|
pass
|
|
|
|
|
|
class TestLoadMemcache(unittest.TestCase):
|
|
def setUp(self):
|
|
self.logger = debug_logger()
|
|
|
|
def test_conf_default_read(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', ExcConfigParser):
|
|
for d in ({},
|
|
{'memcache_servers': '6.7.8.9:10'},
|
|
{'memcache_max_connections': '30'},
|
|
{'item_size_warning_threshold': 75},
|
|
{'memcache_servers': '6.7.8.9:10',
|
|
'item_size_warning_threshold': '75'},
|
|
{'item_size_warning_threshold': '75',
|
|
'memcache_max_connections': '30'},
|
|
):
|
|
with self.assertRaises(Exception) as catcher:
|
|
memcached.load_memcache(d, self.logger)
|
|
self.assertEqual(
|
|
str(catcher.exception),
|
|
"read called with '/etc/swift/memcache.conf'")
|
|
|
|
def test_conf_set_no_read(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', ExcConfigParser):
|
|
exc = None
|
|
try:
|
|
memcached.load_memcache({
|
|
'memcache_servers': '1.2.3.4:5',
|
|
'memcache_max_connections': '30',
|
|
'item_size_warning_threshold': '80'
|
|
|
|
}, self.logger)
|
|
except Exception as err:
|
|
exc = err
|
|
self.assertIsNone(exc)
|
|
|
|
def test_conf_default(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', EmptyConfigParser):
|
|
memcache = memcached.load_memcache({}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['127.0.0.1:11211'])
|
|
self.assertEqual(
|
|
memcache._client_cache['127.0.0.1:11211'].max_size, 2)
|
|
self.assertEqual(memcache.item_size_warning_threshold, -1)
|
|
|
|
def test_conf_inline(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
memcache = memcached.load_memcache({
|
|
'memcache_servers': '6.7.8.9:10',
|
|
'memcache_max_connections': '5',
|
|
'item_size_warning_threshold': '75'
|
|
}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['6.7.8.9:10'])
|
|
self.assertEqual(
|
|
memcache._client_cache['6.7.8.9:10'].max_size, 5)
|
|
self.assertEqual(memcache.item_size_warning_threshold, 75)
|
|
|
|
def test_conf_inline_ratelimiting(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
memcache = memcached.load_memcache({
|
|
'error_suppression_limit': '5',
|
|
'error_suppression_interval': '2.5',
|
|
}, self.logger)
|
|
self.assertEqual(memcache._error_limit_count, 5)
|
|
self.assertEqual(memcache._error_limit_time, 2.5)
|
|
self.assertEqual(memcache._error_limit_duration, 2.5)
|
|
|
|
def test_conf_inline_tls(self):
|
|
fake_context = mock.Mock()
|
|
with mock.patch.object(ssl, 'create_default_context',
|
|
return_value=fake_context):
|
|
with mock.patch.object(memcached, 'ConfigParser',
|
|
get_config_parser()):
|
|
memcached.load_memcache({
|
|
'tls_enabled': 'true',
|
|
'tls_cafile': 'cafile',
|
|
'tls_certfile': 'certfile',
|
|
'tls_keyfile': 'keyfile',
|
|
}, self.logger)
|
|
ssl.create_default_context.assert_called_with(cafile='cafile')
|
|
fake_context.load_cert_chain.assert_called_with('certfile',
|
|
'keyfile')
|
|
|
|
def test_conf_extra_no_section(self):
|
|
with mock.patch.object(memcached, 'ConfigParser',
|
|
get_config_parser(section='foobar')):
|
|
memcache = memcached.load_memcache({}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['127.0.0.1:11211'])
|
|
self.assertEqual(
|
|
memcache._client_cache['127.0.0.1:11211'].max_size, 2)
|
|
|
|
def test_conf_extra_no_option(self):
|
|
replacement_parser = get_config_parser(
|
|
memcache_servers='error',
|
|
memcache_max_connections='error')
|
|
with mock.patch.object(memcached, 'ConfigParser', replacement_parser):
|
|
memcache = memcached.load_memcache({}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['127.0.0.1:11211'])
|
|
self.assertEqual(
|
|
memcache._client_cache['127.0.0.1:11211'].max_size, 2)
|
|
|
|
def test_conf_inline_other_max_conn(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
memcache = memcached.load_memcache({
|
|
'memcache_servers': '6.7.8.9:10',
|
|
'max_connections': '5'
|
|
}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['6.7.8.9:10'])
|
|
self.assertEqual(
|
|
memcache._client_cache['6.7.8.9:10'].max_size, 5)
|
|
|
|
def test_conf_inline_bad_max_conn(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
memcache = memcached.load_memcache({
|
|
'memcache_servers': '6.7.8.9:10',
|
|
'max_connections': 'bad42',
|
|
}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['6.7.8.9:10'])
|
|
self.assertEqual(
|
|
memcache._client_cache['6.7.8.9:10'].max_size, 4)
|
|
|
|
def test_conf_inline_bad_item_warning_threshold(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
with self.assertRaises(ValueError) as err:
|
|
memcached.load_memcache({
|
|
'memcache_servers': '6.7.8.9:10',
|
|
'item_size_warning_threshold': 'bad42',
|
|
}, self.logger)
|
|
self.assertIn('invalid literal for int() with base 10:',
|
|
str(err.exception))
|
|
|
|
def test_conf_from_extra_conf(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
memcache = memcached.load_memcache({}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['1.2.3.4:5'])
|
|
self.assertEqual(
|
|
memcache._client_cache['1.2.3.4:5'].max_size, 4)
|
|
|
|
def test_conf_from_extra_conf_bad_max_conn(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser(
|
|
memcache_max_connections='bad42')):
|
|
memcache = memcached.load_memcache({}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['1.2.3.4:5'])
|
|
self.assertEqual(
|
|
memcache._client_cache['1.2.3.4:5'].max_size, 2)
|
|
|
|
def test_conf_from_inline_and_maxc_from_extra_conf(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
memcache = memcached.load_memcache({
|
|
'memcache_servers': '6.7.8.9:10'}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['6.7.8.9:10'])
|
|
self.assertEqual(
|
|
memcache._client_cache['6.7.8.9:10'].max_size, 4)
|
|
|
|
def test_conf_from_inline_and_sers_from_extra_conf(self):
|
|
with mock.patch.object(memcached, 'ConfigParser', get_config_parser()):
|
|
memcache = memcached.load_memcache({
|
|
'memcache_servers': '6.7.8.9:10',
|
|
'memcache_max_connections': '42',
|
|
}, self.logger)
|
|
self.assertEqual(memcache.memcache_servers, ['6.7.8.9:10'])
|
|
self.assertEqual(
|
|
memcache._client_cache['6.7.8.9:10'].max_size, 42)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|