def _print_isystem_show(isystem):
fields = [
'name', 'system_type', 'system_mode', 'description', 'location',
'contact', 'timezone', 'software_version', 'uuid', 'created_at',
'updated_at', 'region_name', 'service_project_name'
]
if isystem.capabilities.get('region_config'):
fields.append('shared_services')
setattr(isystem, 'shared_services',
isystem.capabilities.get('shared_services'))
if isystem.capabilities.get('sdn_enabled') is not None:
fields.append('sdn_enabled')
setattr(isystem, 'sdn_enabled',
isystem.capabilities.get('sdn_enabled'))
if isystem.capabilities.get('https_enabled') is not None:
fields.append('https_enabled')
setattr(isystem, 'https_enabled',
isystem.capabilities.get('https_enabled'))
if isystem.distributed_cloud_role:
fields.append('distributed_cloud_role')
setattr(isystem, 'distributed_cloud_role',
isystem.distributed_cloud_role)
if isystem.capabilities.get('security_feature') is not None:
fields.append('security_feature')
setattr(isystem, 'security_feature',
isystem.capabilities.get('security_feature'))
data = dict(list([(f, getattr(isystem, f, '')) for f in fields]))
utils.print_dict(data)
def _print_itrapdest_show(itrapdest):
fields = [
'uuid', 'ip_address', 'community', 'port', 'type', 'transport',
'created_at'
]
data = dict([(f, getattr(itrapdest, f, '')) for f in fields])
utils.print_dict(data, wrap=72)
def _print_helm_chart(chart):
# We only want to print the fields that are in the response, that way
# we can reuse this function for printing the override update output
# where the system overrides aren't included.
ordereddata = OrderedDict(
sorted(chart.to_dict().items(), key=lambda t: t[0]))
utils.print_dict(ordereddata)
def do_kube_host_upgrade(cc, args):
"""Perform kubernetes upgrade for a host."""
if args.component == 'control-plane':
host = cc.ihost.kube_upgrade_control_plane(args.hostid, args.force)
elif args.component == 'kubelet':
host = cc.ihost.kube_upgrade_kubelet(args.hostid, args.force)
else:
raise exc.CommandError('Invalid component value: %s' % args.component)
# Get the kubernetes host upgrades
kube_host_upgrade_details = _get_kube_host_upgrade_details(cc)
host.target_version = \
kube_host_upgrade_details[host.id]['target_version']
host.control_plane_version = \
kube_host_upgrade_details[host.id]['control_plane_version']
host.kubelet_version = \
kube_host_upgrade_details[host.id]['kubelet_version']
host.status = \
kube_host_upgrade_details[host.id]['status']
fields = [
'id', 'hostname', 'personality', 'target_version',
'control_plane_version', 'kubelet_version', 'status'
]
data_list = [(f, getattr(host, f, '')) for f in fields]
data = dict(data_list)
ordereddata = OrderedDict(sorted(data.items(), key=lambda t: t[0]))
utils.print_dict(ordereddata, wrap=72)
def _print_ihost_show(ihost):
fields = [
'id', 'uuid', 'personality', 'hostname', 'invprovision',
'administrative', 'operational', 'availability', 'task', 'action',
'mgmt_mac', 'mgmt_ip', 'serialid', 'capabilities', 'bm_type',
'bm_username', 'bm_ip', 'config_applied', 'config_target',
'config_status', 'location', 'uptime', 'reserved', 'created_at',
'updated_at', 'boot_device', 'rootfs_device', 'install_output',
'console', 'tboot', 'vim_progress_status', 'software_load',
'install_state', 'install_state_info', 'inv_state'
]
optional_fields = ['vsc_controllers', 'ttys_dcd']
if ihost.subfunctions != ihost.personality:
fields.append('subfunctions')
if 'controller' in ihost.subfunctions:
fields.append('subfunction_oper')
fields.append('subfunction_avail')
if ihost.peers:
fields.append('peers')
# Do not display the trailing '+' which indicates the audit iterations
if ihost.install_state_info:
ihost.install_state_info = ihost.install_state_info.rstrip('+')
if ihost.install_state:
ihost.install_state = ihost.install_state.rstrip('+')
data_list = [(f, getattr(ihost, f, '')) for f in fields]
data_list += [(f, getattr(ihost, f, '')) for f in optional_fields
if hasattr(ihost, f)]
data = dict(data_list)
ordereddata = OrderedDict(sorted(data.items(), key=lambda t: t[0]))
utils.print_dict(ordereddata, wrap=72)
def _print_sm_service_node_show(node):
fields = [
'id', 'name', 'administrative_state', 'operational_state',
'availability_status', 'ready_state'
]
data = dict([(f, getattr(node, f, '')) for f in fields])
utils.print_dict(data, wrap=72)
def _display_fault(fault):
fields = ['uuid', 'alarm_id', 'alarm_state', 'entity_type_id', 'entity_instance_id',
'timestamp', 'severity', 'reason_text', 'alarm_type',
'probable_cause', 'proposed_repair_action', 'service_affecting',
'suppression', 'suppression_status', 'mgmt_affecting']
data = dict([(f, getattr(fault, f, '')) for f in fields])
cgts_utils.print_dict(data, wrap=72)
def _display_event(log):
fields = [
'uuid', 'event_log_id', 'state', 'entity_type_id',
'entity_instance_id', 'timestamp', 'severity', 'reason_text',
'event_log_type', 'probable_cause', 'proposed_repair_action',
'service_affecting', 'suppression', 'suppression_status'
]
data = dict([(f, getattr(log, f, '')) for f in fields])
utils.print_dict(data, wrap=72)
def do_servicegroup_create(cc, args):
"""Create a new servicegroup."""
field_list = ['servicename', 'state']
fields = dict((k, v) for (k, v) in vars(args).items()
if k in field_list and not (v is None))
# fields = utils.args_array_to_dict(fields, 'activity')
iservicegroup = cc.iservicegroup.create(**fields)
field_list.append('uuid')
data = dict([(f, getattr(iservicegroup, f, '')) for f in field_list])
utils.print_dict(data, wrap=72)
def do_snmp_comm_add(cc, args):
"""Add a new SNMP community."""
field_list = ['community', 'view', 'access']
fields = dict((k, v) for (k, v) in vars(args).items()
if k in field_list and not (v is None))
# fields = utils.args_array_to_dict(fields, 'activity')
# fields = utils.args_array_to_dict(fields, 'reason')
icommunity = cc.icommunity.create(**fields)
field_list.append('uuid')
data = dict([(f, getattr(icommunity, f, '')) for f in field_list])
utils.print_dict(data, wrap=72)
def do_snmp_trapdest_add(cc, args):
"""Create a new SNMP trap destination."""
field_list = ['ip_address', 'community', 'port', 'type', 'transport']
fields = dict((k, v) for (k, v) in vars(args).items()
if k in field_list and not (v is None))
# fields = utils.args_array_to_dict(fields, 'activity')
# fields = utils.args_array_to_dict(fields, 'reason')
itrapdest = cc.itrapdest.create(**fields)
field_list.append('uuid')
data = dict([(f, getattr(itrapdest, f, '')) for f in field_list])
utils.print_dict(data, wrap=72)
def _print_isensorgroup_show(isensorgroup):
fields = [
'uuid', 'sensorgroupname', 'path', 'sensortype', 'datatype',
'audit_interval_group', 'algorithm', 'state', 'possible_states',
'actions_critical_choices', 'actions_major_choices',
'actions_minor_choices', 'actions_minor_group', 'actions_major_group',
'actions_critical_group', 'record_ttl', 'sensors', 'suppress',
'created_at', 'updated_at'
]
fields_analog = [
'unit_base_group', 'unit_modifier_group', 'unit_rate_group',
't_minor_lower_group', 't_minor_upper_group', 't_major_lower_group',
't_major_upper_group', 't_critical_lower_group',
't_critical_upper_group'
]
labels = [
'uuid', 'sensorgroupname', 'path', 'sensortype', 'datatype',
'audit_interval_group', 'algorithm', 'state', 'possible_states',
'actions_critical_choices', 'actions_major_choices',
'actions_minor_choices', 'actions_minor_group', 'actions_major_group',
'actions_critical_group', 'record_ttl', 'sensors', 'suppress',
'created_at', 'updated_at'
]
labels_analog = [
'unit_base_group', 'unit_modifier_group', 'unit_rate_group',
't_minor_lower_group', 't_minor_upper_group', 't_major_lower_group',
't_major_upper_group', 't_critical_lower_group',
't_critical_upper_group'
]
datatype = getattr(isensorgroup, 'datatype') or ""
if datatype == 'analog':
fields.extend(fields_analog)
labels.extend(labels_analog)
data = dict([(f, getattr(isensorgroup, f, '')) for f in fields])
ordereddata = OrderedDict(sorted(data.items(), key=lambda t: t[0]))
utils.print_dict(ordereddata, wrap=72)
def test_prettytable(self):
class Struct:
def __init__(self, **entries):
self.__dict__.update(entries)
# test that the prettytable output is wellformatted (left-aligned)
saved_stdout = sys.stdout
try:
sys.stdout = output_dict = StringIO()
utils.print_dict({'K': 'k', 'Key': 'Value'})
finally:
sys.stdout = saved_stdout
self.assertEqual(
output_dict.getvalue(), '''\
+----------+-------+
| Property | Value |
+----------+-------+
| K | k |
| Key | Value |
+----------+-------+
''')
def _print_iextoam_show(iextoam, cc):
fields = [
'uuid', 'oam_subnet', 'oam_gateway_ip', 'oam_floating_ip', 'oam_c0_ip',
'oam_c1_ip', 'isystem_uuid', 'created_at', 'updated_at'
]
fields_region = ['oam_start_ip', 'oam_end_ip']
region_config = getattr(iextoam, 'region_config') or False
if region_config:
fields.extend(fields_region)
# labels.extend(labels_region)
data = dict([(f, getattr(iextoam, f, '')) for f in fields])
# Rename the floating IP field and remove the
# fields that are not applicable for a simplex system
if cc.isystem.list()[0].system_mode == constants.SYSTEM_MODE_SIMPLEX:
data['oam_ip'] = data.pop('oam_floating_ip')
del data['oam_c0_ip']
del data['oam_c1_ip']
ordereddata = OrderedDict(sorted(data.items(), key=lambda t: t[0]))
utils.print_dict(ordereddata, wrap=72)
def _print_isensor_show(isensor):
fields = [
'sensorname', 'path', 'sensortype', 'datatype', 'status', 'state',
'state_requested', 'audit_interval', 'sensor_action_requested',
'actions_minor', 'actions_major', 'actions_critical', 'suppress',
'algorithm', 'capabilities', 'created_at', 'updated_at', 'uuid'
]
fields_analog = [
'unit_base', 'unit_modifier', 'unit_rate', 't_minor_lower',
't_minor_upper', 't_major_lower', 't_major_upper', 't_critical_lower',
't_critical_upper'
]
labels = [
'sensorname', 'path', 'sensortype', 'datatype', 'status', 'state',
'state_requested', 'audit_interval', 'sensor_action_requested',
'actions_minor', 'actions_major', 'actions_critical', 'suppress',
'algorithm', 'capabilities', 'created_at', 'updated_at', 'uuid'
]
labels_analog = [
'unit_base', 'unit_modifier', 'unit_rate', 't_minor_lower',
't_minor_upper', 't_major_lower', 't_major_upper', 't_critical_lower',
't_critical_upper'
]
datatype = getattr(isensor, 'datatype') or ""
if datatype == 'analog':
fields.extend(fields_analog)
labels.extend(labels_analog)
data = dict([(f, getattr(isensor, f, '')) for f in fields])
ordereddata = OrderedDict(sorted(data.items(), key=lambda t: t[0]))
# utils.print_tuple_list(ordereddata, labels)
utils.print_dict(ordereddata, wrap=72)
def _display_event_suppression(log):
fields = ['uuid', 'alarm_id', 'description', 'suppression_status']
data = dict([(f, getattr(log, f, '')) for f in fields])
utils.print_dict(data, wrap=72)
def _print_iservicegroup_show(iservicegroup):
fields = ['id', 'servicename', 'state']
data = dict([(f, getattr(iservicegroup, f, '')) for f in fields])
utils.print_dict(data, wrap=72)
def _print_service_show(service):
fields = ['id', 'service_name', 'hostname', 'state']
data = dict([(f, getattr(service, f, '')) for f in fields])
data['hostname'] = getattr(service, 'node_name', '')
utils.print_dict(data, wrap=72)
def _print_iservice_show(iservice):
fields = ['id', 'servicename', 'hostname', 'state', 'activity', 'reason']
data = dict([(f, getattr(iservice, f, '')) for f in fields])
utils.print_dict(data, wrap=72)
def _print_kube_version_show(kube_version):
ordereddata = OrderedDict(sorted(kube_version.to_dict().items(),
key=lambda t: t[0]))
utils.print_dict(ordereddata, wrap=72)
def _print_application_show(app):
ordereddata = OrderedDict(sorted(app.to_dict().items(),
key=lambda t: t[0]))
utils.print_dict(ordereddata, wrap=72)
def _print_icommunity_show(icommunity):
fields = ['uuid', 'community', 'view', 'access', 'created_at']
data = dict([(f, getattr(icommunity, f, '')) for f in fields])
utils.print_dict(data, wrap=72)
def _print_kube_cluster_show(kube_cluster):
ordereddata = OrderedDict(
sorted(kube_cluster.to_dict().items(), key=lambda t: t[0]))
utils.print_dict(ordereddata, wrap=72)
