def do_host_lldp_agent_list(cc, args):
"""List host lldp agents."""
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
agent_list = []
agents = cc.lldp_agent.list(ihost.uuid)
field_labels = [
'uuid', 'local_port', 'status', 'chassis_id', 'port_id', 'system_name',
'system_description'
]
fields = [
'uuid', 'port_name', 'status', 'chassis_id', 'port_identifier',
'system_name', 'system_description'
]
formatters = {
'system_name': _lldp_system_name_formatter,
'system_description': _lldp_system_description_formatter,
'port_description': _lldp_port_description_formatter
}
utils.print_list(agents,
fields,
field_labels,
sortby=1,
formatters=formatters)
def do_datanetwork_list(cc, args):
"""List datanetworks."""
labels = ['uuid', 'name', 'network_type', 'mtu']
fields = ['uuid', 'name', 'network_type', 'mtu']
datanetworks = cc.datanetwork.list()
utils.print_list(datanetworks, fields, labels, sortby=1)
def do_load_list(cc, args):
"""List all loads."""
loads = cc.load.list()
field_labels = ['id', 'state', 'software_version']
fields = ['id', 'state', 'software_version']
utils.print_list(loads, fields, field_labels, sortby=0)
def do_helm_override_list(cc, args):
"""List system helm charts."""
app = app_utils._find_app(cc, args.app)
charts = cc.helm.list_charts(app.name)
utils.print_list(charts, ['name', 'namespaces'],
['chart name', 'overrides namespaces'],
sortby=0)
def do_alarm_list(cc, args={}):
'''List all active alarms.'''
includeUUID = args.uuid
include_suppress = False
if args.include_suppress:
include_suppress = True
include_mgmt_affecting = False
if args.mgmt_affecting:
include_mgmt_affecting = True
faults = cc.ialarm.list(q=options.cli_to_array(args.query), include_suppress=include_suppress)
for f in faults:
cgts_utils.normalize_field_data(f, ['entity_type_id', 'entity_instance_id',
'reason_text', 'proposed_repair_action'])
# omit action initially to keep output width sane
# (can switch over to vertical formatting when available from CLIFF)
def hightlightAlarmId(alarm):
suppressed = hasattr(alarm,"suppression_status") and alarm.suppression_status=="suppressed"
if suppressed:
value = "S({})".format(alarm.alarm_id)
else:
value = alarm.alarm_id
return value
field_labels = ['Alarm ID', 'Reason Text', 'Entity ID', 'Severity', 'Time Stamp']
fields = ['alarm_id', 'reason_text', 'entity_instance_id', 'severity', 'timestamp']
# for best results, ensure width ratios add up to 1 (=100%)
formatterSpec = {
"alarm_id" : {"formatter" : hightlightAlarmId, "wrapperFormatter": .08},
"reason_text" : .54,
"entity_instance_id" : .15,
"severity" : .10,
"timestamp" : .10,
}
if includeUUID:
field_labels.insert(0, 'UUID')
fields.insert(0, 'uuid')
# for best results, ensure width ratios add up to 1 (=100%)
formatterSpec['uuid'] = wrapping_formatters.UUID_MIN_LENGTH
formatterSpec['reason_text'] -= .05
formatterSpec['entity_instance_id'] -= .02
if include_mgmt_affecting:
field_labels.insert(4, 'Management Affecting')
fields.insert(4, 'mgmt_affecting')
# for best results, ensure width ratios add up to 1 (=100%)
formatterSpec['mgmt_affecting'] = .08
formatterSpec['reason_text'] -= .05
formatterSpec['severity'] -= .03
formatters = wrapping_formatters.build_wrapping_formatters(faults, fields, field_labels, formatterSpec)
cgts_utils.print_list(faults, fields, field_labels, formatters=formatters,
sortby=fields.index('timestamp'), reversesort=True)
def do_host_lvg_list(cc, args):
"""List Local Volume Groups."""
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
ilvgs = cc.ilvg.list(ihost.uuid)
# Adjust state to be more user friendly
for lvg in ilvgs:
lvg.vg_state = _adjust_state_data(lvg.lvm_vg_name, lvg.vg_state)
# convert size from Byte to GiB
lvg.lvm_vg_avail_size = \
utils.size_unit_conversion(lvg.lvm_vg_avail_size, 3)
# convert size from Byte to GiB
lvg.lvm_vg_size = \
utils.size_unit_conversion(lvg.lvm_vg_size, 3)
field_labels = [
'UUID', 'LVG Name', 'State', 'Access', 'Total Size (GiB)',
'Avail Size (GiB)', 'Current PVs', 'Current LVs'
]
fields = [
'uuid', 'lvm_vg_name', 'vg_state', 'lvm_vg_access', 'lvm_vg_size',
'lvm_vg_avail_size', 'lvm_cur_pv', 'lvm_cur_lv'
]
utils.print_list(ilvgs, fields, field_labels, sortby=0)
def _print_controller_config_show(ihosts):
fields = [
'id', 'hostname', 'personality', 'administrative', 'operational',
'availability', 'config_status'
]
field_labels = list(fields)
utils.print_list(ihosts, fields, field_labels, sortby=0)
def do_kube_host_upgrade_list(cc, args):
"""List kubernetes upgrade info for hosts."""
# Get the list of hosts
ihosts = cc.ihost.list()
# Get the kubernetes host upgrades
kube_host_upgrade_details = _get_kube_host_upgrade_details(cc)
for host in ihosts:
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']
field_labels = [
'id', 'hostname', 'personality', 'target_version',
'control_plane_version', 'kubelet_version', 'status'
]
fields = [
'id', 'hostname', 'personality', 'target_version',
'control_plane_version', 'kubelet_version', 'status'
]
utils.print_list(ihosts, fields, field_labels, sortby=0)
def do_host_apply_ifprofile(cc, args):
"""Apply an interface profile to a host."""
# Assemble patch
profile = iprofile_utils._find_iprofile(cc, args.profilenameoruuid)
patch = _prepare_profile_patch(profile.uuid)
# Send patch
host = ihost_utils._find_ihost(cc, args.hostnameorid)
try:
host = cc.ihost.update(host.id, patch)
except exc.HTTPNotFound:
raise exc.CommandError('host not found: %s' % args.hostnameorid)
# Echo list of new host interfaces
iinterfaces = cc.iinterface.list(host.uuid)
for i in iinterfaces:
iinterface_utils._get_ports(cc, host, i)
field_labels = [
'uuid', 'name', 'network type', 'type', 'vlan id', 'ports', 'uses',
'used by', 'mtu', 'provider networks'
]
fields = [
'uuid', 'ifname', 'networktype', 'iftype', 'vlan_id', 'ports', 'uses',
'used_by', 'imtu', 'providernetworks'
]
utils.print_list(iinterfaces, fields, field_labels, sortby=0)
def do_host_memory_list(cc, args):
"""List memory nodes."""
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
inodes = cc.inode.list(ihost.uuid)
imemorys = cc.imemory.list(ihost.uuid)
for m in imemorys:
for n in inodes:
if m.inode_uuid == n.uuid:
m.numa_node = n.numa_node
break
fields = [
'numa_node', 'memtotal_mib', 'platform_reserved_mib', 'memavail_mib',
'hugepages_configured', 'vswitch_hugepages_size_mib',
'vswitch_hugepages_nr', 'vswitch_hugepages_avail',
'vswitch_hugepages_reqd', 'vm_hugepages_nr_4K', 'vm_hugepages_nr_2M',
'vm_hugepages_avail_2M', 'vm_hugepages_nr_2M_pending',
'vm_hugepages_nr_1G', 'vm_hugepages_avail_1G',
'vm_hugepages_nr_1G_pending', 'vm_hugepages_use_1G'
]
field_labels = [
'processor', 'mem_total(MiB)', 'mem_platform(MiB)', 'mem_avail(MiB)',
'hugepages(hp)_configured', 'vs_hp_size(MiB)', 'vs_hp_total',
'vs_hp_avail', 'vs_hp_reqd', 'vm_total_4K', 'vm_hp_total_2M',
'vm_hp_avail_2M', 'vm_hp_pending_2M', 'vm_hp_total_1G',
'vm_hp_avail_1G', 'vm_hp_pending_1G', 'vm_hp_use_1G'
]
utils.print_list(imemorys, fields, field_labels, sortby=1)
def do_host_apply_cpuprofile(cc, args):
"""Apply a cpu profile to a host."""
# Assemble patch
profile = iprofile_utils._find_iprofile(cc, args.profilenameoruuid)
patch = _prepare_profile_patch(profile.uuid)
# Send patch
host = ihost_utils._find_ihost(cc, args.hostnameorid)
try:
host = cc.ihost.update(host.id, patch)
except exc.HTTPNotFound:
raise exc.CommandError('host not found: %s' % args.hostnameorid)
# Echo list of new host cpus
icpus = cc.icpu.list(host.uuid)
field_labels = [
'uuid', 'log_core', 'processor', 'phy_core', 'thread',
'processor_model', 'assigned_function'
]
fields = [
'uuid', 'cpu', 'numa_node', 'core', 'thread', 'cpu_model',
'allocated_function'
]
utils.print_list(icpus,
fields,
field_labels,
sortby=1,
formatters={
'allocated_function':
icpu_utils._cpu_function_tuple_formatter
})
def do_host_port_list(cc, args):
"""List host ports."""
from cgtsclient.common import wrapping_formatters
terminal_width = utils.get_terminal_size()[0]
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
ports = cc.port.list(ihost.uuid)
field_labels = ['uuid', 'name', 'type', 'pci address', 'device',
'processor', 'accelerated', 'device type']
fields = ['uuid', 'name', 'type', 'pciaddr', 'dev_id', 'numa_node',
'dpdksupport', 'pdevice']
format_spec = wrapping_formatters.build_best_guess_formatters_using_average_widths(ports, fields, field_labels,
no_wrap_fields=['pciaddr'])
# best-guess formatter does not make a good guess for
# proper width of pdevice until terminal is > 155
# We override that width here.
pdevice_width = None
if terminal_width <= 130:
pdevice_width = .1
elif 131 >= terminal_width <= 150:
pdevice_width = .13
elif 151 >= terminal_width <= 155:
pdevice_width = .14
if pdevice_width and format_spec["pdevice"] > pdevice_width:
format_spec["pdevice"] = pdevice_width
formatters = wrapping_formatters.build_wrapping_formatters(ports, fields, field_labels, format_spec)
utils.print_list(ports, fields, field_labels, formatters=formatters, sortby=1)
def do_host_apply_memprofile(cc, args):
"""Apply a memory profile to a host."""
# Assemble patch
profile = iprofile_utils._find_iprofile(cc, args.profilenameoruuid)
patch = _prepare_profile_patch(profile.uuid)
# Send patch
host = ihost_utils._find_ihost(cc, args.hostnameorid)
try:
host = cc.ihost.update(host.id, patch)
except exc.HTTPNotFound:
raise exc.CommandError('host not found: %s' % args.hostnameorid)
# Echo list of new host memory
imemory = cc.imemory.list(host.uuid)
field_labels = [
'uuid', 'vm_hugepages_1G', 'vm_hugepages_2M',
'vm_hugepages_2M_pending', 'vm_hugepages_1G_pending',
'vswitch_hugepages_nr', 'vswitch_hugepages_size_reqd',
'vswitch_hugepages_size_mib'
]
fields = [
'uuid', 'vm_hugepages_nr_1G', 'vm_hugepages_nr_2M',
'vm_hugepages_nr_2M_pending', 'vm_hugepages_nr_1G_pending',
'vswitch_hugepages_nr', 'vswitch_hugepages_reqd',
'vswitch_hugepages_size_mib'
]
utils.print_list(imemory, fields, field_labels, sortby=0)
def _print_controllerfs_list(cc):
controller_fs_list = cc.controller_fs.list()
field_labels = ['UUID', 'FS Name', 'Size in GiB', 'Logical Volume',
'Replicated', 'State']
fields = ['uuid', 'name', 'size', 'logical_volume', 'replicated', 'state']
utils.print_list(controller_fs_list, fields, field_labels, sortby=1)
def do_cpuprofile_list(cc, args):
"""List cpu profiles."""
profiles = cc.iprofile.list_cpu_profiles()
for profile in profiles:
icpu_utils.restructure_host_cpu_data(profile)
profile.platform_cores = get_core_list_str(
profile, icpu_utils.PLATFORM_CPU_TYPE)
profile.vswitch_cores = get_core_list_str(profile,
icpu_utils.VSWITCH_CPU_TYPE)
profile.shared_cores = get_core_list_str(profile,
icpu_utils.SHARED_CPU_TYPE)
profile.application_cores = get_core_list_str(
profile, icpu_utils.APPLICATION_CPU_TYPE)
profile.isolated_cores = get_core_list_str(
profile, icpu_utils.ISOLATED_CPU_TYPE)
field_labels = [
'uuid', 'name', 'processors', 'phy cores per proc', 'hyperthreading',
'platform cores', 'vswitch cores', 'shared cores', 'application cores',
'application-isolated cores'
]
fields = [
'uuid', 'profilename', 'sockets', 'physical_cores', 'hyperthreading',
'platform_cores', 'vswitch_cores', 'shared_cores', 'application_cores',
'isolated_cores'
]
utils.print_list(profiles, fields, field_labels, sortby=0)
def do_host_if_list(cc, args):
"""List interfaces."""
iinterfaces = cc.iinterface.list(args.hostnameorid)
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
for i in iinterfaces[:]:
iinterface_utils._get_ports(cc, ihost, i)
if not args.all:
if i.ifclass is None and i.used_by == []:
iinterfaces.remove(i)
attr_str = "MTU=%s" % i.imtu
if i.iftype == 'ae':
attr_str = "%s,AE_MODE=%s" % (attr_str, i.aemode)
if i.aemode in ['balanced', '802.3ad']:
attr_str = "%s,AE_XMIT_POLICY=%s" % (
attr_str, i.txhashpolicy)
if i.ifclass and i.ifclass == 'data':
if False in i.dpdksupport:
attr_str = "%s,accelerated=False" % attr_str
else:
attr_str = "%s,accelerated=True" % attr_str
setattr(i, 'attrs', attr_str)
field_labels = ['uuid', 'name', 'class', 'type', 'vlan id', 'ports',
'uses i/f', 'used by i/f', 'attributes']
fields = ['uuid', 'ifname', 'ifclass', 'iftype', 'vlan_id', 'ports',
'uses', 'used_by', 'attrs']
utils.print_list(
iinterfaces, fields, field_labels, sortby=0, no_wrap_fields=['ports'])
def donot_config_ptp_list(cc, args):
"""List ptps."""
ptps = cc.ptp.list()
field_labels = ['uuid', 'mode', 'transport', 'mechanism']
fields = ['uuid', 'mode', 'transport', 'mechanism']
utils.print_list(ptps, fields, field_labels, sortby=1)
def do_host_list(cc, args):
"""List hosts."""
ihosts = cc.ihost.list()
field_labels = ['id', 'hostname', 'personality',
'administrative', 'operational', 'availability']
fields = ['id', 'hostname', 'personality',
'administrative', 'operational', 'availability']
utils.print_list(ihosts, fields, field_labels, sortby=0)
def donot_dns_list(cc, args):
"""List dnss."""
idnss = cc.idns.list()
field_labels = ['uuid', 'nameservers']
fields = ['uuid', 'nameservers']
utils.print_list(idnss, fields, field_labels, sortby=1)
def do_snmp_trapdest_list(cc, args):
"""List SNMP trap destinations."""
itrapdest = cc.itrapdest.list()
field_labels = [
'IP Address', 'SNMP Community', 'Port', 'Type', 'Transport'
]
fields = ['ip_address', 'community', 'port', 'type', 'transport']
utils.print_list(itrapdest, fields, field_labels, sortby=1)
def do_host_addr_list(cc, args):
"""List IP addresses on host."""
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
addresses = cc.address.list_by_host(ihost.uuid)
field_labels = ['uuid', 'ifname', 'address', 'prefix']
fields = ['uuid', 'ifname', 'address', 'prefix']
utils.print_list(addresses, fields, field_labels, sortby=1)
def do_host_upgrade_list(cc, args):
"""List software upgrade info for hosts."""
ihosts = cc.ihost.list()
field_labels = [
'id', 'hostname', 'personality', 'running_release', 'target_release'
]
fields = ['id', 'hostname', 'personality', 'software_load', 'target_load']
utils.print_list(ihosts, fields, field_labels, sortby=0)
def donot_config_ntp_list(cc, args):
"""List ntps."""
intps = cc.intp.list()
field_labels = ['uuid', 'ntpservers']
fields = ['uuid', 'ntpservers']
utils.print_list(intps, fields, field_labels, sortby=1)
def do_application_list(cc, args):
"""List all containerized applications"""
apps = cc.app.list()
labels = [
'application', 'manifest name', 'manifest file', 'status', 'progress'
]
fields = ['name', 'manifest_name', 'manifest_file', 'status', 'progress']
utils.print_list(apps, fields, labels, sortby=0)
def do_host_route_list(cc, args):
"""List IP routes on host."""
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
routes = cc.route.list_by_host(ihost.uuid)
field_labels = ['uuid', 'ifname', 'network', 'prefix', 'gateway', 'metric']
fields = ['uuid', 'ifname', 'network', 'prefix', 'gateway', 'metric']
utils.print_list(routes, fields, field_labels, sortby=1)
def do_addrpool_list(cc, args):
"""List IP address pools."""
address_pools = cc.address_pool.list()
fields = ['uuid', 'name', 'network', 'prefix', 'order', 'ranges',
'floating_address', 'controller0_address', 'controller1_address',
'gateway_address']
utils.print_list(address_pools, fields, fields, sortby=1,
formatters={'ranges': _address_range_pool_formatter})
def do_host_node_list(cc, args):
"""List nodes."""
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
inodes = cc.inode.list(ihost.uuid)
field_labels = ['uuid', 'numa_node', 'capabilities']
fields = ['uuid', 'numa_node', 'capabilities']
utils.print_list(inodes, fields, field_labels, sortby=0)
def do_host_label_list(cc, args):
"""List kubernetes labels assigned to a host."""
ihost = ihost_utils._find_ihost(cc, args.hostnameorid)
host_label = cc.label.list(ihost.uuid)
for i in host_label[:]:
setattr(i, 'hostname', ihost.hostname)
field_labels = ['hostname', 'label key', 'label value']
fields = ['hostname', 'label_key', 'label_value']
utils.print_list(host_label, fields, field_labels, sortby=1)
def donot_config_remotelogging_list(cc, args):
"""List remoteloggings."""
remoteloggings = cc.remotelogging.list()
field_labels = [
'IP Address', 'Enabled', 'Transport', 'Port', 'TLS key file'
]
fields = ['ip_address', 'enabled', 'transport', 'port', 'key_file']
utils.print_list(remoteloggings, fields, field_labels, sortby=1)
def do_storage_tier_list(cc, args):
"""List storage tiers."""
cluster = cluster_utils._find_cluster(cc, args.cluster_or_uuid)
tiers = cc.storage_tier.list(cluster.uuid)
fields = ['uuid', 'name', 'status', 'backend_uuid']
labels = ['uuid', 'name', 'status', 'backend_using']
utils.print_list(tiers, fields, labels, sortby=1)
