def get_ceph_state_nodes(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Ceph Get State Nodes: {}".format(self.state))
print("Kwargs:" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
cluster_id = easy.get_ceph_cluster_id_by_name(conn, self.name)
print("Cluster Name: {} Id: {}".format(self.name, cluster_id))
nodes = []
nodes_name = []
response = pcc.get_ceph_clusters_state(conn, str(cluster_id),
str(self.state))
trace("Response:" + str(response))
if self.state.lower() == 'mds':
for val in get_response_data(response)['nodes']:
if self.state_status:
if re.search(self.state_status, val['state']):
nodes_name.append(val['name'])
nodes.append(easy.get_hostip_by_name(
conn, val['name']))
else:
nodes_name.append(val['name'])
nodes.append(easy.get_hostip_by_name(conn, val['name']))
else:
for data in get_response_data(response):
print("Data:" + str(data))
nodes_name.append(data['server'])
nodes.append(easy.get_hostip_by_name(conn, data['server']))
nodes = list(set(nodes))
print("{} Nodes Host IP's: {}".format(self.state, str(nodes)))
print("{} Nodes Name: {}".format(self.state, str(nodes_name)))
trace("{} Nodes: {}".format(self.state, str(nodes)))
return nodes
def rsyslog_server_configuration(self,*args,**kwargs):
banner("CLI.Rsyslog Server Configuration")
self._load_kwargs(kwargs)
trace("Kwargs are: " + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
if self.rsys_server:
server_ip=easy.get_hostip_by_name(conn,self.rsys_server)
print("Server Host Ip: "+str(server_ip))
trace("Server Host Ip: "+str(server_ip))
if self.rsys_tls.lower()=="yes":
path=os.getcwd()+"/tests/test-data/rsyslog/tls"
print("----------------Copying Rsyslog Config File For TLS----------------")
trace("----------------Copying Rsyslog Config File For TLS----------------")
changing_perm="sudo chmod 777 /etc"
cmd_out = cli_run(server_ip, self.linux_user, self.linux_password, changing_perm)
cmd_config="sudo sshpass -p 'cals0ft' scp -o StrictHostKeyChecking=no {}/rsyslog.conf pcc@{}:/etc/".format(path,server_ip)
print("Command for transferriddng rsyslog config file for TLS: "+str(cmd_config))
trace("Command for transferring rsyslog config file for TLS: "+str(cmd_config))
cmd_out = os.system(cmd_config)
print("-----------Verifying if folder exist for server files-----------------")
trace("-----------Verifying if folder exist for server files-----------------")
cmd_dir="sudo test -d /etc/pki/tls/private && echo 'True' || echo 'False'"
cmd_out=cli_run(server_ip,self.linux_user,self.linux_password,cmd_dir)
print("----------------------------------------------------------------------")
if re.search("False", str(cmd_out)):
folder_cmd = "sudo mkdir -p /etc/pki/tls/private"
cmd_out = cli_run(server_ip, self.linux_user, self.linux_password, folder_cmd)
changing_perm="sudo chmod 777 /etc/pki/tls/private"
cmd_out = cli_run(server_ip, self.linux_user, self.linux_password, changing_perm)
print("-----------Copying server files-----------------")
trace("-----------Copying server files-----------------")
cmd_transfer = "sudo sshpass -p 'cals0ft' scp -o StrictHostKeyChecking=no {}/*.pem pcc@{}:/etc/pki/tls/private/.".format(path,server_ip)
print("Command for transferring server files : "+str(cmd_transfer))
trace("Command for transferring server files : "+str(cmd_transfer))
cmd_out = cli_run(server_ip, self.linux_user, self.linux_password, cmd_transfer)
print("------------------------------------------------")
else:
changing_perm="sudo chmod 777 /etc/pki/tls/private"
cmd_out = cli_run(server_ip, self.linux_user, self.linux_password, changing_perm)
print("-----------Copying server files-----------------")
trace("-----------Copying server files-----------------")
cmd_transfer = "sudo sshpass -p 'cals0ft' scp -o StrictHostKeyChecking=no {}/*.pem pcc@{}:/etc/pki/tls/private/.".format(path,server_ip)
print("Command for transferring server files : "+str(cmd_transfer))
trace("Command for transferring server files : "+str(cmd_transfer))
cmd_out = os.system(cmd_transfer)
else:
path=os.getcwd()+"/tests/test-data/rsyslog/non_tls"
changing_perm="sudo chmod 777 /etc"
cmd_out = cli_run(server_ip, self.linux_user, self.linux_password, changing_perm)
print("-----------Copying Rsyslog Config File For Non TLS-----------------")
trace("-----------Copying Rsyslog Config File For Non TLS-----------------")
cmd_config="sudo sshpass -p 'cals0ft' scp -o StrictHostKeyChecking=no {}/rsyslog.conf pcc@{}:/etc/.".format(path,server_ip)
print("Command for transferring rsyslog config file for non TLS: " + str(cmd_config))
trace("Command for transferring rsyslog config file for non TLS: " + str(cmd_config))
cmd_out = os.system(cmd_config)
print("------------------------------------------------")
return "OK"
def ping_check(self, *args, **kwargs):
self._load_kwargs(kwargs)
print("Kwargs:" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
failed_check = []
if self.node_names:
for node in eval(str(self.node_names)):
host_ip = easy.get_hostip_by_name(conn, node)
if type(host_ip) == str:
ping_cmd = "sudo ping {} -c 4".format(host_ip)
ping_execute = cli_run(cmd=ping_cmd,
host_ip=host_ip,
linux_user=self.username,
linux_password=self.password)
ping_serialize = self._serialize_response(
time.time(), ping_execute)
output = str(ping_serialize['Result']['stdout']).replace(
'\n', '').strip()
print("-------Ping Output for {}--------".format(node))
print(output)
if ", 0% packet loss" in output:
continue
else:
failed_check.append(node)
if failed_check:
print("Could not verify ping test for {}".format(failed_check))
return "Could not verify ping test for {}".format(failed_check)
else:
return "OK"
else:
print("node_names argument is missing")
return "node_name argument is missing"
def make_ceph_osds_up(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Ceph Make Osds Up : {}".format(self.name))
print("Kwargs:" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
cluster_id = easy.get_ceph_cluster_id_by_name(conn, self.name)
print("Cluster Name: {} Id: {}".format(self.name, cluster_id))
response = pcc.get_ceph_clusters_state(conn, str(cluster_id), 'osds')
host_ip = None
for data in get_response_data(response):
print("Data:" + str(data))
trace("Data:" + str(data))
print("Server:" + str(data['server']))
print("Osd Id:" + str(data['osd']))
host_ip = easy.get_hostip_by_name(conn, data['server'])
print("Host Ip:" + str(host_ip))
cmd = "sudo systemctl -f restart ceph-osd@{}".format(data['osd'])
cmd_exec = cli_run(host_ip, self.user, self.password, cmd)
print("cmd:" + str(cmd))
print("cmd output:" + str(cmd_exec))
time.sleep(10)
cmd_verify = "sudo ceph osd tree|grep osd.{} |grep up|wc -l".format(
data['osd'])
cmd_verify_exec = cli_run(host_ip, self.user, self.password,
cmd_verify)
serialise_output = self._serialize_response(
time.time(), cmd_verify_exec)['Result']['stdout']
print("cmd:" + str(cmd_verify))
print("cmd output:" + str(cmd_verify_exec))
print("Serialise Output:" + str(serialise_output))
if int(serialise_output) == 1:
print("{} ods id {} up sucessfully !!!".format(
data['server'], data['osd']))
continue
else:
print("Command execution could not make osd id {} up".format(
data['osd']))
return "Error"
return "OK"
def cephi_mgr_reboot_and_verify(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Ceph Reboot Manager And Verify")
print("Kwargs:" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
manager_node_cmd = 'sudo ceph -s |grep mgr | cut -d "," -f1 | cut -d ":" -f2|cut -d "(" -f1'
node = self._serialize_response(
time.time(),
cli_run(self.hostip, self.user, self.password, manager_node_cmd))
print("Node Info:" + str(node))
node_name = str(node["Result"]["stdout"]).strip()
print("Reboot node name:" + str(node_name))
node_ip = easy.get_hostip_by_name(conn, node_name)
print("Reboot node ip:" + str(node_ip))
if type(node_ip) != str:
print("Unable to fetch host ip of " + str(node))
return "Error"
print("Rebooting host " + str(node_ip))
trace("Rebooting host " + str(node_ip))
cmd = "sudo reboot"
restart_cmd = cli_run(node_ip, self.user, self.password, cmd)
banner("Sleeping")
time.sleep(180)
banner("Done sleeping")
cmd = "ping {} -c 4".format(node_ip)
restart_up_status = cli_run(node_ip, self.user, self.password, cmd)
if re.search("0% packet loss", str(restart_up_status)):
cmd = "sudo systemctl status ceph-mgr@{}".format(node_name)
cmd_output = cli_run(node_ip, self.user, self.password, cmd)
if re.search("active", str(cmd_output)):
return "OK"
else:
print(cmd_output)
return "Error"
else:
print("Unable to reboot {}".format(node_ip))
return "Error"
def ceph_active_manager(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Ceph Active Manager And Verify")
print("Kwargs:" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
trace("Connection:{}".format(conn))
except Exception as e:
raise e
manager_node_cmd = 'sudo ceph -s |grep mgr | cut -d "," -f1 | cut -d ":" -f2|cut -d "(" -f1'
trace("Manager node:{}".format(manager_node_cmd))
node = self._serialize_response(
time.time(),
cli_run(self.hostip, self.user, self.password, manager_node_cmd))
trace("Node Info:" + str(node))
node_name = str(node["Result"]["stdout"]).strip()
trace("Active Manager node name:" + str(node_name))
node_ip = easy.get_hostip_by_name(conn, node_name)
print("Active manager node ip:" + str(node_ip))
if type(node_ip) != str:
print("Unable to fetch host ip of " + str(node))
return "Error"
else:
return node_ip