def run(self):
remote_client = RemoteMachineShellConnection(self.server)
now = datetime.now()
day = now.day
month = now.month
year = now.year
hour = now.timetuple().tm_hour
minute = now.timetuple().tm_min
file_name = "%s-%s%s%s-%s%s-couch.tar.gz" % (self.server.ip, month, day, year, hour, minute)
print "Collecting data files from %s\n" % self.server.ip
remote_client.extract_remote_info()
data_path = self.__get_data_path(os_type=remote_client.info.type.lower())
output, error = remote_client.execute_command(
"tar -zcvf {0} '{1}' >/dev/null 2>&1".format(file_name, data_path)
)
print "\n".join(output)
print "\n".join(error)
user_path = "/home/"
if self.server.ssh_username == "root":
user_path = "/"
remote_path = "%s%s" % (user_path, self.server.ssh_username)
status = remote_client.file_exists(remote_path, file_name)
if not status:
raise Exception("%s doesn't exists on server" % file_name)
status = remote_client.get_file(remote_path, file_name, "%s/%s" % (self.path, file_name))
if not status:
raise Exception("Fail to download zipped logs from %s" % self.server.ip)
remote_client.execute_command("rm -f %s" % os.path.join(remote_path, file_name))
remote_client.disconnect()
def run(self):
remote_client = RemoteMachineShellConnection(self.server)
now = datetime.now()
day = now.day
month = now.month
year = now.year
hour = now.timetuple().tm_hour
minute = now.timetuple().tm_min
file_name = "%s-%s%s%s-%s%s-couch.tar.gz" % (self.server.ip,
month, day, year, hour,
minute)
print("Collecting data files from %s\n" % self.server.ip)
remote_client.extract_remote_info()
data_path = self.__get_data_path(os_type=remote_client.info.type.lower())
output, error = remote_client.execute_command("tar -zcvf {0} '{1}' >/dev/null 2>&1".
format(file_name, data_path))
print("\n".join(output))
print("\n".join(error))
user_path = "/home/"
if self.server.ssh_username == "root":
user_path = "/"
remote_path = "%s%s" % (user_path, self.server.ssh_username)
status = remote_client.file_exists(remote_path, file_name)
if not status:
raise Exception("%s doesn't exists on server" % file_name)
status = remote_client.get_file(remote_path, file_name,
"%s/%s" % (self.path, file_name))
if not status:
raise Exception("Fail to download zipped logs from %s"
% self.server.ip)
remote_client.execute_command("rm -f %s" % os.path.join(remote_path, file_name))
remote_client.disconnect()
def create_and_restore_csv(self):
try:
self.__load_data()
shell_obj = RemoteMachineShellConnection(self.master)
self.log.info("Removing backup folder if already present")
info = shell_obj.extract_remote_info()
path = "/tmp/backup/"
if info.type.lower() == "windows":
path = "/cygdrive/c" + path
#TODO : Check for mac also
shell_obj.delete_files(path)
create_dir = "mkdir " + path
data_type = "csv:"
destination = path + "data.csv"
shell_obj.execute_command(create_dir)
source = "http://*****:*****@ %s" % destination)
source, destination = destination, source
options = "-B standard_bucket0" + self.username_arg + self.password_arg
self.log.info("Restoring data....!")
shell_obj.execute_cbtransfer(source, destination, options)
self.sleep(10)
self.log.info("Checking whether number of items loaded match with the number of items restored.")
rest = RestConnection(self.master)
itemCount = rest.get_bucket_json('standard_bucket0')['basicStats']['itemCount']
self.assertEqual(itemCount, self.num_items, msg="Number of items loaded do no match\
with the number of items restored. Number of items loaded is {0} \
but number of items restored is {1}".format(self.num_items, itemCount))
self.log.info("Number of items loaded = Number of items restored. Pass!!")
finally:
shell_obj.disconnect()
def convert_to_hostname(self, servers_with_hostnames):
try:
hostname = []
for server in servers_with_hostnames:
shell = RemoteMachineShellConnection(server)
info = shell.extract_remote_info()
domain = ''.join(info.domain[0])
hostname.append(info.hostname[0] + "." + domain)
master_rest = RestConnection(server)
var = master_rest.get_nodes_self().hostname
flag = True if server.ip in var else False
self.log.info("get_node_self function returned : {0}".format(var))
if flag:
self.log.info("Node {0} is referred via IP. Need to be referred with hostname. Changing the name of the node!!".format(server.ip))
version = RestConnection(server).get_nodes_self().version
if version.startswith("1.8.1") or version.startswith("2.0.0") or version.startswith("2.0.1"):
RemoteUtilHelper.use_hostname_for_server_settings(server)
obj = RestConnection(server)
obj.init_cluster()
else:
obj = RestConnection(server)
obj.init_cluster()
var = master_rest.rename_node(username='******', password='******', port='', hostname=hostname[-1])
else:
self.log.info("Node {0} already referred via hostname. No need to convert the name".format(server.ip))
finally:
shell.disconnect()
return hostname
def convert_to_hostname(self, servers_with_hostnames, username='******', password='******'):
try:
hostname = []
for server in servers_with_hostnames:
shell = RemoteMachineShellConnection(server)
info = shell.extract_remote_info()
domain = ''.join(info.domain[0])
if not domain:
output = shell.execute_command_raw('nslookup %s' % info.hostname[0])
print output
self.fail("Domain is not defined, couchbase cannot be configured correctly. NOT A BUG. CONFIGURATION ISSUE")
hostname.append(info.hostname[0] + "." + domain)
master_rest = RestConnection(server)
current_hostname = master_rest.get_nodes_self().hostname
self.log.info("get_node_self function returned : {0}".format(current_hostname))
if server.ip in current_hostname:
self.log.info("Node {0} is referred via IP. Need to be referred with hostname. Changing the name of the node!!".format(server.ip))
version = RestConnection(server).get_nodes_self().version
if version.startswith("1.8.1") or version.startswith("2.0.0") or version.startswith("2.0.1"):
RemoteUtilHelper.use_hostname_for_server_settings(server)
master_rest.init_cluster()
else:
master_rest.init_cluster()
master_rest.rename_node(username=username, password=password, port='', hostname=hostname[-1])
else:
self.log.info("Node {0} already referred via hostname. No need to convert the name".format(server.ip))
finally:
shell.disconnect()
return hostname
def machine_info(node):
shell = RemoteMachineShellConnection(node)
info = shell.extract_remote_info()
return {
"type": info.type,
"distribution": info.distribution_type,
"version": info.distribution_version,
"ram": info.ram,
"cpu": info.cpu,
"disk": info.disk,
"hostname": info.hostname
}
def drop_data_to_bucket_from_eventing(self,server):
shell = RemoteMachineShellConnection(server)
shell.info = shell.extract_remote_info()
if shell.info.type.lower() == "windows":
raise Exception("Should not run on windows")
o, r = shell.execute_command("/sbin/iptables -A OUTPUT -p tcp --dport 11210 -j DROP")
shell.log_command_output(o, r)
# o, r = shell.execute_command("/sbin/iptables -A INPUT -p tcp --dport 11210 -j DROP")
# shell.log_command_output(o, r)
log.info("enabled firewall on {0}".format(server))
o, r = shell.execute_command("/sbin/iptables --list")
shell.log_command_output(o, r)
shell.disconnect()
def kill_erlang_service(self, server):
remote_client = RemoteMachineShellConnection(server)
os_info = remote_client.extract_remote_info()
log.info("os_info : {0}".format(os_info))
if os_info.type.lower() == "windows":
remote_client.kill_erlang(os="windows")
else:
remote_client.kill_erlang()
remote_client.start_couchbase()
remote_client.disconnect()
# wait for restart and warmup on all node
self.sleep(self.wait_timeout * 2)
# wait till node is ready after warmup
ClusterOperationHelper.wait_for_ns_servers_or_assert([server], self, wait_if_warmup=True)
def kill_erlang_service(self, server):
remote_client = RemoteMachineShellConnection(server)
os_info = remote_client.extract_remote_info()
log.info("os_info : {0}", os_info)
if os_info.type.lower() == "windows":
remote_client.kill_erlang(os="windows")
else:
remote_client.kill_erlang()
remote_client.start_couchbase()
remote_client.disconnect()
# wait for restart and warmup on all node
self.sleep(self.wait_timeout * 2)
# wait till node is ready after warmup
ClusterOperationHelper.wait_for_ns_servers_or_assert([server], self, wait_if_warmup=True)
def check_eventing_logs_for_panic(self):
if self.input.param("skip_host_login", False):
log.warning(
"-->Skipping check_eventing_logs_for_panic due to skip_host_login!"
)
return
self.generate_map_nodes_out_dist()
panic_str = "panic"
eventing_nodes = self.get_nodes_from_services_map(
service_type="eventing", get_all_nodes=True)
if not eventing_nodes:
return None
for eventing_node in eventing_nodes:
shell = RemoteMachineShellConnection(eventing_node)
_, dir_name = RestConnection(eventing_node).diag_eval(
'filename:absname(element(2, application:get_env(ns_server,error_logger_mf_dir))).'
)
eventing_log = str(dir_name) + '/eventing.log*'
count, err = shell.execute_command(
"zgrep \"{0}\" {1} | wc -l".format(panic_str, eventing_log))
if isinstance(count, list):
count = int(count[0])
else:
count = int(count)
if count > self.panic_count:
log.info(
"===== PANIC OBSERVED IN EVENTING LOGS ON SERVER {0}=====".
format(eventing_node.ip))
panic_trace, _ = shell.execute_command(
"zgrep \"{0}\" {1}".format(panic_str, eventing_log))
log.info("\n {0}".format(panic_trace))
self.panic_count = count
os_info = shell.extract_remote_info()
if os_info.type.lower() == "windows":
# This is a fixed path in all windows systems inside couchbase
dir_name_crash = 'c://CrashDumps'
else:
dir_name_crash = str(dir_name) + '/../crash/'
core_dump_count, err = shell.execute_command(
"ls {0}| wc -l".format(dir_name_crash))
if isinstance(core_dump_count, list):
core_dump_count = int(core_dump_count[0])
else:
core_dump_count = int(core_dump_count)
if core_dump_count > 0:
log.info(
"===== CORE DUMPS SEEN ON EVENTING NODES, SERVER {0} : {1} crashes seen ====="
.format(eventing_node.ip, core_dump_count))
shell.disconnect()
def convert_to_hostname(self,
servers_with_hostnames,
username='******',
password='******'):
try:
hostname = []
for server in servers_with_hostnames:
shell = RemoteMachineShellConnection(server)
info = shell.extract_remote_info()
domain = ''.join(info.domain[0])
if not domain:
output = shell.execute_command_raw('nslookup %s' %
info.hostname[0])
print output
self.fail(
"Domain is not defined, couchbase cannot be configured correctly. NOT A BUG. CONFIGURATION ISSUE"
)
hostname.append(info.hostname[0] + "." + domain)
master_rest = RestConnection(server)
current_hostname = master_rest.get_nodes_self().hostname
self.log.info("get_node_self function returned : {0}".format(
current_hostname))
if server.ip in current_hostname:
self.log.info(
"Node {0} is referred via IP. Need to be referred with hostname. Changing the name of the node!!"
.format(server.ip))
version = RestConnection(server).get_nodes_self().version
if version.startswith("1.8.1") or version.startswith(
"2.0.0") or version.startswith("2.0.1"):
RemoteUtilHelper.use_hostname_for_server_settings(
server)
master_rest.init_cluster()
else:
master_rest.init_cluster()
master_rest.rename_node(username=username,
password=password,
port='',
hostname=hostname[-1])
else:
self.log.info(
"Node {0} already referred via hostname. No need to convert the name"
.format(server.ip))
finally:
shell.disconnect()
return hostname
def setUp(self):
self.test_setup_finished = False
log.info(
"============== Multiple CA Upgrade setup has started =============="
)
super(MultipleCAUpgrade, self).setUp()
self.initial_version = self.input.param("initial_version",
'6.6.3-9799')
self.upgrade_version = self.input.param("upgrade_version",
"7.1.0-1745")
self.enc_key_mixed_mode = self.input.param("enc_key_mixed_mode", False)
self.skip_rbac_internal_users_setup = self.input.param(
"skip_rbac_internal_users_setup", False)
self.skip_ldap_external_user_setup = self.input.param(
"skip_ldap_external_user_setup", False)
self.base_version = RestConnection(self.master).get_nodes_versions()[0]
if self.enc_key_mixed_mode in ["True", True]:
self.enc_key_mixed_mode = True
else:
self.enc_key_mixed_mode = False
shell = RemoteMachineShellConnection(self.master)
self.windows_test = False
if shell.extract_remote_info().distribution_type == "windows":
self.windows_test = True
shell.disconnect()
self.openssl_path = "/opt/couchbase/bin/openssl"
self.inbox_folder_path = "/opt/couchbase/var/lib/couchbase/inbox/"
if self.windows_test:
self.openssl_path = "C:/Program Files/Couchbase/Server/bin/openssl"
self.inbox_folder_path = "C:/Program Files/Couchbase/Server/var/lib/couchbase/inbox/"
self.plain_passw_map = dict()
self.load_sample_bucket(self.master, "travel-sample")
if not self.skip_rbac_internal_users_setup:
self.add_rbac_groups_roles(self.master)
if not self.skip_ldap_external_user_setup:
self.setup_ldap_config(server=self.master)
self.add_ldap_user(self.master)
self.test_setup_finished = True
def create_and_restore_csv(self):
try:
self.__load_data()
shell_obj = RemoteMachineShellConnection(self.master)
self.log.info("Removing backup folder if already present")
info = shell_obj.extract_remote_info()
path = "/tmp/backup/"
if info.type.lower() == "windows":
path = "/cygdrive/c" + path
#TODO : Check for mac also
shell_obj.delete_files(path)
create_dir = "mkdir " + path
data_type = "csv:"
destination = path + "data.csv"
shell_obj.execute_command(create_dir)
source = "http://*****:*****@ %s" % destination)
source, destination = destination, source
options = "-B standard_bucket0" + self.username_arg + self.password_arg
self.log.info("Restoring data....!")
shell_obj.execute_cbtransfer(source, destination, options)
self.sleep(10)
self.log.info(
"Checking whether number of items loaded match with the number of items restored."
)
rest = RestConnection(self.master)
itemCount = rest.get_bucket_json(
'standard_bucket0')['basicStats']['itemCount']
self.assertEqual(itemCount,
self.num_items,
msg="Number of items loaded do no match\
with the number of items restored. Number of items loaded is {0} \
but number of items restored is {1}".format(
self.num_items, itemCount))
self.log.info(
"Number of items loaded = Number of items restored. Pass!!")
finally:
shell_obj.disconnect()
def set_backup_node(self, backup_node):
self.backup_rest = RestConnection(backup_node)
self.backup_node = backup_node
self.backup_api = \
self.backup_rest.index_baseUrl + "api/v1/bucket/{0}/backup{1}"
self.is_backup_exists = False
self.backup_data = {}
shell = RemoteMachineShellConnection(backup_node)
info = shell.extract_remote_info().type.lower()
if info == 'linux':
self.cli_command_location = testconstants.LINUX_COUCHBASE_BIN_PATH
self.backup_path = testconstants.LINUX_BACKUP_PATH
elif info == 'windows':
self.cmd_ext = ".exe"
self.cli_command_location = \
testconstants.WIN_COUCHBASE_BIN_PATH_RAW
self.backup_path = testconstants.WIN_BACKUP_C_PATH
elif info == 'mac':
self.cli_command_location = testconstants.MAC_COUCHBASE_BIN_PATH
self.backup_path = testconstants.LINUX_BACKUP_PATH
else:
raise Exception("OS not supported.")
def check_eventing_logs_for_panic(self):
self.generate_map_nodes_out_dist()
panic_str = "panic"
eventing_nodes = self.get_nodes_from_services_map(service_type="eventing", get_all_nodes=True)
if not eventing_nodes:
return None
for eventing_node in eventing_nodes:
shell = RemoteMachineShellConnection(eventing_node)
_, dir_name = RestConnection(eventing_node).diag_eval(
'filename:absname(element(2, application:get_env(ns_server,error_logger_mf_dir))).')
eventing_log = str(dir_name) + '/eventing.log*'
count, err = shell.execute_command("zgrep \"{0}\" {1} | wc -l".
format(panic_str, eventing_log))
if isinstance(count, list):
count = int(count[0])
else:
count = int(count)
if count > self.panic_count:
log.info("===== PANIC OBSERVED IN EVENTING LOGS ON SERVER {0}=====".format(eventing_node.ip))
panic_trace, _ = shell.execute_command("zgrep \"{0}\" {1}".
format(panic_str, eventing_log))
log.info("\n {0}".format(panic_trace))
self.panic_count = count
os_info = shell.extract_remote_info()
if os_info.type.lower() == "windows":
# This is a fixed path in all windows systems inside couchbase
dir_name_crash = 'c://CrashDumps'
else:
dir_name_crash = str(dir_name) + '/../crash/'
core_dump_count, err = shell.execute_command("ls {0}| wc -l".format(dir_name_crash))
if isinstance(core_dump_count, list):
core_dump_count = int(core_dump_count[0])
else:
core_dump_count = int(core_dump_count)
if core_dump_count > 0:
log.info("===== CORE DUMPS SEEN ON EVENTING NODES, SERVER {0} : {1} crashes seen =====".format(
eventing_node.ip, core_dump_count))
shell.disconnect()
def machine_info(node):
shell = RemoteMachineShellConnection(node)
info = shell.extract_remote_info()
return {"type": info.type, "distribution": info.distribution_type,
"version": info.distribution_version, "ram": info.ram,
"cpu": info.cpu, "disk": info.disk, "hostname": info.hostname}
class HostnameTests(BaseTestCase):
def setUp(self):
super(HostnameTests, self).setUp()
self.builds = self.input.param("builds", "2.2.0")
self.product = self.input.param('product', 'couchbase-server')
self.is_negative_test = self.input.param('is_negative_test', False)
self.error = self.input.param('error', '')
self.name = self.input.param('name', '')
def tearDown(self):
super(HostnameTests, self).tearDown()
for server in self.servers:
self.assertTrue(
RestHelper(RestConnection(server)).is_ns_server_running(
timeout_in_seconds=480),
msg="ns server is not running even after waiting for 6 minutes"
)
self.log.info(
"sleep for 10 seconds to give enough time for other nodes to restart"
)
self.sleep(10)
def install_builds(self, builds, servers=None):
params = {}
params['product'] = 'couchbase-server'
builds_list = builds.split(";")
st = 0
end = 1
if None in servers:
servers_to_install = self.servers
else:
servers_to_install = servers
for i in builds_list:
params['version'] = i
InstallerJob().sequential_install(servers_to_install[st:end],
params)
st = st + 1
end = end + 1
self.sleep(20)
super(HostnameTests, self).setUp()
def rest_api_addNode(self):
hostnames = self.convert_to_hostname(self, self.servers[0:2])
master_rest = RestConnection(self.master)
master_rest.add_node(self.servers[1].rest_username,
self.servers[1].rest_password, hostnames[1],
self.servers[1].port)
#Now check whether the node which we added is still referred via hostname or not.
obj = RestConnection(self.servers[1])
var = obj.get_nodes_self().hostname
flag = True if self.servers[1].ip in var else False
self.assertEqual(
flag,
False,
msg=
"Fail - Name of node {0} got converted to IP. Failing the test!!!".
format(self.servers[1].ip))
self.log.info("Test Passed!!")
self.sleep(10)
#Cases 39 and 40 from hostname management test plan combined.
def rest_api_renameNode(self):
try:
self.shell = RemoteMachineShellConnection(self.master)
#com_inst_build = "cat /opt/couchbase/VERSION.txt"
#out = self.shell.execute_command(com_inst_build.format(com_inst_build))
self.install_builds(self.builds, self.servers[0:1])
if self.is_negative_test:
master_rest = RestConnection(self.master)
self.log.info("Renaming node {0} to {1}".format(
self.master, self.name))
var = master_rest.rename_node(
username=self.master.rest_username,
password=self.master.rest_password,
port=self.master.port,
hostname=self.name,
is_negative_test=True)
out = var.pop()
self.assertEqual(
out,
self.error,
msg=
"Fail to find correct error. The error should be {0}, but we got : {1}"
.format(self.error, out))
self.log.info(
"Got correct error - {0}....Passing the test".format(out))
else:
self.log.info(
"Node {0} is referred via IP. Changing the name of the node"
.format(self.servers[0:1]))
hostname = []
info = self.shell.extract_remote_info()
domain = ''.join(info.domain[0])
hostname.append(info.hostname[0] + "." + domain)
self.convert_to_hostname(self, self.servers[0:1])
self.log.info(
"Calling get_node_self() to check the status of node {0}".
format(self.servers[0:1]))
obj = RestConnection(self.master)
var = obj.get_nodes_self().hostname
flag = True if self.master.ip in var else False
self.assertEqual(
flag,
False,
msg="Fail - Node {0} is still referred via IP. Should\
have been referred via hostname. Failing the test!"
.format(self.master.ip))
self.log.info(
"Name of node {0} got converted to hostname. Proceeding......!"
.format(self.master.ip))
self.sleep(10)
self.log.info(
"Now changing name of node {0} from hostname to IP".format(
self.master.ip))
var = obj.rename_node(username='******',
password='******',
port='',
hostname=self.master.ip)
self.log.info(
"Calling get_node_self() to check the status of the node {0}"
.format(self.master.ip))
var = obj.get_nodes_self().hostname
flag = True if self.master.ip in var else False
self.assertEqual(
flag,
True,
msg=
"Fail - Node {0} is still referred via hostname. Should have been referred via IP. Failing the test!"
.format(self.master.ip))
self.log.info("Node {0} referred via IP. Pass !".format(
self.master.ip))
finally:
self.shell.disconnect()
@staticmethod
def convert_to_hostname(self,
servers_with_hostnames,
username='******',
password='******'):
try:
hostname = []
for server in servers_with_hostnames:
shell = RemoteMachineShellConnection(server)
info = shell.extract_remote_info()
domain = ''.join(info.domain[0])
if not domain:
output = shell.execute_command_raw('nslookup %s' %
info.hostname[0])
print output
self.fail(
"Domain is not defined, couchbase cannot be configured correctly. NOT A BUG. CONFIGURATION ISSUE"
)
hostname.append(info.hostname[0] + "." + domain)
master_rest = RestConnection(server)
current_hostname = master_rest.get_nodes_self().hostname
self.log.info("get_node_self function returned : {0}".format(
current_hostname))
if server.ip in current_hostname:
self.log.info(
"Node {0} is referred via IP. Need to be referred with hostname. Changing the name of the node!!"
.format(server.ip))
version = RestConnection(server).get_nodes_self().version
if version.startswith("1.8.1") or version.startswith(
"2.0.0") or version.startswith("2.0.1"):
RemoteUtilHelper.use_hostname_for_server_settings(
server)
master_rest.init_cluster()
else:
master_rest.init_cluster()
master_rest.rename_node(username=username,
password=password,
port='',
hostname=hostname[-1])
else:
self.log.info(
"Node {0} already referred via hostname. No need to convert the name"
.format(server.ip))
finally:
shell.disconnect()
return hostname
class HostnameTests(BaseTestCase):
def setUp(self):
super(HostnameTests, self).setUp()
self.builds = self.input.param("builds", "2.2.0")
self.product = self.input.param('product', 'couchbase-server')
self.is_negative_test = self.input.param('is_negative_test', False)
self.error = self.input.param('error', '')
self.name = self.input.param('name', '')
def tearDown(self):
super(HostnameTests, self).tearDown()
for server in self.servers:
self.assertTrue(RestHelper(RestConnection(server)).is_ns_server_running(timeout_in_seconds=480),
msg="ns server is not running even after waiting for 6 minutes")
self.log.info("sleep for 10 seconds to give enough time for other nodes to restart")
self.sleep(10)
def install_builds(self, builds, servers=None):
params = {}
params['product'] = 'couchbase-server'
builds_list = builds.split(";")
st = 0
end = 1
if None in servers:
servers_to_install = self.servers
else:
servers_to_install = servers
for i in builds_list:
params['version'] = i
InstallerJob().sequential_install(servers_to_install[st:end], params)
st = st + 1
end = end + 1
self.sleep(20)
super(HostnameTests, self).setUp()
def rest_api_addNode(self):
hostnames = self.convert_to_hostname(self, self.servers[0:2])
master_rest = RestConnection(self.master)
master_rest.add_node(self.servers[1].rest_username, self.servers[1].rest_password, hostnames[1], self.servers[1].port)
#Now check whether the node which we added is still referred via hostname or not.
obj = RestConnection(self.servers[1])
var = obj.get_nodes_self().hostname
flag = True if self.servers[1].ip in var else False
self.assertEqual(flag, False, msg="Fail - Name of node {0} got converted to IP. Failing the test!!!".format(self.servers[1].ip))
self.log.info("Test Passed!!")
self.sleep(10)
#Cases 39 and 40 from hostname management test plan combined.
def rest_api_renameNode(self):
try:
self.shell = RemoteMachineShellConnection(self.master)
#com_inst_build = "cat /opt/couchbase/VERSION.txt"
#out = self.shell.execute_command(com_inst_build.format(com_inst_build))
self.install_builds(self.builds, self.servers[0:1])
if self.is_negative_test:
master_rest = RestConnection(self.master)
self.log.info("Renaming node {0} to {1}".format(self.master, self.name))
var = master_rest.rename_node(username=self.master.rest_username, password=self.master.rest_password,
port=self.master.port, hostname=self.name, is_negative_test=True)
out = var.pop()
self.assertEqual(out, self.error, msg="Fail to find correct error. The error should be {0}, but we got : {1}".format(self.error, out))
self.log.info("Got correct error - {0}....Passing the test".format(out))
else:
self.log.info("Node {0} is referred via IP. Changing the name of the node".format(self.servers[0:1]))
hostname = []
info = self.shell.extract_remote_info()
domain = ''.join(info.domain[0])
hostname.append(info.hostname[0] + "." + domain)
self.convert_to_hostname(self, self.servers[0:1])
self.log.info("Calling get_node_self() to check the status of node {0}".format(self.servers[0:1]))
obj = RestConnection(self.master)
var = obj.get_nodes_self().hostname
flag = True if self.master.ip in var else False
self.assertEqual(flag, False, msg="Fail - Node {0} is still referred via IP. Should\
have been referred via hostname. Failing the test!".format(self.master.ip))
self.log.info("Name of node {0} got converted to hostname. Proceeding......!".format(self.master.ip))
self.sleep(10)
self.log.info("Now changing name of node {0} from hostname to IP".format(self.master.ip))
var = obj.rename_node(username='******', password='******', port='', hostname=self.master.ip)
self.log.info("Calling get_node_self() to check the status of the node {0}".format(self.master.ip))
var = obj.get_nodes_self().hostname
flag = True if self.master.ip in var else False
self.assertEqual(flag, True, msg="Fail - Node {0} is still referred via hostname. Should have been referred via IP. Failing the test!".format(self.master.ip))
self.log.info("Node {0} referred via IP. Pass !".format(self.master.ip))
finally:
self.shell.disconnect()
@staticmethod
def convert_to_hostname(self, servers_with_hostnames, username='******', password='******'):
try:
hostname = []
for server in servers_with_hostnames:
shell = RemoteMachineShellConnection(server)
info = shell.extract_remote_info()
domain = ''.join(info.domain[0])
if not domain:
output = shell.execute_command_raw('nslookup %s' % info.hostname[0])
print output
self.fail("Domain is not defined, couchbase cannot be configured correctly. NOT A BUG. CONFIGURATION ISSUE")
hostname.append(info.hostname[0] + "." + domain)
master_rest = RestConnection(server)
current_hostname = master_rest.get_nodes_self().hostname
self.log.info("get_node_self function returned : {0}".format(current_hostname))
if server.ip in current_hostname:
self.log.info("Node {0} is referred via IP. Need to be referred with hostname. Changing the name of the node!!".format(server.ip))
version = RestConnection(server).get_nodes_self().version
if version.startswith("1.8.1") or version.startswith("2.0.0") or version.startswith("2.0.1"):
RemoteUtilHelper.use_hostname_for_server_settings(server)
master_rest.init_cluster()
else:
master_rest.init_cluster()
master_rest.rename_node(username=username, password=password, port='', hostname=hostname[-1])
else:
self.log.info("Node {0} already referred via hostname. No need to convert the name".format(server.ip))
finally:
shell.disconnect()
return hostname
def _backup_with_tool(self, namespaces, include, config_args, backup_args, use_https=False):
remote_client = RemoteMachineShellConnection(self.backup_node)
os_platform = remote_client.extract_remote_info().type.lower()
if os_platform == 'linux':
if remote_client.nonroot:
self.cli_command_location = testconstants.LINUX_NONROOT_CB_BIN_PATH
else:
self.cli_command_location = testconstants.LINUX_COUCHBASE_BIN_PATH
self.backup_path = testconstants.LINUX_BACKUP_PATH
elif os_platform == 'windows':
self.cmd_ext = ".exe"
self.cli_command_location = \
testconstants.WIN_COUCHBASE_BIN_PATH_RAW
self.backup_path = testconstants.WIN_BACKUP_C_PATH
elif os_platform == 'mac':
self.cli_command_location = testconstants.MAC_COUCHBASE_BIN_PATH
self.backup_path = testconstants.LINUX_BACKUP_PATH
else:
raise Exception("OS not supported.")
command = self.cli_command_location + "cbbackupmgr config --archive {0} --repo backup_{1} {2}".format(
self.backup_path, self.rand, self.disabled_services)
if not config_args:
config_args = "--include-data " if include else " --exclude-data "
if namespaces:
namespaces = ["{0}.{1}".format(self.backup_bucket, namespace)
for namespace in namespaces]
config_args += ",".join(namespaces)
else:
if isinstance(self.backup_bucket, list):
config_args += ",".join(self.backup_bucket)
else:
config_args += self.backup_bucket
command += " {0}".format(config_args)
output, error = remote_client.execute_command(command)
remote_client.log_command_output(output, error)
if error or not [
x for x in output
if 'created successfully in archive' in x] and not [
x for x in output
if "`backup_" + str(self.rand) + "` exists" in x]:
self.is_backup_exists = False
return self.is_backup_exists, output
if use_https:
cmd = f"cbbackupmgr backup --archive {self.backup_path} --repo backup_{self.rand} " \
f"--cluster couchbases://{self.backup_node.ip} --username {self.backup_node.rest_username} " \
f"--password {self.backup_node.rest_password} --no-ssl-verify"
else:
cmd = f"cbbackupmgr backup --archive {self.backup_path} --repo backup_{self.rand} " \
f"--cluster couchbase://{self.backup_node.ip} --username {self.backup_node.rest_username} " \
f"--password {self.backup_node.rest_password}"
command = "{0}{1}".format(self.cli_command_location, cmd)
if backup_args:
command += " {0}".format(backup_args)
self.log.info(f"Backing-up using command: {command}")
output, error = remote_client.execute_command(command)
remote_client.log_command_output(output, error)
if error or not [x for x in output if 'Backup successfully completed'
in x or 'Backup completed successfully' in x]:
self.is_backup_exists = False
return self.is_backup_exists, output
self.is_backup_exists = True
return self.is_backup_exists, output
def reset_firewall(self,server):
shell = RemoteMachineShellConnection(server)
shell.info = shell.extract_remote_info()
o, r = shell.execute_command("/sbin/iptables --flush")
shell.log_command_output(o, r)
shell.disconnect()
