def initialize_game_rules_bucket(bucket=None):
if bucket is None:
bucket = Bucket('couchbase://localhost/game_rules')
# Create the game document for super mario bro's
smb = {
'file_name': '/home/mcsmash/dev/nestopia/smb.nes',
'system': 'NES',
'name': 'Super Mario Brothers and Duck Hunt',
}
try:
bucket.insert('game:1', smb)
except KeyExistsError:
pass
sprite_list = []
for i, fn in enumerate(glob('/home/mcsmash/dev/data/game_playing/sprites/*')):
extensionless = os.path.splitext(os.path.basename(fn))
sprite_list.append({
'id': extensionless,
'path': os.path.abspath(fn)
})
try:
bucket.insert('sprites:1', sprite_list)
except KeyExistsError:
pass
try:
bucket.remove('game_number')
except NotFoundError:
pass
try:
bucket.remove('play_number:1')
except NotFoundError:
pass
bucket.counter('game_number', initial=2)
bucket.counter('play_number:1', initial=1)
def initialize_game_rules_bucket(bucket=None):
if bucket is None:
bucket = Bucket("couchbase://localhost/game_rules")
# Create the game document for super mario bro's
smb = {
"file_name": "/home/mcsmash/dev/nestopia/smb.nes",
"system": "NES",
"name": "Super Mario Brothers and Duck Hunt",
}
try:
bucket.insert("game:1", smb)
except KeyExistsError:
pass
sprite_list = []
for i, fn in enumerate(glob("/home/mcsmash/dev/data/game_playing/sprites/*")):
extensionless = os.path.splitext(os.path.basename(fn))
sprite_list.append({"id": extensionless, "path": os.path.abspath(fn)})
try:
bucket.insert("sprites:1", sprite_list)
except KeyExistsError:
pass
try:
bucket.remove("game_number")
except NotFoundError:
pass
try:
bucket.remove("play_number:1")
except NotFoundError:
pass
bucket.counter("game_number", initial=2)
bucket.counter("play_number:1", initial=1)
class TestStandardCouchDB(unittest.TestCase):
def setup_class(self):
""" Clear all spans before a test run """
self.recorder = tracer.recorder
self.cluster = Cluster('couchbase://%s' % testenv['couchdb_host'])
self.bucket = Bucket('couchbase://%s/travel-sample' %
testenv['couchdb_host'],
username=testenv['couchdb_username'],
password=testenv['couchdb_password'])
def setup_method(self):
self.bucket.upsert('test-key', 1)
time.sleep(0.5)
self.recorder.clear_spans()
def test_vanilla_get(self):
res = self.bucket.get("test-key")
assert (res)
def test_pipeline(self):
pass
def test_upsert(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.upsert("test_upsert", 1)
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'upsert')
def test_upsert_multi(self):
res = None
kvs = dict()
kvs['first_test_upsert_multi'] = 1
kvs['second_test_upsert_multi'] = 1
with tracer.start_active_span('test'):
res = self.bucket.upsert_multi(kvs)
assert (res)
self.assertTrue(res['first_test_upsert_multi'].success)
self.assertTrue(res['second_test_upsert_multi'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'upsert_multi')
def test_insert_new(self):
res = None
try:
self.bucket.remove('test_insert_new')
except NotFoundError:
pass
with tracer.start_active_span('test'):
res = self.bucket.insert("test_insert_new", 1)
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'insert')
def test_insert_existing(self):
res = None
try:
self.bucket.insert("test_insert", 1)
except KeyExistsError:
pass
try:
with tracer.start_active_span('test'):
res = self.bucket.insert("test_insert", 1)
except KeyExistsError:
pass
self.assertIsNone(res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertEqual(cb_span.ec, 1)
# Just search for the substring of the exception class
found = cb_span.data["couchbase"]["error"].find("_KeyExistsError")
self.assertFalse(found == -1, "Error substring not found.")
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'insert')
def test_insert_multi(self):
res = None
kvs = dict()
kvs['first_test_upsert_multi'] = 1
kvs['second_test_upsert_multi'] = 1
try:
self.bucket.remove('first_test_upsert_multi')
self.bucket.remove('second_test_upsert_multi')
except NotFoundError:
pass
with tracer.start_active_span('test'):
res = self.bucket.insert_multi(kvs)
assert (res)
self.assertTrue(res['first_test_upsert_multi'].success)
self.assertTrue(res['second_test_upsert_multi'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'insert_multi')
def test_replace(self):
res = None
try:
self.bucket.insert("test_replace", 1)
except KeyExistsError:
pass
with tracer.start_active_span('test'):
res = self.bucket.replace("test_replace", 2)
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'replace')
def test_replace_non_existent(self):
res = None
try:
self.bucket.remove("test_replace")
except NotFoundError:
pass
try:
with tracer.start_active_span('test'):
res = self.bucket.replace("test_replace", 2)
except NotFoundError:
pass
self.assertIsNone(res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertEqual(cb_span.ec, 1)
# Just search for the substring of the exception class
found = cb_span.data["couchbase"]["error"].find("NotFoundError")
self.assertFalse(found == -1, "Error substring not found.")
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'replace')
def test_replace_multi(self):
res = None
kvs = dict()
kvs['first_test_replace_multi'] = 1
kvs['second_test_replace_multi'] = 1
self.bucket.upsert('first_test_replace_multi', "one")
self.bucket.upsert('second_test_replace_multi', "two")
with tracer.start_active_span('test'):
res = self.bucket.replace_multi(kvs)
assert (res)
self.assertTrue(res['first_test_replace_multi'].success)
self.assertTrue(res['second_test_replace_multi'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'replace_multi')
def test_append(self):
self.bucket.upsert("test_append", "one")
res = None
with tracer.start_active_span('test'):
res = self.bucket.append("test_append", "two")
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'append')
def test_append_multi(self):
res = None
kvs = dict()
kvs['first_test_append_multi'] = "ok1"
kvs['second_test_append_multi'] = "ok2"
self.bucket.upsert('first_test_append_multi', "one")
self.bucket.upsert('second_test_append_multi', "two")
with tracer.start_active_span('test'):
res = self.bucket.append_multi(kvs)
assert (res)
self.assertTrue(res['first_test_append_multi'].success)
self.assertTrue(res['second_test_append_multi'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'append_multi')
def test_prepend(self):
self.bucket.upsert("test_prepend", "one")
res = None
with tracer.start_active_span('test'):
res = self.bucket.prepend("test_prepend", "two")
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'prepend')
def test_prepend_multi(self):
res = None
kvs = dict()
kvs['first_test_prepend_multi'] = "ok1"
kvs['second_test_prepend_multi'] = "ok2"
self.bucket.upsert('first_test_prepend_multi', "one")
self.bucket.upsert('second_test_prepend_multi', "two")
with tracer.start_active_span('test'):
res = self.bucket.prepend_multi(kvs)
assert (res)
self.assertTrue(res['first_test_prepend_multi'].success)
self.assertTrue(res['second_test_prepend_multi'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'prepend_multi')
def test_get(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.get("test-key")
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'get')
def test_rget(self):
res = None
try:
with tracer.start_active_span('test'):
res = self.bucket.rget("test-key", replica_index=None)
except CouchbaseTransientError:
pass
self.assertIsNone(res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertEqual(cb_span.ec, 1)
# Just search for the substring of the exception class
found = cb_span.data["couchbase"]["error"].find(
"CouchbaseTransientError")
self.assertFalse(found == -1, "Error substring not found.")
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'rget')
def test_get_not_found(self):
res = None
try:
self.bucket.remove('test_get_not_found')
except NotFoundError:
pass
try:
with tracer.start_active_span('test'):
res = self.bucket.get("test_get_not_found")
except NotFoundError:
pass
self.assertIsNone(res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertEqual(cb_span.ec, 1)
# Just search for the substring of the exception class
found = cb_span.data["couchbase"]["error"].find("NotFoundError")
self.assertFalse(found == -1, "Error substring not found.")
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'get')
def test_get_multi(self):
res = None
self.bucket.upsert('first_test_get_multi', "one")
self.bucket.upsert('second_test_get_multi', "two")
with tracer.start_active_span('test'):
res = self.bucket.get_multi(
['first_test_get_multi', 'second_test_get_multi'])
assert (res)
self.assertTrue(res['first_test_get_multi'].success)
self.assertTrue(res['second_test_get_multi'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'get_multi')
def test_touch(self):
res = None
self.bucket.upsert("test_touch", 1)
with tracer.start_active_span('test'):
res = self.bucket.touch("test_touch")
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'touch')
def test_touch_multi(self):
res = None
self.bucket.upsert('first_test_touch_multi', "one")
self.bucket.upsert('second_test_touch_multi', "two")
with tracer.start_active_span('test'):
res = self.bucket.touch_multi(
['first_test_touch_multi', 'second_test_touch_multi'])
assert (res)
self.assertTrue(res['first_test_touch_multi'].success)
self.assertTrue(res['second_test_touch_multi'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'touch_multi')
def test_lock(self):
res = None
self.bucket.upsert("test_lock_unlock", "lock_this")
with tracer.start_active_span('test'):
rv = self.bucket.lock("test_lock_unlock", ttl=5)
assert (rv)
self.assertTrue(rv.success)
# upsert automatically unlocks the key
res = self.bucket.upsert("test_lock_unlock", "updated", rv.cas)
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
filter = lambda span: span.n == "couchbase" and span.data["couchbase"][
"type"] == "lock"
cb_lock_span = get_first_span_by_filter(spans, filter)
assert (cb_lock_span)
filter = lambda span: span.n == "couchbase" and span.data["couchbase"][
"type"] == "upsert"
cb_upsert_span = get_first_span_by_filter(spans, filter)
assert (cb_upsert_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_lock_span.t)
self.assertEqual(test_span.t, cb_upsert_span.t)
self.assertEqual(cb_lock_span.p, test_span.s)
self.assertEqual(cb_upsert_span.p, test_span.s)
assert (cb_lock_span.stack)
self.assertIsNone(cb_lock_span.ec)
assert (cb_upsert_span.stack)
self.assertIsNone(cb_upsert_span.ec)
self.assertEqual(cb_lock_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_lock_span.data["couchbase"]["bucket"],
'travel-sample')
self.assertEqual(cb_lock_span.data["couchbase"]["type"], 'lock')
self.assertEqual(cb_upsert_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_upsert_span.data["couchbase"]["bucket"],
'travel-sample')
self.assertEqual(cb_upsert_span.data["couchbase"]["type"], 'upsert')
def test_lock_unlock(self):
res = None
self.bucket.upsert("test_lock_unlock", "lock_this")
with tracer.start_active_span('test'):
rv = self.bucket.lock("test_lock_unlock", ttl=5)
assert (rv)
self.assertTrue(rv.success)
# upsert automatically unlocks the key
res = self.bucket.unlock("test_lock_unlock", rv.cas)
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
filter = lambda span: span.n == "couchbase" and span.data["couchbase"][
"type"] == "lock"
cb_lock_span = get_first_span_by_filter(spans, filter)
assert (cb_lock_span)
filter = lambda span: span.n == "couchbase" and span.data["couchbase"][
"type"] == "unlock"
cb_unlock_span = get_first_span_by_filter(spans, filter)
assert (cb_unlock_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_lock_span.t)
self.assertEqual(test_span.t, cb_unlock_span.t)
self.assertEqual(cb_lock_span.p, test_span.s)
self.assertEqual(cb_unlock_span.p, test_span.s)
assert (cb_lock_span.stack)
self.assertIsNone(cb_lock_span.ec)
assert (cb_unlock_span.stack)
self.assertIsNone(cb_unlock_span.ec)
self.assertEqual(cb_lock_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_lock_span.data["couchbase"]["bucket"],
'travel-sample')
self.assertEqual(cb_lock_span.data["couchbase"]["type"], 'lock')
self.assertEqual(cb_unlock_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_unlock_span.data["couchbase"]["bucket"],
'travel-sample')
self.assertEqual(cb_unlock_span.data["couchbase"]["type"], 'unlock')
def test_lock_unlock_muilti(self):
res = None
self.bucket.upsert("test_lock_unlock_multi_1", "lock_this")
self.bucket.upsert("test_lock_unlock_multi_2", "lock_this")
keys_to_lock = ("test_lock_unlock_multi_1", "test_lock_unlock_multi_2")
with tracer.start_active_span('test'):
rv = self.bucket.lock_multi(keys_to_lock, ttl=5)
assert (rv)
self.assertTrue(rv['test_lock_unlock_multi_1'].success)
self.assertTrue(rv['test_lock_unlock_multi_2'].success)
res = self.bucket.unlock_multi(rv)
assert (res)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
filter = lambda span: span.n == "couchbase" and span.data["couchbase"][
"type"] == "lock_multi"
cb_lock_span = get_first_span_by_filter(spans, filter)
assert (cb_lock_span)
filter = lambda span: span.n == "couchbase" and span.data["couchbase"][
"type"] == "unlock_multi"
cb_unlock_span = get_first_span_by_filter(spans, filter)
assert (cb_unlock_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_lock_span.t)
self.assertEqual(test_span.t, cb_unlock_span.t)
self.assertEqual(cb_lock_span.p, test_span.s)
self.assertEqual(cb_unlock_span.p, test_span.s)
assert (cb_lock_span.stack)
self.assertIsNone(cb_lock_span.ec)
assert (cb_unlock_span.stack)
self.assertIsNone(cb_unlock_span.ec)
self.assertEqual(cb_lock_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_lock_span.data["couchbase"]["bucket"],
'travel-sample')
self.assertEqual(cb_lock_span.data["couchbase"]["type"], 'lock_multi')
self.assertEqual(cb_unlock_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_unlock_span.data["couchbase"]["bucket"],
'travel-sample')
self.assertEqual(cb_unlock_span.data["couchbase"]["type"],
'unlock_multi')
def test_remove(self):
res = None
self.bucket.upsert("test_remove", 1)
with tracer.start_active_span('test'):
res = self.bucket.remove("test_remove")
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'remove')
def test_remove_multi(self):
res = None
self.bucket.upsert("test_remove_multi_1", 1)
self.bucket.upsert("test_remove_multi_2", 1)
keys_to_remove = ("test_remove_multi_1", "test_remove_multi_2")
with tracer.start_active_span('test'):
res = self.bucket.remove_multi(keys_to_remove)
assert (res)
self.assertTrue(res['test_remove_multi_1'].success)
self.assertTrue(res['test_remove_multi_2'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'remove_multi')
def test_counter(self):
res = None
self.bucket.upsert("test_counter", 1)
with tracer.start_active_span('test'):
res = self.bucket.counter("test_counter", delta=10)
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'counter')
def test_counter_multi(self):
res = None
self.bucket.upsert("first_test_counter", 1)
self.bucket.upsert("second_test_counter", 1)
with tracer.start_active_span('test'):
res = self.bucket.counter_multi(
("first_test_counter", "second_test_counter"))
assert (res)
self.assertTrue(res['first_test_counter'].success)
self.assertTrue(res['second_test_counter'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'counter_multi')
def test_mutate_in(self):
res = None
self.bucket.upsert(
'king_arthur', {
'name': 'Arthur',
'email': '*****@*****.**',
'interests': ['Holy Grail', 'African Swallows']
})
with tracer.start_active_span('test'):
res = self.bucket.mutate_in(
'king_arthur', SD.array_addunique('interests', 'Cats'),
SD.counter('updates', 1))
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'mutate_in')
def test_lookup_in(self):
res = None
self.bucket.upsert(
'king_arthur', {
'name': 'Arthur',
'email': '*****@*****.**',
'interests': ['Holy Grail', 'African Swallows']
})
with tracer.start_active_span('test'):
res = self.bucket.lookup_in('king_arthur', SD.get('email'),
SD.get('interests'))
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'lookup_in')
def test_stats(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.stats()
assert (res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'stats')
def test_ping(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.ping()
assert (res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'ping')
def test_diagnostics(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.diagnostics()
assert (res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'diagnostics')
def test_observe(self):
res = None
self.bucket.upsert('test_observe', 1)
with tracer.start_active_span('test'):
res = self.bucket.observe('test_observe')
assert (res)
self.assertTrue(res.success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'observe')
def test_observe_multi(self):
res = None
self.bucket.upsert('test_observe_multi_1', 1)
self.bucket.upsert('test_observe_multi_2', 1)
keys_to_observe = ('test_observe_multi_1', 'test_observe_multi_2')
with tracer.start_active_span('test'):
res = self.bucket.observe_multi(keys_to_observe)
assert (res)
self.assertTrue(res['test_observe_multi_1'].success)
self.assertTrue(res['test_observe_multi_2'].success)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'observe_multi')
def test_raw_n1ql_query(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.n1ql_query("SELECT 1")
assert (res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'n1ql_query')
self.assertEqual(cb_span.data["couchbase"]["sql"], 'SELECT 1')
def test_n1ql_query(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.n1ql_query(
N1QLQuery(
'SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"'
))
assert (res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'n1ql_query')
self.assertEqual(
cb_span.data["couchbase"]["sql"],
'SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"'
)
class SDKClient(object):
"""Python SDK Client Implementation for testrunner - master branch Implementation"""
def __init__(self, bucket, hosts = ["localhost"] , scheme = "couchbase",
ssl_path = None, uhm_options = None, password=None,
quiet=True, certpath = None, transcoder = None):
self.connection_string = \
self._createString(scheme = scheme, bucket = bucket, hosts = hosts,
certpath = certpath, uhm_options = uhm_options)
self.password = password
self.quiet = quiet
self.transcoder = transcoder
self.default_timeout = 0
self._createConn()
def _createString(self, scheme ="couchbase", bucket = None, hosts = ["localhost"], certpath = None, uhm_options = ""):
connection_string = "{0}://{1}".format(scheme, ", ".join(hosts).replace(" ",""))
if bucket != None:
connection_string = "{0}/{1}".format(connection_string, bucket)
if uhm_options != None:
connection_string = "{0}?{1}".format(connection_string, uhm_options)
if scheme == "couchbases":
if "?" in connection_string:
connection_string = "{0},certpath={1}".format(connection_string, certpath)
else:
connection_string = "{0}?certpath={1}".format(connection_string, certpath)
return connection_string
def _createConn(self):
try:
self.cb = CouchbaseBucket(self.connection_string, password = self.password,
quiet = self.quiet, transcoder = self.transcoder)
self.default_timeout = self.cb.timeout
except BucketNotFoundError as e:
raise
def reconnect(self):
self.cb.close()
self._createConn()
def close(self):
self.cb._close()
def counter_in(self, key, path, delta, create_parents=True, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.counter_in(key, path, delta, create_parents= create_parents, cas= cas, ttl= ttl, persist_to= persist_to, replicate_to= replicate_to)
except CouchbaseError as e:
raise
def arrayappend_in(self, key, path, value, create_parents=True, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.arrayappend_in(key, path, value, create_parents=create_parents, cas=cas, ttl=ttl, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def arrayprepend_in(self, key, path, value, create_parents=True, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.arrayprepend_in(key, path, value, create_parents=create_parents, cas=cas, ttl=ttl, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def arrayaddunique_in(self, key, path, value, create_parents=True, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.addunique_in(key, path, value, create_parents=create_parents, cas=cas, ttl=ttl, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def arrayinsert_in(self, key, path, value, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.arrayinsert_in(key, path, value, cas=cas, ttl=ttl, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def remove_in(self, key, path, cas=0, ttl=0):
try:
self.cb.remove_in(key, path, cas = cas, ttl = ttl)
except CouchbaseError as e:
raise
def mutate_in(self, key, *specs, **kwargs):
try:
self.cb.mutate_in(key, *specs, **kwargs)
except CouchbaseError as e:
raise
def lookup_in(self, key, *specs, **kwargs):
try:
self.cb.lookup_in(key, *specs, **kwargs)
except CouchbaseError as e:
raise
def get_in(self, key, path):
try:
result = self.cb.get_in(key, path)
return self.__translate_get(result)
except CouchbaseError as e:
raise
def exists_in(self, key, path):
try:
self.cb.exists_in(key, path)
except CouchbaseError as e:
raise
def replace_in(self, key, path, value, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.replace_in(key, path, value, cas=cas, ttl=ttl, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def insert_in(self, key, path, value, create_parents=True, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.insert_in(key, path, value, create_parents=create_parents, cas=cas, ttl=ttl, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def upsert_in(self, key, path, value, create_parents=True, cas=0, ttl=0, persist_to=0, replicate_to=0):
try:
return self.cb.upsert_in(key, path, value, create_parents=create_parents, cas=cas, ttl=ttl, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def append(self, key, value, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.append(key, value, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.append(key, value, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def append_multi(self, keys, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.append_multi(keys, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.append_multi(keys, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def prepend(self, key, value, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.prepend(key, value, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
self.cb.prepend(key, value, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def prepend_multi(self, keys, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.prepend_multi(keys, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.prepend_multi(keys, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def replace(self, key, value, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.replace( key, value, cas=cas, ttl=ttl, format=format,
persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.replace( key, value, cas=cas, ttl=ttl, format=format,
persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def replace_multi(self, keys, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.replace_multi( keys, cas=cas, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.replace_multi( keys, cas=cas, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def cas(self, key, value, cas=0, ttl=0, format=None):
return self.cb.replace(key, value, cas=cas,format=format)
def delete(self,key, cas=0, quiet=True, persist_to=0, replicate_to=0):
self.remove(key, cas=cas, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
def remove(self,key, cas=0, quiet=True, persist_to=0, replicate_to=0):
try:
return self.cb.remove(key, cas=cas, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
return self.cb.remove(key, cas=cas, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def delete(self, keys, quiet=True, persist_to=0, replicate_to=0):
return self.remove(self, keys, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
def remove_multi(self, keys, quiet=True, persist_to=0, replicate_to=0):
try:
self.cb.remove_multi(keys, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.remove_multi(keys, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def set(self, key, value, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
return self.upsert(key, value, cas=cas, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
def upsert(self, key, value, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.upsert(key, value, cas, ttl, format, persist_to, replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.upsert(key, value, cas, ttl, format, persist_to, replicate_to)
except CouchbaseError as e:
raise
def set_multi(self, keys, ttl=0, format=None, persist_to=0, replicate_to=0):
return self.upsert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
def upsert_multi(self, keys, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.upsert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.upsert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def insert(self, key, value, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.insert(key, value, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.insert(key, value, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def insert_multi(self, keys, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.insert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.insert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def touch(self, key, ttl = 0):
try:
self.cb.touch(key, ttl=ttl)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.touch(key, ttl=ttl)
except CouchbaseError as e:
raise
def touch_multi(self, keys, ttl = 0):
try:
self.cb.touch_multi(keys, ttl=ttl)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.touch_multi(keys, ttl=ttl)
except CouchbaseError as e:
raise
def decr(self, key, delta=1, initial=None, ttl=0):
self.counter(key, delta=-delta, initial=initial, ttl=ttl)
def decr_multi(self, keys, delta=1, initial=None, ttl=0):
self.counter_multi(keys, delta=-delta, initial=initial, ttl=ttl)
def incr(self, key, delta=1, initial=None, ttl=0):
self.counter(key, delta=delta, initial=initial, ttl=ttl)
def incr_multi(self, keys, delta=1, initial=None, ttl=0):
self.counter_multi(keys, delta=delta, initial=initial, ttl=ttl)
def counter(self, key, delta=1, initial=None, ttl=0):
try:
self.cb.counter(key, delta=delta, initial=initial, ttl=ttl)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.counter(key, delta=delta, initial=initial, ttl=ttl)
except CouchbaseError as e:
raise
def counter_multi(self, keys, delta=1, initial=None, ttl=0):
try:
self.cb.counter_multi(keys, delta=delta, initial=initial, ttl=ttl)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.counter_multi(keys, delta=delta, initial=initial, ttl=ttl)
except CouchbaseError as e:
raise
def get(self, key, ttl=0, quiet=True, replica=False, no_format=False):
try:
rv = self.cb.get(key, ttl=ttl, quiet=quiet, replica=replica, no_format=no_format)
return self.__translate_get(rv)
except CouchbaseError as e:
try:
time.sleep(10)
rv = self.cb.get(key, ttl=ttl, quiet=quiet, replica=replica, no_format=no_format)
return self.__translate_get(rv)
except CouchbaseError as e:
raise
def rget(self, key, replica_index=None, quiet=True):
try:
data = self.rget(key, replica_index=replica_index, quiet=None)
return self.__translate_get(data)
except CouchbaseError as e:
try:
time.sleep(10)
data = self.rget(key, replica_index=replica_index, quiet=None)
return self.__translate_get(data)
except CouchbaseError as e:
raise
def get_multi(self, keys, ttl=0, quiet=True, replica=False, no_format=False):
try:
data = self.cb.get_multi(keys, ttl=ttl, quiet=quiet, replica=replica, no_format=no_format)
return self.__translate_get_multi(data)
except CouchbaseError as e:
try:
time.sleep(10)
data = self.cb.get_multi(keys, ttl=ttl, quiet=quiet, replica=replica, no_format=no_format)
return self.__translate_get_multi(data)
except CouchbaseError as e:
raise
def rget_multi(self, key, replica_index=None, quiet=True):
try:
data = self.cb.rget_multi(key, replica_index=None, quiet=quiet)
return self.__translate_get_multi(data)
except CouchbaseError as e:
try:
time.sleep(10)
data = self.cb.rget_multi(key, replica_index=None, quiet=quiet)
return self.__translate_get_multi(data)
except CouchbaseError as e:
raise
def stats(self, keys=None):
try:
stat_map = self.cb.stats(keys = keys)
return stat_map
except CouchbaseError as e:
try:
time.sleep(10)
return self.cb.stats(keys = keys)
except CouchbaseError as e:
raise
def errors(self, clear_existing=True):
try:
rv = self.cb.errors(clear_existing = clear_existing)
return rv
except CouchbaseError as e:
raise
def observe(self, key, master_only=False):
try:
return self.cb.observe(key, master_only = master_only)
except CouchbaseError as e:
try:
time.sleep(10)
return self.cb.observe(key, master_only = master_only)
except CouchbaseError as e:
raise
def observe_multi(self, keys, master_only=False):
try:
data = self.cb.observe_multi(keys, master_only = master_only)
return self.__translate_observe_multi(data)
except CouchbaseError as e:
try:
time.sleep(10)
data = self.cb.observe_multi(keys, master_only = master_only)
return self.__translate_observe_multi(data)
except CouchbaseError as e:
raise
def endure(self, key, persist_to=-1, replicate_to=-1, cas=0, check_removed=False, timeout=5.0, interval=0.010):
try:
self.cb.endure(key, persist_to=persist_to, replicate_to=replicate_to,
cas=cas, check_removed=check_removed, timeout=timeout, interval=interval)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.endure(key, persist_to=persist_to, replicate_to=replicate_to,
cas=cas, check_removed=check_removed, timeout=timeout, interval=interval)
except CouchbaseError as e:
raise
def endure_multi(self, keys, persist_to=-1, replicate_to=-1, cas=0, check_removed=False, timeout=5.0, interval=0.010):
try:
self.cb.endure(keys, persist_to=persist_to, replicate_to=replicate_to,
cas=cas, check_removed=check_removed, timeout=timeout, interval=interval)
except CouchbaseError as e:
try:
time.sleep(10)
self.cb.endure(keys, persist_to=persist_to, replicate_to=replicate_to,
cas=cas, check_removed=check_removed, timeout=timeout, interval=interval)
except CouchbaseError as e:
raise
def lock(self, key, ttl=0):
try:
data = self.cb.lock(key, ttl = ttl)
return self.__translate_get(data)
except CouchbaseError as e:
try:
time.sleep(10)
data = self.cb.lock(key, ttl = ttl)
return self.__translate_get(data)
except CouchbaseError as e:
raise
def lock_multi(self, keys, ttl=0):
try:
data = self.cb.lock_multi(keys, ttl = ttl)
return self.__translate_get_multi(data)
except CouchbaseError as e:
try:
time.sleep(10)
data = self.cb.lock_multi(keys, ttl = ttl)
return self.__translate_get_multi(data)
except CouchbaseError as e:
raise
def unlock(self, key, ttl=0):
try:
return self.cb.unlock(key)
except CouchbaseError as e:
try:
time.sleep(10)
return self.cb.unlock(key)
except CouchbaseError as e:
raise
def unlock_multi(self, keys):
try:
return self.cb.unlock_multi(keys)
except CouchbaseError as e:
try:
time.sleep(10)
return self.cb.unlock_multi(keys)
except CouchbaseError as e:
raise
def n1ql_query(self, statement, prepared=False):
try:
return N1QLQuery(statement, prepared)
except CouchbaseError as e:
raise
def n1ql_request(self, query):
try:
return N1QLRequest(query, self.cb)
except CouchbaseError as e:
raise
def __translate_get_multi(self, data):
map = {}
if data == None:
return map
for key, result in data.items():
map[key] = [result.flags, result.cas, result.value]
return map
def __translate_get(self, data):
return data.flags, data.cas, data.value
def __translate_delete(self, data):
return data
def __translate_observe(self, data):
return data
def __translate_observe_multi(self, data):
map = {}
if data == None:
return map
for key, result in data.items():
map[key] = result.value
return map
def __translate_upsert_multi(self, data):
map = {}
if data == None:
return map
for key, result in data.items():
map[key] = result
return map
def __translate_upsert_op(self, data):
return data.rc, data.success, data.errstr, data.key
class SDKClient(object):
"""Python SDK Client Implementation for testrunner - master branch Implementation"""
def __init__(self, bucket, hosts = ["localhost"] , scheme = "couchbase",
ssl_path = None, uhm_options = None, password=None,
quiet=False, certpath = None, transcoder = None):
self.connection_string = \
self._createString(scheme = scheme, bucket = bucket, hosts = hosts,
certpath = certpath, uhm_options = uhm_options)
self.password = password
self.quiet = quiet
self.transcoder = transcoder
self._createConn()
def _createString(self, scheme ="couchbase", bucket = None, hosts = ["localhost"], certpath = None, uhm_options = ""):
connection_string = "{0}://{1}".format(scheme, ", ".join(hosts).replace(" ",""))
if bucket != None:
connection_string = "{0}/{1}".format(connection_string, bucket)
if uhm_options != None:
connection_string = "{0}?{1}".format(connection_string, uhm_options)
if scheme == "couchbases":
if "?" in connection_string:
connection_string = "{0},certpath={1}".format(connection_string, certpath)
else:
connection_string = "{0}?certpath={1}".format(connection_string, certpath)
return connection_string
def _createConn(self):
try:
self.cb = CouchbaseBucket(self.connection_string, password = self.password,
quiet = self.quiet, transcoder = self.transcoder)
except BucketNotFoundError as e:
raise
def reconnect(self):
self.cb.close()
self._createConn()
def close(self):
self.cb._close()
def append(self, key, value, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.append(key, value, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def append_multi(self, keys, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.append_multi(keys, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def prepend(self, key, value, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.prepend(key, value, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def prepend_multi(self, keys, cas=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.prepend_multi(keys, cas=cas, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def replace(self, key, value, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.replace( key, value, cas=cas, ttl=ttl, format=format,
persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def replace_multi(self, keys, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.replace_multi( keys, cas=cas, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def cas(self, key, value, cas=0, ttl=0, format=None):
return self.cb.replace(key, value, cas=cas,format=format)
def delete(self,key, cas=0, quiet=None, persist_to=0, replicate_to=0):
self.remove(key, cas=cas, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
def remove(self,key, cas=0, quiet=None, persist_to=0, replicate_to=0):
try:
return self.cb.remove(key, cas=cas, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def delete(self, keys, quiet=None, persist_to=0, replicate_to=0):
return self.remove(self, keys, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
def remove_multi(self, keys, quiet=None, persist_to=0, replicate_to=0):
try:
self.cb.remove_multi(keys, quiet=quiet, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def set(self, key, value, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
return self.upsert(key, value, cas=cas, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
def upsert(self, key, value, cas=0, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.upsert(key, value, cas, ttl, format, persist_to, replicate_to)
except CouchbaseError as e:
raise
def set_multi(self, keys, ttl=0, format=None, persist_to=0, replicate_to=0):
return self.upsert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
def upsert_multi(self, keys, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.upsert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def insert(self, key, value, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.insert(key, value, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def insert_multi(self, keys, ttl=0, format=None, persist_to=0, replicate_to=0):
try:
self.cb.insert_multi(keys, ttl=ttl, format=format, persist_to=persist_to, replicate_to=replicate_to)
except CouchbaseError as e:
raise
def touch(self, key, ttl = 0):
try:
self.cb.touch(key, ttl=ttl)
except CouchbaseError as e:
raise
def touch_multi(self, keys, ttl = 0):
try:
self.cb.touch_multi(keys, ttl=ttl)
except CouchbaseError as e:
raise
def decr(self, key, delta=1, initial=None, ttl=0):
self.counter(key, delta=-delta, initial=initial, ttl=ttl)
def decr_multi(self, keys, delta=1, initial=None, ttl=0):
self.counter_multi(keys, delta=-delta, initial=initial, ttl=ttl)
def incr(self, key, delta=1, initial=None, ttl=0):
self.counter(key, delta=delta, initial=initial, ttl=ttl)
def incr_multi(self, keys, delta=1, initial=None, ttl=0):
self.counter_multi(keys, delta=delta, initial=initial, ttl=ttl)
def counter(self, key, delta=1, initial=None, ttl=0):
try:
self.cb.counter(key, delta=delta, initial=initial, ttl=ttl)
except CouchbaseError as e:
raise
def counter_multi(self, keys, delta=1, initial=None, ttl=0):
try:
self.cb.counter_multi(keys, delta=delta, initial=initial, ttl=ttl)
except CouchbaseError as e:
raise
def get(self, key, ttl=0, quiet=None, replica=False, no_format=False):
try:
rv = self.cb.get(key, ttl=ttl, quiet=quiet, replica=replica, no_format=no_format)
return self.__translate_get(rv)
except CouchbaseError as e:
raise
def rget(self, key, replica_index=None, quiet=None):
try:
data = self.rget(key, replica_index=replica_index, quiet=None)
return self.__translate_get(data)
except CouchbaseError as e:
raise
def get_multi(self, keys, ttl=0, quiet=None, replica=False, no_format=False):
try:
data = self.cb.get_multi(keys, ttl=ttl, quiet=quiet, replica=replica, no_format=no_format)
return self.__translate_get_multi(data)
except CouchbaseError as e:
raise
def rget_multi(self, key, replica_index=None, quiet=None):
try:
data = self.cb.rget_multi(key, replica_index=None, quiet=None)
return self.__translate_get_multi(data)
except CouchbaseError as e:
raise
def stats(self, keys=None):
try:
stat_map = self.cb.stats(keys = keys)
return stat_map
except CouchbaseError as e:
raise
def errors(self, clear_existing=True):
try:
rv = self.cb.errors(clear_existing = clear_existing)
return rv
except CouchbaseError as e:
raise
def observe(self, key, master_only=False):
try:
return self.cb.observe(key, master_only = master_only)
except CouchbaseError as e:
raise
def observe_multi(self, keys, master_only=False):
try:
data = self.cb.observe_multi(keys, master_only = master_only)
return self.__translate_observe_multi(data)
except CouchbaseError as e:
raise
def endure(self, key, persist_to=-1, replicate_to=-1, cas=0, check_removed=False, timeout=5.0, interval=0.010):
try:
self.cb.endure(key, persist_to=persist_to, replicate_to=replicate_to,
cas=cas, check_removed=check_removed, timeout=timeout, interval=interval)
except CouchbaseError as e:
raise
def endure_multi(self, keys, persist_to=-1, replicate_to=-1, cas=0, check_removed=False, timeout=5.0, interval=0.010):
try:
self.cb.endure(keys, persist_to=persist_to, replicate_to=replicate_to,
cas=cas, check_removed=check_removed, timeout=timeout, interval=interval)
except CouchbaseError as e:
raise
def lock(self, key, ttl=0):
try:
data = self.cb.lock(key, ttl = ttl)
return self.__translate_get(data)
except CouchbaseError as e:
raise
def lock_multi(self, keys, ttl=0):
try:
data = self.cb.lock_multi(keys, ttl = ttl)
return self.__translate_get_multi(data)
except CouchbaseError as e:
raise
def unlock(self, key, ttl=0):
try:
return self.cb.unlock(key)
except CouchbaseError as e:
raise
def unlock_multi(self, keys):
try:
return self.cb.unlock_multi(keys)
except CouchbaseError as e:
raise
def __translate_get_multi(self, data):
map = {}
if data == None:
return map
for key, result in data.items():
map[key] = [result.flags, result.cas, result.value]
return map
def __translate_get(self, data):
return data.flags, data.cas, data.value
def __translate_delete(self, data):
return data
def __translate_observe(self, data):
return data
def __translate_observe_multi(self, data):
map = {}
if data == None:
return map
for key, result in data.items():
map[key] = result.value
return map
def __translate_upsert_multi(self, data):
map = {}
if data == None:
return map
for key, result in data.items():
map[key] = result
return map
def __translate_upsert_op(self, data):
return data.rc, data.success, data.errstr, data.key
#!/usr/bin/env python
from __future__ import print_function
from couchbase.bucket import Bucket
cb = Bucket('couchbase://10.0.0.31/default')
# Remove document so we have predictable behavior in this example
# the 'quiet' argument instructs the client not to raise an exception if the
# document doesn't exist, but fail silently (the status can still be retrieved
# from the returned result object)
cb.remove('docid', quiet=True)
# Without the 'initial' parameter, this command would fail if the item doesn't exist
rv = cb.counter('docid', delta=20, initial=100)
print('Delta=20, Initial=100. Current value is:', rv.value)
rv = cb.counter('docid', delta=1)
print('Delta=1. Current value is:', rv.value)
rv = cb.counter('docid', delta=-50)
print('Delta=-50. Current value is:', rv.value)
class CouchbaseMemcacheMirror(object):
def __init__(self, couchbase_uri, memcached_hosts, primary=PRIMARY_COUCHBASE):
"""
:param couchbase_uri: Connection string for Couchbase
:param memcached_hosts: List of Memcached nodes
:param primary: Determines which datastore is authoritative.
This affects how get operations are performed and which datastore
is used for CAS operations.
PRIMARY_COUCHBASE: Couchbase is authoritative
PRIMARY_MEMCACHED: Memcached is authoritative
By default, Couchbase is the primary store
:return:
"""
self.cb = CbBucket(couchbase_uri)
self.mc = McClient(memcached_hosts)
self._primary = primary
@property
def primary(self):
return self._primary
def _cb_get(self, key):
try:
return self.cb.get(key).value
except NotFoundError:
return None
def get(self, key, try_alternate=True):
"""
Gets a document
:param key: The key to retrieve
:param try_alternate: Whether to try the secondary data source if the
item is not found in the primary.
:return: The value as a Python object
"""
if self._primary == PRIMARY_COUCHBASE:
order = [self._cb_get, self.mc.get]
else:
order = [self.mc.get, self._cb_get]
for meth in order:
ret = meth(key)
if ret or not try_alternate:
return ret
return None
def _cb_mget(self, keys):
"""
Internal method to execute a Couchbase multi-get
:param keys: The keys to retrieve
:return: A tuple of {found_key:found_value, ...}, [missing_key1,...]
"""
try:
ok_rvs = self.cb.get_multi(keys)
bad_rvs = {}
except NotFoundError as e:
ok_rvs, bad_rvs = e.split_results()
ok_dict = {k: (v.value, v.cas) for k, v in ok_rvs}
return ok_dict, bad_rvs.keys()
def get_multi(self, keys, try_alternate=True):
"""
Gets multiple items from the server
:param keys: The keys to fetch as an iterable
:param try_alternate: Whether to fetch missing items from alternate store
:return: A dictionary of key:value. Only contains keys which exist and have values
"""
if self._primary == PRIMARY_COUCHBASE:
ok, err = self._cb_get(keys)
if err and try_alternate:
ok.update(self.mc.get_many(err))
return ok
else:
ok = self.mc.get_many(keys)
if len(ok) < len(keys) and try_alternate:
keys_err = set(keys) - set(ok)
ok.update(self._cb_mget(list(keys_err))[0])
return ok
def gets(self, key):
"""
Get an item with its CAS. The item will always be fetched from the primary
data store.
:param key: the key to get
:return: the value of the key, or None if no such value
"""
if self._primary == PRIMARY_COUCHBASE:
try:
rv = self.cb.get(key)
return key, rv.cas
except NotFoundError:
return None, None
else:
return self.mc.gets(key)
def gets_multi(self, keys):
if self._primary == PRIMARY_COUCHBASE:
try:
rvs = self.cb.get_multi(keys)
except NotFoundError as e:
rvs, _ = e.split_results()
return {k: (v.value, v.cas) for k, v in rvs}
else:
# TODO: I'm not sure if this is implemented in HasClient :(
return self.mc.gets_many(keys)
def delete(self, key):
st = Status()
try:
self.cb.remove(key)
except NotFoundError as e:
st.cb_error = e
st.mc_status = self.mc.delete(key)
return st
def delete_multi(self, keys):
st = Status()
try:
self.cb.remove_multi(keys)
except NotFoundError as e:
st.cb_error = e
st.mc_status = self.mc.delete_many(keys)
def _do_incrdecr(self, key, value, is_incr):
cb_value = value if is_incr else -value
mc_meth = self.mc.incr if is_incr else self.mc.decr
st = Status()
try:
self.cb.counter(key, delta=cb_value)
except NotFoundError as e:
st.cb_error = e
st.mc_status = mc_meth(key, value)
def incr(self, key, value):
return self._do_incrdecr(key, value, True)
def decr(self, key, value):
return self._do_incrdecr(key, value, False)
def touch(self, key, expire=0):
st = Status()
try:
self.cb.touch(key, ttl=expire)
except NotFoundError as e:
st.cb_error = st
st.mc_status = self.mc.touch(key)
def set(self, key, value, expire=0):
"""
Write first to Couchbase, and then to Memcached
:param key: Key to use
:param value: Value to use
:param expire: If set, the item will expire in the given amount of time
:return: Status object if successful (will always be success).
on failure an exception is raised
"""
self.cb.upsert(key, value, ttl=expire)
self.mc.set(key, value, expire=expire)
return Status()
def set_multi(self, values, expire=0):
"""
Set multiple items.
:param values: A dictionary of key, value indicating values to store
:param expire: If present, expiration time for all the items
:return:
"""
self.cb.upsert_multi(values, ttl=expire)
self.mc.set_many(values, expire=expire)
return Status()
def replace(self, key, value, expire=0):
"""
Replace existing items
:param key: key to replace
:param value: new value
:param expire: expiration for item
:return: Status object. Will be OK
"""
status = Status()
try:
self.cb.replace(key, value, ttl=expire)
except NotFoundError as e:
status.cb_error = e
status.mc_status = self.mc.replace(key, value, expire=expire)
return status
def add(self, key, value, expire=0):
status = Status()
try:
self.cb.insert(key, value, ttl=expire)
except KeyExistsError as e:
status.cb_error = e
status.mc_status = self.mc.add(key, value, expire=expire)
return status
def _append_prepend(self, key, value, is_append):
cb_meth = self.cb.append if is_append else self.cb.prepend
mc_meth = self.mc.append if is_append else self.mc.prepend
st = Status()
try:
cb_meth(key, value, format=FMT_UTF8)
except (NotStoredError, NotFoundError) as e:
st.cb_error = e
st.mc_status = mc_meth(key, value)
def append(self, key, value):
return self._append_prepend(key, value, True)
def prepend(self, key, value):
return self._append_prepend(key, value, False)
def cas(self, key, value, cas, expire=0):
if self._primary == PRIMARY_COUCHBASE:
try:
self.cb.replace(key, value, cas=cas, ttl=expire)
self.mc.set(key, value, ttl=expire)
return True
except KeyExistsError:
return False
except NotFoundError:
return None
else:
return self.mc.cas(key, value, cas)
return self.current_signal
else:
return {}
if __name__ == '__main__':
rom = '/home/mcsmash/dev/nestopia/smb.nes'
data_base_dir = '/home/mcsmash/dev/data/game_playing/frames'
bucket = Bucket('couchbase://localhost/game_rules')
start_screen = '/home/mcsmash/dev/data/game_playing/frames/game_1/trigger_frames/start_screen.png'
start_screen = cv2.imread(start_screen)
game_id = 1
game_info = bucket.get('game:{}'.format(game_id))
try:
play_number = bucket.counter('play_number:{}'.format(game_id)).value
except NotFoundError:
play_number = bucket.counter('play_number:{}'.format(game_id), initial=1).value
data_dir = os.path.join(data_base_dir, 'game_{}'.format(game_id))
if not os.path.exists(data_dir):
os.mkdir(data_dir)
data_dir = os.path.join(data_dir, 'play_number_{}'.format(play_number))
if not os.path.exists(data_dir):
os.mkdir(data_dir)
init_sequence = [
(175, 1, {
'start': True,
}), (225, 1, {