def __init__(self, **kwargs):
connection_string = 'couchbase://{host}?password={password}'
connection_string = connection_string.format(
host=kwargs['host'], password=kwargs['password'])
pass_auth = PasswordAuthenticator(kwargs['username'],
kwargs['password'])
timeout = ClusterTimeoutOptions(kv_timeout=timedelta(
seconds=self.TIMEOUT))
options = ClusterOptions(authenticator=pass_auth,
timeout_options=timeout)
self.cluster = TxCluster(connection_string=connection_string,
options=options)
self.bucket_name = kwargs['bucket']
self.collections = dict()
self.collection = None
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
class CBAsyncGen3:
TIMEOUT = 120 # seconds
def __init__(self, **kwargs):
connection_string = 'couchbase://{host}?password={password}'
connection_string = connection_string.format(
host=kwargs['host'], password=kwargs['password'])
pass_auth = PasswordAuthenticator(kwargs['username'],
kwargs['password'])
timeout = ClusterTimeoutOptions(kv_timeout=timedelta(
seconds=self.TIMEOUT))
options = ClusterOptions(authenticator=pass_auth,
timeout_options=timeout)
self.cluster = TxCluster(connection_string=connection_string,
options=options)
self.bucket_name = kwargs['bucket']
self.collections = dict()
self.collection = None
def connect_collections(self, scope_collection_list):
self.bucket = self.cluster.bucket(self.bucket_name)
for scope_collection in scope_collection_list:
scope, collection = scope_collection.split(":")
if scope == "_default" and collection == "_default":
self.collections[scope_collection] = \
self.bucket.default_collection()
else:
self.collections[scope_collection] = \
self.bucket.scope(scope).collection(collection)
def create(self, *args, **kwargs):
self.collection = self.collections[args[0]]
return self.do_create(*args[1:], **kwargs)
def do_create(self,
key: str,
doc: dict,
persist_to: int = 0,
replicate_to: int = 0,
ttl: int = 0):
return self.collection.upsert(key,
doc,
persist_to=persist_to,
replicate_to=replicate_to,
ttl=ttl)
def create_durable(self, *args, **kwargs):
self.collection = self.collections[args[0]]
return self.do_create_durable(*args[1:], **kwargs)
def do_create_durable(self,
key: str,
doc: dict,
durability: int = None,
ttl: int = 0):
return self.collection.upsert(key,
doc,
durability_level=durability,
ttl=ttl)
def read(self, *args, **kwargs):
self.collection = self.collections[args[0]]
return self.do_read(*args[1:], **kwargs)
def do_read(self, key: str):
return self.collection.get(key)
def update(self, *args, **kwargs):
self.collection = self.collections[args[0]]
return self.do_update(*args[1:], **kwargs)
def do_update(self,
key: str,
doc: dict,
persist_to: int = 0,
replicate_to: int = 0,
ttl: int = 0):
return self.collection.upsert(key,
doc,
persist_to=persist_to,
replicate_to=replicate_to,
ttl=ttl)
def update_durable(self, *args, **kwargs):
self.collection = self.collections[args[0]]
return self.do_update_durable(*args[1:], **kwargs)
def do_update_durable(self,
key: str,
doc: dict,
durability: int = None,
ttl: int = 0):
return self.collection.upsert(key,
doc,
durability_level=durability,
ttl=ttl)
def delete(self, *args, **kwargs):
self.collection = self.collections[args[0]]
return self.do_delete(*args[1:], **kwargs)
def do_delete(self, key: str):
return self.collection.remove(key)
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 txcouchbase.cluster import TxCluster
from couchbase.cluster import ClusterOptions
from couchbase.auth import PasswordAuthenticator
from couchbase.analytics import AnalyticsOptions
def handle_query_results(result):
for r in result.rows():
print("query row: {}".format(r))
reactor.stop()
cluster = TxCluster(
"couchbase://localhost",
ClusterOptions(PasswordAuthenticator("Administrator", "password")))
# create a bucket object
bucket = cluster.bucket("travel-sample")
# create a collection object
cb = bucket.default_collection()
d = cluster.analytics_query(
"SELECT id, country FROM airports a WHERE a.country = $country LIMIT 10",
AnalyticsOptions(named_parameters={"country": "France"}))
d.addCallback(handle_query_results)
reactor.run()
# end::simple_query[]
from twisted.internet import reactor
from txcouchbase.cluster import TxCluster
from couchbase.cluster import ClusterOptions
from couchbase.auth import PasswordAuthenticator
import couchbase.search as search
def handle_query_results(result):
for r in result.rows():
print("query row: {}".format(r))
reactor.stop()
cluster = TxCluster(
"couchbase://localhost",
ClusterOptions(PasswordAuthenticator("Administrator", "password")))
# create a bucket object
bucket = cluster.bucket("travel-sample")
# create a collection object
cb = bucket.default_collection()
d = cluster.search_query("travel-sample-index",
search.QueryStringQuery("swanky"))
d.addCallback(handle_query_results)
reactor.run()
# end::simple_query[]
# tag::simple_query[]
from twisted.internet import reactor
from txcouchbase.cluster import TxCluster
from couchbase.cluster import ClusterOptions, QueryOptions
from couchbase.auth import PasswordAuthenticator
def handle_query_results(result):
for r in result.rows():
print("query row: {}".format(r))
reactor.stop()
cluster = TxCluster("couchbase://localhost",
ClusterOptions(PasswordAuthenticator("Administrator", "password")))
# create a bucket object
bucket = cluster.bucket("travel-sample")
# create a collection object
cb = bucket.default_collection()
d = cluster.query("SELECT ts.* FROM `travel-sample` ts WHERE ts.`type`=$type LIMIT 10",
QueryOptions(named_parameters={"type": "hotel"}))
d.addCallback(handle_query_results)
reactor.run()
# end::simple_query[]