parallelvirtualcluster
/
pvc
1
0
Fork 0
Code Issues 11 Pull Requests Projects Releases 111 Wiki Activity

Lint: E201 whitespace after '{'

This commit is contained in:
Joshua Boniface 2020-11-07 12:38:31 -05:00
parent 292ccdd94e
commit e333f2b935
18 changed files with 415 additions and 415 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
api-daemon/pvcapid/benchmark.py
View File

@ -105,7 +105,7 @@ def list_benchmarks(job=None):
if data: if data:
return data, 200 return data, 200
else: else:
return { 'message': 'No benchmark found.' }, 404 return {'message': 'No benchmark found.' }, 404
def run_benchmark(self, pool): def run_benchmark(self, pool):
# Runtime imports # Runtime imports
@ -456,4 +456,4 @@ def run_benchmark(self, pool):
close_database(db_conn, db_cur) close_database(db_conn, db_cur)
pvc_common.stopZKConnection(zk_conn) pvc_common.stopZKConnection(zk_conn)
return { 'status': "Storage benchmark '{}' completed successfully.", 'current': 3, 'total': 3 } return {'status': "Storage benchmark '{}' completed successfully.", 'current': 3, 'total': 3 }

478
api-daemon/pvcapid/flaskapi.py
View File

File diff suppressed because it is too large Load Diff

6
api-daemon/pvcapid/helper.py
View File

@ -439,7 +439,7 @@ def vm_define(xml, node, limit, selector, autostart, migration_method):
xml_data = etree.fromstring(xml) xml_data = etree.fromstring(xml)
new_cfg = etree.tostring(xml_data, pretty_print=True).decode('utf8') new_cfg = etree.tostring(xml_data, pretty_print=True).decode('utf8')
except Exception as e: except Exception as e:
return { 'message': 'XML is malformed or incorrect: {}'.format(e) }, 400 return {'message': 'XML is malformed or incorrect: {}'.format(e) }, 400
zk_conn = pvc_common.startZKConnection(config['coordinators']) zk_conn = pvc_common.startZKConnection(config['coordinators'])
retflag, retdata = pvc_vm.define_vm(zk_conn, new_cfg, node, limit, selector, autostart, migration_method, profile=None) retflag, retdata = pvc_vm.define_vm(zk_conn, new_cfg, node, limit, selector, autostart, migration_method, profile=None)
@ -522,7 +522,7 @@ def vm_modify(name, restart, xml):
xml_data = etree.fromstring(xml) xml_data = etree.fromstring(xml)
new_cfg = etree.tostring(xml_data, pretty_print=True).decode('utf8') new_cfg = etree.tostring(xml_data, pretty_print=True).decode('utf8')
except Exception as e: except Exception as e:
return { 'message': 'XML is malformed or incorrect: {}'.format(e) }, 400 return {'message': 'XML is malformed or incorrect: {}'.format(e) }, 400
zk_conn = pvc_common.startZKConnection(config['coordinators']) zk_conn = pvc_common.startZKConnection(config['coordinators'])
retflag, retdata = pvc_vm.modify_vm(zk_conn, name, restart, new_cfg) retflag, retdata = pvc_vm.modify_vm(zk_conn, name, restart, new_cfg)
pvc_common.stopZKConnection(zk_conn) pvc_common.stopZKConnection(zk_conn)
@ -1047,7 +1047,7 @@ def ceph_osd_state(osd):
in_state = retdata[0]['stats']['in'] in_state = retdata[0]['stats']['in']
up_state = retdata[0]['stats']['up'] up_state = retdata[0]['stats']['up']
return { "id": osd, "in": in_state, "up": up_state }, retcode return {"id": osd, "in": in_state, "up": up_state }, retcode
def ceph_osd_add(node, device, weight): def ceph_osd_add(node, device, weight):
""" """

8
api-daemon/pvcapid/ova.py
View File

