def upgrade_kubernetes_by_id(self, *args, **kwargs):
banner("PCC.K8s Upgrade Cluster")
self._load_kwargs(kwargs)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
tmp_pool = []
if self.pools:
for pool in eval(str(self.pools)):
tmp_pool.append(easy.get_ceph_pool_id_by_name(conn, pool))
self.pools = tmp_pool
if self.networkClusterName:
self.networkClusterId = easy.get_network_clusters_id_by_name(
conn, self.networkClusterName)
payload = {
"k8sVersion": self.k8sVersion,
"pools": self.pools,
"networkClusterId": self.networkClusterId
}
if self.cluster_id == None:
raise Exception(
"[PCC.Upgrade Cluster]: cluster id is not specified.")
else:
return pcc.upgrade_kubernetes_by_id(conn, str(self.cluster_id),
payload)
def add_kubernetes(self, *args, **kwargs):
banner("PCC.K8s Create Cluster")
self._load_kwargs(kwargs)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
tmp_node = []
for node_name in eval(str(self.nodes)):
node_id = easy.get_node_id_by_name(conn, node_name)
tmp_node.append({"id": node_id})
self.nodes = tmp_node
tmp_pool = []
if self.pools:
for pool in eval(str(self.pools)):
tmp_pool.append(easy.get_ceph_pool_id_by_name(conn, pool))
self.pools = tmp_pool
if self.networkClusterName:
self.networkClusterId = easy.get_network_clusters_id_by_name(
conn, self.networkClusterName)
payload = {
"id": int(self.id),
"k8sVersion": self.k8sVersion,
"cniPlugin": self.cniPlugin,
"name": self.name,
"nodes": self.nodes,
"pools": self.pools,
"networkClusterId": self.networkClusterId
}
print("paylod:-" + str(payload))
return pcc.add_kubernetes(conn, payload)
def add_ceph_cluster(self, *args, **kwargs):
banner("PCC.Ceph Create Cluster")
self._load_kwargs(kwargs)
print("Kwargs:" + str(kwargs))
conn = BuiltIn().get_variable_value("${PCC_CONN}")
tmp_node = []
for node_name in eval(str(self.nodes)):
print("Getting Node Id for -" + str(node_name))
node_id = easy.get_node_id_by_name(conn, node_name)
print(" Node Id retrieved -" + str(node_id))
tmp_node.append({"id": node_id})
self.nodes = tmp_node
if self.tags:
self.tags = eval(str(self.tags))
self.networkClusterId = easy.get_network_clusters_id_by_name(
conn, self.networkClusterName)
payload = {
"name": self.name,
"nodes": self.nodes,
"tags": self.tags,
"networkClusterId": self.networkClusterId
}
print("Payload:-" + str(payload))
return pcc.add_ceph_cluster(conn, payload)
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 modify_kubernetes_by_id(self, *args, **kwargs):
banner("PCC.K8s Update Cluster Nodes")
self._load_kwargs(kwargs)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
tmp_node = []
if len(eval(str(self.toAdd))) != 0:
for node_name in eval(str(self.toAdd)):
node_id = easy.get_node_id_by_name(conn, node_name)
tmp_node.append({"id": node_id})
self.toAdd = tmp_node
tmp_node = []
if len(eval(str(self.toRemove))) != 0:
for node_name in eval(str(self.toRemove)):
node_id = easy.get_node_id_by_name(conn, node_name)
tmp_node.append(node_id)
self.toRemove = tmp_node
payload = {
"rolePolicy": self.rolePolicy,
"toAdd": self.toAdd,
"toRemove": self.toRemove
}
print("Payload:-" + str(payload))
return pcc.modify_kubernetes_by_id(conn, str(self.cluster_id), payload)
def modify_ceph_clusters(self, *args, **kwargs):
self._load_kwargs(kwargs)
print("Kwargs:" + str(kwargs))
conn = BuiltIn().get_variable_value("${PCC_CONN}")
time.sleep(60)
tmp_node = []
payload_nodes = []
for node_name in eval(str(self.nodes)):
node_id = easy.get_node_id_by_name(conn, node_name)
tmp_node.append(node_id)
self.nodes = []
response = pcc.get_ceph_clusters(conn)
for data in get_response_data(response):
if str(data['name']).lower() == str(self.name).lower():
payload_nodes = eval(str(data['nodes']))
if not self.tags:
self.tags = data['tags']
if not self.name:
self.name = data['name']
if not self.networkClusterName:
self.networkClusterId = data['networkClusterId']
else:
self.networkClusterId = easy.get_network_clusters_id_by_name(
conn, self.networkClusterName)
for id in tmp_node:
count = 0
for data in payload_nodes:
if int(data['id']) == int(id):
self.nodes.append(data)
count = 1
if count == 0:
self.nodes.append({"id": int(id)})
if self.tags:
self.tags = eval(str(self.tags))
try:
payload = {
"id": self.id,
"name": self.name,
"nodes": self.nodes,
"tags": self.tags,
"networkClusterId": self.networkClusterId
}
print("Payload:-" + str(payload))
except Exception as e:
trace("[update_cluster] EXCEPTION: %s" % str(e))
raise Exception(e)
return pcc.modify_ceph_clusters(conn, payload)
def add_rados_gateway(self, *args, **kwargs):
banner("PCC.Rados Gateway Create")
self._load_kwargs(kwargs)
print("Kwargs:" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
if self.cephPoolID == None:
self.cephPoolID = easy.get_ceph_pool_id_by_name(
conn, self.poolName)
if self.certificateID == None:
self.certificateID = easy.get_certificate_id_by_name(
conn, self.certificateName)
if self.port:
self.port = ast.literal_eval(str(self.port))
if self.S3Accounts != None or self.S3Accounts != []:
tmp_cert = {}
for cert in eval(str(self.S3Accounts)):
cert_id = easy.get_metadata_profile_id_by_name(conn, cert)
tmp_cert[str(cert_id)] = {}
self.S3Accounts = tmp_cert
tmp_node = []
if self.targetNodes != [] or self.targetNodes != '':
for node_name in eval(str(self.targetNodes)):
print("Node Name:" + str(node_name))
node_id = easy.get_node_id_by_name(conn, node_name)
print("Node Id:" + str(node_id))
tmp_node.append(node_id)
print("Node List:" + str(tmp_node))
self.targetNodes = tmp_node
if self.service_ip.lower() == "yes":
serviceIpType = "NodeIp"
else:
serviceIpType = "Default"
payload = {
"name": self.name,
"cephPoolID": self.cephPoolID,
"targetNodes": self.targetNodes,
"port": self.port,
"certificateID": self.certificateID,
"S3Accounts": self.S3Accounts,
"serviceIpType": serviceIpType
}
print("Payload:-" + str(payload))
return pcc.add_ceph_rgw(conn, payload)
def alert_create_rule_template(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Alert Create Rule Template")
print("kwargs:-" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
tmp_node = []
for node_name in eval(str(self.nodes)):
node_id = easy.get_node_id_by_name(conn, node_name)
print("Node-Name:-" + str(node_name))
print("Node-Id:-" + str(node_id))
tmp_node.append(node_id)
self.nodeIds = tmp_node
print("Node Ids:-" + str(self.nodeIds))
if self.templateId:
self.templateId = ast.literal_eval(str(self.templateId))
payload = {
"name": self.name,
"nodeIds": self.nodeIds,
"parameter": self.parameter,
"operator": self.operator,
"value": self.value,
"time": self.time,
"templateId": self.templateId
}
print("Payload:-" + str(payload))
return pcc.add_alert_rule(conn, payload)
def verify_OS_details_from_PCC(self, *args, **kwargs):
'''
## Image
get on "pccserver/images"
fetch label by name
get details by node id
get get_node_by_id and return os version in sysytem data
search os version in label of images
'''
banner("PCC.Verify OS details from PCC")
self._load_kwargs(kwargs)
logger.console(
"kwargs in verify_OS_details_from_PCC are: {}".format(kwargs))
conn = BuiltIn().get_variable_value("${PCC_CONN}")
label_name = easy.get_os_label_by_name(conn, Name=self.image_name)
print("label name is: {}".format(label_name))
logger.console("label_name: {}".format(label_name))
OS_version = self.get_OS_version_by_node_name(**kwargs)
print("OS version is: {}".format(OS_version))
logger.console("OS_version: {}".format(OS_version))
if str(OS_version) in str(label_name):
print("OS deployed successfully")
return True
else:
print("Error in deploying OS: {} not in {}".format(
str(OS_version), str(label_name)))
return False
def get_ceph_rgw_secret_key(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Ceph Get Rgw Secret Key")
if self.name == None:
print("Ceph Rgw name is empty!!")
return "Error"
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
rados_id = easy.get_ceph_rgw_id_by_name(
conn, Name=self.name, Ceph_cluster_name=self.ceph_cluster_name)
key_data = get_response_data(
pcc.get_profiles_with_additional_data_for_specific_application(
conn, "ceph", str(rados_id)))
print("Response:" + str(key_data))
print("Secret Key:" + str(key_data[0]['profile']["secretKey"]))
if key_data[0]['profile']["secretKey"]:
return key_data[0]['profile']["secretKey"]
else:
print("Can't extract Secret Key")
return "Error"
return None
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 wait_until_rados_ready(self, *args, **kwargs):
banner("PCC.Wait Until Rados Gateway Ready")
self._load_kwargs(kwargs)
print("Kwargs" + str(kwargs))
if self.name == None:
return None
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
gateway_ready = False
timeout = time.time() + PCCSERVER_TIMEOUT
ceph_cluster_id = str(
easy.get_ceph_cluster_id_by_name(conn,
Name=self.ceph_cluster_name))
while gateway_ready == False:
response = pcc.get_ceph_rgws(conn, ceph_cluster_id)
for data in get_response_data(response):
if str(data['name']).lower() == str(self.name).lower():
print("Response To Look :-" + str(data))
trace(" Waiting until %s is Ready, current status: %s" %
(str(data['name']), str(data['deploy_status'])))
if data['deploy_status'] == "completed":
return "OK"
elif re.search("failed", str(data['deploy_status'])):
return "Error"
else:
break
if time.time() > timeout:
raise Exception("[PCC.Ceph Wait Until Rgw Ready] Timeout")
time.sleep(5)
return "OK"
def monitor_verify_node_health(self, *args, **kwargs):
banner("PCC.Monitor Verify Node Health")
self._load_kwargs(kwargs)
print("Kwargs:" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
if not self.nodes:
print("Node names can not be empty!!")
return "Error"
tmp_node = []
for node_name in eval(str(self.nodes)):
print("Getting Node Id for -" + str(node_name))
node_id = easy.get_node_id_by_name(conn, node_name)
print(" Node Id retrieved -" + str(node_id))
tmp_node.append(node_id)
self.nodes = tmp_node
payload = {"unit": "HOUR", "value": 1}
for nodeId in eval(str(self.nodes)):
health = pcc.add_monitor_cache(conn, "summary", str(nodeId),
payload)
status = health['Result']['metrics'][0]['overallStatus']['status']
if status.lower() != 'ok' and status.lower() != 'warning':
print("Health status node ID {} : {}".format(
nodeId,
health['Result']['metrics'][0]['overallStatus']['status']))
return "Error"
else:
print("NodeId:" + str(nodeId))
print("Health Status:" + str(health['Result']['metrics'][0]
['overallStatus']['status']))
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 get_ceph_version(self, *args, **kwargs):
banner("Get Ceph Version")
self._load_kwargs(kwargs)
try:
print("Kwargs are: {}".format(kwargs))
# Get Ceph Version
#cmd = "ceph -v"
#status = cli_run(cmd=cmd, host_ip=self.hostip, linux_user=self.user, linux_password=self.password)
#print("cmd: {} executed successfully and status is: {}".format(cmd, status))
#return status
banner("PCC.Get Ceph Version [Name=%s]" % self.name)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
print("conn is {}".format(conn))
ceph_ID = easy.get_ceph_cluster_id_by_name(conn, self.name)
print("ceph_ID is {}".format(ceph_ID))
ceph_node_list = pcc.get_ceph_version_list(conn, str(ceph_ID))
print("ceph_node_list is {}".format(ceph_node_list))
'''
"ceph_version":"ceph version 14.2.20 (36274af6eb7f2a5055f2d53ad448f2694e9046a0) nautilus (stable)",
"hostname":"qa-clusterhead-10"
'''
ceph_ver_list = {}
for node_data in ceph_node_list["Result"]["Data"]:
print("ceph_version of hostname {} is {} ".format(
node_data["hostname"], node_data["ceph_version"]))
ceph_ver_list[
node_data["hostname"]] = node_data["ceph_version"]
print("ceph_ver_list is {}".format(ceph_ver_list))
return ceph_ver_list
except Exception as e:
trace("Error in getting ceph version: {}".format(e))
def delete_policy(self, *args, **kwargs):
banner("PCC.Delete Policy")
self._load_kwargs(kwargs)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
appId = self.get_app_id_from_policies(conn, Name=self.Name)
Id = easy.get_policy_id(conn, Desc=self.description, AppID=appId)
return pcc.delete_policy_by_id(conn, str(Id))
def get_scope_id(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Get Scope Id")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
Id = easy.get_scope_id_by_name(conn,
Name=self.scope_name,
ParentID=self.parentID)
return Id
def delete_scope(self, *args, **kwargs):
banner("PCC.Delete Scope")
self._load_kwargs(kwargs)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
Id = easy.get_scope_id_by_name(conn,
Name=self.scope_name,
ParentID=self.parentID)
return pcc.delete_scope_by_id(conn, str(Id))
def get_policy_id(self, *args, **kwargs):
self._load_kwargs(kwargs)
logger.console("Kwargs are : {}".format(kwargs))
banner("PCC.Get Policy Id")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
appId = self.get_app_id_from_policies(conn, Name=self.Name)
logger.console("App id in get policy id is {}".format(appId))
Id = easy.get_policy_id(conn, Desc=self.description, AppID=appId)
return Id
def apply_policy(self, *args, **kwargs):
banner("PCC.Apply Policy To Scope")
self._load_kwargs(kwargs)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
payload = {}
Id = easy.get_scope_id_by_name(conn,
Name=self.scope_name,
ParentID=self.parentID)
return pcc.apply_policy(conn, str(Id), data=payload)
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 ipam_subnet_get_id(self,*args,**kwargs):
self._load_kwargs(kwargs)
banner("PCC.Ipam Subnet Get Id")
print("Kwargs:"+str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
ipam_id = easy.get_subnet_id_by_name(conn,self.name)
return ipam_id
def get_k8s_cluster_id_by_name(self, *args, **kwargs):
banner("PCC.K8s Get Cluster Id")
self._load_kwargs(kwargs)
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
cluster_id = easy.get_k8s_cluster_id_by_name(conn, self.name)
return cluster_id
def monitor_verify_interface_counts(self, *args, **kwargs):
self._load_kwargs(kwargs)
print("Kwargs:" + str(kwargs))
banner("PCC.Monitor Verify Interface Counts")
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
payload = {"unit": "HOUR", "value": 1}
if not self.nodes:
print("Node names can not be empty!!")
return "Error"
tmp_node = []
failed_chk = []
for node_name in eval(str(self.nodes)):
print("Getting Node Id for -" + str(node_name))
node_id = easy.get_node_id_by_name(conn, node_name)
print(" Node Id retrieved -" + str(node_id))
tmp_node.append(node_id)
self.nodes = tmp_node
for nodeId in self.nodes:
print("***********************************")
print("NodeID:" + str(nodeId))
for topic in eval(str(self.category)):
for ip in eval(str(self.nodes_ip)):
if topic.lower() == 'network':
cmd = "sudo ip link|cut -d' ' -f2|sed '/^$/d'|wc -l"
print("#####################################")
print("Topic:" + str(topic))
print("Topic Cmd:" + str(cmd))
print("Host:" + str(ip))
network_check = self._serialize_response(
time.time(),
cli_run(ip, self.user, self.password,
cmd))['Result']['stdout']
payload = {"unit": "HOUR", "value": 1}
data = pcc.add_monitor_cache(conn, "network",
str(nodeId), payload)
interfaces = data['Result']['metrics'][0]['interfaces']
print("Network Interfacea PCC:" + str(interfaces))
print("Interface Count Backend:" + str(network_check))
print("Interface Count API:" + str(len(interfaces)))
if len(interfaces) == int(network_check):
continue
else:
failed_chk.append(nodeId)
else:
print("Invalid Category:" + str(topic))
return "Error"
if failed_chk:
print("Could not verify the topics for Node ids: " + str())
return "Error"
else:
return "OK"
def get_node_rsop(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Get Node RSOP")
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
Id = easy.get_node_id_by_name(conn, Name=self.node_name)
except Exception as e:
return "Error in get_node_rsop: {}".format(e)
response = pcc.get_node_rsop(conn, id=str(Id))
return response
def operation_to_perform_on_all_osds_daemons_of_node(
self, *args, **kwargs):
banner("PCC.Operation to perform on All OSD Daemons Of Node")
self._load_kwargs(kwargs)
print("Kwargs are: {}".format(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
try:
if "operation_to_perform" not in kwargs:
self.operation_to_perform = None
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_name = easy.get_hostname_by_ip(conn, Hostip=self.hostip)
osd_ids = [
data['osd'] for data in get_response_data(response)
if data['server'] == host_name
]
for osd_id in osd_ids:
if self.operation_to_perform:
cmd = "sudo systemctl {} ceph-osd@{}".format(
self.operation_to_perform.lower(), osd_id)
status = cli_run(cmd=cmd,
host_ip=self.hostip,
linux_user=self.user,
linux_password=self.password)
print("Status is: {}".format(status))
time.sleep(2)
trace("Command: {} executed successfully".format(cmd))
else:
return "Please provide a valid operation to perform. Choose from 'Start', 'Stop', 'Status'"
return "OK"
except Exception as e:
trace("Error in stop_all_osds_daemons_of_node: {}".format(e))
def get_node_id(self, *args, **kwargs):
"""
Get Node Id
[Args]
(str) Name
[Returns]
(dict) Response: Get Node response (includes any errors)
"""
self._load_kwargs(kwargs)
banner("PCC.Get Node Id")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
return easy.get_node_id_by_name(conn, self.Name)
def get_ceph_rgw_id_by_name(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Ceph Get Rgw Id")
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
rados_id = easy.get_ceph_rgw_id_by_name(
conn, Name=self.name, Ceph_cluster_name=self.ceph_cluster_name)
return rados_id
def alert_get_rule_id(self, *args, **kwargs):
self._load_kwargs(kwargs)
banner("PCC.Alert Get Rule Id")
print("kwargs:-" + str(kwargs))
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
alert_id = easy.get_alert_id_by_name(conn, self.name)
return alert_id
def get_ceph_pool_id_by_name(self, *args, **kwargs):
self._load_kwargs(kwargs)
pool_id = None
banner("PCC.Ceph Get Pool Id")
try:
conn = BuiltIn().get_variable_value("${PCC_CONN}")
except Exception as e:
raise e
pool_id = easy.get_ceph_pool_id_by_name(conn, self.name)
return pool_id
