def key_not_exists_test(self):
self.assertTrue(len(self.buckets) > 0, 'at least 1 bucket required')
bucket = self.buckets[0].name
client = VBucketAwareMemcached(RestConnection(self.master), bucket)
KEY_NAME = 'key'
for i in range(1500):
client.set(KEY_NAME, 0, 0, "x")
# delete and verify get fails
client.delete(KEY_NAME)
err = None
try:
rc = client.get(KEY_NAME)
except MemcachedError as error:
# It is expected to raise MemcachedError because the key is deleted.
err = error.status
self.assertTrue(err == ERR_NOT_FOUND,
'expected key to be deleted {0}'.format(KEY_NAME))
#cas errors do not sleep the test for 10 seconds, plus we need to check that the correct
#error is being thrown
err = None
try:
#For some reason replace instead of cas would not reproduce the bug
mc_active = client.memcached(KEY_NAME)
mc_active.replace(KEY_NAME, 0, 10, "value")
except MemcachedError as error:
err = error.status
self.assertTrue(
err == ERR_NOT_FOUND,
'was able to replace cas on removed key {0}'.format(KEY_NAME))
def key_not_exists_test(self):
self.assertTrue(len(self.buckets) > 0, 'at least 1 bucket required')
bucket = self.buckets[0].name
client = VBucketAwareMemcached(RestConnection(self.master), bucket)
KEY_NAME = 'key'
for i in range(1500):
client.set(KEY_NAME, 0, 0, "x")
# delete and verify get fails
client.delete(KEY_NAME)
err = None
try:
rc = client.get(KEY_NAME)
except MemcachedError as error:
# It is expected to raise MemcachedError because the key is deleted.
err = error.status
self.assertTrue(err == ERR_NOT_FOUND, 'expected key to be deleted {0}'.format(KEY_NAME))
#cas errors do not sleep the test for 10 seconds, plus we need to check that the correct
#error is being thrown
err = None
try:
#For some reason replace instead of cas would not reproduce the bug
mc_active = client.memcached(KEY_NAME)
mc_active.replace(KEY_NAME, 0, 10, "value")
except MemcachedError as error:
err = error.status
self.assertTrue(err == ERR_NOT_FOUND, 'was able to replace cas on removed key {0}'.format(KEY_NAME))
def delete_docs(self, num_of_docs, prefix):
smart = VBucketAwareMemcached(RestConnection(self.master), self.bucket)
doc_names = []
for i in range(0, num_of_docs):
key = "{0}-{1}".format(prefix, i)
try:
smart.delete(key)
except MemcachedError as e:
# Don't care if we try to delete a document that doesn't exist
if e.status == memcacheConstants.ERR_NOT_FOUND:
continue
else:
raise
doc_names.append(key)
self.log.info("deleted {0} json documents".format(len(doc_names)))
return doc_names
def delete_docs(self, num_of_docs, prefix='doc'):
smart = VBucketAwareMemcached(RestConnection(self.master), self.bucket)
doc_names = []
for i in range(0, num_of_docs):
key = "{0}-{1}".format(prefix, i)
try:
smart.delete(key)
except MemcachedError as e:
# Don't care if we try to delete a document that doesn't exist
if e.status == memcacheConstants.ERR_NOT_FOUND:
continue
else:
raise
doc_names.append(key)
self.log.info("deleted {0} json documents".format(len(doc_names)))
return doc_names
class GenericLoadingTask(Thread, Task):
def __init__(self, server, bucket, kv_store):
Thread.__init__(self)
Task.__init__(self, "load_gen_task")
self.kv_store = kv_store
self.client = VBucketAwareMemcached(RestConnection(server), bucket)
def execute(self, task_manager):
self.start()
self.state = EXECUTING
def check(self, task_manager):
pass
def run(self):
while self.has_next() and not self.done():
self.next()
self.state = FINISHED
self.set_result(True)
def has_next(self):
raise NotImplementedError
def next(self):
raise NotImplementedError
def _unlocked_create(self, partition, key, value):
try:
value_json = json.loads(value)
value_json['mutated'] = 0
value = json.dumps(value_json)
except ValueError:
index = random.choice(range(len(value)))
value = value[0:index] + random.choice(string.ascii_uppercase) + value[index+1:]
try:
self.client.set(key, self.exp, 0, value)
partition.set(key, value, self.exp)
except MemcachedError as error:
self.state = FINISHED
self.set_exception(error)
def _unlocked_read(self, partition, key):
try:
o, c, d = self.client.get(key)
except MemcachedError as error:
if error.status == ERR_NOT_FOUND and partition.get_valid(key) is None:
pass
else:
self.state = FINISHED
self.set_exception(error)
def _unlocked_update(self, partition, key):
value = partition.get_valid(key)
if value is None:
return
try:
value_json = json.loads(value)
value_json['mutated'] += 1
value = json.dumps(value_json)
except ValueError:
index = random.choice(range(len(value)))
value = value[0:index] + random.choice(string.ascii_uppercase) + value[index+1:]
try:
self.client.set(key, self.exp, 0, value)
partition.set(key, value, self.exp)
except MemcachedError as error:
self.state = FINISHED
self.set_exception(error)
def _unlocked_delete(self, partition, key):
try:
self.client.delete(key)
partition.delete(key)
except MemcachedError as error:
if error.status == ERR_NOT_FOUND and partition.get_valid(key) is None:
pass
else:
self.state = FINISHED
self.set_exception(error)
