pvc/client-cli/cli_lib/provisioner.py

1145 lines
43 KiB
Python
Raw Normal View History

2020-01-02 11:18:46 -05:00
#!/usr/bin/env python3
# provisioner.py - PVC CLI client function library, Provisioner functions
# Part of the Parallel Virtual Cluster (PVC) system
#
2020-01-08 19:38:02 -05:00
# Copyright (C) 2018-2020 Joshua M. Boniface <joshua@boniface.me>
2020-01-02 11:18:46 -05:00
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
###############################################################################
import time
import re
import subprocess
import cli_lib.ansiprint as ansiprint
from cli_lib.common import call_api
2020-01-02 11:18:46 -05:00
#
# Primary functions
#
def template_info(config, template, template_type):
"""
Get information about template
API endpoint: GET /api/v1/provisioner/template/{template_type}/{template}
API arguments:
2020-01-04 13:04:01 -05:00
API schema: {json_template_object}
2020-01-02 11:18:46 -05:00
"""
response = call_api(config, 'get', '/provisioner/template/{template_type}/{template}'.format(template_type=template_type, template=template))
2020-01-02 11:18:46 -05:00
if response.status_code == 200:
return True, response.json()
else:
return False, response.json()['message']
def template_list(config, limit, template_type=None):
"""
Get list information about templates (limited by {limit})
API endpoint: GET /api/v1/provisioner/template/{template_type}
API arguments: limit={limit}
2020-01-04 13:04:01 -05:00
API schema: [{json_template_object},{json_template_object},etc.]
2020-01-02 11:18:46 -05:00
"""
params = dict()
if limit:
params['limit'] = limit
if template_type is not None:
response = call_api(config, 'get', '/provisioner/template/{template_type}'.format(template_type=template_type), params=params)
2020-01-02 11:18:46 -05:00
else:
response = call_api(config, 'get', '/provisioner/template', params=params)
2020-01-02 11:18:46 -05:00
if response.status_code == 200:
return True, response.json()
else:
return False, response.json()['message']
2020-01-04 11:58:30 -05:00
def template_add(config, params, template_type=None):
"""
Add a new template of {template_type} with {params}
API endpoint: POST /api/v1/provisioner/template/{template_type}
API_arguments: args
API schema: {message}
"""
response = call_api(config, 'post', '/provisioner/template/{template_type}'.format(template_type=template_type), params=params)
2020-01-04 11:58:30 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def template_remove(config, name, template_type=None):
"""
2020-01-04 13:04:01 -05:00
Remove template {name} of {template_type}
2020-01-04 11:58:30 -05:00
API endpoint: DELETE /api/v1/provisioner/template/{template_type}/{name}
API_arguments:
API schema: {message}
"""
response = call_api(config, 'delete', '/provisioner/template/{template_type}/{name}'.format(template_type=template_type, name=name))
2020-01-04 11:58:30 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def template_element_add(config, name, element_id, params, element_type=None, template_type=None):
"""
Add a new template element of {element_type} with {params} to template {name} of {template_type}
API endpoint: POST /api/v1/provisioner/template/{template_type}/{name}/{element_type}/{element_id}
API_arguments: args
API schema: {message}
"""
response = call_api(config, 'post', '/provisioner/template/{template_type}/{name}/{element_type}/{element_id}'.format(template_type=template_type, name=name, element_type=element_type, element_id=element_id), params=params)
2020-01-04 11:58:30 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def template_element_remove(config, name, element_id, element_type=None, template_type=None):
"""
2020-01-04 13:04:01 -05:00
Remove template element {element_id} of {element_type} from template {name} of {template_type}
2020-01-04 11:58:30 -05:00
API endpoint: DELETE /api/v1/provisioner/template/{template_type}/{name}/{element_type}/{element_id}
API_arguments:
API schema: {message}
"""
response = call_api(config, 'delete', '/provisioner/template/{template_type}/{name}/{element_type}/{element_id}'.format(template_type=template_type, name=name, element_type=element_type, element_id=element_id))
2020-01-04 11:58:30 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
2020-01-04 13:04:01 -05:00
def userdata_info(config, userdata):
"""
Get information about userdata
API endpoint: GET /api/v1/provisioner/userdata/{userdata}
API arguments:
API schema: {json_data_object}
"""
response = call_api(config, 'get', '/provisioner/userdata/{userdata}'.format(userdata=userdata))
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
return True, response.json()[0]
else:
return False, response.json()['message']
def userdata_list(config, limit):
"""
Get list information about userdatas (limited by {limit})
2020-01-04 14:06:36 -05:00
API endpoint: GET /api/v1/provisioner/userdata
2020-01-04 13:04:01 -05:00
API arguments: limit={limit}
API schema: [{json_data_object},{json_data_object},etc.]
"""
params = dict()
if limit:
params['limit'] = limit
response = call_api(config, 'get', '/provisioner/userdata', params=params)
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
return True, response.json()
else:
return False, response.json()['message']
def userdata_add(config, params):
"""
Add a new userdata with {params}
API endpoint: POST /api/v1/provisioner/userdata
API_arguments: args
API schema: {message}
"""
2020-01-06 23:28:06 -05:00
name = params.get('name')
userdata_data = params.get('data')
params = {
'name': name
}
data = {
'data': userdata_data
}
response = call_api(config, 'post', '/provisioner/userdata', params=params, data=data)
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def userdata_modify(config, name, params):
"""
Modify userdata {name} with {params}
API endpoint: PUT /api/v1/provisioner/userdata/{name}
API_arguments: args
API schema: {message}
"""
2020-01-06 23:28:06 -05:00
userdata_data = params.get('data')
params = {
'name': name
}
data = {
'data': userdata_data
}
response = call_api(config, 'put', '/provisioner/userdata/{name}'.format(name=name), params=params, data=data)
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def userdata_remove(config, name):
"""
Remove userdata {name}
API endpoint: DELETE /api/v1/provisioner/userdata/{name}
API_arguments:
API schema: {message}
"""
response = call_api(config, 'delete', '/provisioner/userdata/{name}'.format(name=name))
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def script_info(config, script):
"""
Get information about script
API endpoint: GET /api/v1/provisioner/script/{script}
API arguments:
API schema: {json_data_object}
"""
response = call_api(config, 'get', '/provisioner/script/{script}'.format(script=script))
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
return True, response.json()[0]
else:
return False, response.json()['message']
def script_list(config, limit):
"""
Get list information about scripts (limited by {limit})
2020-01-04 14:06:36 -05:00
API endpoint: GET /api/v1/provisioner/script
2020-01-04 13:04:01 -05:00
API arguments: limit={limit}
API schema: [{json_data_object},{json_data_object},etc.]
"""
params = dict()
if limit:
params['limit'] = limit
response = call_api(config, 'get', '/provisioner/script', params=params)
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
return True, response.json()
else:
return False, response.json()['message']
def script_add(config, params):
"""
Add a new script with {params}
API endpoint: POST /api/v1/provisioner/script
API_arguments: args
API schema: {message}
"""
2020-01-06 23:28:06 -05:00
name = params.get('name')
script_data = params.get('data')
params = {
'name': name
}
data = {
'data': script_data
}
response = call_api(config, 'post', '/provisioner/script', params=params, data=data)
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def script_modify(config, name, params):
"""
Modify script {name} with {params}
2020-01-04 11:58:30 -05:00
2020-01-04 13:04:01 -05:00
API endpoint: PUT /api/v1/provisioner/script/{name}
API_arguments: args
API schema: {message}
"""
2020-01-06 23:28:06 -05:00
script_data = params.get('data')
params = {
'name': name
}
data = {
'data': script_data
}
response = call_api(config, 'put', '/provisioner/script/{name}'.format(name=name), params=params, data=data)
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def script_remove(config, name):
"""
Remove script {name}
API endpoint: DELETE /api/v1/provisioner/script/{name}
API_arguments:
API schema: {message}
"""
response = call_api(config, 'delete', '/provisioner/script/{name}'.format(name=name))
2020-01-04 13:04:01 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
2020-01-04 11:58:30 -05:00
2020-01-04 14:06:36 -05:00
def profile_info(config, profile):
"""
Get information about profile
API endpoint: GET /api/v1/provisioner/profile/{profile}
API arguments:
API schema: {json_data_object}
"""
response = call_api(config, 'get', '/provisioner/profile/{profile}'.format(profile=profile))
2020-01-04 14:06:36 -05:00
if response.status_code == 200:
return True, response.json()[0]
else:
return False, response.json()['message']
def profile_list(config, limit):
"""
Get list information about profiles (limited by {limit})
API endpoint: GET /api/v1/provisioner/profile/{profile_type}
API arguments: limit={limit}
API schema: [{json_data_object},{json_data_object},etc.]
"""
params = dict()
if limit:
params['limit'] = limit
response = call_api(config, 'get', '/provisioner/profile', params=params)
2020-01-04 14:06:36 -05:00
if response.status_code == 200:
return True, response.json()
else:
return False, response.json()['message']
def profile_add(config, params):
"""
Add a new profile with {params}
API endpoint: POST /api/v1/provisioner/profile
API_arguments: args
API schema: {message}
"""
response = call_api(config, 'post', '/provisioner/profile', params=params)
2020-01-04 14:06:36 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def profile_modify(config, name, params):
"""
Modify profile {name} with {params}
API endpoint: PUT /api/v1/provisioner/profile/{name}
API_arguments: args
API schema: {message}
"""
response = call_api(config, 'put', '/provisioner/profile/{name}'.format(name=name), params=params)
2020-01-04 14:06:36 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def profile_remove(config, name):
"""
Remove profile {name}
API endpoint: DELETE /api/v1/provisioner/profile/{name}
API_arguments:
API schema: {message}
"""
response = call_api(config, 'delete', '/provisioner/profile/{name}'.format(name=name))
2020-01-04 14:06:36 -05:00
if response.status_code == 200:
retvalue = True
else:
retvalue = False
return retvalue, response.json()['message']
def vm_create(config, name, profile, wait_flag, define_flag, start_flag):
2020-01-04 14:06:36 -05:00
"""
2020-01-04 14:31:22 -05:00
Create a new VM named {name} with profile {profile}
2020-01-04 14:06:36 -05:00
2020-01-04 14:31:22 -05:00
API endpoint: POST /api/v1/provisioner/create
API_arguments: name={name}, profile={profile}
API schema: {message}
"""
params = {
'name': name,
'profile': profile,
'start_vm': start_flag,
'define_vm': define_flag
}
response = call_api(config, 'post', '/provisioner/create', params=params)
2020-01-04 14:31:22 -05:00
if response.status_code == 202:
retvalue = True
if not wait_flag:
retdata = 'Task ID: {}'.format(response.json()['task_id'])
else:
# Just return the task_id raw, instead of formatting it
retdata = response.json()['task_id']
2020-01-04 14:31:22 -05:00
else:
retvalue = False
retdata = response.json()['message']
return retvalue, retdata
def task_status(config, task_id, is_watching=False):
2020-01-04 14:31:22 -05:00
"""
Get information about provisioner job {task_id}
API endpoint: GET /api/v1/provisioner/status
2020-01-04 14:06:36 -05:00
API arguments:
API schema: {json_data_object}
"""
response = call_api(config, 'get', '/provisioner/status/{task_id}'.format(task_id=task_id))
2020-01-04 14:06:36 -05:00
if response.status_code == 200:
2020-01-04 14:31:22 -05:00
retvalue = True
respjson = response.json()
if is_watching:
# Just return the raw JSON to the watching process instead of formatting it
return respjson
2020-01-04 14:31:22 -05:00
job_state = respjson['state']
if job_state == 'RUNNING':
retdata = 'Job state: RUNNING\nStage: {}/{}\nStatus: {}'.format(
respjson['current'],
respjson['total'],
respjson['status']
)
2020-01-04 14:45:40 -05:00
elif job_state == 'FAILED':
2020-01-04 14:31:22 -05:00
retdata = 'Job state: FAILED\nStatus: {}'.format(
respjson['status']
)
2020-01-04 14:45:40 -05:00
elif job_state == 'COMPLETED':
retdata = 'Job state: COMPLETED\nStatus: {}'.format(
respjson['status']
)
else:
retdata = 'Job state: {}\nStatus: {}'.format(
respjson['state'],
respjson['status']
)
2020-01-04 14:06:36 -05:00
else:
2020-01-04 14:31:22 -05:00
retvalue = False
retdata = response.json()['message']
return retvalue, retdata
2020-01-04 14:06:36 -05:00
2020-01-04 11:58:30 -05:00
#
# Format functions
#
2020-01-04 14:06:36 -05:00
def format_list_template(template_data, template_type=None):
2020-01-02 11:18:46 -05:00
"""
2020-01-04 13:04:01 -05:00
Format the returned template template
2020-01-02 11:18:46 -05:00
template_type can be used to only display part of the full list, allowing function
reuse with more limited output options.
"""
template_types = [ 'system', 'network', 'storage' ]
2020-01-04 14:06:36 -05:00
normalized_template_data = dict()
ainformation = list()
2020-01-02 11:18:46 -05:00
if template_type in template_types:
template_types = [ template_type ]
2020-01-04 14:06:36 -05:00
template_data_type = '{}_templates'.format(template_type)
normalized_template_data[template_data_type] = template_data
2020-01-04 11:58:30 -05:00
else:
2020-01-04 14:06:36 -05:00
normalized_template_data = template_data
2020-01-02 11:18:46 -05:00
if 'system' in template_types:
ainformation.append('System templates:')
ainformation.append('')
ainformation.append(format_list_template_system(normalized_template_data['system_templates']))
2020-01-04 11:58:30 -05:00
if len(template_types) > 1:
ainformation.append('')
2020-01-02 11:18:46 -05:00
if 'network' in template_types:
ainformation.append('Network templates:')
ainformation.append('')
ainformation.append(format_list_template_network(normalized_template_data['network_templates']))
2020-01-04 11:58:30 -05:00
if len(template_types) > 1:
ainformation.append('')
2020-01-02 11:18:46 -05:00
2020-01-04 11:58:30 -05:00
if 'storage' in template_types:
ainformation.append('Storage templates:')
ainformation.append('')
ainformation.append(format_list_template_storage(normalized_template_data['storage_templates']))
return '\n'.join(ainformation)
2020-01-02 11:18:46 -05:00
2020-01-04 14:06:36 -05:00
def format_list_template_system(template_data):
if isinstance(template_data, dict):
template_data = [ template_data ]
2020-01-02 11:18:46 -05:00
template_list_output = []
# Determine optimal column widths
template_name_length = 5
2020-01-04 14:06:36 -05:00
template_id_length = 3
2020-01-02 11:18:46 -05:00
template_vcpu_length = 6
template_vram_length = 10
template_serial_length = 7
template_vnc_length = 4
template_vnc_bind_length = 10
template_node_limit_length = 9
template_node_selector_length = 11
template_node_autostart_length = 11
2020-01-04 14:06:36 -05:00
for template in template_data:
2020-01-02 11:18:46 -05:00
# template_name column
_template_name_length = len(str(template['name'])) + 1
if _template_name_length > template_name_length:
template_name_length = _template_name_length
# template_id column
_template_id_length = len(str(template['id'])) + 1
if _template_id_length > template_id_length:
template_id_length = _template_id_length
# template_vcpu column
_template_vcpu_length = len(str(template['vcpu_count'])) + 1
if _template_vcpu_length > template_vcpu_length:
template_vcpu_length = _template_vcpu_length
# template_vram column
_template_vram_length = len(str(template['vram_mb'])) + 1
if _template_vram_length > template_vram_length:
template_vram_length = _template_vram_length
# template_serial column
_template_serial_length = len(str(template['serial'])) + 1
if _template_serial_length > template_serial_length:
template_serial_length = _template_serial_length
# template_vnc column
_template_vnc_length = len(str(template['vnc'])) + 1
if _template_vnc_length > template_vnc_length:
template_vnc_length = _template_vnc_length
# template_vnc_bind column
_template_vnc_bind_length = len(str(template['vnc_bind'])) + 1
if _template_vnc_bind_length > template_vnc_bind_length:
template_vnc_bind_length = _template_vnc_bind_length
# template_node_limit column
_template_node_limit_length = len(str(template['node_limit'])) + 1
if _template_node_limit_length > template_node_limit_length:
template_node_limit_length = _template_node_limit_length
# template_node_selector column
_template_node_selector_length = len(str(template['node_selector'])) + 1
if _template_node_selector_length > template_node_selector_length:
template_node_selector_length = _template_node_selector_length
# template_node_autostart column
_template_node_autostart_length = len(str(template['node_autostart'])) + 1
if _template_node_autostart_length > template_node_autostart_length:
template_node_autostart_length = _template_node_autostart_length
# Format the string (header)
2020-01-04 11:58:30 -05:00
template_list_output_header = '{bold}{template_name: <{template_name_length}} {template_id: <{template_id_length}} \
2020-01-02 11:18:46 -05:00
{template_vcpu: <{template_vcpu_length}} \
{template_vram: <{template_vram_length}} \
Consoles: {template_serial: <{template_serial_length}} \
{template_vnc: <{template_vnc_length}} \
{template_vnc_bind: <{template_vnc_bind_length}} \
2020-01-05 19:19:19 -05:00
Metadata: {template_node_limit: <{template_node_limit_length}} \
2020-01-02 11:18:46 -05:00
{template_node_selector: <{template_node_selector_length}} \
{template_node_autostart: <{template_node_autostart_length}}{end_bold}'.format(
template_name_length=template_name_length,
template_id_length=template_id_length,
template_vcpu_length=template_vcpu_length,
template_vram_length=template_vram_length,
template_serial_length=template_serial_length,
template_vnc_length=template_vnc_length,
template_vnc_bind_length=template_vnc_bind_length,
template_node_limit_length=template_node_limit_length,
template_node_selector_length=template_node_selector_length,
template_node_autostart_length=template_node_autostart_length,
bold=ansiprint.bold(),
end_bold=ansiprint.end(),
template_state_colour='',
end_colour='',
template_name='Name',
template_id='ID',
template_vcpu='vCPUs',
template_vram='vRAM [MB]',
template_serial='Serial',
template_vnc='VNC',
template_vnc_bind='VNC bind',
template_node_limit='Limit',
template_node_selector='Selector',
template_node_autostart='Autostart'
)
# Keep track of nets we found to be valid to cut down on duplicate API hits
valid_net_list = []
# Format the string (elements)
2020-01-04 14:06:36 -05:00
for template in sorted(template_data, key=lambda i: i.get('name', None)):
2020-01-02 11:18:46 -05:00
template_list_output.append(
'{bold}{template_name: <{template_name_length}} {template_id: <{template_id_length}} \
{template_vcpu: <{template_vcpu_length}} \
{template_vram: <{template_vram_length}} \
{template_serial: <{template_serial_length}} \
{template_vnc: <{template_vnc_length}} \
{template_vnc_bind: <{template_vnc_bind_length}} \
{template_node_limit: <{template_node_limit_length}} \
{template_node_selector: <{template_node_selector_length}} \
{template_node_autostart: <{template_node_autostart_length}}{end_bold}'.format(
template_name_length=template_name_length,
template_id_length=template_id_length,
template_vcpu_length=template_vcpu_length,
template_vram_length=template_vram_length,
template_serial_length=template_serial_length,
template_vnc_length=template_vnc_length,
template_vnc_bind_length=template_vnc_bind_length,
template_node_limit_length=template_node_limit_length,
template_node_selector_length=template_node_selector_length,
template_node_autostart_length=template_node_autostart_length,
bold='',
end_bold='',
template_name=str(template['name']),
template_id=str(template['id']),
template_vcpu=str(template['vcpu_count']),
template_vram=str(template['vram_mb']),
template_serial=str(template['serial']),
template_vnc=str(template['vnc']),
template_vnc_bind=str(template['vnc_bind']),
template_node_limit=str(template['node_limit']),
template_node_selector=str(template['node_selector']),
template_node_autostart=str(template['node_autostart'])
)
)
return '\n'.join([template_list_output_header] + template_list_output)
2020-01-02 11:18:46 -05:00
return True, ''
2020-01-04 13:04:01 -05:00
def format_list_template_network(template_template):
if isinstance(template_template, dict):
template_template = [ template_template ]
2020-01-02 11:18:46 -05:00
template_list_output = []
# Determine optimal column widths
template_name_length = 5
2020-01-04 14:06:36 -05:00
template_id_length = 3
2020-01-02 11:18:46 -05:00
template_mac_template_length = 13
template_networks_length = 10
2020-01-04 13:04:01 -05:00
for template in template_template:
2020-01-02 11:18:46 -05:00
# Join the networks elements into a single list of VNIs
network_list = list()
for network in template['networks']:
network_list.append(str(network['vni']))
template['networks_csv'] = ','.join(network_list)
2020-01-04 13:04:01 -05:00
for template in template_template:
2020-01-02 11:18:46 -05:00
# template_name column
_template_name_length = len(str(template['name'])) + 1
if _template_name_length > template_name_length:
template_name_length = _template_name_length
# template_id column
_template_id_length = len(str(template['id'])) + 1
if _template_id_length > template_id_length:
template_id_length = _template_id_length
# template_mac_template column
_template_mac_template_length = len(str(template['mac_template'])) + 1
if _template_mac_template_length > template_mac_template_length:
template_mac_template_length = _template_mac_template_length
# template_networks column
_template_networks_length = len(str(template['networks_csv'])) + 1
if _template_networks_length > template_networks_length:
template_networks_length = _template_networks_length
# Format the string (header)
2020-01-04 11:58:30 -05:00
template_list_output_header = '{bold}{template_name: <{template_name_length}} {template_id: <{template_id_length}} \
2020-01-02 11:18:46 -05:00
{template_mac_template: <{template_mac_template_length}} \
{template_networks: <{template_networks_length}}{end_bold}'.format(
template_name_length=template_name_length,
template_id_length=template_id_length,
template_mac_template_length=template_mac_template_length,
template_networks_length=template_networks_length,
bold=ansiprint.bold(),
end_bold=ansiprint.end(),
template_name='Name',
template_id='ID',
template_mac_template='MAC template',
template_networks='Network VNIs'
)
# Format the string (elements)
2020-01-04 13:04:01 -05:00
for template in sorted(template_template, key=lambda i: i.get('name', None)):
2020-01-02 11:18:46 -05:00
template_list_output.append(
'{bold}{template_name: <{template_name_length}} {template_id: <{template_id_length}} \
{template_mac_template: <{template_mac_template_length}} \
{template_networks: <{template_networks_length}}{end_bold}'.format(
template_name_length=template_name_length,
template_id_length=template_id_length,
template_mac_template_length=template_mac_template_length,
template_networks_length=template_networks_length,
bold='',
end_bold='',
template_name=str(template['name']),
template_id=str(template['id']),
template_mac_template=str(template['mac_template']),
template_networks=str(template['networks_csv'])
)
)
return '\n'.join([template_list_output_header] + template_list_output)
2020-01-02 11:18:46 -05:00
2020-01-04 13:04:01 -05:00
def format_list_template_storage(template_template):
if isinstance(template_template, dict):
template_template = [ template_template ]
2020-01-02 11:18:46 -05:00
2020-01-04 11:58:30 -05:00
template_list_output = []
2020-01-02 11:18:46 -05:00
2020-01-04 11:58:30 -05:00
# Determine optimal column widths
template_name_length = 5
2020-01-04 14:06:36 -05:00
template_id_length = 3
2020-01-04 11:58:30 -05:00
template_disk_id_length = 8
template_disk_pool_length = 8
2020-01-05 19:11:52 -05:00
template_disk_source_length = 14
2020-01-04 11:58:30 -05:00
template_disk_size_length = 10
template_disk_filesystem_length = 11
template_disk_fsargs_length = 10
template_disk_mountpoint_length = 10
2020-01-02 11:18:46 -05:00
2020-01-04 13:04:01 -05:00
for template in template_template:
2020-01-04 11:58:30 -05:00
# template_name column
_template_name_length = len(str(template['name'])) + 1
if _template_name_length > template_name_length:
template_name_length = _template_name_length
# template_id column
_template_id_length = len(str(template['id'])) + 1
if _template_id_length > template_id_length:
template_id_length = _template_id_length
2020-01-02 11:18:46 -05:00
2020-01-04 11:58:30 -05:00
for disk in template['disks']:
# template_disk_id column
_template_disk_id_length = len(str(disk['disk_id'])) + 1
if _template_disk_id_length > template_disk_id_length:
template_disk_id_length = _template_disk_id_length
# template_disk_pool column
_template_disk_pool_length = len(str(disk['pool'])) + 1
if _template_disk_pool_length > template_disk_pool_length:
template_disk_pool_length = _template_disk_pool_length
2020-01-05 19:11:52 -05:00
# template_disk_source column
_template_disk_source_length = len(str(disk['source_volume'])) + 1
if _template_disk_source_length > template_disk_source_length:
template_disk_source_length = _template_disk_source_length
2020-01-04 11:58:30 -05:00
# template_disk_size column
_template_disk_size_length = len(str(disk['disk_size_gb'])) + 1
if _template_disk_size_length > template_disk_size_length:
template_disk_size_length = _template_disk_size_length
# template_disk_filesystem column
_template_disk_filesystem_length = len(str(disk['filesystem'])) + 1
if _template_disk_filesystem_length > template_disk_filesystem_length:
template_disk_filesystem_length = _template_disk_filesystem_length
# template_disk_fsargs column
_template_disk_fsargs_length = len(str(disk['filesystem_args'])) + 1
if _template_disk_fsargs_length > template_disk_fsargs_length:
template_disk_fsargs_length = _template_disk_fsargs_length
# template_disk_mountpoint column
_template_disk_mountpoint_length = len(str(disk['mountpoint'])) + 1
if _template_disk_mountpoint_length > template_disk_mountpoint_length:
template_disk_mountpoint_length = _template_disk_mountpoint_length
2020-01-02 11:18:46 -05:00
# Format the string (header)
2020-01-04 11:58:30 -05:00
template_list_output_header = '{bold}{template_name: <{template_name_length}} {template_id: <{template_id_length}} \
{template_disk_id: <{template_disk_id_length}} \
{template_disk_pool: <{template_disk_pool_length}} \
2020-01-05 19:11:52 -05:00
{template_disk_source: <{template_disk_source_length}} \
2020-01-04 11:58:30 -05:00
{template_disk_size: <{template_disk_size_length}} \
{template_disk_filesystem: <{template_disk_filesystem_length}} \
{template_disk_fsargs: <{template_disk_fsargs_length}} \
{template_disk_mountpoint: <{template_disk_mountpoint_length}}{end_bold}'.format(
template_name_length=template_name_length,
template_id_length=template_id_length,
template_disk_id_length=template_disk_id_length,
template_disk_pool_length=template_disk_pool_length,
2020-01-05 19:11:52 -05:00
template_disk_source_length=template_disk_source_length,
2020-01-04 11:58:30 -05:00
template_disk_size_length=template_disk_size_length,
template_disk_filesystem_length=template_disk_filesystem_length,
template_disk_fsargs_length=template_disk_fsargs_length,
template_disk_mountpoint_length=template_disk_mountpoint_length,
2020-01-02 11:18:46 -05:00
bold=ansiprint.bold(),
end_bold=ansiprint.end(),
2020-01-04 11:58:30 -05:00
template_name='Name',
template_id='ID',
template_disk_id='Disk ID',
template_disk_pool='Pool',
2020-01-05 19:11:52 -05:00
template_disk_source='Source Volume',
2020-01-04 11:58:30 -05:00
template_disk_size='Size [GB]',
template_disk_filesystem='Filesystem',
template_disk_fsargs='Arguments',
template_disk_mountpoint='Mountpoint'
2020-01-02 11:18:46 -05:00
)
# Format the string (elements)
2020-01-04 13:04:01 -05:00
for template in sorted(template_template, key=lambda i: i.get('name', None)):
2020-01-04 11:58:30 -05:00
template_list_output.append(
'{bold}{template_name: <{template_name_length}} {template_id: <{template_id_length}}{end_bold}'.format(
template_name_length=template_name_length,
template_id_length=template_id_length,
2020-01-02 11:18:46 -05:00
bold='',
end_bold='',
2020-01-04 11:58:30 -05:00
template_name=str(template['name']),
template_id=str(template['id'])
2020-01-02 11:18:46 -05:00
)
)
2020-01-04 11:58:30 -05:00
for disk in sorted(template['disks'], key=lambda i: i.get('disk_id', None)):
template_list_output.append(
'{bold}{template_name: <{template_name_length}} {template_id: <{template_id_length}} \
{template_disk_id: <{template_disk_id_length}} \
{template_disk_pool: <{template_disk_pool_length}} \
2020-01-05 19:11:52 -05:00
{template_disk_source: <{template_disk_source_length}} \
2020-01-04 11:58:30 -05:00
{template_disk_size: <{template_disk_size_length}} \
{template_disk_filesystem: <{template_disk_filesystem_length}} \
{template_disk_fsargs: <{template_disk_fsargs_length}} \
{template_disk_mountpoint: <{template_disk_mountpoint_length}}{end_bold}'.format(
template_name_length=template_name_length,
template_id_length=template_id_length,
template_disk_id_length=template_disk_id_length,
template_disk_pool_length=template_disk_pool_length,
2020-01-05 19:11:52 -05:00
template_disk_source_length=template_disk_source_length,
2020-01-04 11:58:30 -05:00
template_disk_size_length=template_disk_size_length,
template_disk_filesystem_length=template_disk_filesystem_length,
template_disk_fsargs_length=template_disk_fsargs_length,
template_disk_mountpoint_length=template_disk_mountpoint_length,
bold='',
end_bold='',
template_name='',
template_id='',
template_disk_id=str(disk['disk_id']),
template_disk_pool=str(disk['pool']),
2020-01-05 19:11:52 -05:00
template_disk_source=str(disk['source_volume']),
2020-01-04 11:58:30 -05:00
template_disk_size=str(disk['disk_size_gb']),
template_disk_filesystem=str(disk['filesystem']),
template_disk_fsargs=str(disk['filesystem_args']),
template_disk_mountpoint=str(disk['mountpoint'])
)
)
2020-01-02 11:18:46 -05:00
return '\n'.join([template_list_output_header] + template_list_output)
2020-01-04 11:58:30 -05:00
2020-01-04 14:06:36 -05:00
def format_list_userdata(userdata_data, lines=None):
if isinstance(userdata_data, dict):
userdata_data = [ userdata_data ]
2020-01-04 13:04:01 -05:00
2020-01-04 14:06:36 -05:00
userdata_list_output = []
2020-01-04 13:04:01 -05:00
# Determine optimal column widths
2020-01-04 14:06:36 -05:00
userdata_name_length = 5
userdata_id_length = 3
userdata_useruserdata_length = 8
for userdata in userdata_data:
# userdata_name column
_userdata_name_length = len(str(userdata['name'])) + 1
if _userdata_name_length > userdata_name_length:
userdata_name_length = _userdata_name_length
# userdata_id column
_userdata_id_length = len(str(userdata['id'])) + 1
if _userdata_id_length > userdata_id_length:
userdata_id_length = _userdata_id_length
2020-01-04 13:04:01 -05:00
# Format the string (header)
2020-01-04 14:06:36 -05:00
userdata_list_output_header = '{bold}{userdata_name: <{userdata_name_length}} {userdata_id: <{userdata_id_length}} \
{userdata_data}{end_bold}'.format(
userdata_name_length=userdata_name_length,
userdata_id_length=userdata_id_length,
2020-01-04 13:04:01 -05:00
bold=ansiprint.bold(),
end_bold=ansiprint.end(),
2020-01-04 14:06:36 -05:00
userdata_name='Name',
userdata_id='ID',
userdata_data='Document'
2020-01-04 13:04:01 -05:00
)
# Format the string (elements)
2020-01-04 14:06:36 -05:00
for data in sorted(userdata_data, key=lambda i: i.get('name', None)):
2020-01-04 13:04:01 -05:00
line_count = 0
for line in data['userdata'].split('\n'):
if line_count < 1:
2020-01-04 14:06:36 -05:00
userdata_name = data['name']
userdata_id = data['id']
2020-01-04 13:04:01 -05:00
else:
2020-01-04 14:06:36 -05:00
userdata_name = ''
userdata_id = ''
2020-01-04 13:04:01 -05:00
line_count += 1
if lines and line_count > lines:
2020-01-04 14:06:36 -05:00
userdata_list_output.append(
'{bold}{userdata_name: <{userdata_name_length}} {userdata_id: <{userdata_id_length}} \
{userdata_data}{end_bold}'.format(
userdata_name_length=userdata_name_length,
userdata_id_length=userdata_id_length,
2020-01-04 13:04:01 -05:00
bold='',
end_bold='',
2020-01-04 14:06:36 -05:00
userdata_name=userdata_name,
userdata_id=userdata_id,
userdata_data='[...]'
2020-01-04 13:04:01 -05:00
)
)
break
2020-01-04 14:06:36 -05:00
userdata_list_output.append(
'{bold}{userdata_name: <{userdata_name_length}} {userdata_id: <{userdata_id_length}} \
{userdata_data}{end_bold}'.format(
userdata_name_length=userdata_name_length,
userdata_id_length=userdata_id_length,
2020-01-04 13:04:01 -05:00
bold='',
end_bold='',
2020-01-04 14:06:36 -05:00
userdata_name=userdata_name,
userdata_id=userdata_id,
userdata_data=str(line)
2020-01-04 13:04:01 -05:00
)
)
return '\n'.join([userdata_list_output_header] + userdata_list_output)
2020-01-04 13:04:01 -05:00
2020-01-04 14:06:36 -05:00
def format_list_script(script_data, lines=None):
if isinstance(script_data, dict):
script_data = [ script_data ]
2020-01-04 13:04:01 -05:00
2020-01-04 14:06:36 -05:00
script_list_output = []
2020-01-04 13:04:01 -05:00
# Determine optimal column widths
2020-01-04 14:06:36 -05:00
script_name_length = 5
script_id_length = 3
script_script_length = 8
for script in script_data:
# script_name column
_script_name_length = len(str(script['name'])) + 1
if _script_name_length > script_name_length:
script_name_length = _script_name_length
# script_id column
_script_id_length = len(str(script['id'])) + 1
if _script_id_length > script_id_length:
script_id_length = _script_id_length
2020-01-04 13:04:01 -05:00
# Format the string (header)
2020-01-04 14:06:36 -05:00
script_list_output_header = '{bold}{script_name: <{script_name_length}} {script_id: <{script_id_length}} \
{script_data}{end_bold}'.format(
script_name_length=script_name_length,
script_id_length=script_id_length,
2020-01-04 13:04:01 -05:00
bold=ansiprint.bold(),
end_bold=ansiprint.end(),
2020-01-04 14:06:36 -05:00
script_name='Name',
script_id='ID',
script_data='Script'
2020-01-04 13:04:01 -05:00
)
# Format the string (elements)
2020-01-04 14:06:36 -05:00
for script in sorted(script_data, key=lambda i: i.get('name', None)):
2020-01-04 13:04:01 -05:00
line_count = 0
2020-01-04 14:06:36 -05:00
for line in script['script'].split('\n'):
2020-01-04 13:04:01 -05:00
if line_count < 1:
2020-01-04 14:06:36 -05:00
script_name = script['name']
script_id = script['id']
2020-01-04 13:04:01 -05:00
else:
2020-01-04 14:06:36 -05:00
script_name = ''
script_id = ''
2020-01-04 13:04:01 -05:00
line_count += 1
if lines and line_count > lines:
2020-01-04 14:06:36 -05:00
script_list_output.append(
'{bold}{script_name: <{script_name_length}} {script_id: <{script_id_length}} \
{script_data}{end_bold}'.format(
script_name_length=script_name_length,
script_id_length=script_id_length,
2020-01-04 13:04:01 -05:00
bold='',
end_bold='',
2020-01-04 14:06:36 -05:00
script_name=script_name,
script_id=script_id,
script_data='[...]'
2020-01-04 13:04:01 -05:00
)
)
break
2020-01-04 14:06:36 -05:00
script_list_output.append(
'{bold}{script_name: <{script_name_length}} {script_id: <{script_id_length}} \
{script_data}{end_bold}'.format(
script_name_length=script_name_length,
script_id_length=script_id_length,
2020-01-04 13:04:01 -05:00
bold='',
end_bold='',
2020-01-04 14:06:36 -05:00
script_name=script_name,
script_id=script_id,
script_data=str(line)
2020-01-04 13:04:01 -05:00
)
)
return '\n'.join([script_list_output_header] + script_list_output)
2020-01-04 14:06:36 -05:00
def format_list_profile(profile_data):
if isinstance(profile_data, dict):
profile_data = [ profile_data ]
profile_list_output = []
# Determine optimal column widths
profile_name_length = 5
profile_id_length = 3
profile_system_template_length = 7
profile_network_template_length = 8
profile_storage_template_length = 8
profile_userdata_length = 9
profile_script_length = 7
for profile in profile_data:
# profile_name column
_profile_name_length = len(str(profile['name'])) + 1
if _profile_name_length > profile_name_length:
profile_name_length = _profile_name_length
# profile_id column
_profile_id_length = len(str(profile['id'])) + 1
if _profile_id_length > profile_id_length:
profile_id_length = _profile_id_length
# profile_system_template column
_profile_system_template_length = len(str(profile['system_template'])) + 1
if _profile_system_template_length > profile_system_template_length:
profile_system_template_length = _profile_system_template_length
# profile_network_template column
_profile_network_template_length = len(str(profile['network_template'])) + 1
if _profile_network_template_length > profile_network_template_length:
profile_network_template_length = _profile_network_template_length
# profile_storage_template column
_profile_storage_template_length = len(str(profile['storage_template'])) + 1
if _profile_storage_template_length > profile_storage_template_length:
profile_storage_template_length = _profile_storage_template_length
# profile_userdata column
_profile_userdata_length = len(str(profile['userdata'])) + 1
if _profile_userdata_length > profile_userdata_length:
profile_userdata_length = _profile_userdata_length
# profile_script column
_profile_script_length = len(str(profile['script'])) + 1
if _profile_script_length > profile_script_length:
profile_script_length = _profile_script_length
# Format the string (header)
profile_list_output_header = '{bold}{profile_name: <{profile_name_length}} {profile_id: <{profile_id_length}} \
Templates: {profile_system_template: <{profile_system_template_length}} \
{profile_network_template: <{profile_network_template_length}} \
{profile_storage_template: <{profile_storage_template_length}} \
Data: {profile_userdata: <{profile_userdata_length}} \
{profile_script: <{profile_script_length}} \
{profile_arguments}{end_bold}'.format(
profile_name_length=profile_name_length,
profile_id_length=profile_id_length,
profile_system_template_length=profile_system_template_length,
profile_network_template_length=profile_network_template_length,
profile_storage_template_length=profile_storage_template_length,
profile_userdata_length=profile_userdata_length,
profile_script_length=profile_script_length,
bold=ansiprint.bold(),
end_bold=ansiprint.end(),
profile_name='Name',
profile_id='ID',
profile_system_template='System',
profile_network_template='Network',
profile_storage_template='Storage',
profile_userdata='Userdata',
profile_script='Script',
profile_arguments='Script Arguments'
)
# Format the string (elements)
for profile in sorted(profile_data, key=lambda i: i.get('name', None)):
profile_list_output.append(
'{bold}{profile_name: <{profile_name_length}} {profile_id: <{profile_id_length}} \
{profile_system_template: <{profile_system_template_length}} \
{profile_network_template: <{profile_network_template_length}} \
{profile_storage_template: <{profile_storage_template_length}} \
{profile_userdata: <{profile_userdata_length}} \
{profile_script: <{profile_script_length}} \
{profile_arguments}{end_bold}'.format(
profile_name_length=profile_name_length,
profile_id_length=profile_id_length,
profile_system_template_length=profile_system_template_length,
profile_network_template_length=profile_network_template_length,
profile_storage_template_length=profile_storage_template_length,
profile_userdata_length=profile_userdata_length,
profile_script_length=profile_script_length,
bold='',
end_bold='',
profile_name=profile['name'],
profile_id=profile['id'],
profile_system_template=profile['system_template'],
profile_network_template=profile['network_template'],
profile_storage_template=profile['storage_template'],
profile_userdata=profile['userdata'],
profile_script=profile['script'],
profile_arguments=', '.join(profile['arguments'])
)
)
return '\n'.join([profile_list_output_header] + profile_list_output)