def testClusterInit(self):
cluster_init_username = self.input.param("cluster_init_username", "Administrator")
cluster_init_password = self.input.param("cluster_init_password", "password")
cluster_init_port = self.input.param("cluster_init_port", 8091)
cluster_init_ramsize = self.input.param("cluster_init_ramsize", 300)
command_init = self.input.param("command_init", "cluster-init")
param_prefix = self.input.param("param_prefix", "--cluster-init")
server = self.servers[-1]
remote_client = RemoteMachineShellConnection(server)
rest = RestConnection(server)
rest.force_eject_node()
self.sleep(5)
try:
cli_command = command_init
options = "--cluster-init-username={0} {1}-password={2} {3}-port={4} {5}-ramsize={6}".\
format(cluster_init_username, param_prefix, cluster_init_password, param_prefix, cluster_init_port, param_prefix, cluster_init_ramsize)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user="******", password="******")
self.assertEqual(output[0], "SUCCESS: init localhost")
options = "{0}-username={1} {2}-password={3} {4}-port={5}".\
format(param_prefix, cluster_init_username + "1", param_prefix, cluster_init_password + "1", param_prefix, str(cluster_init_port)[:-1] + "9")
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=cluster_init_username, password=cluster_init_password)
# MB-8202 cluster-init/edit doesn't provide status
self.assertTrue(output == [])
server.rest_username = cluster_init_username + "1"
server.rest_password = cluster_init_password + "1"
server.port = str(cluster_init_port)[:-1] + "9"
cli_command = "server-list"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", cluster_port=str(cluster_init_port)[:-1] + "9", user=cluster_init_username + "1", password=cluster_init_password + "1")
self.assertTrue("{0} healthy active".format(str(cluster_init_port)[:-1] + "9") in output[0])
server_info = self._get_cluster_info(remote_client, cluster_port=server.port, user=server.rest_username, password=server.rest_password)
result = server_info["otpNode"] + " " + server_info["hostname"] + " " + server_info["status"] + " " + server_info["clusterMembership"]
self.assertTrue("{0} healthy active".format(str(cluster_init_port)[:-1] + "9") in result)
cli_command = command_init
options = "{0}-username={1} {2}-password={3} {4}-port={5}".\
format(param_prefix, cluster_init_username, param_prefix, cluster_init_password, param_prefix, cluster_init_port)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", cluster_port=str(cluster_init_port)[:-1] + "9", user=(cluster_init_username + "1"), password=cluster_init_password + "1")
# MB-8202 cluster-init/edit doesn't provide status
self.assertTrue(output == [])
server.rest_username = cluster_init_username
server.rest_password = cluster_init_password
server.port = cluster_init_port
remote_client = RemoteMachineShellConnection(server)
cli_command = "server-list"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user=cluster_init_username, password=cluster_init_password)
self.assertTrue("{0} healthy active".format(str(cluster_init_port)) in output[0])
server_info = self._get_cluster_info(remote_client, cluster_port=server.port, user=server.rest_username, password=server.rest_password)
result = server_info["otpNode"] + " " + server_info["hostname"] + " " + server_info["status"] + " " + server_info["clusterMembership"]
self.assertTrue("{0} healthy active".format(str(cluster_init_port)) in result)
remote_client.disconnect()
finally:
rest = RestConnection(server)
rest.force_eject_node()
self.sleep(5)
rest.init_cluster()
def testXDCRSetup(self):
'''xdcr-setup OPTIONS:
--create create a new xdcr configuration
--edit modify existed xdcr configuration
--delete delete existed xdcr configuration
--xdcr-cluster-name=CLUSTERNAME cluster name
--xdcr-hostname=HOSTNAME remote host name to connect to
--xdcr-username=USERNAME remote cluster admin username
--xdcr-password=PASSWORD remtoe cluster admin password'''
remote_client = RemoteMachineShellConnection(self.master)
try:
#rest = RestConnection(self.master)
#xdcr_cluster_name & xdcr_hostname=the number of server in ini file to add to master as replication
xdcr_cluster_name = self.input.param("xdcr-cluster-name", None)
xdcr_hostname = self.input.param("xdcr-hostname", None)
xdcr_username = self.input.param("xdcr-username", None)
xdcr_password = self.input.param("xdcr-password", None)
output_error = ""
ip = None
if xdcr_cluster_name is not None:
ip = self.servers[xdcr_cluster_name].ip
# if ip is not None:
# output_error = 'SUCCESS: init {0}'.format(ip)
output_error = self.input.param("output_error", 'SUCCESS: init HOSTIP').replace(";", ",")
if ip is not None:
output_error = output_error.replace("HOSTIP", ip)
cli_command = "xdcr-setup"
options = "--create"
options += (" --xdcr-cluster-name={0}".format(ip), "")[xdcr_cluster_name is None]
if xdcr_hostname is not None:
options += " --xdcr-hostname={0}".format(self.servers[xdcr_hostname].ip)
options += (" --xdcr-username={0}".format(xdcr_username), "")[xdcr_username is None]
options += (" --xdcr-password={0}".format(xdcr_password), "")[xdcr_password is None]
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user="******", password="******")
self.assertEqual([s.rstrip() for s in output], [s for s in output_error.split(',')])
if "SUCCESS: init" in output_error:
#MB-8570 add verification when will be fixed
options = options.replace("--create ", "--edit ")
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user="******", password="******")
if "SUCCESS: init" in output_error and xdcr_cluster_name is None:
#MB-8573 couchbase-cli: quotes are not supported when try to remove remote xdcr cluster that has white spaces in the name
options = "--delete --xdcr-cluster-name={0}".format("remote%20cluster")
else:
options = "--delete --xdcr-cluster-name={0}".format(self.servers[xdcr_cluster_name].ip)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user="******", password="******")
if "SUCCESS: init" in output_error:
self.assertEqual(output, ["SUCCESS: delete {0}".format(self.servers[xdcr_cluster_name].ip)])
else:
self.assertEqual(output, ["ERROR: unable to delete xdcr remote site localhost (404) Object Not Found", "unknown remote cluster"])
finally:
remote_client.disconnect()
self._teardown_xdcr()
def testBucketModification(self):
cli_command = "bucket-edit"
bucket_type = self.input.param("bucket_type", "couchbase")
bucket_password = self.input.param("bucket_password", None)
bucket_port = self.input.param("bucket_port", 11211)
enable_flush = self.input.param("enable_flush", None)
bucket_port_new = self.input.param("bucket_port_new", None)
bucket_password_new = self.input.param("bucket_password_new", None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
enable_flush_new = self.input.param("enable_flush_new", None)
enable_index_replica_new = self.input.param("enable_index_replica_new", None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
bucket = self.input.param("bucket", "default")
bucket_ramsize = self.input.param("bucket_ramsize", 200)
bucket_replica = self.input.param("bucket_replica", 1)
enable_flush = self.input.param("enable_flush", None)
enable_index_replica = self.input.param("enable_index_replica", None)
wait = self.input.param("wait", False)
remote_client = RemoteMachineShellConnection(self.master)
self._create_bucket(remote_client, bucket, bucket_type=bucket_type, bucket_port=bucket_port, bucket_password=bucket_password, \
bucket_ramsize=bucket_ramsize, bucket_replica=bucket_replica, wait=wait, enable_flush=enable_flush, enable_index_replica=enable_index_replica)
cli_command = "bucket-edit"
options = "--bucket={0}".format(bucket)
options += (" --enable-flush={0}".format(enable_flush_new), "")[enable_flush_new is None]
options += (" --enable-index-replica={0}".format(enable_index_replica_new), "")[enable_index_replica_new is None]
options += (" --bucket-port={0}".format(bucket_port_new), "")[bucket_port_new is None]
options += (" --bucket-password={0}".format(bucket_password_new), "")[bucket_password_new is None]
options += (" --bucket-ramsize={0}".format(bucket_ramsize_new), "")[bucket_ramsize_new is None]
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
expectedResults = {'bucket_name':'BBB', 'ram_quota':465567744, 'num_replicas':1,
'replica_index':True, 'eviction_policy':'value_only', 'type':'membase', \
'auth_type':'none', "autocompaction":'false', "purge_interval":"undefined", \
"flush_enabled":True, "num_threads":3, "source":self.source, \
"user":self.ldapUser, "ip":'127.0.0.1', "port":57457, 'sessionid':'',
"moxi_port":1224 }
self.checkConfig(8202, self.master, expectedResults)
cli_command = "bucket-flush --force"
options = "--bucket={0}".format(bucket)
if enable_flush_new is not None:
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
expectedResults = {"bucket_name":"BBB", "source":self.source, "user":self.ldapUser, "ip":"127.0.0.1", 'port':57457}
self.checkConfig(8204, self.master, expectedResults)
cli_command = "bucket-delete"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
expectedResults = {"bucket_name":"BBB", "source":self.source, "user":self.ldapUser, "ip":"127.0.0.1", "port":57457}
self.checkConfig(8203, self.master, expectedResults)
remote_client.disconnect()
def testInfoCommands(self):
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "server-list"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
server_info = self._get_cluster_info(remote_client)
result = server_info["otpNode"] + " " + server_info["hostname"] + " " + server_info["status"] + " " + server_info["clusterMembership"]
self.assertEqual(result, "ns_1@{0} {0}:8091 healthy active".format("127.0.0.1"))
cli_command = "bucket-list"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
self.assertEqual([], output)
remote_client.disconnect()
def testStartStopRebalance(self):
nodes_add = self.input.param("nodes_add", 1)
nodes_rem = self.input.param("nodes_rem", 1)
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "rebalance-status"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
self.assertEqual(output, ["(u'none', None)"])
cli_command = "server-add"
for num in xrange(nodes_add):
options = "--server-add={0}:8091 --server-add-username=Administrator --server-add-password=password".format(self.servers[num + 1].ip)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user="******", password="******")
self.assertEqual(output, ["SUCCESS: server-add {0}:8091".format(self.servers[num + 1].ip)])
cli_command = "rebalance-status"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
self.assertEqual(output, ["(u'none', None)"])
self._create_bucket(remote_client)
cli_command = "rebalance"
t = Thread(target=remote_client.execute_couchbase_cli, name="rebalance_after_add",
args=(cli_command, "localhost", '', None, "Administrator", "password"))
t.start()
self.sleep(5)
cli_command = "rebalance-status"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
self.assertEqual(output, ["(u'running', None)"])
t.join()
cli_command = "rebalance"
for num in xrange(nodes_rem):
options = "--server-remove={0}:8091".format(self.servers[nodes_add - num].ip)
t = Thread(target=remote_client.execute_couchbase_cli, name="rebalance_after_add",
args=(cli_command, "localhost", options, None, "Administrator", "password"))
t.start()
self.sleep(5)
cli_command = "rebalance-status"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
self.assertEqual(output, ["(u'running', None)"])
cli_command = "rebalance-stop"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
t.join()
cli_command = "rebalance"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
self.assertEqual(output[1], "SUCCESS: rebalanced cluster")
cli_command = "rebalance-status"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, cluster_host="localhost", user="******", password="******")
self.assertEqual(output, ["(u'none', None)"])
remote_client.disconnect()
def testBucketModification(self):
if self.role in ['replication_admin','views_admin[*]']:
result = "Forbidden"
elif self.role in ['admin','cluster_admin','bucket_admin[*]']:
result = 'SUCCESS'
cli_command = "bucket-edit"
bucket_type = self.input.param("bucket_type", "couchbase")
enable_flush = self.input.param("enable_flush", None)
bucket_port_new = self.input.param("bucket_port_new", None)
bucket_password_new = self.input.param("bucket_password_new", None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
enable_flush_new = self.input.param("enable_flush_new", None)
enable_index_replica_new = self.input.param("enable_index_replica_new", None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
bucket = self.input.param("bucket", "default")
bucket_ramsize = self.input.param("bucket_ramsize", 200)
bucket_replica = self.input.param("bucket_replica", 1)
enable_flush = self.input.param("enable_flush", None)
enable_index_replica = self.input.param("enable_index_replica", None)
wait = self.input.param("wait", False)
remote_client = RemoteMachineShellConnection(self.master)
self._create_bucket(remote_client, bucket, bucket_type=bucket_type, bucket_ramsize=bucket_ramsize,
bucket_replica=bucket_replica, wait=wait, enable_flush=enable_flush,
enable_index_replica=enable_index_replica,user="******",password='******')
cli_command = "bucket-edit"
options = "--bucket={0}".format(bucket)
options += (" --enable-flush={0}".format(enable_flush_new), "")[enable_flush_new is None]
options += (" --enable-index-replica={0}".format(enable_index_replica_new), "")[enable_index_replica_new is None]
#options += (" --bucket-port={0}".format(bucket_port_new), "")[bucket_port_new is None]
options += (" --bucket-ramsize={0}".format(bucket_ramsize_new), "")[bucket_ramsize_new is None]
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
self._validate_roles(output,result)
cli_command = "bucket-flush --force"
options = "--bucket={0}".format(bucket)
if enable_flush_new is not None:
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
self._validate_roles(output,result)
cli_command = "bucket-delete"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
expectedResults = {"bucket_name":"BBB", "source":self.source, "user":self.ldapUser, "ip":"127.0.0.1", "port":57457}
self._validate_roles(output,result)
remote_client.disconnect()
def testSettingCompacttion(self):
'''setting-compacttion OPTIONS:
--compaction-db-percentage=PERCENTAGE at which point database compaction is triggered
--compaction-db-size=SIZE[MB] at which point database compaction is triggered
--compaction-view-percentage=PERCENTAGE at which point view compaction is triggered
--compaction-view-size=SIZE[MB] at which point view compaction is triggered
--compaction-period-from=HH:MM allow compaction time period from
--compaction-period-to=HH:MM allow compaction time period to
--enable-compaction-abort=[0|1] allow compaction abort when time expires
--enable-compaction-parallel=[0|1] allow parallel compaction for database and view'''
compaction_db_percentage = self.input.param("compaction-db-percentage", None)
compaction_db_size = self.input.param("compaction-db-size", None)
compaction_view_percentage = self.input.param("compaction-view-percentage", None)
compaction_view_size = self.input.param("compaction-view-size", None)
compaction_period_from = self.input.param("compaction-period-from", None)
compaction_period_to = self.input.param("compaction-period-to", None)
enable_compaction_abort = self.input.param("enable-compaction-abort", None)
enable_compaction_parallel = self.input.param("enable-compaction-parallel", None)
bucket = self.input.param("bucket", "default")
output = self.input.param("output", '')
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "setting-compaction"
options = (" --compaction-db-percentage={0}".format(compaction_db_percentage), "")[compaction_db_percentage is None]
options += (" --compaction-db-size={0}".format(compaction_db_size), "")[compaction_db_size is None]
options += (" --compaction-view-percentage={0}".format(compaction_view_percentage), "")[compaction_view_percentage is None]
options += (" --compaction-view-size={0}".format(compaction_view_size), "")[compaction_view_size is None]
options += (" --compaction-period-from={0}".format(compaction_period_from), "")[compaction_period_from is None]
options += (" --compaction-period-to={0}".format(compaction_period_to), "")[compaction_period_to is None]
options += (" --enable-compaction-abort={0}".format(enable_compaction_abort), "")[enable_compaction_abort is None]
options += (" --enable-compaction-parallel={0}".format(enable_compaction_parallel), "")[enable_compaction_parallel is None]
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user="******", password="******")
expectedResults = {"parallel_db_and_view_compaction":False, "database_fragmentation_threshold:size":10485760, "database_fragmentation_threshold:view_fragmentation_threshold":{}, "real_userid:source":"ns_server", "real_userid:user":"******", "remote:ip":"127.0.0.1", "remote:port":60019}
self.checkConfig(8225, self.master, expectedResults)
remote_client.disconnect()
def testSSLManage(self):
"""ssl-manage OPTIONS:
--retrieve-cert=CERTIFICATE retrieve cluster certificate AND save to a pem file
--regenerate-cert=CERTIFICATE regenerate cluster certificate AND save to a pem file"""
xdcr_cert = self.input.param("xdcr-certificate", None)
xdcr_cert = "/tmp/" + xdcr_cert
cli_command = "ssl-manage"
remote_client = RemoteMachineShellConnection(self.master)
options = "--regenerate-cert={0}".format(xdcr_cert)
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass,
)
self.assertFalse(error, "Error thrown during CLI execution %s" % error)
self.shell.execute_command("rm {0}".format(xdcr_cert))
expectedResults = {
"real_userid:source": self.source,
"real_userid:user": self.ldapUser,
"remote:ip": "127.0.0.1",
"port": 60035,
}
self.checkConfig(8226, self.master, expectedResults)
def test_compaction_with_cluster_ramquota_change(self):
self.make_ddocs(self.ddocs_num, self.view_per_ddoc)
self.create_ddocs()
gen_load = BlobGenerator("test_view_compaction", "test_view_compaction-", self.value_size, end=self.num_items)
self._load_all_buckets(self.master, gen_load, "create", 0)
for ddoc in self.ddocs:
fragmentation_monitor = self.cluster.async_monitor_view_fragmentation(
self.master, ddoc.name, self.fragmentation_value
)
while fragmentation_monitor.state != "FINISHED":
self._load_all_buckets(self.master, gen_load, "update", 0)
for view in ddoc.views:
self.cluster.query_view(self.master, ddoc.name, view.name, {})
fragmentation_monitor.result()
compaction_tasks = []
for ddoc in self.ddocs:
compaction_tasks.append(self.cluster.async_compact_view(self.master, ddoc.name))
remote = RemoteMachineShellConnection(self.master)
cli_command = "cluster-init"
options = "--cluster-init-ramsize=%s" % (self.quota + 10)
output, error = remote.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.master.rest_username,
password=self.master.rest_password,
)
self.assertTrue("\n".join(output).find("SUCCESS") != -1, "ram wasn't changed")
self.log.info("Quota was changed")
for task in compaction_tasks:
task.result()
def execute_admin_role_manage(self, options):
cli_command = 'user-manage'
options = options
remote_client = RemoteMachineShellConnection(self.master)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
return output, error
def _retrieve_cluster_cert_extended(self,server):
cli_command = 'ssl-manage'
options = "--cluster-cert-info --extended"
remote_client = RemoteMachineShellConnection(server)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
return output, error
def test_full_eviction_changed_to_value_eviction(self):
KEY_NAME = 'key1'
gen_create = BlobGenerator('eviction', 'eviction-', self.value_size, end=self.num_items)
gen_create2 = BlobGenerator('eviction2', 'eviction2-', self.value_size, end=self.num_items)
self._load_all_buckets(self.master, gen_create, "create", 0)
self._wait_for_stats_all_buckets(self.servers[:self.nodes_init])
self._verify_stats_all_buckets(self.servers[:self.nodes_init])
remote = RemoteMachineShellConnection(self.master)
for bucket in self.buckets:
output, _ = remote.execute_couchbase_cli(cli_command='bucket-edit',
cluster_host="localhost",
user=self.master.rest_username,
password=self.master.rest_password,
options='--bucket=%s --bucket-eviction-policy=valueOnly' % bucket.name)
self.assertTrue(' '.join(output).find('SUCCESS') != -1, 'Eviction policy wasn\'t changed')
ClusterOperationHelper.wait_for_ns_servers_or_assert(
self.servers[:self.nodes_init], self,
wait_time=self.wait_timeout, wait_if_warmup=True)
self.sleep(10, 'Wait some time before next load')
#self._load_all_buckets(self.master, gen_create2, "create", 0)
#import pdb;pdb.set_trace()
rest = RestConnection(self.master)
client = VBucketAwareMemcached(rest, 'default')
mcd = client.memcached(KEY_NAME)
try:
rc = mcd.set(KEY_NAME, 0,0, json.dumps({'value':'value2'}))
self.fail('Bucket is incorrectly functional')
except MemcachedError, e:
pass # this is the exception we are hoping for
def testClusterInitNegative(self):
cluster_init_username = self.input.param("cluster_init_username", None)
cluster_init_password = self.input.param("cluster_init_password", None)
cluster_init_port = self.input.param("cluster_init_port", None)
cluster_init_ramsize = self.input.param("cluster_init_ramsize", None)
command_init = self.input.param("command_init", "cluster-init")
server = self.servers[-1]
remote_client = RemoteMachineShellConnection(server)
rest = RestConnection(server)
rest.force_eject_node()
self.sleep(5)
try:
cli_command = command_init
options = ""
if cluster_init_username is not None:
options += "--cluster-init-username={0} ".format(cluster_init_username)
if cluster_init_password is not None:
options += "--cluster-init-password={0} ".format(cluster_init_password)
if cluster_init_port is not None:
options += "--cluster-init-port={0} ".format(cluster_init_port)
if cluster_init_ramsize is None:
options += "--cluster-init-ramsize={0} ".format(cluster_init_ramsize)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=None, password=None)
self.assertEqual(output[0], 'ERROR: unable to init localhost (400) Bad Request')
self.assertTrue(output[1] == "[u'Username and password are required.']" or output[1] == "[u'The password must be at least six characters.']")
remote_client.disconnect()
finally:
rest = RestConnection(server)
rest.force_eject_node()
self.sleep(5)
rest.init_cluster()
def _download_node_cert(self,server):
cli_command = 'ssl-manage'
options = "--node-cert-info"
remote_client = RemoteMachineShellConnection(server)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host=server.ip + ":8091", user=self.ldapUser, password=self.ldapPass)
return output, error
def test_enableDisableLdap(self):
rest = RestConnection(self.master)
remote_client = RemoteMachineShellConnection(self.master)
origState = rest.ldapRestOperationGetResponse()['enabled']
cli_command = 'setting-ldap'
options = "--ldap-enable=0"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
tempStatus = rest.ldapRestOperationGetResponse()['enabled']
self.assertFalse(tempStatus, "Issues with setting LDAP enable/disable")
cli_command = 'setting-ldap'
options = "--ldap-enable=1"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user="******", password="******")
tempStatus = rest.ldapRestOperationGetResponse()['enabled']
self.assertTrue(tempStatus, "Issues with setting LDAP enable/disable")
def execute_password_policy(self, options):
cli_command = 'setting-password-policy'
options = options
remote_client = RemoteMachineShellConnection(self.master)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
return output, error
def disableLdap(self):
cli_command = 'setting-ldap'
options = "--ldap-enable=0"
remote_client = RemoteMachineShellConnection(self.master)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user="******", password="******")
print output
print error
def test_cli_travel_sample_bucket(self):
sample = "travel-sample"
num_expected = self.input.param('num_items', 31569)
""" couchbase-cli does not have option to reset the node yet
use rest to reset node to set services correctly: index,kv,n1ql """
self.rest.force_eject_node()
shell = RemoteMachineShellConnection(self.master)
options = '--cluster-init-username="******" \
--cluster-init-password="******" \
--cluster-init-port=8091 \
--cluster-ramsize=300 \
--cluster-index-ramsize=300 \
--services=data,index,query'
o, e = shell.execute_couchbase_cli(cli_command="cluster-init", options=options)
self.assertEqual(o[0], "SUCCESS: init/edit localhost")
shell = RemoteMachineShellConnection(self.master)
shell.execute_command("{0}cbdocloader -u Administrator -p password \
-n {1} -b travel-sample -s 100 {2}travel-sample.zip" \
.format(self.bin_path, self.master.ip, self.sample_path))
shell.disconnect()
buckets = RestConnection(self.master).get_buckets()
for bucket in buckets:
if bucket.name != "travel-sample":
self.fail("travel-sample bucket did not create")
""" check for load data into travel-sample bucket """
end_time = time.time() + 120
while time.time() < end_time:
self.sleep(10)
num_actual = self.get_item_count(self.master,"travel-sample")
if num_actual == num_expected:
break
self.assertTrue(num_actual == num_expected,
"Items number expected %s, actual %s" % (
num_expected, num_actual))
""" check all indexes are completed """
index_name = []
result = self.rest.index_tool_stats()
end_time_i = time.time() + 60
for map in result:
if result["indexes"]:
for x in result["indexes"]:
if x["bucket"] == "travel-sample":
if x["progress"] == 100 and x["index"] not in index_name:
index_name.append(x["index"])
else:
self.fail("indexing failed to build")
if len(index_name) < 8:
self.log.info("index list {0}".format(index_name))
self.fail("some indexing may not complete")
elif len(index_name) == 8:
self.log.info("travel-sample bucket is created and complete indexing")
self.log.info("index list in travel-sample bucket: {0}"
.format(index_name))
def test_enableDisableAudit(self):
auditIns = audit(host=self.master)
remote_client = RemoteMachineShellConnection(self.master)
tempEnable = auditIns.getAuditStatus()
try:
cli_command = 'setting-audit'
options = "--audit-enable=0"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
tempEnable = auditIns.getAuditStatus()
self.assertFalse(tempEnable, "Issues enable/disable via CLI")
options = "--audit-enable=1"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
tempEnable = auditIns.getAuditStatus()
self.assertTrue(tempEnable, "Issues enable/disable via CLI")
finally:
auditIns.setAuditEnable(self.returnBoolVal(tempEnable))
def testSettingNotification(self):
setting_enable_notification = self.input.param("enable-notification", 1)
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "setting-notification"
options = (" --enable-notification={0}".format(setting_enable_notification))
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
remote_client.disconnect()
def _upload_cert_cli(self):
path_to_root_cert = self.install_path + x509main.CHAINFILEPATH + "/root.crt"
self._copy_root_crt()
cli_command = 'ssl-manage'
options = "--upload-cluster-ca={0}".format(path_to_root_cert)
remote_client = RemoteMachineShellConnection(self.master)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
return output, error
def test_hostname_mgmt_server_list(self):
hostnames = self.rename_nodes(self.servers[:self.nodes_init])
self._set_hostames_to_servers_objs(hostnames)
self.verify_referenced_by_names(self.servers[:self.nodes_init], hostnames)
remote = RemoteMachineShellConnection(self.master)
cli_command = "server-list"
output, error = remote.execute_couchbase_cli(cli_command=cli_command,
cluster_host=self.master.hostname,
user="******", password="******")
self.assertEqual(''.join(output), "ns_1@{0} {0}:8091 healthy active".format(self.master.hostname))
def test_hostname_mgmt_buckets_list(self):
hostnames = self.rename_nodes(self.servers[:self.nodes_init])
self._set_hostames_to_servers_objs(hostnames)
self.verify_referenced_by_names(self.servers[:self.nodes_init], hostnames)
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "bucket-list"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command,
cluster_host=self.master.hostname,
user="******", password="******")
self.assertTrue(''.join(output).find(''.join([b.name for b in self.buckets])) != -1)
remote_client.disconnect()
def _reset_original(self):
self.log.info ("Reverting to original state - regenerating certificate and removing inbox folder")
tmp_path = "/tmp/abcd.pem"
for servers in self.servers:
cli_command = "ssl-manage"
remote_client = RemoteMachineShellConnection(servers)
options = "--regenerate-cert={0}".format(tmp_path)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options,
cluster_host=servers.ip, user="******",
password="******")
x509main(servers)._delete_inbox_folder()
def test_setLDAPParam(self):
cli_command = "setting-ldap"
options = " --ldap-enable={0}".format(self.enableStatus)
options += " --ldap-roadmins={0}".format(",".join(self.roAdmin))
options += " --ldap-admins={0}".format(",".join(self.admin))
options += " --ldap-default={0}".format(self.default)
remote_client = RemoteMachineShellConnection(self.master)
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
tempFlag = self.validateSettings(self.enableStatus, self.admin, self.roAdmin, self.default)
self.assertTrue(tempFlag)
def testSettingCompacttion(self):
if self.role in ["replication_admin", "views_admin[*]", "bucket_admin[*]"]:
result = "Forbidden"
elif self.role in ["admin", "cluster_admin"]:
result = "SUCCESS"
cli_command = "bucket-edit"
"""setting-compacttion OPTIONS:
--compaction-db-percentage=PERCENTAGE at which point database compaction is triggered
--compaction-db-size=SIZE[MB] at which point database compaction is triggered
--compaction-view-percentage=PERCENTAGE at which point view compaction is triggered
--compaction-view-size=SIZE[MB] at which point view compaction is triggered
--compaction-period-from=HH:MM allow compaction time period from
--compaction-period-to=HH:MM allow compaction time period to
--enable-compaction-abort=[0|1] allow compaction abort when time expires
--enable-compaction-parallel=[0|1] allow parallel compaction for database and view"""
compaction_db_percentage = self.input.param("compaction-db-percentage", None)
compaction_db_size = self.input.param("compaction-db-size", None)
compaction_view_percentage = self.input.param("compaction-view-percentage", None)
compaction_view_size = self.input.param("compaction-view-size", None)
compaction_period_from = self.input.param("compaction-period-from", None)
compaction_period_to = self.input.param("compaction-period-to", None)
enable_compaction_abort = self.input.param("enable-compaction-abort", None)
enable_compaction_parallel = self.input.param("enable-compaction-parallel", None)
bucket = self.input.param("bucket", "default")
output = self.input.param("output", "")
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "setting-compaction"
options = (" --compaction-db-percentage={0}".format(compaction_db_percentage), "")[
compaction_db_percentage is None
]
options += (" --compaction-db-size={0}".format(compaction_db_size), "")[compaction_db_size is None]
options += (" --compaction-view-percentage={0}".format(compaction_view_percentage), "")[
compaction_view_percentage is None
]
options += (" --compaction-view-size={0}".format(compaction_view_size), "")[compaction_view_size is None]
options += (" --compaction-period-from={0}".format(compaction_period_from), "")[compaction_period_from is None]
options += (" --compaction-period-to={0}".format(compaction_period_to), "")[compaction_period_to is None]
options += (" --enable-compaction-abort={0}".format(enable_compaction_abort), "")[
enable_compaction_abort is None
]
options += (" --enable-compaction-parallel={0}".format(enable_compaction_parallel), "")[
enable_compaction_parallel is None
]
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass,
)
self._validate_roles(output, result)
remote_client.disconnect()
def test_rebalance_in_with_cluster_ramquota_change(self):
rebalance = self.cluster.async_rebalance(self.servers[:self.nodes_init],
self.servers[self.nodes_init:self.nodes_init + self.nodes_in],
[])
self.sleep(10, "Wait for rebalance have some progress")
remote = RemoteMachineShellConnection(self.master)
cli_command = "setting-cluster"
options = "--cluster-ramsize=%s" % (3000)
output, error = remote.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost",
user=self.master.rest_username, password=self.master.rest_password)
self.assertTrue('\n'.join(output).find('SUCCESS') != -1, 'RAM wasn\'t chnged')
rebalance.result()
def test_hostname_mgmt_create_bucket(self):
hostnames = self.rename_nodes(self.servers[:self.nodes_init])
self._set_hostames_to_servers_objs(hostnames)
self.verify_referenced_by_names(self.servers[:self.nodes_init], hostnames)
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "bucket-create"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command,
cluster_host=self.master.hostname,
user="******", password="******",
options=' --bucket=test --bucket-type=couchbase --bucket-port=11210 --bucket-ramsize=100 --bucket-replica=1')
self.assertTrue(''.join(output).find(''.join([b.name for b in self.buckets])) != -1)
remote_client.disconnect()
def test_hostname_mgmt_remove_bucket(self):
hostnames = self.rename_nodes(self.servers[:self.nodes_init])
self._set_hostames_to_servers_objs(hostnames)
self.verify_referenced_by_names(self.servers[:self.nodes_init], hostnames)
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "bucket-delete"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command,
cluster_host=self.master.hostname,
user="******", password="******",
options='--bucket=default')
self.assertEqual(['SUCCESS: bucket-delete'], [i for i in output if i != ''])
remote_client.disconnect()
def testSettingFailover(self):
setting_enable_auto_failover = self.input.param("enable-auto-failover", 1)
setting_auto_failover_timeout = self.input.param("auto-failover-timeout", 50)
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "setting-autofailover"
options = (" --enable-auto-failover={0}".format(setting_enable_auto_failover))
options += (" --auto-failover-timeout={0}".format(setting_auto_failover_timeout))
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
expectedResults = {"max_nodes":1, "timeout":50, "real_userid:source":self.source, "real_userid:user":self.ldapUser, "remote:ip":"127.0.0.1", "port":60033}
self.checkConfig(8220, self.master, expectedResults)
remote_client.disconnect()
def test_compression_active_and_off(self):
'''
test reproducer for MB-29272,
Load some documents with compression mode set to active
get the cbstats
change compression mode to off and wait for minimum 250ms
Load some more documents and check the compression is not done
epengine.basic_ops.basic_ops.test_compression_active_and_off,items=10000,compression_mode=active
:return:
'''
# Load some documents with compression mode as active
gen_create = BlobGenerator('eviction',
'eviction-',
self.value_size,
end=self.num_items)
gen_create2 = BlobGenerator('eviction2',
'eviction2-',
self.value_size,
end=self.num_items)
def_bucket = self.bucket_util.get_all_buckets()[0]
print_ops_task = self.bucket_util.async_print_bucket_ops(def_bucket)
task = self.task.async_load_gen_docs(self.cluster,
def_bucket,
gen_create,
"create",
0,
batch_size=10,
process_concurrency=8,
replicate_to=self.replicate_to,
persist_to=self.persist_to,
durability=self.durability_level,
timeout_secs=self.sdk_timeout,
retries=self.sdk_retries)
self.task.jython_task_manager.get_task_result(task)
self.bucket_util._wait_for_stats_all_buckets()
self.bucket_util.verify_stats_all_buckets(self.num_items)
print_ops_task.end_task()
remote = RemoteMachineShellConnection(self.cluster.master)
for bucket in self.buckets:
# change compression mode to off
output, _ = remote.execute_couchbase_cli(
cli_command='bucket-edit',
cluster_host="localhost:8091",
user=self.cluster.master.rest_username,
password=self.cluster.master.rest_password,
options='--bucket=%s --compression-mode off' % bucket.name)
self.assertTrue(' '.join(output).find('SUCCESS') != -1,
'compression mode set to off')
# sleep for 10 sec (minimum 250sec)
time.sleep(10)
# Load data and check stats to see compression
# is not done for newly added data
print_ops_task = self.bucket_util.async_print_bucket_ops(def_bucket)
task = self.task.async_load_gen_docs(self.cluster,
def_bucket,
gen_create2,
"create",
0,
batch_size=10,
process_concurrency=8,
replicate_to=self.replicate_to,
persist_to=self.persist_to,
durability=self.durability_level,
timeout_secs=self.sdk_timeout,
retries=self.sdk_retries)
self.task.jython_task_manager.get_task_result(task)
self.bucket_util._wait_for_stats_all_buckets()
self.bucket_util.verify_stats_all_buckets(self.num_items)
print_ops_task.end_task()
def testBucketModification(self):
if self.role in ['replication_admin', 'views_admin[*]']:
result = "Forbidden"
elif self.role in ['admin', 'cluster_admin', 'bucket_admin[*]']:
result = 'SUCCESS'
cli_command = "bucket-edit"
bucket_type = self.input.param("bucket_type", "couchbase")
enable_flush = self.input.param("enable_flush", None)
bucket_port_new = self.input.param("bucket_port_new", None)
bucket_password_new = self.input.param("bucket_password_new", None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
enable_flush_new = self.input.param("enable_flush_new", None)
enable_index_replica_new = self.input.param("enable_index_replica_new",
None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
bucket = self.input.param("bucket", "default")
bucket_ramsize = self.input.param("bucket_ramsize", 200)
bucket_replica = self.input.param("bucket_replica", 1)
enable_flush = self.input.param("enable_flush", None)
enable_index_replica = self.input.param("enable_index_replica", None)
wait = self.input.param("wait", False)
remote_client = RemoteMachineShellConnection(self.master)
self._create_bucket(remote_client,
bucket,
bucket_type=bucket_type,
bucket_ramsize=bucket_ramsize,
bucket_replica=bucket_replica,
wait=wait,
enable_flush=enable_flush,
enable_index_replica=enable_index_replica,
user="******",
password='******')
cli_command = "bucket-edit"
options = "--bucket={0}".format(bucket)
options += (" --enable-flush={0}".format(enable_flush_new),
"")[enable_flush_new is None]
options += (
" --enable-index-replica={0}".format(enable_index_replica_new),
"")[enable_index_replica_new is None]
#options += (" --bucket-port={0}".format(bucket_port_new), "")[bucket_port_new is None]
options += (" --bucket-ramsize={0}".format(bucket_ramsize_new),
"")[bucket_ramsize_new is None]
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
cli_command = "bucket-flush --force"
options = "--bucket={0}".format(bucket)
if enable_flush_new is not None:
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
cli_command = "bucket-delete"
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {
"bucket_name": "BBB",
"source": self.source,
"user": self.ldapUser,
"ip": "127.0.0.1",
"port": 57457
}
self._validate_roles(output, result)
remote_client.disconnect()
def testSettingCompacttion(self):
if self.role in [
'replication_admin', 'views_admin[*]', 'bucket_admin[*]'
]:
result = "Forbidden"
elif self.role in ['admin', 'cluster_admin']:
result = 'SUCCESS'
cli_command = "bucket-edit"
'''setting-compacttion OPTIONS:
--compaction-db-percentage=PERCENTAGE at which point database compaction is triggered
--compaction-db-size=SIZE[MB] at which point database compaction is triggered
--compaction-view-percentage=PERCENTAGE at which point view compaction is triggered
--compaction-view-size=SIZE[MB] at which point view compaction is triggered
--compaction-period-from=HH:MM allow compaction time period from
--compaction-period-to=HH:MM allow compaction time period to
--enable-compaction-abort=[0|1] allow compaction abort when time expires
--enable-compaction-parallel=[0|1] allow parallel compaction for database and view'''
compaction_db_percentage = self.input.param("compaction-db-percentage",
None)
compaction_db_size = self.input.param("compaction-db-size", None)
compaction_view_percentage = self.input.param(
"compaction-view-percentage", None)
compaction_view_size = self.input.param("compaction-view-size", None)
compaction_period_from = self.input.param("compaction-period-from",
None)
compaction_period_to = self.input.param("compaction-period-to", None)
enable_compaction_abort = self.input.param("enable-compaction-abort",
None)
enable_compaction_parallel = self.input.param(
"enable-compaction-parallel", None)
bucket = self.input.param("bucket", "default")
output = self.input.param("output", '')
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "setting-compaction"
options = (
" --compaction-db-percentage={0}".format(compaction_db_percentage),
"")[compaction_db_percentage is None]
options += (" --compaction-db-size={0}".format(compaction_db_size),
"")[compaction_db_size is None]
options += (" --compaction-view-percentage={0}".format(
compaction_view_percentage),
"")[compaction_view_percentage is None]
options += (" --compaction-view-size={0}".format(compaction_view_size),
"")[compaction_view_size is None]
options += (
" --compaction-period-from={0}".format(compaction_period_from),
"")[compaction_period_from is None]
options += (" --compaction-period-to={0}".format(compaction_period_to),
"")[compaction_period_to is None]
options += (
" --enable-compaction-abort={0}".format(enable_compaction_abort),
"")[enable_compaction_abort is None]
options += (" --enable-compaction-parallel={0}".format(
enable_compaction_parallel),
"")[enable_compaction_parallel is None]
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
remote_client.disconnect()
def testBucketModification(self):
cli_command = "bucket-edit"
bucket_type = self.input.param("bucket_type", "couchbase")
bucket_password = self.input.param("bucket_password", None)
bucket_port = self.input.param("bucket_port", 11211)
enable_flush = self.input.param("enable_flush", None)
bucket_port_new = self.input.param("bucket_port_new", None)
bucket_password_new = self.input.param("bucket_password_new", None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
enable_flush_new = self.input.param("enable_flush_new", None)
enable_index_replica_new = self.input.param("enable_index_replica_new",
None)
bucket_ramsize_new = self.input.param("bucket_ramsize_new", None)
bucket = self.input.param("bucket", "default")
bucket_ramsize = self.input.param("bucket_ramsize", 200)
bucket_replica = self.input.param("bucket_replica", 1)
enable_flush = self.input.param("enable_flush", None)
enable_index_replica = self.input.param("enable_index_replica", None)
wait = self.input.param("wait", False)
remote_client = RemoteMachineShellConnection(self.master)
self._create_bucket(remote_client,
bucket,
bucket_type=bucket_type,
bucket_ramsize=bucket_ramsize,
bucket_replica=bucket_replica,
wait=wait,
enable_flush=enable_flush,
enable_index_replica=enable_index_replica)
cli_command = "bucket-edit"
options = "--bucket={0}".format(bucket)
options += (" --enable-flush={0}".format(enable_flush_new),
"")[enable_flush_new is None]
options += (
" --enable-index-replica={0}".format(enable_index_replica_new),
"")[enable_index_replica_new is None]
options += (" --bucket-ramsize={0}".format(bucket_ramsize_new),
"")[bucket_ramsize_new is None]
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {'bucket_name':'BBB', 'ram_quota':465567744, 'num_replicas':1,
'replica_index':True, 'eviction_policy':'value_only', 'type':'membase', \
'auth_type':'none', "autocompaction":'false', "purge_interval":"undefined", \
"flush_enabled":True, "num_threads":3, "source":self.source, \
"user":self.ldapUser, "ip":'::1', "port":57457, 'sessionid':'',
'auth_type':self.source, 'storage_mode': 'couchstore'}
self.checkConfig(8202, self.master, expectedResults)
cli_command = "bucket-flush --force"
options = "--bucket={0}".format(bucket)
if enable_flush_new is not None:
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {
"bucket_name": "BBB",
"source": self.source,
"user": self.ldapUser,
"ip": "::1",
'port': 57457
}
self.checkConfig(8204, self.master, expectedResults)
cli_command = "bucket-delete"
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {
"bucket_name": "BBB",
"source": self.source,
"user": self.ldapUser,
"ip": "::1",
"port": 57457
}
self.checkConfig(8203, self.master, expectedResults)
remote_client.disconnect()
def testSettingCompacttion(self):
'''setting-compacttion OPTIONS:
--compaction-db-percentage=PERCENTAGE at which point database compaction is triggered
--compaction-db-size=SIZE[MB] at which point database compaction is triggered
--compaction-view-percentage=PERCENTAGE at which point view compaction is triggered
--compaction-view-size=SIZE[MB] at which point view compaction is triggered
--compaction-period-from=HH:MM allow compaction time period from
--compaction-period-to=HH:MM allow compaction time period to
--enable-compaction-abort=[0|1] allow compaction abort when time expires
--enable-compaction-parallel=[0|1] allow parallel compaction for database and view'''
compaction_db_percentage = self.input.param("compaction-db-percentage",
None)
compaction_db_size = self.input.param("compaction-db-size", None)
compaction_view_percentage = self.input.param(
"compaction-view-percentage", None)
compaction_view_size = self.input.param("compaction-view-size", None)
compaction_period_from = self.input.param("compaction-period-from",
None)
compaction_period_to = self.input.param("compaction-period-to", None)
enable_compaction_abort = self.input.param("enable-compaction-abort",
None)
enable_compaction_parallel = self.input.param(
"enable-compaction-parallel", None)
bucket = self.input.param("bucket", "default")
output = self.input.param("output", '')
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "setting-compaction"
options = (
" --compaction-db-percentage={0}".format(compaction_db_percentage),
"")[compaction_db_percentage is None]
options += (" --compaction-db-size={0}".format(compaction_db_size),
"")[compaction_db_size is None]
options += (" --compaction-view-percentage={0}".format(
compaction_view_percentage),
"")[compaction_view_percentage is None]
options += (" --compaction-view-size={0}".format(compaction_view_size),
"")[compaction_view_size is None]
options += (
" --compaction-period-from={0}".format(compaction_period_from),
"")[compaction_period_from is None]
options += (" --compaction-period-to={0}".format(compaction_period_to),
"")[compaction_period_to is None]
options += (
" --enable-compaction-abort={0}".format(enable_compaction_abort),
"")[enable_compaction_abort is None]
options += (" --enable-compaction-parallel={0}".format(
enable_compaction_parallel),
"")[enable_compaction_parallel is None]
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {
"parallel_db_and_view_compaction": False,
"database_fragmentation_threshold:size": 10485760,
"database_fragmentation_threshold:view_fragmentation_threshold":
{},
"real_userid:source": self.source,
"real_userid:user": self.ldapUser,
"remote:ip": "::1",
"remote:port": 60019
}
self.checkConfig(8225, self.master, expectedResults)
remote_client.disconnect()
def testSettingEmail(self):
setting_enable_email_alert = self.input.param("enable-email-alert", 1)
setting_email_recipients = self.input.param("email-recipients",
'*****@*****.**')
setting_email_sender = self.input.param("email-sender",
'*****@*****.**')
setting_email_user = self.input.param("email-user", 'ritam')
setting_emaiL_password = self.input.param("email-password", 'password')
setting_email_host = self.input.param("email-host", 'localhost')
setting_email_port = self.input.param("email-port", '25')
setting_email_encrypt = self.input.param("enable-email-encrypt", 0)
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "setting-alert"
options = (
" --enable-email-alert={0}".format(setting_enable_email_alert))
options += (" --email-recipients={0}".format(setting_email_recipients))
options += (" --email-sender={0}".format(setting_email_sender))
options += (" --email-user={0}".format(setting_email_user))
options += (" --email-password={0}".format(setting_emaiL_password))
options += (" --email-host={0}".format(setting_email_host))
options += (" --email-port={0}".format(setting_email_port))
options += (
" --enable-email-encrypt={0}".format(setting_email_encrypt))
options += (" --alert-auto-failover-node")
options += (" --alert-auto-failover-max-reached")
options += (" --alert-auto-failover-node-down")
options += (" --alert-auto-failover-cluster-small")
options += (" --alert-ip-changed")
options += (" --alert-disk-space")
options += (" --alert-meta-overhead")
options += (" --alert-meta-oom")
options += (" --alert-write-failed")
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {
"email_server:encrypt":
False,
"email_server:port":
25,
"email_server:host":
"localhost",
"email_server:user":
"******",
"alerts": [
"auto_failover_node", "auto_failover_maximum_reached",
"auto_failover_other_nodes_down",
"auto_failover_cluster_too_small", "ip", "disk", "overhead",
"ep_oom_errors", "ep_item_commit_failed"
],
"recipients": ["*****@*****.**"],
"sender":
"*****@*****.**",
"real_userid:source":
self.source,
"real_userid:user":
self.ldapUser,
"remote:ip":
"127.0.0.1",
"port":
60025
}
self.checkConfig(8223, self.master, expectedResults)
remote_client.disconnect()
def testCreateRenameDeleteGroup(self):
remote_client = RemoteMachineShellConnection(self.master)
cli_command = "group-manage"
source = self.source
user = self.ldapUser
rest = RestConnection(self.master)
if self.os == "linux":
# create group
options = " --create --group-name=group2"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
output = self.del_runCmd_value(output)
self.assertEqual(output[1], "SUCCESS: Server group created")
expectedResults = {
'group_name': 'group2',
'source': source,
'user': user,
'ip': '127.0.0.1',
'port': 1234
}
tempStr = rest.get_zone_uri()[expectedResults['group_name']]
tempStr = (tempStr.split("/"))[4]
expectedResults['uuid'] = tempStr
self.checkConfig(8210, self.master, expectedResults)
# rename group test
options = " --rename=group3 --group-name=group2"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
output = self.del_runCmd_value(output)
self.assertEqual(output[1], ["SUCCESS: group renamed group"])
expectedResults = {}
expectedResults = {
'group_name': 'group3',
'source': source,
'user': user,
'ip': '127.0.0.1',
'port': 1234,
'nodes': []
}
expectedResults['uuid'] = tempStr
self.checkConfig(8212, self.master, expectedResults)
# delete group test
options = " --delete --group-name=group3"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
output = self.del_runCmd_value(output)
self.assertEqual(output[1], ["SUCCESS: group deleted group"])
expectedResults = {}
expectedResults = {
'group_name': 'group3',
'source': source,
'user': user,
'ip': '127.0.0.1',
'port': 1234
}
expectedResults['uuid'] = tempStr
self.checkConfig(8211, self.master, expectedResults)
if self.os == "windows":
# create group
options = " --create --group-name=group2"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
self.assertEqual(output[0], "SUCCESS: group created group2")
expectedResults = {
'group_name': 'group2',
'source': source,
'user': user,
'ip': '127.0.0.1',
'port': 1234
}
tempStr = rest.get_zone_uri()[expectedResults['group_name']]
tempStr = (tempStr.split("/"))[4]
expectedResults['uuid'] = tempStr
self.checkConfig(8210, self.master, expectedResults)
# rename group test
options = " --rename=group3 --group-name=group2"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
self.assertEqual(output[0], "SUCCESS: group renamed group2")
expectedResults = {}
expectedResults = {
'group_name': 'group3',
'source': source,
'user': user,
'ip': '127.0.0.1',
'port': 1234,
'nodes': []
}
expectedResults['uuid'] = tempStr
self.checkConfig(8212, self.master, expectedResults)
# delete group test
options = " --delete --group-name=group3"
output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, \
options=options, cluster_host="localhost", user=self.ldapUser, password=self.ldapPass)
self.assertEqual(output[0], "SUCCESS: group deleted group3")
expectedResults = {}
expectedResults = {
'group_name': 'group3',
'source': source,
'user': user,
'ip': '127.0.0.1',
'port': 1234
}
expectedResults['uuid'] = tempStr
self.checkConfig(8211, self.master, expectedResults)
remote_client.disconnect()
class XdcrCLITest(CliBaseTest):
def setUp(self):
TestInputSingleton.input.test_params["default_bucket"] = False
super(XdcrCLITest, self).setUp()
self.ldapUser = self.input.param("ldapUser", 'Administrator')
self.ldapPass = self.input.param('ldapPass', 'password')
self.source = self.input.param('source', 'ns_server')
self.__user = self.input.param("ldapUser", 'Administrator')
self.__password = self.input.param('ldapPass', 'password')
self.shell = RemoteMachineShellConnection(self.master)
info = self.shell.extract_remote_info()
type = info.type.lower()
if type == 'windows' and self.source == 'saslauthd':
raise Exception(" Ldap Tests cannot run on windows")
elif self.source == 'saslauthd':
rest = RestConnection(self.master)
self.setupLDAPSettings(rest)
#rest.ldapUserRestOperation(True, [[self.ldapUser]], exclude=None)
self.set_user_role(rest, self.ldapUser)
def tearDown(self):
for server in self.servers:
rest = RestConnection(server)
rest.remove_all_remote_clusters()
rest.remove_all_replications()
rest.remove_all_recoveries()
super(XdcrCLITest, self).tearDown()
def set_user_role(self, rest, username, user_role='admin'):
payload = "name=" + username + "&roles=" + user_role
content = rest.set_user_roles(user_id=username, payload=payload)
def setupLDAPSettings(self, rest):
api = rest.baseUrl + 'settings/saslauthdAuth'
params = urllib.urlencode({
"enabled": 'true',
"admins": [],
"roAdmins": []
})
status, content, header = rest._http_request(api, 'POST', params)
return status, content, header
#Wrapper around auditmain
def checkConfig(self, eventID, host, expectedResults):
Audit = audit(eventID=eventID, host=host)
fieldVerification, valueVerification = Audit.validateEvents(
expectedResults)
self.assertTrue(fieldVerification, "One of the fields is not matching")
self.assertTrue(valueVerification,
"Values for one of the fields is not matching")
def __execute_cli(self,
cli_command,
options,
cluster_host="localhost",
user=None,
password=None):
if user is None:
user = self.__user
password = self.__password
return self.shell.execute_couchbase_cli(cli_command=cli_command,
options=options,
cluster_host=cluster_host,
user=user,
password=password)
def __xdcr_setup_create(self):
# xdcr_hostname=the number of server in ini file to add to master as replication
xdcr_cluster_name = self.input.param("xdcr-cluster-name", None)
xdcr_hostname = self.input.param("xdcr-hostname", None)
xdcr_username = self.input.param("xdcr-username", None)
xdcr_password = self.input.param("xdcr-password", None)
demand_encyrption = self.input.param("demand-encryption", 0)
xdcr_cert = self.input.param("xdcr-certificate", None)
wrong_cert = self.input.param("wrong-certificate", None)
cli_command = "xdcr-setup"
options = "--create"
options += (" --xdcr-cluster-name=\'{0}\'".format(xdcr_cluster_name),
"")[xdcr_cluster_name is None]
print("Value of xdcr_home is {0}".format(xdcr_hostname))
if xdcr_hostname is not None:
options += " --xdcr-hostname={0}".format(
self.servers[xdcr_hostname].ip)
options += (" --xdcr-username={0}".format(xdcr_username),
"")[xdcr_username is None]
options += (" --xdcr-password={0}".format(xdcr_password),
"")[xdcr_password is None]
options += (" --xdcr-demand-encryption={0}".format(demand_encyrption))
cluster_host = self.servers[xdcr_hostname].ip
output, _ = self.__execute_cli(
cli_command="ssl-manage",
options="--retrieve-cert={0}".format(xdcr_cert),
cluster_host=cluster_host,
user='******',
password='******')
options += (" --xdcr-certificate={0}".format(xdcr_cert),
"")[xdcr_cert is None]
#self.assertNotEqual(output[0].find("SUCCESS"), -1, "ssl-manage CLI failed to retrieve certificate")
output, error = self.__execute_cli(cli_command=cli_command,
options=options)
return output, error, xdcr_cluster_name, xdcr_hostname, cli_command, options
def testXDCRSetup(self):
output, _, xdcr_cluster_name, xdcr_hostname, cli_command, options = self.__xdcr_setup_create(
)
expectedResults = {
"real_userid:source": self.source,
"user": self.__user,
"cluster_name": "remote",
"cluster_hostname": self.servers[xdcr_hostname].ip + ":8091",
"is_encrypted": False
}
self.checkConfig(16384, self.master, expectedResults)
if xdcr_cluster_name:
options = options.replace("--create ", "--edit ")
output, _ = self.__execute_cli(cli_command=cli_command,
options=options)
expectedResults = {
"real_userid:source": self.source,
"user": self.__user,
"cluster_name": "remote",
"cluster_hostname": self.servers[xdcr_hostname].ip + ":8091",
"is_encrypted": False,
'encryption_type': ''
}
self.checkConfig(16385, self.master, expectedResults)
if not xdcr_cluster_name:
options = "--delete --xdcr-cluster-name=\'{0}\'".format(
"remote cluster")
else:
options = "--delete --xdcr-cluster-name=\'{0}\'".format(
xdcr_cluster_name)
output, _ = self.__execute_cli(cli_command=cli_command,
options=options)
expectedResults = {
"real_userid:source": self.source,
"user": self.__user,
"cluster_name": "remote",
"cluster_hostname": self.servers[xdcr_hostname].ip + ":8091",
"is_encrypted": False
}
self.checkConfig(16386, self.master, expectedResults)
def testXdcrReplication(self):
'''xdcr-replicate OPTIONS:
--create create and start a new replication
--delete stop and cancel a replication
--list list all xdcr replications
--xdcr-from-bucket=BUCKET local bucket name to replicate from
--xdcr-cluster-name=CLUSTERNAME remote cluster to replicate to
--xdcr-to-bucket=BUCKETNAME remote bucket to replicate to'''
to_bucket = self.input.param("xdcr-to-bucket", None)
from_bucket = self.input.param("xdcr-from-bucket", None)
error_expected = self.input.param("error-expected", False)
replication_mode = self.input.param("replication_mode", None)
pause_resume = self.input.param("pause-resume", None)
_, _, xdcr_cluster_name, xdcr_hostname, _, _ = self.__xdcr_setup_create(
)
cli_command = "xdcr-replicate"
options = "--create"
options += (" --xdcr-cluster-name=\'{0}\'".format(xdcr_cluster_name),
"")[xdcr_cluster_name is None]
options += (" --xdcr-from-bucket=\'{0}\'".format(from_bucket),
"")[from_bucket is None]
options += (" --xdcr-to-bucket=\'{0}\'".format(to_bucket),
"")[to_bucket is None]
options += (
" --xdcr-replication-mode=\'{0}\'".format(replication_mode),
"")[replication_mode is None]
self.bucket_size = self._get_bucket_size(self.quota, 1)
if from_bucket:
bucket_params = self._create_bucket_params(
server=self.master,
size=self.bucket_size,
replicas=self.num_replicas,
enable_replica_index=self.enable_replica_index)
self.cluster.create_default_bucket(bucket_params)
if to_bucket:
bucket_params = self._create_bucket_params(
server=self.servers[xdcr_hostname],
size=self.bucket_size,
replicas=self.num_replicas,
enable_replica_index=self.enable_replica_index)
self.cluster.create_default_bucket(bucket_params)
output, _ = self.__execute_cli(cli_command, options)
expectedResults = {
"real_userid:source": self.source,
"user": self.__user,
"local_cluster_name": self.master.ip + ":8091",
"source_bucket_name": "default",
"remote_cluster_name": "remote",
"target_bucket_name": "default"
}
self.checkConfig(16387, self.master, expectedResults)
self.sleep(8)
options = "--list"
output, _ = self.__execute_cli(cli_command, options)
for value in output:
if value.startswith("stream id"):
replicator = value.split(":")[1].strip()
if pause_resume is not None:
# pause replication
options = "--pause"
options += (" --xdcr-replicator={0}".format(replicator))
output, _ = self.__execute_cli(cli_command, options)
# validate output message
expectedResults = {
"real_userid:source": self.source,
"user": self.__user,
"local_cluster_name": self.master.ip + ":8091",
"source_bucket_name": "default",
"remote_cluster_name": "remote",
"target_bucket_name": "default"
}
self.checkConfig(16388, self.master, expectedResults)
expectedResults = {
"source_bucket_name": "default",
"remote_cluster_name": "remote",
"target_bucket_name": "default",
"real_userid:source": "internal",
"user": self.__user,
"local_cluster_name": self.master.ip + ":8091",
"updated_settings:pauseRequested": True
}
self.checkConfig(16392, self.master, expectedResults)
self.sleep(60)
# resume replication
options = "--resume"
options += (" --xdcr-replicator={0}".format(replicator))
output, _ = self.__execute_cli(cli_command, options)
expectedResults = {
"real_userid:source": self.source,
"user": self.__user,
"local_cluster_name": self.master.ip + ":8091",
"source_bucket_name": "default",
"remote_cluster_name": "remote",
"target_bucket_name": "default"
}
self.checkConfig(16389, self.master, expectedResults)
options = "--delete"
options += (" --xdcr-replicator={0}".format(replicator))
output, _ = self.__execute_cli(cli_command, options)
expectedResults = {
"real_userid:source": self.source,
"user": self.__user,
"local_cluster_name": self.master.ip + ":8091",
"source_bucket_name": "default",
"remote_cluster_name": "remote",
"target_bucket_name": "default"
}
self.checkConfig(16390, self.master, expectedResults)
def testAddRemoveNodes(self):
nodes_add = self.input.param("nodes_add", 1)
nodes_rem = self.input.param("nodes_rem", 1)
nodes_failover = self.input.param("nodes_failover", 0)
force_failover = self.input.param("force_failover", False)
nodes_readd = self.input.param("nodes_readd", 0)
cli_command = self.input.param("cli_command", None)
source = self.source
remote_client = RemoteMachineShellConnection(self.master)
for num in xrange(nodes_add):
options = "--server-add={0}:8091 --server-add-username=Administrator --server-add-password=password".format(
self.servers[num + 1].ip)
output, error = remote_client.execute_couchbase_cli(
cli_command='server-add',
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
output, error = remote_client.execute_couchbase_cli(
cli_command='rebalance',
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
if (cli_command == "server-add"):
expectedResults = {
"services": ['kv'],
'port': 8091,
'hostname': self.servers[num + 1].ip,
'groupUUID': "0",
'node': 'ns_1@' + self.servers[num + 1].ip,
'source': source,
'user': self.master.rest_username,
"real_userid:user": self.ldapUser,
"ip": '127.0.0.1',
"remote:port": 57457
}
self.checkConfig(self.eventID, self.master, expectedResults)
expectedResults = {
"delta_recovery_buckets":
"all",
'known_nodes':
["ns_1@" + self.servers[num + 1].ip, "ns_1@" + self.master.ip],
'ejected_nodes': [],
'source':
'ns_server',
'source':
source,
'user':
self.master.rest_username,
"ip":
'127.0.0.1',
"port":
57457,
"real_userid:user":
self.ldapUser
}
self.checkConfig(8200, self.master, expectedResults)
if (cli_command == 'server-remove'):
for num in xrange(nodes_rem):
cli_command = "rebalance"
options = "--server-remove={0}:8091".format(
self.servers[nodes_add - num].ip)
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
#expectedResults = {'node':'ns_1@' + self.servers[num + 1].ip, 'source':source, 'user':self.master.rest_username, "ip":'127.0.0.1', "port":57457}
#self.checkConfig(self.eventID, self.master, expectedResults)
expectedResults = {
"delta_recovery_buckets":
"all",
'known_nodes': [
"ns_1@" + self.servers[num + 1].ip,
"ns_1@" + self.master.ip
],
'ejected_nodes': ["ns_1@" + self.servers[num + 1].ip],
'source':
source,
'user':
self.master.rest_username,
"ip":
'127.0.0.1',
"port":
57457,
"real_userid:user":
self.ldapUser
}
self.checkConfig(8200, self.master, expectedResults)
if (cli_command in ["failover"]):
cli_command = 'failover'
for num in xrange(nodes_failover):
self.log.info("failover node {0}".format(
self.servers[nodes_add - nodes_rem - num].ip))
options = "--server-failover={0}:8091".format(
self.servers[nodes_add - nodes_rem - num].ip)
options += " --force"
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {
'source': source,
"real_userid:user": self.ldapUser,
'user': self.master.rest_username,
"ip": '127.0.0.1',
"port": 57457,
'type': 'hard',
'node':
'ns_1@' + self.servers[nodes_add - nodes_rem - num].ip
}
self.checkConfig(self.eventID, self.master, expectedResults)
if (cli_command == "server-readd"):
for num in xrange(nodes_readd):
cli_command = 'failover'
self.log.info("failover node {0}".format(
self.servers[nodes_add - nodes_rem - num].ip))
options = "--server-failover={0}:8091".format(
self.servers[nodes_add - nodes_rem - num].ip)
options += " --force"
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
self.log.info("add back node {0} to cluster".format(
self.servers[nodes_add - nodes_rem - num].ip))
cli_command = "server-readd"
options = "--server-add={0}:8091 ".format(
self.servers[nodes_add - nodes_rem - num].ip)
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="localhost",
user=self.ldapUser,
password=self.ldapPass)
expectedResults = {
'node':
'ns_1@' + self.servers[nodes_add - nodes_rem - num].ip,
'type': 'full',
"real_userid:user": self.ldapUser,
'source': source,
'user': self.master.rest_username,
"ip": '127.0.0.1',
"port": 57457
}
self.checkConfig(self.eventID, self.master, expectedResults)
remote_client.disconnect()
def testAddRemoveNodes(self):
if self.role in [
'replication_admin', 'views_admin[*]', 'bucket_admin[*]'
]:
result = "Forbidden"
elif self.role in ['admin', 'cluster_admin']:
result = 'SUCCESS'
nodes_add = self.input.param("nodes_add", 1)
nodes_rem = self.input.param("nodes_rem", 1)
nodes_failover = self.input.param("nodes_failover", 0)
force_failover = self.input.param("force_failover", False)
nodes_readd = self.input.param("nodes_readd", 0)
cli_command = self.input.param("cli_command", None)
source = self.source
remote_client = RemoteMachineShellConnection(self.master)
for num in xrange(nodes_add):
options = "--server-add=http://{0}:8091 --server-add-username=Administrator --server-add-password=password".format(
self.servers[num + 1].ip)
output, error = remote_client.execute_couchbase_cli(
cli_command='server-add',
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
output, error = remote_client.execute_couchbase_cli(
cli_command='rebalance',
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
if (cli_command == 'server-remove'):
for num in xrange(nodes_rem):
cli_command = "rebalance"
options = "--server-remove={0}:8091".format(
self.servers[nodes_add - num].ip)
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
if (cli_command in ["failover"]):
cli_command = 'failover'
for num in xrange(nodes_failover):
self.log.info("failover node {0}".format(
self.servers[nodes_add - nodes_rem - num].ip))
options = "--server-failover={0}:8091".format(
self.servers[nodes_add - nodes_rem - num].ip)
options += " --force"
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
if (cli_command == "server-readd"):
for num in xrange(nodes_readd):
cli_command = 'failover'
self.log.info("failover node {0}".format(
self.servers[nodes_add - nodes_rem - num].ip))
options = "--server-failover={0}:8091".format(
self.servers[nodes_add - nodes_rem - num].ip)
options += " --force"
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
self.log.info("add back node {0} to cluster".format(
self.servers[nodes_add - nodes_rem - num].ip))
cli_command = "server-readd"
options = "--server-add={0}:8091".format(
self.servers[nodes_add - nodes_rem - num].ip)
output, error = remote_client.execute_couchbase_cli(
cli_command=cli_command,
options=options,
cluster_host="127.0.0.1:8091",
user=self.ldapUser,
password=self.ldapPass)
self._validate_roles(output, result)
remote_client.disconnect()
