def get_info(self):
inv_info = self._smutclient.get_host_info()
host_info = {}
with zvmutils.expect_invalid_resp_data(inv_info):
host_info['zcc_userid'] = inv_info['zcc_userid']
host_info['zvm_host'] = inv_info['zvm_host']
host_info['vcpus'] = int(inv_info['lpar_cpu_total'])
host_info['vcpus_used'] = int(inv_info['lpar_cpu_used'])
host_info['cpu_info'] = {}
host_info['cpu_info'] = {'architecture': const.ARCHITECTURE,
'cec_model': inv_info['cec_model'], }
mem_mb = zvmutils.convert_to_mb(inv_info['lpar_memory_total'])
host_info['memory_mb'] = mem_mb
mem_mb_used = zvmutils.convert_to_mb(inv_info['lpar_memory_used'])
host_info['memory_mb_used'] = mem_mb_used
host_info['hypervisor_type'] = const.HYPERVISOR_TYPE
verl = inv_info['hypervisor_os'].split()[1].split('.')
version = int(''.join(verl))
host_info['hypervisor_version'] = version
host_info['hypervisor_hostname'] = inv_info['hypervisor_name']
host_info['ipl_time'] = inv_info['ipl_time']
diskpool_name = CONF.zvm.disk_pool.split(':')[1]
dp_info = self.diskpool_get_info(diskpool_name)
host_info.update(dp_info)
return host_info
def diskpool_get_info(self, pool):
dp_info = self._smutclient.get_diskpool_info(pool)
with zvmutils.expect_invalid_resp_data(dp_info):
for k in list(dp_info.keys()):
s = dp_info[k].strip().upper()
if s.endswith('G'):
sl = s[:-1].split('.')
n1, n2 = int(sl[0]), int(sl[1])
if n2 >= 5:
n1 += 1
dp_info[k] = n1
elif s.endswith('M'):
n_mb = int(s[:-3])
n_gb, n_ad = n_mb // 1024, n_mb % 1024
if n_ad >= 512:
n_gb += 1
dp_info[k] = n_gb
else:
exp = "ending with a 'G' or 'M'"
errmsg = ("Invalid diskpool size format: %(invalid)s; "
"Expected: %(exp)s") % {'invalid': s, 'exp': exp}
LOG.error(errmsg)
raise exception.SDKInternalError(msg=errmsg)
return dp_info
def get_volume_info(self, volume_name):
update_needed = False
with zvmutils.expect_invalid_resp_data():
if self._volume_infos is not None:
volume_info = self._volume_infos.get(volume_name)
if not volume_info:
update_needed = True
else:
return volume_info
else:
update_needed = True
if update_needed:
# results of get_volume_info() is the format like:
# {'IAS100': { 'volume_type': '3390-54',
# 'volume_size': '60102'},
# 'IAS101': { 'volume_type': '3390-09',
# 'volume_size': '60102'}}
self._volume_infos = self._smtclient.get_volume_info()
volume_info = self._volume_infos.get(volume_name)
if not volume_info:
msg = ("Not found the volume info for the"
" volume %(volume)s: make sure the volume"
" is in the disk_pool configured for sdkserver.") \
% {'volume': volume_name}
raise exception.ZVMNotFound(msg=msg)
else:
return volume_info
def _update_nic_data(self):
nics = {}
vsw_dict = self._smtclient.virtual_network_vswitch_query_byte_stats()
with zvmutils.expect_invalid_resp_data():
for vsw in vsw_dict['vswitches']:
for nic in vsw['nics']:
userid = nic['userid']
nic_entry = {
'vswitch_name': vsw['vswitch_name'],
'nic_vdev': nic['vdev'],
'nic_fr_rx': int(nic['nic_fr_rx']),
'nic_fr_tx': int(nic['nic_fr_tx']),
'nic_fr_rx_dsc': int(nic['nic_fr_rx_dsc']),
'nic_fr_tx_dsc': int(nic['nic_fr_tx_dsc']),
'nic_fr_rx_err': int(nic['nic_fr_rx_err']),
'nic_fr_tx_err': int(nic['nic_fr_tx_err']),
'nic_rx': int(nic['nic_rx']),
'nic_tx': int(nic['nic_tx'])
}
if nics.get(userid, None) is None:
nics[userid] = [nic_entry]
else:
nics[userid].append(nic_entry)
# Update cache if enabled
if self._cache_enabled():
self._cache.refresh('vnics', nics)
return nics
def inspect_stats(self, uid_list):
cpumem_data = self._get_inspect_data('cpumem', uid_list)
# construct and return final result
stats_data = {}
for uid in uid_list:
if uid in cpumem_data:
with zvmutils.expect_invalid_resp_data():
user_data = cpumem_data[uid]
guest_cpus = int(user_data['guest_cpus'])
used_cpu_time = user_data['used_cpu_time']
used_cpu_time = int(used_cpu_time.partition(' ')[0])
elapsed_cpu_time = int(
user_data['elapsed_cpu_time'].partition(' ')[0])
used_mem = int(user_data['used_memory'].partition(' ')[0])
max_mem = int(user_data['max_memory'].partition(' ')[0])
min_mem = int(user_data['min_memory'].partition(' ')[0])
shared_mem = int(
user_data['shared_memory'].partition(' ')[0])
stats_data[uid] = {
'guest_cpus': guest_cpus,
'used_cpu_time_us': used_cpu_time,
'elapsed_cpu_time_us': elapsed_cpu_time,
'min_cpu_count': int(user_data['min_cpu_count']),
'max_cpu_limit': int(user_data['max_cpu_limit']),
'samples_cpu_in_use': int(user_data['samples_cpu_in_use']),
'samples_cpu_delay': int(user_data['samples_cpu_delay']),
'used_mem_kb': used_mem,
'max_mem_kb': max_mem,
'min_mem_kb': min_mem,
'shared_mem_kb': shared_mem
}
return stats_data
def inspect_cpus(self, uid_list):
cpumem_data = self._get_inspect_data('cpumem', uid_list)
# construct and return final result
cpu_data = {}
for uid in uid_list:
uid = uid.upper()
if uid in cpumem_data:
with zvmutils.expect_invalid_resp_data():
user_data = cpumem_data[uid]
guest_cpus = int(user_data['guest_cpus'])
used_cpu_time = user_data['used_cpu_time']
used_cpu_time = int(used_cpu_time.partition(' ')[0])
elapsed_cpu_time = int(
user_data['elapsed_cpu_time'].partition(' ')[0])
cpu_data[uid] = {
'guest_cpus': guest_cpus,
'used_cpu_time_us': used_cpu_time,
'elapsed_cpu_time_us': elapsed_cpu_time,
'min_cpu_count': int(user_data['min_cpu_count']),
'max_cpu_limit': int(user_data['max_cpu_limit']),
'samples_cpu_in_use': int(user_data['samples_cpu_in_use']),
'samples_cpu_delay': int(user_data['samples_cpu_delay'])
}
return cpu_data
def get_power_state(self, userid):
"""Get power status of a z/VM instance."""
LOG.debug('Query power stat of %s' % userid)
requestData = "PowerVM " + userid + " status"
results = self._request(requestData)
with zvmutils.expect_invalid_resp_data(results):
status = results['response'][0].partition(': ')[2]
return status
def inspect_vnics(self, uid_list):
vnics = self._get_inspect_data('vnics', uid_list)
# construct and return final result
target_vnics = {}
for uid in uid_list:
if uid in vnics:
with zvmutils.expect_invalid_resp_data():
target_vnics[uid] = vnics[uid]
return target_vnics
def is_reachable(self, userid):
"""Return True is the instance is reachable."""
res_dict = self._zvmclient.get_guest_connection_status(userid)
LOG.debug('Get instance status of %s', userid)
with zvmutils.expect_invalid_resp_data(res_dict):
status = res_dict['node'][0][0]['data'][0]
if status is not None:
if status.__contains__('sshd'):
return True
return False
def image_performance_query(self, uid_list):
"""Call Image_Performance_Query to get guest current status.
:uid_list: A list of zvm userids to be queried
"""
if not isinstance(uid_list, list):
uid_list = [uid_list]
smut_userid = zvmutils.get_smut_userid()
rd = ' '.join(("SMAPI %s API Image_Performance_Query" % smut_userid,
"--operands", '-T "%s"' % (' '.join(uid_list)),
"-c %d" % len(uid_list)))
results = self._request(rd)
ipq_kws = {
'userid': "Guest name:",
'guest_cpus': "Guest CPUs:",
'used_cpu_time': "Used CPU time:",
'elapsed_cpu_time': "Elapsed time:",
'min_cpu_count': "Minimum CPU count:",
'max_cpu_limit': "Max CPU limit:",
'samples_cpu_in_use': "Samples CPU in use:",
'samples_cpu_delay': ",Samples CPU delay:",
'used_memory': "Used memory:",
'max_memory': "Max memory:",
'min_memory': "Minimum memory:",
'shared_memory': "Shared memory:",
}
pi_dict = {}
pi = {}
with zvmutils.expect_invalid_resp_data():
rpi_list = ('\n'.join(results['response'])).split("\n\n")
for rpi in rpi_list:
try:
pi = zvmutils.translate_response_to_dict(rpi, ipq_kws)
except exception.ZVMInvalidResponseDataError as err:
emsg = err.format_message()
# when there is only one userid queried and this userid is
# in 'off'state, the smcli will only returns the queried
# userid number, no valid performance info returned.
if (emsg.__contains__("No value matched with keywords.")):
continue
else:
raise err
for k, v in pi.items():
pi[k] = v.strip('" ')
if pi.get('userid') is not None:
pi_dict[pi['userid']] = pi
return pi_dict
def get_vm_nic_vswitch_info(self, vm_id):
"""
Get NIC and switch mapping for the specified virtual machine.
"""
switch_info = self._NetDbOperator.switch_select_record_for_node(vm_id)
with zvmutils.expect_invalid_resp_data():
switch_dict = {}
for item in switch_info:
switch_dict[item[0]] = item[1]
LOG.debug("Switch info the %(vm_id)s is %(switch_dict)s", {
"vm_id": vm_id,
"switch_dict": switch_dict
})
return switch_dict
def inspect_mem(self, uid_list):
cpumem_data = self._get_inspect_data('cpumem', uid_list)
# construct and return final result
mem_data = {}
for uid in uid_list:
uid = uid.upper()
if uid in cpumem_data:
with zvmutils.expect_invalid_resp_data():
user_data = cpumem_data[uid]
used_mem = int(user_data['used_memory'].partition(' ')[0])
max_mem = int(user_data['max_memory'].partition(' ')[0])
min_mem = int(user_data['min_memory'].partition(' ')[0])
shared_mem = int(
user_data['shared_memory'].partition(' ')[0])
mem_data[uid] = {
'used_mem_kb': used_mem,
'max_mem_kb': max_mem,
'min_mem_kb': min_mem,
'shared_mem_kb': shared_mem
}
return mem_data
def _get_max_memory_from_user_dict(self, dict_info):
with zvmutils.expect_invalid_resp_data():
mem = dict_info[0].split(' ')[4]
return zvmutils.convert_to_mb(mem) * 1024
def guest_list(self):
guest_list = self._smtclient.get_all_user_direct()
with zvmutils.expect_invalid_resp_data(guest_list):
return guest_list
def diskpool_get_volumes(self, pool_name):
diskpool_volume_list = self._smtclient.get_diskpool_volumes(pool_name)
with zvmutils.expect_invalid_resp_data(diskpool_volume_list):
return diskpool_volume_list
def _parse_vswitch_inspect_data(self, rd_list):
""" Parse the Virtual_Network_Vswitch_Query_IUO_Stats data to get
inspect data. This is an internal function shared by both smut and
xcat client.
"""
def _parse_value(data_list, idx, keyword, offset):
return idx + offset, data_list[idx].rpartition(keyword)[2].strip()
vsw_dict = {}
with zvmutils.expect_invalid_resp_data():
# vswitch count
idx = 0
idx, vsw_count = _parse_value(rd_list, idx, 'vswitch count:', 2)
vsw_dict['vswitch_count'] = int(vsw_count)
# deal with each vswitch data
vsw_dict['vswitches'] = []
for i in range(vsw_dict['vswitch_count']):
vsw_data = {}
# skip vswitch number
idx += 1
# vswitch name
idx, vsw_name = _parse_value(rd_list, idx, 'vswitch name:', 1)
vsw_data['vswitch_name'] = vsw_name
# uplink count
idx, up_count = _parse_value(rd_list, idx, 'uplink count:', 1)
# skip uplink data
idx += int(up_count) * 9
# skip bridge data
idx += 8
# nic count
vsw_data['nics'] = []
idx, nic_count = _parse_value(rd_list, idx, 'nic count:', 1)
nic_count = int(nic_count)
for j in range(nic_count):
nic_data = {}
idx, nic_id = _parse_value(rd_list, idx, 'nic_id:', 1)
userid, toss, vdev = nic_id.partition(' ')
nic_data['userid'] = userid
nic_data['vdev'] = vdev
idx, nic_data['nic_fr_rx'] = _parse_value(
rd_list, idx, 'nic_fr_rx:', 1)
idx, nic_data['nic_fr_rx_dsc'] = _parse_value(
rd_list, idx, 'nic_fr_rx_dsc:', 1)
idx, nic_data['nic_fr_rx_err'] = _parse_value(
rd_list, idx, 'nic_fr_rx_err:', 1)
idx, nic_data['nic_fr_tx'] = _parse_value(
rd_list, idx, 'nic_fr_tx:', 1)
idx, nic_data['nic_fr_tx_dsc'] = _parse_value(
rd_list, idx, 'nic_fr_tx_dsc:', 1)
idx, nic_data['nic_fr_tx_err'] = _parse_value(
rd_list, idx, 'nic_fr_tx_err:', 1)
idx, nic_data['nic_rx'] = _parse_value(
rd_list, idx, 'nic_rx:', 1)
idx, nic_data['nic_tx'] = _parse_value(
rd_list, idx, 'nic_tx:', 1)
vsw_data['nics'].append(nic_data)
# vlan count
idx, vlan_count = _parse_value(rd_list, idx, 'vlan count:', 1)
# skip vlan data
idx += int(vlan_count) * 3
# skip the blank line
idx += 1
vsw_dict['vswitches'].append(vsw_data)
return vsw_dict
