def create_default_views(self, is_one_ddoc=False):
views = [View(self.testcase.default_view_name + "0",
'function (doc) {emit(doc.geometry, doc.age);}',
dev_view=self.testcase.use_dev_views, is_spatial=True),
View(self.testcase.default_view_name + "1",
'function (doc) {emit(doc.geometry, null);}',
dev_view=self.testcase.use_dev_views, is_spatial=True),
View(self.testcase.default_view_name + "2",
'function (doc) {emit(doc.geometry, doc.name);}',
dev_view=self.testcase.use_dev_views, is_spatial=True),
View(self.testcase.default_view_name + "3",
'function (doc) {emit(doc.geometry, [doc.name, doc.age]);}',
dev_view=self.testcase.use_dev_views, is_spatial=True),
View(self.testcase.default_view_name + "4",
'function (doc) {emit(doc.geometry, {result : {age:doc.age}});}',
dev_view=self.testcase.use_dev_views, is_spatial=True)]
ddocs = []
if is_one_ddoc:
ddocs.append(DesignDocument(self.testcase.default_ddoc_name, [],
spatial_views=views))
else:
for i in xrange(5):
ddocs.append(DesignDocument(self.testcase.default_ddoc_name + str(i), [],
spatial_views=[views[i]]))
for ddoc in ddocs:
for view in ddoc.spatial_views:
self.testcase.cluster.create_view(self.testcase.master, ddoc.name, view,
bucket=self.testcase.bucket_name)
return ddocs
def test_add_spatial_views_case_sensative(self):
ddoc = DesignDocument(self.default_ddoc_name, [], spatial_views=[
View(self.default_view_name, self.default_map,
dev_view=self.use_dev_views, is_spatial=True),
View(self.default_view_name.upper(), self.default_map,
dev_view=self.use_dev_views, is_spatial=True)])
self.create_ddocs([ddoc])
def create_ddocs(self, is_dev_view):
mapview = View(self.map_view_name,
'''function(doc) {
emit(doc.integer, doc.string);
}''',
dev_view=is_dev_view)
self.cluster.create_view(self.master, 'test', mapview)
redview = View(self.red_view_name,
'''function(doc) {
emit([doc.integer, doc.string], doc.integer);
}''',
'''_count''',
dev_view=is_dev_view)
self.cluster.create_view(self.master, 'test', redview)
redview_stats = View(self.red_view_stats_name,
'''function(doc) {
emit(doc.string, doc.string);
}''',
'''_stats''',
dev_view=is_dev_view)
self.cluster.create_view(self.master, 'test2', redview_stats)
# The keys view is there to test the `keys` query parameter. In order
# to reproduce the ordering bug (MB-16618) there must be more than
# one document with the same key, hence modulo is used
modulo = self.num_docs / 3
keysview = View(self.keys_view_name,
'''function(doc) {
emit(doc.integer % ''' + str(modulo) + ''', doc.string);
}''',
'_count',
dev_view=is_dev_view)
self.cluster.create_view(self.master, 'test3', keysview)
RebalanceHelper.wait_for_persistence(self.master, self.bucket, 0)
def make_ddocs(self, ddocs_num, views_per_ddoc, non_spatial_views_per_ddoc):
ddocs = []
for i in xrange(ddocs_num):
views = []
for k in xrange(views_per_ddoc):
views.append(View(self.default_view_name + str(k), self.default_map,
dev_view=self.use_dev_views, is_spatial=True))
non_spatial_views = []
if non_spatial_views_per_ddoc:
for k in xrange(non_spatial_views_per_ddoc):
non_spatial_views.append(View(self.default_view_name + str(k), 'function (doc) { emit(null, doc);}',
dev_view=self.use_dev_views))
ddocs.append(DesignDocument(self.default_ddoc_name + str(i), non_spatial_views, spatial_views=views))
return ddocs
def setUp(self):
super(RebalanceBaseTest, self).setUp()
self.doc_ops = self.input.param("doc_ops", "create")
self.doc_size = self.input.param("doc_size", 10)
self.key_size = self.input.param("key_size", 0)
self.zone = self.input.param("zone", 1)
self.default_view_name = "default_view"
self.defaul_map_func = "function (doc) {\n emit(doc._id, doc);\n}"
self.default_view = View(self.default_view_name, self.defaul_map_func,
None)
self.max_verify = self.input.param("max_verify", None)
self.std_vbucket_dist = self.input.param("std_vbucket_dist", None)
self.key = 'test_docs'.rjust(self.key_size, '0')
nodes_init = self.cluster.servers[
1:self.nodes_init] if self.nodes_init != 1 else []
self.task.rebalance([self.cluster.master], nodes_init, [])
self.cluster.nodes_in_cluster.extend([self.cluster.master] +
nodes_init)
self.bucket_util.create_default_bucket(replica=self.num_replicas)
self.bucket_util.add_rbac_user()
self.sleep(10)
self.gen_load = self.get_doc_generator(0, self.num_items)
# gen_update is used for doing mutation for 1/2th of uploaded data
self.gen_update = self.get_doc_generator(0, (self.num_items / 2 - 1))
self.log.info("==========Finished rebalance base setup========")
def perform_view_tasks(viewMsgList):
rest = create_rest()
if isinstance(viewMsgList, dict):
viewMsgList = [viewMsgList]
for viewMsg in viewMsgList:
if "create" in viewMsg:
ddocMsg = parseDdocMsg(viewMsg['create'])
for ddoc_name, views in ddocMsg.items():
view_list = []
bucket_name = ''
for view in views:
view_list.append(View(view['view_name'], view['map_func'], view['red_func'],
view['dev_view'], view['is_spatial']))
bucket_name = view['bucket_name']
bucket_obj = rest.get_bucket(bucket_name, 2, 2)
rest.create_ddoc(ddoc_name, bucket_obj, view_list)
if "delete" in viewMsg:
for view in viewMsg['delete']:
viewMsgParsed = parseViewMsg(view)
bucket_obj = rest.get_bucket(viewMsgParsed['bucket_name'], 2, 2)
rest.delete_view(bucket_obj, viewMsgParsed['ddoc_name'])
def setUp(self):
self.ddoc_name = "tuq_ddoc"
super(QueriesViewsTests, self).setUp()
self.map_fn = 'function (doc){emit([doc.join_yr, doc.join_mo],doc.name);}'
self.view_name = "tuq_view"
self.default_view = View(self.view_name, self.map_fn, None, False)
self.query_buckets = self.get_query_buckets(check_all_buckets=True)
def test_add_single_spatial_view(self):
name_lenght = self.input.param('name_lenght', None)
view_name = self.input.param('view_name', self.default_view_name)
if name_lenght:
view_name = ''.join(
random.choice(string.ascii_lowercase)
for x in range(name_lenght))
not_compilable = self.input.param('not_compilable', False)
error = self.input.param('error', None)
map_fn = (
self.default_map,
'function (doc) {emit(doc.geometry, doc.age);')[not_compilable]
ddoc = DesignDocument(self.default_ddoc_name, [],
spatial_views=[
View(view_name,
map_fn,
dev_view=self.use_dev_views,
is_spatial=True)
])
try:
self.create_ddocs([ddoc])
except Exception as ex:
if error and str(ex).find(error) != -1:
self.log.info("Error caught as expected %s" % error)
return
else:
self.fail("Unexpected error appeared during run %s" % ex)
if error:
self.fail("Expected error '%s' didn't appear" % error)
def test_view_cbcollectinfo_with_collection(self):
self.test_cbworkloadgen_with_collection()
self.default_design_doc_name = "Doc1"
self.view_name = self.input.param("view_name", "View")
self.generate_map_reduce_error = self.input.param(
"map_reduce_error", False)
self.default_map_func = 'function (doc) { emit(doc.age, doc.first_name);}'
self.reduce_fn = "_count"
expected_num_items = self.num_items
if self.generate_map_reduce_error:
self.reduce_fn = "_sum"
expected_num_items = None
view = View(self.view_name,
self.default_map_func,
self.reduce_fn,
dev_view=False)
self.cluster.create_view(self.master, self.default_design_doc_name,
view, 'default', self.wait_timeout * 2)
query = {"stale": "false", "connection_timeout": 60000}
try:
self.cluster.query_view(self.master,
self.default_design_doc_name,
self.view_name,
query,
expected_num_items,
'default',
timeout=self.wait_timeout)
except Exception as ex:
if not self.generate_map_reduce_error:
raise ex
self.shell.execute_cbcollect_info("%s.zip" % (self.log_filename))
self.verify_results(self.log_filename)
def test_add_spatial_views_threads(self):
same_names = self.input.param('same-name', False)
num_views_per_ddoc = 10
create_threads = []
ddocs = []
for i in range(num_views_per_ddoc):
ddoc = DesignDocument(self.default_ddoc_name + str(i), [],
spatial_views=[
View(self.default_view_name +
(str(i), "")[same_names],
self.default_map,
dev_view=self.use_dev_views,
is_spatial=True)
])
ddocs.append(ddoc)
if self.ddoc_op == 'update' or self.ddoc_op == 'delete':
self.create_ddocs(ddocs)
i = 0
for ddoc in ddocs:
create_thread = Thread(target=self.perform_ddoc_ops,
name="ops_thread" + str(i),
args=([
ddoc,
], ))
i += 1
create_threads.append(create_thread)
create_thread.start()
for create_thread in create_threads:
create_thread.join()
if self.thread_crashed.is_set():
self.fail("Error occured during run")
def test_rename_with_index(self):
self.defaul_map_func = "function (doc) {\n emit(doc._id, doc);\n}"
self.default_view_name = "default_view"
self.default_view = View(self.default_view_name, self.defaul_map_func,
None)
num_views = self.input.param('num_views', 1)
ddoc_name = views_prefix = 'hostname_mgmt'
query = {'stale': 'false'}
views = []
for bucket in self.buckets:
view = self.make_default_views(views_prefix,
num_views,
different_map=True)
self.create_views(self.master, ddoc_name, view, bucket)
views += view
for bucket in self.buckets:
for view in views:
self.cluster.query_view(self.master, ddoc_name, view.name,
query)
hostnames = self.rename_nodes(self.servers[:self.nodes_init])
self.verify_referenced_by_names(self.servers[:self.nodes_init],
hostnames)
self._set_hostames_to_servers_objs(hostnames)
query = {'stale': 'ok'}
for server in self.servers[:self.nodes_init]:
for view in views:
self.cluster.query_view(server, ddoc_name, view.name, query)
def pass_encrypted_in_logs_test(self):
self.bucket_size = self._get_bucket_size(self.quota, 1)
self._create_sasl_buckets(self.master, 1, password='******')
bucket = self.buckets[-1]
if self.input.param("load", 0):
self.num_items = self.input.param("load", 0)
self._load_doc_data_all_buckets()
if self.input.param("views", 0):
views = []
for i in range(self.input.param("views", 0)):
views.append(View("view_sasl" + str(i),
'function (doc, meta) {'
'emit(meta.id, "emitted_value%s");}' % str(i),
None, False))
self.create_views(self.master, "ddoc", views, bucket)
if self.input.param("rebalance", 0):
self.cluster.rebalance(self.servers[:self.nodes_init],
self.servers[self.nodes_init:self.nodes_init + self.input.param("rebalance", 0)],
[])
for server in self.servers[:self.nodes_init]:
for log_file in ['debug', 'info', 'views', 'xdcr']:
self.assertFalse(RemoteUtilHelper.is_text_present_in_logs(server, bucket.saslPassword, logs_to_check=log_file),
"%s logs contains password in plain text" % log_file)
def collectinfo_test_for_views(self):
self.default_design_doc_name = "Doc1"
self.view_name = self.input.param("view_name", "View")
self.generate_map_reduce_error = self.input.param(
"map_reduce_error", False)
self.default_map_func = 'function (doc) { emit(doc.age, doc.first_name);}'
self.gen_load = BlobGenerator('couch',
'cb-',
self.value_size,
end=self.num_items)
self._load_all_buckets(self.master, self.gen_load, "create", 0)
self.reduce_fn = "_count"
expected_num_items = self.num_items
if self.generate_map_reduce_error:
self.reduce_fn = "_sum"
expected_num_items = None
view = View(self.view_name,
self.default_map_func,
self.reduce_fn,
dev_view=False)
self.cluster.create_view(self.master, self.default_design_doc_name,
view, 'default', self.wait_timeout * 2)
query = {"stale": "false", "connection_timeout": 60000}
try:
self.cluster.query_view(self.master,
self.default_design_doc_name,
self.view_name,
query,
expected_num_items,
'default',
timeout=self.wait_timeout)
except Exception, ex:
if not self.generate_map_reduce_error:
raise ex
def test_views_during_ddoc_compaction(self):
fragmentation_value = self.input.param("fragmentation_value", 80)
ddoc_to_compact = DesignDocument(
"ddoc_to_compact", [],
spatial_views=[
View(self.default_view_name,
'function (doc) { emit(doc.age, doc.name);}',
dev_view=self.use_dev_views)
])
ddocs = self.make_ddocs(self.num_ddoc, self.views_per_ddoc, 0)
self.disable_compaction()
self.create_ddocs([
ddoc_to_compact,
])
fragmentation_monitor = self.cluster.async_monitor_view_fragmentation(
self.master, ddoc_to_compact.name, fragmentation_value,
self.default_bucket_name)
end_time = time.time() + self.wait_timeout * 30
while fragmentation_monitor.state != "FINISHED" and end_time > time.time(
):
self.helper.insert_docs(self.num_items, 'spatial-doc')
if end_time < time.time(
) and fragmentation_monitor.state != "FINISHED":
self.fail("impossible to reach compaction value after %s sec" %
(self.wait_timeout * 20))
fragmentation_monitor.result()
compaction_task = self.cluster.async_compact_view(
self.master, ddoc_to_compact.name, self.default_bucket_name)
self.perform_ddoc_ops(ddocs)
result = compaction_task.result(self.wait_timeout * 10)
self.assertTrue(
result, "Compaction didn't finished correctly. Please check diags")
def setUp(self):
try:
super(CreateDeleteViewTests, self).setUp()
self.bucket_ddoc_map = {}
self.ddoc_ops = self.input.param("ddoc_ops", None)
self.boot_op = self.input.param("boot_op", None)
self.nodes_in = self.input.param("nodes_in", 1)
self.nodes_out = self.input.param("nodes_out", 1)
self.test_with_view = self.input.param("test_with_view", False)
self.num_views_per_ddoc = self.input.param("num_views_per_ddoc", 1)
self.num_ddocs = self.input.param("num_ddocs", 1)
self.gen = None
self.default_design_doc_name = "Doc1"
self.default_map_func = 'function (doc) { emit(doc.age, doc.first_name);}'
self.updated_map_func = 'function (doc) { emit(null, doc);}'
self.default_view = View("View", self.default_map_func, None,
False)
self.fragmentation_value = self.input.param(
"fragmentation_value", 80)
self.nodes_init = self.input.param("nodes_init", 1)
self.nodes_in = self.input.param("nodes_in", 1)
self.nodes_out = self.input.param("nodes_out", 1)
self.wait_timeout = self.input.param("wait_timeout", 60)
nodes_init = self.cluster.servers[
1:self.nodes_init] if self.nodes_init != 1 else []
self.task.rebalance([self.cluster.master], nodes_init, [])
self.cluster.nodes_in_cluster.append(self.cluster.master)
self.bucket_util.create_default_bucket()
self.bucket_util.add_rbac_user()
except Exception as ex:
self.input.test_params["stop-on-failure"] = True
self.log.error("SETUP WAS FAILED. ALL TESTS WILL BE SKIPPED")
self.fail(ex)
def test_add_views_to_1_ddoc(self):
same_names = self.input.param('same-name', False)
error = self.input.param('error', None)
num_views_per_ddoc = 10
create_threads = []
try:
for i in range(num_views_per_ddoc):
ddoc = DesignDocument(self.default_ddoc_name, [],
spatial_views=[
View(self.default_view_name +
(str(i), "")[same_names],
self.default_map,
dev_view=self.use_dev_views,
is_spatial=True)
])
create_thread = Thread(target=self.create_ddocs,
name="create_thread" + str(i),
args=([
ddoc,
], ))
create_threads.append(create_thread)
create_thread.start()
for create_thread in create_threads:
create_thread.join()
except Exception as ex:
if error and str(ex).find(error) != -1:
self.log.info("Error caught as expected %s" % error)
return
else:
self.fail("Unexpected error appeared during run %s" % ex)
if error:
self.fail("Expected error '%s' didn't appear" % error)
def _create_views(self):
default_map_func = "function (doc) {\n emit(doc._id, doc);\n}"
default_view_name = "test"
default_ddoc_name = "ddoc_test"
prefix = "dev_"
query = {"full_set": "true", "stale": "false", "connection_timeout": 60000}
view = View(default_view_name, default_map_func)
task = self.cluster.async_create_view(self.master, default_ddoc_name, view, "default")
task.result()
def setUp(self):
super(RebalanceBaseTest, self).setUp()
self.doc_ops = self.input.param("doc_ops", "create")
self.doc_size = self.input.param("doc_size", 10)
self.key_size = self.input.param("key_size", 0)
self.zone = self.input.param("zone", 1)
self.new_replica = self.input.param("new_replica", None)
self.default_view_name = "default_view"
self.defaul_map_func = "function (doc) {\n emit(doc._id, doc);\n}"
self.default_view = View(self.default_view_name, self.defaul_map_func,
None)
self.max_verify = self.input.param("max_verify", None)
self.std_vbucket_dist = self.input.param("std_vbucket_dist", None)
self.key = 'test_docs'.rjust(self.key_size, '0')
nodes_init = self.cluster.servers[
1:self.nodes_init] if self.nodes_init != 1 else []
self.task.rebalance([self.cluster.master], nodes_init, [])
self.cluster.nodes_in_cluster.extend([self.cluster.master] +
nodes_init)
self.bucket_util.create_default_bucket(replica=self.num_replicas)
self.bucket_util.add_rbac_user()
self.sleep(10)
gen_create = self.get_doc_generator(0, self.num_items)
self.print_cluster_stat_task = self.cluster_util.async_print_cluster_stats(
)
for bucket in self.bucket_util.buckets:
task = self.task.async_load_gen_docs(
self.cluster,
bucket,
gen_create,
"create",
0,
persist_to=self.persist_to,
replicate_to=self.replicate_to,
batch_size=10,
timeout_secs=self.sdk_timeout,
process_concurrency=8,
retries=self.sdk_retries,
durability=self.durability_level)
self.task.jython_task_manager.get_task_result(task)
self.sleep(20)
current_item = self.bucket_util.get_bucket_current_item_count(
self.cluster, bucket)
self.num_items = current_item
self.log.info("Inserted {} number of items after loadgen".format(
self.num_items))
self.gen_load = self.get_doc_generator(0, self.num_items)
# gen_update is used for doing mutation for 1/2th of uploaded data
self.gen_update = self.get_doc_generator(0, (self.num_items / 2))
self.durability_helper = DurabilityHelper(
self.log,
len(self.cluster.nodes_in_cluster),
durability=self.durability_level,
replicate_to=self.replicate_to,
persist_to=self.persist_to)
self.log.info("==========Finished rebalance base setup========")
def _verify_with_views(self, expected_rows):
for bucket in self.buckets:
default_map_func = 'function (doc, meta) { emit(meta.id, null);}'
default_view = View("View", default_map_func, None, False)
ddoc_name = "key_ddoc"
self.create_views(self.cluster.master, ddoc_name, [default_view],
bucket.name)
query = {"stale": "false", "connection_timeout": 60000}
self.cluster.query_view(self.cluster.master, ddoc_name,
default_view.name, query,
expected_rows, bucket=bucket.name)
def create_ddocs(self, is_dev_view):
mapview = View(self.map_view_name,
'''function(doc) {
emit(doc.integer, doc.string);
}''',
dev_view=is_dev_view)
self.cluster.create_view(self.master, 'test', mapview)
redview = View(self.red_view_name,
'''function(doc) {
emit([doc.integer, doc.string], doc.integer);
}''',
'''_count''',
dev_view=is_dev_view)
self.cluster.create_view(self.master, 'test', redview)
redview_stats = View(self.red_view_stats_name,
'''function(doc) {
emit(doc.string, doc.string);
}''',
'''_stats''',
dev_view=is_dev_view)
self.cluster.create_view(self.master, 'test2', redview_stats)
RebalanceHelper.wait_for_persistence(self.master, self.bucket, 0)
def setUp(self):
super(RebalanceBaseTest, self).setUp()
self.value_size = self.input.param("value_size", 256)
self.doc_ops = self.input.param("doc_ops", None)
self.withMutationOps = self.input.param("withMutationOps", False)
self.total_vbuckets = self.input.param("total_vbuckets", 1024)
if self.doc_ops is not None:
self.doc_ops = self.doc_ops.split(":")
self.defaul_map_func = "function (doc) {\n emit(doc._id, doc);\n}"
self.default_view_name = "default_view"
self.default_view = View(self.default_view_name, self.defaul_map_func,
None)
self.std_vbucket_dist = self.input.param("std_vbucket_dist", None)
self.zone = self.input.param("zone", 1)
# define the data that will be used to test
self.blob_generator = self.input.param("blob_generator", True)
# To validate MB-34173
self.sleep_before_rebalance = \
self.input.param("sleep_before_rebalance", None)
self.flusher_total_batch_limit = \
self.input.param("flusher_total_batch_limit", None)
if self.flusher_total_batch_limit:
self.set_flusher_total_batch_limit(self.flusher_total_batch_limit,
self.buckets)
if self.blob_generator:
# gen_load is used to create initial docs (1000 items by default)
self.gen_load = BlobGenerator('mike',
'mike-',
self.value_size,
end=self.num_items)
# gen_update is used for doing mutation for 1/2th of uploaded data
self.gen_update = BlobGenerator('mike',
'mike-',
self.value_size,
end=(self.num_items // 2 - 1))
# upload data before each test
self._load_all_buckets(self.servers[0],
self.gen_load,
"create",
0,
flag=2,
batch_size=20000)
else:
self._load_doc_data_all_buckets(batch_size=20000)
# Validate seq_no snap_start/stop values with initial load
self.check_snap_start_corruption()
def test_ephemeral_bucket_views(self):
default_map_func = "function (doc, meta) {emit(meta.id, null);}"
default_view_name = ("xattr", "default_view")[False]
view = View(default_view_name, default_map_func, None, False)
ddoc_name = "ddoc1"
tasks = self.async_create_views(self.master, ddoc_name, [view], self.buckets[0].name)
for task in tasks:
try:
task.result()
self.fail("Views not allowed for ephemeral buckets")
except DesignDocCreationException as e:
self.assertEqual(e._message,
'Error occured design document _design/ddoc1: {"error":"not_found","reason":"views are supported only on couchbase buckets"}\n')
def setUp(self):
super(CCCP, self).setUp()
self.map_fn = 'function (doc){emit([doc.join_yr, doc.join_mo],doc.name);}'
self.ddoc_name = "cccp_ddoc"
self.view_name = "cccp_view"
self.default_view = View(self.view_name, self.map_fn, None, False)
self.ops = self.input.param("ops", None)
self.clients = {}
try:
for bucket in self.buckets:
self.clients[bucket.name] =\
MemcachedClientHelper.direct_client(self.master, bucket.name)
except:
self.tearDown()
def _create_views(self, ddocs_num, buckets, views_num, server):
ddocs = []
if ddocs_num:
self.default_view = View(self.default_view_name, None, None)
for bucket in buckets:
for i in xrange(ddocs_num):
views = self.make_default_views(self.default_view_name, views_num,
self.is_dev_ddoc, different_map=True)
ddoc = DesignDocument(self.default_view_name + str(i), views)
bucket_server = self._get_bucket(bucket, server)
tasks = self.async_create_views(server, ddoc.name, views, bucket=bucket_server)
for task in tasks:
task.result(timeout=90)
ddocs.append(ddoc)
return ddocs
def cluster_bucket_views_read(self,username,password,host,port=8091, servers=None,cluster=None,httpCode=None,user_role=None):
cluster.create_view(host,"Doc1",View('abcd', 'function (doc) { emit(doc.age, doc.first_name);}', None),'default',180,with_query=False)
doc_id = "_design/dev_Doc1"
_cluster_bucket_views_read ={
"getview":"pools/default/buckets/<bucket_name>/ddocs;GET"
}
for perm in _cluster_bucket_views_read:
temp = _cluster_bucket_views_read[perm]
temp = temp.replace('<bucket_name>','default')
_cluster_bucket_views_read[perm] = temp
result = self._return_http_code(_cluster_bucket_views_read,username,password,host=host,port=8092, httpCode=httpCode, user_role=user_role)
def create_ddocs_and_views(self):
self.default_view = View(self.default_view_name, None, None)
for bucket in self.buckets:
for i in xrange(int(self.ddocs_num)):
views = self.make_default_views(self.default_view_name,
self.view_num,
self.is_dev_ddoc,
different_map=True)
ddoc = DesignDocument(self.default_view_name + str(i), views)
self.ddocs.append(ddoc)
for view in views:
self.cluster.create_view(self.master,
ddoc.name,
view,
bucket=bucket)
def cluster_bucket_views_compact(self,username,password,host,port=8091, servers=None,cluster=None,httpCode=None,user_role=None):
cluster.create_view(host,"Doc1",View('abcd', 'function (doc) { emit(doc.age, doc.first_name);}', None),'default',180,with_query=False)
doc_id = "_design%2Fdev_Doc1"
_cluster_bucket_views_compact ={
"compact_view":"pools/default/buckets/<bucket_name>/ddocs/<doc_id>/controller/compactView;POST",
"cancel_compact":"pools/default/buckets/<bucket_name>/ddocs/<doc_id>/controller/cancelViewCompaction;POST"
}
for perm in _cluster_bucket_views_compact:
temp = _cluster_bucket_views_compact[perm]
temp = temp.replace('<bucket_name>','default')
temp = temp.replace('<doc_id>',doc_id)
_cluster_bucket_views_compact[perm] = temp
result = self._return_http_code(_cluster_bucket_views_compact,username,password,host=host,port=8092, httpCode=httpCode, user_role=user_role)
def setUp(self):
super(ObserveXdcrTest, self).setUp()
self.src_cluster = self.get_cb_cluster_by_name('C1')
self.src_master = self.src_cluster.get_master_node()
self.dest_cluster = self.get_cb_cluster_by_name('C2')
self.dest_master = self.dest_cluster.get_master_node()
# Variables defined for _run_observe() in observetest.
self.observe_with = self._input.param("observe_with", "")
self.default_map_func = 'function (doc) { emit(doc.age, doc.first_name);}'
self.default_design_doc = "Doc1"
map_func = 'function (doc) { emit(null, doc);}'
self.default_view = View("default_view", map_func, None)
self.mutate_by = self._input.param("mutate_by", "set")
self.cluster = Cluster()
self.wait_timeout = self._wait_timeout
self.num_items = self._num_items
def setUp(self):
super(CompactionViewTests, self).setUp()
self.value_size = self.input.param("value_size", 256)
self.fragmentation_value = self.input.param("fragmentation_value", 80)
self.ddocs_num = self.input.param("ddocs_num", 1)
self.view_per_ddoc = self.input.param("view_per_ddoc", 2)
self.use_dev_views = self.input.param("use_dev_views", False)
self.default_map_func = "function (doc) {\n emit(doc._id, doc);\n}"
self.default_view_name = "default_view"
self.default_view = View(self.default_view_name, self.default_map_func,
None)
self.ddocs = []
self.gen_load = BlobGenerator('test_view_compaction',
'test_view_compaction-',
self.value_size,
end=self.num_items)
self.thread_crashed = Event()
self.thread_stopped = Event()
def setUp(self):
super(XDCRViewTests, self).setUp()
self.bucket_ddoc_map = {}
self.ddoc_ops = self._input.param("ddoc_ops", None)
self.ddoc_ops_dest = self._input.param("ddoc_ops_dest", None)
self.stale_param = self._input.param("stale_param", "false")
self.num_views_per_ddoc = self._input.param("num_views_per_ddoc", 1)
self.num_ddocs = self._input.param("num_ddocs", 1)
self.test_with_view = True
self.updated_map_func = 'function (doc) { emit(null, doc);}'
self.src_cluster = self.get_cb_cluster_by_name('C1')
self.src_master = self.src_cluster.get_master_node()
self.dest_cluster = self.get_cb_cluster_by_name('C2')
self.dest_master = self.dest_cluster.get_master_node()
self.defaul_map_func = "function (doc) {\n emit(doc._id, doc);\n}"
self.default_view_name = "default_view"
self.default_view = View(self.default_view_name, self.defaul_map_func, None)
self.cluster = self.src_cluster.get_cluster()