def _get_nodeinfolist(self, server_nodes_info):
##_LOGGER.info("***** START - get_nodeinfolist ***** ")
nodeinfolist = collections.OrderedDict()
default_node_info = collections.OrderedDict()
# DEFAULT NODE INFO
try:
vnodes = json.load(open(self._nodes_info_file, 'r'))
for vnode in vnodes:
NODE = {}
NODE['name'] = vnode["name"]
NODE['state'] = NodeInfo.OFF
NODE['keywords'] = {}
NODE['cpus'] = float(self._default_cpu_node)
if "cpu" in vnode:
NODE['cpus'] = int(vnode["cpu"])
NODE['memory'] = _get_memory_in_bytes(
self._default_memory_node)
if "memory" in vnode:
NODE['memory'] = _get_memory_in_bytes(vnode["memory"])
if "keywords" in vnode:
for keypair in vnode["keywords"].split(','):
parts = keypair.split('=')
NODE['keywords'][parts[0].strip()] = TypedClass(
parts[1].strip(), TypedClass.STRING)
if "queues" in vnode:
queues = vnode["queues"].split(",")
if queues:
NODE['keywords']['queues'] = TypedList(
[TypedClass.auto(q) for q in queues])
else: # All queues to the node
NODE['keywords']['queues'] = TypedList(
[TypedClass.auto(q) for q in self._queues[:]])
default_node_info[NODE['name']] = NODE
except Exception as ex:
_LOGGER.error("Error processing file %s: %s" %
(self._nodes_info_file, str(ex)))
clients_by_server = {}
for server_node in server_nodes_info:
clients_by_server[server_node] = self._get_Clients_by_Server(
server_node
) # Obtain ID, Name, Status, NodeClass and if the Client is running some job
# Obtain Resources and Queues
for client_id in clients_by_server[server_node]:
info_client = clients_by_server[server_node][client_id]
if (info_client['state'] in [NodeInfo.IDLE,
NodeInfo.USED]): # Client is ON
# Obtain Client node address for checking used resources
info_client['resources'] = self._get_Client_resources(
server_node, client_id)
if info_client[
'name'] in default_node_info: # Valid node for CLUES and IM
nodeinfolist[info_client['name']] = self._get_NodeInfo(
info_client,
default_node_info[info_client['name']])
else:
_LOGGER.warning(
"Nomad Client with name '%s' founded using Nomad Server API but not exists this node in the configuration file %s"
% (info_client['name'], self._nodes_info_file))
# Add nodes from nomad_info file to the list
for namenode, node_info in default_node_info.items():
if namenode not in nodeinfolist:
nodeinfolist[namenode] = NodeInfo(namenode, node_info['cpus'],
node_info['cpus'],
node_info['memory'],
node_info['memory'],
node_info['keywords'])
nodeinfolist[namenode].state = node_info['state']
# Print all nodes in log with keywords
for key, value in nodeinfolist.items():
string = "%s + keywords={ " % (str(value))
for key2 in value.keywords:
string += key2 + ":" + str(value.keywords[key2]) + ","
string = string[:-1] + "}"
_LOGGER.debug(string)
##_LOGGER.info("***** END - get_nodeinfolist ***** ")
return nodeinfolist
def get_nodeinfolist(self):
nodeinfolist = collections.OrderedDict()
nodes_data = self._create_request('GET', self._nodes_api_url_path,
self.auth_data)
if nodes_data:
pods_data = self._create_request('GET', self._pods_api_url_path,
self.auth_data)
if not pods_data:
_LOGGER.error(
"Error getting Kubernetes pod list. Node usage will not be obtained."
)
for node in nodes_data["items"]:
name = node["metadata"]["name"]
memory_total = self._get_memory_in_bytes(
node["status"]["allocatable"]["memory"])
slots_total = int(node["status"]["allocatable"]["cpu"])
pods_total = int(node["status"]["allocatable"]["pods"])
skip_node = False
# Get Taints
if 'taints' in node["spec"] and node["spec"]['taints']:
for taint in node["spec"]['taints']:
if taint['effect'] in [
"NoSchedule", "PreferNoSchedule", "NoExecute"
]:
skip_node = True
_LOGGER.debug(
"Node %s is tainted with %s, skiping." %
(name, taint['effect']))
if not skip_node:
used_mem, used_cpus, used_pods, system_pods = self._get_node_used_resources(
name, pods_data)
memory_free = memory_total - used_mem
slots_free = slots_total - used_cpus
pods_free = pods_total - used_pods
is_ready = True
for conditions in node["status"]["conditions"]:
if conditions['type'] == "Ready":
if conditions['status'] != "True":
is_ready = False
keywords = {
'pods_free': TypedNumber(pods_free),
'nodeName': TypedClass(name, TypedClass.STRING)
}
# Add labels as keywords
for key, value in node["metadata"]["labels"].items():
keywords[key] = TypedClass(value, TypedClass.STRING)
nodeinfolist[name] = NodeInfo(name, slots_total,
slots_free, memory_total,
memory_free, keywords)
if is_ready:
nodeinfolist[name].state = NodeInfo.IDLE
if (used_pods - system_pods) > 0:
nodeinfolist[name].state = NodeInfo.USED
else:
nodeinfolist[name].state = NodeInfo.OFF
else:
_LOGGER.error("Error getting Kubernetes node list.")
# Add the "virtual" nodes
try:
vnodes = json.load(open('/etc/clues2/kubernetes_vnodes.info', 'r'))
for vnode in vnodes:
name = vnode["name"]
if name not in nodeinfolist:
keywords = {
'pods_free': TypedNumber(self._node_pods),
'nodeName': TypedClass(name, TypedClass.STRING)
}
cpus = self._node_slots
if "cpu" in vnode:
cpus = int(vnode["cpu"])
memory = self._node_memory
if "memory" in vnode:
memory = self._get_memory_in_bytes(vnode["memory"])
if "queues" in vnode:
queues = vnode["queues"].split(",")
if queues:
keywords['queues'] = TypedList(
[TypedClass.auto(q) for q in queues])
if "keywords" in vnode:
for keypair in vnode["keywords"].split(','):
parts = keypair.split('=')
keywords[parts[0].strip()] = TypedClass(
parts[1].strip(), TypedClass.STRING)
nodeinfolist[name] = NodeInfo(name, cpus, cpus, memory,
memory, keywords)
nodeinfolist[name].state = NodeInfo.OFF
except Exception as ex:
_LOGGER.error(
"Error processing file /etc/clues2/kubernetes_vnodes.info: %s"
% str(ex))
return nodeinfolist
def get_nodeinfolist(self):
nodeinfolist = collections.OrderedDict()
try:
vnodes = json.load(open('/etc/clues2/mesos_vnodes.info', 'r'))
for vnode in vnodes:
name = vnode["name"]
if name not in nodeinfolist:
keywords = {'hostname': TypedClass(name, TypedClass.STRING)}
state = NodeInfo.OFF
slots_count = self._node_slots
slots_free = self._node_slots
if "cpu" in vnode:
slots_count = int(vnode["cpu"])
slots_free = int(vnode["cpu"])
memory_total = self._node_memory
memory_free = self._node_memory
if "memory" in vnode:
memory_total = get_memory_in_bytes(vnode["memory"])
memory_free = get_memory_in_bytes(vnode["memory"])
#queues = ["default"]
#if "queues" in vnode:
# queues = vnode["queues"].split(",")
# if queues:
# keywords['queues'] = TypedList([TypedClass.auto(q) for q in queues])
if "keywords" in vnode:
for keypair in vnode["keywords"].split(','):
parts = keypair.split('=')
keywords[parts[0].strip()] = TypedClass(parts[1].strip(), TypedClass.STRING)
nodeinfolist[name] = NodeInfo(name, slots_count, slots_free, memory_total, memory_free, keywords)
nodeinfolist[name].state = state
except Exception as ex:
_LOGGER.error("Error processing file /etc/clues2/mesos_vnodes.info: %s" % str(ex))
mesos_slaves = self._obtain_mesos_nodes()
if mesos_slaves:
for mesos_slave in mesos_slaves['slaves']:
name = mesos_slave['hostname']
if nodeinfolist:
for node in nodeinfolist:
nodeinfolist_node_ip = None
try:
nodeinfolist_node_ip = socket.gethostbyname(nodeinfolist[node].name)
except:
_LOGGER.warning("Error resolving node ip %s" % nodeinfolist[node].name)
if name == nodeinfolist[node].name or name == nodeinfolist_node_ip:
name = nodeinfolist[node].name
slots_count = float(mesos_slave['resources']['cpus'])
memory_total = calculate_memory_bytes(mesos_slave['resources']['mem'])
used_cpu = float(mesos_slave['used_resources']['cpus'])
used_mem = calculate_memory_bytes(mesos_slave['used_resources']['mem'])
state = NodeInfo.UNKNOWN
if mesos_slave["active"]:
if used_cpu > 0 or used_mem > 0:
state = NodeInfo.USED
else:
state = NodeInfo.IDLE
else:
state = NodeInfo.OFF
slots_free = slots_count - used_cpu
memory_free = memory_total - used_mem
# Create a fake queue
keywords = {}
keywords['hostname'] = TypedClass.auto(name)
#queues = ["default"]
#if queues:
# keywords['queues'] = TypedList([TypedClass.auto(q) for q in queues])
nodeinfolist[name] = NodeInfo(
name, slots_count, slots_free, memory_total, memory_free, keywords)
nodeinfolist[name].state = state
return nodeinfolist
