class MemcachedClientBench(Bench):
def __init__(self):
from couchbase.memcachedclient import MemcachedClient
self.client = MemcachedClient(port=11210)
def sets(self, key, value):
self.client.set(key, 0, 0, value)
def gets(self, key, value):
self.client.get(key)
class MemcachedClientBench(Bench):
def __init__(self):
from couchbase.memcachedclient import MemcachedClient
self.client = MemcachedClient(port=11210)
def sets(self, key, value):
self.client.set(key, 0, 0, value)
def gets(self, key, value):
self.client.get(key)
def direct_client(rest, ip, port, bucket):
bucket_info = rest.get_bucket(bucket)
vBuckets = bucket_info.vbuckets
vbucket_count = len(vBuckets)
for node in bucket_info.nodes:
if node.ip == ip and node.memcached == int(port):
if vbucket_count == 0:
client = MemcachedClient(ip.encode("ascii", "ignore"), int(port))
else:
client = VBucketAwareClient(ip.encode("ascii", "ignore"), int(port))
client.vbucket_count = vbucket_count
client.sasl_auth_plain(bucket_info.name.encode("ascii"), bucket_info.saslPassword.encode("ascii"))
return client
raise Exception(("unexpected error - unable to find ip:%s in this" " cluster" % (ip)))
def __init__(self, name, server):
self.server = server
self.name = name
rest = server._rest()
self.info = rest.get_bucket(self.name)
self.password = self.info.saslPassword
ip, port, rest_username, rest_password = server._rest_info()
formatter_uri = "http://%s:%s/pools/default"
self.mc_client = CouchbaseClient(formatter_uri % (ip, port), self.name,
self.password)
# Fix based on Jon-Eric's comment in
# http://www.couchbase.com/forums/thread/python-memcached-bucket-does-it-work
# Fixes PYCBC-55
if self.info.type == 'memcached':
self.mc_client = MemcachedClient(server.servers[0]['ip'])
self.mc_client.sasl_auth_plain(self.info.name.encode('ascii'),
self.info.saslPassword.encode('ascii'))
self.mc_client.vbucket_count = 1
self.mc_client.done = self.mc_client.close
def direct_client(rest, ip, port, bucket):
bucket_info = rest.get_bucket(bucket)
vBuckets = bucket_info.vbuckets
vbucket_count = len(vBuckets)
for node in bucket_info.nodes:
if node.ip == ip and node.memcached == int(port):
if vbucket_count == 0:
client = MemcachedClient(ip.encode('ascii', 'ignore'),
int(port))
else:
client = VBucketAwareClient(ip.encode('ascii', 'ignore'),
int(port))
client.vbucket_count = vbucket_count
client.sasl_auth_plain(bucket_info.name.encode('ascii'),
bucket_info.saslPassword
.encode('ascii'))
return client
raise Exception(("unexpected error - unable to find ip:%s in this"
" cluster" % (ip)))
def setUp(self):
super(MemcachedClientTest, self).setUp()
# TODO: pull memcached port from config
self.client = MemcachedClient(self.host)
class MemcachedClientTest(Base):
def setUp(self):
super(MemcachedClientTest, self).setUp()
# TODO: pull memcached port from config
self.client = MemcachedClient(self.host)
def tearDown(self):
pass
@attr(cbv="1.0.0")
def test_simple_add(self):
key = 'test_simple_add'
try:
# delete the key we want to use, so we don't get a conflict while
# running the test
self.client.delete(key)
except MemcachedError as err:
if err.status == 1:
# if the above fails, the key didn't exist, and we can continue
pass
else:
raise err
self.client.add(key, 0, 0, 'value')
self.assertTrue(self.client.get(key)[2] == 'value')
# now let's try and add one on purpose that we know exist and make sure
# we're throwing the error properly
self.assertRaises(MemcachedError, self.client.add, key, 0, 0,
'other value')
self.client.delete(key)
@attr(cbv="1.0.0")
def test_simple_append(self):
key = 'test_simple_append'
self.client.set(key, 0, 0, 'value')
self.client.append(key, 'appended')
self.assertTrue(self.client.get(key)[2] == 'valueappended')
self.client.delete(key)
@attr(cbv="1.0.0")
def test_simple_delete(self):
key = 'test_simple_delete'
self.client.set(key, 0, 0, 'value')
self.client.delete(key)
self.assertRaises(MemcachedError, self.client.get, key)
@attr(cbv="1.0.0")
def test_simple_decr(self):
key = 'test_simple_decr'
self.client.set(key, 0, 0, '4')
self.client.decr(key, 1)
self.assertTrue(self.client.get(key)[2] == 3)
# test again using set with an int
self.client.set(key, 0, 0, 4)
self.client.decr(key, 1)
self.assertTrue(self.client.get(key)[2] == 3)
self.client.delete(key)
@attr(cbv="1.0.0")
def test_simple_incr(self):
key = 'test_simple_incr'
self.client.set(key, 0, 0, '1')
self.client.incr(key, 1)
self.assertTrue(self.client.get(key)[2] == 2)
# test again using set with an int
self.client.set(key, 0, 0, 1)
self.client.incr(key, 1)
self.assertTrue(self.client.get(key)[2] == 2)
self.client.delete(key)
@attr(cbv="1.0.0")
def test_simple_get(self):
key = 'test_simple_get'
try:
self.client.get(key)
raise Exception('Key existed that should not have')
except MemcachedError as e:
if e.status != 1:
raise e
self.client.set(key, 0, 0, 'value')
self.assertTrue(self.client.get(key)[2] == 'value')
self.client.delete(key)
@attr(cbv="1.0.0")
def test_simple_prepend(self):
key = 'test_simple_prepend'
self.client.set(key, 0, 0, 'value')
self.client.prepend(key, 'prepend')
self.assertTrue(self.client.get(key)[2] == 'prependvalue')
self.client.delete(key)
@attr(cbv="1.0.0")
def test_simple_replace(self):
key = 'test_simple_replace'
self.client.set(key, 0, 0, 'value')
self.client.replace(key, 0, 0, 'replaced')
self.assertTrue(self.client.get(key)[2] == 'replaced')
self.client.delete(key)
@attr(cbv="1.0.0")
def test_set_and_get(self):
kvs = [('test_set_and_get_%d' % i, str(uuid.uuid4())) \
for i in range(0, 100)]
for k, v in kvs:
self.client.set(k, 0, 0, v)
for k, v in kvs:
value = self.client.get(k)[2]
self.assertEqual(v, value)
for k, v in kvs:
self.client.delete(k)
@attr(cbv="1.0.0")
def test_set_and_delete(self):
kvs = [('test_set_and_delete_%d' % i, str(uuid.uuid4())) \
for i in range(0, 100)]
for k, v in kvs:
self.client.set(k, 0, 0, v)
for k, v in kvs:
self.assertTrue(isinstance(self.client.delete(k), tuple))
self.assertRaises(MemcachedError, self.client.get, k)
@attr(cbv="1.0.0")
def test_version(self):
self.assertIsInstance(self.client.version()[2], str)
@attr(cbv="1.0.0")
def test_sasl_mechanisms(self):
try:
# testing for SASL enabled Memcached servers
self.assertIsInstance(self.client.sasl_mechanisms(), frozenset)
except MemcachedConfigurationError:
self.assertRaises(MemcachedConfigurationError,
self.client.sasl_mechanisms)
@attr(cbv="1.0.0")
def test_getMulti(self):
for kv in [{'test_getMulti_key1': 'value1',
'test_getMulti_key2': 'value2'},
{'test_getMulti_int1': 1, 'test_getMulti_int2': 2}]:
for k in kv:
self.client.set(k, 0, 0, kv[k])
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
# Trigger a warning.
rv = self.client.getMulti(kv.keys())
# Verify some things
self.assertTrue(len(w) == 1)
self.assertTrue("deprecated" in str(w[-1].message))
for k in kv:
self.assertIn(k, rv)
self.assertEqual(rv[k][2], kv[k])
self.client.delete(k)
@attr(cbv="1.0.0")
def test_get_multi(self):
for kv in [{'test_get_multi_key1': 'value1',
'test_get_multi_key2': 'value2'},
{'test_get_multi_int1': 1, 'test_get_multi_int2': 2}]:
for k in kv:
self.client.set(k, 0, 0, kv[k])
rv = self.client.get_multi(kv.keys())
for k in kv:
self.assertIn(k, rv)
self.assertEqual(rv[k][2], kv[k])
self.client.delete(k)
@attr(cbv="1.0.0")
def test_cas(self):
key = 'test_cas'
cas = self.client.set(key, 0, 0, 'testing')[1]
self.assertEqual(cas, self.client.get(key)[1])
self.client.cas(key, 0, 0, cas, 'testing some more')
_, new_cas, value = self.client.get(key)
self.assertNotEqual(cas, new_cas)
self.assertEqual(value, 'testing some more')
def __init__(self):
from couchbase.memcachedclient import MemcachedClient
self.client = MemcachedClient(port=11210)
class Bucket(object):
"""Handles Bucket management as well as key/value access for a specific
bucket."""
def __init__(self, name, server):
self.server = server
self.name = name
rest = server._rest()
self.info = rest.get_bucket(self.name)
self.password = self.info.saslPassword
ip, port, rest_username, rest_password = server._rest_info()
formatter_uri = "http://%s:%s/pools/default"
self.mc_client = CouchbaseClient(formatter_uri % (ip, port), self.name,
self.password)
# Fix based on Jon-Eric's comment in
# http://www.couchbase.com/forums/thread/python-memcached-bucket-does-it-work
# Fixes PYCBC-55
if self.info.type == 'memcached':
self.mc_client = MemcachedClient(server.servers[0]['ip'])
self.mc_client.sasl_auth_plain(self.info.name.encode('ascii'),
self.info.saslPassword.encode('ascii'))
self.mc_client.vbucket_count = 1
self.mc_client.done = self.mc_client.close
def __del__(self):
self.mc_client.done()
def append(self, key, value, cas=0):
return self.mc_client.append(key, value, cas)
def prepend(self, key, value, cas=0):
return self.mc_client.prepend(key, value, cas)
def incr(self, key, amt=1, init=0, exp=0):
return self.mc_client.incr(key, amt, init, exp)
def decr(self, key, amt=1, init=0, exp=0):
return self.mc_client.decr(key, amt, init, exp)
def set(self, key, expiration, flags, value):
if isinstance(value, dict):
value = json.dumps(value)
return self.mc_client.set(key, expiration, flags, value)
def add(self, key, exp, flags, val):
return self.mc_client.add(key, exp, flags, val)
def replace(self, key, exp, flags, val):
return self.mc_client.replace(key, exp, flags, val)
def get(self, key):
return self.mc_client.get(key)
def getl(self, key, exp=15):
return self.mc_client.getl(key, exp)
def cas(self, key, exp, flags, oldVal, val):
return self.mc_client.cas(key, exp, flags, oldVal, val)
def touch(self, key, exp):
return self.mc_client.touch(key, exp)
def gat(self, key, exp):
return self.mc_client.gat(key, exp)
def stats(self, sub=''):
return self.mc_client.stats(sub)
def delete(self, key, cas=0):
if key.startswith('_design/'):
# this is a design doc, we need to handle it differently
view = key.split('/')[1]
rest = self.server._rest()
rest.delete_view(self.name, view)
else:
return self.mc_client.delete(key, cas)
def save(self, document):
warnings.warn("save is deprecated; use set instead",
DeprecationWarning)
value = deepcopy(document)
if '_id' in value:
key = value['_id']
del value['_id']
else:
key = str(uuid.uuid4())
if '$flags' in value:
flags = value['$flags']
del value['$flags']
else:
flags = 0
if '$expiration' in value:
expiration = value['$expiration']
del value['$expiration']
else:
expiration = 0
if key.startswith('_design/'):
self[key] = value
else:
if '_rev' in value:
# couchbase works in clobber mode so for "set" _rev is useless
del value['_rev']
self.set(key, expiration, flags, json.dumps(value))
return key
def __setitem__(self, key, value):
if isinstance(value, dict):
if 'expiration' in value or 'flags' in value:
assert 'value' in value
if isinstance(value['value'], dict):
v = json.dumps(value['value'])
else:
v = value['value']
self.set(key, value.get('expiration', 0),
value.get('flags', 0), v)
elif key.startswith('_design/'):
rest = self.server._rest()
rest.create_design_doc(self.name, key[8:], json.dumps(value))
else:
self.set(key, 0, 0, json.dumps(value))
else:
self.set(key, 0, 0, value)
def __getitem__(self, key):
if key.startswith("_design/"):
rest = self.server._rest()
doc = rest.get_design_doc(self.name, key[8:])
return DesignDoc(key[8:], doc, self)
else:
return self.get(key)
def view(self, view, **options):
params = deepcopy(options)
limit = None
if 'limit' in params:
limit = params['limit']
del params['limit']
if view.startswith("_design/"):
view_s = view.split('/')
view_doc = view_s[1]
view_map = view_s[3]
else:
view_doc = view
view_map = None
rest = self.server._rest()
results = rest.view_results(self.name, view_doc, view_map,
params, limit)
if 'rows' in results:
return results['rows']
else:
return None
def design_docs(self):
"""List all design documents and return DesignDoc objects for each"""
(ip, port, _, _) = self.server._rest_info()
api = ''.join(['http://{0}:{1}'.format(ip, port),
self.info.ddocs['uri']])
r = requests.get(api, auth=(self.server.rest_username,
self.server.rest_password))
ddocs = []
for ddoc in r.json().get('rows'):
ddocs.append(DesignDoc(ddoc['doc']['meta']['id'],
ddoc['doc']['json'], bucket=self))
return ddocs
def flush(self):
"""RESTful Bucket flushing - will destory all the data in a bucket."""
ip, port, rest_username, rest_password = self.server._rest_info()
api = ''.join(["http://{0}:{1}".format(ip, port),
self.info.controllers['flush']])
response = requests.post(api, auth=(rest_username, rest_password))
if response.status_code is 503:
raise Exception("Only buckets of type 'memcached' support flush.")
elif response.status_code is 404:
raise BucketUnavailableException
elif response.status_code is 200:
return True
class MemcachedClientTest(Base):
def setUp(self):
super(MemcachedClientTest, self).setUp()
# TODO: pull memcached port from config
self.client = MemcachedClient(self.host)
def tearDown(self):
self.client.flush()
@attr(cbv="1.0.0")
def test_simple_add(self):
self.client.add('key', 0, 0, 'value')
self.assertTrue(self.client.get('key')[2] == 'value')
@attr(cbv="1.0.0")
def test_simple_append(self):
self.client.set('key', 0, 0, 'value')
self.client.append('key', 'appended')
self.assertTrue(self.client.get('key')[2] == 'valueappended')
@attr(cbv="1.0.0")
def test_simple_delete(self):
self.client.set('key', 0, 0, 'value')
self.client.delete('key')
self.assertRaises(MemcachedError, self.client.get, 'key')
@attr(cbv="1.0.0")
def test_simple_decr(self):
self.client.set('key', 0, 0, '4')
self.client.decr('key', 1)
self.assertTrue(self.client.get('key')[2] == 3)
# test again using set with an int
self.client.set('key', 0, 0, 4)
self.client.decr('key', 1)
self.assertTrue(self.client.get('key')[2] == 3)
@attr(cbv="1.0.0")
def test_simple_incr(self):
self.client.set('key', 0, 0, '1')
self.client.incr('key', 1)
self.assertTrue(self.client.get('key')[2] == 2)
# test again using set with an int
self.client.set('key', 0, 0, 1)
self.client.incr('key', 1)
self.assertTrue(self.client.get('key')[2] == 2)
@attr(cbv="1.0.0")
def test_simple_get(self):
try:
self.client.get('key')
raise Exception('Key existed that should not have')
except MemcachedError as e:
if e.status != 1:
raise e
self.client.set('key', 0, 0, 'value')
self.assertTrue(self.client.get('key')[2] == 'value')
@attr(cbv="1.0.0")
def test_simple_prepend(self):
self.client.set('key', 0, 0, 'value')
self.client.prepend('key', 'prepend')
self.assertTrue(self.client.get('key')[2] == 'prependvalue')
@attr(cbv="1.0.0")
def test_simple_replace(self):
self.client.set('key', 0, 0, 'value')
self.client.replace('key', 0, 0, 'replaced')
self.assertTrue(self.client.get('key')[2] == 'replaced')
@attr(cbv="1.0.0")
def test_set_and_get(self):
kvs = [(str(uuid.uuid4()), str(uuid.uuid4())) for i in range(0, 100)]
for k, v in kvs:
self.client.set(k, 0, 0, v)
for k, v in kvs:
self.client.get(k)
@attr(cbv="1.0.0")
def test_set_and_delete(self):
kvs = [(str(uuid.uuid4()), str(uuid.uuid4())) for i in range(0, 100)]
for k, v in kvs:
self.client.set(k, 0, 0, v)
for k, v in kvs:
self.client.delete(k)
@attr(cbv="1.0.0")
def test_version(self):
self.assertIsInstance(self.client.version()[2], str)
@attr(cbv="1.0.0")
def test_sasl_mechanisms(self):
try:
# testing for SASL enabled Memcached servers
self.assertIsInstance(self.client.sasl_mechanisms(), frozenset)
except MemcachedConfigurationError:
self.assertRaises(MemcachedConfigurationError,
self.client.sasl_mechanisms)
@attr(cbv="1.0.0")
def test_getMulti(self):
for kv in [{'key1': 'value1', 'key2': 'value2'},
{'int1': 1, 'int2': 2}]:
for k in kv:
self.client.set(k, 0, 0, kv[k])
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
# Trigger a warning.
rv = self.client.getMulti(kv.keys())
# Verify some things
self.assertTrue(len(w) == 1)
self.assertTrue("deprecated" in str(w[-1].message))
for k in kv:
self.assertIn(k, rv)
self.assertEqual(rv[k][2], kv[k])
@attr(cbv="1.0.0")
def test_get_multi(self):
for kv in [{'key1': 'value1', 'key2': 'value2'},
{'int1': 1, 'int2': 2}]:
for k in kv:
self.client.set(k, 0, 0, kv[k])
rv = self.client.get_multi(kv.keys())
for k in kv:
self.assertIn(k, rv)
self.assertEqual(rv[k][2], kv[k])
def __init__(self):
from couchbase.memcachedclient import MemcachedClient
self.client = MemcachedClient(port=11210)
