mirror of
https://github.com/gyptazy/ProxLB.git
synced 2026-04-05 20:31:57 +02:00
571 lines
32 KiB
Python
571 lines
32 KiB
Python
"""
|
|
The Calculations class is responsible for handling the balancing of virtual machines (VMs)
|
|
and containers (CTs) across all available nodes in a Proxmox cluster. It provides methods
|
|
to calculate the optimal distribution of VMs and CTs based on the provided data.
|
|
"""
|
|
|
|
|
|
__author__ = "Florian Paul Azim Hoberg <gyptazy>"
|
|
__copyright__ = "Copyright (C) 2025 Florian Paul Azim Hoberg (@gyptazy)"
|
|
__license__ = "GPL-3.0"
|
|
|
|
|
|
import sys
|
|
from typing import Dict, Any
|
|
from utils.logger import SystemdLogger
|
|
|
|
logger = SystemdLogger()
|
|
|
|
|
|
class Calculations:
|
|
"""
|
|
The calculation class is responsible for handling the balancing of virtual machines (VMs)
|
|
and containers (CTs) across all available nodes in a Proxmox cluster. It provides methods
|
|
to calculate the optimal distribution of VMs and CTs based on the provided data.
|
|
|
|
Methods:
|
|
__init__(proxlb_data: Dict[str, Any]):
|
|
Initializes the Calculation class with the provided ProxLB data.
|
|
|
|
set_node_assignments(proxlb_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
Sets the assigned resources of the nodes based on the current assigned
|
|
guest resources by their created groups as an initial base.
|
|
|
|
get_balanciness(proxlb_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
Gets the balanciness for further actions where the highest and lowest
|
|
usage or assignments of Proxmox nodes are compared.
|
|
|
|
get_most_free_node(proxlb_data: Dict[str, Any], return_node: bool = False) -> Dict[str, Any]:
|
|
Gets the name of the Proxmox node in the cluster with the most free resources based on
|
|
the user-defined method (e.g., memory) and mode (e.g., used).
|
|
|
|
relocate_guests_on_maintenance_nodes(proxlb_data: Dict[str, Any]):
|
|
Relocates guests that are currently on nodes marked for maintenance to
|
|
nodes with the most available resources.
|
|
|
|
relocate_guests(proxlb_data: Dict[str, Any]):
|
|
Relocates guests within the provided data structure to ensure affinity groups are
|
|
placed on nodes with the most free resources.
|
|
|
|
val_anti_affinity(proxlb_data: Dict[str, Any], guest_name: str):
|
|
Validates and assigns nodes to guests based on anti-affinity rules.
|
|
|
|
update_node_resources(proxlb_data):
|
|
Updates the resource allocation and usage statistics for nodes when a guest
|
|
is moved from one node to another.
|
|
"""
|
|
|
|
def __init__(self, proxlb_data: Dict[str, Any]):
|
|
"""
|
|
Initializes the Calculation class with the provided ProxLB data.
|
|
|
|
Args:
|
|
proxlb_data (Dict[str, Any]): The data required for balancing VMs and CTs.
|
|
"""
|
|
|
|
@staticmethod
|
|
def set_node_assignments(proxlb_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Set the assigned resources of the nodes based on the current assigned
|
|
guest resources by their created groups as an initial base.
|
|
|
|
Args:
|
|
proxlb_data (Dict[str, Any]): The data holding all current statistics.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Updated ProxLB data of nodes section with updated node assigned values.
|
|
"""
|
|
logger.debug("Starting: set_node_assignments.")
|
|
for group_name, group_meta in proxlb_data["groups"]["affinity"].items():
|
|
|
|
for guest_name in group_meta["guests"]:
|
|
guest_node_current = proxlb_data["guests"][guest_name]["node_current"]
|
|
# Update resource assignments
|
|
# Update assigned values for the current node
|
|
logger.debug(f"set_node_assignment of guest {guest_name} on node {guest_node_current} with cpu_total: {proxlb_data['guests'][guest_name]['cpu_total']}, memory_total: {proxlb_data['guests'][guest_name]['memory_total']}, disk_total: {proxlb_data['guests'][guest_name]['disk_total']}.")
|
|
proxlb_data["nodes"][guest_node_current]["cpu_assigned"] += proxlb_data["guests"][guest_name]["cpu_total"]
|
|
proxlb_data["nodes"][guest_node_current]["memory_assigned"] += proxlb_data["guests"][guest_name]["memory_total"]
|
|
proxlb_data["nodes"][guest_node_current]["disk_assigned"] += proxlb_data["guests"][guest_name]["disk_total"]
|
|
# Update assigned percentage values for the current node
|
|
proxlb_data["nodes"][guest_node_current]["cpu_assigned_percent"] = proxlb_data["nodes"][guest_node_current]["cpu_assigned"] / proxlb_data["nodes"][guest_node_current]["cpu_total"] * 100
|
|
proxlb_data["nodes"][guest_node_current]["memory_assigned_percent"] = proxlb_data["nodes"][guest_node_current]["memory_assigned"] / proxlb_data["nodes"][guest_node_current]["memory_total"] * 100
|
|
proxlb_data["nodes"][guest_node_current]["disk_assigned_percent"] = proxlb_data["nodes"][guest_node_current]["disk_assigned"] / proxlb_data["nodes"][guest_node_current]["disk_total"] * 100
|
|
|
|
logger.debug("Finished: set_node_assignments.")
|
|
|
|
def set_node_hot(proxlb_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Evaluates node 'full' pressure metrics for memory, cpu, and io
|
|
against defined thresholds and sets <metric>_pressure_hot = True
|
|
when a node is considered HOT.
|
|
|
|
Returns the modified proxlb_data dict.
|
|
"""
|
|
logger.debug("Starting: set_node_hot.")
|
|
balancing_cfg = proxlb_data.get("meta", {}).get("balancing", {})
|
|
thresholds = balancing_cfg.get("psi_thresholds", balancing_cfg.get("psi", {}).get("nodes", {}))
|
|
nodes = proxlb_data.get("nodes", {})
|
|
|
|
for node_name, node in nodes.items():
|
|
|
|
if node.get("maintenance"):
|
|
continue
|
|
|
|
if node.get("ignore"):
|
|
continue
|
|
|
|
# PSI metrics are only availavble on Proxmox VE 9.0 and higher.
|
|
if proxlb_data["meta"]["balancing"].get("mode", "used") == "psi":
|
|
|
|
if tuple(map(int, proxlb_data["nodes"][node["name"]]["pve_version"].split('.'))) < tuple(map(int, "9.0".split('.'))):
|
|
logger.critical(f"Proxmox node {node['name']} runs Proxmox VE version {proxlb_data['nodes'][node['name']]['pve_version']}."
|
|
" PSI metrics require Proxmox VE 9.0 or higher. Balancing deactivated!")
|
|
|
|
for metric, threshold in thresholds.items():
|
|
pressure_full = node.get(f"{metric}_pressure_full_percent", 0.0)
|
|
pressure_some = node.get(f"{metric}_pressure_some_percent", 0.0)
|
|
pressure_spikes = node.get(f"{metric}_pressure_full_spikes_percent", 0.0)
|
|
is_hot = (pressure_full >= threshold["pressure_full"] and pressure_some >= threshold["pressure_some"]) or (pressure_spikes >= threshold["pressure_spikes"])
|
|
|
|
if is_hot:
|
|
logger.debug(f"Set node {node['name']} as hot based on {metric} pressure metrics.")
|
|
proxlb_data["nodes"][node["name"]][f"{metric}_pressure_hot"] = True
|
|
proxlb_data["nodes"][node["name"]][f"pressure_hot"] = True
|
|
else:
|
|
logger.debug(f"Node {node['name']} is not hot based on {metric} pressure metrics.")
|
|
|
|
logger.debug("Finished: set_node_hot.")
|
|
return proxlb_data
|
|
|
|
def set_guest_hot(proxlb_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Evaluates guest 'full' pressure metrics for memory, cpu, and io
|
|
against defined thresholds and sets <metric>_pressure_hot = True
|
|
when a guest is considered HOT.
|
|
|
|
Returns the modified proxlb_data dict.
|
|
"""
|
|
logger.debug("Starting: set_guest_hot.")
|
|
balancing_cfg = proxlb_data.get("meta", {}).get("balancing", {})
|
|
thresholds = balancing_cfg.get("psi_thresholds", balancing_cfg.get("psi", {}).get("guests", {}))
|
|
guests = proxlb_data.get("guests", {})
|
|
|
|
for guest_name, guest in guests.items():
|
|
if guest.get("ignore"):
|
|
continue
|
|
|
|
for metric, threshold in thresholds.items():
|
|
pressure_full = guest.get(f"{metric}_pressure_full_percent", 0.0)
|
|
pressure_some = guest.get(f"{metric}_pressure_some_percent", 0.0)
|
|
pressure_spikes = guest.get(f"{metric}_pressure_full_spikes_percent", 0.0)
|
|
is_hot = (pressure_full >= threshold["pressure_full"] and pressure_some >= threshold["pressure_some"]) or (pressure_spikes >= threshold["pressure_spikes"])
|
|
|
|
if is_hot:
|
|
logger.debug(f"Set guest {guest['name']} as hot based on {metric} pressure metrics.")
|
|
proxlb_data["guests"][guest["name"]][f"{metric}_pressure_hot"] = True
|
|
proxlb_data["guests"][guest["name"]][f"pressure_hot"] = True
|
|
else:
|
|
logger.debug(f"guest {guest['name']} is not hot based on {metric} pressure metrics.")
|
|
|
|
logger.debug("Finished: set_guest_hot.")
|
|
return proxlb_data
|
|
|
|
@staticmethod
|
|
def get_balanciness(proxlb_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Get the blanaciness for further actions where the highest and lowest
|
|
usage or assignments of Proxmox nodes are compared. Based on the users
|
|
provided balanciness delta the balancing will be performed.
|
|
|
|
Args:
|
|
proxlb_data (Dict[str, Any]): The data holding all content of all objects.
|
|
Returns:
|
|
Dict[str, Any]: Updated meta data section of the balanciness action defined
|
|
as a bool.
|
|
"""
|
|
logger.debug("Starting: get_balanciness.")
|
|
proxlb_data["meta"]["balancing"]["balance"] = False
|
|
|
|
if len(proxlb_data["groups"]) > 0:
|
|
method = proxlb_data["meta"]["balancing"].get("method", "memory")
|
|
mode = proxlb_data["meta"]["balancing"].get("mode", "used")
|
|
balanciness = proxlb_data["meta"]["balancing"].get("balanciness", 10)
|
|
|
|
if mode == "assigned":
|
|
method_value = [node_meta[f"{method}_{mode}_percent"] for node_meta in proxlb_data["nodes"].values()]
|
|
|
|
if proxlb_data["meta"]["balancing"].get(f"{method}_threshold", None):
|
|
threshold = proxlb_data["meta"]["balancing"].get(f"{method}_threshold")
|
|
highest_usage_node = max(proxlb_data["nodes"].values(), key=lambda x: x[f"{method}_{mode}_percent"])
|
|
highest_node_value = highest_usage_node[f"{method}_{mode}_percent"]
|
|
|
|
if highest_node_value >= threshold:
|
|
logger.debug(f"Guest balancing is required. Highest {method} usage node {highest_usage_node['name']} is above the defined threshold of {threshold}% with a value of {highest_node_value}%.")
|
|
proxlb_data["meta"]["balancing"]["balance"] = True
|
|
else:
|
|
logger.debug(f"Guest balancing is ok. Highest {method} usage node {highest_usage_node['name']} is below the defined threshold of {threshold}% with a value of {highest_node_value}%.")
|
|
proxlb_data["meta"]["balancing"]["balance"] = False
|
|
|
|
else:
|
|
logger.debug(f"No {method} threshold defined for balancing. Skipping threshold check.")
|
|
|
|
elif mode == "used":
|
|
method_value = [node_meta[f"{method}_{mode}_percent"] for node_meta in proxlb_data["nodes"].values()]
|
|
|
|
if proxlb_data["meta"]["balancing"].get(f"{method}_threshold", None):
|
|
threshold = proxlb_data["meta"]["balancing"].get(f"{method}_threshold")
|
|
highest_usage_node = max(proxlb_data["nodes"].values(), key=lambda x: x[f"{method}_{mode}_percent"])
|
|
highest_node_value = highest_usage_node[f"{method}_{mode}_percent"]
|
|
|
|
if highest_node_value >= threshold:
|
|
logger.debug(f"Guest balancing is required. Highest {method} usage node {highest_usage_node['name']} is above the defined threshold of {threshold}% with a value of {highest_node_value}%.")
|
|
proxlb_data["meta"]["balancing"]["balance"] = True
|
|
else:
|
|
logger.debug(f"Guest balancing is ok. Highest {method} usage node {highest_usage_node['name']} is below the defined threshold of {threshold}% with a value of {highest_node_value}%.")
|
|
proxlb_data["meta"]["balancing"]["balance"] = False
|
|
|
|
else:
|
|
logger.debug(f"No {method} threshold defined for balancing. Skipping threshold check.")
|
|
|
|
elif mode == "psi":
|
|
method_value = [node_meta[f"{method}_pressure_full_spikes_percent"] for node_meta in proxlb_data["nodes"].values()]
|
|
any_node_hot = any(node.get(f"{method}_pressure_hot", False) for node in proxlb_data["nodes"].values())
|
|
any_guest_hot = any(node.get(f"{method}_pressure_hot", False) for node in proxlb_data["guests"].values())
|
|
|
|
if any_node_hot:
|
|
logger.debug(f"Guest balancing is required. A node is marked as HOT based on {method} pressure metrics.")
|
|
proxlb_data["meta"]["balancing"]["balance"] = True
|
|
else:
|
|
logger.debug(f"Guest balancing is ok. No node is marked as HOT based on {method} pressure metrics.")
|
|
|
|
if any_guest_hot:
|
|
logger.debug(f"Guest balancing is required. A guest is marked as HOT based on {method} pressure metrics.")
|
|
proxlb_data["meta"]["balancing"]["balance"] = True
|
|
else:
|
|
logger.debug(f"Guest balancing is ok. No guest is marked as HOT based on {method} pressure metrics.")
|
|
|
|
return proxlb_data
|
|
|
|
else:
|
|
logger.critical(f"Unknown balancing mode: {mode} provided. Cannot get balanciness.")
|
|
sys.exit(1)
|
|
|
|
method_value_highest = max(method_value)
|
|
method_value_lowest = min(method_value)
|
|
|
|
if method_value_highest - method_value_lowest > balanciness:
|
|
proxlb_data["meta"]["balancing"]["balance"] = True
|
|
logger.debug(f"Guest balancing is required. Highest value: {method_value_highest}, lowest value: {method_value_lowest} balanced by {method} and {mode}.")
|
|
else:
|
|
logger.debug(f"Guest balancing is ok. Highest value: {method_value_highest}, lowest value: {method_value_lowest} balanced by {method} and {mode}.")
|
|
|
|
else:
|
|
logger.warning("No guests for balancing found.")
|
|
|
|
logger.debug("Finished: get_balanciness.")
|
|
|
|
@staticmethod
|
|
def get_most_free_node(proxlb_data: Dict[str, Any], return_node: bool = False, guest_node_relation_list: list = []) -> Dict[str, Any]:
|
|
"""
|
|
Get the name of the Proxmox node in the cluster with the most free resources based on
|
|
the user defined method (e.g.: memory) and mode (e.g.: used).
|
|
|
|
Args:
|
|
proxlb_data (Dict[str, Any]): The data holding all content of all objects.
|
|
return_node (bool): The indicator to simply return the best node for further
|
|
assignments.
|
|
guest_node_relation_list (list): A list of nodes that have a tag on the given
|
|
guest relationship for pinning.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Updated meta data section of the node with the most free resources that should
|
|
be used for the next balancing action.
|
|
"""
|
|
logger.debug("Starting: get_most_free_node.")
|
|
proxlb_data["meta"]["balancing"]["balance_next_node"] = ""
|
|
|
|
# Filter and exclude nodes that are in maintenance mode
|
|
filtered_nodes = [node for node in proxlb_data["nodes"].values() if not node["maintenance"]]
|
|
|
|
# Filter and include nodes that given by a relationship between guest and node. This is only
|
|
# used if the guest has a relationship to a node defined by "pin" tags.
|
|
if len(guest_node_relation_list) > 0:
|
|
filtered_nodes = [node for node in proxlb_data["nodes"].values() if node["name"] in guest_node_relation_list]
|
|
|
|
# Filter by the defined methods and modes for balancing
|
|
method = proxlb_data["meta"]["balancing"].get("method", "memory")
|
|
mode = proxlb_data["meta"]["balancing"].get("mode", "used")
|
|
|
|
if mode == "assigned":
|
|
logger.debug(f"Get best node for balancing by assigned {method} resources.")
|
|
lowest_usage_node = min(filtered_nodes, key=lambda x: x[f"{method}_{mode}_percent"])
|
|
|
|
elif mode == "used":
|
|
logger.debug(f"Get best node for balancing by used {method} resources.")
|
|
lowest_usage_node = min(filtered_nodes, key=lambda x: x[f"{method}_{mode}_percent"])
|
|
|
|
elif mode == "psi":
|
|
logger.debug(f"Get best node for balancing by pressure of {method} resources.")
|
|
lowest_usage_node = min(filtered_nodes, key=lambda x: x[f"{method}_pressure_full_spikes_percent"])
|
|
|
|
else:
|
|
logger.critical(f"Unknown balancing mode: {mode} provided. Cannot get best node.")
|
|
sys.exit(1)
|
|
|
|
proxlb_data["meta"]["balancing"]["balance_reason"] = 'resources'
|
|
proxlb_data["meta"]["balancing"]["balance_next_node"] = lowest_usage_node["name"]
|
|
|
|
# If executed to simply get the best node for further usage, we return
|
|
# the best node on stdout and gracefully exit here
|
|
if return_node:
|
|
print(lowest_usage_node["name"])
|
|
sys.exit(0)
|
|
|
|
logger.debug("Finished: get_most_free_node.")
|
|
|
|
@staticmethod
|
|
def relocate_guests_on_maintenance_nodes(proxlb_data: Dict[str, Any]):
|
|
"""
|
|
Relocates guests that are currently on nodes marked for maintenance to
|
|
nodes with the most available resources.
|
|
|
|
This function iterates over all guests on maintenance nodes and attempts
|
|
to relocate them to nodes with the most free resources that are not in
|
|
maintenance mode. It updates the node resources accordingly and logs
|
|
warnings if the balancing may not be perfect due to the maintenance
|
|
status of the original node.
|
|
|
|
Args:
|
|
proxlb_data (Dict[str, Any]): The data holding all content of all objects.
|
|
Returns:
|
|
None
|
|
"""
|
|
logger.debug("Starting: relocate_guests_on_maintenance_nodes.")
|
|
proxlb_data["meta"]["balancing"]["balance_next_guest"] = ""
|
|
|
|
for guest_name in proxlb_data["groups"]["maintenance"]:
|
|
# Update the node with the most free nodes which is
|
|
# not in a maintenance
|
|
proxlb_data["meta"]["balancing"]["balance_next_guest"] = guest_name
|
|
Calculations.get_most_free_node(proxlb_data)
|
|
Calculations.update_node_resources(proxlb_data)
|
|
logger.warning(f"Warning: Balancing may not be perfect because guest {guest_name} was located on a node which is in maintenance mode.")
|
|
|
|
logger.debug("Finished: relocate_guests_on_maintenance_nodes.")
|
|
|
|
@staticmethod
|
|
def relocate_guests(proxlb_data: Dict[str, Any]):
|
|
"""
|
|
Relocates guests within the provided data structure to ensure affinity groups are
|
|
placed on nodes with the most free resources.
|
|
|
|
This function iterates over each affinity group in the provided data, identifies
|
|
the node with the most free resources, and migrates all guests within the group
|
|
to that node. It updates the node resources accordingly.
|
|
|
|
Args:
|
|
proxlb_data (Dict[str, Any]): The data holding all content of all objects.
|
|
Returns:
|
|
None
|
|
"""
|
|
logger.debug("Starting: relocate_guests.")
|
|
if proxlb_data["meta"]["balancing"]["balance"] or proxlb_data["meta"]["balancing"].get("enforce_affinity", False):
|
|
|
|
if proxlb_data["meta"]["balancing"].get("balance", False):
|
|
logger.debug("Balancing of guests will be performed. Reason: balanciness")
|
|
|
|
if proxlb_data["meta"]["balancing"].get("enforce_affinity", False):
|
|
logger.debug("Balancing of guests will be performed. Reason: enforce affinity balancing")
|
|
|
|
for group_name in proxlb_data["groups"]["affinity"]:
|
|
|
|
# We get initially the node with the most free resources and then
|
|
# migrate all guests within the group to that node to ensure the
|
|
# affinity.
|
|
Calculations.get_most_free_node(proxlb_data)
|
|
|
|
for guest_name in proxlb_data["groups"]["affinity"][group_name]["guests"]:
|
|
mode = proxlb_data["meta"]["balancing"].get("mode", "used")
|
|
|
|
if mode == 'psi':
|
|
logger.debug(f"Evaluating guest relocation based on {mode} mode.")
|
|
method = proxlb_data["meta"]["balancing"].get("method", "memory")
|
|
processed_guests_psi = proxlb_data["meta"]["balancing"].setdefault("processed_guests_psi", [])
|
|
unprocessed_guests_psi = [guest for guest in proxlb_data["guests"].values() if guest["name"] not in processed_guests_psi]
|
|
|
|
# Filter by the defined methods and modes for balancing
|
|
highest_usage_guest = max(unprocessed_guests_psi, key=lambda x: x[f"{method}_pressure_full_spikes_percent"])
|
|
|
|
# Append guest to the psi based processed list of guests
|
|
if highest_usage_guest["name"] == guest_name and guest_name not in proxlb_data["meta"]["balancing"]["processed_guests_psi"]:
|
|
proxlb_data["meta"]["balancing"]["processed_guests_psi"].append(guest_name)
|
|
proxlb_data["meta"]["balancing"]["balance_next_guest"] = guest_name
|
|
|
|
else:
|
|
logger.debug(f"Evaluating guest relocation based on {mode} mode.")
|
|
proxlb_data["meta"]["balancing"]["balance_next_guest"] = guest_name
|
|
|
|
Calculations.val_anti_affinity(proxlb_data, guest_name)
|
|
Calculations.val_node_relationships(proxlb_data, guest_name)
|
|
Calculations.update_node_resources(proxlb_data)
|
|
|
|
logger.debug("Finished: relocate_guests.")
|
|
|
|
@staticmethod
|
|
def val_anti_affinity(proxlb_data: Dict[str, Any], guest_name: str):
|
|
"""
|
|
Validates and assigns nodes to guests based on anti-affinity rules.
|
|
|
|
This function iterates over all defined anti-affinity groups in the provided
|
|
`proxlb_data` and checks if the specified `guest_name` is included in any of
|
|
these groups. If the guest is included and has not been processed yet, it
|
|
attempts to assign an unused and non-maintenance node to the guest, ensuring
|
|
that the anti-affinity rules are respected.
|
|
|
|
Parameters:
|
|
proxlb_data (Dict[str, Any]): The data holding all content of all objects.
|
|
guest_name (str): The name of the guest to be validated and assigned a node.
|
|
|
|
Returns:
|
|
None
|
|
"""
|
|
logger.debug("Starting: val_anti_affinity.")
|
|
# Start by iterating over all defined anti-affinity groups
|
|
for group_name in proxlb_data["groups"]["anti_affinity"].keys():
|
|
|
|
# Validate if the provided guest is included in the anti-affinity group
|
|
if guest_name in proxlb_data["groups"]["anti_affinity"][group_name]['guests'] and not proxlb_data["guests"][guest_name]["processed"]:
|
|
logger.debug(f"Anti-Affinity: Guest: {guest_name} is included in anti-affinity group: {group_name}.")
|
|
|
|
# Check if the group has only one member. If so skip new guest node assignment.
|
|
if proxlb_data["groups"]["anti_affinity"][group_name]["counter"] > 1:
|
|
logger.debug(f"Anti-Affinity: Group has more than 1 member.")
|
|
# Iterate over all available nodes
|
|
for node_name in proxlb_data["nodes"].keys():
|
|
|
|
# Only select node if it was not used before and is not in a
|
|
# maintenance mode. Afterwards, add it to the list of already
|
|
# used nodes for the current anti-affinity group
|
|
if node_name not in proxlb_data["groups"]["anti_affinity"][group_name]["used_nodes"]:
|
|
|
|
if not proxlb_data["nodes"][node_name]["maintenance"]:
|
|
# If the node has not been used yet, we assign this node to the guest
|
|
proxlb_data["meta"]["balancing"]["balance_next_node"] = node_name
|
|
proxlb_data["groups"]["anti_affinity"][group_name]["used_nodes"].append(node_name)
|
|
logger.debug(f"Node: {node_name} marked as used for anti-affinity group: {group_name} with guest {guest_name}")
|
|
break
|
|
|
|
else:
|
|
logger.critical(f"Node: {node_name} already got used for anti-affinity group:: {group_name}. (Tried for guest: {guest_name})")
|
|
else:
|
|
logger.debug(f"Anti-Affinity: Group has less than 2 members. Skipping node calculation for the group.")
|
|
|
|
else:
|
|
logger.debug(f"Guest: {guest_name} is not included in anti-affinity group: {group_name}. Skipping.")
|
|
|
|
logger.debug("Finished: val_anti_affinity.")
|
|
|
|
@staticmethod
|
|
def val_node_relationships(proxlb_data: Dict[str, Any], guest_name: str):
|
|
"""
|
|
Validates and assigns guests to nodes based on defined relationships based on tags.
|
|
|
|
Parameters:
|
|
proxlb_data (Dict[str, Any]): The data holding all content of all objects.
|
|
guest_name (str): The name of the guest to be validated and assigned a node.
|
|
|
|
Returns:
|
|
None
|
|
"""
|
|
logger.debug("Starting: val_node_relationships.")
|
|
proxlb_data["guests"][guest_name]["processed"] = True
|
|
|
|
if len(proxlb_data["guests"][guest_name]["node_relationships"]) > 0:
|
|
logger.debug(f"Guest '{guest_name}' has relationships defined to node(s): {','.join(proxlb_data['guests'][guest_name]['node_relationships'])}. Pinning to node.")
|
|
|
|
# Get the node with the most free resources of the group
|
|
guest_node_relation_list = proxlb_data["guests"][guest_name]["node_relationships"]
|
|
Calculations.get_most_free_node(proxlb_data, False, guest_node_relation_list)
|
|
|
|
# Validate if the specified node name is really part of the cluster
|
|
if proxlb_data["meta"]["balancing"]["balance_next_node"] in proxlb_data["nodes"].keys():
|
|
logger.debug(f"Guest '{guest_name}' has a specific relationship defined to node: {proxlb_data['meta']['balancing']['balance_next_node']} is a known hypervisor node in the cluster.")
|
|
else:
|
|
logger.warning(f"Guest '{guest_name}' has a specific relationship defined to node: {proxlb_data['meta']['balancing']['balance_next_node']} but this node name is not known in the cluster!")
|
|
|
|
else:
|
|
logger.debug(f"Guest '{guest_name}' does not have any specific node relationships.")
|
|
|
|
logger.debug("Finished: val_node_relationships.")
|
|
|
|
@staticmethod
|
|
def update_node_resources(proxlb_data):
|
|
"""
|
|
Updates the resource allocation and usage statistics for nodes when a guest
|
|
is moved from one node to another.
|
|
|
|
Parameters:
|
|
proxlb_data (dict): A dictionary containing information about the nodes and
|
|
guests, including their resource allocations and usage.
|
|
|
|
The function performs the following steps:
|
|
1. Retrieves the guest name, current node, and target node from the provided data.
|
|
2. Updates the resource allocations and usage statistics for the target node by
|
|
adding the resources of the moved guest.
|
|
3. Updates the resource allocations and usage statistics for the current node by
|
|
subtracting the resources of the moved guest.
|
|
4. Logs the start and end of the resource update process, as well as the movement
|
|
of the guest from the current node to the target node.
|
|
"""
|
|
logger.debug("Starting: update_node_resources.")
|
|
guest_name = proxlb_data["meta"]["balancing"]["balance_next_guest"]
|
|
|
|
if guest_name == "":
|
|
logger.debug("No guest defined to update node resources for.")
|
|
return
|
|
|
|
node_current = proxlb_data["guests"][guest_name]["node_current"]
|
|
node_target = proxlb_data["meta"]["balancing"]["balance_next_node"]
|
|
|
|
# Update resources for the target node by the moved guest resources
|
|
# Add assigned resources to the target node
|
|
proxlb_data["nodes"][node_target]["cpu_assigned"] += proxlb_data["guests"][guest_name]["cpu_total"]
|
|
proxlb_data["nodes"][node_target]["memory_assigned"] += proxlb_data["guests"][guest_name]["memory_total"]
|
|
proxlb_data["nodes"][node_target]["disk_assigned"] += proxlb_data["guests"][guest_name]["disk_total"]
|
|
# Update the assigned percentages of assigned resources for the target node
|
|
proxlb_data["nodes"][node_target]["cpu_assigned_percent"] = proxlb_data["nodes"][node_target]["cpu_assigned"] / proxlb_data["nodes"][node_target]["cpu_total"] * 100
|
|
proxlb_data["nodes"][node_target]["memory_assigned_percent"] = proxlb_data["nodes"][node_target]["memory_assigned"] / proxlb_data["nodes"][node_target]["memory_total"] * 100
|
|
proxlb_data["nodes"][node_target]["disk_assigned_percent"] = proxlb_data["nodes"][node_target]["disk_assigned"] / proxlb_data["nodes"][node_target]["disk_total"] * 100
|
|
# Add used resources to the target node
|
|
proxlb_data["nodes"][node_target]["cpu_used"] += proxlb_data["guests"][guest_name]["cpu_used"]
|
|
proxlb_data["nodes"][node_target]["memory_used"] += proxlb_data["guests"][guest_name]["memory_used"]
|
|
proxlb_data["nodes"][node_target]["disk_used"] += proxlb_data["guests"][guest_name]["disk_used"]
|
|
# Update the used percentages of usage resources for the target node
|
|
proxlb_data["nodes"][node_target]["cpu_used_percent"] = proxlb_data["nodes"][node_target]["cpu_used"] / proxlb_data["nodes"][node_target]["cpu_total"] * 100
|
|
proxlb_data["nodes"][node_target]["memory_used_percent"] = proxlb_data["nodes"][node_target]["memory_used"] / proxlb_data["nodes"][node_target]["memory_total"] * 100
|
|
proxlb_data["nodes"][node_target]["disk_used_percent"] = proxlb_data["nodes"][node_target]["disk_used"] / proxlb_data["nodes"][node_target]["disk_total"] * 100
|
|
|
|
# Update resources for the current node by the moved guest resources
|
|
# Add assigned resources to the target node
|
|
proxlb_data["nodes"][node_current]["cpu_assigned"] -= proxlb_data["guests"][guest_name]["cpu_total"]
|
|
proxlb_data["nodes"][node_current]["memory_assigned"] -= proxlb_data["guests"][guest_name]["memory_total"]
|
|
proxlb_data["nodes"][node_current]["disk_assigned"] -= proxlb_data["guests"][guest_name]["disk_total"]
|
|
# Update the assigned percentages of assigned resources for the target node
|
|
proxlb_data["nodes"][node_current]["cpu_assigned_percent"] = proxlb_data["nodes"][node_current]["cpu_assigned"] / proxlb_data["nodes"][node_current]["cpu_total"] * 100
|
|
proxlb_data["nodes"][node_current]["memory_assigned_percent"] = proxlb_data["nodes"][node_current]["memory_assigned"] / proxlb_data["nodes"][node_current]["memory_total"] * 100
|
|
proxlb_data["nodes"][node_current]["disk_assigned_percent"] = proxlb_data["nodes"][node_current]["disk_assigned"] / proxlb_data["nodes"][node_current]["disk_total"] * 100
|
|
# Add used resources to the target node
|
|
proxlb_data["nodes"][node_current]["cpu_used"] -= proxlb_data["guests"][guest_name]["cpu_used"]
|
|
proxlb_data["nodes"][node_current]["memory_used"] -= proxlb_data["guests"][guest_name]["memory_used"]
|
|
proxlb_data["nodes"][node_current]["disk_used"] -= proxlb_data["guests"][guest_name]["disk_used"]
|
|
# Update the used percentages of usage resources for the target node
|
|
proxlb_data["nodes"][node_current]["cpu_used_percent"] = proxlb_data["nodes"][node_current]["cpu_used"] / proxlb_data["nodes"][node_current]["cpu_total"] * 100
|
|
proxlb_data["nodes"][node_current]["memory_used_percent"] = proxlb_data["nodes"][node_current]["memory_used"] / proxlb_data["nodes"][node_current]["memory_total"] * 100
|
|
proxlb_data["nodes"][node_current]["disk_used_percent"] = proxlb_data["nodes"][node_current]["disk_used"] / proxlb_data["nodes"][node_current]["disk_total"] * 100
|
|
|
|
# Assign guest to the new target node
|
|
proxlb_data["guests"][guest_name]["node_target"] = node_target
|
|
logger.debug(f"Set guest {guest_name} from node {node_current} to node {node_target}.")
|
|
|
|
logger.debug("Finished: update_node_resources.")
|