Reformat code with Black code formatter
Unify the code style along PEP and Black principles using the tool.
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@ -29,28 +29,24 @@ import daemon_lib.ceph as pvc_ceph
|
||||
|
||||
|
||||
def set_maintenance(zkhandler, maint_state):
|
||||
current_maint_state = zkhandler.read('base.config.maintenance')
|
||||
current_maint_state = zkhandler.read("base.config.maintenance")
|
||||
if maint_state == current_maint_state:
|
||||
if maint_state == 'true':
|
||||
return True, 'Cluster is already in maintenance mode'
|
||||
if maint_state == "true":
|
||||
return True, "Cluster is already in maintenance mode"
|
||||
else:
|
||||
return True, 'Cluster is already in normal mode'
|
||||
return True, "Cluster is already in normal mode"
|
||||
|
||||
if maint_state == 'true':
|
||||
zkhandler.write([
|
||||
('base.config.maintenance', 'true')
|
||||
])
|
||||
return True, 'Successfully set cluster in maintenance mode'
|
||||
if maint_state == "true":
|
||||
zkhandler.write([("base.config.maintenance", "true")])
|
||||
return True, "Successfully set cluster in maintenance mode"
|
||||
else:
|
||||
zkhandler.write([
|
||||
('base.config.maintenance', 'false')
|
||||
])
|
||||
return True, 'Successfully set cluster in normal mode'
|
||||
zkhandler.write([("base.config.maintenance", "false")])
|
||||
return True, "Successfully set cluster in normal mode"
|
||||
|
||||
|
||||
def getClusterInformation(zkhandler):
|
||||
# Get cluster maintenance state
|
||||
maint_state = zkhandler.read('base.config.maintenance')
|
||||
maint_state = zkhandler.read("base.config.maintenance")
|
||||
|
||||
# List of messages to display to the clients
|
||||
cluster_health_msg = []
|
||||
@ -69,7 +65,9 @@ def getClusterInformation(zkhandler):
|
||||
retcode, ceph_osd_list = pvc_ceph.get_list_osd(zkhandler, None)
|
||||
retcode, ceph_pool_list = pvc_ceph.get_list_pool(zkhandler, None)
|
||||
retcode, ceph_volume_list = pvc_ceph.get_list_volume(zkhandler, None, None)
|
||||
retcode, ceph_snapshot_list = pvc_ceph.get_list_snapshot(zkhandler, None, None, None)
|
||||
retcode, ceph_snapshot_list = pvc_ceph.get_list_snapshot(
|
||||
zkhandler, None, None, None
|
||||
)
|
||||
|
||||
# Determine, for each subsection, the total count
|
||||
node_count = len(node_list)
|
||||
@ -91,8 +89,8 @@ def getClusterInformation(zkhandler):
|
||||
node_largest_index = None
|
||||
node_largest_count = 0
|
||||
for index, node in enumerate(node_list):
|
||||
node_mem_total = node['memory']['total']
|
||||
node_mem_alloc = node['memory']['allocated']
|
||||
node_mem_total = node["memory"]["total"]
|
||||
node_mem_alloc = node["memory"]["allocated"]
|
||||
alloc_total += node_mem_alloc
|
||||
|
||||
# Determine if this node is the largest seen so far
|
||||
@ -105,32 +103,42 @@ def getClusterInformation(zkhandler):
|
||||
continue
|
||||
n_minus_1_node_list.append(node)
|
||||
for index, node in enumerate(n_minus_1_node_list):
|
||||
n_minus_1_total += node['memory']['total']
|
||||
n_minus_1_total += node["memory"]["total"]
|
||||
if alloc_total > n_minus_1_total:
|
||||
cluster_healthy_status = False
|
||||
cluster_health_msg.append("Total VM memory ({}) is overprovisioned (max {}) for (n-1) failure scenarios".format(alloc_total, n_minus_1_total))
|
||||
cluster_health_msg.append(
|
||||
"Total VM memory ({}) is overprovisioned (max {}) for (n-1) failure scenarios".format(
|
||||
alloc_total, n_minus_1_total
|
||||
)
|
||||
)
|
||||
|
||||
# Determinations for node health
|
||||
node_healthy_status = list(range(0, node_count))
|
||||
node_report_status = list(range(0, node_count))
|
||||
for index, node in enumerate(node_list):
|
||||
daemon_state = node['daemon_state']
|
||||
domain_state = node['domain_state']
|
||||
if daemon_state != 'run' and domain_state != 'ready':
|
||||
daemon_state = node["daemon_state"]
|
||||
domain_state = node["domain_state"]
|
||||
if daemon_state != "run" and domain_state != "ready":
|
||||
node_healthy_status[index] = False
|
||||
cluster_health_msg.append("Node '{}' in {},{} state".format(node['name'], daemon_state, domain_state))
|
||||
cluster_health_msg.append(
|
||||
"Node '{}' in {},{} state".format(
|
||||
node["name"], daemon_state, domain_state
|
||||
)
|
||||
)
|
||||
else:
|
||||
node_healthy_status[index] = True
|
||||
node_report_status[index] = daemon_state + ',' + domain_state
|
||||
node_report_status[index] = daemon_state + "," + domain_state
|
||||
|
||||
# Determinations for VM health
|
||||
vm_healthy_status = list(range(0, vm_count))
|
||||
vm_report_status = list(range(0, vm_count))
|
||||
for index, vm in enumerate(vm_list):
|
||||
vm_state = vm['state']
|
||||
if vm_state not in ['start', 'disable', 'migrate', 'unmigrate', 'provision']:
|
||||
vm_state = vm["state"]
|
||||
if vm_state not in ["start", "disable", "migrate", "unmigrate", "provision"]:
|
||||
vm_healthy_status[index] = False
|
||||
cluster_health_msg.append("VM '{}' in {} state".format(vm['name'], vm_state))
|
||||
cluster_health_msg.append(
|
||||
"VM '{}' in {} state".format(vm["name"], vm_state)
|
||||
)
|
||||
else:
|
||||
vm_healthy_status[index] = True
|
||||
vm_report_status[index] = vm_state
|
||||
@ -140,70 +148,99 @@ def getClusterInformation(zkhandler):
|
||||
ceph_osd_report_status = list(range(0, ceph_osd_count))
|
||||
for index, ceph_osd in enumerate(ceph_osd_list):
|
||||
try:
|
||||
ceph_osd_up = ceph_osd['stats']['up']
|
||||
ceph_osd_up = ceph_osd["stats"]["up"]
|
||||
except KeyError:
|
||||
ceph_osd_up = 0
|
||||
|
||||
try:
|
||||
ceph_osd_in = ceph_osd['stats']['in']
|
||||
ceph_osd_in = ceph_osd["stats"]["in"]
|
||||
except KeyError:
|
||||
ceph_osd_in = 0
|
||||
|
||||
up_texts = {1: 'up', 0: 'down'}
|
||||
in_texts = {1: 'in', 0: 'out'}
|
||||
up_texts = {1: "up", 0: "down"}
|
||||
in_texts = {1: "in", 0: "out"}
|
||||
|
||||
if not ceph_osd_up or not ceph_osd_in:
|
||||
ceph_osd_healthy_status[index] = False
|
||||
cluster_health_msg.append('OSD {} in {},{} state'.format(ceph_osd['id'], up_texts[ceph_osd_up], in_texts[ceph_osd_in]))
|
||||
cluster_health_msg.append(
|
||||
"OSD {} in {},{} state".format(
|
||||
ceph_osd["id"], up_texts[ceph_osd_up], in_texts[ceph_osd_in]
|
||||
)
|
||||
)
|
||||
else:
|
||||
ceph_osd_healthy_status[index] = True
|
||||
ceph_osd_report_status[index] = up_texts[ceph_osd_up] + ',' + in_texts[ceph_osd_in]
|
||||
ceph_osd_report_status[index] = (
|
||||
up_texts[ceph_osd_up] + "," + in_texts[ceph_osd_in]
|
||||
)
|
||||
|
||||
# Find out the overall cluster health; if any element of a healthy_status is false, it's unhealthy
|
||||
if maint_state == 'true':
|
||||
cluster_health = 'Maintenance'
|
||||
elif cluster_healthy_status is False or False in node_healthy_status or False in vm_healthy_status or False in ceph_osd_healthy_status:
|
||||
cluster_health = 'Degraded'
|
||||
if maint_state == "true":
|
||||
cluster_health = "Maintenance"
|
||||
elif (
|
||||
cluster_healthy_status is False
|
||||
or False in node_healthy_status
|
||||
or False in vm_healthy_status
|
||||
or False in ceph_osd_healthy_status
|
||||
):
|
||||
cluster_health = "Degraded"
|
||||
else:
|
||||
cluster_health = 'Optimal'
|
||||
cluster_health = "Optimal"
|
||||
|
||||
# Find out our storage health from Ceph
|
||||
ceph_status = zkhandler.read('base.storage').split('\n')
|
||||
ceph_status = zkhandler.read("base.storage").split("\n")
|
||||
ceph_health = ceph_status[2].split()[-1]
|
||||
|
||||
# Parse the status output to get the health indicators
|
||||
line_record = False
|
||||
for index, line in enumerate(ceph_status):
|
||||
if re.search('services:', line):
|
||||
if re.search("services:", line):
|
||||
line_record = False
|
||||
if line_record and len(line.strip()) > 0:
|
||||
storage_health_msg.append(line.strip())
|
||||
if re.search('health:', line):
|
||||
if re.search("health:", line):
|
||||
line_record = True
|
||||
|
||||
if maint_state == 'true':
|
||||
storage_health = 'Maintenance'
|
||||
elif ceph_health != 'HEALTH_OK':
|
||||
storage_health = 'Degraded'
|
||||
if maint_state == "true":
|
||||
storage_health = "Maintenance"
|
||||
elif ceph_health != "HEALTH_OK":
|
||||
storage_health = "Degraded"
|
||||
else:
|
||||
storage_health = 'Optimal'
|
||||
storage_health = "Optimal"
|
||||
|
||||
# State lists
|
||||
node_state_combinations = [
|
||||
'run,ready', 'run,flush', 'run,flushed', 'run,unflush',
|
||||
'init,ready', 'init,flush', 'init,flushed', 'init,unflush',
|
||||
'stop,ready', 'stop,flush', 'stop,flushed', 'stop,unflush',
|
||||
'dead,ready', 'dead,flush', 'dead,flushed', 'dead,unflush'
|
||||
"run,ready",
|
||||
"run,flush",
|
||||
"run,flushed",
|
||||
"run,unflush",
|
||||
"init,ready",
|
||||
"init,flush",
|
||||
"init,flushed",
|
||||
"init,unflush",
|
||||
"stop,ready",
|
||||
"stop,flush",
|
||||
"stop,flushed",
|
||||
"stop,unflush",
|
||||
"dead,ready",
|
||||
"dead,flush",
|
||||
"dead,flushed",
|
||||
"dead,unflush",
|
||||
]
|
||||
vm_state_combinations = [
|
||||
'start', 'restart', 'shutdown', 'stop', 'disable', 'fail', 'migrate', 'unmigrate', 'provision'
|
||||
]
|
||||
ceph_osd_state_combinations = [
|
||||
'up,in', 'up,out', 'down,in', 'down,out'
|
||||
"start",
|
||||
"restart",
|
||||
"shutdown",
|
||||
"stop",
|
||||
"disable",
|
||||
"fail",
|
||||
"migrate",
|
||||
"unmigrate",
|
||||
"provision",
|
||||
]
|
||||
ceph_osd_state_combinations = ["up,in", "up,out", "down,in", "down,out"]
|
||||
|
||||
# Format the Node states
|
||||
formatted_node_states = {'total': node_count}
|
||||
formatted_node_states = {"total": node_count}
|
||||
for state in node_state_combinations:
|
||||
state_count = 0
|
||||
for node_state in node_report_status:
|
||||
@ -213,7 +250,7 @@ def getClusterInformation(zkhandler):
|
||||
formatted_node_states[state] = state_count
|
||||
|
||||
# Format the VM states
|
||||
formatted_vm_states = {'total': vm_count}
|
||||
formatted_vm_states = {"total": vm_count}
|
||||
for state in vm_state_combinations:
|
||||
state_count = 0
|
||||
for vm_state in vm_report_status:
|
||||
@ -223,7 +260,7 @@ def getClusterInformation(zkhandler):
|
||||
formatted_vm_states[state] = state_count
|
||||
|
||||
# Format the OSD states
|
||||
formatted_osd_states = {'total': ceph_osd_count}
|
||||
formatted_osd_states = {"total": ceph_osd_count}
|
||||
for state in ceph_osd_state_combinations:
|
||||
state_count = 0
|
||||
for ceph_osd_state in ceph_osd_report_status:
|
||||
@ -234,19 +271,19 @@ def getClusterInformation(zkhandler):
|
||||
|
||||
# Format the status data
|
||||
cluster_information = {
|
||||
'health': cluster_health,
|
||||
'health_msg': cluster_health_msg,
|
||||
'storage_health': storage_health,
|
||||
'storage_health_msg': storage_health_msg,
|
||||
'primary_node': common.getPrimaryNode(zkhandler),
|
||||
'upstream_ip': zkhandler.read('base.config.upstream_ip'),
|
||||
'nodes': formatted_node_states,
|
||||
'vms': formatted_vm_states,
|
||||
'networks': network_count,
|
||||
'osds': formatted_osd_states,
|
||||
'pools': ceph_pool_count,
|
||||
'volumes': ceph_volume_count,
|
||||
'snapshots': ceph_snapshot_count
|
||||
"health": cluster_health,
|
||||
"health_msg": cluster_health_msg,
|
||||
"storage_health": storage_health,
|
||||
"storage_health_msg": storage_health_msg,
|
||||
"primary_node": common.getPrimaryNode(zkhandler),
|
||||
"upstream_ip": zkhandler.read("base.config.upstream_ip"),
|
||||
"nodes": formatted_node_states,
|
||||
"vms": formatted_vm_states,
|
||||
"networks": network_count,
|
||||
"osds": formatted_osd_states,
|
||||
"pools": ceph_pool_count,
|
||||
"volumes": ceph_volume_count,
|
||||
"snapshots": ceph_snapshot_count,
|
||||
}
|
||||
|
||||
return cluster_information
|
||||
@ -258,29 +295,32 @@ def get_info(zkhandler):
|
||||
if cluster_information:
|
||||
return True, cluster_information
|
||||
else:
|
||||
return False, 'ERROR: Failed to obtain cluster information!'
|
||||
return False, "ERROR: Failed to obtain cluster information!"
|
||||
|
||||
|
||||
def cluster_initialize(zkhandler, overwrite=False):
|
||||
# Abort if we've initialized the cluster before
|
||||
if zkhandler.exists('base.config.primary_node') and not overwrite:
|
||||
return False, 'ERROR: Cluster contains data and overwrite not set.'
|
||||
if zkhandler.exists("base.config.primary_node") and not overwrite:
|
||||
return False, "ERROR: Cluster contains data and overwrite not set."
|
||||
|
||||
if overwrite:
|
||||
# Delete the existing keys
|
||||
for key in zkhandler.schema.keys('base'):
|
||||
if key == 'root':
|
||||
for key in zkhandler.schema.keys("base"):
|
||||
if key == "root":
|
||||
# Don't delete the root key
|
||||
continue
|
||||
|
||||
status = zkhandler.delete('base.{}'.format(key), recursive=True)
|
||||
status = zkhandler.delete("base.{}".format(key), recursive=True)
|
||||
if not status:
|
||||
return False, 'ERROR: Failed to delete data in cluster; running nodes perhaps?'
|
||||
return (
|
||||
False,
|
||||
"ERROR: Failed to delete data in cluster; running nodes perhaps?",
|
||||
)
|
||||
|
||||
# Create the root keys
|
||||
zkhandler.schema.apply(zkhandler)
|
||||
|
||||
return True, 'Successfully initialized cluster'
|
||||
return True, "Successfully initialized cluster"
|
||||
|
||||
|
||||
def cluster_backup(zkhandler):
|
||||
@ -294,25 +334,25 @@ def cluster_backup(zkhandler):
|
||||
cluster_data[path] = data
|
||||
|
||||
if children:
|
||||
if path == '/':
|
||||
child_prefix = '/'
|
||||
if path == "/":
|
||||
child_prefix = "/"
|
||||
else:
|
||||
child_prefix = path + '/'
|
||||
child_prefix = path + "/"
|
||||
|
||||
for child in children:
|
||||
if child_prefix + child == '/zookeeper':
|
||||
if child_prefix + child == "/zookeeper":
|
||||
# We must skip the built-in /zookeeper tree
|
||||
continue
|
||||
if child_prefix + child == '/patroni':
|
||||
if child_prefix + child == "/patroni":
|
||||
# We must skip the /patroni tree
|
||||
continue
|
||||
|
||||
get_data(child_prefix + child)
|
||||
|
||||
try:
|
||||
get_data('/')
|
||||
get_data("/")
|
||||
except Exception as e:
|
||||
return False, 'ERROR: Failed to obtain backup: {}'.format(e)
|
||||
return False, "ERROR: Failed to obtain backup: {}".format(e)
|
||||
|
||||
return True, cluster_data
|
||||
|
||||
@ -322,18 +362,23 @@ def cluster_restore(zkhandler, cluster_data):
|
||||
kv = []
|
||||
schema_version = None
|
||||
for key in cluster_data:
|
||||
if key == zkhandler.schema.path('base.schema.version'):
|
||||
if key == zkhandler.schema.path("base.schema.version"):
|
||||
schema_version = cluster_data[key]
|
||||
data = cluster_data[key]
|
||||
kv.append((key, data))
|
||||
|
||||
if int(schema_version) != int(zkhandler.schema.version):
|
||||
return False, 'ERROR: Schema version of backup ({}) does not match cluster schema version ({}).'.format(schema_version, zkhandler.schema.version)
|
||||
return (
|
||||
False,
|
||||
"ERROR: Schema version of backup ({}) does not match cluster schema version ({}).".format(
|
||||
schema_version, zkhandler.schema.version
|
||||
),
|
||||
)
|
||||
|
||||
# Close the Zookeeper connection
|
||||
result = zkhandler.write(kv)
|
||||
|
||||
if result:
|
||||
return True, 'Restore completed successfully.'
|
||||
return True, "Restore completed successfully."
|
||||
else:
|
||||
return False, 'Restore failed.'
|
||||
return False, "Restore failed."
|
||||
|
||||
@ -40,8 +40,8 @@ from functools import wraps
|
||||
# Get performance statistics on a function or class
|
||||
class Profiler(object):
|
||||
def __init__(self, config):
|
||||
self.is_debug = config['debug']
|
||||
self.pvc_logdir = '/var/log/pvc'
|
||||
self.is_debug = config["debug"]
|
||||
self.pvc_logdir = "/var/log/pvc"
|
||||
|
||||
def __call__(self, function):
|
||||
if not callable(function):
|
||||
@ -58,11 +58,15 @@ class Profiler(object):
|
||||
from datetime import datetime
|
||||
|
||||
if not path.exists(self.pvc_logdir):
|
||||
print('Profiler: Requested profiling of {} but no log dir present; printing instead.'.format(str(function.__name__)))
|
||||
print(
|
||||
"Profiler: Requested profiling of {} but no log dir present; printing instead.".format(
|
||||
str(function.__name__)
|
||||
)
|
||||
)
|
||||
log_result = False
|
||||
else:
|
||||
log_result = True
|
||||
profiler_logdir = '{}/profiler'.format(self.pvc_logdir)
|
||||
profiler_logdir = "{}/profiler".format(self.pvc_logdir)
|
||||
if not path.exists(profiler_logdir):
|
||||
makedirs(profiler_logdir)
|
||||
|
||||
@ -76,12 +80,23 @@ class Profiler(object):
|
||||
stats.sort_stats(pstats.SortKey.TIME)
|
||||
|
||||
if log_result:
|
||||
stats.dump_stats(filename='{}/{}_{}.log'.format(profiler_logdir, str(function.__name__), str(datetime.now()).replace(' ', '_')))
|
||||
stats.dump_stats(
|
||||
filename="{}/{}_{}.log".format(
|
||||
profiler_logdir,
|
||||
str(function.__name__),
|
||||
str(datetime.now()).replace(" ", "_"),
|
||||
)
|
||||
)
|
||||
else:
|
||||
print('Profiler stats for function {} at {}:'.format(str(function.__name__), str(datetime.now())))
|
||||
print(
|
||||
"Profiler stats for function {} at {}:".format(
|
||||
str(function.__name__), str(datetime.now())
|
||||
)
|
||||
)
|
||||
stats.print_stats()
|
||||
|
||||
return ret
|
||||
|
||||
return profiler_wrapper
|
||||
|
||||
|
||||
@ -97,7 +112,7 @@ class OSDaemon(object):
|
||||
command = shlex_split(command_string)
|
||||
# Set stdout to be a logfile if set
|
||||
if logfile:
|
||||
stdout = open(logfile, 'a')
|
||||
stdout = open(logfile, "a")
|
||||
else:
|
||||
stdout = subprocess.PIPE
|
||||
|
||||
@ -112,10 +127,10 @@ class OSDaemon(object):
|
||||
# Signal the process
|
||||
def signal(self, sent_signal):
|
||||
signal_map = {
|
||||
'hup': signal.SIGHUP,
|
||||
'int': signal.SIGINT,
|
||||
'term': signal.SIGTERM,
|
||||
'kill': signal.SIGKILL
|
||||
"hup": signal.SIGHUP,
|
||||
"int": signal.SIGINT,
|
||||
"term": signal.SIGTERM,
|
||||
"kill": signal.SIGKILL,
|
||||
}
|
||||
self.proc.send_signal(signal_map[sent_signal])
|
||||
|
||||
@ -131,6 +146,7 @@ def run_os_daemon(command_string, environment=None, logfile=None):
|
||||
def run_os_command(command_string, background=False, environment=None, timeout=None):
|
||||
command = shlex_split(command_string)
|
||||
if background:
|
||||
|
||||
def runcmd():
|
||||
try:
|
||||
subprocess.run(
|
||||
@ -142,6 +158,7 @@ def run_os_command(command_string, background=False, environment=None, timeout=N
|
||||
)
|
||||
except subprocess.TimeoutExpired:
|
||||
pass
|
||||
|
||||
thread = Thread(target=runcmd, args=())
|
||||
thread.start()
|
||||
return 0, None, None
|
||||
@ -161,13 +178,13 @@ def run_os_command(command_string, background=False, environment=None, timeout=N
|
||||
retcode = 255
|
||||
|
||||
try:
|
||||
stdout = command_output.stdout.decode('ascii')
|
||||
stdout = command_output.stdout.decode("ascii")
|
||||
except Exception:
|
||||
stdout = ''
|
||||
stdout = ""
|
||||
try:
|
||||
stderr = command_output.stderr.decode('ascii')
|
||||
stderr = command_output.stderr.decode("ascii")
|
||||
except Exception:
|
||||
stderr = ''
|
||||
stderr = ""
|
||||
return retcode, stdout, stderr
|
||||
|
||||
|
||||
@ -187,7 +204,7 @@ def validateUUID(dom_uuid):
|
||||
#
|
||||
def getDomainXML(zkhandler, dom_uuid):
|
||||
try:
|
||||
xml = zkhandler.read(('domain.xml', dom_uuid))
|
||||
xml = zkhandler.read(("domain.xml", dom_uuid))
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
@ -208,16 +225,20 @@ def getDomainMainDetails(parsed_xml):
|
||||
ddescription = "N/A"
|
||||
dname = str(parsed_xml.name)
|
||||
dmemory = str(parsed_xml.memory)
|
||||
dmemory_unit = str(parsed_xml.memory.attrib.get('unit'))
|
||||
if dmemory_unit == 'KiB':
|
||||
dmemory_unit = str(parsed_xml.memory.attrib.get("unit"))
|
||||
if dmemory_unit == "KiB":
|
||||
dmemory = int(int(dmemory) / 1024)
|
||||
elif dmemory_unit == 'GiB':
|
||||
elif dmemory_unit == "GiB":
|
||||
dmemory = int(int(dmemory) * 1024)
|
||||
dvcpu = str(parsed_xml.vcpu)
|
||||
try:
|
||||
dvcputopo = '{}/{}/{}'.format(parsed_xml.cpu.topology.attrib.get('sockets'), parsed_xml.cpu.topology.attrib.get('cores'), parsed_xml.cpu.topology.attrib.get('threads'))
|
||||
dvcputopo = "{}/{}/{}".format(
|
||||
parsed_xml.cpu.topology.attrib.get("sockets"),
|
||||
parsed_xml.cpu.topology.attrib.get("cores"),
|
||||
parsed_xml.cpu.topology.attrib.get("threads"),
|
||||
)
|
||||
except Exception:
|
||||
dvcputopo = 'N/A'
|
||||
dvcputopo = "N/A"
|
||||
|
||||
return duuid, dname, ddescription, dmemory, dvcpu, dvcputopo
|
||||
|
||||
@ -227,9 +248,9 @@ def getDomainMainDetails(parsed_xml):
|
||||
#
|
||||
def getDomainExtraDetails(parsed_xml):
|
||||
dtype = str(parsed_xml.os.type)
|
||||
darch = str(parsed_xml.os.type.attrib['arch'])
|
||||
dmachine = str(parsed_xml.os.type.attrib['machine'])
|
||||
dconsole = str(parsed_xml.devices.console.attrib['type'])
|
||||
darch = str(parsed_xml.os.type.attrib["arch"])
|
||||
dmachine = str(parsed_xml.os.type.attrib["machine"])
|
||||
dconsole = str(parsed_xml.devices.console.attrib["type"])
|
||||
demulator = str(parsed_xml.devices.emulator)
|
||||
|
||||
return dtype, darch, dmachine, dconsole, demulator
|
||||
@ -255,37 +276,41 @@ def getDomainCPUFeatures(parsed_xml):
|
||||
def getDomainDisks(parsed_xml, stats_data):
|
||||
ddisks = []
|
||||
for device in parsed_xml.devices.getchildren():
|
||||
if device.tag == 'disk':
|
||||
if device.tag == "disk":
|
||||
disk_attrib = device.source.attrib
|
||||
disk_target = device.target.attrib
|
||||
disk_type = device.attrib.get('type')
|
||||
disk_stats_list = [x for x in stats_data.get('disk_stats', []) if x.get('name') == disk_attrib.get('name')]
|
||||
disk_type = device.attrib.get("type")
|
||||
disk_stats_list = [
|
||||
x
|
||||
for x in stats_data.get("disk_stats", [])
|
||||
if x.get("name") == disk_attrib.get("name")
|
||||
]
|
||||
try:
|
||||
disk_stats = disk_stats_list[0]
|
||||
except Exception:
|
||||
disk_stats = {}
|
||||
|
||||
if disk_type == 'network':
|
||||
if disk_type == "network":
|
||||
disk_obj = {
|
||||
'type': disk_attrib.get('protocol'),
|
||||
'name': disk_attrib.get('name'),
|
||||
'dev': disk_target.get('dev'),
|
||||
'bus': disk_target.get('bus'),
|
||||
'rd_req': disk_stats.get('rd_req', 0),
|
||||
'rd_bytes': disk_stats.get('rd_bytes', 0),
|
||||
'wr_req': disk_stats.get('wr_req', 0),
|
||||
'wr_bytes': disk_stats.get('wr_bytes', 0)
|
||||
"type": disk_attrib.get("protocol"),
|
||||
"name": disk_attrib.get("name"),
|
||||
"dev": disk_target.get("dev"),
|
||||
"bus": disk_target.get("bus"),
|
||||
"rd_req": disk_stats.get("rd_req", 0),
|
||||
"rd_bytes": disk_stats.get("rd_bytes", 0),
|
||||
"wr_req": disk_stats.get("wr_req", 0),
|
||||
"wr_bytes": disk_stats.get("wr_bytes", 0),
|
||||
}
|
||||
elif disk_type == 'file':
|
||||
elif disk_type == "file":
|
||||
disk_obj = {
|
||||
'type': 'file',
|
||||
'name': disk_attrib.get('file'),
|
||||
'dev': disk_target.get('dev'),
|
||||
'bus': disk_target.get('bus'),
|
||||
'rd_req': disk_stats.get('rd_req', 0),
|
||||
'rd_bytes': disk_stats.get('rd_bytes', 0),
|
||||
'wr_req': disk_stats.get('wr_req', 0),
|
||||
'wr_bytes': disk_stats.get('wr_bytes', 0)
|
||||
"type": "file",
|
||||
"name": disk_attrib.get("file"),
|
||||
"dev": disk_target.get("dev"),
|
||||
"bus": disk_target.get("bus"),
|
||||
"rd_req": disk_stats.get("rd_req", 0),
|
||||
"rd_bytes": disk_stats.get("rd_bytes", 0),
|
||||
"wr_req": disk_stats.get("wr_req", 0),
|
||||
"wr_bytes": disk_stats.get("wr_bytes", 0),
|
||||
}
|
||||
else:
|
||||
disk_obj = {}
|
||||
@ -300,8 +325,8 @@ def getDomainDisks(parsed_xml, stats_data):
|
||||
def getDomainDiskList(zkhandler, dom_uuid):
|
||||
domain_information = getInformationFromXML(zkhandler, dom_uuid)
|
||||
disk_list = []
|
||||
for disk in domain_information['disks']:
|
||||
disk_list.append(disk['name'])
|
||||
for disk in domain_information["disks"]:
|
||||
disk_list.append(disk["name"])
|
||||
|
||||
return disk_list
|
||||
|
||||
@ -317,10 +342,14 @@ def getDomainTags(zkhandler, dom_uuid):
|
||||
"""
|
||||
tags = list()
|
||||
|
||||
for tag in zkhandler.children(('domain.meta.tags', dom_uuid)):
|
||||
tag_type = zkhandler.read(('domain.meta.tags', dom_uuid, 'tag.type', tag))
|
||||
protected = bool(strtobool(zkhandler.read(('domain.meta.tags', dom_uuid, 'tag.protected', tag))))
|
||||
tags.append({'name': tag, 'type': tag_type, 'protected': protected})
|
||||
for tag in zkhandler.children(("domain.meta.tags", dom_uuid)):
|
||||
tag_type = zkhandler.read(("domain.meta.tags", dom_uuid, "tag.type", tag))
|
||||
protected = bool(
|
||||
strtobool(
|
||||
zkhandler.read(("domain.meta.tags", dom_uuid, "tag.protected", tag))
|
||||
)
|
||||
)
|
||||
tags.append({"name": tag, "type": tag_type, "protected": protected})
|
||||
|
||||
return tags
|
||||
|
||||
@ -334,20 +363,25 @@ def getDomainMetadata(zkhandler, dom_uuid):
|
||||
|
||||
The UUID must be validated before calling this function!
|
||||
"""
|
||||
domain_node_limit = zkhandler.read(('domain.meta.node_limit', dom_uuid))
|
||||
domain_node_selector = zkhandler.read(('domain.meta.node_selector', dom_uuid))
|
||||
domain_node_autostart = zkhandler.read(('domain.meta.autostart', dom_uuid))
|
||||
domain_migration_method = zkhandler.read(('domain.meta.migrate_method', dom_uuid))
|
||||
domain_node_limit = zkhandler.read(("domain.meta.node_limit", dom_uuid))
|
||||
domain_node_selector = zkhandler.read(("domain.meta.node_selector", dom_uuid))
|
||||
domain_node_autostart = zkhandler.read(("domain.meta.autostart", dom_uuid))
|
||||
domain_migration_method = zkhandler.read(("domain.meta.migrate_method", dom_uuid))
|
||||
|
||||
if not domain_node_limit:
|
||||
domain_node_limit = None
|
||||
else:
|
||||
domain_node_limit = domain_node_limit.split(',')
|
||||
domain_node_limit = domain_node_limit.split(",")
|
||||
|
||||
if not domain_node_autostart:
|
||||
domain_node_autostart = None
|
||||
|
||||
return domain_node_limit, domain_node_selector, domain_node_autostart, domain_migration_method
|
||||
return (
|
||||
domain_node_limit,
|
||||
domain_node_selector,
|
||||
domain_node_autostart,
|
||||
domain_migration_method,
|
||||
)
|
||||
|
||||
|
||||
#
|
||||
@ -358,25 +392,30 @@ def getInformationFromXML(zkhandler, uuid):
|
||||
Gather information about a VM from the Libvirt XML configuration in the Zookeper database
|
||||
and return a dict() containing it.
|
||||
"""
|
||||
domain_state = zkhandler.read(('domain.state', uuid))
|
||||
domain_node = zkhandler.read(('domain.node', uuid))
|
||||
domain_lastnode = zkhandler.read(('domain.last_node', uuid))
|
||||
domain_failedreason = zkhandler.read(('domain.failed_reason', uuid))
|
||||
domain_state = zkhandler.read(("domain.state", uuid))
|
||||
domain_node = zkhandler.read(("domain.node", uuid))
|
||||
domain_lastnode = zkhandler.read(("domain.last_node", uuid))
|
||||
domain_failedreason = zkhandler.read(("domain.failed_reason", uuid))
|
||||
|
||||
domain_node_limit, domain_node_selector, domain_node_autostart, domain_migration_method = getDomainMetadata(zkhandler, uuid)
|
||||
(
|
||||
domain_node_limit,
|
||||
domain_node_selector,
|
||||
domain_node_autostart,
|
||||
domain_migration_method,
|
||||
) = getDomainMetadata(zkhandler, uuid)
|
||||
domain_tags = getDomainTags(zkhandler, uuid)
|
||||
domain_profile = zkhandler.read(('domain.profile', uuid))
|
||||
domain_profile = zkhandler.read(("domain.profile", uuid))
|
||||
|
||||
domain_vnc = zkhandler.read(('domain.console.vnc', uuid))
|
||||
domain_vnc = zkhandler.read(("domain.console.vnc", uuid))
|
||||
if domain_vnc:
|
||||
domain_vnc_listen, domain_vnc_port = domain_vnc.split(':')
|
||||
domain_vnc_listen, domain_vnc_port = domain_vnc.split(":")
|
||||
else:
|
||||
domain_vnc_listen = 'None'
|
||||
domain_vnc_port = 'None'
|
||||
domain_vnc_listen = "None"
|
||||
domain_vnc_port = "None"
|
||||
|
||||
parsed_xml = getDomainXML(zkhandler, uuid)
|
||||
|
||||
stats_data = zkhandler.read(('domain.stats', uuid))
|
||||
stats_data = zkhandler.read(("domain.stats", uuid))
|
||||
if stats_data is not None:
|
||||
try:
|
||||
stats_data = loads(stats_data)
|
||||
@ -385,54 +424,66 @@ def getInformationFromXML(zkhandler, uuid):
|
||||
else:
|
||||
stats_data = {}
|
||||
|
||||
domain_uuid, domain_name, domain_description, domain_memory, domain_vcpu, domain_vcputopo = getDomainMainDetails(parsed_xml)
|
||||
(
|
||||
domain_uuid,
|
||||
domain_name,
|
||||
domain_description,
|
||||
domain_memory,
|
||||
domain_vcpu,
|
||||
domain_vcputopo,
|
||||
) = getDomainMainDetails(parsed_xml)
|
||||
domain_networks = getDomainNetworks(parsed_xml, stats_data)
|
||||
|
||||
domain_type, domain_arch, domain_machine, domain_console, domain_emulator = getDomainExtraDetails(parsed_xml)
|
||||
(
|
||||
domain_type,
|
||||
domain_arch,
|
||||
domain_machine,
|
||||
domain_console,
|
||||
domain_emulator,
|
||||
) = getDomainExtraDetails(parsed_xml)
|
||||
|
||||
domain_features = getDomainCPUFeatures(parsed_xml)
|
||||
domain_disks = getDomainDisks(parsed_xml, stats_data)
|
||||
domain_controllers = getDomainControllers(parsed_xml)
|
||||
|
||||
if domain_lastnode:
|
||||
domain_migrated = 'from {}'.format(domain_lastnode)
|
||||
domain_migrated = "from {}".format(domain_lastnode)
|
||||
else:
|
||||
domain_migrated = 'no'
|
||||
domain_migrated = "no"
|
||||
|
||||
domain_information = {
|
||||
'name': domain_name,
|
||||
'uuid': domain_uuid,
|
||||
'state': domain_state,
|
||||
'node': domain_node,
|
||||
'last_node': domain_lastnode,
|
||||
'migrated': domain_migrated,
|
||||
'failed_reason': domain_failedreason,
|
||||
'node_limit': domain_node_limit,
|
||||
'node_selector': domain_node_selector,
|
||||
'node_autostart': bool(strtobool(domain_node_autostart)),
|
||||
'migration_method': domain_migration_method,
|
||||
'tags': domain_tags,
|
||||
'description': domain_description,
|
||||
'profile': domain_profile,
|
||||
'memory': int(domain_memory),
|
||||
'memory_stats': stats_data.get('mem_stats', {}),
|
||||
'vcpu': int(domain_vcpu),
|
||||
'vcpu_topology': domain_vcputopo,
|
||||
'vcpu_stats': stats_data.get('cpu_stats', {}),
|
||||
'networks': domain_networks,
|
||||
'type': domain_type,
|
||||
'arch': domain_arch,
|
||||
'machine': domain_machine,
|
||||
'console': domain_console,
|
||||
'vnc': {
|
||||
'listen': domain_vnc_listen,
|
||||
'port': domain_vnc_port
|
||||
},
|
||||
'emulator': domain_emulator,
|
||||
'features': domain_features,
|
||||
'disks': domain_disks,
|
||||
'controllers': domain_controllers,
|
||||
'xml': lxml.etree.tostring(parsed_xml, encoding='ascii', method='xml').decode().replace('\"', '\'')
|
||||
"name": domain_name,
|
||||
"uuid": domain_uuid,
|
||||
"state": domain_state,
|
||||
"node": domain_node,
|
||||
"last_node": domain_lastnode,
|
||||
"migrated": domain_migrated,
|
||||
"failed_reason": domain_failedreason,
|
||||
"node_limit": domain_node_limit,
|
||||
"node_selector": domain_node_selector,
|
||||
"node_autostart": bool(strtobool(domain_node_autostart)),
|
||||
"migration_method": domain_migration_method,
|
||||
"tags": domain_tags,
|
||||
"description": domain_description,
|
||||
"profile": domain_profile,
|
||||
"memory": int(domain_memory),
|
||||
"memory_stats": stats_data.get("mem_stats", {}),
|
||||
"vcpu": int(domain_vcpu),
|
||||
"vcpu_topology": domain_vcputopo,
|
||||
"vcpu_stats": stats_data.get("cpu_stats", {}),
|
||||
"networks": domain_networks,
|
||||
"type": domain_type,
|
||||
"arch": domain_arch,
|
||||
"machine": domain_machine,
|
||||
"console": domain_console,
|
||||
"vnc": {"listen": domain_vnc_listen, "port": domain_vnc_port},
|
||||
"emulator": domain_emulator,
|
||||
"features": domain_features,
|
||||
"disks": domain_disks,
|
||||
"controllers": domain_controllers,
|
||||
"xml": lxml.etree.tostring(parsed_xml, encoding="ascii", method="xml")
|
||||
.decode()
|
||||
.replace('"', "'"),
|
||||
}
|
||||
|
||||
return domain_information
|
||||
@ -444,14 +495,14 @@ def getInformationFromXML(zkhandler, uuid):
|
||||
def getDomainNetworks(parsed_xml, stats_data):
|
||||
dnets = []
|
||||
for device in parsed_xml.devices.getchildren():
|
||||
if device.tag == 'interface':
|
||||
if device.tag == "interface":
|
||||
try:
|
||||
net_type = device.attrib.get('type')
|
||||
net_type = device.attrib.get("type")
|
||||
except Exception:
|
||||
net_type = None
|
||||
|
||||
try:
|
||||
net_mac = device.mac.attrib.get('address')
|
||||
net_mac = device.mac.attrib.get("address")
|
||||
except Exception:
|
||||
net_mac = None
|
||||
|
||||
@ -461,48 +512,52 @@ def getDomainNetworks(parsed_xml, stats_data):
|
||||
net_bridge = None
|
||||
|
||||
try:
|
||||
net_model = device.model.attrib.get('type')
|
||||
net_model = device.model.attrib.get("type")
|
||||
except Exception:
|
||||
net_model = None
|
||||
|
||||
try:
|
||||
net_stats_list = [x for x in stats_data.get('net_stats', []) if x.get('bridge') == net_bridge]
|
||||
net_stats_list = [
|
||||
x
|
||||
for x in stats_data.get("net_stats", [])
|
||||
if x.get("bridge") == net_bridge
|
||||
]
|
||||
net_stats = net_stats_list[0]
|
||||
except Exception:
|
||||
net_stats = {}
|
||||
|
||||
net_rd_bytes = net_stats.get('rd_bytes', 0)
|
||||
net_rd_packets = net_stats.get('rd_packets', 0)
|
||||
net_rd_errors = net_stats.get('rd_errors', 0)
|
||||
net_rd_drops = net_stats.get('rd_drops', 0)
|
||||
net_wr_bytes = net_stats.get('wr_bytes', 0)
|
||||
net_wr_packets = net_stats.get('wr_packets', 0)
|
||||
net_wr_errors = net_stats.get('wr_errors', 0)
|
||||
net_wr_drops = net_stats.get('wr_drops', 0)
|
||||
net_rd_bytes = net_stats.get("rd_bytes", 0)
|
||||
net_rd_packets = net_stats.get("rd_packets", 0)
|
||||
net_rd_errors = net_stats.get("rd_errors", 0)
|
||||
net_rd_drops = net_stats.get("rd_drops", 0)
|
||||
net_wr_bytes = net_stats.get("wr_bytes", 0)
|
||||
net_wr_packets = net_stats.get("wr_packets", 0)
|
||||
net_wr_errors = net_stats.get("wr_errors", 0)
|
||||
net_wr_drops = net_stats.get("wr_drops", 0)
|
||||
|
||||
if net_type == 'direct':
|
||||
net_vni = 'macvtap:' + device.source.attrib.get('dev')
|
||||
net_bridge = device.source.attrib.get('dev')
|
||||
elif net_type == 'hostdev':
|
||||
net_vni = 'hostdev:' + str(device.sriov_device)
|
||||
if net_type == "direct":
|
||||
net_vni = "macvtap:" + device.source.attrib.get("dev")
|
||||
net_bridge = device.source.attrib.get("dev")
|
||||
elif net_type == "hostdev":
|
||||
net_vni = "hostdev:" + str(device.sriov_device)
|
||||
net_bridge = str(device.sriov_device)
|
||||
else:
|
||||
net_vni = re_match(r'[vm]*br([0-9a-z]+)', net_bridge).group(1)
|
||||
net_vni = re_match(r"[vm]*br([0-9a-z]+)", net_bridge).group(1)
|
||||
|
||||
net_obj = {
|
||||
'type': net_type,
|
||||
'vni': net_vni,
|
||||
'mac': net_mac,
|
||||
'source': net_bridge,
|
||||
'model': net_model,
|
||||
'rd_bytes': net_rd_bytes,
|
||||
'rd_packets': net_rd_packets,
|
||||
'rd_errors': net_rd_errors,
|
||||
'rd_drops': net_rd_drops,
|
||||
'wr_bytes': net_wr_bytes,
|
||||
'wr_packets': net_wr_packets,
|
||||
'wr_errors': net_wr_errors,
|
||||
'wr_drops': net_wr_drops
|
||||
"type": net_type,
|
||||
"vni": net_vni,
|
||||
"mac": net_mac,
|
||||
"source": net_bridge,
|
||||
"model": net_model,
|
||||
"rd_bytes": net_rd_bytes,
|
||||
"rd_packets": net_rd_packets,
|
||||
"rd_errors": net_rd_errors,
|
||||
"rd_drops": net_rd_drops,
|
||||
"wr_bytes": net_wr_bytes,
|
||||
"wr_packets": net_wr_packets,
|
||||
"wr_errors": net_wr_errors,
|
||||
"wr_drops": net_wr_drops,
|
||||
}
|
||||
dnets.append(net_obj)
|
||||
|
||||
@ -515,13 +570,13 @@ def getDomainNetworks(parsed_xml, stats_data):
|
||||
def getDomainControllers(parsed_xml):
|
||||
dcontrollers = []
|
||||
for device in parsed_xml.devices.getchildren():
|
||||
if device.tag == 'controller':
|
||||
controller_type = device.attrib.get('type')
|
||||
if device.tag == "controller":
|
||||
controller_type = device.attrib.get("type")
|
||||
try:
|
||||
controller_model = device.attrib.get('model')
|
||||
controller_model = device.attrib.get("model")
|
||||
except KeyError:
|
||||
controller_model = 'none'
|
||||
controller_obj = {'type': controller_type, 'model': controller_model}
|
||||
controller_model = "none"
|
||||
controller_obj = {"type": controller_type, "model": controller_model}
|
||||
dcontrollers.append(controller_obj)
|
||||
|
||||
return dcontrollers
|
||||
@ -531,7 +586,7 @@ def getDomainControllers(parsed_xml):
|
||||
# Verify node is valid in cluster
|
||||
#
|
||||
def verifyNode(zkhandler, node):
|
||||
return zkhandler.exists(('node', node))
|
||||
return zkhandler.exists(("node", node))
|
||||
|
||||
|
||||
#
|
||||
@ -541,11 +596,11 @@ def getPrimaryNode(zkhandler):
|
||||
failcount = 0
|
||||
while True:
|
||||
try:
|
||||
primary_node = zkhandler.read('base.config.primary_node')
|
||||
primary_node = zkhandler.read("base.config.primary_node")
|
||||
except Exception:
|
||||
primary_node == 'none'
|
||||
primary_node == "none"
|
||||
|
||||
if primary_node == 'none':
|
||||
if primary_node == "none":
|
||||
raise
|
||||
time.sleep(1)
|
||||
failcount += 1
|
||||
@ -565,7 +620,7 @@ def getPrimaryNode(zkhandler):
|
||||
def findTargetNode(zkhandler, dom_uuid):
|
||||
# Determine VM node limits; set config value if read fails
|
||||
try:
|
||||
node_limit = zkhandler.read(('domain.meta.node_limit', dom_uuid)).split(',')
|
||||
node_limit = zkhandler.read(("domain.meta.node_limit", dom_uuid)).split(",")
|
||||
if not any(node_limit):
|
||||
node_limit = None
|
||||
except Exception:
|
||||
@ -573,22 +628,22 @@ def findTargetNode(zkhandler, dom_uuid):
|
||||
|
||||
# Determine VM search field or use default; set config value if read fails
|
||||
try:
|
||||
search_field = zkhandler.read(('domain.meta.node_selector', dom_uuid))
|
||||
search_field = zkhandler.read(("domain.meta.node_selector", dom_uuid))
|
||||
except Exception:
|
||||
search_field = None
|
||||
|
||||
# If our search field is invalid, use the default
|
||||
if search_field is None or search_field == 'None':
|
||||
search_field = zkhandler.read('base.config.migration_target_selector')
|
||||
if search_field is None or search_field == "None":
|
||||
search_field = zkhandler.read("base.config.migration_target_selector")
|
||||
|
||||
# Execute the search
|
||||
if search_field == 'mem':
|
||||
if search_field == "mem":
|
||||
return findTargetNodeMem(zkhandler, node_limit, dom_uuid)
|
||||
if search_field == 'load':
|
||||
if search_field == "load":
|
||||
return findTargetNodeLoad(zkhandler, node_limit, dom_uuid)
|
||||
if search_field == 'vcpus':
|
||||
if search_field == "vcpus":
|
||||
return findTargetNodeVCPUs(zkhandler, node_limit, dom_uuid)
|
||||
if search_field == 'vms':
|
||||
if search_field == "vms":
|
||||
return findTargetNodeVMs(zkhandler, node_limit, dom_uuid)
|
||||
|
||||
# Nothing was found
|
||||
@ -600,20 +655,20 @@ def findTargetNode(zkhandler, dom_uuid):
|
||||
#
|
||||
def getNodes(zkhandler, node_limit, dom_uuid):
|
||||
valid_node_list = []
|
||||
full_node_list = zkhandler.children('base.node')
|
||||
current_node = zkhandler.read(('domain.node', dom_uuid))
|
||||
full_node_list = zkhandler.children("base.node")
|
||||
current_node = zkhandler.read(("domain.node", dom_uuid))
|
||||
|
||||
for node in full_node_list:
|
||||
if node_limit and node not in node_limit:
|
||||
continue
|
||||
|
||||
daemon_state = zkhandler.read(('node.state.daemon', node))
|
||||
domain_state = zkhandler.read(('node.state.domain', node))
|
||||
daemon_state = zkhandler.read(("node.state.daemon", node))
|
||||
domain_state = zkhandler.read(("node.state.domain", node))
|
||||
|
||||
if node == current_node:
|
||||
continue
|
||||
|
||||
if daemon_state != 'run' or domain_state != 'ready':
|
||||
if daemon_state != "run" or domain_state != "ready":
|
||||
continue
|
||||
|
||||
valid_node_list.append(node)
|
||||
@ -630,9 +685,9 @@ def findTargetNodeMem(zkhandler, node_limit, dom_uuid):
|
||||
|
||||
node_list = getNodes(zkhandler, node_limit, dom_uuid)
|
||||
for node in node_list:
|
||||
memprov = int(zkhandler.read(('node.memory.provisioned', node)))
|
||||
memused = int(zkhandler.read(('node.memory.used', node)))
|
||||
memfree = int(zkhandler.read(('node.memory.free', node)))
|
||||
memprov = int(zkhandler.read(("node.memory.provisioned", node)))
|
||||
memused = int(zkhandler.read(("node.memory.used", node)))
|
||||
memfree = int(zkhandler.read(("node.memory.free", node)))
|
||||
memtotal = memused + memfree
|
||||
provfree = memtotal - memprov
|
||||
|
||||
@ -652,7 +707,7 @@ def findTargetNodeLoad(zkhandler, node_limit, dom_uuid):
|
||||
|
||||
node_list = getNodes(zkhandler, node_limit, dom_uuid)
|
||||
for node in node_list:
|
||||
load = float(zkhandler.read(('node.cpu.load', node)))
|
||||
load = float(zkhandler.read(("node.cpu.load", node)))
|
||||
|
||||
if load < least_load:
|
||||
least_load = load
|
||||
@ -670,7 +725,7 @@ def findTargetNodeVCPUs(zkhandler, node_limit, dom_uuid):
|
||||
|
||||
node_list = getNodes(zkhandler, node_limit, dom_uuid)
|
||||
for node in node_list:
|
||||
vcpus = int(zkhandler.read(('node.vcpu.allocated', node)))
|
||||
vcpus = int(zkhandler.read(("node.vcpu.allocated", node)))
|
||||
|
||||
if vcpus < least_vcpus:
|
||||
least_vcpus = vcpus
|
||||
@ -688,7 +743,7 @@ def findTargetNodeVMs(zkhandler, node_limit, dom_uuid):
|
||||
|
||||
node_list = getNodes(zkhandler, node_limit, dom_uuid)
|
||||
for node in node_list:
|
||||
vms = int(zkhandler.read(('node.count.provisioned_domains', node)))
|
||||
vms = int(zkhandler.read(("node.count.provisioned_domains", node)))
|
||||
|
||||
if vms < least_vms:
|
||||
least_vms = vms
|
||||
@ -710,25 +765,33 @@ def runRemoteCommand(node, command, become=False):
|
||||
class DnssecPolicy(paramiko.client.MissingHostKeyPolicy):
|
||||
def missing_host_key(self, client, hostname, key):
|
||||
sshfp_expect = hashlib.sha1(key.asbytes()).hexdigest()
|
||||
ans = dns.resolver.query(hostname, 'SSHFP')
|
||||
ans = dns.resolver.query(hostname, "SSHFP")
|
||||
if not ans.response.flags & dns.flags.DO:
|
||||
raise AssertionError('Answer is not DNSSEC signed')
|
||||
raise AssertionError("Answer is not DNSSEC signed")
|
||||
for answer in ans.response.answer:
|
||||
for item in answer.items:
|
||||
if sshfp_expect in item.to_text():
|
||||
client._log(paramiko.common.DEBUG, 'Found {} in SSHFP for host {}'.format(key.get_name(), hostname))
|
||||
client._log(
|
||||
paramiko.common.DEBUG,
|
||||
"Found {} in SSHFP for host {}".format(
|
||||
key.get_name(), hostname
|
||||
),
|
||||
)
|
||||
return
|
||||
raise AssertionError('SSHFP not published in DNS')
|
||||
raise AssertionError("SSHFP not published in DNS")
|
||||
|
||||
if become:
|
||||
command = 'sudo ' + command
|
||||
command = "sudo " + command
|
||||
|
||||
ssh_client = paramiko.client.SSHClient()
|
||||
ssh_client.load_system_host_keys()
|
||||
ssh_client.set_missing_host_key_policy(DnssecPolicy())
|
||||
ssh_client.connect(node)
|
||||
stdin, stdout, stderr = ssh_client.exec_command(command)
|
||||
return stdout.read().decode('ascii').rstrip(), stderr.read().decode('ascii').rstrip()
|
||||
return (
|
||||
stdout.read().decode("ascii").rstrip(),
|
||||
stderr.read().decode("ascii").rstrip(),
|
||||
)
|
||||
|
||||
|
||||
#
|
||||
@ -736,29 +799,20 @@ def runRemoteCommand(node, command, become=False):
|
||||
#
|
||||
def reload_firewall_rules(rules_file, logger=None):
|
||||
if logger is not None:
|
||||
logger.out('Reloading firewall configuration', state='o')
|
||||
logger.out("Reloading firewall configuration", state="o")
|
||||
|
||||
retcode, stdout, stderr = run_os_command('/usr/sbin/nft -f {}'.format(rules_file))
|
||||
retcode, stdout, stderr = run_os_command("/usr/sbin/nft -f {}".format(rules_file))
|
||||
if retcode != 0 and logger is not None:
|
||||
logger.out('Failed to reload configuration: {}'.format(stderr), state='e')
|
||||
logger.out("Failed to reload configuration: {}".format(stderr), state="e")
|
||||
|
||||
|
||||
#
|
||||
# Create an IP address
|
||||
#
|
||||
def createIPAddress(ipaddr, cidrnetmask, dev):
|
||||
run_os_command("ip address add {}/{} dev {}".format(ipaddr, cidrnetmask, dev))
|
||||
run_os_command(
|
||||
'ip address add {}/{} dev {}'.format(
|
||||
ipaddr,
|
||||
cidrnetmask,
|
||||
dev
|
||||
)
|
||||
)
|
||||
run_os_command(
|
||||
'arping -P -U -W 0.02 -c 2 -i {dev} -S {ip} {ip}'.format(
|
||||
dev=dev,
|
||||
ip=ipaddr
|
||||
)
|
||||
"arping -P -U -W 0.02 -c 2 -i {dev} -S {ip} {ip}".format(dev=dev, ip=ipaddr)
|
||||
)
|
||||
|
||||
|
||||
@ -766,13 +820,7 @@ def createIPAddress(ipaddr, cidrnetmask, dev):
|
||||
# Remove an IP address
|
||||
#
|
||||
def removeIPAddress(ipaddr, cidrnetmask, dev):
|
||||
run_os_command(
|
||||
'ip address delete {}/{} dev {}'.format(
|
||||
ipaddr,
|
||||
cidrnetmask,
|
||||
dev
|
||||
)
|
||||
)
|
||||
run_os_command("ip address delete {}/{} dev {}".format(ipaddr, cidrnetmask, dev))
|
||||
|
||||
|
||||
#
|
||||
@ -792,6 +840,6 @@ def sortInterfaceNames(interface_names):
|
||||
http://nedbatchelder.com/blog/200712/human_sorting.html
|
||||
(See Toothy's implementation in the comments)
|
||||
"""
|
||||
return [atoi(c) for c in re_split(r'(\d+)', text)]
|
||||
return [atoi(c) for c in re_split(r"(\d+)", text)]
|
||||
|
||||
return sorted(interface_names, key=natural_keys)
|
||||
|
||||
@ -34,56 +34,56 @@ class Logger(object):
|
||||
# formatted in various ways based off secondary characteristics.
|
||||
|
||||
# ANSII colours for output
|
||||
fmt_red = '\033[91m'
|
||||
fmt_green = '\033[92m'
|
||||
fmt_yellow = '\033[93m'
|
||||
fmt_blue = '\033[94m'
|
||||
fmt_purple = '\033[95m'
|
||||
fmt_cyan = '\033[96m'
|
||||
fmt_white = '\033[97m'
|
||||
fmt_bold = '\033[1m'
|
||||
fmt_end = '\033[0m'
|
||||
fmt_red = "\033[91m"
|
||||
fmt_green = "\033[92m"
|
||||
fmt_yellow = "\033[93m"
|
||||
fmt_blue = "\033[94m"
|
||||
fmt_purple = "\033[95m"
|
||||
fmt_cyan = "\033[96m"
|
||||
fmt_white = "\033[97m"
|
||||
fmt_bold = "\033[1m"
|
||||
fmt_end = "\033[0m"
|
||||
|
||||
last_colour = ''
|
||||
last_prompt = ''
|
||||
last_colour = ""
|
||||
last_prompt = ""
|
||||
|
||||
# Format maps
|
||||
format_map_colourized = {
|
||||
# Colourized formatting with chevron prompts (log_colours = True)
|
||||
'o': {'colour': fmt_green, 'prompt': '>>> '},
|
||||
'e': {'colour': fmt_red, 'prompt': '>>> '},
|
||||
'w': {'colour': fmt_yellow, 'prompt': '>>> '},
|
||||
't': {'colour': fmt_purple, 'prompt': '>>> '},
|
||||
'i': {'colour': fmt_blue, 'prompt': '>>> '},
|
||||
's': {'colour': fmt_cyan, 'prompt': '>>> '},
|
||||
'd': {'colour': fmt_white, 'prompt': '>>> '},
|
||||
'x': {'colour': last_colour, 'prompt': last_prompt}
|
||||
"o": {"colour": fmt_green, "prompt": ">>> "},
|
||||
"e": {"colour": fmt_red, "prompt": ">>> "},
|
||||
"w": {"colour": fmt_yellow, "prompt": ">>> "},
|
||||
"t": {"colour": fmt_purple, "prompt": ">>> "},
|
||||
"i": {"colour": fmt_blue, "prompt": ">>> "},
|
||||
"s": {"colour": fmt_cyan, "prompt": ">>> "},
|
||||
"d": {"colour": fmt_white, "prompt": ">>> "},
|
||||
"x": {"colour": last_colour, "prompt": last_prompt},
|
||||
}
|
||||
format_map_textual = {
|
||||
# Uncolourized formatting with text prompts (log_colours = False)
|
||||
'o': {'colour': '', 'prompt': 'ok: '},
|
||||
'e': {'colour': '', 'prompt': 'failed: '},
|
||||
'w': {'colour': '', 'prompt': 'warning: '},
|
||||
't': {'colour': '', 'prompt': 'tick: '},
|
||||
'i': {'colour': '', 'prompt': 'info: '},
|
||||
's': {'colour': '', 'prompt': 'system: '},
|
||||
'd': {'colour': '', 'prompt': 'debug: '},
|
||||
'x': {'colour': '', 'prompt': last_prompt}
|
||||
"o": {"colour": "", "prompt": "ok: "},
|
||||
"e": {"colour": "", "prompt": "failed: "},
|
||||
"w": {"colour": "", "prompt": "warning: "},
|
||||
"t": {"colour": "", "prompt": "tick: "},
|
||||
"i": {"colour": "", "prompt": "info: "},
|
||||
"s": {"colour": "", "prompt": "system: "},
|
||||
"d": {"colour": "", "prompt": "debug: "},
|
||||
"x": {"colour": "", "prompt": last_prompt},
|
||||
}
|
||||
|
||||
# Initialization of instance
|
||||
def __init__(self, config):
|
||||
self.config = config
|
||||
|
||||
if self.config['file_logging']:
|
||||
self.logfile = self.config['log_directory'] + '/pvc.log'
|
||||
if self.config["file_logging"]:
|
||||
self.logfile = self.config["log_directory"] + "/pvc.log"
|
||||
# We open the logfile for the duration of our session, but have a hup function
|
||||
self.writer = open(self.logfile, 'a', buffering=0)
|
||||
self.writer = open(self.logfile, "a", buffering=0)
|
||||
|
||||
self.last_colour = ''
|
||||
self.last_prompt = ''
|
||||
self.last_colour = ""
|
||||
self.last_prompt = ""
|
||||
|
||||
if self.config['zookeeper_logging']:
|
||||
if self.config["zookeeper_logging"]:
|
||||
self.zookeeper_queue = Queue()
|
||||
self.zookeeper_logger = ZookeeperLogger(self.config, self.zookeeper_queue)
|
||||
self.zookeeper_logger.start()
|
||||
@ -91,14 +91,14 @@ class Logger(object):
|
||||
# Provide a hup function to close and reopen the writer
|
||||
def hup(self):
|
||||
self.writer.close()
|
||||
self.writer = open(self.logfile, 'a', buffering=0)
|
||||
self.writer = open(self.logfile, "a", buffering=0)
|
||||
|
||||
# Provide a termination function so all messages are flushed before terminating the main daemon
|
||||
def terminate(self):
|
||||
if self.config['file_logging']:
|
||||
if self.config["file_logging"]:
|
||||
self.writer.close()
|
||||
if self.config['zookeeper_logging']:
|
||||
self.out("Waiting 15s for Zookeeper message queue to drain", state='s')
|
||||
if self.config["zookeeper_logging"]:
|
||||
self.out("Waiting 15s for Zookeeper message queue to drain", state="s")
|
||||
|
||||
tick_count = 0
|
||||
while not self.zookeeper_queue.empty():
|
||||
@ -111,48 +111,48 @@ class Logger(object):
|
||||
self.zookeeper_logger.join()
|
||||
|
||||
# Output function
|
||||
def out(self, message, state=None, prefix=''):
|
||||
def out(self, message, state=None, prefix=""):
|
||||
|
||||
# Get the date
|
||||
if self.config['log_dates']:
|
||||
date = '{} '.format(datetime.now().strftime('%Y/%m/%d %H:%M:%S.%f'))
|
||||
if self.config["log_dates"]:
|
||||
date = "{} ".format(datetime.now().strftime("%Y/%m/%d %H:%M:%S.%f"))
|
||||
else:
|
||||
date = ''
|
||||
date = ""
|
||||
|
||||
# Get the format map
|
||||
if self.config['log_colours']:
|
||||
if self.config["log_colours"]:
|
||||
format_map = self.format_map_colourized
|
||||
endc = Logger.fmt_end
|
||||
else:
|
||||
format_map = self.format_map_textual
|
||||
endc = ''
|
||||
endc = ""
|
||||
|
||||
# Define an undefined state as 'x'; no date in these prompts
|
||||
if not state:
|
||||
state = 'x'
|
||||
date = ''
|
||||
state = "x"
|
||||
date = ""
|
||||
|
||||
# Get colour and prompt from the map
|
||||
colour = format_map[state]['colour']
|
||||
prompt = format_map[state]['prompt']
|
||||
colour = format_map[state]["colour"]
|
||||
prompt = format_map[state]["prompt"]
|
||||
|
||||
# Append space and separator to prefix
|
||||
if prefix != '':
|
||||
prefix = prefix + ' - '
|
||||
if prefix != "":
|
||||
prefix = prefix + " - "
|
||||
|
||||
# Assemble message string
|
||||
message = colour + prompt + endc + date + prefix + message
|
||||
|
||||
# Log to stdout
|
||||
if self.config['stdout_logging']:
|
||||
if self.config["stdout_logging"]:
|
||||
print(message)
|
||||
|
||||
# Log to file
|
||||
if self.config['file_logging']:
|
||||
self.writer.write(message + '\n')
|
||||
if self.config["file_logging"]:
|
||||
self.writer.write(message + "\n")
|
||||
|
||||
# Log to Zookeeper
|
||||
if self.config['zookeeper_logging']:
|
||||
if self.config["zookeeper_logging"]:
|
||||
self.zookeeper_queue.put(message)
|
||||
|
||||
# Set last message variables
|
||||
@ -165,10 +165,11 @@ class ZookeeperLogger(Thread):
|
||||
Defines a threaded writer for Zookeeper locks. Threading prevents the blocking of other
|
||||
daemon events while the records are written. They will be eventually-consistent
|
||||
"""
|
||||
|
||||
def __init__(self, config, zookeeper_queue):
|
||||
self.config = config
|
||||
self.node = self.config['node']
|
||||
self.max_lines = self.config['node_log_lines']
|
||||
self.node = self.config["node"]
|
||||
self.max_lines = self.config["node_log_lines"]
|
||||
self.zookeeper_queue = zookeeper_queue
|
||||
self.connected = False
|
||||
self.running = False
|
||||
@ -195,10 +196,7 @@ class ZookeeperLogger(Thread):
|
||||
self.connected = True
|
||||
|
||||
# Ensure the root keys for this are instantiated
|
||||
self.zkhandler.write([
|
||||
('base.logs', ''),
|
||||
(('logs', self.node), '')
|
||||
])
|
||||
self.zkhandler.write([("base.logs", ""), (("logs", self.node), "")])
|
||||
|
||||
def run(self):
|
||||
while not self.connected:
|
||||
@ -207,10 +205,10 @@ class ZookeeperLogger(Thread):
|
||||
|
||||
self.running = True
|
||||
# Get the logs that are currently in Zookeeper and populate our deque
|
||||
raw_logs = self.zkhandler.read(('logs.messages', self.node))
|
||||
raw_logs = self.zkhandler.read(("logs.messages", self.node))
|
||||
if raw_logs is None:
|
||||
raw_logs = ''
|
||||
logs = deque(raw_logs.split('\n'), self.max_lines)
|
||||
raw_logs = ""
|
||||
logs = deque(raw_logs.split("\n"), self.max_lines)
|
||||
while self.running:
|
||||
# Get a new message
|
||||
try:
|
||||
@ -220,19 +218,21 @@ class ZookeeperLogger(Thread):
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
if not self.config['log_dates']:
|
||||
if not self.config["log_dates"]:
|
||||
# We want to log dates here, even if the log_dates config is not set
|
||||
date = '{} '.format(datetime.now().strftime('%Y/%m/%d %H:%M:%S.%f'))
|
||||
date = "{} ".format(datetime.now().strftime("%Y/%m/%d %H:%M:%S.%f"))
|
||||
else:
|
||||
date = ''
|
||||
date = ""
|
||||
# Add the message to the deque
|
||||
logs.append(f'{date}{message}')
|
||||
logs.append(f"{date}{message}")
|
||||
|
||||
tick_count = 0
|
||||
while True:
|
||||
try:
|
||||
# Write the updated messages into Zookeeper
|
||||
self.zkhandler.write([(('logs.messages', self.node), '\n'.join(logs))])
|
||||
self.zkhandler.write(
|
||||
[(("logs.messages", self.node), "\n".join(logs))]
|
||||
)
|
||||
break
|
||||
except Exception:
|
||||
# The write failed (connection loss, etc.) so retry for 15 seconds
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -29,50 +29,49 @@ def getNodeInformation(zkhandler, node_name):
|
||||
"""
|
||||
Gather information about a node from the Zookeeper database and return a dict() containing it.
|
||||
"""
|
||||
node_daemon_state = zkhandler.read(('node.state.daemon', node_name))
|
||||
node_coordinator_state = zkhandler.read(('node.state.router', node_name))
|
||||
node_domain_state = zkhandler.read(('node.state.domain', node_name))
|
||||
node_static_data = zkhandler.read(('node.data.static', node_name)).split()
|
||||
node_pvc_version = zkhandler.read(('node.data.pvc_version', node_name))
|
||||
node_daemon_state = zkhandler.read(("node.state.daemon", node_name))
|
||||
node_coordinator_state = zkhandler.read(("node.state.router", node_name))
|
||||
node_domain_state = zkhandler.read(("node.state.domain", node_name))
|
||||
node_static_data = zkhandler.read(("node.data.static", node_name)).split()
|
||||
node_pvc_version = zkhandler.read(("node.data.pvc_version", node_name))
|
||||
node_cpu_count = int(node_static_data[0])
|
||||
node_kernel = node_static_data[1]
|
||||
node_os = node_static_data[2]
|
||||
node_arch = node_static_data[3]
|
||||
node_vcpu_allocated = int(zkhandler.read(('node.vcpu.allocated', node_name)))
|
||||
node_mem_total = int(zkhandler.read(('node.memory.total', node_name)))
|
||||
node_mem_allocated = int(zkhandler.read(('node.memory.allocated', node_name)))
|
||||
node_mem_provisioned = int(zkhandler.read(('node.memory.provisioned', node_name)))
|
||||
node_mem_used = int(zkhandler.read(('node.memory.used', node_name)))
|
||||
node_mem_free = int(zkhandler.read(('node.memory.free', node_name)))
|
||||
node_load = float(zkhandler.read(('node.cpu.load', node_name)))
|
||||
node_domains_count = int(zkhandler.read(('node.count.provisioned_domains', node_name)))
|
||||
node_running_domains = zkhandler.read(('node.running_domains', node_name)).split()
|
||||
node_vcpu_allocated = int(zkhandler.read(("node.vcpu.allocated", node_name)))
|
||||
node_mem_total = int(zkhandler.read(("node.memory.total", node_name)))
|
||||
node_mem_allocated = int(zkhandler.read(("node.memory.allocated", node_name)))
|
||||
node_mem_provisioned = int(zkhandler.read(("node.memory.provisioned", node_name)))
|
||||
node_mem_used = int(zkhandler.read(("node.memory.used", node_name)))
|
||||
node_mem_free = int(zkhandler.read(("node.memory.free", node_name)))
|
||||
node_load = float(zkhandler.read(("node.cpu.load", node_name)))
|
||||
node_domains_count = int(
|
||||
zkhandler.read(("node.count.provisioned_domains", node_name))
|
||||
)
|
||||
node_running_domains = zkhandler.read(("node.running_domains", node_name)).split()
|
||||
|
||||
# Construct a data structure to represent the data
|
||||
node_information = {
|
||||
'name': node_name,
|
||||
'daemon_state': node_daemon_state,
|
||||
'coordinator_state': node_coordinator_state,
|
||||
'domain_state': node_domain_state,
|
||||
'pvc_version': node_pvc_version,
|
||||
'cpu_count': node_cpu_count,
|
||||
'kernel': node_kernel,
|
||||
'os': node_os,
|
||||
'arch': node_arch,
|
||||
'load': node_load,
|
||||
'domains_count': node_domains_count,
|
||||
'running_domains': node_running_domains,
|
||||
'vcpu': {
|
||||
'total': node_cpu_count,
|
||||
'allocated': node_vcpu_allocated
|
||||
"name": node_name,
|
||||
"daemon_state": node_daemon_state,
|
||||
"coordinator_state": node_coordinator_state,
|
||||
"domain_state": node_domain_state,
|
||||
"pvc_version": node_pvc_version,
|
||||
"cpu_count": node_cpu_count,
|
||||
"kernel": node_kernel,
|
||||
"os": node_os,
|
||||
"arch": node_arch,
|
||||
"load": node_load,
|
||||
"domains_count": node_domains_count,
|
||||
"running_domains": node_running_domains,
|
||||
"vcpu": {"total": node_cpu_count, "allocated": node_vcpu_allocated},
|
||||
"memory": {
|
||||
"total": node_mem_total,
|
||||
"allocated": node_mem_allocated,
|
||||
"provisioned": node_mem_provisioned,
|
||||
"used": node_mem_used,
|
||||
"free": node_mem_free,
|
||||
},
|
||||
'memory': {
|
||||
'total': node_mem_total,
|
||||
'allocated': node_mem_allocated,
|
||||
'provisioned': node_mem_provisioned,
|
||||
'used': node_mem_used,
|
||||
'free': node_mem_free
|
||||
}
|
||||
}
|
||||
return node_information
|
||||
|
||||
@ -83,27 +82,32 @@ def getNodeInformation(zkhandler, node_name):
|
||||
def secondary_node(zkhandler, node):
|
||||
# Verify node is valid
|
||||
if not common.verifyNode(zkhandler, node):
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(node)
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(
|
||||
node
|
||||
)
|
||||
|
||||
# Ensure node is a coordinator
|
||||
daemon_mode = zkhandler.read(('node.mode', node))
|
||||
if daemon_mode == 'hypervisor':
|
||||
return False, 'ERROR: Cannot change router mode on non-coordinator node "{}"'.format(node)
|
||||
daemon_mode = zkhandler.read(("node.mode", node))
|
||||
if daemon_mode == "hypervisor":
|
||||
return (
|
||||
False,
|
||||
'ERROR: Cannot change router mode on non-coordinator node "{}"'.format(
|
||||
node
|
||||
),
|
||||
)
|
||||
|
||||
# Ensure node is in run daemonstate
|
||||
daemon_state = zkhandler.read(('node.state.daemon', node))
|
||||
if daemon_state != 'run':
|
||||
daemon_state = zkhandler.read(("node.state.daemon", node))
|
||||
if daemon_state != "run":
|
||||
return False, 'ERROR: Node "{}" is not active'.format(node)
|
||||
|
||||
# Get current state
|
||||
current_state = zkhandler.read(('node.state.router', node))
|
||||
if current_state == 'secondary':
|
||||
current_state = zkhandler.read(("node.state.router", node))
|
||||
if current_state == "secondary":
|
||||
return True, 'Node "{}" is already in secondary router mode.'.format(node)
|
||||
|
||||
retmsg = 'Setting node {} in secondary router mode.'.format(node)
|
||||
zkhandler.write([
|
||||
('base.config.primary_node', 'none')
|
||||
])
|
||||
retmsg = "Setting node {} in secondary router mode.".format(node)
|
||||
zkhandler.write([("base.config.primary_node", "none")])
|
||||
|
||||
return True, retmsg
|
||||
|
||||
@ -111,27 +115,32 @@ def secondary_node(zkhandler, node):
|
||||
def primary_node(zkhandler, node):
|
||||
# Verify node is valid
|
||||
if not common.verifyNode(zkhandler, node):
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(node)
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(
|
||||
node
|
||||
)
|
||||
|
||||
# Ensure node is a coordinator
|
||||
daemon_mode = zkhandler.read(('node.mode', node))
|
||||
if daemon_mode == 'hypervisor':
|
||||
return False, 'ERROR: Cannot change router mode on non-coordinator node "{}"'.format(node)
|
||||
daemon_mode = zkhandler.read(("node.mode", node))
|
||||
if daemon_mode == "hypervisor":
|
||||
return (
|
||||
False,
|
||||
'ERROR: Cannot change router mode on non-coordinator node "{}"'.format(
|
||||
node
|
||||
),
|
||||
)
|
||||
|
||||
# Ensure node is in run daemonstate
|
||||
daemon_state = zkhandler.read(('node.state.daemon', node))
|
||||
if daemon_state != 'run':
|
||||
daemon_state = zkhandler.read(("node.state.daemon", node))
|
||||
if daemon_state != "run":
|
||||
return False, 'ERROR: Node "{}" is not active'.format(node)
|
||||
|
||||
# Get current state
|
||||
current_state = zkhandler.read(('node.state.router', node))
|
||||
if current_state == 'primary':
|
||||
current_state = zkhandler.read(("node.state.router", node))
|
||||
if current_state == "primary":
|
||||
return True, 'Node "{}" is already in primary router mode.'.format(node)
|
||||
|
||||
retmsg = 'Setting node {} in primary router mode.'.format(node)
|
||||
zkhandler.write([
|
||||
('base.config.primary_node', node)
|
||||
])
|
||||
retmsg = "Setting node {} in primary router mode.".format(node)
|
||||
zkhandler.write([("base.config.primary_node", node)])
|
||||
|
||||
return True, retmsg
|
||||
|
||||
@ -139,22 +148,22 @@ def primary_node(zkhandler, node):
|
||||
def flush_node(zkhandler, node, wait=False):
|
||||
# Verify node is valid
|
||||
if not common.verifyNode(zkhandler, node):
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(node)
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(
|
||||
node
|
||||
)
|
||||
|
||||
if zkhandler.read(('node.state.domain', node)) == 'flushed':
|
||||
return True, 'Hypervisor {} is already flushed.'.format(node)
|
||||
if zkhandler.read(("node.state.domain", node)) == "flushed":
|
||||
return True, "Hypervisor {} is already flushed.".format(node)
|
||||
|
||||
retmsg = 'Flushing hypervisor {} of running VMs.'.format(node)
|
||||
retmsg = "Flushing hypervisor {} of running VMs.".format(node)
|
||||
|
||||
# Add the new domain to Zookeeper
|
||||
zkhandler.write([
|
||||
(('node.state.domain', node), 'flush')
|
||||
])
|
||||
zkhandler.write([(("node.state.domain", node), "flush")])
|
||||
|
||||
if wait:
|
||||
while zkhandler.read(('node.state.domain', node)) == 'flush':
|
||||
while zkhandler.read(("node.state.domain", node)) == "flush":
|
||||
time.sleep(1)
|
||||
retmsg = 'Flushed hypervisor {} of running VMs.'.format(node)
|
||||
retmsg = "Flushed hypervisor {} of running VMs.".format(node)
|
||||
|
||||
return True, retmsg
|
||||
|
||||
@ -162,22 +171,22 @@ def flush_node(zkhandler, node, wait=False):
|
||||
def ready_node(zkhandler, node, wait=False):
|
||||
# Verify node is valid
|
||||
if not common.verifyNode(zkhandler, node):
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(node)
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(
|
||||
node
|
||||
)
|
||||
|
||||
if zkhandler.read(('node.state.domain', node)) == 'ready':
|
||||
return True, 'Hypervisor {} is already ready.'.format(node)
|
||||
if zkhandler.read(("node.state.domain", node)) == "ready":
|
||||
return True, "Hypervisor {} is already ready.".format(node)
|
||||
|
||||
retmsg = 'Restoring hypervisor {} to active service.'.format(node)
|
||||
retmsg = "Restoring hypervisor {} to active service.".format(node)
|
||||
|
||||
# Add the new domain to Zookeeper
|
||||
zkhandler.write([
|
||||
(('node.state.domain', node), 'unflush')
|
||||
])
|
||||
zkhandler.write([(("node.state.domain", node), "unflush")])
|
||||
|
||||
if wait:
|
||||
while zkhandler.read(('node.state.domain', node)) == 'unflush':
|
||||
while zkhandler.read(("node.state.domain", node)) == "unflush":
|
||||
time.sleep(1)
|
||||
retmsg = 'Restored hypervisor {} to active service.'.format(node)
|
||||
retmsg = "Restored hypervisor {} to active service.".format(node)
|
||||
|
||||
return True, retmsg
|
||||
|
||||
@ -185,17 +194,19 @@ def ready_node(zkhandler, node, wait=False):
|
||||
def get_node_log(zkhandler, node, lines=2000):
|
||||
# Verify node is valid
|
||||
if not common.verifyNode(zkhandler, node):
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(node)
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(
|
||||
node
|
||||
)
|
||||
|
||||
# Get the data from ZK
|
||||
node_log = zkhandler.read(('logs.messages', node))
|
||||
node_log = zkhandler.read(("logs.messages", node))
|
||||
|
||||
if node_log is None:
|
||||
return True, ''
|
||||
return True, ""
|
||||
|
||||
# Shrink the log buffer to length lines
|
||||
shrunk_log = node_log.split('\n')[-lines:]
|
||||
loglines = '\n'.join(shrunk_log)
|
||||
shrunk_log = node_log.split("\n")[-lines:]
|
||||
loglines = "\n".join(shrunk_log)
|
||||
|
||||
return True, loglines
|
||||
|
||||
@ -203,7 +214,9 @@ def get_node_log(zkhandler, node, lines=2000):
|
||||
def get_info(zkhandler, node):
|
||||
# Verify node is valid
|
||||
if not common.verifyNode(zkhandler, node):
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(node)
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(
|
||||
node
|
||||
)
|
||||
|
||||
# Get information about node in a pretty format
|
||||
node_information = getNodeInformation(zkhandler, node)
|
||||
@ -213,20 +226,27 @@ def get_info(zkhandler, node):
|
||||
return True, node_information
|
||||
|
||||
|
||||
def get_list(zkhandler, limit, daemon_state=None, coordinator_state=None, domain_state=None, is_fuzzy=True):
|
||||
def get_list(
|
||||
zkhandler,
|
||||
limit,
|
||||
daemon_state=None,
|
||||
coordinator_state=None,
|
||||
domain_state=None,
|
||||
is_fuzzy=True,
|
||||
):
|
||||
node_list = []
|
||||
full_node_list = zkhandler.children('base.node')
|
||||
full_node_list = zkhandler.children("base.node")
|
||||
|
||||
for node in full_node_list:
|
||||
if limit:
|
||||
try:
|
||||
if not is_fuzzy:
|
||||
limit = '^' + limit + '$'
|
||||
limit = "^" + limit + "$"
|
||||
|
||||
if re.match(limit, node):
|
||||
node_list.append(getNodeInformation(zkhandler, node))
|
||||
except Exception as e:
|
||||
return False, 'Regex Error: {}'.format(e)
|
||||
return False, "Regex Error: {}".format(e)
|
||||
else:
|
||||
node_list.append(getNodeInformation(zkhandler, node))
|
||||
|
||||
@ -234,11 +254,11 @@ def get_list(zkhandler, limit, daemon_state=None, coordinator_state=None, domain
|
||||
limited_node_list = []
|
||||
for node in node_list:
|
||||
add_node = False
|
||||
if daemon_state and node['daemon_state'] == daemon_state:
|
||||
if daemon_state and node["daemon_state"] == daemon_state:
|
||||
add_node = True
|
||||
if coordinator_state and node['coordinator_state'] == coordinator_state:
|
||||
if coordinator_state and node["coordinator_state"] == coordinator_state:
|
||||
add_node = True
|
||||
if domain_state and node['domain_state'] == domain_state:
|
||||
if domain_state and node["domain_state"] == domain_state:
|
||||
add_node = True
|
||||
if add_node:
|
||||
limited_node_list.append(node)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user