def check_node_exists(self, *args, **kwargs):
"""
Check if node already exists and provision status is Ready
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) IP: IP of the Node
[Returns]
(bool) True: if IP matches the node host in the list of nodes
else False: if doesnot exists
(dict) Error response: If Exception occured
"""
self._load_kwargs(kwargs)
banner("PCC.Check node exists")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
node_list = pcc.get_nodes(conn)['Result']['Data']
print("node_list_status: {}".format(node_list))
try:
if node_list == None:
return False
for node in node_list:
print("Node in check node exists: {}".format(node))
if (str(node['Host']) == str(self.IP)) and (str(
node['provisionStatus']) == 'Ready'):
return True
return False
except Exception as e:
print("In exception of check node exists" + str(e))
return {"Error": str(e)}
def verify_node_roles_on_nodes(self, *args, **kwargs):
"""
Verify node role on Nodes
[Args]
(list) nodes: name of pcc nodes
(list) roles: name of roles
[Returns]
(dict) Response: OK if node role exists on the node (includes any errors)
"""
self._load_kwargs(kwargs)
print("kwargs:-"+str(kwargs))
banner("PCC.Verify Node Role On Nodes")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
node_role_id = self.get_node_role_id(conn,Name= self.Name)
for node in ast.literal_eval(self.nodes):
print("Node from user is: {}".format(node))
response = pcc.get_nodes(conn)
for data in get_response_data(response):
self.Id=data['Id']
self.Host=data['Host']
print("node name from pcc: {}".format(data['Name']).lower())
if str(data['Name']).lower() == str(node).lower():
if data['roles'] == None:
return "No roles present on node"
if node_role_id in data['roles']:
return "OK"
else:
return "Node role {} not present on node: {}".format(self.Name, node)
def wait_until_node_ready(self, *args, **kwargs):
"""
Wait Until Node Ready
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) Name: Name of the Node
[Returns]
(dict) Wait Time
(dict) Error response: If Exception occured
"""
self._load_kwargs(kwargs)
banner("PCC.Wait Until Node Ready")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
ready = False
time.sleep(10)
time_waited = 0
PCC_TIMEOUT = 60 * 10 #10 minutes
timeout = time.time() + PCC_TIMEOUT
while not ready:
ready = False
node_list = pcc.get_nodes(conn)['Result']['Data']
for node in node_list:
if str(node['Name']) == str(self.Name):
if node['provisionStatus'] == 'Ready':
trace("Node:{} is ready".format(self.Name))
return "OK"
if "fail" in node['provisionStatus']:
return "Wait until node ready status - Failed. Node Status is {}".format(
node['provisionStatus'])
if time.time() > timeout:
return {"Error": "Timeout"}
if not ready:
trace("Node:{} is not yet ready".format(self.Name))
time.sleep(5)
time_waited += 5
def validate_tenant_assigned_to_node(self, *args, **kwargs):
"""
Validate tenant assigned to Node
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) Name: Name of the Node
(str) Tenant_Name : Name of the tenant
[Returns]
"OK": If tenant assigned to Node
else: "Not assigned" : If tenant not assigned to node
"""
self._load_kwargs(kwargs)
banner("Validate Tenant Assigned to Node")
print("Kwargs are:{}".format(kwargs))
conn = BuiltIn().get_variable_value("${PCC_CONN}")
nodes_response = pcc.get_nodes(conn)['Result']['Data']
try:
for node in nodes_response:
if str(node['Name']) == str(self.Name):
if node['tenant'] == str(self.Tenant_Name):
return "OK"
return "Not assigned"
except Exception as e:
return {"Error": str(e)}
def wait_until_node_deleted(self, *args, **kwargs):
"""
Wait Until Node Deleted
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) Name: Name of the Node
[Returns]
(dict) Wait time
(dict) Error response: If Exception occured
"""
self._load_kwargs(kwargs)
banner("PCC.Wait Until Node Deleted")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
found = True
time_waited = 0
timeout = time.time() + PCC_TIMEOUT
try:
while found:
node_list = pcc.get_nodes(conn)['Result']['Data']
if node_list == None:
return "OK"
if re.search(self.Name, str(node_list)):
trace("Node:{} not yet deleted".format(self.Name))
time.sleep(3)
if time.time() > timeout:
return {"Error": "Timeout"}
else:
return "OK"
except Exception as e:
return "Exception encountered: {}".format(e)
def wait_until_PXE_booted_node_added(self, *args, **kwargs):
banner("PCC.Wait until pxe booted node added to PCC")
self._load_kwargs(kwargs)
logger.console("Kwargs are: {}".format(kwargs))
conn = BuiltIn().get_variable_value("${PCC_CONN}")
notfound = True
counter = 0
while notfound:
counter += 1
node_list = pcc.get_nodes(conn)['Result']['Data']
logger.console(
"Counter {}: Pxe-booted server not added yet to PCC".format(
counter))
if counter <= 300:
time.sleep(5)
for node in node_list:
if node['Name'] == self.Name:
notfound = False
logger.console("Pxe-booted server added to PCC")
return "OK"
else:
logger.console("Pxe-booted server not found")
break
return "Error: Pxe-booted server not found"
def add_and_verify_tags_on_nodes(self, *args, **kwargs):
"""
Add Roles and Verify Tags to Nodes
[Args]
(list) nodes: name of pcc nodes
(list) tags: name of tags
[Returns]
(dict) Response: Add Node tags response (includes any errors)
"""
self._load_kwargs(kwargs)
print("kwargs:-" + str(kwargs))
banner("PCC.Add and Verify Tags On Nodes")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
for node in eval(str(self.nodes)):
response = pcc.get_nodes(conn)
for data in get_response_data(response):
self.Id = data['Id']
self.Host = data['Host']
if str(data['Name']).lower() == str(node).lower():
payload = {
"Id": self.Id,
"Host": self.Host,
"tags": eval(str(self.tags))
}
print("Payload:-" + str(payload))
api_response = pcc.modify_node(conn, payload)
print("API Response:-" + str(api_response))
if api_response['Result']['status'] == 200:
continue
else:
return api_response
return "OK"
def get_nodes(self, *args, **kwargs):
"""
Get Nodes
[Args]
None
[Returns]
(dict) Response: Get Node response (includes any errors)
"""
self._load_kwargs(kwargs)
banner("PCC.Get Nodes ")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
return pcc.get_nodes(conn)
def add_and_verify_roles_on_nodes(self, *args, **kwargs):
"""
Add Roles and Verify to Nodes
[Args]
(list) nodes: name of pcc nodes
(list) roles: name of roles
[Returns]
(dict) Response: Add Node Role response (includes any errors)
"""
self._load_kwargs(kwargs)
print("kwargs:-" + str(kwargs))
banner("PCC.Add and Verify Roles On Nodes")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
payload = None
tmp_id = None
for node in eval(str(self.nodes)):
role_ids = []
response = pcc.get_nodes(conn)
for data in get_response_data(response):
self.Id = data['Id']
self.Host = data['Host']
if str(data['Name']).lower() == str(node).lower():
for role in eval(str(self.roles)):
tmp_id = easy.get_node_role_id_by_name(conn, str(role))
print("Role-Id:-" + str(role) + "-" + str(tmp_id))
role_ids.append(tmp_id)
trace("role_ids : {}".format(role_ids))
if "scopeId" not in kwargs:
trace("Node id is :{}".format(str(data['Id'])))
get_node_response = pcc.get_node_by_id(
conn, str(data['Id']))
trace("get_node_response: {}".format(
str(get_node_response)))
self.scopeId = int(
get_node_response['Result']['Data']["scopeId"])
payload = {
"Id": self.Id,
"Host": self.Host,
"roles": role_ids,
"scopeId": self.scopeId
}
print("Payload:-" + str(payload))
api_response = pcc.modify_node(conn, payload)
print("API Response:-" + str(api_response))
if api_response['Result']['status'] == 200:
continue
else:
return api_response
return "OK"
def assign_node_group_to_node(self, *args, **kwargs):
"""
Assign Node Group to Node
[Args]
(int) Id : Node group Id
[Returns]
(dict) Response: Get Node response after Node group is assigned (includes any errors)
"""
self._load_kwargs(kwargs)
banner("PCC.Assign Node Group to Node")
node_payload = {"ClusterId": int(self.Id), "Id": int(self.node_id)}
conn = BuiltIn().get_variable_value("${PCC_CONN}")
response = pcc.modify_node(conn, data=node_payload)
return pcc.get_nodes(conn)
def check_provision_ready_status(self, *args, **kwargs):
banner("PCC.Check Provision Ready Status")
self._load_kwargs(kwargs)
conn = BuiltIn().get_variable_value("${PCC_CONN}")
node_list = pcc.get_nodes(conn)['Result']['Data']
try:
for node in node_list:
if str(node['Name']) == str(self.Name):
return node['ready']
return None
except Exception as e:
return {"Error": str(e)}
def get_host_name_by_ip(conn: dict, ip: str) -> str:
"""
Get HostName by IP
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) Ip: IP of the Host Node
[Returns]
(dict) Error response: If Exception occured
"""
node_list = pcc.get_nodes(conn)['Result']['Data']
try:
for node in node_list:
if str(node['Host']) == str(ip):
return node['Name']
return None
except Exception as e:
return {"Error": str(e)}
def get_node_id_by_name(conn: dict, Name: str) -> int:
"""
Get Node Id by Name
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) Name: Name of the Node
[Returns]
(int) Id: Id of the matchining Node, or
None: if no match found, or
(dict) Error response: If Exception occured
"""
node_list = pcc.get_nodes(conn)['Result']['Data']
try:
for node in node_list:
if str(node['Name']) == str(Name):
return node['Id']
return None
except Exception as e:
return {"Error": str(e)}
def wait_until_node_ready(self, *args, **kwargs):
"""
Wait Until Node Ready
[Args]
(str) Name: Name of the Node
[Returns]
(str) Ok
(str) Error response: If Exception occured
"""
self._load_kwargs(kwargs)
print("kwargs:-" + str(kwargs))
banner("PCC.Wait Until Roles Ready On Nodes")
ready = False
status = None
timeout = time.time() + PCC_TIMEOUT
conn = BuiltIn().get_variable_value("${PCC_CONN}")
time.sleep(10)
while not ready:
ready = False
node_list = pcc.get_nodes(conn)['Result']['Data']
tmp_response = None
for node in node_list:
if str(node['Name']).lower() == str(self.node_name).lower():
tmp_response = node
status = node['provisionStatus']
if node['provisionStatus'] == 'Ready':
print("Node Response:-" + str(node))
ready = True
return "OK"
elif re.search("failed", str(node['provisionStatus'])):
print("Node Response:-" + str(node))
return "Failed"
if time.time() > timeout:
print("Node Response:" + str(tmp_response))
return {"Error": "Timeout"}
if not ready:
trace("Waiting until node: %s is Ready, currently status: %s" %
(self.node_name, status))
time.sleep(5)
def validate_node_group_assigned_to_node(self, *args, **kwargs):
"""
Validate Node Group assigned to Node
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) Name: Name of the Node
(str) Id : Id of the node group
[Returns]
"OK": If node group assigned to Node
else: "Not assigned" : If node group not assigned to node
"""
self._load_kwargs(kwargs)
banner("PCC.Validate Node Group Assigned to Node")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
nodes_response = pcc.get_nodes(conn)['Result']['Data']
try:
for node in nodes_response:
if str(node['Name']) == str(self.Name):
if node['ClusterId'] == int(self.Id):
return "OK"
return "Not assigned"
except Exception as e:
return {"Error": str(e)}
def wait_until_all_nodes_are_ready(self, *args, **kwargs):
"""
Wait Until Node Ready
[Args]
(dict) conn: Connection dictionary obtained after logging in
(str) Name: Name of the Node
[Returns]
(dict) Wait Time
(dict) Error response: If Exception occured
"""
self._load_kwargs(kwargs)
banner("PCC.Wait Until All Nodes are Ready")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
all_node_list = pcc.get_nodes(conn)['Result']['Data']
node_ready_status = []
try:
for node_name in all_node_list:
ready = False
time_waited = 0
PCC_TIMEOUT = 60 * 10 #10 minutes
timeout = time.time() + PCC_TIMEOUT
while not ready:
ready = False
node_list = pcc.get_nodes(conn)['Result']['Data']
for node in node_list:
if str(node['Name']) == str(node_name['Name']):
if node['provisionStatus'] == 'Ready':
trace("Node:{} is ready".format(
node_name['Name']))
node_ready_status.append("OK")
ready = True
break
if "fail" in node['provisionStatus']:
node_ready_status.append("Failed:{}".format(
node['Name']))
trace(
"Wait until node ready status - Failed on node {}. Node Status is {}"
.format(node_name['Name'],
node['provisionStatus']))
print(
"Wait until node ready status - Failed on node {}. Node Status is {}"
.format(node_name['Name'],
node['provisionStatus']))
ready = True
break
if time.time() > timeout:
print("Error: Timeout for node {}".format(
node_name['Name']))
node_ready_status.append("Timeout: {}".format(
node_name['Name']))
ready = True
break
if not ready:
trace("Node:{} is not yet ready".format(
node_name['Name']))
time.sleep(5)
time_waited += 5
node_ready_result = len(node_ready_status) > 0 and all(
elem == "OK" for elem in node_ready_status)
if node_ready_result:
return "OK"
else:
return "Wait Until Node ready status is: {}".format(
node_ready_status)
except Exception as e:
return "Exception encountered: {}".format(e)
def delete_and_verify_roles_on_nodes(self, *args, **kwargs):
"""
Delete Roles and Verify to Nodes
[Args]
(list) nodes: name of pcc nodes
(list) roles: name of roles
[Returns]
(dict) Response: Add Node Role response (includes any errors)
"""
self._load_kwargs(kwargs)
print("kwargs:-" + str(kwargs))
banner("PCC.Delete and Verify Roles On Nodes")
conn = BuiltIn().get_variable_value("${PCC_CONN}")
payload = None
tmp_id = None
response_code_list = []
for node in eval(str(self.nodes)):
print(
"***************** On node from user: {} ********************"
.format(node))
response = pcc.get_nodes(conn)
for data in get_response_data(response):
self.Id = data['Id']
role_ids = data['roles']
print(
"***************** node from pcc: {} ********************".
format(data['Name'].lower()))
if str(data['Name']).lower() == str(node).lower():
print("Role_Ids_On_Node:-" + str(role_ids))
if role_ids:
for role in eval(str(self.roles)):
tmp_id = easy.get_node_role_id_by_name(
conn, str(role))
print("Role-Id to Remove:-" + str(role) + "-" +
str(tmp_id))
if tmp_id in eval(str(role_ids)):
role_ids.remove(tmp_id)
if "scopeId" not in kwargs:
trace("Node id is :{}".format(str(data['Id'])))
get_node_response = pcc.get_node_by_id(
conn, str(data['Id']))
trace("get_node_response: {}".format(
str(get_node_response)))
self.scopeId = int(
get_node_response['Result']['Data']["scopeId"])
payload = {
"Id": self.Id,
"roles": role_ids,
"scopeId": self.scopeId
}
print("Payload:-" + str(payload))
api_response = pcc.modify_node(conn, payload)
print("API Response:-" + str(api_response))
if api_response['StatusCode'] == 200:
print("Required roles deleted for {}".format(node))
response_code_list.append(
str(api_response['StatusCode']))
continue
else:
return api_response
else:
print("No roles present of node: {}".format(node))
result = len(response_code_list) > 0 and all(
elem == "200" for elem in response_code_list)
if result:
return "OK"
else:
return "Error in removing node roles: {}".format(
response_code_list)
