def get_list():
"""Supports starling/peafowl-style queue_<name>_items introspection via stats."""
conn = Client(CONN.split(';'))
queue_list = []
queue_re = re.compile(r'queue\_(.*?)\_total_items')
try:
for server in conn.get_stats():
for key in server[1].keys():
if queue_re.findall(key):
queue_list.append(queue_re.findall(key)[0])
except (KeyError, AttributeError, memcache.MemcachedKeyError, MemcachedStringEncodingError):
pass
return queue_list
def get_list():
"""Supports starling/peafowl-style queue_<name>_items introspection via stats."""
conn = Client(CONN.split(';'))
queue_list = []
queue_re = re.compile(r'queue\_(.*?)\_total_items')
try:
for server in conn.get_stats():
for key in server[1].keys():
if queue_re.findall(key):
queue_list.append(queue_re.findall(key)[0])
except (KeyError, AttributeError, memcache.MemcachedKeyError,
MemcachedStringEncodingError):
pass
return queue_list
class Queue(BaseQueue):
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
def read(self):
try:
return self._connection.get(self.name)
except (memcache.MemcachedKeyError, MemcachedStringEncodingError), e:
raise QueueException, e
class Queue(BaseQueue):
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
def read(self):
try:
return self._connection.get(self.name)
except (memcache.MemcachedKeyError, MemcachedStringEncodingError), e:
raise QueueException, e
def __init__(self, use_memcache, memcache_time=60 * 60 * 24 * 7,
memcache_host=None, item_prefix='template/', client=None):
if memcache_host is None:
memcache_host = ['127.0.0.1:11211']
if use_memcache:
if client is None:
try:
try:
from cmemcache import Client
except ImportError:
from memcache import Client
except ImportError:
raise RuntimeError('the %r loader requires an installed '
'memcache module' %
self.__class__.__name__)
client = Client(list(memcache_host))
self.__memcache = client
self.__memcache_time = memcache_time
else:
self.__memcache = None
self.__item_prefix = item_prefix
self.__lock = Lock()
class TestPeafowl(unittest.TestCase):
def setUp(self):
self.memcache = Client(['127.0.0.1:21122'])
def tearDown(self):
self.memcache.disconnect_all()
def test_set_and_get_one_entry(self):
v = random.randint(1, 32)
self.assertEqual(None, self.memcache.get('test_set_and_get_one_entry'))
self.memcache.set('test_set_and_get_one_entry', v)
self.assertEqual(v, self.memcache.get('test_set_and_get_one_entry'))
def test_set_with_expiry(self):
v = random.randint(1, 32)
self.assertEqual(None, self.memcache.get('test_set_with_expiry'))
now = time.time()
self.memcache.set('test_set_with_expiry', v + 2, now)
self.memcache.set('test_set_with_expiry', v)
time.sleep(now + 1 - time.time())
self.assertEqual(v, self.memcache.get('test_set_with_expiry'))
def test_long_value(self):
string = ''.join([
random.choice(
"abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789")
for i in range(300)
])
self.memcache.set('test_long_value', string)
string = self.memcache.get('test_long_value')
self.assertEqual(len(string), 300)
def test_stats(self):
(key, stats) = self.memcache.get_stats()[0]
self.assertEqual('127.0.0.1:21122 (1)', key)
keys = [
'bytes', 'pid', 'time', 'limit_maxbytes', 'cmd_get', 'version',
'bytes_written', 'cmd_set', 'get_misses', 'total_connections',
'curr_connections', 'curr_items', 'uptime', 'get_hits',
'total_items', 'rusage_system', 'rusage_user', 'bytes_read'
]
for key in keys:
self.assert_(stats.has_key(key), "key '%s' is not in stats" % key)
def test_unknown_command_returns_valid_result(self):
response = self.memcache.add('blah', 1)
self.assertEqual(False, response)
def test_that_disconnecting_and_reconnecting_works(self):
v = random.randint(1, 32)
self.memcache.set('test_that_disconnecting_and_reconnecting_works', v)
self.memcache.disconnect_all()
self.assertEqual(
v,
int(
self.memcache.get(
'test_that_disconnecting_and_reconnecting_works')))
def setUp(self):
self.memcache = Client(['127.0.0.1:21122'])
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
self._connection.set('%s_head' % self.name, None)
self._connection.set('%s_len' % self.name, 0)
class Queue(BaseQueue):
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
self._connection.set('%s_head' % self.name, None)
self._connection.set('%s_len' % self.name, 0)
def read(self):
try:
_head = self._connection.get('%s_head' % self.name)
if _head:
value, _next = self._connection.get('%s_%s' %
(self.name, _head))
length = self._connection.get('%s_len' % self.name)
self._connection.set('%s_len' % self.name, length - 1)
self._connection.delete('%s_%s' % (self.name, _head))
self._connection.set('%s_head' % self.name, _next)
return value
else:
return None
except Exception:
pass
def write(self, message):
try:
_head = self._connection.get('%s_head' % self.name)
_label = str(uuid1())
_node_value = (message, _head)
self._connection.set('%s_%s' % (self.name, _label), _node_value)
length = self._connection.get('%s_len' % self.name)
self._connection.set('%s_len' % self.name, length + 1)
self._connection.set('%s_head' % self.name, _label)
return True
except Exception:
pass
def __len__(self):
try:
try:
return self._connection.get('%s_len' % self.name)
except Exception:
pass
except AttributeError:
# If this memcached backend doesn't support starling-style stats
# or if this queue doesn't exist
return 0
def __repr__(self):
return "<Queue %s>" % self.name
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
self._connection.set('%s_head' % self.name, None)
self._connection.set('%s_len' % self.name, 0)
class Queue(BaseQueue):
def __init__(self, name):
self._connection = Client(CONN.split(';'))
self.backend = 'memcached'
self.name = name
self._connection.set('%s_head' % self.name, None)
self._connection.set('%s_len' % self.name, 0)
def read(self):
try:
_head = self._connection.get('%s_head' % self.name)
if _head:
value, _next = self._connection.get('%s_%s' % (self.name, _head))
length = self._connection.get('%s_len' % self.name)
self._connection.set('%s_len' % self.name, length - 1)
self._connection.delete('%s_%s' % (self.name, _head))
self._connection.set('%s_head' % self.name, _next)
return value
else:
return None
except Exception:
pass
def write(self, message):
try:
_head = self._connection.get('%s_head' % self.name)
_label = str(uuid1())
_node_value = (message, _head)
self._connection.set('%s_%s' % (self.name, _label), _node_value)
length = self._connection.get('%s_len' % self.name)
self._connection.set('%s_len' % self.name, length + 1)
self._connection.set('%s_head' % self.name, _label)
return True
except Exception:
pass
def __len__(self):
try:
try:
return self._connection.get('%s_len' % self.name)
except Exception:
pass
except AttributeError:
# If this memcached backend doesn't support starling-style stats
# or if this queue doesn't exist
return 0
def __repr__(self):
return "<Queue %s>" % self.name
def setUp(self):
self.memcache = Client(['127.0.0.1:21122'])
class TestPeafowl(unittest.TestCase):
def setUp(self):
self.memcache = Client(['127.0.0.1:21122'])
def tearDown(self):
self.memcache.disconnect_all()
def test_set_and_get_one_entry(self):
v = random.randint(1, 32)
self.assertEqual(None, self.memcache.get('test_set_and_get_one_entry'))
self.memcache.set('test_set_and_get_one_entry', v)
self.assertEqual(v, self.memcache.get('test_set_and_get_one_entry'))
def test_set_with_expiry(self):
v = random.randint(1, 32)
self.assertEqual(None, self.memcache.get('test_set_with_expiry'))
now = time.time()
self.memcache.set('test_set_with_expiry', v + 2, now)
self.memcache.set('test_set_with_expiry', v)
time.sleep(now + 1 - time.time())
self.assertEqual(v, self.memcache.get('test_set_with_expiry'))
def test_long_value(self):
string = ''.join([random.choice("abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789") for i in range(300)])
self.memcache.set('test_long_value', string)
string = self.memcache.get('test_long_value')
self.assertEqual(len(string), 300)
def test_stats(self):
(key, stats) = self.memcache.get_stats()[0]
self.assertEqual('127.0.0.1:21122 (1)', key)
keys = ['bytes', 'pid', 'time', 'limit_maxbytes',
'cmd_get', 'version', 'bytes_written', 'cmd_set',
'get_misses', 'total_connections', 'curr_connections',
'curr_items', 'uptime', 'get_hits', 'total_items',
'rusage_system', 'rusage_user', 'bytes_read']
for key in keys:
self.assert_(stats.has_key(key), "key '%s' is not in stats" % key)
def test_unknown_command_returns_valid_result(self):
response = self.memcache.add('blah', 1)
self.assertEqual(False, response)
def test_that_disconnecting_and_reconnecting_works(self):
v = random.randint(1, 32)
self.memcache.set('test_that_disconnecting_and_reconnecting_works', v)
self.memcache.disconnect_all()
self.assertEqual(v, int(self.memcache.get('test_that_disconnecting_and_reconnecting_works')))
