def wait_for_replication(servers, cluster_helper=None, timeout=600):
if cluster_helper is None:
cluster = Cluster()
else:
cluster = cluster_helper
tasks = []
rest = RestConnection(servers[0])
buckets = rest.get_buckets()
for server in servers:
for bucket in buckets:
for server_repl in list(set(servers) - {server}):
tasks.append(
cluster.async_wait_for_stats(
[server], bucket, 'tap',
'eq_tapq:replication_ns_1@' + server_repl.ip +
':idle', '==', 'true'))
tasks.append(
cluster.async_wait_for_stats(
[server], bucket, 'tap',
'eq_tapq:replication_ns_1@' + server_repl.ip +
':backfill_completed', '==', 'true'))
try:
for task in tasks:
task.result(timeout)
finally:
if cluster_helper is None:
# stop all newly created task manager threads
cluster.shutdown()
return True
def setUp(self):
super(NodeServiceTests, self).setUp()
self.helper = ServerHelper(self)
num_buckets = self.input.param("num_buckets", 1)
compression = self.input.param("sdk_compression", True)
for i in range(num_buckets):
RestConnection(self.servers[0]).create_bucket(
bucket='bucket%s' % i,
ramQuotaMB=100,
proxyPort=STANDARD_BUCKET_PORT + i + 1)
gen_load = BlobGenerator('ui', 'ui-', 256, start=0, end=10)
cluster = Cluster()
try:
gen = copy.deepcopy(gen_load)
task = cluster.async_load_gen_docs(self.servers[0],
'bucket%s' % i,
gen,
Bucket().kvs[1],
'create',
0,
0,
True,
1,
1,
30,
compression=compression)
task.result()
finally:
cluster.shutdown()
BaseHelper(self).login()
class SwapRebalanceBase(unittest.TestCase):
@staticmethod
def common_setup(self):
self.log = logger.Logger.get_logger()
self.cluster_run = False
self.input = TestInputSingleton.input
self.servers = self.input.servers
serverInfo = self.servers[0]
rest = RestConnection(serverInfo)
if len(set([server.ip for server in self.servers])) == 1:
ip = rest.get_nodes_self().ip
for server in self.servers:
server.ip = ip
self.cluster_run = True
self.case_number = self.input.param("case_number", 0)
self.replica = self.input.param("replica", 1)
self.keys_count = self.input.param("keys-count", 1000)
self.load_ratio = self.input.param("load-ratio", 1)
self.ratio_expiry = self.input.param("ratio-expiry", 0.03)
self.ratio_deletes = self.input.param("ratio-deletes", 0.13)
self.num_buckets = self.input.param("num-buckets", 1)
self.failover_factor = self.num_swap = self.input.param("num-swap", 1)
self.num_initial_servers = self.input.param("num-initial-servers", 3)
self.fail_orchestrator = self.swap_orchestrator = self.input.param("swap-orchestrator", False)
self.do_access = self.input.param("do-access", True)
self.load_started = False
self.loaders = []
try:
# Clear the state from Previous invalid run
if rest._rebalance_progress_status() == 'running':
self.log.warning("rebalancing is still running, previous test should be verified")
stopped = rest.stop_rebalance()
self.assertTrue(stopped, msg="unable to stop rebalance")
self.log.info("============== SwapRebalanceBase setup was started for test #{0} {1}=============="\
.format(self.case_number, self._testMethodName))
SwapRebalanceBase.reset(self)
self.cluster_helper = Cluster()
# Make sure the test is setup correctly
min_servers = int(self.num_initial_servers) + int(self.num_swap)
msg = "minimum {0} nodes required for running swap rebalance"
self.assertTrue(len(self.servers) >= min_servers, msg=msg.format(min_servers))
self.log.info('picking server : {0} as the master'.format(serverInfo))
node_ram_ratio = BucketOperationHelper.base_bucket_ratio(self.servers)
info = rest.get_nodes_self()
rest.init_cluster(username=serverInfo.rest_username, password=serverInfo.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=int(info.mcdMemoryReserved * node_ram_ratio))
if self.num_buckets > 10:
BaseTestCase.change_max_buckets(self, self.num_buckets)
self.log.info("============== SwapRebalanceBase setup was finished for test #{0} {1} =============="
.format(self.case_number, self._testMethodName))
SwapRebalanceBase._log_start(self)
except Exception, e:
self.cluster_helper.shutdown()
self.fail(e)
def main():
try:
(opts, args) = getopt.getopt(sys.argv[1:], 'hi:p', [])
for o, a in opts:
if o == "-h":
usage()
input = TestInput.TestInputParser.get_test_input(sys.argv)
if not input.servers:
usage("ERROR: no servers specified. Please use the -i parameter.")
except IndexError:
usage()
except getopt.GetoptError as error:
usage("ERROR: " + str(error))
docs_per_day = input.param("doc_per_day", 49)
years = input.param("years", 2)
bucket_name = input.param("bucket_name", "default")
bucket_port = input.param("bucket_port", None)
bucket_sasl_pass = input.param("bucket_sasl_pass", None)
flag = input.param("flags", 0)
to_directory = input.param("to_dir", '')
loader_type = input.param("loader_type", 'default')
if to_directory:
loader = DocLoaderDirectory(input.servers[0], to_directory,
bucket_name)
generators_load = loader.generate_docs(docs_per_day, years)
loader.load(generators_load)
else:
cluster = Cluster()
try:
bucket = initialize_bucket(bucket_name, bucket_port,
bucket_sasl_pass)
if loader_type == 'default':
loader = DocLoaderCouchbase(input.servers, cluster)
elif loader_type == 'join':
loader = JoinDocLoader(input.servers, cluster)
elif loader_type == 'sabre':
loader = SabreDocLoader(input.servers, cluster)
elif loader_type == 'base64':
loader = Base64DocLoader(input.servers, cluster)
elif loader_type == 'nondoc':
loader = NonDocLoader(input.servers, cluster)
generators_load = loader.generate_docs(docs_per_day, years)
loader.load(generators_load, bucket, flag=flag)
finally:
cluster.shutdown()
def setUp(self):
super(NodeServiceTests, self).setUp()
self.helper = ServerHelper(self)
num_buckets = self.input.param("num_buckets", 1)
for i in xrange(num_buckets):
RestConnection(self.servers[0]).create_bucket(bucket='bucket%s' % i, ramQuotaMB=100, proxyPort=STANDARD_BUCKET_PORT + i + 1)
gen_load = BlobGenerator('ui', 'ui-', 256, start=0, end=10)
cluster = Cluster()
try:
gen = copy.deepcopy(gen_load)
task = cluster.async_load_gen_docs(self.servers[0], 'bucket%s' % i, gen,
Bucket().kvs[1], 'create',
0, 0, True, 1, 1, 30)
task.result()
finally:
cluster.shutdown()
BaseHelper(self).login()
def wait_for_replication(servers, cluster_helper=None, timeout=600):
if cluster_helper is None:
cluster = Cluster()
else:
cluster = cluster_helper
tasks = []
rest = RestConnection(servers[0])
buckets = rest.get_buckets()
for server in servers:
for bucket in buckets:
for server_repl in list(set(servers) - set([server])):
tasks.append(cluster.async_wait_for_stats([server], bucket, 'tap',
'eq_tapq:replication_ns_1@' + server_repl.ip + ':idle', '==', 'true'))
tasks.append(cluster.async_wait_for_stats([server], bucket, 'tap',
'eq_tapq:replication_ns_1@' + server_repl.ip + ':backfill_completed', '==', 'true'))
try:
for task in tasks:
task.result(timeout)
finally:
if cluster_helper is None:
# stop all newly created task manager threads
cluster.shutdown()
return True
except IndexError:
usage()
except getopt.GetoptError, error:
usage("ERROR: " + str(error))
docs_per_day = input.param("doc_per_day", 49)
years = input.param("years", 2)
bucket_name = input.param("bucket_name", "default")
bucket_port = input.param("bucket_port", None)
bucket_sasl_pass = input.param("bucket_sasl_pass", None)
flag = input.param("flags", 0)
to_directory = input.param("to_dir", "")
if to_directory:
loader = DocLoaderDirectory(input.servers[0], to_directory, bucket_name)
generators_load = loader.generate_docs(docs_per_day, years)
loader.load(generators_load)
else:
cluster = Cluster()
try:
bucket = initialize_bucket(bucket_name, bucket_port, bucket_sasl_pass)
loader = DocLoaderCouchbase(input.servers, cluster)
generators_load = loader.generate_docs(docs_per_day, years)
loader.load(generators_load, bucket, flag=flag)
finally:
cluster.shutdown()
if __name__ == "__main__":
main()
class SwapRebalanceBase(unittest.TestCase):
@staticmethod
def common_setup(self):
self.cluster_helper = Cluster()
self.log = logger.Logger.get_logger()
self.cluster_run = False
self.input = TestInputSingleton.input
self.servers = self.input.servers
serverInfo = self.servers[0]
rest = RestConnection(serverInfo)
if len(set([server.ip for server in self.servers])) == 1:
ip = rest.get_nodes_self().ip
for server in self.servers:
server.ip = ip
self.cluster_run = True
self.case_number = self.input.param("case_number", 0)
self.replica = self.input.param("replica", 1)
self.keys_count = self.input.param("keys-count", 1000)
self.load_ratio = self.input.param("load-ratio", 1)
self.ratio_expiry = self.input.param("ratio-expiry", 0.03)
self.ratio_deletes = self.input.param("ratio-deletes", 0.13)
self.num_buckets = self.input.param("num-buckets", 1)
self.failover_factor = self.num_swap = self.input.param("num-swap", 1)
self.num_initial_servers = self.input.param("num-initial-servers", 3)
self.fail_orchestrator = self.swap_orchestrator = self.input.param(
"swap-orchestrator", False)
self.do_access = self.input.param("do-access", True)
self.load_started = False
self.loaders = []
try:
# Clear the state from Previous invalid run
if rest._rebalance_progress_status() == 'running':
self.log.warning(
"rebalancing is still running, previous test should be verified"
)
stopped = rest.stop_rebalance()
self.assertTrue(stopped, msg="unable to stop rebalance")
self.log.info("============== SwapRebalanceBase setup was started for test #{0} {1}=============="\
.format(self.case_number, self._testMethodName))
SwapRebalanceBase.reset(self)
# Make sure the test is setup correctly
min_servers = int(self.num_initial_servers) + int(self.num_swap)
msg = "minimum {0} nodes required for running swap rebalance"
self.assertTrue(len(self.servers) >= min_servers,
msg=msg.format(min_servers))
self.log.info(
'picking server : {0} as the master'.format(serverInfo))
node_ram_ratio = BucketOperationHelper.base_bucket_ratio(
self.servers)
info = rest.get_nodes_self()
rest.init_cluster(username=serverInfo.rest_username,
password=serverInfo.rest_password)
rest.init_cluster_memoryQuota(
memoryQuota=int(info.mcdMemoryReserved * node_ram_ratio))
SwapRebalanceBase.enable_diag_eval_on_non_local_hosts(
self, serverInfo)
# Add built-in user
testuser = [{
'id': 'cbadminbucket',
'name': 'cbadminbucket',
'password': '******'
}]
RbacBase().create_user_source(testuser, 'builtin', self.servers[0])
# Assign user to role
role_list = [{
'id': 'cbadminbucket',
'name': 'cbadminbucket',
'roles': 'admin'
}]
RbacBase().add_user_role(role_list,
RestConnection(self.servers[0]),
'builtin')
if self.num_buckets > 10:
BaseTestCase.change_max_buckets(self, self.num_buckets)
self.log.info(
"============== SwapRebalanceBase setup was finished for test #{0} {1} =============="
.format(self.case_number, self._testMethodName))
SwapRebalanceBase._log_start(self)
except Exception, e:
self.cluster_helper.shutdown()
self.fail(e)
class BaseUITestCase(unittest.TestCase):
# selenium thread
def _start_selenium(self):
host = self.machine.ip
if host in ['localhost', '127.0.0.1']:
os.system("java -jar %sselenium-server-standalone*.jar -Dwebdriver.chrome.driver=%s > selenium.log 2>&1"
% (self.input.ui_conf['selenium_path'], self.input.ui_conf['chrome_path']))
else:
self.shell.execute_command('{0}start-selenium.bat > {0}selenium.log 2>&1 &'.format(self.input.ui_conf['selenium_path']))
def _kill_old_drivers(self):
if self.shell.extract_remote_info().type.lower() == 'windows':
self.shell.execute_command('taskkill /F /IM chromedriver.exe')
self.shell.execute_command('taskkill /F /IM chrome.exe')
def _wait_for_selenium_is_started(self, timeout=10):
if self.machine.ip in ['localhost', '127.0.0.1']:
start_time = time.time()
while (time.time() - start_time) < timeout:
log = open("/tmp/selenium.log")
if log.read().find('Started org.openqa.jetty.jetty.Server') > -1:
log.close()
if self._is_selenium_running():
time.sleep(1)
return
time.sleep(1)
else:
time.sleep(timeout)
def _start_selenium_thread(self):
self.t = Thread(target=self._start_selenium,
name="selenium",
args=())
self.t.start()
def _is_selenium_running(self):
host = self.machine.ip
if host in ['localhost', '127.0.0.1']:
cmd = 'ps -ef|grep selenium-server'
output = commands.getstatusoutput(cmd)
if str(output).find('selenium-server-standalone') > -1:
return True
else:
#cmd = "ssh {0}@{1} 'bash -s' < 'tasklist |grep selenium-server'".format(self.input.servers[0].ssh_username,
# host)
cmd = 'tasklist |grep java'
o, r = self.shell.execute_command(cmd)
#cmd = "ssh {0}@{1} 'bash -s' < 'ps -ef|grep selenium-server'"
if str(o).find('java') > -1:
return True
return False
def setUp(self):
try:
self.log = logger.Logger.get_logger()
self.input = TestInputSingleton.input
self.servers = self.input.servers
self.browser = self.input.ui_conf['browser']
self.replica = self.input.param("replica", 1)
self.case_number = self.input.param("case_number", 0)
self.cluster = Cluster()
self.machine = self.input.ui_conf['server']
self.driver = None
self.shell = RemoteMachineShellConnection(self.machine)
#avoid clean up if the previous test has been tear down
if not self.input.param("skip_cleanup", True) \
or self.case_number == 1:
self.tearDown()
self._log_start(self)
self._kill_old_drivers()
#thread for selenium server
if not self._is_selenium_running():
self.log.info('start selenium')
self._start_selenium_thread()
self._wait_for_selenium_is_started()
self.log.info('start selenium session')
if self.browser == 'ff':
self.driver = webdriver.Remote(command_executor='http://{0}:{1}/wd/hub'
.format(self.machine.ip,
self.machine.port),
desired_capabilities=DesiredCapabilities.FIREFOX)
elif self.browser == 'chrome':
self.driver = webdriver.Remote(command_executor='http://{0}:{1}/wd/hub'
.format(self.machine.ip,
self.machine.port),
desired_capabilities=DesiredCapabilities.CHROME)
self.log.info('start selenium started')
self.driver.get("http://{0}:{1}".format(self.servers[0].ip,
self.servers[0].port))
self.driver.maximize_window()
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)
@staticmethod
def _log_start(self):
try:
msg = "{0} : {1} started ".format(datetime.datetime.now(),
self._testMethodName)
RestConnection(self.servers[0]).log_client_error(msg)
except:
pass
@staticmethod
def _log_finish(self):
try:
msg = "{0} : {1} finished ".format(datetime.datetime.now(),
self._testMethodName)
RestConnection(self.servers[0]).log_client_error(msg)
except:
pass
def tearDown(self):
try:
if self.driver:
path_screen = self.input.ui_conf['screenshots'] or 'logs/screens'
full_path = '{1}/screen_{0}.png'.format(time.time(), path_screen)
self.log.info('screenshot is available: %s' % full_path)
if not os.path.exists(path_screen):
os.mkdir(path_screen)
self.driver.get_screenshot_as_file(os.path.abspath(full_path))
rest = RestConnection(self.servers[0])
if rest._rebalance_progress_status() == 'running':
stopped = rest.stop_rebalance()
self.assertTrue(stopped, msg="unable to stop rebalance")
BucketOperationHelper.delete_all_buckets_or_assert(self.servers, self)
for server in self.servers:
ClusterOperationHelper.cleanup_cluster([server])
ClusterOperationHelper.wait_for_ns_servers_or_assert(self.servers, self)
if self.driver:
self.driver.close()
except Exception as e:
raise e
finally:
if self.driver:
self.shell.disconnect()
self.cluster.shutdown()
class SwapRebalanceBase(unittest.TestCase):
@staticmethod
def common_setup(self):
self.cluster_helper = Cluster()
self.log = logger.Logger.get_logger()
self.cluster_run = False
self.input = TestInputSingleton.input
self.servers = self.input.servers
serverInfo = self.servers[0]
rest = RestConnection(serverInfo)
if len({server.ip for server in self.servers}) == 1:
ip = rest.get_nodes_self().ip
for server in self.servers:
server.ip = ip
self.cluster_run = True
self.case_number = self.input.param("case_number", 0)
self.replica = self.input.param("replica", 1)
self.keys_count = self.input.param("keys-count", 1000)
self.load_ratio = self.input.param("load-ratio", 1)
self.ratio_expiry = self.input.param("ratio-expiry", 0.03)
self.ratio_deletes = self.input.param("ratio-deletes", 0.13)
self.num_buckets = self.input.param("num-buckets", 1)
self.bucket_storage = self.input.param("bucket_storage", 'couchstore')
self.failover_factor = self.num_swap = self.input.param("num-swap", 1)
self.num_initial_servers = self.input.param("num-initial-servers", 3)
self.fail_orchestrator = self.swap_orchestrator = self.input.param("swap-orchestrator", False)
self.do_access = self.input.param("do-access", True)
self.load_started = False
self.loaders = []
for node in self.servers:
if node.internal_ip:
RestConnection(node).set_alternate_address(node.ip)
try:
# Clear the state from Previous invalid run
if rest._rebalance_progress_status() == 'running':
self.log.warning("rebalancing is still running, previous test should be verified")
stopped = rest.stop_rebalance()
self.assertTrue(stopped, msg="unable to stop rebalance")
self.log.info("============== SwapRebalanceBase setup was started for test #{0} {1}=============="\
.format(self.case_number, self._testMethodName))
SwapRebalanceBase.reset(self)
# Make sure the test is setup correctly
min_servers = int(self.num_initial_servers) + int(self.num_swap)
msg = "minimum {0} nodes required for running swap rebalance"
self.assertTrue(len(self.servers) >= min_servers, msg=msg.format(min_servers))
self.log.info('picking server : {0} as the master'.format(serverInfo))
node_ram_ratio = BucketOperationHelper.base_bucket_ratio(self.servers)
info = rest.get_nodes_self()
rest.init_cluster(username=serverInfo.rest_username, password=serverInfo.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=int(info.mcdMemoryReserved * node_ram_ratio))
SwapRebalanceBase.enable_diag_eval_on_non_local_hosts(self, serverInfo)
# Add built-in user
testuser = [{'id': 'cbadminbucket', 'name': 'cbadminbucket', 'password': '******'}]
RbacBase().create_user_source(testuser, 'builtin', self.servers[0])
# Assign user to role
role_list = [{'id': 'cbadminbucket', 'name': 'cbadminbucket', 'roles': 'admin'}]
RbacBase().add_user_role(role_list, RestConnection(self.servers[0]), 'builtin')
if self.num_buckets > 10:
BaseTestCase.change_max_buckets(self, self.num_buckets)
self.log.info("============== SwapRebalanceBase setup was finished for test #{0} {1} =============="
.format(self.case_number, self._testMethodName))
SwapRebalanceBase._log_start(self)
except Exception as e:
self.cluster_helper.shutdown()
self.fail(e)
@staticmethod
def common_tearDown(self):
self.cluster_helper.shutdown()
test_failed = (hasattr(self, '_resultForDoCleanups') and len(self._resultForDoCleanups.failures or self._resultForDoCleanups.errors)) \
or (hasattr(self, '_exc_info') and self._exc_info()[1] is not None)
if test_failed and TestInputSingleton.input.param("stop-on-failure", False)\
or self.input.param("skip_cleanup", False):
self.log.warning("CLEANUP WAS SKIPPED")
else:
SwapRebalanceBase.reset(self)
SwapRebalanceBase._log_finish(self)
# Remove rbac user in teardown
try:
role_del = ['cbadminbucket']
RbacBase().remove_user_role(role_del, RestConnection(
self.servers[0]))
except:
pass
@staticmethod
def reset(self):
self.log.info("============== SwapRebalanceBase cleanup was started for test #{0} {1} =============="\
.format(self.case_number, self._testMethodName))
self.log.info("Stopping load in Teardown")
SwapRebalanceBase.stop_load(self.loaders)
for server in self.servers:
rest = RestConnection(server)
if rest._rebalance_progress_status() == 'running':
self.log.warning("rebalancing is still running, test should be verified")
stopped = rest.stop_rebalance()
self.assertTrue(stopped, msg="unable to stop rebalance")
BucketOperationHelper.delete_all_buckets_or_assert(self.servers, self)
for server in self.servers:
ClusterOperationHelper.cleanup_cluster([server])
if server.data_path:
rest = RestConnection(server)
rest.set_data_path(data_path=server.data_path)
ClusterOperationHelper.wait_for_ns_servers_or_assert(self.servers, self)
self.log.info("============== SwapRebalanceBase cleanup was finished for test #{0} {1} =============="\
.format(self.case_number, self._testMethodName))
@staticmethod
def enable_diag_eval_on_non_local_hosts(self, master):
"""
Enable diag/eval to be run on non-local hosts.
:param master: Node information of the master node of the cluster
:return: Nothing
"""
remote = RemoteMachineShellConnection(master)
output, error = remote.enable_diag_eval_on_non_local_hosts()
if "ok" not in output:
self.log.error("Error in enabling diag/eval on non-local hosts on {}. {}".format(master.ip, output))
raise Exception("Error in enabling diag/eval on non-local hosts on {}".format(master.ip))
else:
self.log.info("Enabled diag/eval for non-local hosts from {}".format(master.ip))
@staticmethod
def _log_start(self):
try:
msg = "{0} : {1} started ".format(datetime.datetime.now(), self._testMethodName)
RestConnection(self.servers[0]).log_client_error(msg)
except:
pass
@staticmethod
def _log_finish(self):
try:
msg = "{0} : {1} finished ".format(datetime.datetime.now(), self._testMethodName)
RestConnection(self.servers[0]).log_client_error(msg)
except:
pass
@staticmethod
def sleep(self, timeout=1, message=""):
self.log.info("sleep for {0} secs. {1} ...".format(timeout, message))
time.sleep(timeout)
@staticmethod
def _create_default_bucket(self, replica=1):
name = "default"
master = self.servers[0]
rest = RestConnection(master)
helper = RestHelper(RestConnection(master))
if not helper.bucket_exists(name):
node_ram_ratio = BucketOperationHelper.base_bucket_ratio(self.servers)
info = rest.get_nodes_self()
available_ram = info.memoryQuota * node_ram_ratio
rest.create_bucket(bucket=name, ramQuotaMB=int(available_ram), replicaNumber=replica,
storageBackend=self.bucket_storage)
ready = BucketOperationHelper.wait_for_memcached(master, name)
self.assertTrue(ready, msg="wait_for_memcached failed")
self.assertTrue(helper.bucket_exists(name),
msg="unable to create {0} bucket".format(name))
@staticmethod
def _create_multiple_buckets(self, replica=1):
master = self.servers[0]
created = BucketOperationHelper.create_multiple_buckets(master, replica, howmany=self.num_buckets,
bucket_storage=self.bucket_storage)
self.assertTrue(created, "unable to create multiple buckets")
rest = RestConnection(master)
buckets = rest.get_buckets()
for bucket in buckets:
ready = BucketOperationHelper.wait_for_memcached(master, bucket.name)
self.assertTrue(ready, msg="wait_for_memcached failed")
# Used for items verification active vs. replica
@staticmethod
def items_verification(test, master):
rest = RestConnection(master)
# Verify items count across all node
timeout = 600
for bucket in rest.get_buckets():
verified = RebalanceHelper.wait_till_total_numbers_match(master, bucket.name, timeout_in_seconds=timeout)
test.assertTrue(verified, "Lost items!!.. failing test in {0} secs".format(timeout))
@staticmethod
def start_load_phase(self, master):
loaders = []
rest = RestConnection(master)
for bucket in rest.get_buckets():
loader = dict()
loader["mcsoda"] = LoadWithMcsoda(master, self.keys_count, bucket=bucket.name,
rest_password=master.rest_password, prefix=str(bucket.name), port=8091)
loader["mcsoda"].cfg["exit-after-creates"] = 1
loader["mcsoda"].cfg["json"] = 0
loader["thread"] = Thread(target=loader["mcsoda"].load_data, name='mcloader_' + bucket.name)
loader["thread"].daemon = True
loaders.append(loader)
for loader in loaders:
loader["thread"].start()
return loaders
@staticmethod
def start_access_phase(self, master):
loaders = []
rest = RestConnection(master)
for bucket in rest.get_buckets():
loader = dict()
loader["mcsoda"] = LoadWithMcsoda(master, self.keys_count // 2, bucket=bucket.name,
rest_password=master.rest_password, prefix=str(bucket.name), port=8091)
loader["mcsoda"].cfg["ratio-sets"] = 0.8
loader["mcsoda"].cfg["ratio-hot"] = 0.2
loader["mcsoda"].cfg["ratio-creates"] = 0.5
loader["mcsoda"].cfg["ratio-deletes"] = self.ratio_deletes
loader["mcsoda"].cfg["ratio-expirations"] = self.ratio_expiry
loader["mcsoda"].cfg["json"] = 0
loader["thread"] = Thread(target=loader["mcsoda"].load_data, name='mcloader_' + bucket.name)
loader["thread"].daemon = True
loaders.append(loader)
for loader in loaders:
loader["thread"].start()
return loaders
@staticmethod
def stop_load(loaders, do_stop=True):
if do_stop:
for loader in loaders:
loader["mcsoda"].load_stop()
for loader in loaders:
if do_stop:
loader["thread"].join(300)
else:
loader["thread"].join()
@staticmethod
def create_buckets(self):
if self.num_buckets == 1:
SwapRebalanceBase._create_default_bucket(self, replica=self.replica)
else:
SwapRebalanceBase._create_multiple_buckets(self, replica=self.replica)
@staticmethod
def verification_phase(test, master):
# Stop loaders
SwapRebalanceBase.stop_load(test.loaders)
test.log.info("DONE DATA ACCESS PHASE")
test.log.info("VERIFICATION PHASE")
rest = RestConnection(master)
servers_in_cluster = []
nodes = rest.get_nodes()
for server in test.servers:
for node in nodes:
if node.ip == server.ip and node.port == server.port:
servers_in_cluster.append(server)
time.sleep(60)
SwapRebalanceBase.items_verification(test, master)
@staticmethod
def _common_test_body_swap_rebalance(self, do_stop_start=False):
master = self.servers[0]
rest = RestConnection(master)
num_initial_servers = self.num_initial_servers
creds = self.input.membase_settings
intial_severs = self.servers[:num_initial_servers]
self.log.info("CREATE BUCKET PHASE")
SwapRebalanceBase.create_buckets(self)
# Cluster all starting set of servers
self.log.info("INITIAL REBALANCE PHASE")
status, servers_rebalanced = RebalanceHelper.rebalance_in(intial_severs, len(intial_severs) - 1)
self.assertTrue(status, msg="Rebalance was failed")
self.log.info("DATA LOAD PHASE")
self.loaders = SwapRebalanceBase.start_load_phase(self, master)
# Wait till load phase is over
SwapRebalanceBase.stop_load(self.loaders, do_stop=False)
self.log.info("DONE LOAD PHASE")
# Start the swap rebalance
current_nodes = RebalanceHelper.getOtpNodeIds(master)
self.log.info("current nodes : {0}".format(current_nodes))
toBeEjectedNodes = RebalanceHelper.pick_nodes(master, howmany=self.num_swap)
optNodesIds = [node.id for node in toBeEjectedNodes]
if self.swap_orchestrator:
status, content = ClusterOperationHelper.find_orchestrator(master)
self.assertTrue(status, msg="Unable to find orchestrator: {0}:{1}".\
format(status, content))
if self.num_swap is len(current_nodes):
optNodesIds.append(content)
else:
optNodesIds[0] = content
for node in optNodesIds:
self.log.info("removing node {0} and rebalance afterwards".format(node))
new_swap_servers = self.servers[num_initial_servers:num_initial_servers + self.num_swap]
for server in new_swap_servers:
otpNode = rest.add_node(creds.rest_username, creds.rest_password, server.cluster_ip, server.port)
msg = "unable to add node {0} to the cluster"
self.assertTrue(otpNode, msg.format(server.ip))
if self.swap_orchestrator:
rest = RestConnection(new_swap_servers[0])
master = new_swap_servers[0]
if self.do_access:
self.log.info("DATA ACCESS PHASE")
self.loaders = SwapRebalanceBase.start_access_phase(self, master)
self.log.info("SWAP REBALANCE PHASE")
rest.rebalance(otpNodes=[node.id for node in rest.node_statuses()],
ejectedNodes=optNodesIds)
if do_stop_start:
# Rebalance is stopped at 20%, 40% and 60% completion
retry = 0
for expected_progress in (20, 40, 60):
self.log.info("STOP/START SWAP REBALANCE PHASE WITH PROGRESS {0}%".
format(expected_progress))
while True:
progress = rest._rebalance_progress()
if progress < 0:
self.log.error("rebalance progress code : {0}".format(progress))
break
elif progress == 100:
self.log.warning("Rebalance has already reached 100%")
break
elif progress >= expected_progress:
self.log.info("Rebalance will be stopped with {0}%".format(progress))
stopped = rest.stop_rebalance()
self.assertTrue(stopped, msg="unable to stop rebalance")
SwapRebalanceBase.sleep(self, 20)
rest.rebalance(otpNodes=[node.id for node in rest.node_statuses()],
ejectedNodes=optNodesIds)
break
elif retry > 100:
break
else:
retry += 1
SwapRebalanceBase.sleep(self, 1)
self.assertTrue(rest.monitorRebalance(),
msg="rebalance operation failed after adding node {0}".format(optNodesIds))
SwapRebalanceBase.verification_phase(self, master)
@staticmethod
def _common_test_body_failed_swap_rebalance(self):
master = self.servers[0]
rest = RestConnection(master)
num_initial_servers = self.num_initial_servers
creds = self.input.membase_settings
intial_severs = self.servers[:num_initial_servers]
self.log.info("CREATE BUCKET PHASE")
SwapRebalanceBase.create_buckets(self)
# Cluster all starting set of servers
self.log.info("INITIAL REBALANCE PHASE")
status, servers_rebalanced = RebalanceHelper.rebalance_in(intial_severs, len(intial_severs) - 1)
self.assertTrue(status, msg="Rebalance was failed")
self.log.info("DATA LOAD PHASE")
self.loaders = SwapRebalanceBase.start_load_phase(self, master)
# Wait till load phase is over
SwapRebalanceBase.stop_load(self.loaders, do_stop=False)
self.log.info("DONE LOAD PHASE")
# Start the swap rebalance
current_nodes = RebalanceHelper.getOtpNodeIds(master)
self.log.info("current nodes : {0}".format(current_nodes))
toBeEjectedNodes = RebalanceHelper.pick_nodes(master, howmany=self.num_swap)
optNodesIds = [node.id for node in toBeEjectedNodes]
if self.swap_orchestrator:
status, content = ClusterOperationHelper.find_orchestrator(master)
self.assertTrue(status, msg="Unable to find orchestrator: {0}:{1}".\
format(status, content))
# When swapping all the nodes
if self.num_swap is len(current_nodes):
optNodesIds.append(content)
else:
optNodesIds[0] = content
for node in optNodesIds:
self.log.info("removing node {0} and rebalance afterwards".format(node))
new_swap_servers = self.servers[num_initial_servers:num_initial_servers + self.num_swap]
for server in new_swap_servers:
otpNode = rest.add_node(creds.rest_username, creds.rest_password, server.ip, server.port)
msg = "unable to add node {0} to the cluster"
self.assertTrue(otpNode, msg.format(server.ip))
if self.swap_orchestrator:
rest = RestConnection(new_swap_servers[0])
master = new_swap_servers[0]
self.log.info("DATA ACCESS PHASE")
self.loaders = SwapRebalanceBase.start_access_phase(self, master)
self.log.info("SWAP REBALANCE PHASE")
rest.rebalance(otpNodes=[node.id for node in rest.node_statuses()],
ejectedNodes=optNodesIds)
SwapRebalanceBase.sleep(self, 10, "Rebalance should start")
self.log.info("FAIL SWAP REBALANCE PHASE @ {0}".format(self.percentage_progress))
reached = RestHelper(rest).rebalance_reached(self.percentage_progress)
if reached and RestHelper(rest).is_cluster_rebalanced():
# handle situation when rebalance failed at the beginning
self.log.error('seems rebalance failed!')
rest.print_UI_logs()
self.fail("rebalance failed even before killing memcached")
bucket = rest.get_buckets()[0].name
pid = None
if self.swap_orchestrator and not self.cluster_run:
# get PID via remote connection if master is a new node
shell = RemoteMachineShellConnection(master)
pid = shell.get_memcache_pid()
shell.disconnect()
else:
times = 2
if self.cluster_run:
times = 20
for i in range(times):
try:
_mc = MemcachedClientHelper.direct_client(master, bucket)
pid = _mc.stats()["pid"]
break
except (EOFError, KeyError) as e:
self.log.error("{0}.Retry in 2 sec".format(e))
SwapRebalanceBase.sleep(self, 2)
if pid is None:
# sometimes pid is not returned by mc.stats()
shell = RemoteMachineShellConnection(master)
pid = shell.get_memcache_pid()
shell.disconnect()
if pid is None:
self.fail("impossible to get a PID")
command = "os:cmd(\"kill -9 {0} \")".format(pid)
self.log.info(command)
killed = rest.diag_eval(command)
self.log.info("killed {0}:{1}?? {2} ".format(master.ip, master.port, killed))
self.log.info("sleep for 10 sec after kill memcached")
SwapRebalanceBase.sleep(self, 10)
# we can't get stats for new node when rebalance falls
if not self.swap_orchestrator:
ClusterOperationHelper._wait_warmup_completed(self, [master], bucket, wait_time=600)
i = 0
# we expect that rebalance will be failed
try:
rest.monitorRebalance()
except RebalanceFailedException:
# retry rebalance if it failed
self.log.warning("Rebalance failed but it's expected")
SwapRebalanceBase.sleep(self, 30)
self.assertFalse(RestHelper(rest).is_cluster_rebalanced(), msg="cluster need rebalance")
knownNodes = rest.node_statuses();
self.log.info("nodes are still in cluster: {0}".format([(node.ip, node.port) for node in knownNodes]))
ejectedNodes = list(set(optNodesIds) & {node.id for node in knownNodes})
rest.rebalance(otpNodes=[node.id for node in knownNodes], ejectedNodes=ejectedNodes)
SwapRebalanceBase.sleep(self, 10, "Wait for rebalance to start")
self.assertTrue(rest.monitorRebalance(),
msg="rebalance operation failed after adding node {0}".format(toBeEjectedNodes))
else:
self.log.info("rebalance completed successfully")
SwapRebalanceBase.verification_phase(self, master)
@staticmethod
def _add_back_failed_node(self, do_node_cleanup=False):
master = self.servers[0]
rest = RestConnection(master)
creds = self.input.membase_settings
self.log.info("CREATE BUCKET PHASE")
SwapRebalanceBase.create_buckets(self)
# Cluster all servers
self.log.info("INITIAL REBALANCE PHASE")
status, servers_rebalanced = RebalanceHelper.rebalance_in(self.servers, len(self.servers) - 1)
self.assertTrue(status, msg="Rebalance was failed")
self.log.info("DATA LOAD PHASE")
self.loaders = SwapRebalanceBase.start_load_phase(self, master)
# Wait till load phase is over
SwapRebalanceBase.stop_load(self.loaders, do_stop=False)
self.log.info("DONE LOAD PHASE")
# Start the swap rebalance
current_nodes = RebalanceHelper.getOtpNodeIds(master)
self.log.info("current nodes : {0}".format(current_nodes))
toBeEjectedNodes = RebalanceHelper.pick_nodes(master, howmany=self.failover_factor)
optNodesIds = [node.id for node in toBeEjectedNodes]
# List of servers that will not be failed over
not_failed_over = []
for server in self.servers:
if self.cluster_run:
if server.port not in [node.port for node in toBeEjectedNodes]:
not_failed_over.append(server)
self.log.info("Node {0}:{1} not failed over".format(server.ip, server.port))
else:
if server.ip not in [node.ip for node in toBeEjectedNodes]:
not_failed_over.append(server)
self.log.info("Node {0}:{1} not failed over".format(server.ip, server.port))
if self.fail_orchestrator:
status, content = ClusterOperationHelper.find_orchestrator(master)
self.assertTrue(status, msg="Unable to find orchestrator: {0}:{1}".\
format(status, content))
# When swapping all the nodes
if self.num_swap is len(current_nodes):
optNodesIds.append(content)
else:
optNodesIds[0] = content
master = not_failed_over[-1]
self.log.info("DATA ACCESS PHASE")
self.loaders = SwapRebalanceBase.start_access_phase(self, master)
# Failover selected nodes
for node in optNodesIds:
self.log.info("failover node {0} and rebalance afterwards".format(node))
rest.fail_over(node)
rest.rebalance(otpNodes=[node.id for node in rest.node_statuses()], \
ejectedNodes=optNodesIds)
self.assertTrue(rest.monitorRebalance(),
msg="rebalance operation failed after adding node {0}".format(optNodesIds))
# Add back the same failed over nodes
# Cleanup the node, somehow
# TODO: cluster_run?
if do_node_cleanup:
pass
# Make rest connection with node part of cluster
rest = RestConnection(master)
# Given the optNode, find ip
add_back_servers = []
nodes = rest.get_nodes()
for server in nodes:
if isinstance(server.ip, str):
add_back_servers.append(server)
final_add_back_servers = []
for server in self.servers:
if self.cluster_run:
if server.port not in [serv.port for serv in add_back_servers]:
final_add_back_servers.append(server)
else:
if server.ip not in [serv.ip for serv in add_back_servers]:
final_add_back_servers.append(server)
for server in final_add_back_servers:
otpNode = rest.add_node(creds.rest_username, creds.rest_password, server.ip, server.port)
msg = "unable to add node {0} to the cluster"
self.assertTrue(otpNode, msg.format(server.ip))
rest.rebalance(otpNodes=[node.id for node in rest.node_statuses()], ejectedNodes=[])
self.assertTrue(rest.monitorRebalance(),
msg="rebalance operation failed after adding node {0}".format(add_back_servers))
SwapRebalanceBase.verification_phase(self, master)
@staticmethod
def _failover_swap_rebalance(self):
master = self.servers[0]
rest = RestConnection(master)
creds = self.input.membase_settings
num_initial_servers = self.num_initial_servers
intial_severs = self.servers[:num_initial_servers]
self.log.info("CREATE BUCKET PHASE")
SwapRebalanceBase.create_buckets(self)
# Cluster all starting set of servers
self.log.info("INITIAL REBALANCE PHASE")
status, servers_rebalanced = RebalanceHelper.rebalance_in(intial_severs, len(intial_severs) - 1)
self.assertTrue(status, msg="Rebalance was failed")
self.log.info("DATA LOAD PHASE")
self.loaders = SwapRebalanceBase.start_load_phase(self, master)
# Wait till load phase is over
SwapRebalanceBase.stop_load(self.loaders, do_stop=False)
self.log.info("DONE LOAD PHASE")
# Start the swap rebalance
self.log.info("current nodes : {0}".format(RebalanceHelper.getOtpNodeIds(master)))
toBeEjectedNodes = RebalanceHelper.pick_nodes(master, howmany=self.failover_factor)
optNodesIds = [node.id for node in toBeEjectedNodes]
if self.fail_orchestrator:
status, content = ClusterOperationHelper.find_orchestrator(master)
self.assertTrue(status, msg="Unable to find orchestrator: {0}:{1}".\
format(status, content))
optNodesIds[0] = content
self.log.info("FAILOVER PHASE")
# Failover selected nodes
for node in optNodesIds:
self.log.info("failover node {0} and rebalance afterwards".format(node))
rest.fail_over(node)
self.assertTrue(rest.monitorRebalance(),
msg="failed after failover of {0}".format(node))
new_swap_servers = self.servers[num_initial_servers:num_initial_servers + self.failover_factor]
for server in new_swap_servers:
otpNode = rest.add_node(creds.rest_username, creds.rest_password, server.ip, server.port)
msg = "unable to add node {0} to the cluster"
self.assertTrue(otpNode, msg.format(server.ip))
if self.fail_orchestrator:
rest = RestConnection(new_swap_servers[0])
master = new_swap_servers[0]
self.log.info("DATA ACCESS PHASE")
self.loaders = SwapRebalanceBase.start_access_phase(self, master)
rest.rebalance(otpNodes=[node.id for node in rest.node_statuses()], \
ejectedNodes=optNodesIds)
self.assertTrue(rest.monitorRebalance(),
msg="rebalance operation failed after adding node {0}".format(new_swap_servers))
SwapRebalanceBase.verification_phase(self, master)
usage("ERROR: " + str(error))
docs_per_day = input.param("doc_per_day", 49)
years = input.param("years", 2)
bucket_name = input.param("bucket_name", "default")
bucket_port = input.param("bucket_port", None)
bucket_sasl_pass = input.param("bucket_sasl_pass", None)
flag = input.param("flags", 0)
to_directory = input.param("to_dir", '')
loader_type = input.param("loader_type", 'default')
if to_directory:
loader = DocLoaderDirectory(input.servers[0], to_directory, bucket_name)
generators_load = loader.generate_docs(docs_per_day, years)
loader.load(generators_load)
else:
cluster = Cluster()
try:
bucket = initialize_bucket(bucket_name, bucket_port, bucket_sasl_pass)
if loader_type == 'default':
loader = DocLoaderCouchbase(input.servers, cluster)
elif loader_type == 'join':
loader = JoinDocLoader(input.servers, cluster)
generators_load = loader.generate_docs(docs_per_day, years)
loader.load(generators_load, bucket, flag=flag)
finally:
cluster.shutdown()
if __name__ == "__main__":
main()
class SGConfigTests(GatewayConfigBaseTest):
def setUp(self):
super(SGConfigTests, self).setUp()
for server in self.servers:
if self.case_number == 1:
with open('pytests/sg/resources/gateway_config_walrus_template.json', 'r') as file:
filedata = file.read()
filedata = filedata.replace('LOCAL_IP', server.ip)
with open('pytests/sg/resources/gateway_config_walrus.json', 'w') as file:
file.write(filedata)
shell = RemoteMachineShellConnection(server)
shell.execute_command("rm -rf {0}/tmp/*".format(self.folder_prefix))
shell.copy_files_local_to_remote('pytests/sg/resources', '{0}/tmp'.format(self.folder_prefix))
# will install sg only the first time
self.install(shell)
pid = self.is_sync_gateway_process_running(shell)
self.assertNotEqual(pid, 0)
exist = shell.file_exists('{0}/tmp/'.format(self.folder_prefix), 'gateway.log')
self.assertTrue(exist)
shell.disconnect()
if self.case_number == 1:
shutil.copy2('pytests/sg/resources/gateway_config_backup.json', 'pytests/sg/resources/gateway_config.json')
BucketOperationHelper.delete_all_buckets_or_assert(self.servers, self)
self.cluster = Cluster()
self.cluster.create_default_bucket(self.master, 150)
task = self.cluster.async_create_sasl_bucket(self.master, 'test_%E-.5', 'password', 150, 1)
task.result()
task = self.cluster.async_create_standard_bucket(self.master, 'db', 11219, 150, 1)
task.result()
def tearDown(self):
super(SGConfigTests, self).tearDown()
if self.case_number == 1:
self.cluster.shutdown(force=True)
def configHelp(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
output, error = shell.execute_command_raw('/opt/couchbase-sync-gateway/bin/sync_gateway -help')
for index, str in enumerate(help_string):
if index != help_string[index]:
self.log.info('configHelp found unmatched help text. error({0}), help({1})'.format(error[index],
help_string[
index]))
self.assertEqual(error[index], help_string[index])
shell.disconnect()
def configCreateUser(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configGuestUser(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.get_user(shell))
self.assertFalse(self.delete_user(shell))
shell.disconnect()
def configCreateRole(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_role(shell, self.role_name, self.admin_channels))
if not self.expected_stdout:
self.assertTrue(self.get_role(shell))
self.delete_role(shell)
shell.disconnect()
def configUserRolesChannels(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.parse_input_create_roles(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configUserRolesNotExist(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configInspectDocChannel(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.parse_input_create_roles(shell))
if self.doc_channels:
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.get_all_docs(shell))
self.assertTrue(self.delete_doc(shell, revision))
shell.disconnect()
def configCBS(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
shutil.copy2('pytests/sg/resources/gateway_config_backup.json', 'pytests/sg/resources/gateway_config.json')
self.assertTrue(self.start_sync_gateway_template(shell, self.template))
if not self.expected_error:
time.sleep(5)
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.delete_doc(shell, revision))
self.assertTrue(self.check_message_in_gatewaylog(shell, self.expected_log))
shell.disconnect()
def configStartSgw(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
shutil.copy2('pytests/sg/resources/gateway_config_backup.json', 'pytests/sg/resources/gateway_config.json')
shell.copy_files_local_to_remote('pytests/sg/resources', '/tmp')
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.check_message_in_gatewaylog(shell, self.expected_log))
if not self.expected_error:
if self.admin_port:
self.assertTrue(self.get_users(shell))
if self.sync_port:
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.delete_doc(shell, revision))
shell.disconnect()
class SGConfigTests(GatewayConfigBaseTest):
def setUp(self):
super(SGConfigTests, self).setUp()
for server in self.servers:
if self.case_number == 1:
with open(
'pytests/sg/resources/gateway_config_walrus_template.json',
'r') as file:
filedata = file.read()
filedata = filedata.replace('LOCAL_IP', server.ip)
with open('pytests/sg/resources/gateway_config_walrus.json',
'w') as file:
file.write(filedata)
shell = RemoteMachineShellConnection(server)
shell.execute_command("rm -rf {0}/tmp/*".format(
self.folder_prefix))
shell.copy_files_local_to_remote(
'pytests/sg/resources',
'{0}/tmp'.format(self.folder_prefix))
# will install sg only the first time
self.install(shell)
pid = self.is_sync_gateway_process_running(shell)
self.assertNotEqual(pid, 0)
exist = shell.file_exists(
'{0}/tmp/'.format(self.folder_prefix), 'gateway.log')
self.assertTrue(exist)
shell.disconnect()
if self.case_number == 1:
shutil.copy2('pytests/sg/resources/gateway_config_backup.json',
'pytests/sg/resources/gateway_config.json')
BucketOperationHelper.delete_all_buckets_or_assert(
self.servers, self)
self.cluster = Cluster()
shared_params = self._create_bucket_params(server=self.master,
size=150)
self.cluster.create_default_bucket(shared_params)
task = self.cluster.async_create_sasl_bucket(
name='test_%E-.5',
password='******',
bucket_params=shared_params)
task.result()
task = self.cluster.async_create_standard_bucket(
name='db', port=11219, bucket_params=shared_params)
task.result()
def tearDown(self):
super(SGConfigTests, self).tearDown()
if self.case_number == 1:
self.cluster.shutdown(force=True)
def _create_bucket_params(self,
server,
replicas=1,
size=0,
port=11211,
password=None,
bucket_type='membase',
enable_replica_index=1,
eviction_policy='valueOnly',
bucket_priority=None,
flush_enabled=1,
lww=False):
"""Create a set of bucket_parameters to be sent to all of the bucket_creation methods
Parameters:
server - The server to create the bucket on. (TestInputServer)
bucket_name - The name of the bucket to be created. (String)
port - The port to create this bucket on. (String)
password - The password for this bucket. (String)
size - The size of the bucket to be created. (int)
enable_replica_index - can be 0 or 1, 1 enables indexing of replica bucket data (int)
replicas - The number of replicas for this bucket. (int)
eviction_policy - The eviction policy for the bucket, can be valueOnly or fullEviction. (String)
bucket_priority - The priority of the bucket:either none, low, or high. (String)
bucket_type - The type of bucket. (String)
flushEnabled - Enable or Disable the flush functionality of the bucket. (int)
lww = determine the conflict resolution type of the bucket. (Boolean)
Returns:
bucket_params - A dictionary containing the parameters needed to create a bucket."""
bucket_params = {}
bucket_params['server'] = server
bucket_params['replicas'] = replicas
bucket_params['size'] = size
bucket_params['port'] = port
bucket_params['password'] = password
bucket_params['bucket_type'] = bucket_type
bucket_params['enable_replica_index'] = enable_replica_index
bucket_params['eviction_policy'] = eviction_policy
bucket_params['bucket_priority'] = bucket_priority
bucket_params['flush_enabled'] = flush_enabled
bucket_params['lww'] = lww
return bucket_params
def configHelp(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
output, error = shell.execute_command_raw(
'/opt/couchbase-sync-gateway/bin/sync_gateway -help')
for index, str in enumerate(help_string):
if index != help_string[index]:
self.log.info(
'configHelp found unmatched help text. error({0}), help({1})'
.format(error[index], help_string[index]))
self.assertEqual(error[index], help_string[index])
shell.disconnect()
def configCreateUser(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configGuestUser(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.get_user(shell))
self.assertFalse(self.delete_user(shell))
shell.disconnect()
def configCreateRole(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(
self.create_role(shell, self.role_name, self.admin_channels))
if not self.expected_stdout:
self.assertTrue(self.get_role(shell))
self.delete_role(shell)
shell.disconnect()
def configUserRolesChannels(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.parse_input_create_roles(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configUserRolesNotExist(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configInspectDocChannel(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.parse_input_create_roles(shell))
if self.doc_channels:
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.get_all_docs(shell))
self.assertTrue(self.delete_doc(shell, revision))
shell.disconnect()
def configCBS(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
shutil.copy2('pytests/sg/resources/gateway_config_backup.json',
'pytests/sg/resources/gateway_config.json')
self.assertTrue(
self.start_sync_gateway_template(shell, self.template))
if not self.expected_error:
time.sleep(5)
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.delete_doc(shell, revision))
self.assertTrue(
self.check_message_in_gatewaylog(shell, self.expected_log))
shell.disconnect()
def configStartSgw(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
shutil.copy2('pytests/sg/resources/gateway_config_backup.json',
'pytests/sg/resources/gateway_config.json')
shell.copy_files_local_to_remote('pytests/sg/resources', '/tmp')
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(
self.check_message_in_gatewaylog(shell, self.expected_log))
if not self.expected_error:
if self.admin_port:
self.assertTrue(self.get_users(shell))
if self.sync_port:
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.delete_doc(shell, revision))
shell.disconnect()
class SGConfigTests(GatewayConfigBaseTest):
def setUp(self):
super(SGConfigTests, self).setUp()
for server in self.servers:
if self.case_number == 1:
with open('pytests/sg/resources/gateway_config_walrus_template.json', 'r') as file:
filedata = file.read()
filedata = filedata.replace('LOCAL_IP', server.ip)
with open('pytests/sg/resources/gateway_config_walrus.json', 'w') as file:
file.write(filedata)
shell = RemoteMachineShellConnection(server)
shell.execute_command("rm -rf {0}/tmp/*".format(self.folder_prefix))
shell.copy_files_local_to_remote('pytests/sg/resources', '{0}/tmp'.format(self.folder_prefix))
# will install sg only the first time
self.install(shell)
pid = self.is_sync_gateway_process_running(shell)
self.assertNotEqual(pid, 0)
exist = shell.file_exists('{0}/tmp/'.format(self.folder_prefix), 'gateway.log')
self.assertTrue(exist)
shell.disconnect()
if self.case_number == 1:
shutil.copy2('pytests/sg/resources/gateway_config_backup.json', 'pytests/sg/resources/gateway_config.json')
BucketOperationHelper.delete_all_buckets_or_assert(self.servers, self)
self.cluster = Cluster()
shared_params=self._create_bucket_params(server=self.master, size=150)
self.cluster.create_default_bucket(shared_params)
task = self.cluster.async_create_sasl_bucket(name='test_%E-.5',password='******',
bucket_params=shared_params)
task.result()
task = self.cluster.async_create_standard_bucket(name='db',port=11219,bucket_params=shared_params)
task.result()
def tearDown(self):
super(SGConfigTests, self).tearDown()
if self.case_number == 1:
self.cluster.shutdown(force=True)
def _create_bucket_params(self, server, replicas=1, size=0, port=11211, password=None,
bucket_type='membase', enable_replica_index=1, eviction_policy='valueOnly',
bucket_priority=None, flush_enabled=1, lww=False):
"""Create a set of bucket_parameters to be sent to all of the bucket_creation methods
Parameters:
server - The server to create the bucket on. (TestInputServer)
bucket_name - The name of the bucket to be created. (String)
port - The port to create this bucket on. (String)
password - The password for this bucket. (String)
size - The size of the bucket to be created. (int)
enable_replica_index - can be 0 or 1, 1 enables indexing of replica bucket data (int)
replicas - The number of replicas for this bucket. (int)
eviction_policy - The eviction policy for the bucket, can be valueOnly or fullEviction. (String)
bucket_priority - The priority of the bucket:either none, low, or high. (String)
bucket_type - The type of bucket. (String)
flushEnabled - Enable or Disable the flush functionality of the bucket. (int)
lww = determine the conflict resolution type of the bucket. (Boolean)
Returns:
bucket_params - A dictionary containing the parameters needed to create a bucket."""
bucket_params = {}
bucket_params['server'] = server
bucket_params['replicas'] = replicas
bucket_params['size'] = size
bucket_params['port'] = port
bucket_params['password'] = password
bucket_params['bucket_type'] = bucket_type
bucket_params['enable_replica_index'] = enable_replica_index
bucket_params['eviction_policy'] = eviction_policy
bucket_params['bucket_priority'] = bucket_priority
bucket_params['flush_enabled'] = flush_enabled
bucket_params['lww'] = lww
return bucket_params
def configHelp(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
output, error = shell.execute_command_raw('/opt/couchbase-sync-gateway/bin/sync_gateway -help')
for index, str in enumerate(help_string):
if index != help_string[index]:
self.log.info('configHelp found unmatched help text. error({0}), help({1})'.format(error[index],
help_string[
index]))
self.assertEqual(error[index], help_string[index])
shell.disconnect()
def configCreateUser(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configGuestUser(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.get_user(shell))
self.assertFalse(self.delete_user(shell))
shell.disconnect()
def configCreateRole(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_role(shell, self.role_name, self.admin_channels))
if not self.expected_stdout:
self.assertTrue(self.get_role(shell))
self.delete_role(shell)
shell.disconnect()
def configUserRolesChannels(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.parse_input_create_roles(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configUserRolesNotExist(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.create_user(shell))
if not self.expected_stdout:
self.assertTrue(self.get_user(shell))
self.delete_user(shell)
shell.disconnect()
def configInspectDocChannel(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
self.config = 'gateway_config_walrus.json'
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.parse_input_create_roles(shell))
if self.doc_channels:
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.get_all_docs(shell))
self.assertTrue(self.delete_doc(shell, revision))
shell.disconnect()
def configCBS(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
shutil.copy2('pytests/sg/resources/gateway_config_backup.json', 'pytests/sg/resources/gateway_config.json')
self.assertTrue(self.start_sync_gateway_template(shell, self.template))
if not self.expected_error:
time.sleep(5)
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.delete_doc(shell, revision))
self.assertTrue(self.check_message_in_gatewaylog(shell, self.expected_log))
shell.disconnect()
def configStartSgw(self):
for server in self.servers:
shell = RemoteMachineShellConnection(server)
shutil.copy2('pytests/sg/resources/gateway_config_backup.json', 'pytests/sg/resources/gateway_config.json')
shell.copy_files_local_to_remote('pytests/sg/resources', '/tmp')
self.assertTrue(self.start_sync_gateway(shell))
self.assertTrue(self.check_message_in_gatewaylog(shell, self.expected_log))
if not self.expected_error:
if self.admin_port:
self.assertTrue(self.get_users(shell))
if self.sync_port:
success, revision = self.create_doc(shell)
self.assertTrue(success)
self.assertTrue(self.delete_doc(shell, revision))
shell.disconnect()