@ -103,12 +103,12 @@ def list_ova(limit, is_fuzzy=True):
if ova_data: if ova_data:
return ova_data, 200 return ova_data, 200
else: else:
return { 'message': 'No OVAs found.' }, 404 return {'message': 'No OVAs found.' }, 404
def delete_ova(name): def delete_ova(name):
ova_data, retcode = list_ova(name, is_fuzzy=False) ova_data, retcode = list_ova(name, is_fuzzy=False)
if retcode != 200: if retcode != 200:
retmsg = { 'message': 'The OVA "{}" does not exist.'.format(name) } retmsg = {'message': 'The OVA "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -146,10 +146,10 @@ def delete_ova(name):
args = (ova_id,) args = (ova_id,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed OVA image "{}".'.format(name) } retmsg = {"message": 'Removed OVA image "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to remove OVA "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to remove OVA "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode

182
api-daemon/pvcapid/provisioner.py
View File

@ -149,7 +149,7 @@ def list_template_system(limit, is_fuzzy=True):
if data: if data:
return data, 200 return data, 200
else: else:
return { 'message': 'No system templates found.' }, 404 return {'message': 'No system templates found.' }, 404
def list_template_network(limit, is_fuzzy=True): def list_template_network(limit, is_fuzzy=True):
""" """
@ -159,7 +159,7 @@ def list_template_network(limit, is_fuzzy=True):
if data: if data:
return data, 200 return data, 200
else: else:
return { 'message': 'No network templates found.' }, 404 return {'message': 'No network templates found.' }, 404
def list_template_network_vnis(name): def list_template_network_vnis(name):
""" """
@ -170,7 +170,7 @@ def list_template_network_vnis(name):
if networks: if networks:
return networks, 200 return networks, 200
else: else:
return { 'message': 'No network template networks found.' }, 404 return {'message': 'No network template networks found.' }, 404
def list_template_storage(limit, is_fuzzy=True): def list_template_storage(limit, is_fuzzy=True):
""" """
@ -180,7 +180,7 @@ def list_template_storage(limit, is_fuzzy=True):
if data: if data:
return data, 200 return data, 200
else: else:
return { 'message': 'No storage templates found.' }, 404 return {'message': 'No storage templates found.' }, 404
def list_template_storage_disks(name): def list_template_storage_disks(name):
""" """
@ -191,7 +191,7 @@ def list_template_storage_disks(name):
if disks: if disks:
return disks, 200 return disks, 200
else: else:
return { 'message': 'No storage template disks found.' }, 404 return {'message': 'No storage template disks found.' }, 404
def template_list(limit): def template_list(limit):
system_templates, code = list_template_system(limit) system_templates, code = list_template_system(limit)
@ -204,14 +204,14 @@ def template_list(limit):
if code != 200: if code != 200:
storage_templates = [] storage_templates = []
return { "system_templates": system_templates, "network_templates": network_templates, "storage_templates": storage_templates } return {"system_templates": system_templates, "network_templates": network_templates, "storage_templates": storage_templates }
# #
# Template Create functions # Template Create functions
# #
def create_template_system(name, vcpu_count, vram_mb, serial=False, vnc=False, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=False, migration_method=None, ova=None): def create_template_system(name, vcpu_count, vram_mb, serial=False, vnc=False, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=False, migration_method=None, ova=None):
if list_template_system(name, is_fuzzy=False)[-1] != 404: if list_template_system(name, is_fuzzy=False)[-1] != 404:
retmsg = { 'message': 'The system template "{}" already exists.'.format(name) } retmsg = {'message': 'The system template "{}" already exists.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -221,17 +221,17 @@ def create_template_system(name, vcpu_count, vram_mb, serial=False, vnc=False, v
conn, cur = open_database(config) conn, cur = open_database(config)
try: try:
cur.execute(query, args) cur.execute(query, args)
retmsg = { 'message': 'Added new system template "{}".'.format(name) } retmsg = {'message': 'Added new system template "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create system template "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to create system template "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def create_template_network(name, mac_template=None): def create_template_network(name, mac_template=None):
if list_template_network(name, is_fuzzy=False)[-1] != 404: if list_template_network(name, is_fuzzy=False)[-1] != 404:
retmsg = { 'message': 'The network template "{}" already exists.'.format(name) } retmsg = {'message': 'The network template "{}" already exists.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -240,17 +240,17 @@ def create_template_network(name, mac_template=None):
query = "INSERT INTO network_template (name, mac_template) VALUES (%s, %s);" query = "INSERT INTO network_template (name, mac_template) VALUES (%s, %s);"
args = (name, mac_template) args = (name, mac_template)
cur.execute(query, args) cur.execute(query, args)
retmsg = { 'message': 'Added new network template "{}".'.format(name) } retmsg = {'message': 'Added new network template "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create network template "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to create network template "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def create_template_network_element(name, vni): def create_template_network_element(name, vni):
if list_template_network(name, is_fuzzy=False)[-1] != 200: if list_template_network(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The network template "{}" does not exist.'.format(name) } retmsg = {'message': 'The network template "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -262,7 +262,7 @@ def create_template_network_element(name, vni):
if int(network['vni']) == int(vni): if int(network['vni']) == int(vni):
found_vni = True found_vni = True
if found_vni: if found_vni:
retmsg = { 'message': 'The VNI "{}" in network template "{}" already exists.'.format(vni, name) } retmsg = {'message': 'The VNI "{}" in network template "{}" already exists.'.format(vni, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -275,17 +275,17 @@ def create_template_network_element(name, vni):
query = "INSERT INTO network (network_template, vni) VALUES (%s, %s);" query = "INSERT INTO network (network_template, vni) VALUES (%s, %s);"
args = (template_id, vni) args = (template_id, vni)
cur.execute(query, args) cur.execute(query, args)
retmsg = { 'message': 'Added new network "{}" to network template "{}".'.format(vni, name) } retmsg = {'message': 'Added new network "{}" to network template "{}".'.format(vni, name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create entry "{}": {}'.format(vni, e) } retmsg = {'message': 'Failed to create entry "{}": {}'.format(vni, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def create_template_storage(name): def create_template_storage(name):
if list_template_storage(name, is_fuzzy=False)[-1] != 404: if list_template_storage(name, is_fuzzy=False)[-1] != 404:
retmsg = { 'message': 'The storage template "{}" already exists.'.format(name) } retmsg = {'message': 'The storage template "{}" already exists.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -294,17 +294,17 @@ def create_template_storage(name):
query = "INSERT INTO storage_template (name) VALUES (%s);" query = "INSERT INTO storage_template (name) VALUES (%s);"
args = (name,) args = (name,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { 'message': 'Added new storage template "{}".'.format(name) } retmsg = {'message': 'Added new storage template "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def create_template_storage_element(name, disk_id, pool, source_volume=None, disk_size_gb=None, filesystem=None, filesystem_args=[], mountpoint=None): def create_template_storage_element(name, disk_id, pool, source_volume=None, disk_size_gb=None, filesystem=None, filesystem_args=[], mountpoint=None):
if list_template_storage(name, is_fuzzy=False)[-1] != 200: if list_template_storage(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The storage template "{}" does not exist.'.format(name) } retmsg = {'message': 'The storage template "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -316,17 +316,17 @@ def create_template_storage_element(name, disk_id, pool, source_volume=None, dis
if disk['disk_id'] == disk_id: if disk['disk_id'] == disk_id:
found_disk = True found_disk = True
if found_disk: if found_disk:
retmsg = { 'message': 'The disk "{}" in storage template "{}" already exists.'.format(disk_id, name) } retmsg = {'message': 'The disk "{}" in storage template "{}" already exists.'.format(disk_id, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
if mountpoint and not filesystem: if mountpoint and not filesystem:
retmsg = { "message": "A filesystem must be specified along with a mountpoint." } retmsg = {"message": "A filesystem must be specified along with a mountpoint." }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
if source_volume and (disk_size_gb or filesystem or mountpoint): if source_volume and (disk_size_gb or filesystem or mountpoint):
retmsg = { "message": "Clone volumes are not compatible with disk size, filesystem, or mountpoint specifications." } retmsg = {"message": "Clone volumes are not compatible with disk size, filesystem, or mountpoint specifications." }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -343,10 +343,10 @@ def create_template_storage_element(name, disk_id, pool, source_volume=None, dis
fsargs = '' fsargs = ''
args = (template_id, pool, disk_id, source_volume, disk_size_gb, mountpoint, filesystem, fsargs) args = (template_id, pool, disk_id, source_volume, disk_size_gb, mountpoint, filesystem, fsargs)
cur.execute(query, args) cur.execute(query, args)
retmsg = { 'message': 'Added new disk "{}" to storage template "{}".'.format(disk_id, name) } retmsg = {'message': 'Added new disk "{}" to storage template "{}".'.format(disk_id, name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create entry "{}": {}'.format(disk_id, e) } retmsg = {'message': 'Failed to create entry "{}": {}'.format(disk_id, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
@ -356,7 +356,7 @@ def create_template_storage_element(name, disk_id, pool, source_volume=None, dis
# #
def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc=None, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=None, migration_method=None): def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc=None, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=None, migration_method=None):
if list_template_system(name, is_fuzzy=False)[-1] != 200: if list_template_system(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The system template "{}" does not exist.'.format(name) } retmsg = {'message': 'The system template "{}" does not exist.'.format(name) }
retcode = 404 retcode = 404
return retmsg, retcode return retmsg, retcode
@ -366,7 +366,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
try: try:
vcpu_count = int(vcpu_count) vcpu_count = int(vcpu_count)
except Exception: except Exception:
retmsg = { 'message': 'The vcpus value must be an integer.' } retmsg = {'message': 'The vcpus value must be an integer.' }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'vcpu_count', 'data': vcpu_count}) fields.append({'field': 'vcpu_count', 'data': vcpu_count})
@ -375,7 +375,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
try: try:
vram_mb = int(vram_mb) vram_mb = int(vram_mb)
except Exception: except Exception:
retmsg = { 'message': 'The vram value must be an integer.' } retmsg = {'message': 'The vram value must be an integer.' }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'vram_mb', 'data': vram_mb}) fields.append({'field': 'vram_mb', 'data': vram_mb})
@ -384,7 +384,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
try: try:
serial = bool(strtobool(serial)) serial = bool(strtobool(serial))
except Exception: except Exception:
retmsg = { 'message': 'The serial value must be a boolean.' } retmsg = {'message': 'The serial value must be a boolean.' }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'serial', 'data': serial}) fields.append({'field': 'serial', 'data': serial})
@ -393,7 +393,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
try: try:
vnc = bool(strtobool(vnc)) vnc = bool(strtobool(vnc))
except Exception: except Exception:
retmsg = { 'message': 'The vnc value must be a boolean.' } retmsg = {'message': 'The vnc value must be a boolean.' }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'vnc', 'data': vnc}) fields.append({'field': 'vnc', 'data': vnc})
@ -411,7 +411,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
try: try:
node_autostart = bool(strtobool(node_autostart)) node_autostart = bool(strtobool(node_autostart))
except Exception: except Exception:
retmsg = { 'message': 'The node_autostart value must be a boolean.' } retmsg = {'message': 'The node_autostart value must be a boolean.' }
retcode = 400 retcode = 400
fields.append({'field': 'node_autostart', 'data': node_autostart}) fields.append({'field': 'node_autostart', 'data': node_autostart})
@ -424,10 +424,10 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
query = "UPDATE system_template SET {} = %s WHERE name = %s;".format(field.get('field')) query = "UPDATE system_template SET {} = %s WHERE name = %s;".format(field.get('field'))
args = (field.get('data'), name) args = (field.get('data'), name)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Modified system template "{}".'.format(name) } retmsg = {"message": 'Modified system template "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to modify entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to modify entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
@ -437,7 +437,7 @@ def modify_template_system(name, vcpu_count=None, vram_mb=None, serial=None, vnc
# #
def delete_template_system(name): def delete_template_system(name):
if list_template_system(name, is_fuzzy=False)[-1] != 200: if list_template_system(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The system template "{}" does not exist.'.format(name) } retmsg = {'message': 'The system template "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -446,17 +446,17 @@ def delete_template_system(name):
query = "DELETE FROM system_template WHERE name = %s;" query = "DELETE FROM system_template WHERE name = %s;"
args = (name,) args = (name,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed system template "{}".'.format(name) } retmsg = {"message": 'Removed system template "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def delete_template_network(name): def delete_template_network(name):
if list_template_network(name, is_fuzzy=False)[-1] != 200: if list_template_network(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The network template "{}" does not exist.'.format(name) } retmsg = {'message': 'The network template "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -472,17 +472,17 @@ def delete_template_network(name):
query = "DELETE FROM network_template WHERE name = %s;" query = "DELETE FROM network_template WHERE name = %s;"
args = (name,) args = (name,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed network template "{}".'.format(name) } retmsg = {"message": 'Removed network template "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def delete_template_network_element(name, vni): def delete_template_network_element(name, vni):
if list_template_network(name, is_fuzzy=False)[-1] != 200: if list_template_network(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The network template "{}" does not exist.'.format(name) } retmsg = {'message': 'The network template "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -492,7 +492,7 @@ def delete_template_network_element(name, vni):
if network['vni'] == int(vni): if network['vni'] == int(vni):
found_vni = True found_vni = True
if not found_vni: if not found_vni:
retmsg = { 'message': 'The VNI "{}" in network template "{}" does not exist.'.format(vni, name) } retmsg = {'message': 'The VNI "{}" in network template "{}" does not exist.'.format(vni, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -505,17 +505,17 @@ def delete_template_network_element(name, vni):
query = "DELETE FROM network WHERE network_template = %s and vni = %s;" query = "DELETE FROM network WHERE network_template = %s and vni = %s;"
args = (template_id, vni) args = (template_id, vni)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed network "{}" from network template "{}".'.format(vni, name) } retmsg = {"message": 'Removed network "{}" from network template "{}".'.format(vni, name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def delete_template_storage(name): def delete_template_storage(name):
if list_template_storage(name, is_fuzzy=False)[-1] != 200: if list_template_storage(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The storage template "{}" does not exist.'.format(name) } retmsg = {'message': 'The storage template "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -531,17 +531,17 @@ def delete_template_storage(name):
query = "DELETE FROM storage_template WHERE name = %s;" query = "DELETE FROM storage_template WHERE name = %s;"
args = (name,) args = (name,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed storage template "{}".'.format(name) } retmsg = {"message": 'Removed storage template "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def delete_template_storage_element(name, disk_id): def delete_template_storage_element(name, disk_id):
if list_template_storage(name, is_fuzzy=False)[-1] != 200: if list_template_storage(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The storage template "{}" does not exist.'.format(name) } retmsg = {'message': 'The storage template "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -551,7 +551,7 @@ def delete_template_storage_element(name, disk_id):
if disk['disk_id'] == disk_id: if disk['disk_id'] == disk_id:
found_disk = True found_disk = True
if not found_disk: if not found_disk:
retmsg = { 'message': 'The disk "{}" in storage template "{}" does not exist.'.format(disk_id, name) } retmsg = {'message': 'The disk "{}" in storage template "{}" does not exist.'.format(disk_id, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -564,10 +564,10 @@ def delete_template_storage_element(name, disk_id):
query = "DELETE FROM storage WHERE storage_template = %s and disk_id = %s;" query = "DELETE FROM storage WHERE storage_template = %s and disk_id = %s;"
args = (template_id, disk_id) args = (template_id, disk_id)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed disk "{}" from storage template "{}".'.format(disk_id, name) } retmsg = {"message": 'Removed disk "{}" from storage template "{}".'.format(disk_id, name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
@ -601,11 +601,11 @@ def list_userdata(limit, is_fuzzy=True):
if data: if data:
return data, 200 return data, 200
else: else:
return { 'message': 'No userdata documents found.' }, 404 return {'message': 'No userdata documents found.' }, 404
def create_userdata(name, userdata): def create_userdata(name, userdata):
if list_userdata(name, is_fuzzy=False)[-1] != 404: if list_userdata(name, is_fuzzy=False)[-1] != 404:
retmsg = { 'message': 'The userdata document "{}" already exists.'.format(name) } retmsg = {'message': 'The userdata document "{}" already exists.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -614,17 +614,17 @@ def create_userdata(name, userdata):
query = "INSERT INTO userdata (name, userdata) VALUES (%s, %s);" query = "INSERT INTO userdata (name, userdata) VALUES (%s, %s);"
args = (name, userdata) args = (name, userdata)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Created userdata document "{}".'.format(name) } retmsg = {"message": 'Created userdata document "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def update_userdata(name, userdata): def update_userdata(name, userdata):
if list_userdata(name, is_fuzzy=False)[-1] != 200: if list_userdata(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The userdata "{}" does not exist.'.format(name) } retmsg = {'message': 'The userdata "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -636,17 +636,17 @@ def update_userdata(name, userdata):
query = "UPDATE userdata SET userdata = %s WHERE id = %s;" query = "UPDATE userdata SET userdata = %s WHERE id = %s;"
args = (userdata, tid) args = (userdata, tid)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Updated userdata document "{}".'.format(name) } retmsg = {"message": 'Updated userdata document "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to update entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to update entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def delete_userdata(name): def delete_userdata(name):
if list_userdata(name, is_fuzzy=False)[-1] != 200: if list_userdata(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The userdata "{}" does not exist.'.format(name) } retmsg = {'message': 'The userdata "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -655,10 +655,10 @@ def delete_userdata(name):
query = "DELETE FROM userdata WHERE name = %s;" query = "DELETE FROM userdata WHERE name = %s;"
args = (name,) args = (name,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed userdata document "{}".'.format(name) } retmsg = {"message": 'Removed userdata document "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
@ -692,11 +692,11 @@ def list_script(limit, is_fuzzy=True):
if data: if data:
return data, 200 return data, 200
else: else:
return { 'message': 'No scripts found.' }, 404 return {'message': 'No scripts found.' }, 404
def create_script(name, script): def create_script(name, script):
if list_script(name, is_fuzzy=False)[-1] != 404: if list_script(name, is_fuzzy=False)[-1] != 404:
retmsg = { 'message': 'The script "{}" already exists.'.format(name) } retmsg = {'message': 'The script "{}" already exists.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -705,17 +705,17 @@ def create_script(name, script):
query = "INSERT INTO script (name, script) VALUES (%s, %s);" query = "INSERT INTO script (name, script) VALUES (%s, %s);"
args = (name, script) args = (name, script)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Created provisioning script "{}".'.format(name) } retmsg = {"message": 'Created provisioning script "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def update_script(name, script): def update_script(name, script):
if list_script(name, is_fuzzy=False)[-1] != 200: if list_script(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The script "{}" does not exist.'.format(name) } retmsg = {'message': 'The script "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -727,17 +727,17 @@ def update_script(name, script):
query = "UPDATE script SET script = %s WHERE id = %s;" query = "UPDATE script SET script = %s WHERE id = %s;"
args = (script, tid) args = (script, tid)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Updated provisioning script "{}".'.format(name) } retmsg = {"message": 'Updated provisioning script "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to update entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to update entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def delete_script(name): def delete_script(name):
if list_script(name, is_fuzzy=False)[-1] != 200: if list_script(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The script "{}" does not exist.'.format(name) } retmsg = {'message': 'The script "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -746,10 +746,10 @@ def delete_script(name):
query = "DELETE FROM script WHERE name = %s;" query = "DELETE FROM script WHERE name = %s;"
args = (name,) args = (name,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed provisioning script "{}".'.format(name) } retmsg = {"message": 'Removed provisioning script "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
@ -803,16 +803,16 @@ def list_profile(limit, is_fuzzy=True):
if data: if data:
return data, 200 return data, 200
else: else:
return { 'message': 'No profiles found.' }, 404 return {'message': 'No profiles found.' }, 404
def create_profile(name, profile_type, system_template, network_template, storage_template, userdata=None, script=None, ova=None, arguments=None): def create_profile(name, profile_type, system_template, network_template, storage_template, userdata=None, script=None, ova=None, arguments=None):
if list_profile(name, is_fuzzy=False)[-1] != 404: if list_profile(name, is_fuzzy=False)[-1] != 404:
retmsg = { 'message': 'The profile "{}" already exists.'.format(name) } retmsg = {'message': 'The profile "{}" already exists.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
if profile_type not in ['provisioner', 'ova']: if profile_type not in ['provisioner', 'ova']:
retmsg = { 'message': 'A valid profile type (provisioner, ova) must be specified.' } retmsg = {'message': 'A valid profile type (provisioner, ova) must be specified.' }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -824,7 +824,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
if template['name'] == system_template: if template['name'] == system_template:
system_template_id = template['id'] system_template_id = template['id']
if not system_template_id: if not system_template_id:
retmsg = { 'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) } retmsg = {'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -836,7 +836,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
if template['name'] == network_template: if template['name'] == network_template:
network_template_id = template['id'] network_template_id = template['id']
if not network_template_id and profile_type != 'ova': if not network_template_id and profile_type != 'ova':
retmsg = { 'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) } retmsg = {'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -848,7 +848,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
if template['name'] == storage_template: if template['name'] == storage_template:
storage_template_id = template['id'] storage_template_id = template['id']
if not storage_template_id and profile_type != 'ova': if not storage_template_id and profile_type != 'ova':
retmsg = { 'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) } retmsg = {'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -886,17 +886,17 @@ def create_profile(name, profile_type, system_template, network_template, storag
query = "INSERT INTO profile (name, profile_type, system_template, network_template, storage_template, userdata, script, ova, arguments) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);" query = "INSERT INTO profile (name, profile_type, system_template, network_template, storage_template, userdata, script, ova, arguments) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);"
args = (name, profile_type, system_template_id, network_template_id, storage_template_id, userdata_id, script_id, ova_id, arguments_formatted) args = (name, profile_type, system_template_id, network_template_id, storage_template_id, userdata_id, script_id, ova_id, arguments_formatted)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Created VM profile "{}".'.format(name) } retmsg = {"message": 'Created VM profile "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to create entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to create entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def modify_profile(name, profile_type, system_template, network_template, storage_template, userdata, script, ova, arguments=None): def modify_profile(name, profile_type, system_template, network_template, storage_template, userdata, script, ova, arguments=None):
if list_profile(name, is_fuzzy=False)[-1] != 200: if list_profile(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The profile "{}" does not exist.'.format(name) } retmsg = {'message': 'The profile "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -904,7 +904,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
if profile_type is not None: if profile_type is not None:
if profile_type not in ['provisioner', 'ova']: if profile_type not in ['provisioner', 'ova']:
retmsg = { 'message': 'A valid profile type (provisioner, ova) must be specified.' } retmsg = {'message': 'A valid profile type (provisioner, ova) must be specified.' }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'type', 'data': profile_type}) fields.append({'field': 'type', 'data': profile_type})
@ -916,7 +916,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
if template['name'] == system_template: if template['name'] == system_template:
system_template_id = template['id'] system_template_id = template['id']
if not system_template_id: if not system_template_id:
retmsg = { 'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) } retmsg = {'message': 'The system template "{}" for profile "{}" does not exist.'.format(system_template, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'system_template', 'data': system_template_id}) fields.append({'field': 'system_template', 'data': system_template_id})
@ -928,7 +928,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
if template['name'] == network_template: if template['name'] == network_template:
network_template_id = template['id'] network_template_id = template['id']
if not network_template_id: if not network_template_id:
retmsg = { 'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) } retmsg = {'message': 'The network template "{}" for profile "{}" does not exist.'.format(network_template, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'network_template', 'data': network_template_id}) fields.append({'field': 'network_template', 'data': network_template_id})
@ -940,7 +940,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
if template['name'] == storage_template: if template['name'] == storage_template:
storage_template_id = template['id'] storage_template_id = template['id']
if not storage_template_id: if not storage_template_id:
retmsg = { 'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) } retmsg = {'message': 'The storage template "{}" for profile "{}" does not exist.'.format(storage_template, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'storage_template', 'data': storage_template_id}) fields.append({'field': 'storage_template', 'data': storage_template_id})
@ -952,7 +952,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
if template['name'] == userdata: if template['name'] == userdata:
userdata_id = template['id'] userdata_id = template['id']
if not userdata_id: if not userdata_id:
retmsg = { 'message': 'The userdata template "{}" for profile "{}" does not exist.'.format(userdata, name) } retmsg = {'message': 'The userdata template "{}" for profile "{}" does not exist.'.format(userdata, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'userdata', 'data': userdata_id}) fields.append({'field': 'userdata', 'data': userdata_id})
@ -964,7 +964,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
if scr['name'] == script: if scr['name'] == script:
script_id = scr['id'] script_id = scr['id']
if not script_id: if not script_id:
retmsg = { 'message': 'The script "{}" for profile "{}" does not exist.'.format(script, name) } retmsg = {'message': 'The script "{}" for profile "{}" does not exist.'.format(script, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'script', 'data': script_id}) fields.append({'field': 'script', 'data': script_id})
@ -976,7 +976,7 @@ def modify_profile(name, profile_type, system_template, network_template, storag
if ov['name'] == ova: if ov['name'] == ova:
ova_id = ov['id'] ova_id = ov['id']
if not ova_id: if not ova_id:
retmsg = { 'message': 'The OVA "{}" for profile "{}" does not exist.'.format(ova, name) } retmsg = {'message': 'The OVA "{}" for profile "{}" does not exist.'.format(ova, name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
fields.append({'field': 'ova', 'data': ova_id}) fields.append({'field': 'ova', 'data': ova_id})
@ -994,17 +994,17 @@ def modify_profile(name, profile_type, system_template, network_template, storag
query = "UPDATE profile SET {}=%s WHERE name=%s;".format(field.get('field')) query = "UPDATE profile SET {}=%s WHERE name=%s;".format(field.get('field'))
args = (field.get('data'), name) args = (field.get('data'), name)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Modified VM profile "{}".'.format(name) } retmsg = {"message": 'Modified VM profile "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to modify entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to modify entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode
def delete_profile(name): def delete_profile(name):
if list_profile(name, is_fuzzy=False)[-1] != 200: if list_profile(name, is_fuzzy=False)[-1] != 200:
retmsg = { 'message': 'The profile "{}" does not exist.'.format(name) } retmsg = {'message': 'The profile "{}" does not exist.'.format(name) }
retcode = 400 retcode = 400
return retmsg, retcode return retmsg, retcode
@ -1013,10 +1013,10 @@ def delete_profile(name):
query = "DELETE FROM profile WHERE name = %s;" query = "DELETE FROM profile WHERE name = %s;"
args = (name,) args = (name,)
cur.execute(query, args) cur.execute(query, args)
retmsg = { "message": 'Removed VM profile "{}".'.format(name) } retmsg = {"message": 'Removed VM profile "{}".'.format(name) }
retcode = 200 retcode = 200
except Exception as e: except Exception as e:
retmsg = { 'message': 'Failed to delete entry "{}": {}'.format(name, e) } retmsg = {'message': 'Failed to delete entry "{}": {}'.format(name, e) }
retcode = 400 retcode = 400
close_database(conn, cur) close_database(conn, cur)
return retmsg, retcode return retmsg, retcode

2
client-cli/cli_lib/ceph.py
View File

@ -874,7 +874,7 @@ def ceph_volume_upload(config, pool, volume, image_format, image_file):
bar = UploadProgressBar(image_file, end_message="Parsing file on remote side...", end_nl=False) bar = UploadProgressBar(image_file, end_message="Parsing file on remote side...", end_nl=False)
upload_data = MultipartEncoder( upload_data = MultipartEncoder(
fields={ 'file': ('filename', open(image_file, 'rb'), 'application/octet-stream')} fields={'file': ('filename', open(image_file, 'rb'), 'application/octet-stream')}
) )
upload_monitor = MultipartEncoderMonitor(upload_data, bar.update) upload_monitor = MultipartEncoderMonitor(upload_data, bar.update)

2
client-cli/cli_lib/provisioner.py
View File

@ -432,7 +432,7 @@ def ova_upload(config, name, ova_file, params):
bar = UploadProgressBar(ova_file, end_message="Parsing file on remote side...", end_nl=False) bar = UploadProgressBar(ova_file, end_message="Parsing file on remote side...", end_nl=False)
upload_data = MultipartEncoder( upload_data = MultipartEncoder(
fields={ 'file': ('filename', open(ova_file, 'rb'), 'application/octet-stream')} fields={'file': ('filename', open(ova_file, 'rb'), 'application/octet-stream')}
) )
upload_monitor = MultipartEncoderMonitor(upload_data, bar.update) upload_monitor = MultipartEncoderMonitor(upload_data, bar.update)

2
client-cli/pvc.py
View File

@ -85,7 +85,7 @@ def get_config(store_data, cluster=None):
if os.path.isfile(cfgfile): if os.path.isfile(cfgfile):
host, port, scheme, api_key = read_from_yaml(cfgfile) host, port, scheme, api_key = read_from_yaml(cfgfile)
else: else:
return { 'badcfg': True } return {'badcfg': True }
# Handle an all-wildcard address # Handle an all-wildcard address
if host == '0.0.0.0': if host == '0.0.0.0':
host = '127.0.0.1' host = '127.0.0.1'

4
daemon-common/cluster.py
View File

@ -144,8 +144,8 @@ def getClusterInformation(zk_conn):
except KeyError: except KeyError:
ceph_osd_in = 0 ceph_osd_in = 0
up_texts = { 1: 'up', 0: 'down' } up_texts = {1: 'up', 0: 'down' }
in_texts = { 1: 'in', 0: 'out' } in_texts = {1: 'in', 0: 'out' }
if not ceph_osd_up or not ceph_osd_in: if not ceph_osd_up or not ceph_osd_in:
ceph_osd_healthy_status[index] = False ceph_osd_healthy_status[index] = False

2
daemon-common/common.py
View File

@ -373,7 +373,7 @@ def getDomainControllers(parsed_xml):
controller_model = device.attrib.get('model') controller_model = device.attrib.get('model')
except KeyError: except KeyError:
controller_model = 'none' controller_model = 'none'
controller_obj = { 'type': controller_type, 'model': controller_model } controller_obj = {'type': controller_type, 'model': controller_model }
dcontrollers.append(controller_obj) dcontrollers.append(controller_obj)
return dcontrollers return dcontrollers

16
daemon-common/vm.py
View File

@ -274,7 +274,7 @@ def modify_vm(zk_conn, domain, restart, new_vm_config):
if restart: if restart:
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'restart' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'restart' })
lock.release() lock.release()
return True, '' return True, ''
@ -301,7 +301,7 @@ def undefine_vm(zk_conn, domain):
# Set the domain into stop mode # Set the domain into stop mode
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'stop' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'stop' })
lock.release() lock.release()
# Wait for 2 seconds to allow state to flow to all nodes # Wait for 2 seconds to allow state to flow to all nodes
@ -330,7 +330,7 @@ def remove_vm(zk_conn, domain):
# Set the domain into stop mode # Set the domain into stop mode
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'stop' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'stop' })
lock.release() lock.release()
# Wait for 2 seconds to allow state to flow to all nodes # Wait for 2 seconds to allow state to flow to all nodes
@ -364,7 +364,7 @@ def start_vm(zk_conn, domain):
# Set the VM to start # Set the VM to start
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'start' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'start' })
lock.release() lock.release()
return True, 'Starting VM "{}".'.format(domain) return True, 'Starting VM "{}".'.format(domain)
@ -385,7 +385,7 @@ def restart_vm(zk_conn, domain, wait=False):
# Set the VM to restart # Set the VM to restart
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'restart' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'restart' })
lock.release() lock.release()
if wait: if wait:
@ -411,7 +411,7 @@ def shutdown_vm(zk_conn, domain, wait=False):
# Set the VM to shutdown # Set the VM to shutdown
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'shutdown' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'shutdown' })
lock.release() lock.release()
if wait: if wait:
@ -430,7 +430,7 @@ def stop_vm(zk_conn, domain):
# Set the VM to start # Set the VM to start
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'stop' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'stop' })
lock.release() lock.release()
return True, 'Forcibly stopping VM "{}".'.format(domain) return True, 'Forcibly stopping VM "{}".'.format(domain)
@ -449,7 +449,7 @@ def disable_vm(zk_conn, domain):
# Set the VM to start # Set the VM to start
lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid)) lock = zkhandler.exclusivelock(zk_conn, '/domains/{}/state'.format(dom_uuid))
lock.acquire() lock.acquire()
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(dom_uuid): 'disable' }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(dom_uuid): 'disable' })
lock.release() lock.release()
return True, 'Marked VM "{}" as disable.'.format(domain) return True, 'Marked VM "{}" as disable.'.format(domain)

30
node-daemon/pvcnoded/Daemon.py
View File

@ -557,7 +557,7 @@ def cleanup():
logger.out('Terminating pvcnoded and cleaning up', state='s') logger.out('Terminating pvcnoded and cleaning up', state='s')
# Set shutdown state in Zookeeper # Set shutdown state in Zookeeper
zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(myhostname): 'shutdown' }) zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(myhostname): 'shutdown' })
# Waiting for any flushes to complete # Waiting for any flushes to complete
logger.out('Waiting for any active flushes', state='s') logger.out('Waiting for any active flushes', state='s')
@ -599,7 +599,7 @@ def cleanup():
node_keepalive() node_keepalive()
# Set stop state in Zookeeper # Set stop state in Zookeeper
zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(myhostname): 'stop' }) zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(myhostname): 'stop' })
# Forcibly terminate dnsmasq because it gets stuck sometimes # Forcibly terminate dnsmasq because it gets stuck sometimes
common.run_os_command('killall dnsmasq') common.run_os_command('killall dnsmasq')
@ -690,7 +690,7 @@ if current_primary and current_primary != 'none':
else: else:
if config['daemon_mode'] == 'coordinator': if config['daemon_mode'] == 'coordinator':
logger.out('No primary node found; creating with us as primary.', state='i') logger.out('No primary node found; creating with us as primary.', state='i')
zkhandler.writedata(zk_conn, { '/primary_node': myhostname }) zkhandler.writedata(zk_conn, {'/primary_node': myhostname })
############################################################################### ###############################################################################
# PHASE 7a - Ensure IPMI is reachable and working # PHASE 7a - Ensure IPMI is reachable and working
@ -742,8 +742,8 @@ if enable_networking:
flush ruleset flush ruleset
# Add the filter table and chains # Add the filter table and chains
add table inet filter add table inet filter
add chain inet filter forward {{ type filter hook forward priority 0; }} add chain inet filter forward {{type filter hook forward priority 0; }}
add chain inet filter input {{ type filter hook input priority 0; }} add chain inet filter input {{type filter hook input priority 0; }}
# Include static rules and network rules # Include static rules and network rules
include "{rulesdir}/static/*" include "{rulesdir}/static/*"
include "{rulesdir}/networks/*" include "{rulesdir}/networks/*"
@ -1042,7 +1042,7 @@ def collect_ceph_stats(queue):
logger.out("Getting health stats from monitor", state='d', prefix='ceph-thread') logger.out("Getting health stats from monitor", state='d', prefix='ceph-thread')
# Get Ceph cluster health for local status output # Get Ceph cluster health for local status output
command = { "prefix": "health", "format": "json" } command = {"prefix": "health", "format": "json" }
try: try:
health_status = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1]) health_status = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])
ceph_health = health_status['status'] ceph_health = health_status['status']
@ -1062,7 +1062,7 @@ def collect_ceph_stats(queue):
if debug: if debug:
logger.out("Set ceph health information in zookeeper (primary only)", state='d', prefix='ceph-thread') logger.out("Set ceph health information in zookeeper (primary only)", state='d', prefix='ceph-thread')
command = { "prefix": "status", "format": "pretty" } command = {"prefix": "status", "format": "pretty" }
ceph_status = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii') ceph_status = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii')
try: try:
zkhandler.writedata(zk_conn, { zkhandler.writedata(zk_conn, {
@ -1076,7 +1076,7 @@ def collect_ceph_stats(queue):
logger.out("Set ceph rados df information in zookeeper (primary only)", state='d', prefix='ceph-thread') logger.out("Set ceph rados df information in zookeeper (primary only)", state='d', prefix='ceph-thread')
# Get rados df info # Get rados df info
command = { "prefix": "df", "format": "pretty" } command = {"prefix": "df", "format": "pretty" }
ceph_df = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii') ceph_df = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii')
try: try:
zkhandler.writedata(zk_conn, { zkhandler.writedata(zk_conn, {
@ -1090,7 +1090,7 @@ def collect_ceph_stats(queue):
logger.out("Set pool information in zookeeper (primary only)", state='d', prefix='ceph-thread') logger.out("Set pool information in zookeeper (primary only)", state='d', prefix='ceph-thread')
# Get pool info # Get pool info
command = { "prefix": "df", "format": "json" } command = {"prefix": "df", "format": "json" }
try: try:
ceph_pool_df_raw = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])['pools'] ceph_pool_df_raw = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])['pools']
except Exception as e: except Exception as e:
@ -1161,7 +1161,7 @@ def collect_ceph_stats(queue):
# Parse the dump data # Parse the dump data
osd_dump = dict() osd_dump = dict()
command = { "prefix": "osd dump", "format": "json" } command = {"prefix": "osd dump", "format": "json" }
try: try:
retcode, stdout, stderr = common.run_os_command('ceph osd dump --format json --connect-timeout 2', timeout=2) retcode, stdout, stderr = common.run_os_command('ceph osd dump --format json --connect-timeout 2', timeout=2)
osd_dump_raw = json.loads(stdout)['osds'] osd_dump_raw = json.loads(stdout)['osds']
@ -1187,7 +1187,7 @@ def collect_ceph_stats(queue):
osd_df = dict() osd_df = dict()
command = { "prefix": "osd df", "format": "json" } command = {"prefix": "osd df", "format": "json" }
try: try:
osd_df_raw = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])['nodes'] osd_df_raw = json.loads(ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1])['nodes']
except Exception as e: except Exception as e:
@ -1214,7 +1214,7 @@ def collect_ceph_stats(queue):
osd_status = dict() osd_status = dict()
command = { "prefix": "osd status", "format": "pretty" } command = {"prefix": "osd status", "format": "pretty" }
try: try:
osd_status_raw = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii') osd_status_raw = ceph_conn.mon_command(json.dumps(command), b'', timeout=1)[1].decode('ascii')
except Exception as e: except Exception as e:
@ -1341,7 +1341,7 @@ def collect_vm_stats(queue):
raise raise
except Exception: except Exception:
# Toggle a state "change" # Toggle a state "change"
zkhandler.writedata(zk_conn, { '/domains/{}/state'.format(domain): instance.getstate() }) zkhandler.writedata(zk_conn, {'/domains/{}/state'.format(domain): instance.getstate() })
elif instance.getnode() == this_node.name: elif instance.getnode() == this_node.name:
memprov += instance.getmemory() memprov += instance.getmemory()
@ -1469,7 +1469,7 @@ def node_keepalive():
past_state = zkhandler.readdata(zk_conn, '/nodes/{}/daemonstate'.format(this_node.name)) past_state = zkhandler.readdata(zk_conn, '/nodes/{}/daemonstate'.format(this_node.name))
if past_state != 'run': if past_state != 'run':
this_node.daemon_state = 'run' this_node.daemon_state = 'run'
zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(this_node.name): 'run' }) zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(this_node.name): 'run' })
else: else:
this_node.daemon_state = 'run' this_node.daemon_state = 'run'
@ -1638,7 +1638,7 @@ def node_keepalive():
fence_thread = Thread(target=fencing.fenceNode, args=(node_name, zk_conn, config, logger), kwargs={}) fence_thread = Thread(target=fencing.fenceNode, args=(node_name, zk_conn, config, logger), kwargs={})
fence_thread.start() fence_thread.start()
# Write the updated data after we start the fence thread # Write the updated data after we start the fence thread
zkhandler.writedata(zk_conn, { '/nodes/{}/daemonstate'.format(node_name): 'dead' }) zkhandler.writedata(zk_conn, {'/nodes/{}/daemonstate'.format(node_name): 'dead' })
if debug: if debug:
logger.out("Keepalive finished", state='d', prefix='main-thread') logger.out("Keepalive finished", state='d', prefix='main-thread')

10
node-daemon/pvcnoded/NodeInstance.py
View File

@ -646,8 +646,8 @@ class NodeInstance(object):
if target_node is None: if target_node is None:
self.logger.out('Failed to find migration target for VM "{}"; shutting down and setting autostart flag'.format(dom_uuid), state='e') self.logger.out('Failed to find migration target for VM "{}"; shutting down and setting autostart flag'.format(dom_uuid), state='e')
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(dom_uuid): 'shutdown' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(dom_uuid): 'shutdown' })
zkhandler.writedata(self.zk_conn, { '/domains/{}/node_autostart'.format(dom_uuid): 'True' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/node_autostart'.format(dom_uuid): 'True' })
else: else:
self.logger.out('Migrating VM "{}" to node "{}"'.format(dom_uuid, target_node), state='i') self.logger.out('Migrating VM "{}" to node "{}"'.format(dom_uuid, target_node), state='i')
zkhandler.writedata(self.zk_conn, { zkhandler.writedata(self.zk_conn, {
@ -665,8 +665,8 @@ class NodeInstance(object):
break break
time.sleep(0.2) time.sleep(0.2)
zkhandler.writedata(self.zk_conn, { '/nodes/{}/runningdomains'.format(self.name): '' }) zkhandler.writedata(self.zk_conn, {'/nodes/{}/runningdomains'.format(self.name): '' })
zkhandler.writedata(self.zk_conn, { '/nodes/{}/domainstate'.format(self.name): 'flushed' }) zkhandler.writedata(self.zk_conn, {'/nodes/{}/domainstate'.format(self.name): 'flushed' })
self.flush_thread = None self.flush_thread = None
self.flush_stopper = False self.flush_stopper = False
return return
@ -714,7 +714,7 @@ class NodeInstance(object):
while zkhandler.readdata(self.zk_conn, '/domains/{}/state'.format(dom_uuid)) in ['migrate', 'unmigrate', 'shutdown']: while zkhandler.readdata(self.zk_conn, '/domains/{}/state'.format(dom_uuid)) in ['migrate', 'unmigrate', 'shutdown']:
time.sleep(0.1) time.sleep(0.1)
zkhandler.writedata(self.zk_conn, { '/nodes/{}/domainstate'.format(self.name): 'ready' }) zkhandler.writedata(self.zk_conn, {'/nodes/{}/domainstate'.format(self.name): 'ready' })
self.flush_thread = None self.flush_thread = None
self.flush_stopper = False self.flush_stopper = False
return return

2
node-daemon/pvcnoded/VMConsoleWatcherInstance.py
View File

@ -86,7 +86,7 @@ class VMConsoleWatcherInstance(object):
self.fetch_lines() self.fetch_lines()
# Update Zookeeper with the new loglines if they changed # Update Zookeeper with the new loglines if they changed
if self.loglines != self.last_loglines: if self.loglines != self.last_loglines:
zkhandler.writedata(self.zk_conn, { '/domains/{}/consolelog'.format(self.domuuid): self.loglines }) zkhandler.writedata(self.zk_conn, {'/domains/{}/consolelog'.format(self.domuuid): self.loglines })
self.last_loglines = self.loglines self.last_loglines = self.loglines
def fetch_lines(self): def fetch_lines(self):

38
node-daemon/pvcnoded/VMInstance.py
View File

@ -185,7 +185,7 @@ class VMInstance(object):
# Add the domain to the domain_list array # Add the domain to the domain_list array
self.this_node.domain_list.append(self.domuuid) self.this_node.domain_list.append(self.domuuid)
# Push the change up to Zookeeper # Push the change up to Zookeeper
zkhandler.writedata(self.zk_conn, { '/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) }) zkhandler.writedata(self.zk_conn, {'/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) })
except Exception as e: except Exception as e:
self.logger.out('Error adding domain to list: {}'.format(e), state='e') self.logger.out('Error adding domain to list: {}'.format(e), state='e')
@ -195,7 +195,7 @@ class VMInstance(object):
# Remove the domain from the domain_list array # Remove the domain from the domain_list array
self.this_node.domain_list.remove(self.domuuid) self.this_node.domain_list.remove(self.domuuid)
# Push the change up to Zookeeper # Push the change up to Zookeeper
zkhandler.writedata(self.zk_conn, { '/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) }) zkhandler.writedata(self.zk_conn, {'/nodes/{}/runningdomains'.format(self.this_node.name): ' '.join(self.this_node.domain_list) })
except Exception as e: except Exception as e:
self.logger.out('Error removing domain from list: {}'.format(e), state='e') self.logger.out('Error removing domain from list: {}'.format(e), state='e')
@ -225,7 +225,7 @@ class VMInstance(object):
if curstate == libvirt.VIR_DOMAIN_RUNNING: if curstate == libvirt.VIR_DOMAIN_RUNNING:
# If it is running just update the model # If it is running just update the model
self.addDomainToList() self.addDomainToList()
zkhandler.writedata(self.zk_conn, { '/domains/{}/failedreason'.format(self.domuuid): '' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/failedreason'.format(self.domuuid): '' })
else: else:
# Or try to create it # Or try to create it
try: try:
@ -235,11 +235,11 @@ class VMInstance(object):
self.addDomainToList() self.addDomainToList()
self.logger.out('Successfully started VM', state='o', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Successfully started VM', state='o', prefix='Domain {}'.format(self.domuuid))
self.dom = dom self.dom = dom
zkhandler.writedata(self.zk_conn, { '/domains/{}/failedreason'.format(self.domuuid): '' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/failedreason'.format(self.domuuid): '' })
except libvirt.libvirtError as e: except libvirt.libvirtError as e:
self.logger.out('Failed to create VM', state='e', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Failed to create VM', state='e', prefix='Domain {}'.format(self.domuuid))
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'fail' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'fail' })
zkhandler.writedata(self.zk_conn, { '/domains/{}/failedreason'.format(self.domuuid): str(e) }) zkhandler.writedata(self.zk_conn, {'/domains/{}/failedreason'.format(self.domuuid): str(e) })
self.dom = None self.dom = None
lv_conn.close() lv_conn.close()
@ -264,7 +264,7 @@ class VMInstance(object):
self.start_vm() self.start_vm()
self.addDomainToList() self.addDomainToList()
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
lv_conn.close() lv_conn.close()
self.inrestart = False self.inrestart = False
@ -295,7 +295,7 @@ class VMInstance(object):
self.removeDomainFromList() self.removeDomainFromList()
if self.inrestart is False: if self.inrestart is False:
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'stop' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'stop' })
self.logger.out('Successfully stopped VM', state='o', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Successfully stopped VM', state='o', prefix='Domain {}'.format(self.domuuid))
self.dom = None self.dom = None
@ -329,7 +329,7 @@ class VMInstance(object):
if lvdomstate != libvirt.VIR_DOMAIN_RUNNING: if lvdomstate != libvirt.VIR_DOMAIN_RUNNING:
self.removeDomainFromList() self.removeDomainFromList()
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'stop' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'stop' })
self.logger.out('Successfully shutdown VM', state='o', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Successfully shutdown VM', state='o', prefix='Domain {}'.format(self.domuuid))
self.dom = None self.dom = None
# Stop the log watcher # Stop the log watcher
@ -338,7 +338,7 @@ class VMInstance(object):
if tick >= self.config['vm_shutdown_timeout']: if tick >= self.config['vm_shutdown_timeout']:
self.logger.out('Shutdown timeout ({}s) expired, forcing off'.format(self.config['vm_shutdown_timeout']), state='e', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Shutdown timeout ({}s) expired, forcing off'.format(self.config['vm_shutdown_timeout']), state='e', prefix='Domain {}'.format(self.domuuid))
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'stop' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'stop' })
break break
self.inshutdown = False self.inshutdown = False
@ -349,7 +349,7 @@ class VMInstance(object):
if self.inrestart: if self.inrestart:
# Wait to prevent race conditions # Wait to prevent race conditions
time.sleep(1) time.sleep(1)
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
# Migrate the VM to a target host # Migrate the VM to a target host
def migrate_vm(self, force_live=False, force_shutdown=False): def migrate_vm(self, force_live=False, force_shutdown=False):
@ -458,7 +458,7 @@ class VMInstance(object):
def migrate_shutdown(): def migrate_shutdown():
self.logger.out('Shutting down VM for offline migration', state='i', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Shutting down VM for offline migration', state='i', prefix='Domain {}'.format(self.domuuid))
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'shutdown' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'shutdown' })
while zkhandler.readdata(self.zk_conn, '/domains/{}/state'.format(self.domuuid)) != 'stop': while zkhandler.readdata(self.zk_conn, '/domains/{}/state'.format(self.domuuid)) != 'stop':
time.sleep(0.5) time.sleep(0.5)
return True return True
@ -551,7 +551,7 @@ class VMInstance(object):
self.logger.out('Receiving VM migration from node "{}"'.format(self.node), state='i', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Receiving VM migration from node "{}"'.format(self.node), state='i', prefix='Domain {}'.format(self.domuuid))
# Ensure our lock key is populated # Ensure our lock key is populated
zkhandler.writedata(self.zk_conn, { '/locks/domain_migrate/{}'.format(self.domuuid): self.domuuid }) zkhandler.writedata(self.zk_conn, {'/locks/domain_migrate/{}'.format(self.domuuid): self.domuuid })
# Synchronize nodes A (I am writer) # Synchronize nodes A (I am writer)
lock = zkhandler.writelock(self.zk_conn, '/locks/domain_migrate/{}'.format(self.domuuid)) lock = zkhandler.writelock(self.zk_conn, '/locks/domain_migrate/{}'.format(self.domuuid))
@ -601,11 +601,11 @@ class VMInstance(object):
if lvdomstate == libvirt.VIR_DOMAIN_RUNNING: if lvdomstate == libvirt.VIR_DOMAIN_RUNNING:
# VM has been received and started # VM has been received and started
self.addDomainToList() self.addDomainToList()
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
self.logger.out('Successfully received migrated VM', state='o', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Successfully received migrated VM', state='o', prefix='Domain {}'.format(self.domuuid))
else: else:
# The receive somehow failed # The receive somehow failed
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'fail' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'fail' })
else: else:
if self.node == self.this_node.name: if self.node == self.this_node.name:
if self.state in ['start']: if self.state in ['start']:
@ -613,7 +613,7 @@ class VMInstance(object):
self.logger.out('Receive aborted via state change', state='w', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Receive aborted via state change', state='w', prefix='Domain {}'.format(self.domuuid))
elif self.state in ['stop']: elif self.state in ['stop']:
# The send was shutdown-based # The send was shutdown-based
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
else: else:
# The send failed or was aborted # The send failed or was aborted
self.logger.out('Migrate aborted or failed; VM in state {}'.format(self.state), state='w', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Migrate aborted or failed; VM in state {}'.format(self.state), state='w', prefix='Domain {}'.format(self.domuuid))
@ -622,7 +622,7 @@ class VMInstance(object):
lock.release() lock.release()
self.logger.out('Released write lock for synchronization phase D', state='o', prefix='Domain {}'.format(self.domuuid)) self.logger.out('Released write lock for synchronization phase D', state='o', prefix='Domain {}'.format(self.domuuid))
zkhandler.writedata(self.zk_conn, { '/locks/domain_migrate/{}'.format(self.domuuid): '' }) zkhandler.writedata(self.zk_conn, {'/locks/domain_migrate/{}'.format(self.domuuid): '' })
self.inreceive = False self.inreceive = False
return return
@ -681,7 +681,7 @@ class VMInstance(object):
elif self.state == "migrate" or self.state == "migrate-live": elif self.state == "migrate" or self.state == "migrate-live":
# Start the log watcher # Start the log watcher
self.console_log_instance.start() self.console_log_instance.start()
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
# Add domain to running list # Add domain to running list
self.addDomainToList() self.addDomainToList()
# VM should be restarted # VM should be restarted
@ -704,7 +704,7 @@ class VMInstance(object):
self.receive_migrate() self.receive_migrate()
# VM should be restarted (i.e. started since it isn't running) # VM should be restarted (i.e. started since it isn't running)
if self.state == "restart": if self.state == "restart":
zkhandler.writedata(self.zk_conn, { '/domains/{}/state'.format(self.domuuid): 'start' }) zkhandler.writedata(self.zk_conn, {'/domains/{}/state'.format(self.domuuid): 'start' })
# VM should be shut down; ensure it's gone from this node's domain_list # VM should be shut down; ensure it's gone from this node's domain_list
elif self.state == "shutdown": elif self.state == "shutdown":
self.removeDomainFromList() self.removeDomainFromList()

4
node-daemon/pvcnoded/common.py
View File

@ -144,7 +144,7 @@ def findTargetNode(zk_conn, config, logger, dom_uuid):
node_limit = '' node_limit = ''
except Exception: except Exception:
node_limit = '' node_limit = ''
zkhandler.writedata(zk_conn, { '/domains/{}/node_limit'.format(dom_uuid): '' }) zkhandler.writedata(zk_conn, {'/domains/{}/node_limit'.format(dom_uuid): '' })
# Determine VM search field # Determine VM search field
try: try:
@ -155,7 +155,7 @@ def findTargetNode(zk_conn, config, logger, dom_uuid):
# If our search field is invalid, use and set the default (for next time) # If our search field is invalid, use and set the default (for next time)
if search_field is None or search_field == 'None': if search_field is None or search_field == 'None':
search_field = config['migration_target_selector'] search_field = config['migration_target_selector']
zkhandler.writedata(zk_conn, { '/domains/{}/node_selector'.format(dom_uuid): config['migration_target_selector'] }) zkhandler.writedata(zk_conn, {'/domains/{}/node_selector'.format(dom_uuid): config['migration_target_selector'] })
if config['debug']: if config['debug']:
logger.out('Migrating VM {} with selector {}'.format(dom_uuid, search_field), state='d', prefix='node-flush') logger.out('Migrating VM {} with selector {}'.format(dom_uuid, search_field), state='d', prefix='node-flush')

8
node-daemon/pvcnoded/fencing.py
View File

@ -62,9 +62,9 @@ def fenceNode(node_name, zk_conn, config, logger):
# Force into secondary network state if needed # Force into secondary network state if needed
if node_name in config['coordinators']: if node_name in config['coordinators']:
logger.out('Forcing secondary status for node "{}"'.format(node_name), state='i') logger.out('Forcing secondary status for node "{}"'.format(node_name), state='i')
zkhandler.writedata(zk_conn, { '/nodes/{}/routerstate'.format(node_name): 'secondary' }) zkhandler.writedata(zk_conn, {'/nodes/{}/routerstate'.format(node_name): 'secondary' })
if zkhandler.readdata(zk_conn, '/primary_node') == node_name: if zkhandler.readdata(zk_conn, '/primary_node') == node_name:
zkhandler.writedata(zk_conn, { '/primary_node': 'none' }) zkhandler.writedata(zk_conn, {'/primary_node': 'none' })
# If the fence succeeded and successful_fence is migrate # If the fence succeeded and successful_fence is migrate
if fence_status and config['successful_fence'] == 'migrate': if fence_status and config['successful_fence'] == 'migrate':
@ -82,7 +82,7 @@ def migrateFromFencedNode(zk_conn, node_name, config, logger):
dead_node_running_domains = zkhandler.readdata(zk_conn, '/nodes/{}/runningdomains'.format(node_name)).split() dead_node_running_domains = zkhandler.readdata(zk_conn, '/nodes/{}/runningdomains'.format(node_name)).split()
# Set the node to a custom domainstate so we know what's happening # Set the node to a custom domainstate so we know what's happening
zkhandler.writedata(zk_conn, { '/nodes/{}/domainstate'.format(node_name): 'fence-flush' }) zkhandler.writedata(zk_conn, {'/nodes/{}/domainstate'.format(node_name): 'fence-flush' })
# Migrate a VM after a flush # Migrate a VM after a flush
def fence_migrate_vm(dom_uuid): def fence_migrate_vm(dom_uuid):
@ -109,7 +109,7 @@ def migrateFromFencedNode(zk_conn, node_name, config, logger):
fence_migrate_vm(dom_uuid) fence_migrate_vm(dom_uuid)
# Set node in flushed state for easy remigrating when it comes back # Set node in flushed state for easy remigrating when it comes back
zkhandler.writedata(zk_conn, { '/nodes/{}/domainstate'.format(node_name): 'flushed' }) zkhandler.writedata(zk_conn, {'/nodes/{}/domainstate'.format(node_name): 'flushed' })
# #
# Perform an IPMI fence # Perform an IPMI fence

32
node-daemon/pvcnoded/log.py
View File

@ -44,25 +44,25 @@ class Logger(object):
# Format maps # Format maps
format_map_colourized = { format_map_colourized = {
# Colourized formatting with chevron prompts (log_colours = True) # Colourized formatting with chevron prompts (log_colours = True)
'o': { 'colour': fmt_green, 'prompt': '>>> ' }, 'o': {'colour': fmt_green, 'prompt': '>>> ' },
'e': { 'colour': fmt_red, 'prompt': '>>> ' }, 'e': {'colour': fmt_red, 'prompt': '>>> ' },
'w': { 'colour': fmt_yellow, 'prompt': '>>> ' }, 'w': {'colour': fmt_yellow, 'prompt': '>>> ' },
't': { 'colour': fmt_purple, 'prompt': '>>> ' }, 't': {'colour': fmt_purple, 'prompt': '>>> ' },
'i': { 'colour': fmt_blue, 'prompt': '>>> ' }, 'i': {'colour': fmt_blue, 'prompt': '>>> ' },
's': { 'colour': fmt_cyan, 'prompt': '>>> ' }, 's': {'colour': fmt_cyan, 'prompt': '>>> ' },
'd': { 'colour': fmt_white, 'prompt': '>>> ' }, 'd': {'colour': fmt_white, 'prompt': '>>> ' },
'x': { 'colour': last_colour, 'prompt': last_prompt } 'x': {'colour': last_colour, 'prompt': last_prompt }
} }
format_map_textual = { format_map_textual = {
# Uncolourized formatting with text prompts (log_colours = False) # Uncolourized formatting with text prompts (log_colours = False)
'o': { 'colour': '', 'prompt': 'ok: ' }, 'o': {'colour': '', 'prompt': 'ok: ' },
'e': { 'colour': '', 'prompt': 'failed: ' }, 'e': {'colour': '', 'prompt': 'failed: ' },
'w': { 'colour': '', 'prompt': 'warning: ' }, 'w': {'colour': '', 'prompt': 'warning: ' },
't': { 'colour': '', 'prompt': 'tick: ' }, 't': {'colour': '', 'prompt': 'tick: ' },
'i': { 'colour': '', 'prompt': 'info: ' }, 'i': {'colour': '', 'prompt': 'info: ' },
's': { 'colour': '', 'prompt': 'system: ' }, 's': {'colour': '', 'prompt': 'system: ' },
'd': { 'colour': '', 'prompt': 'debug: ' }, 'd': {'colour': '', 'prompt': 'debug: ' },
'x': { 'colour': '', 'prompt': last_prompt } 'x': {'colour': '', 'prompt': last_prompt }
} }
# Initialization of instance # Initialization of instance