class CBAsyncGen:
TIMEOUT = 60 # seconds
def __init__(self, **kwargs):
self.client = TxConnection(quiet=True, **kwargs)
self.client.timeout = self.TIMEOUT
def create(self, key: str, doc: dict, persist_to: int = 0,
replicate_to: int = 0, ttl: int = 0):
return self.client.upsert(key, doc,
persist_to=persist_to,
replicate_to=replicate_to,
ttl=ttl)
def read(self, key: str):
return self.client.get(key)
def update(self, key: str, doc: dict, persist_to: int = 0,
replicate_to: int = 0, ttl: int = 0):
return self.client.upsert(key, doc,
persist_to=persist_to,
replicate_to=replicate_to,
ttl=ttl)
def delete(self, key: str):
return self.client.remove(key)
class CBAsyncGen:
TIMEOUT = 60 # seconds
def __init__(self, **kwargs):
self.client = TxConnection(quiet=True, **kwargs)
self.client.timeout = self.TIMEOUT
def create(self,
key: str,
doc: dict,
persist_to: int = 0,
replicate_to: int = 0):
return self.client.upsert(key,
doc,
persist_to=persist_to,
replicate_to=replicate_to)
def read(self, key: str):
return self.client.get(key)
def update(self,
key: str,
doc: dict,
persist_to: int = 0,
replicate_to: int = 0):
return self.client.upsert(key,
doc,
persist_to=persist_to,
replicate_to=replicate_to)
def delete(self, key: str):
return self.client.remove(key)
class MyClient(object):
def __init__(self):
self.cb = Connection(bucket='default')
self.do_set()
def on_op_error(self, msg):
print "Got operation error!" + str(msg)
def do_set(self):
self.cb.set("foo", "bar").addCallback(self.on_set)
def on_set(self, res):
print res
self.cb.get("foo").addCallback(self.on_get)
def on_get(self, res):
print res
class CBAsyncGen(object):
def __init__(self, **kwargs):
self.client = TxConnection(quiet=True, timeout=60, **kwargs)
def create(self, key, doc, ttl=None):
extra_params = {}
if ttl is None:
extra_params['ttl'] = ttl
return self.client.set(key, doc, **extra_params)
def read(self, key):
return self.client.get(key)
def update(self, key, doc):
return self.client.set(key, doc)
def cas(self, key, doc):
cas = self.client.get(key).cas
return self.client.set(key, doc, cas=cas)
def delete(self, key):
return self.client.delete(key)
class CBAsyncGen(object):
def __init__(self, **kwargs):
self.client = TxConnection(quiet=True, timeout=60, **kwargs)
def create(self, key, doc, ttl=None):
extra_params = {}
if ttl is None:
extra_params['ttl'] = ttl
return self.client.set(key, doc, **extra_params)
def read(self, key):
return self.client.get(key)
def update(self, key, doc):
return self.client.set(key, doc)
def cas(self, key, doc):
cas = self.client.get(key).cas
return self.client.set(key, doc, cas=cas)
def delete(self, key):
return self.client.delete(key)
class CBAsyncGen:
TIMEOUT = 60 # seconds
def __init__(self, use_ssl=False, **kwargs):
self.client = TxConnection(quiet=True, **kwargs)
self.client.timeout = self.TIMEOUT
def create(self, key: str, doc: dict):
return self.client.set(key, doc)
def read(self, key: str):
return self.client.get(key)
def update(self, key: str, doc: dict):
return self.client.set(key, doc)
def delete(self, key: str):
return self.client.delete(key)
class WorkloadGen:
NUM_ITERATIONS = 5
def __init__(self, num_items, host, bucket, password, small=True):
self.num_items = num_items
if small:
self.kv_cls = KeyValueIterator
self.field_cls = NewFieldIterator
else:
self.kv_cls = KeyLargeValueIterator
self.field_cls = NewLargeFieldIterator
self.kv_iterator = self.kv_cls(self.num_items)
self.field_iterator = self.field_cls(self.num_items)
self.cb = Connection(bucket=bucket, host=host, password=password)
self.fraction = 1
self.iteration = 0
def _interrupt(self, err):
logger.interrupt(err.value)
def _on_set(self, *args):
self.counter += 1
if self.counter == self.kv_cls.BATCH_SIZE:
self._set()
def _set(self, *args):
self.counter = 0
try:
for k, v in self.kv_iterator.next():
d = self.cb.set(k, v)
d.addCallback(self._on_set)
d.addErrback(self._interrupt)
except StopIteration:
logger.info('Started iteration: {}-{}'.format(self.iteration,
self.fraction))
self._append()
def run(self):
logger.info('Running initial load: {} items'.format(self.num_items))
d = self.cb.connect()
d.addCallback(self._set)
d.addErrback(self._interrupt)
reactor.run()
def _on_append(self, *args):
self.counter += 1
if self.counter == self.field_cls.BATCH_SIZE:
self._append()
def _on_get(self, rv, f):
v = rv.value
v.append(f)
d = self.cb.set(rv.key, v)
d.addCallback(self._on_append)
d.addErrback(self._interrupt)
def _append(self, *args):
self.counter = 0
try:
for k, f in self.field_iterator.next():
d = self.cb.get(k)
d.addCallback(self._on_get, f)
d.addErrback(self._interrupt)
except StopIteration:
logger.info('Finished iteration: {}-{}'.format(self.iteration,
self.fraction))
if self.fraction == 4:
num_items = self.num_items
self.fraction = 1
self.iteration += 1
if self.iteration == self.NUM_ITERATIONS:
reactor.stop()
else:
self.fraction *= 2
num_items = self.num_items / self.fraction
self.field_iterator = self.field_cls(num_items)
logger.info('Started iteration: {}-{}'.format(self.iteration,
self.fraction))
self._append()
def run_sync_example():
cb = Connection(bucket='default')
rv_set = yield cb.set("foo", "bar")
print rv_set
rv_get = yield cb.get("foo")
print rv_get
class WorkloadGen:
NUM_ITERATIONS = 5
def __init__(self, num_items, host, bucket, password, small=True):
self.num_items = num_items
if small:
self.kv_cls = KeyValueIterator
self.field_cls = NewFieldIterator
else:
self.kv_cls = KeyLargeValueIterator
self.field_cls = NewLargeFieldIterator
self.kv_iterator = self.kv_cls(self.num_items)
self.field_iterator = self.field_cls(self.num_items)
self.cb = Connection(bucket=bucket, host=host, password=password)
self.fraction = 1
self.iteration = 0
def _interrupt(self, err):
logger.interrupt(err.value)
def _on_set(self, *args):
self.counter += 1
if self.counter == self.kv_cls.BATCH_SIZE:
self._set()
def _set(self, *args):
self.counter = 0
try:
for k, v in self.kv_iterator.next():
d = self.cb.set(k, v)
d.addCallback(self._on_set)
d.addErrback(self._interrupt)
except StopIteration:
logger.info('Started iteration: {}-{}'.format(
self.iteration, self.fraction))
self._append()
def run(self):
logger.info('Running initial load: {} items'.format(self.num_items))
d = self.cb.connect()
d.addCallback(self._set)
d.addErrback(self._interrupt)
reactor.run()
def _on_append(self, *args):
self.counter += 1
if self.counter == self.field_cls.BATCH_SIZE:
self._append()
def _on_get(self, rv, f):
v = rv.value
v.append(f)
d = self.cb.set(rv.key, v)
d.addCallback(self._on_append)
d.addErrback(self._interrupt)
def _append(self, *args):
self.counter = 0
try:
for k, f in self.field_iterator.next():
d = self.cb.get(k)
d.addCallback(self._on_get, f)
d.addErrback(self._interrupt)
except StopIteration:
logger.info('Finished iteration: {}-{}'.format(
self.iteration, self.fraction))
if self.fraction == 4:
num_items = self.num_items
self.fraction = 1
self.iteration += 1
if self.iteration == self.NUM_ITERATIONS:
reactor.stop()
else:
self.fraction *= 2
num_items = self.num_items / self.fraction
self.field_iterator = self.field_cls(num_items)
logger.info('Started iteration: {}-{}'.format(
self.iteration, self.fraction))
self._append()
class WorkloadGen:
NUM_ITERATIONS = 5
def __init__(self,
num_items,
host,
bucket,
password,
collections=None,
small=True):
if collections:
self.use_collection = True
else:
self.use_collection = False
self.num_items = num_items
if small:
self.kv_cls = KeyValueIterator
self.field_cls = NewFieldIterator
else:
self.kv_cls = KeyLargeValueIterator
self.field_cls = NewLargeFieldIterator
self.kv_iterator = self.kv_cls(self.num_items)
self.field_iterator = self.field_cls(self.num_items)
cb_version = pkg_resources.get_distribution("couchbase").version
if cb_version[0] == '2':
self.cb = Connection(bucket=bucket, host=host, password=password)
elif cb_version[0] == '3':
connection_string = 'couchbase://{host}?password={password}'
connection_string = connection_string.format(host=host,
password=password)
pass_auth = PasswordAuthenticator(bucket, password)
self.cluster = TxCluster(connection_string=connection_string,
options=ClusterOptions(pass_auth))
self.bucket = self.cluster.bucket(bucket)
self.collection = self.bucket.scope("scope-1").collection(
"collection-1")
self.fraction = 1
self.iteration = 0
def _interrupt(self, err):
logger.interrupt(err.value)
def _on_set(self, *args):
self.counter += 1
if self.counter == self.kv_cls.BATCH_SIZE:
self._set()
def _set(self, *args):
self.counter = 0
try:
for k, v in self.kv_iterator.next():
if self.use_collection:
d = self.collection.upsert(k, v)
d.addCallback(self._on_set)
d.addErrback(self._interrupt)
else:
d = self.cb.set(k, v)
d.addCallback(self._on_set)
d.addErrback(self._interrupt)
except StopIteration:
logger.info('Started iteration: {}-{}'.format(
self.iteration, self.fraction))
self._append()
def run(self):
if self.use_collection:
logger.info('Running initial load: {} items per collection'.format(
self.num_items))
d = self.bucket.on_connect()
d.addCallback(self._set)
d.addErrback(self._interrupt)
else:
logger.info('Running initial load: {} items'.format(
self.num_items))
d = self.cb.connect()
d.addCallback(self._set)
d.addErrback(self._interrupt)
reactor.run()
def _on_append(self, *args):
self.counter += 1
if self.counter == self.field_cls.BATCH_SIZE:
self._append()
def _on_get(self, rv, f, key=None):
if self.use_collection:
v = rv.content
v.append(f)
d = self.collection.upsert(key, v)
d.addCallback(self._on_append)
d.addErrback(self._interrupt)
else:
v = rv.value
v.append(f)
d = self.cb.set(rv.key, v)
d.addCallback(self._on_append)
d.addErrback(self._interrupt)
def _append(self, *args):
self.counter = 0
try:
for k, f in self.field_iterator.next():
if self.use_collection:
d = self.collection.get(k)
d.addCallback(self._on_get, f, k)
d.addErrback(self._interrupt)
else:
d = self.cb.get(k)
d.addCallback(self._on_get, f)
d.addErrback(self._interrupt)
except StopIteration:
logger.info('Finished iteration: {}-{}'.format(
self.iteration, self.fraction))
if self.fraction == 4:
num_items = self.num_items
self.fraction = 1
self.iteration += 1
if self.iteration == self.NUM_ITERATIONS:
reactor.stop()
else:
self.fraction *= 2
num_items = self.num_items / self.fraction
self.field_iterator = self.field_cls(num_items)
logger.info('Started iteration: {}-{}'.format(
self.iteration, self.fraction))
self._append()
from twisted.internet import reactor
from couchbase import experimental
experimental.enable()
from txcouchbase.connection import Connection as TxCouchbase
cb = TxCouchbase(bucket='default')
def on_set(ret):
print("Set key. Result", ret)
def on_get(ret):
print("Got key. Result", ret)
reactor.stop()
cb.set("key", "value").addCallback(on_set)
cb.get("key").addCallback(on_get)
reactor.run()
from twisted.internet import reactor
from txcouchbase.connection import Connection as TxCouchbase
cb = TxCouchbase(bucket='default')
def on_set(ret):
print("Set key. Result", ret)
def on_get(ret):
print("Got key. Result", ret)
reactor.stop()
cb.set("key", "value").addCallback(on_set)
cb.get("key").addCallback(on_get)
reactor.run()
