def test_invalid_name_collection(self): for _ in range(1000): scope_name = BucketUtils.get_random_name(invalid_name=True) try: status, content = BucketHelper( self.cluster.master).create_scope(self.bucket, scope_name) if status is True: self.log_failure("Scope '%s::%s' creation not failed: %s" % (self.bucket, scope_name, content)) except Exception as e: self.log.debug(e) for _ in range(1000): collection_name = BucketUtils.get_random_name(invalid_name=True) try: status, content = BucketHelper(self.cluster.master) \ .create_collection(self.bucket, CbServer.default_scope, collection_name) if status is True: self.log_failure( "Collection '%s::%s::%s' creation not failed: %s" % (self.bucket, CbServer.default_scope, collection_name, content)) except Exception as e: self.log.debug(e) # Validate doc count as per bucket collections self.bucket_util.validate_docs_per_collections_all_buckets() self.validate_test_failure()
def setUp(self): super(ExpiryMaxTTL, self).setUp() # Create default bucket self.create_bucket(self.cluster) self.key = 'test_ttl_docs'.rjust(self.key_size, '0') if self.target_vbucket and type(self.target_vbucket) is not list: self.target_vbucket = [self.target_vbucket] self.bucket_util.get_all_buckets(self.cluster) self.bucket_helper_obj = BucketHelper(self.cluster.master) self.cluster_util.print_cluster_stats(self.cluster) self.bucket_util.print_bucket_stats(self.cluster) # Create sdk_clients for pool if self.sdk_client_pool: self.log.info("Creating SDK client pool") self.sdk_client_pool.create_clients( self.cluster.buckets[0], self.cluster.nodes_in_cluster, req_clients=self.sdk_pool_capacity, compression_settings=self.sdk_compression) self.log.info("==========Finished ExpiryMaxTTL base setup========")
def load_bucket_into_dgm(self, cluster, bucket, key, num_items, active_resident_threshold, load_batch_size=20000, batch_size=10, process_concurrency=4, persist_to=None, replicate_to=None): rest = BucketHelper(cluster.master) bucket_stat = rest.get_bucket_stats_for_node(bucket.name, cluster.master) while bucket_stat["vb_active_resident_items_ratio"] > \ active_resident_threshold: gen_load = doc_generator(key, num_items, num_items + load_batch_size, doc_type="binary") num_items += load_batch_size task = self.async_load_gen_docs( cluster, bucket, gen_load, "create", 0, batch_size=batch_size, process_concurrency=process_concurrency, persist_to=persist_to, replicate_to=replicate_to) self.jython_task_manager.get_task_result(task) bucket_stat = rest.get_bucket_stats_for_node( bucket.name, cluster.master) return num_items
def load_document_until_ram_percentage(self): self.start = 0 doc_batch_size = 5000 self.end = doc_batch_size bucket_helper = BucketHelper(self.cluster.master) mem_cap = (self.document_ram_percentage * self.bucket_ram * 1000000) while True: self.log.info("Add documents to bucket") self.perform_doc_ops_in_all_cb_buckets( "create", self.start, self.end, durability=self.durability_level) self.log.info("Calculate available free memory") bucket_json = bucket_helper.get_bucket_json(self.cb_bucket_name) mem_used = 0 for node_stat in bucket_json["nodes"]: mem_used += node_stat["interestingStats"]["mem_used"] if mem_used < mem_cap: self.log.info("Memory used: %s < %s" % (mem_used, mem_cap)) self.start = self.end self.end = self.end + doc_batch_size self.num_items = self.end else: break
def setUp(self): super(ExpiryMaxTTL, self).setUp() self.key = 'test_ttl_docs'.rjust(self.key_size, '0') if self.target_vbucket and type(self.target_vbucket) is not list: self.target_vbucket = [self.target_vbucket] 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( bucket_type=self.bucket_type, maxTTL=self.maxttl, storage=self.bucket_storage, eviction_policy=self.bucket_eviction_policy, replica=self.num_replicas, compression_mode=self.compression_mode) self.bucket_util.add_rbac_user() self.bucket_util.get_all_buckets() self.bucket_helper_obj = BucketHelper(self.cluster.master) self.cluster_util.print_cluster_stats() self.bucket_util.print_bucket_stats() # Create sdk_clients for pool if self.sdk_client_pool: self.log.info("Creating SDK client pool") self.sdk_client_pool.create_clients( self.bucket_util.buckets[0], self.cluster.nodes_in_cluster, req_clients=self.sdk_pool_capacity, compression_settings=self.sdk_compression) self.log.info("==========Finished ExpiryMaxTTL base setup========")
def get_bucket_dgm(self, bucket): self.rest_client = BucketHelper(self.cluster.master) dgm = self.rest_client.fetch_bucket_stats( bucket.name)["op"]["samples"]["vb_active_resident_items_ratio"][-1] self.log.info("Active Resident Threshold of {0} is {1}".format( bucket.name, dgm)) return dgm
def test_MB_34947(self): # Update already Created docs with async_writes load_gen = doc_generator(self.key, 0, self.num_items, key_size=self.key_size, doc_size=self.doc_size, doc_type=self.doc_type, vbuckets=self.cluster.vbuckets) task = self.task.async_load_gen_docs( self.cluster, self.def_bucket, load_gen, "update", 0, persist_to=self.persist_to, replicate_to=self.replicate_to, timeout_secs=self.sdk_timeout, batch_size=10, process_concurrency=8) self.task.jython_task_manager.get_task_result(task) # Update bucket replica to new value bucket_helper = BucketHelper(self.cluster.master) bucket_helper.change_bucket_props( self.def_bucket, replicaNumber=self.new_replica) self.bucket_util.print_bucket_stats(self.cluster) # Start rebalance task rebalance = self.task.async_rebalance(self.cluster.servers, [], []) self.sleep(10, "Wait for rebalance to start") # Wait for rebalance task to complete self.task.jython_task_manager.get_task_result(rebalance) # Assert if rebalance failed self.assertTrue(rebalance.result, "Rebalance failed after replica update")
def set_num_writer_and_reader_threads(self, num_writer_threads="default", num_reader_threads="default"): for node in self.cluster_util.get_kv_nodes(): bucket_helper = BucketHelper(node) bucket_helper.update_memcached_settings( num_writer_threads=num_writer_threads, num_reader_threads=num_reader_threads)
def set_num_writer_and_reader_threads(self, num_writer_threads="default", num_reader_threads="default", num_storage_threads="default"): bucket_helper = BucketHelper(self.cluster.master) bucket_helper.update_memcached_settings( num_writer_threads=num_writer_threads, num_reader_threads=num_reader_threads, num_storage_threads=num_storage_threads)
def load_document_until_ram_percentage(self): self.start = 0 doc_batch_size = 5000 self.end = doc_batch_size bucket_helper = BucketHelper(self.cluster.master) mem_cap = (self.document_ram_percentage * self.bucket_ram * 1000000) first = ['james', 'sharon', 'dave', 'bill', 'mike', 'steve'] profession = ['doctor', 'lawyer'] template_obj = JsonObject.create() template_obj.put("number", 0) template_obj.put("first_name", "") template_obj.put("profession", "") template_obj.put("mutated", 0) template_obj.put("mutation_type", "ADD") while True: self.log.info("Add documents to bucket") doc_gen = DocumentGenerator("test_docs", template_obj, start=self.start, end=self.end, randomize=False, first_name=first, profession=profession, number=range(70)) try: self.bucket_util.sync_load_all_buckets( self.cluster, doc_gen, "create", 0, batch_size=doc_batch_size, durability=self.durability_level, suppress_error_table=True) except Exception as e: self.fail("Following error occurred while loading bucket - {" "0}".format(str(e))) self.log.info("Calculate available free memory") bucket_json = bucket_helper.get_bucket_json(self.bucket_name) mem_used = 0 for node_stat in bucket_json["nodes"]: mem_used += node_stat["interestingStats"]["mem_used"] if mem_used < mem_cap: self.log.info("Memory used: %s < %s" % (mem_used, mem_cap)) self.start = self.end self.end = self.end + doc_batch_size self.num_items = self.end else: break
def update_bucket_replica(self): self.log.info("Updating all the bucket replicas to {0}".format( self.replicas_for_failover)) for i in range(len(self.bucket_util.buckets)): bucket_helper = BucketHelper(self.cluster.master) bucket_helper.change_bucket_props( self.bucket_util.buckets[i], replicaNumber=self.replicas_for_failover) task = self.task.async_rebalance( self.cluster.servers[:self.nodes_init], [], []) self.task.jython_task_manager.get_task_result(task) self.log.info("Bucket stats before failover") self.bucket_util.print_bucket_stats()
def get_bucket_dgm(self, bucket): self.rest_client = BucketHelper(self.cluster.master) count = 0 dgm = 100 while count < 5: try: dgm = self.rest_client.fetch_bucket_stats( bucket.name )["op"]["samples"]["vb_active_resident_items_ratio"][-1] self.log.info("Active Resident Threshold of {0} is {1}".format( bucket.name, dgm)) return dgm except Exception as e: self.sleep(5, e) count += 1 return dgm
def durability_succeeds(self, bucket_name, master, induced_error=None, failed_nodes=[]): """ Determines whether the durability will fail/work based on the type of error_induced during the test and number of nodes the error is induced on. :param bucket_name: Name of the bucket used for fetching the replica value (str) :param master: Master node from the cluster :param induced_error: Error induced during the test execution (str) :param failed_nodes: No of nodes failed due to the induced_error (int) :return durability_succeeds: Durability status for the bucket (bool) """ durability_succeeds = True bucket = BucketHelper(master).get_bucket_json(bucket_name) min_nodes_req = bucket["replicaNumber"] + 1 majority_value = floor(min_nodes_req / 2) + 1 if induced_error is None: if (self.cluster_len - failed_nodes) < majority_value: durability_succeeds = False else: if (self.durability == Bucket.DurabilityLevel.MAJORITY and induced_error in self.disk_error_types): durability_succeeds = True elif (self.cluster_len - len(failed_nodes)) < majority_value: durability_succeeds = False return durability_succeeds
def test_bucket_flush_while_index_are_created(self): self.log.info("Add documents, create CBAS buckets, " "dataset and validate count") self.setup_for_test() self.log.info('Disconnect CBAS bucket') self.cbas_util.disconnect_from_bucket(self.cbas_bucket_name) self.log.info('Create secondary index in Async') index_fields = self.input.param("index_fields", None) index_fields = index_fields.replace('-', ',') query = "create index {0} on {1}({2});" \ .format("sec_idx", self.cbas_dataset_name, index_fields) create_index_task = self.task.async_cbas_query_execute( self.cluster.master, self.cbas_util, None, query, 'default') self.log.info('Flush bucket while index are getting created') # Flush the CB bucket BucketHelper(self.cluster.master).flush_bucket(self.cb_bucket_name) self.log.info('Get result on index creation') self.task_manager.get_task_result(create_index_task) self.log.info('Connect back cbas bucket') self.cbas_util.connect_to_bucket(self.cbas_bucket_name) self.log.info('Validate no. of items in CBAS dataset') if not self.cbas_util.validate_cbas_dataset_items_count( self.cbas_dataset_name, 0): self.fail("No. of items in CBAS dataset do not match " "that in the CB bucket")
def test_replica_update(self): if self.atomicity: replica_count = 3 else: replica_count = 4 if self.nodes_init < 2: self.log.error("Test not supported for < 2 node cluster") return doc_ops = self.input.param("doc_ops", "") bucket_helper = BucketHelper(self.cluster.master) doc_count = self.num_items start_doc_for_insert = self.num_items # Replica increment tests doc_count, start_doc_for_insert = self.generic_replica_update( doc_count, doc_ops, bucket_helper, range(1, min(replica_count, self.nodes_init)), start_doc_for_insert) # Replica decrement tests _, _ = self.generic_replica_update( doc_count, doc_ops, bucket_helper, range(min(replica_count, self.nodes_init) - 2, -1, -1), start_doc_for_insert)
def test_nru_eviction_impact_on_cbas(self): self.log.info("Create dataset") self.cbas_util.create_dataset_on_bucket(self.cb_bucket_name, self.cbas_dataset_name) self.log.info("Connect to Local link") self.cbas_util.connect_link() self.log.info("Add documents until ram percentage") self.load_document_until_ram_percentage() self.log.info("Fetch current document count") bucket_helper = BucketHelper(self.master) item_count = bucket_helper.get_bucket( self.cb_bucket_name).stats.itemCount self.log.info("Completed base load with %s items" % item_count) self.log.info( "Fetch initial inserted 100 documents, so they are not removed") client = SDKClient(hosts=[self.master.ip], bucket=self.cb_bucket_name, password=self.master.rest_password) for i in range(100): client.get("test_docs-" + str(i)) self.log.info("Add 20% more items to trigger NRU") for i in range(item_count, int(item_count * 1.2)): client.insert_document("key-id" + str(i), '{"name":"dave"}') self.log.info("Validate document count on CBAS") count_n1ql = self.rest.query_tool( 'select count(*) from %s' % (self.cb_bucket_name))['results'][0]['$1'] if self.cbas_util.validate_cbas_dataset_items_count( self.cbas_dataset_name, count_n1ql): pass else: self.log.info( "Document count mismatch might be due to ejection of documents on KV. Retry again" ) count_n1ql = self.rest.query_tool( 'select count(*) from %s' % (self.cb_bucket_name))['results'][0]['$1'] self.assertTrue(self.cbas_util.validate_cbas_dataset_items_count( self.cbas_dataset_name, count_n1ql), msg="Count mismatch on CBAS")
def setUp(self): super(CollectionBase, self).setUp() self.log_setup_status("CollectionBase", "started") self.key = 'test_collection'.rjust(self.key_size, '0') self.simulate_error = self.input.param("simulate_error", None) self.error_type = self.input.param("error_type", "memory") self.doc_ops = self.input.param("doc_ops", None) # If True, creates bucket/scope/collections with simpler names self.use_simple_names = self.input.param("use_simple_names", True) self.spec_name = self.input.param("bucket_spec", "single_bucket.default") self.data_spec_name = self.input.param("data_spec_name", "initial_load") self.remove_default_collection = \ self.input.param("remove_default_collection", False) self.action_phase = self.input.param("action_phase", "before_default_load") self.skip_collections_cleanup = \ self.input.param("skip_collections_cleanup", False) self.validate_docs_count_during_teardown = \ self.input.param("validate_docs_count_during_teardown", False) self.batch_size = self.input.param("batch_size", 200) self.process_concurrency = self.input.param("process_concurrency", 1) self.retry_get_process_num = \ self.input.param("retry_get_process_num", 200) self.change_magma_quota = self.input.param("change_magma_quota", False) self.crud_batch_size = 100 self.num_nodes_affected = 1 if self.num_replicas > 1: self.num_nodes_affected = 2 if self.doc_ops: self.doc_ops = self.doc_ops.split(';') self.durability_helper = DurabilityHelper( self.log, len(self.cluster.nodes_in_cluster), self.durability_level) # Disable auto-failover to avoid failover of nodes status = RestConnection(self.cluster.master) \ .update_autofailover_settings(False, 120) self.assertTrue(status, msg="Failure during disabling auto-failover") self.bucket_helper_obj = BucketHelper(self.cluster.master) self.disk_optimized_thread_settings = self.input.param("disk_optimized_thread_settings", False) if self.disk_optimized_thread_settings: self.set_num_writer_and_reader_threads(num_writer_threads="disk_io_optimized", num_reader_threads="disk_io_optimized") try: self.collection_setup() except Java_base_exception as exception: self.handle_setup_exception(exception) except Exception as exception: self.handle_setup_exception(exception) self.supported_d_levels = \ self.bucket_util.get_supported_durability_levels() self.log_setup_status("CollectionBase", "complete")
def execute(self): try: rest = BucketHelper(self.server) if rest.flush_bucket(self.bucket): self.state = CHECKING self.task_manager.schedule(self) else: self.state = FINISHED self.set_result(False) except BucketFlushFailed as e: self.state = FINISHED self.set_unexpected_exception(e) except Exception as e: self.state = FINISHED self.set_unexpected_exception(e)
def test_no_eviction_impact_on_cbas(self): self.log.info("Create dataset") self.cbas_util.create_dataset_on_bucket(self.cb_bucket_name, self.cbas_dataset_name) self.log.info("Connect to Local link") self.cbas_util.connect_link() self.log.info("Add documents until ram percentage") self.load_document_until_ram_percentage() self.log.info("Fetch current document count") bucket_helper = BucketHelper(self.master) item_count = bucket_helper.get_bucket( self.cb_bucket_name).stats.itemCount self.log.info("Completed base load with %s items" % item_count) self.log.info("Load more until we are out of memory") client = SDKClient(hosts=[self.master.ip], bucket=self.cb_bucket_name, password=self.master.rest_password) i = item_count insert_success = True while insert_success: insert_success = client.insert_document("key-id" + str(i), '{"name":"dave"}') i += 1 self.log.info('Memory is full at {0} items'.format(i)) self.log.info("As a result added more %s items" % (i - item_count)) self.log.info("Fetch item count") stats = bucket_helper.get_bucket(self.cb_bucket_name).stats itemCountWhenOOM = stats.itemCount memoryWhenOOM = stats.memUsed self.log.info('Item count when OOM {0} and memory used {1}'.format( itemCountWhenOOM, memoryWhenOOM)) self.log.info("Validate document count on CBAS") count_n1ql = self.rest.query_tool( 'select count(*) from %s' % (self.cb_bucket_name))['results'][0]['$1'] self.assertTrue(self.cbas_util.validate_cbas_dataset_items_count( self.cbas_dataset_name, count_n1ql), msg="Count mismatch on CBAS")
def _record_vbuckets(self, master, servers): map = dict() for bucket in self.buckets: self.log.info("Record vbucket for the bucket {0}".format( bucket.name)) map[bucket.name] = BucketHelper(master)\ ._get_vbuckets(servers, bucket_name=bucket.name) #self.log.info("Map: {0}".format(map)) return map
def setUp(self): super(DCPSeqItr, self).setUp() self.vbuckets = range(1024) self.start_seq_no_list = self.input.param("start", [0] * len(self.vbuckets)) self.end_seq_no = self.input.param("end", 0xffffffffffffffff) self.vb_uuid_list = self.input.param("vb_uuid_list", ['0'] * len(self.vbuckets)) self.vb_retry = self.input.param("retry_limit", 10) self.filter_file = self.input.param("filter", None) self.bucket_helper_obj = BucketHelper(self.cluster.master) self.items = copy.deepcopy(self.init_num_items) self.bucket = self.cluster.buckets[0] self.dcp_util = DCPUtils(self.cluster.master, self.cluster.buckets[0], self.start_seq_no_list, self.end_seq_no, self.vb_uuid_list) self.dcp_util.initialise_cluster_connections()
def setUp(self): super(CollectionBase, self).setUp() self.log_setup_status("CollectionBase", "started") self.MAX_SCOPES = CbServer.max_scopes self.MAX_COLLECTIONS = CbServer.max_collections self.key = 'test_collection'.rjust(self.key_size, '0') self.simulate_error = self.input.param("simulate_error", None) self.error_type = self.input.param("error_type", "memory") self.doc_ops = self.input.param("doc_ops", None) self.spec_name = self.input.param("bucket_spec", "single_bucket.default") self.data_spec_name = self.input.param("data_spec_name", "initial_load") self.remove_default_collection = \ self.input.param("remove_default_collection", False) self.action_phase = self.input.param("action_phase", "before_default_load") self.skip_collections_cleanup = \ self.input.param("skip_collections_cleanup", False) self.validate_docs_count_during_teardown = \ self.input.param("validate_docs_count_during_teardown", False) self.batch_size = self.input.param("batch_size", 200) self.vbuckets = self.input.param("vbuckets", self.cluster_util.vbuckets) self.retry_get_process_num = self.input.param("retry_get_process_num", 25) self.crud_batch_size = 100 self.num_nodes_affected = 1 if self.num_replicas > 1: self.num_nodes_affected = 2 if self.doc_ops: self.doc_ops = self.doc_ops.split(';') self.durability_helper = DurabilityHelper( self.log, len(self.cluster.nodes_in_cluster), self.durability_level) # Disable auto-failover to avoid failover of nodes status = RestConnection(self.cluster.master) \ .update_autofailover_settings(False, 120, False) self.assertTrue(status, msg="Failure during disabling auto-failover") self.bucket_helper_obj = BucketHelper(self.cluster.master) try: self.collection_setup() except Java_base_exception as exception: self.handle_setup_exception(exception) except Exception as exception: self.handle_setup_exception(exception) self.supported_d_levels = \ self.bucket_util.get_supported_durability_levels() self.log_setup_status("CollectionBase", "complete")
def execute(self): try: status = BucketHelper(self.server).compact_bucket(self.bucket) self.state = CHECKING self.call() except BucketCompactionException as e: self.test_log.error("Bucket compaction failed: {0}".format(e)) self.set_unexpected_exception(e) self.state = FINISHED self.set_result(False)
def execute(self): try: status = BucketHelper(self.server).compact_bucket(self.bucket) self.state = CHECKING self.call() except BucketCompactionException as e: log.error("Bucket compaction failed for unknown reason") self.set_unexpected_exception(e) self.state = FINISHED self.set_result(False)
def compact_cb_bucket_with_cbas_connected(self): self.setup_for_test() # Compact the CB bucket BucketHelper(self.cluster.master).flush_bucket(self.cb_bucket_name) # Validate no. of items in CBAS dataset if not self.cbas_util.validate_cbas_dataset_items_count( self.cbas_dataset_name, self.num_items): self.fail("No. of items in CBAS dataset do not match " "that in the CB bucket")
def setUp(self): super(ExpiryMaxTTL, self).setUp() self.key = 'test_ttl_docs'.rjust(self.key_size, '0') if self.target_vbucket and type(self.target_vbucket) is not list: self.target_vbucket = [self.target_vbucket] 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( bucket_type=self.bucket_type, maxTTL=self.maxttl, replica=self.num_replicas, compression_mode=self.compression_mode) self.bucket_util.add_rbac_user() self.bucket_util.get_all_buckets() self.bucket_helper_obj = BucketHelper(self.cluster.master) self.log.info("==========Finished ExpiryMaxTTL base setup========")
def create_scope_collections(self): self.__print_step("Creating required scope/collections") BucketHelper(self.cluster.master).import_collection_using_manifest( self.bucket.name, str(collection_spec).replace("'", '"')) self.bucket.stats.increment_manifest_uid() for scope in collection_spec["scopes"]: self.bucket_util.create_scope_object(self.bucket, scope) for collection in scope["collections"]: self.bucket_util.create_collection_object( self.bucket, scope["name"], collection)
def initialise(self): # Create the collections for this task for collection in self.collections: BucketHelper(self.node).create_collection( Bucket({'name': self.bucket}), self.scope.name, {"name": collection}) # A client for each collection self.clients = {} for collection in self.collections: self.clients[collection] = \ SDKClient([self.node], Bucket( {'name': self.bucket}), scope=self.scope.name, collection=collection)
def __init__(self, master, eventing_nodes, src_bucket_name='src_bucket', dst_bucket_name='dst_bucket', metadata_bucket_name='metadata', dst_bucket_name1='dst_bucket_name1', eventing_log_level='INFO', use_memory_manager=True, timer_storage_chan_size=10000, dcp_gen_chan_size=10000, is_sbm=False, is_curl=False, hostname='https://postman-echo.com/', auth_type='no-auth', curl_username=None, curl_password=None, cookies=False, print_eventing_handler_code_in_logs=True): self.log = logging.getLogger("test") self.eventing_nodes = eventing_nodes self.master = master self.eventing_helper = EventingHelper(self.eventing_nodes[0]) self.src_bucket_name = src_bucket_name self.dst_bucket_name = dst_bucket_name self.metadata_bucket_name = metadata_bucket_name self.dst_bucket_name1 = dst_bucket_name1 self.eventing_log_level = eventing_log_level self.use_memory_manager = use_memory_manager self.timer_storage_chan_size = timer_storage_chan_size self.dcp_gen_chan_size = dcp_gen_chan_size self.is_sbm = is_sbm self.is_curl = is_curl self.hostname = hostname self.auth_type = auth_type self.curl_username = curl_username self.curl_password = curl_password self.cookies = cookies self.bucket_helper = BucketHelper(self.master) self.print_eventing_handler_code_in_logs = print_eventing_handler_code_in_logs
def execute(self): try: rest = RestConnection(self.server) except ServerUnavailableException as error: self.state = FINISHED self.set_unexpected_exception(error) return info = rest.get_nodes_self() if int(info.port) in xrange(9091, 9991): self.port = info.port if self.bucket.ramQuotaMB <= 0: self.size = info.memoryQuota * 2 / 3 if int(info.port) in xrange(9091, 9991): try: BucketHelper(self.server).create_bucket(self.bucket.__dict__) self.state = CHECKING self.call() except Exception as e: self.test_log.error(str(e)) self.state = FINISHED #self. set_unexpected_exception(e) return version = rest.get_nodes_self().version try: if float(version[:2]) >= 3.0 and self.bucket_priority is not None: self.bucket.threadsNumber = self.bucket_priority BucketHelper(self.server).create_bucket(self.bucket.__dict__) self.state = CHECKING self.call() except BucketCreationException as e: self.state = FINISHED self.test_log.debug(str(e)) #self. set_unexpected_exception(e) # catch and set all unexpected exceptions except Exception as e: self.test_log.error(str(e)) self.state = FINISHED