def __init__(self):
"""Initalises the state of all host specific objects such as
* host
* host_CPU
* host_metrics
* PIF
* PIF_metrics
* network
* Storage Repository
* PPCI
* PSCSI
"""
self.xc = xen.lowlevel.xc.xc()
self.state_store = XendStateStore(xendoptions().get_xend_state_path())
self.monitor = XendMonitor()
self.monitor.start()
# load host state from XML file
saved_host = self.state_store.load_state('host')
if saved_host and len(saved_host.keys()) == 1:
self.uuid = saved_host.keys()[0]
host = saved_host[self.uuid]
self.name = host.get('name_label', socket.gethostname())
self.desc = host.get('name_description', '')
self.host_metrics_uuid = host.get('metrics_uuid',
uuid.createString())
try:
self.other_config = eval(host['other_config'])
except:
self.other_config = {}
self.cpus = {}
else:
self.uuid = uuid.createString()
self.name = socket.gethostname()
self.desc = ''
self.other_config = {}
self.cpus = {}
self.host_metrics_uuid = uuid.createString()
# put some arbitrary params in other_config as this
# is directly exposed via XenAPI
self.other_config["xen_pagesize"] = self.xeninfo_dict()["xen_pagesize"]
self.other_config["platform_params"] = self.xeninfo_dict()["platform_params"]
self.other_config["xen_commandline"] = self.xeninfo_dict()["xen_commandline"]
# load CPU UUIDs
saved_cpus = self.state_store.load_state('cpu')
for cpu_uuid, cpu in saved_cpus.items():
self.cpus[cpu_uuid] = cpu
cpuinfo = osdep.get_cpuinfo()
physinfo = self.physinfo_dict()
cpu_count = physinfo['nr_cpus']
cpu_features = physinfo['hw_caps']
virt_caps = physinfo['virt_caps']
# If the number of CPUs don't match, we should just reinitialise
# the CPU UUIDs.
if cpu_count != len(self.cpus):
self.cpus = {}
for i in range(cpu_count):
u = uuid.createString()
self.cpus[u] = {'uuid': u, 'number': i }
for u in self.cpus.keys():
number = self.cpus[u]['number']
# We can run off the end of the cpuinfo list if domain0 does not
# have #vcpus == #pcpus. In that case we just replicate one that's
# in the hash table.
if not cpuinfo.has_key(number):
number = cpuinfo.keys()[0]
if arch.type == "x86":
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
'virt_caps': virt_caps,
'speed' : int(float(cpuinfo[number]['cpu MHz'])),
'vendor' : cpuinfo[number]['vendor_id'],
'modelname': cpuinfo[number]['model name'],
'stepping' : cpuinfo[number]['stepping'],
'flags' : cpuinfo[number]['flags'],
})
elif arch.type == "ia64":
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
'speed' : int(float(cpuinfo[number]['cpu MHz'])),
'vendor' : cpuinfo[number]['vendor'],
'modelname': cpuinfo[number]['family'],
'stepping' : cpuinfo[number]['model'],
'flags' : cpuinfo[number]['features'],
})
else:
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
})
self.srs = {}
self._init_networks()
self._init_PIFs()
self._init_SRs()
self._init_PBDs()
self._init_PPCIs()
self._init_PSCSIs()
self._init_cpu_pools()
class XendNode:
"""XendNode - Represents a Domain 0 Host."""
def __init__(self):
"""Initalises the state of all host specific objects such as
* host
* host_CPU
* host_metrics
* PIF
* PIF_metrics
* network
* Storage Repository
* PPCI
* PSCSI
"""
self.xc = xen.lowlevel.xc.xc()
self.state_store = XendStateStore(xendoptions().get_xend_state_path())
self.monitor = XendMonitor()
self.monitor.start()
# load host state from XML file
saved_host = self.state_store.load_state('host')
if saved_host and len(saved_host.keys()) == 1:
self.uuid = saved_host.keys()[0]
host = saved_host[self.uuid]
self.name = host.get('name_label', socket.gethostname())
self.desc = host.get('name_description', '')
self.host_metrics_uuid = host.get('metrics_uuid',
uuid.createString())
try:
self.other_config = eval(host['other_config'])
except:
self.other_config = {}
self.cpus = {}
else:
self.uuid = uuid.createString()
self.name = socket.gethostname()
self.desc = ''
self.other_config = {}
self.cpus = {}
self.host_metrics_uuid = uuid.createString()
# put some arbitrary params in other_config as this
# is directly exposed via XenAPI
self.other_config["xen_pagesize"] = self.xeninfo_dict()["xen_pagesize"]
self.other_config["platform_params"] = self.xeninfo_dict()["platform_params"]
self.other_config["xen_commandline"] = self.xeninfo_dict()["xen_commandline"]
# load CPU UUIDs
saved_cpus = self.state_store.load_state('cpu')
for cpu_uuid, cpu in saved_cpus.items():
self.cpus[cpu_uuid] = cpu
cpuinfo = osdep.get_cpuinfo()
physinfo = self.physinfo_dict()
cpu_count = physinfo['nr_cpus']
cpu_features = physinfo['hw_caps']
virt_caps = physinfo['virt_caps']
# If the number of CPUs don't match, we should just reinitialise
# the CPU UUIDs.
if cpu_count != len(self.cpus):
self.cpus = {}
for i in range(cpu_count):
u = uuid.createString()
self.cpus[u] = {'uuid': u, 'number': i }
for u in self.cpus.keys():
number = self.cpus[u]['number']
# We can run off the end of the cpuinfo list if domain0 does not
# have #vcpus == #pcpus. In that case we just replicate one that's
# in the hash table.
if not cpuinfo.has_key(number):
number = cpuinfo.keys()[0]
if arch.type == "x86":
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
'virt_caps': virt_caps,
'speed' : int(float(cpuinfo[number]['cpu MHz'])),
'vendor' : cpuinfo[number]['vendor_id'],
'modelname': cpuinfo[number]['model name'],
'stepping' : cpuinfo[number]['stepping'],
'flags' : cpuinfo[number]['flags'],
})
elif arch.type == "ia64":
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
'speed' : int(float(cpuinfo[number]['cpu MHz'])),
'vendor' : cpuinfo[number]['vendor'],
'modelname': cpuinfo[number]['family'],
'stepping' : cpuinfo[number]['model'],
'flags' : cpuinfo[number]['features'],
})
else:
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
})
self.srs = {}
self._init_networks()
self._init_PIFs()
self._init_SRs()
self._init_PBDs()
self._init_PPCIs()
self._init_PSCSIs()
self._init_cpu_pools()
def _init_networks(self):
# Initialise networks
# First configure ones off disk
saved_networks = self.state_store.load_state('network')
if saved_networks:
for net_uuid, network in saved_networks.items():
try:
XendNetwork.recreate(network, net_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating network %s", net_uuid)
# Next discover any existing bridges and check
# they are not already configured
# 'tmpbridge' is a temporary bridge created by network-bridge script.
# Wait a couple of seconds for it to be renamed.
for i in xrange(20):
bridges = Brctl.get_state().keys()
if 'tmpbridge' in bridges:
time.sleep(0.1)
else:
break
configured_bridges = [XendAPIStore.get(
network_uuid, "network")
.get_name_label()
for network_uuid in XendNetwork.get_all()]
unconfigured_bridges = [bridge
for bridge in bridges
if bridge not in configured_bridges]
for unconfigured_bridge in unconfigured_bridges:
if unconfigured_bridge != 'tmpbridge':
XendNetwork.create_phy(unconfigured_bridge)
def _init_PIFs(self):
# Initialise PIFs
# First configure ones off disk
saved_pifs = self.state_store.load_state('pif')
if saved_pifs:
for pif_uuid, pif in saved_pifs.items():
try:
XendPIF.recreate(pif, pif_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PIF %s", pif_uuid)
# Next discover any existing PIFs and check
# they are not already configured
configured_pifs = [XendAPIStore.get(
pif_uuid, "PIF")
.get_interface_name()
for pif_uuid in XendPIF.get_all()]
unconfigured_pifs = [(name, mtu, mac)
for name, mtu, mac in linux_get_phy_ifaces()
if name not in configured_pifs]
# Get a mapping from interface to bridge
if_to_br = dict([(i,b)
for (b,ifs) in Brctl.get_state().items()
for i in ifs])
for name, mtu, mac in unconfigured_pifs:
# Check PIF is on bridge
# if not, ignore
bridge_name = if_to_br.get(name, None)
if bridge_name is not None:
# Translate bridge name to network uuid
for network_uuid in XendNetwork.get_all():
network = XendAPIStore.get(
network_uuid, 'network')
if network.get_name_label() == bridge_name:
XendPIF.create_phy(network_uuid, name,
mac, mtu)
break
else:
log.debug("Cannot find network for bridge %s "
"when configuring PIF %s",
(bridge_name, name))
def _init_SRs(self):
# initialise storage
saved_srs = self.state_store.load_state('sr')
if saved_srs:
for sr_uuid, sr_cfg in saved_srs.items():
if sr_cfg['type'] == 'qcow_file':
self.srs[sr_uuid] = XendQCoWStorageRepo(sr_uuid)
elif sr_cfg['type'] == 'local':
self.srs[sr_uuid] = XendLocalStorageRepo(sr_uuid)
# Create missing SRs if they don't exist
if not self.get_sr_by_type('local'):
image_sr_uuid = uuid.createString()
self.srs[image_sr_uuid] = XendLocalStorageRepo(image_sr_uuid)
if not self.get_sr_by_type('qcow_file'):
qcow_sr_uuid = uuid.createString()
self.srs[qcow_sr_uuid] = XendQCoWStorageRepo(qcow_sr_uuid)
def _init_PBDs(self):
saved_pbds = self.state_store.load_state('pbd')
if saved_pbds:
for pbd_uuid, pbd_cfg in saved_pbds.items():
try:
XendPBD.recreate(pbd_uuid, pbd_cfg)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PBD %s", pbd_uuid)
def _init_PPCIs(self):
saved_ppcis = self.state_store.load_state('ppci')
saved_ppci_table = {}
if saved_ppcis:
for ppci_uuid, ppci_record in saved_ppcis.items():
try:
saved_ppci_table[ppci_record['name']] = ppci_uuid
except KeyError:
pass
for pci_dev in PciUtil.get_all_pci_devices():
ppci_record = {
'domain': pci_dev.domain,
'bus': pci_dev.bus,
'slot': pci_dev.slot,
'func': pci_dev.func,
'vendor_id': pci_dev.vendor,
'vendor_name': pci_dev.vendorname,
'device_id': pci_dev.device,
'device_name': pci_dev.devicename,
'revision_id': pci_dev.revision,
'class_code': pci_dev.classcode,
'class_name': pci_dev.classname,
'subsystem_vendor_id': pci_dev.subvendor,
'subsystem_vendor_name': pci_dev.subvendorname,
'subsystem_id': pci_dev.subdevice,
'subsystem_name': pci_dev.subdevicename,
'driver': pci_dev.driver
}
# If saved uuid exists, use it. Otherwise create one.
ppci_uuid = saved_ppci_table.get(pci_dev.name, uuid.createString())
XendPPCI(ppci_uuid, ppci_record)
def _init_PSCSIs(self):
# Initialise PSCSIs and PSCSI_HBAs
saved_pscsis = self.state_store.load_state('pscsi')
saved_pscsi_table = {}
if saved_pscsis:
for pscsi_uuid, pscsi_record in saved_pscsis.items():
try:
saved_pscsi_table[pscsi_record['scsi_id']] = pscsi_uuid
except KeyError:
pass
saved_pscsi_HBAs = self.state_store.load_state('pscsi_HBA')
saved_pscsi_HBA_table = {}
if saved_pscsi_HBAs:
for pscsi_HBA_uuid, pscsi_HBA_record in saved_pscsi_HBAs.items():
try:
physical_host = int(pscsi_HBA_record['physical_host'])
saved_pscsi_HBA_table[physical_host] = pscsi_HBA_uuid
except (KeyError, ValueError):
pass
pscsi_table = {}
pscsi_HBA_table = {}
pscsi_records = []
for pscsi_mask in xendoptions().get_pscsi_device_mask():
pscsi_records += vscsi_util.get_all_scsi_devices(pscsi_mask)
log.debug("pscsi record count: %s" % len(pscsi_records))
for pscsi_record in pscsi_records:
scsi_id = pscsi_record['scsi_id']
if scsi_id:
saved_HBA_uuid = None
pscsi_uuid = saved_pscsi_table.get(scsi_id, None)
if pscsi_uuid is None:
pscsi_uuid = uuid.createString()
saved_pscsi_table[scsi_id] = pscsi_uuid
else:
try:
saved_HBA_uuid = saved_pscsis[pscsi_uuid].get('HBA', None)
except KeyError:
log.warn("Multi-path SCSI devices are not supported for XenAPI")
return
physical_host = int(pscsi_record['physical_HCTL'].split(':')[0])
if pscsi_HBA_table.has_key(physical_host):
pscsi_HBA_uuid = pscsi_HBA_table[physical_host]
elif saved_pscsi_HBA_table.has_key(physical_host):
pscsi_HBA_uuid = saved_pscsi_HBA_table[physical_host]
pscsi_HBA_table[physical_host] = pscsi_HBA_uuid
else:
pscsi_HBA_uuid = uuid.createString()
pscsi_HBA_table[physical_host] = pscsi_HBA_uuid
if saved_HBA_uuid is not None and \
saved_HBA_uuid != pscsi_HBA_uuid:
log.debug('The PSCSI(%s) host number was changed', scsi_id)
pscsi_record['HBA'] = pscsi_HBA_uuid
pscsi_table[pscsi_uuid] = pscsi_record
for pscsi_uuid, pscsi_record in pscsi_table.items():
XendPSCSI(pscsi_uuid, pscsi_record)
for physical_host, pscsi_HBA_uuid in pscsi_HBA_table.items():
XendPSCSI_HBA(pscsi_HBA_uuid, {'physical_host': physical_host})
def _init_cpu_pools(self):
# Initialise cpu_pools
saved_cpu_pools = self.state_store.load_state(XendCPUPool.getClass())
if saved_cpu_pools:
for cpu_pool_uuid, cpu_pool in saved_cpu_pools.items():
try:
XendCPUPool.recreate(cpu_pool, cpu_pool_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating %s %s",
(XendCPUPool.getClass(), cpu_pool_uuid))
XendCPUPool.recreate_active_pools()
def add_network(self, interface):
# TODO
log.debug("add_network(): Not implemented.")
def remove_network(self, interface):
# TODO
log.debug("remove_network(): Not implemented.")
def add_PPCI(self, pci_name):
# Update lspci info
PciUtil.create_lspci_info()
# Initialise the PPCI
saved_ppcis = self.state_store.load_state('ppci')
saved_ppci_table = {}
if saved_ppcis:
for ppci_uuid, ppci_record in saved_ppcis.items():
try:
saved_ppci_table[ppci_record['name']] = ppci_uuid
except KeyError:
pass
pci_dev = PciUtil.PciDevice(PciUtil.parse_pci_name(pci_name))
ppci_record = {
'domain': pci_dev.domain,
'bus': pci_dev.bus,
'slot': pci_dev.slot,
'func': pci_dev.func,
'vendor_id': pci_dev.vendor,
'vendor_name': pci_dev.vendorname,
'device_id': pci_dev.device,
'device_name': pci_dev.devicename,
'revision_id': pci_dev.revision,
'class_code': pci_dev.classcode,
'class_name': pci_dev.classname,
'subsystem_vendor_id': pci_dev.subvendor,
'subsystem_vendor_name': pci_dev.subvendorname,
'subsystem_id': pci_dev.subdevice,
'subsystem_name': pci_dev.subdevicename,
'driver': pci_dev.driver
}
# If saved uuid exists, use it. Otherwise create one.
ppci_uuid = saved_ppci_table.get(pci_dev.name, uuid.createString())
XendPPCI(ppci_uuid, ppci_record)
self.save_PPCIs()
def remove_PPCI(self, pci_name):
# Update lspci info
PciUtil.create_lspci_info()
# Remove the PPCI
(domain, bus, slot, func) = PciUtil.parse_pci_name(pci_name)
ppci_ref = XendPPCI.get_by_sbdf(domain, bus, slot, func)
XendAPIStore.get(ppci_ref, "PPCI").destroy()
self.save_PPCIs()
def add_PSCSI(self, add_HCTL):
saved_pscsis = self.state_store.load_state('pscsi')
saved_pscsi_table = {}
if saved_pscsis:
for saved_uuid, saved_record in saved_pscsis.items():
try:
saved_pscsi_table[saved_record['scsi_id']] = saved_uuid
except KeyError:
pass
saved_pscsi_HBAs = self.state_store.load_state('pscsi_HBA')
saved_pscsi_HBA_table = {}
if saved_pscsi_HBAs:
for saved_HBA_uuid, saved_HBA_record in saved_pscsi_HBAs.items():
try:
physical_host = int(saved_HBA_record['physical_host'])
saved_pscsi_HBA_table[physical_host] = saved_HBA_uuid
except (KeyError, ValueError):
pass
# Initialise the PSCSI and the PSCSI_HBA
pscsi_record = vscsi_util.get_scsi_device(add_HCTL)
if pscsi_record and pscsi_record['scsi_id']:
pscsi_uuid = saved_pscsi_table.get(pscsi_record['scsi_id'], None)
if pscsi_uuid is None:
physical_host = int(add_HCTL.split(':')[0])
pscsi_HBA_uuid = saved_pscsi_HBA_table.get(physical_host, None)
if pscsi_HBA_uuid is None:
pscsi_HBA_uuid = uuid.createString()
XendPSCSI_HBA(pscsi_HBA_uuid, {'physical_host': physical_host})
pscsi_record['HBA'] = pscsi_HBA_uuid
pscsi_uuid = uuid.createString()
XendPSCSI(pscsi_uuid, pscsi_record)
self.save_PSCSIs()
self.save_PSCSI_HBAs()
def remove_PSCSI(self, rem_HCTL):
saved_pscsis = self.state_store.load_state('pscsi')
if not saved_pscsis:
return
# Remove the PSCSI
for pscsi_record in saved_pscsis.values():
if rem_HCTL == pscsi_record['physical_HCTL']:
pscsi_ref = XendPSCSI.get_by_HCTL(rem_HCTL)
XendAPIStore.get(pscsi_ref, "PSCSI").destroy()
self.save_PSCSIs()
physical_host = int(rem_HCTL.split(':')[0])
pscsi_HBA_ref = XendPSCSI_HBA.get_by_physical_host(physical_host)
if pscsi_HBA_ref:
if not XendAPIStore.get(pscsi_HBA_ref, 'PSCSI_HBA').get_PSCSIs():
XendAPIStore.get(pscsi_HBA_ref, 'PSCSI_HBA').destroy()
self.save_PSCSI_HBAs()
return
def add_usbdev(self, busid):
# if the adding usb device should be owned by usbback
# and is probed by other usb drivers, seize it!
bus, intf = busid.split(':')
buses = vusb_util.get_assigned_buses()
if str(bus) in buses:
if not vusb_util.usb_intf_is_binded(busid):
log.debug("add_usb(): %s is binded to other driver" % busid)
vusb_util.unbind_usb_device(bus)
vusb_util.bind_usb_device(bus)
return
def remove_usbdev(self, busid):
log.debug("remove_usbdev(): Not implemented.")
## def network_destroy(self, net_uuid):
## del self.networks[net_uuid]
## self.save_networks()
def get_PIF_refs(self):
log.debug(XendPIF.get_all())
return XendPIF.get_all()
## def _PIF_create(self, name, mtu, vlan, mac, network, persist = True,
## pif_uuid = None, metrics_uuid = None):
## for pif in self.pifs.values():
## if pif.network == network:
## raise NetworkAlreadyConnected(pif.uuid)
## if pif_uuid is None:
## pif_uuid = uuid.createString()
## if metrics_uuid is None:
## metrics_uuid = uuid.createString()
## metrics = XendPIFMetrics(metrics_uuid)
## pif = XendPIF(pif_uuid, metrics, name, mtu, vlan, mac, network, self)
## metrics.set_PIF(pif)
## self.pif_metrics[metrics_uuid] = metrics
## self.pifs[pif_uuid] = pif
## if persist:
## self.save_PIFs()
## self.refreshBridges()
## return pif_uuid
## def PIF_destroy(self, pif_uuid):
## pif = self.pifs[pif_uuid]
## if pif.vlan == -1:
## raise PIFIsPhysical()
## del self.pifs[pif_uuid]
## self.save_PIFs()
def get_PPCI_refs(self):
return XendPPCI.get_all()
def get_ppci_by_uuid(self, ppci_uuid):
if ppci_uuid in self.get_PPCI_refs():
return ppci_uuid
return None
def get_PSCSI_refs(self):
return XendPSCSI.get_all()
def get_pscsi_by_uuid(self, pscsi_uuid):
if pscsi_uuid in self.get_PSCSI_refs():
return pscsi_uuid
return None
def get_PSCSI_HBA_refs(self):
return XendPSCSI_HBA.get_all()
def get_pscsi_HBA_by_uuid(self, pscsi_HBA_uuid):
if pscsi_HBA_uuid in self.get_PSCSI_HBA_refs():
return pscsi_HBA_uuid
return None
def save(self):
# save state
host_record = {self.uuid: {'name_label':self.name,
'name_description':self.desc,
'metrics_uuid': self.host_metrics_uuid,
'other_config': self.other_config}}
self.state_store.save_state('host',host_record)
self.state_store.save_state('cpu', self.cpus)
self.save_PIFs()
self.save_networks()
self.save_PBDs()
self.save_SRs()
self.save_PPCIs()
self.save_PSCSIs()
self.save_PSCSI_HBAs()
self.save_cpu_pools()
def save_PIFs(self):
pif_records = dict([(pif_uuid, XendAPIStore.get(
pif_uuid, "PIF").get_record())
for pif_uuid in XendPIF.get_all()])
self.state_store.save_state('pif', pif_records)
def save_networks(self):
net_records = dict([(network_uuid, XendAPIStore.get(
network_uuid, "network").get_record())
for network_uuid in XendNetwork.get_all()])
self.state_store.save_state('network', net_records)
def save_PBDs(self):
pbd_records = dict([(pbd_uuid, XendAPIStore.get(
pbd_uuid, "PBD").get_record())
for pbd_uuid in XendPBD.get_all()])
self.state_store.save_state('pbd', pbd_records)
def save_SRs(self):
sr_records = dict([(k, v.get_record(transient = False))
for k, v in self.srs.items()])
self.state_store.save_state('sr', sr_records)
def save_PPCIs(self):
ppci_records = dict([(ppci_uuid, XendAPIStore.get(
ppci_uuid, "PPCI").get_record())
for ppci_uuid in XendPPCI.get_all()])
self.state_store.save_state('ppci', ppci_records)
def save_PSCSIs(self):
pscsi_records = dict([(pscsi_uuid, XendAPIStore.get(
pscsi_uuid, "PSCSI").get_record())
for pscsi_uuid in XendPSCSI.get_all()])
self.state_store.save_state('pscsi', pscsi_records)
def save_PSCSI_HBAs(self):
pscsi_HBA_records = dict([(pscsi_HBA_uuid, XendAPIStore.get(
pscsi_HBA_uuid, "PSCSI_HBA").get_record())
for pscsi_HBA_uuid in XendPSCSI_HBA.get_all()])
self.state_store.save_state('pscsi_HBA', pscsi_HBA_records)
def save_cpu_pools(self):
cpu_pool_records = dict([(cpu_pool_uuid, XendAPIStore.get(
cpu_pool_uuid, XendCPUPool.getClass()).get_record())
for cpu_pool_uuid in XendCPUPool.get_all_managed()])
self.state_store.save_state(XendCPUPool.getClass(), cpu_pool_records)
def shutdown(self):
return 0
def reboot(self):
return 0
def notify(self, _):
return 0
#
# Ref validation
#
def is_valid_host(self, host_ref):
return (host_ref == self.uuid)
def is_valid_cpu(self, cpu_ref):
return (cpu_ref in self.cpus)
def is_valid_sr(self, sr_ref):
return (sr_ref in self.srs)
def is_valid_vdi(self, vdi_ref):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_ref):
return True
return False
#
# Storage Repositories
#
def get_sr(self, sr_uuid):
return self.srs.get(sr_uuid)
def get_sr_by_type(self, sr_type):
return [sr.uuid for sr in self.srs.values() if sr.type == sr_type]
def get_sr_by_name(self, name):
return [sr.uuid for sr in self.srs.values() if sr.name_label == name]
def get_all_sr_uuid(self):
return self.srs.keys()
def get_vdi_by_uuid(self, vdi_uuid):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_uuid):
return sr.get_vdi_by_uuid(vdi_uuid)
return None
def get_vdi_by_name_label(self, name):
for sr in self.srs.values():
vdi = sr.get_vdi_by_name_label(name)
if vdi:
return vdi
return None
def get_sr_containing_vdi(self, vdi_uuid):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_uuid):
return sr
return None
#
# Host Functions
#
def xen_version(self):
info = self.xc.xeninfo()
info = {'Xen': '%(xen_major)d.%(xen_minor)d' % info}
# Add xend_config_format
info.update(self.xendinfo_dict())
# Add version info about machine
info.update(self.nodeinfo_dict())
# Add specific xen version info
xeninfo_dict = self.xeninfo_dict()
info.update({
"xen_major": xeninfo_dict["xen_major"],
"xen_minor": xeninfo_dict["xen_minor"],
"xen_extra": xeninfo_dict["xen_extra"],
"cc_compiler": xeninfo_dict["cc_compiler"],
"cc_compile_by": xeninfo_dict["cc_compile_by"],
"cc_compile_domain": xeninfo_dict["cc_compile_domain"],
"cc_compile_date": xeninfo_dict["cc_compile_date"],
"xen_changeset": xeninfo_dict["xen_changeset"],
"xen_commandline": xeninfo_dict["xen_commandline"]
})
return info
def get_name(self):
return self.name
def set_name(self, new_name):
self.name = new_name
def get_description(self):
return self.desc
def set_description(self, new_desc):
self.desc = new_desc
def get_uuid(self):
return self.uuid
def get_capabilities(self):
return self.xc.xeninfo()['xen_caps'].split(" ")
#
# Host CPU Functions
#
def get_host_cpu_by_uuid(self, host_cpu_uuid):
if host_cpu_uuid in self.cpus:
return host_cpu_uuid
raise XendError('Invalid CPU UUID')
def get_host_cpu_refs(self):
return self.cpus.keys()
def get_host_cpu_uuid(self, host_cpu_ref):
if host_cpu_ref in self.cpus:
return host_cpu_ref
else:
raise XendError('Invalid CPU Reference')
def get_host_cpu_field(self, ref, field):
try:
return self.cpus[ref][field]
except KeyError:
raise XendError('Invalid CPU Reference')
def get_host_cpu_load(self, host_cpu_ref):
host_cpu = self.cpus.get(host_cpu_ref)
if not host_cpu:
return 0.0
vcpu = int(host_cpu['number'])
cpu_loads = self.monitor.get_domain_vcpus_util()
if 0 in cpu_loads and vcpu in cpu_loads[0]:
return cpu_loads[0][vcpu]
return 0.0
def get_vcpus_policy(self):
sched_id = self.xc.sched_id_get()
if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
return 'sedf'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
return 'credit'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT2:
return 'credit2'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_RTGLOBAL:
return 'rtglobal'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_RTPARTITION:
return 'rtpartition'
else:
return 'unknown'
def get_cpu_configuration(self):
phys_info = self.physinfo_dict()
cpu_info = {
"nr_nodes": phys_info["nr_nodes"],
"nr_cpus": phys_info["nr_cpus"],
"cores_per_socket": phys_info["cores_per_socket"],
"threads_per_core": phys_info["threads_per_core"]
}
return cpu_info
#
# Network Functions
#
def bridge_to_network(self, bridge):
"""
Determine which network a particular bridge is attached to.
@param bridge The name of the bridge. If empty, the default bridge
will be used instead (the first one in the list returned by brctl
show); this is the behaviour of the vif-bridge script.
@return The XendNetwork instance to which this bridge is attached.
@raise Exception if the interface is not connected to a network.
"""
if not bridge:
rc, bridge = commands.getstatusoutput(
'brctl show | cut -d "\n" -f 2 | cut -f 1')
if rc != 0 or not bridge:
raise Exception(
'Could not find default bridge, and none was specified')
for network_uuid in XendNetwork.get_all():
network = XendAPIStore.get(network_uuid, "network")
if network.get_name_label() == bridge:
return network
else:
raise Exception('Cannot find network for bridge %s' % bridge)
#
# Debug keys.
#
def send_debug_keys(self, keys):
return self.xc.send_debug_keys(keys)
#
# Getting host information.
#
def info(self, show_numa = 1):
return (self.nodeinfo() + self.physinfo(show_numa) + self.xeninfo() +
self.xendinfo())
def nodeinfo(self):
(sys, host, rel, ver, mch) = os.uname()
return [['system', sys],
['host', host],
['release', rel],
['version', ver],
['machine', mch]]
def list_to_rangepairs(self,cmap):
cmap.sort()
pairs = []
x = y = 0
for i in range(0,len(cmap)):
try:
if ((cmap[y+1] - cmap[i]) > 1):
pairs.append((cmap[x],cmap[y]))
x = y = i+1
else:
y = y + 1
# if we go off the end, then just add x to y
except IndexError:
pairs.append((cmap[x],cmap[y]))
return pairs
def format_pairs(self,pairs):
if not pairs:
return "no cpus"
out = ""
for f,s in pairs:
if (f==s):
out += '%d'%f
else:
out += '%d-%d'%(f,s)
out += ','
# trim trailing ','
return out[:-1]
def list_to_strrange(self,list):
return self.format_pairs(self.list_to_rangepairs(list))
def format_cpu_to_core_socket_node(self, tinfo):
max_cpu_index=tinfo['max_cpu_index']
str='\ncpu: core socket node\n'
for i in range(0, max_cpu_index+1):
try:
str+='%3d:%8d %8d %8d\n' % (i,
tinfo['cpu_to_core'][i],
tinfo['cpu_to_socket'][i],
tinfo['cpu_to_node'][i])
except:
pass
return str[:-1];
def format_numa_info(self, ninfo):
try:
max_node_index=ninfo['max_node_index']
str='\nnode: TotalMemory FreeMemory dma32Memory NodeDist:'
for i in range(0, max_node_index+1):
str+='%4d ' % i
str+='\n'
for i in range(0, max_node_index+1):
str+='%4d: %8dMB %8dMB %8dMB :' % (i,
ninfo['node_memsize'][i],
ninfo['node_memfree'][i],
ninfo['node_to_dma32_mem'][i])
for j in range(0, nr_nodes):
try:
str+='%4d ' % ninfo['node_to_node_dist'][i][j]
except:
str+='- '
str+='\n'
except:
str='none\n'
return str[:-1];
def physinfo(self, show_numa):
info = self.xc.physinfo()
tinfo = self.xc.topologyinfo()
ninfo = self.xc.numainfo()
info['cpu_mhz'] = info['cpu_khz'] / 1000
# physinfo is in KiB, need it in MiB
info['total_memory'] = info['total_memory'] / 1024
info['free_memory'] = info['free_memory'] / 1024
info['free_cpus'] = len(XendCPUPool.unbound_cpus())
ITEM_ORDER = ['nr_cpus',
'nr_nodes',
'cores_per_socket',
'threads_per_core',
'cpu_mhz',
'hw_caps',
'virt_caps',
'total_memory',
'free_memory',
'free_cpus',
]
if show_numa != 0:
info['cpu_topology'] = \
self.format_cpu_to_core_socket_node(tinfo)
info['numa_info'] = \
self.format_numa_info(ninfo)
ITEM_ORDER += [ 'cpu_topology', 'numa_info' ]
return [[k, info[k]] for k in ITEM_ORDER]
def pciinfo(self):
from xen.xend.server.pciif import get_all_assigned_pci_devices
assigned_devs = get_all_assigned_pci_devices()
# Each element of dev_list is a PciDevice
dev_list = PciUtil.find_all_assignable_devices()
if dev_list is None:
return None
# Each element of devs_list is a list of PciDevice
devs_list = PciUtil.check_FLR_capability(dev_list)
devs_list = PciUtil.check_mmio_bar(devs_list)
# Check if the devices have been assigned to guests.
final_devs_list = []
for dev_list in devs_list:
available = True
for d in dev_list:
if d.name in assigned_devs:
available = False
break
if available:
final_devs_list = final_devs_list + [dev_list]
pci_sxp_list = []
for dev_list in final_devs_list:
for d in dev_list:
pci_sxp = ['dev', ['domain', '0x%04x' % d.domain],
['bus', '0x%02x' % d.bus],
['slot', '0x%02x' % d.slot],
['func', '0x%x' % d.func]]
pci_sxp_list.append(pci_sxp)
return pci_sxp_list
def xenschedinfo(self):
sched_id = self.xc.sched_id_get()
if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
return 'sedf'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
return 'credit'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT2:
return 'credit2'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_RTGLOBAL:
return 'rtglobal'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_RTPARTITION:
return 'rtpartition'
else:
return 'unknown'
def xeninfo(self):
info = self.xc.xeninfo()
info['xen_scheduler'] = self.xenschedinfo()
ITEM_ORDER = ['xen_major',
'xen_minor',
'xen_extra',
'xen_caps',
'xen_scheduler',
'xen_pagesize',
'platform_params',
'xen_changeset',
'xen_commandline',
'cc_compiler',
'cc_compile_by',
'cc_compile_domain',
'cc_compile_date',
]
return [[k, info[k]] for k in ITEM_ORDER]
def xendinfo(self):
return [['xend_config_format', 4]]
#
# utilisation tracking
#
def get_vcpu_util(self, domid, vcpuid):
cpu_loads = self.monitor.get_domain_vcpus_util()
if domid in cpu_loads:
return cpu_loads[domid].get(vcpuid, 0.0)
return 0.0
def get_vif_util(self, domid, vifid):
vif_loads = self.monitor.get_domain_vifs_util()
if domid in vif_loads:
return vif_loads[domid].get(vifid, (0.0, 0.0))
return (0.0, 0.0)
def get_vif_stat(self, domid, vifid):
vif_loads = self.monitor.get_domain_vifs_stat()
if domid in vif_loads:
return vif_loads[domid].get(vifid, (0.0, 0.0))
return (0.0, 0.0)
def get_vbd_util(self, domid, vbdid):
vbd_loads = self.monitor.get_domain_vbds_util()
if domid in vbd_loads:
return vbd_loads[domid].get(vbdid, (0.0, 0.0))
return (0.0, 0.0)
# dictionary version of *info() functions to get rid of
# SXPisms.
def nodeinfo_dict(self):
return dict(self.nodeinfo())
def xendinfo_dict(self):
return dict(self.xendinfo())
def xeninfo_dict(self):
return dict(self.xeninfo())
def physinfo_dict(self):
return dict(self.physinfo(1))
def info_dict(self):
return dict(self.info())
# tmem
def tmem_list(self, cli_id, use_long):
pool_id = -1
subop = TMEMC_LIST
arg1 = 32768
arg2 = use_long
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_thaw(self, cli_id):
pool_id = -1
subop = TMEMC_THAW
arg1 = 0
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_freeze(self, cli_id):
pool_id = -1
subop = TMEMC_FREEZE
arg1 = 0
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_flush(self, cli_id, pages):
pool_id = -1
subop = TMEMC_FLUSH
arg1 = pages
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_destroy(self, cli_id):
pool_id = -1
subop = TMEMC_DESTROY
arg1 = 0
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_set_weight(self, cli_id, arg1):
pool_id = -1
subop = TMEMC_SET_WEIGHT
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_set_cap(self, cli_id, arg1):
pool_id = -1
subop = TMEMC_SET_CAP
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_set_compress(self, cli_id, arg1):
pool_id = -1
subop = TMEMC_SET_COMPRESS
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_query_freeable_mb(self):
pool_id = -1
cli_id = -1
subop = TMEMC_QUERY_FREEABLE_MB
arg1 = 0
arg2 = 0
arg3 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, arg3, buf)
def tmem_shared_auth(self, cli_id, uuid_str, auth):
return self.xc.tmem_auth(cli_id, uuid_str, auth)
def __init__(self):
"""Initalises the state of all host specific objects such as
* host
* host_CPU
* host_metrics
* PIF
* PIF_metrics
* network
* Storage Repository
* PPCI
* PSCSI
"""
self.xc = xen.lowlevel.xc.xc()
self.state_store = XendStateStore(xendoptions().get_xend_state_path())
self.monitor = XendMonitor()
self.monitor.start()
# load host state from XML file
saved_host = self.state_store.load_state('host')
if saved_host and len(saved_host.keys()) == 1:
self.uuid = saved_host.keys()[0]
host = saved_host[self.uuid]
self.name = host.get('name_label', socket.gethostname())
self.desc = host.get('name_description', '')
self.host_metrics_uuid = host.get('metrics_uuid',
uuid.createString())
try:
self.other_config = eval(host['other_config'])
except:
self.other_config = {}
self.cpus = {}
else:
self.uuid = uuid.createString()
self.name = socket.gethostname()
self.desc = ''
self.other_config = {}
self.cpus = {}
self.host_metrics_uuid = uuid.createString()
# put some arbitrary params in other_config as this
# is directly exposed via XenAPI
self.other_config["xen_pagesize"] = self.xeninfo_dict()["xen_pagesize"]
self.other_config["platform_params"] = self.xeninfo_dict(
)["platform_params"]
self.other_config["xen_commandline"] = self.xeninfo_dict(
)["xen_commandline"]
# load CPU UUIDs
saved_cpus = self.state_store.load_state('cpu')
for cpu_uuid, cpu in saved_cpus.items():
self.cpus[cpu_uuid] = cpu
cpuinfo = osdep.get_cpuinfo()
physinfo = self.physinfo_dict()
cpu_count = physinfo['nr_cpus']
cpu_features = physinfo['hw_caps']
virt_caps = physinfo['virt_caps']
# If the number of CPUs don't match, we should just reinitialise
# the CPU UUIDs.
if cpu_count != len(self.cpus):
self.cpus = {}
for i in range(cpu_count):
u = uuid.createString()
self.cpus[u] = {'uuid': u, 'number': i}
for u in self.cpus.keys():
number = self.cpus[u]['number']
# We can run off the end of the cpuinfo list if domain0 does not
# have #vcpus == #pcpus. In that case we just replicate one that's
# in the hash table.
if not cpuinfo.has_key(number):
number = cpuinfo.keys()[0]
if arch.type == "x86":
self.cpus[u].update({
'host':
self.uuid,
'features':
cpu_features,
'virt_caps':
virt_caps,
'speed':
int(float(cpuinfo[number]['cpu MHz'])),
'vendor':
cpuinfo[number]['vendor_id'],
'modelname':
cpuinfo[number]['model name'],
'stepping':
cpuinfo[number]['stepping'],
'flags':
cpuinfo[number]['flags'],
})
elif arch.type == "ia64":
self.cpus[u].update({
'host':
self.uuid,
'features':
cpu_features,
'speed':
int(float(cpuinfo[number]['cpu MHz'])),
'vendor':
cpuinfo[number]['vendor'],
'modelname':
cpuinfo[number]['family'],
'stepping':
cpuinfo[number]['model'],
'flags':
cpuinfo[number]['features'],
})
else:
self.cpus[u].update({
'host': self.uuid,
'features': cpu_features,
})
self.srs = {}
self._init_networks()
self._init_PIFs()
self._init_SRs()
self._init_PBDs()
self._init_PPCIs()
self._init_PSCSIs()
class XendNode:
"""XendNode - Represents a Domain 0 Host."""
def __init__(self):
"""Initalises the state of all host specific objects such as
* host
* host_CPU
* host_metrics
* PIF
* PIF_metrics
* network
* Storage Repository
* PPCI
* PSCSI
"""
self.xc = xen.lowlevel.xc.xc()
self.state_store = XendStateStore(xendoptions().get_xend_state_path())
self.monitor = XendMonitor()
self.monitor.start()
# load host state from XML file
saved_host = self.state_store.load_state('host')
if saved_host and len(saved_host.keys()) == 1:
self.uuid = saved_host.keys()[0]
host = saved_host[self.uuid]
self.name = host.get('name_label', socket.gethostname())
self.desc = host.get('name_description', '')
self.host_metrics_uuid = host.get('metrics_uuid',
uuid.createString())
try:
self.other_config = eval(host['other_config'])
except:
self.other_config = {}
self.cpus = {}
else:
self.uuid = uuid.createString()
self.name = socket.gethostname()
self.desc = ''
self.other_config = {}
self.cpus = {}
self.host_metrics_uuid = uuid.createString()
# put some arbitrary params in other_config as this
# is directly exposed via XenAPI
self.other_config["xen_pagesize"] = self.xeninfo_dict()["xen_pagesize"]
self.other_config["platform_params"] = self.xeninfo_dict(
)["platform_params"]
self.other_config["xen_commandline"] = self.xeninfo_dict(
)["xen_commandline"]
# load CPU UUIDs
saved_cpus = self.state_store.load_state('cpu')
for cpu_uuid, cpu in saved_cpus.items():
self.cpus[cpu_uuid] = cpu
cpuinfo = osdep.get_cpuinfo()
physinfo = self.physinfo_dict()
cpu_count = physinfo['nr_cpus']
cpu_features = physinfo['hw_caps']
virt_caps = physinfo['virt_caps']
# If the number of CPUs don't match, we should just reinitialise
# the CPU UUIDs.
if cpu_count != len(self.cpus):
self.cpus = {}
for i in range(cpu_count):
u = uuid.createString()
self.cpus[u] = {'uuid': u, 'number': i}
for u in self.cpus.keys():
number = self.cpus[u]['number']
# We can run off the end of the cpuinfo list if domain0 does not
# have #vcpus == #pcpus. In that case we just replicate one that's
# in the hash table.
if not cpuinfo.has_key(number):
number = cpuinfo.keys()[0]
if arch.type == "x86":
self.cpus[u].update({
'host':
self.uuid,
'features':
cpu_features,
'virt_caps':
virt_caps,
'speed':
int(float(cpuinfo[number]['cpu MHz'])),
'vendor':
cpuinfo[number]['vendor_id'],
'modelname':
cpuinfo[number]['model name'],
'stepping':
cpuinfo[number]['stepping'],
'flags':
cpuinfo[number]['flags'],
})
elif arch.type == "ia64":
self.cpus[u].update({
'host':
self.uuid,
'features':
cpu_features,
'speed':
int(float(cpuinfo[number]['cpu MHz'])),
'vendor':
cpuinfo[number]['vendor'],
'modelname':
cpuinfo[number]['family'],
'stepping':
cpuinfo[number]['model'],
'flags':
cpuinfo[number]['features'],
})
else:
self.cpus[u].update({
'host': self.uuid,
'features': cpu_features,
})
self.srs = {}
self._init_networks()
self._init_PIFs()
self._init_SRs()
self._init_PBDs()
self._init_PPCIs()
self._init_PSCSIs()
def _init_networks(self):
# Initialise networks
# First configure ones off disk
saved_networks = self.state_store.load_state('network')
if saved_networks:
for net_uuid, network in saved_networks.items():
try:
XendNetwork.recreate(network, net_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating network %s", net_uuid)
# Next discover any existing bridges and check
# they are not already configured
# 'tmpbridge' is a temporary bridge created by network-bridge script.
# Wait a couple of seconds for it to be renamed.
for i in xrange(20):
bridges = Brctl.get_state().keys()
if 'tmpbridge' in bridges:
time.sleep(0.1)
else:
break
configured_bridges = [
XendAPIStore.get(network_uuid, "network").get_name_label()
for network_uuid in XendNetwork.get_all()
]
unconfigured_bridges = [
bridge for bridge in bridges if bridge not in configured_bridges
]
for unconfigured_bridge in unconfigured_bridges:
if unconfigured_bridge != 'tmpbridge':
XendNetwork.create_phy(unconfigured_bridge)
def _init_PIFs(self):
# Initialise PIFs
# First configure ones off disk
saved_pifs = self.state_store.load_state('pif')
if saved_pifs:
for pif_uuid, pif in saved_pifs.items():
try:
XendPIF.recreate(pif, pif_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PIF %s", pif_uuid)
# Next discover any existing PIFs and check
# they are not already configured
configured_pifs = [
XendAPIStore.get(pif_uuid, "PIF").get_interface_name()
for pif_uuid in XendPIF.get_all()
]
unconfigured_pifs = [(name, mtu, mac)
for name, mtu, mac in linux_get_phy_ifaces()
if name not in configured_pifs]
# Get a mapping from interface to bridge
if_to_br = dict([(i, b) for (b, ifs) in Brctl.get_state().items()
for i in ifs])
for name, mtu, mac in unconfigured_pifs:
# Check PIF is on bridge
# if not, ignore
bridge_name = if_to_br.get(name, None)
if bridge_name is not None:
# Translate bridge name to network uuid
for network_uuid in XendNetwork.get_all():
network = XendAPIStore.get(network_uuid, 'network')
if network.get_name_label() == bridge_name:
XendPIF.create_phy(network_uuid, name, mac, mtu)
break
else:
log.debug(
"Cannot find network for bridge %s "
"when configuring PIF %s", (bridge_name, name))
def _init_SRs(self):
# initialise storage
saved_srs = self.state_store.load_state('sr')
if saved_srs:
for sr_uuid, sr_cfg in saved_srs.items():
if sr_cfg['type'] == 'qcow_file':
self.srs[sr_uuid] = XendQCoWStorageRepo(sr_uuid)
elif sr_cfg['type'] == 'local':
self.srs[sr_uuid] = XendLocalStorageRepo(sr_uuid)
# Create missing SRs if they don't exist
if not self.get_sr_by_type('local'):
image_sr_uuid = uuid.createString()
self.srs[image_sr_uuid] = XendLocalStorageRepo(image_sr_uuid)
if not self.get_sr_by_type('qcow_file'):
qcow_sr_uuid = uuid.createString()
self.srs[qcow_sr_uuid] = XendQCoWStorageRepo(qcow_sr_uuid)
def _init_PBDs(self):
saved_pbds = self.state_store.load_state('pbd')
if saved_pbds:
for pbd_uuid, pbd_cfg in saved_pbds.items():
try:
XendPBD.recreate(pbd_uuid, pbd_cfg)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PBD %s", pbd_uuid)
def _init_PPCIs(self):
saved_ppcis = self.state_store.load_state('ppci')
saved_ppci_table = {}
if saved_ppcis:
for ppci_uuid, ppci_record in saved_ppcis.items():
try:
saved_ppci_table[ppci_record['name']] = ppci_uuid
except KeyError:
pass
for pci_dev in PciUtil.get_all_pci_devices():
ppci_record = {
'domain': pci_dev.domain,
'bus': pci_dev.bus,
'slot': pci_dev.slot,
'func': pci_dev.func,
'vendor_id': pci_dev.vendor,
'vendor_name': pci_dev.vendorname,
'device_id': pci_dev.device,
'device_name': pci_dev.devicename,
'revision_id': pci_dev.revision,
'class_code': pci_dev.classcode,
'class_name': pci_dev.classname,
'subsystem_vendor_id': pci_dev.subvendor,
'subsystem_vendor_name': pci_dev.subvendorname,
'subsystem_id': pci_dev.subdevice,
'subsystem_name': pci_dev.subdevicename,
'driver': pci_dev.driver
}
# If saved uuid exists, use it. Otherwise create one.
ppci_uuid = saved_ppci_table.get(pci_dev.name, uuid.createString())
XendPPCI(ppci_uuid, ppci_record)
def _init_PSCSIs(self):
# Initialise PSCSIs
saved_pscsis = self.state_store.load_state('pscsi')
saved_pscsi_table = {}
if saved_pscsis:
for pscsi_uuid, pscsi_record in saved_pscsis.items():
try:
saved_pscsi_table[pscsi_record['scsi_id']] = pscsi_uuid
except KeyError:
pass
for pscsi_record in vscsi_util.get_all_scsi_devices():
if pscsi_record['scsi_id']:
# If saved uuid exists, use it. Otherwise create one.
pscsi_uuid = saved_pscsi_table.get(pscsi_record['scsi_id'],
uuid.createString())
XendPSCSI(pscsi_uuid, pscsi_record)
def add_network(self, interface):
# TODO
log.debug("add_network(): Not implemented.")
def remove_network(self, interface):
# TODO
log.debug("remove_network(): Not implemented.")
def add_PPCI(self, pci_name):
# Update lspci info
PciUtil.create_lspci_info()
# Initialise the PPCI
saved_ppcis = self.state_store.load_state('ppci')
saved_ppci_table = {}
if saved_ppcis:
for ppci_uuid, ppci_record in saved_ppcis.items():
try:
saved_ppci_table[ppci_record['name']] = ppci_uuid
except KeyError:
pass
pci_dev = PciUtil.PciDevice(PciUtil.parse_pci_name(pci_name))
ppci_record = {
'domain': pci_dev.domain,
'bus': pci_dev.bus,
'slot': pci_dev.slot,
'func': pci_dev.func,
'vendor_id': pci_dev.vendor,
'vendor_name': pci_dev.vendorname,
'device_id': pci_dev.device,
'device_name': pci_dev.devicename,
'revision_id': pci_dev.revision,
'class_code': pci_dev.classcode,
'class_name': pci_dev.classname,
'subsystem_vendor_id': pci_dev.subvendor,
'subsystem_vendor_name': pci_dev.subvendorname,
'subsystem_id': pci_dev.subdevice,
'subsystem_name': pci_dev.subdevicename,
'driver': pci_dev.driver
}
# If saved uuid exists, use it. Otherwise create one.
ppci_uuid = saved_ppci_table.get(pci_dev.name, uuid.createString())
XendPPCI(ppci_uuid, ppci_record)
self.save_PPCIs()
def remove_PPCI(self, pci_name):
# Update lspci info
PciUtil.create_lspci_info()
# Remove the PPCI
(domain, bus, slot, func) = PciUtil.parse_pci_name(pci_name)
ppci_ref = XendPPCI.get_by_sbdf(domain, bus, slot, func)
XendAPIStore.get(ppci_ref, "PPCI").destroy()
self.save_PPCIs()
def add_PSCSI(self, add_HCTL):
saved_pscsis = self.state_store.load_state('pscsi')
saved_pscsi_table = {}
if saved_pscsis:
for saved_uuid, saved_record in saved_pscsis.items():
try:
saved_pscsi_table[saved_record['scsi_id']] = saved_uuid
except KeyError:
pass
# Initialise the PSCSI
pscsi_record = vscsi_util.get_scsi_device(add_HCTL)
if pscsi_record and pscsi_record['scsi_id']:
pscsi_uuid = saved_pscsi_table.get(pscsi_record['scsi_id'], None)
if pscsi_uuid is None:
pscsi_uuid = uuid.createString()
XendPSCSI(pscsi_uuid, pscsi_record)
self.save_PSCSIs()
def remove_PSCSI(self, rem_HCTL):
saved_pscsis = self.state_store.load_state('pscsi')
if not saved_pscsis:
return
# Remove the PSCSI
for pscsi_record in saved_pscsis.values():
if rem_HCTL == pscsi_record['physical_HCTL']:
pscsi_ref = XendPSCSI.get_by_HCTL(rem_HCTL)
XendAPIStore.get(pscsi_ref, "PSCSI").destroy()
self.save_PSCSIs()
return
## def network_destroy(self, net_uuid):
## del self.networks[net_uuid]
## self.save_networks()
def get_PIF_refs(self):
log.debug(XendPIF.get_all())
return XendPIF.get_all()
## def _PIF_create(self, name, mtu, vlan, mac, network, persist = True,
## pif_uuid = None, metrics_uuid = None):
## for pif in self.pifs.values():
## if pif.network == network:
## raise NetworkAlreadyConnected(pif.uuid)
## if pif_uuid is None:
## pif_uuid = uuid.createString()
## if metrics_uuid is None:
## metrics_uuid = uuid.createString()
## metrics = XendPIFMetrics(metrics_uuid)
## pif = XendPIF(pif_uuid, metrics, name, mtu, vlan, mac, network, self)
## metrics.set_PIF(pif)
## self.pif_metrics[metrics_uuid] = metrics
## self.pifs[pif_uuid] = pif
## if persist:
## self.save_PIFs()
## self.refreshBridges()
## return pif_uuid
## def PIF_destroy(self, pif_uuid):
## pif = self.pifs[pif_uuid]
## if pif.vlan == -1:
## raise PIFIsPhysical()
## del self.pifs[pif_uuid]
## self.save_PIFs()
def get_PPCI_refs(self):
return XendPPCI.get_all()
def get_ppci_by_uuid(self, ppci_uuid):
if ppci_uuid in self.get_PPCI_refs():
return ppci_uuid
return None
def get_PSCSI_refs(self):
return XendPSCSI.get_all()
def get_pscsi_by_uuid(self, pscsi_uuid):
if pscsi_uuid in self.get_PSCSI_refs():
return pscsi_uuid
return None
def save(self):
# save state
host_record = {
self.uuid: {
'name_label': self.name,
'name_description': self.desc,
'metrics_uuid': self.host_metrics_uuid,
'other_config': self.other_config
}
}
self.state_store.save_state('host', host_record)
self.state_store.save_state('cpu', self.cpus)
self.save_PIFs()
self.save_networks()
self.save_PBDs()
self.save_SRs()
self.save_PPCIs()
self.save_PSCSIs()
def save_PIFs(self):
pif_records = dict([(pif_uuid, XendAPIStore.get(pif_uuid,
"PIF").get_record())
for pif_uuid in XendPIF.get_all()])
self.state_store.save_state('pif', pif_records)
def save_networks(self):
net_records = dict([(network_uuid,
XendAPIStore.get(network_uuid,
"network").get_record())
for network_uuid in XendNetwork.get_all()])
self.state_store.save_state('network', net_records)
def save_PBDs(self):
pbd_records = dict([(pbd_uuid, XendAPIStore.get(pbd_uuid,
"PBD").get_record())
for pbd_uuid in XendPBD.get_all()])
self.state_store.save_state('pbd', pbd_records)
def save_SRs(self):
sr_records = dict([(k, v.get_record(transient=False))
for k, v in self.srs.items()])
self.state_store.save_state('sr', sr_records)
def save_PPCIs(self):
ppci_records = dict([(ppci_uuid, XendAPIStore.get(ppci_uuid,
"PPCI").get_record())
for ppci_uuid in XendPPCI.get_all()])
self.state_store.save_state('ppci', ppci_records)
def save_PSCSIs(self):
pscsi_records = dict([
(pscsi_uuid, XendAPIStore.get(pscsi_uuid, "PSCSI").get_record())
for pscsi_uuid in XendPSCSI.get_all()
])
self.state_store.save_state('pscsi', pscsi_records)
def shutdown(self):
return 0
def reboot(self):
return 0
def notify(self, _):
return 0
#
# Ref validation
#
def is_valid_host(self, host_ref):
return (host_ref == self.uuid)
def is_valid_cpu(self, cpu_ref):
return (cpu_ref in self.cpus)
def is_valid_sr(self, sr_ref):
return (sr_ref in self.srs)
def is_valid_vdi(self, vdi_ref):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_ref):
return True
return False
#
# Storage Repositories
#
def get_sr(self, sr_uuid):
return self.srs.get(sr_uuid)
def get_sr_by_type(self, sr_type):
return [sr.uuid for sr in self.srs.values() if sr.type == sr_type]
def get_sr_by_name(self, name):
return [sr.uuid for sr in self.srs.values() if sr.name_label == name]
def get_all_sr_uuid(self):
return self.srs.keys()
def get_vdi_by_uuid(self, vdi_uuid):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_uuid):
return sr.get_vdi_by_uuid(vdi_uuid)
return None
def get_vdi_by_name_label(self, name):
for sr in self.srs.values():
vdi = sr.get_vdi_by_name_label(name)
if vdi:
return vdi
return None
def get_sr_containing_vdi(self, vdi_uuid):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_uuid):
return sr
return None
#
# Host Functions
#
def xen_version(self):
info = self.xc.xeninfo()
info = {'Xen': '%(xen_major)d.%(xen_minor)d' % info}
# Add xend_config_format
info.update(self.xendinfo_dict())
# Add version info about machine
info.update(self.nodeinfo_dict())
# Add specific xen version info
xeninfo_dict = self.xeninfo_dict()
info.update({
"xen_major": xeninfo_dict["xen_major"],
"xen_minor": xeninfo_dict["xen_minor"],
"xen_extra": xeninfo_dict["xen_extra"],
"cc_compiler": xeninfo_dict["cc_compiler"],
"cc_compile_by": xeninfo_dict["cc_compile_by"],
"cc_compile_domain": xeninfo_dict["cc_compile_domain"],
"cc_compile_date": xeninfo_dict["cc_compile_date"],
"xen_changeset": xeninfo_dict["xen_changeset"],
"xen_commandline": xeninfo_dict["xen_commandline"]
})
return info
def get_name(self):
return self.name
def set_name(self, new_name):
self.name = new_name
def get_description(self):
return self.desc
def set_description(self, new_desc):
self.desc = new_desc
def get_uuid(self):
return self.uuid
def get_capabilities(self):
return self.xc.xeninfo()['xen_caps'].split(" ")
#
# Host CPU Functions
#
def get_host_cpu_by_uuid(self, host_cpu_uuid):
if host_cpu_uuid in self.cpus:
return host_cpu_uuid
raise XendError('Invalid CPU UUID')
def get_host_cpu_refs(self):
return self.cpus.keys()
def get_host_cpu_uuid(self, host_cpu_ref):
if host_cpu_ref in self.cpus:
return host_cpu_ref
else:
raise XendError('Invalid CPU Reference')
def get_host_cpu_field(self, ref, field):
try:
return self.cpus[ref][field]
except KeyError:
raise XendError('Invalid CPU Reference')
def get_host_cpu_load(self, host_cpu_ref):
host_cpu = self.cpus.get(host_cpu_ref)
if not host_cpu:
return 0.0
vcpu = int(host_cpu['number'])
cpu_loads = self.monitor.get_domain_vcpus_util()
if 0 in cpu_loads and vcpu in cpu_loads[0]:
return cpu_loads[0][vcpu]
return 0.0
def get_vcpus_policy(self):
sched_id = self.xc.sched_id_get()
if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
return 'sedf'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
return 'credit'
else:
return 'unknown'
def get_cpu_configuration(self):
phys_info = self.physinfo_dict()
cpu_info = {
"nr_nodes": phys_info["nr_nodes"],
"nr_cpus": phys_info["nr_cpus"],
"cores_per_socket": phys_info["cores_per_socket"],
"threads_per_core": phys_info["threads_per_core"]
}
return cpu_info
#
# Network Functions
#
def bridge_to_network(self, bridge):
"""
Determine which network a particular bridge is attached to.
@param bridge The name of the bridge. If empty, the default bridge
will be used instead (the first one in the list returned by brctl
show); this is the behaviour of the vif-bridge script.
@return The XendNetwork instance to which this bridge is attached.
@raise Exception if the interface is not connected to a network.
"""
if not bridge:
rc, bridge = commands.getstatusoutput(
'brctl show | cut -d "\n" -f 2 | cut -f 1')
if rc != 0 or not bridge:
raise Exception(
'Could not find default bridge, and none was specified')
for network_uuid in XendNetwork.get_all():
network = XendAPIStore.get(network_uuid, "network")
if network.get_name_label() == bridge:
return network
else:
raise Exception('Cannot find network for bridge %s' % bridge)
#
# Debug keys.
#
def send_debug_keys(self, keys):
return self.xc.send_debug_keys(keys)
#
# Getting host information.
#
def info(self):
return (self.nodeinfo() + self.physinfo() + self.xeninfo() +
self.xendinfo())
def nodeinfo(self):
(sys, host, rel, ver, mch) = os.uname()
return [['system', sys], ['host', host], ['release', rel],
['version', ver], ['machine', mch]]
def list_to_rangepairs(self, cmap):
cmap.sort()
pairs = []
x = y = 0
for i in range(0, len(cmap)):
try:
if ((cmap[y + 1] - cmap[i]) > 1):
pairs.append((cmap[x], cmap[y]))
x = y = i + 1
else:
y = y + 1
# if we go off the end, then just add x to y
except IndexError:
pairs.append((cmap[x], cmap[y]))
return pairs
def format_pairs(self, pairs):
if not pairs:
return "no cpus"
out = ""
for f, s in pairs:
if (f == s):
out += '%d' % f
else:
out += '%d-%d' % (f, s)
out += ','
# trim trailing ','
return out[:-1]
def list_to_strrange(self, list):
return self.format_pairs(self.list_to_rangepairs(list))
def format_node_to_cpu(self, pinfo):
str = ''
whitespace = ''
try:
node_to_cpu = pinfo['node_to_cpu']
for i in range(0, pinfo['nr_nodes']):
str += '%snode%d:%s\n' % (
whitespace, i, self.list_to_strrange(node_to_cpu[i]))
whitespace = '%25s' % ''
except:
str = 'none\n'
return str[:-1]
def format_node_to_memory(self, pinfo):
str = ''
whitespace = ''
try:
node_to_memory = pinfo['node_to_memory']
for i in range(0, pinfo['nr_nodes']):
str += '%snode%d:%d\n' % (whitespace, i,
node_to_memory[i] / 1024)
whitespace = '%25s' % ''
except:
str = 'none\n'
return str[:-1]
def physinfo(self):
info = self.xc.physinfo()
info['cpu_mhz'] = info['cpu_khz'] / 1000
# physinfo is in KiB, need it in MiB
info['total_memory'] = info['total_memory'] / 1024
info['free_memory'] = info['free_memory'] / 1024
info['node_to_cpu'] = self.format_node_to_cpu(info)
info['node_to_memory'] = self.format_node_to_memory(info)
ITEM_ORDER = [
'nr_cpus', 'nr_nodes', 'cores_per_socket', 'threads_per_core',
'cpu_mhz', 'hw_caps', 'virt_caps', 'total_memory', 'free_memory',
'node_to_cpu', 'node_to_memory'
]
return [[k, info[k]] for k in ITEM_ORDER]
def pciinfo(self):
# Each element of dev_list is a PciDevice
dev_list = PciUtil.find_all_assignable_devices()
# Each element of devs_list is a list of PciDevice
devs_list = PciUtil.check_FLR_capability(dev_list)
devs_list = PciUtil.check_mmio_bar(devs_list)
# Check if the devices have been assigned to guests.
final_devs_list = []
for dev_list in devs_list:
available = True
for d in dev_list:
pci_str = '0x%x,0x%x,0x%x,0x%x' % (d.domain, d.bus, d.slot,
d.func)
# Xen doesn't care what the domid is, so we pass 0 here...
domid = 0
bdf = self.xc.test_assign_device(domid, pci_str)
if bdf != 0:
available = False
break
if available:
final_devs_list = final_devs_list + [dev_list]
pci_sxp_list = []
for dev_list in final_devs_list:
for d in dev_list:
pci_sxp = [
'dev', ['domain', '0x%04x' % d.domain],
['bus', '0x%02x' % d.bus], ['slot',
'0x%02x' % d.slot],
['func', '0x%x' % d.func]
]
pci_sxp_list.append(pci_sxp)
return pci_sxp_list
def xenschedinfo(self):
sched_id = self.xc.sched_id_get()
if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
return 'sedf'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
return 'credit'
else:
return 'unknown'
def xeninfo(self):
info = self.xc.xeninfo()
info['xen_scheduler'] = self.xenschedinfo()
ITEM_ORDER = [
'xen_major',
'xen_minor',
'xen_extra',
'xen_caps',
'xen_scheduler',
'xen_pagesize',
'platform_params',
'xen_changeset',
'xen_commandline',
'cc_compiler',
'cc_compile_by',
'cc_compile_domain',
'cc_compile_date',
]
return [[k, info[k]] for k in ITEM_ORDER]
def xendinfo(self):
return [['xend_config_format', 4]]
#
# utilisation tracking
#
def get_vcpu_util(self, domid, vcpuid):
cpu_loads = self.monitor.get_domain_vcpus_util()
if domid in cpu_loads:
return cpu_loads[domid].get(vcpuid, 0.0)
return 0.0
def get_vif_util(self, domid, vifid):
vif_loads = self.monitor.get_domain_vifs_util()
if domid in vif_loads:
return vif_loads[domid].get(vifid, (0.0, 0.0))
return (0.0, 0.0)
def get_vif_stat(self, domid, vifid):
vif_loads = self.monitor.get_domain_vifs_stat()
if domid in vif_loads:
return vif_loads[domid].get(vifid, (0.0, 0.0))
return (0.0, 0.0)
def get_vbd_util(self, domid, vbdid):
vbd_loads = self.monitor.get_domain_vbds_util()
if domid in vbd_loads:
return vbd_loads[domid].get(vbdid, (0.0, 0.0))
return (0.0, 0.0)
# dictionary version of *info() functions to get rid of
# SXPisms.
def nodeinfo_dict(self):
return dict(self.nodeinfo())
def xendinfo_dict(self):
return dict(self.xendinfo())
def xeninfo_dict(self):
return dict(self.xeninfo())
def physinfo_dict(self):
return dict(self.physinfo())
def info_dict(self):
return dict(self.info())
# tmem
def tmem_list(self, cli_id, use_long):
pool_id = -1
subop = TMEMC_LIST
arg1 = 32768
arg2 = use_long
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def tmem_thaw(self, cli_id):
pool_id = -1
subop = TMEMC_THAW
arg1 = 0
arg2 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def tmem_freeze(self, cli_id):
pool_id = -1
subop = TMEMC_FREEZE
arg1 = 0
arg2 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def tmem_flush(self, cli_id, pages):
pool_id = -1
subop = TMEMC_FLUSH
arg1 = pages
arg2 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def tmem_destroy(self, cli_id):
pool_id = -1
subop = TMEMC_DESTROY
arg1 = 0
arg2 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def tmem_set_weight(self, cli_id, arg1):
pool_id = -1
subop = TMEMC_SET_WEIGHT
arg2 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def tmem_set_cap(self, cli_id, arg1):
pool_id = -1
subop = TMEMC_SET_CAP
arg2 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def tmem_set_compress(self, cli_id, arg1):
pool_id = -1
subop = TMEMC_SET_COMPRESS
arg2 = 0
buf = ''
return self.xc.tmem_control(pool_id, subop, cli_id, arg1, arg2, buf)
def __init__(self):
"""Initalises the state of all host specific objects such as
* host
* host_CPU
* host_metrics
* PIF
* PIF_metrics
* network
* Storage Repository
* PPCI
"""
self.xc = xen.lowlevel.xc.xc()
self.state_store = XendStateStore(xendoptions().get_xend_state_path())
self.monitor = XendMonitor()
self.monitor.start()
# load host state from XML file
saved_host = self.state_store.load_state('host')
if saved_host and len(saved_host.keys()) == 1:
self.uuid = saved_host.keys()[0]
host = saved_host[self.uuid]
self.name = host.get('name_label', socket.gethostname())
self.desc = host.get('name_description', '')
self.host_metrics_uuid = host.get('metrics_uuid',
uuid.createString())
try:
self.other_config = eval(host['other_config'])
except:
self.other_config = {}
self.cpus = {}
else:
self.uuid = uuid.createString()
self.name = socket.gethostname()
self.desc = ''
self.other_config = {}
self.cpus = {}
self.host_metrics_uuid = uuid.createString()
# put some arbitrary params in other_config as this
# is directly exposed via XenAPI
self.other_config["xen_pagesize"] = self.xeninfo_dict()["xen_pagesize"]
self.other_config["platform_params"] = self.xeninfo_dict(
)["platform_params"]
# load CPU UUIDs
saved_cpus = self.state_store.load_state('cpu')
for cpu_uuid, cpu in saved_cpus.items():
self.cpus[cpu_uuid] = cpu
cpuinfo = osdep.get_cpuinfo()
physinfo = self.physinfo_dict()
cpu_count = physinfo['nr_cpus']
cpu_features = physinfo['hw_caps']
virt_caps = physinfo['virt_caps']
# If the number of CPUs don't match, we should just reinitialise
# the CPU UUIDs.
if cpu_count != len(self.cpus):
self.cpus = {}
for i in range(cpu_count):
u = uuid.createString()
self.cpus[u] = {'uuid': u, 'number': i}
for u in self.cpus.keys():
number = self.cpus[u]['number']
# We can run off the end of the cpuinfo list if domain0 does not
# have #vcpus == #pcpus. In that case we just replicate one that's
# in the hash table.
if not cpuinfo.has_key(number):
number = cpuinfo.keys()[0]
if arch.type == "x86":
self.cpus[u].update({
'host':
self.uuid,
'features':
cpu_features,
'virt_caps':
virt_caps,
'speed':
int(float(cpuinfo[number]['cpu MHz'])),
'vendor':
cpuinfo[number]['vendor_id'],
'modelname':
cpuinfo[number]['model name'],
'stepping':
cpuinfo[number]['stepping'],
'flags':
cpuinfo[number]['flags'],
})
elif arch.type == "ia64":
self.cpus[u].update({
'host':
self.uuid,
'features':
cpu_features,
'speed':
int(float(cpuinfo[number]['cpu MHz'])),
'vendor':
cpuinfo[number]['vendor'],
'modelname':
cpuinfo[number]['family'],
'stepping':
cpuinfo[number]['model'],
'flags':
cpuinfo[number]['features'],
})
else:
self.cpus[u].update({
'host': self.uuid,
'features': cpu_features,
})
self.srs = {}
# Initialise networks
# First configure ones off disk
saved_networks = self.state_store.load_state('network')
if saved_networks:
for net_uuid, network in saved_networks.items():
try:
XendNetwork.recreate(network, net_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating network %s", net_uuid)
# Next discover any existing bridges and check
# they are not already configured
bridges = Brctl.get_state().keys()
configured_bridges = [
XendAPIStore.get(network_uuid, "network").get_name_label()
for network_uuid in XendNetwork.get_all()
]
unconfigured_bridges = [
bridge for bridge in bridges if bridge not in configured_bridges
]
for unconfigured_bridge in unconfigured_bridges:
XendNetwork.create_phy(unconfigured_bridge)
# Initialise PIFs
# First configure ones off disk
saved_pifs = self.state_store.load_state('pif')
if saved_pifs:
for pif_uuid, pif in saved_pifs.items():
try:
XendPIF.recreate(pif, pif_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PIF %s", pif_uuid)
# Next discover any existing PIFs and check
# they are not already configured
configured_pifs = [
XendAPIStore.get(pif_uuid, "PIF").get_interface_name()
for pif_uuid in XendPIF.get_all()
]
unconfigured_pifs = [(name, mtu, mac)
for name, mtu, mac in linux_get_phy_ifaces()
if name not in configured_pifs]
# Get a mapping from interface to bridge
if_to_br = dict([(i, b) for (b, ifs) in Brctl.get_state().items()
for i in ifs])
for name, mtu, mac in unconfigured_pifs:
# Check PIF is on bridge
# if not, ignore
bridge_name = if_to_br.get(name, None)
if bridge_name is not None:
# Translate bridge name to network uuid
for network_uuid in XendNetwork.get_all():
network = XendAPIStore.get(network_uuid, 'network')
if network.get_name_label() == bridge_name:
XendPIF.create_phy(network_uuid, name, mac, mtu)
break
else:
log.debug(
"Cannot find network for bridge %s "
"when configuring PIF %s", (bridge_name, name))
# initialise storage
saved_srs = self.state_store.load_state('sr')
if saved_srs:
for sr_uuid, sr_cfg in saved_srs.items():
if sr_cfg['type'] == 'qcow_file':
self.srs[sr_uuid] = XendQCoWStorageRepo(sr_uuid)
elif sr_cfg['type'] == 'local':
self.srs[sr_uuid] = XendLocalStorageRepo(sr_uuid)
# Create missing SRs if they don't exist
if not self.get_sr_by_type('local'):
image_sr_uuid = uuid.createString()
self.srs[image_sr_uuid] = XendLocalStorageRepo(image_sr_uuid)
if not self.get_sr_by_type('qcow_file'):
qcow_sr_uuid = uuid.createString()
self.srs[qcow_sr_uuid] = XendQCoWStorageRepo(qcow_sr_uuid)
saved_pbds = self.state_store.load_state('pbd')
if saved_pbds:
for pbd_uuid, pbd_cfg in saved_pbds.items():
try:
XendPBD.recreate(pbd_uuid, pbd_cfg)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PBD %s", pbd_uuid)
# Initialise PPCIs
saved_ppcis = self.state_store.load_state('ppci')
saved_ppci_table = {}
if saved_ppcis:
for ppci_uuid, ppci_record in saved_ppcis.items():
try:
saved_ppci_table[ppci_record['name']] = ppci_uuid
except KeyError:
pass
for pci_dev in PciUtil.get_all_pci_devices():
ppci_record = {
'domain': pci_dev.domain,
'bus': pci_dev.bus,
'slot': pci_dev.slot,
'func': pci_dev.func,
'vendor_id': pci_dev.vendor,
'vendor_name': pci_dev.vendorname,
'device_id': pci_dev.device,
'device_name': pci_dev.devicename,
'revision_id': pci_dev.revision,
'class_code': pci_dev.classcode,
'class_name': pci_dev.classname,
'subsystem_vendor_id': pci_dev.subvendor,
'subsystem_vendor_name': pci_dev.subvendorname,
'subsystem_id': pci_dev.subdevice,
'subsystem_name': pci_dev.subdevicename,
'driver': pci_dev.driver
}
# If saved uuid exists, use it. Otherwise create one.
ppci_uuid = saved_ppci_table.get(pci_dev.name, uuid.createString())
XendPPCI(ppci_uuid, ppci_record)
class XendNode:
"""XendNode - Represents a Domain 0 Host."""
def __init__(self):
"""Initalises the state of all host specific objects such as
* host
* host_CPU
* host_metrics
* PIF
* PIF_metrics
* network
* Storage Repository
"""
self.xc = xen.lowlevel.xc.xc()
self.state_store = XendStateStore(xendoptions().get_xend_state_path())
self.monitor = XendMonitor()
self.monitor.start()
# load host state from XML file
saved_host = self.state_store.load_state('host')
if saved_host and len(saved_host.keys()) == 1:
self.uuid = saved_host.keys()[0]
host = saved_host[self.uuid]
self.name = host.get('name_label', socket.gethostname())
self.desc = host.get('name_description', '')
self.host_metrics_uuid = host.get('metrics_uuid',
uuid.createString())
try:
self.other_config = eval(host['other_config'])
except:
self.other_config = {}
self.cpus = {}
else:
self.uuid = uuid.createString()
self.name = socket.gethostname()
self.desc = ''
self.other_config = {}
self.cpus = {}
self.host_metrics_uuid = uuid.createString()
# put some arbitrary params in other_config as this
# is directly exposed via XenAPI
self.other_config["xen_pagesize"] = self.xeninfo_dict()["xen_pagesize"]
self.other_config["platform_params"] = self.xeninfo_dict()["platform_params"]
# load CPU UUIDs
saved_cpus = self.state_store.load_state('cpu')
for cpu_uuid, cpu in saved_cpus.items():
self.cpus[cpu_uuid] = cpu
cpuinfo = parse_proc_cpuinfo()
physinfo = self.physinfo_dict()
cpu_count = physinfo['nr_cpus']
cpu_features = physinfo['hw_caps']
# If the number of CPUs don't match, we should just reinitialise
# the CPU UUIDs.
if cpu_count != len(self.cpus):
self.cpus = {}
for i in range(cpu_count):
u = uuid.createString()
self.cpus[u] = {'uuid': u, 'number': i }
for u in self.cpus.keys():
number = self.cpus[u]['number']
# We can run off the end of the cpuinfo list if domain0 does not
# have #vcpus == #pcpus. In that case we just replicate one that's
# in the hash table.
if not cpuinfo.has_key(number):
number = cpuinfo.keys()[0]
if arch.type == "x86":
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
'speed' : int(float(cpuinfo[number]['cpu MHz'])),
'vendor' : cpuinfo[number]['vendor_id'],
'modelname': cpuinfo[number]['model name'],
'stepping' : cpuinfo[number]['stepping'],
'flags' : cpuinfo[number]['flags'],
})
elif arch.type == "ia64":
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
'speed' : int(float(cpuinfo[number]['cpu MHz'])),
'vendor' : cpuinfo[number]['vendor'],
'modelname': cpuinfo[number]['family'],
'stepping' : cpuinfo[number]['model'],
'flags' : cpuinfo[number]['features'],
})
else:
self.cpus[u].update(
{ 'host' : self.uuid,
'features' : cpu_features,
})
self.srs = {}
# Initialise networks
# First configure ones off disk
saved_networks = self.state_store.load_state('network')
if saved_networks:
for net_uuid, network in saved_networks.items():
try:
XendNetwork.recreate(network, net_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating network %s", net_uuid)
# Next discover any existing bridges and check
# they are not already configured
bridges = Brctl.get_state().keys()
configured_bridges = [XendAPIStore.get(
network_uuid, "network")
.get_name_label()
for network_uuid in XendNetwork.get_all()]
unconfigured_bridges = [bridge
for bridge in bridges
if bridge not in configured_bridges]
for unconfigured_bridge in unconfigured_bridges:
XendNetwork.create_phy(unconfigured_bridge)
# Initialise PIFs
# First configure ones off disk
saved_pifs = self.state_store.load_state('pif')
if saved_pifs:
for pif_uuid, pif in saved_pifs.items():
try:
XendPIF.recreate(pif, pif_uuid)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PIF %s", pif_uuid)
# Next discover any existing PIFs and check
# they are not already configured
configured_pifs = [XendAPIStore.get(
pif_uuid, "PIF")
.get_interface_name()
for pif_uuid in XendPIF.get_all()]
unconfigured_pifs = [(name, mtu, mac)
for name, mtu, mac in linux_get_phy_ifaces()
if name not in configured_pifs]
# Get a mapping from interface to bridge
if_to_br = dict([(i,b)
for (b,ifs) in Brctl.get_state().items()
for i in ifs])
for name, mtu, mac in unconfigured_pifs:
# Check PIF is on bridge
# if not, ignore
bridge_name = if_to_br.get(name, None)
if bridge_name is not None:
# Translate bridge name to network uuid
for network_uuid in XendNetwork.get_all():
network = XendAPIStore.get(
network_uuid, 'network')
if network.get_name_label() == bridge_name:
XendPIF.create_phy(network_uuid, name,
mac, mtu)
break
else:
log.debug("Cannot find network for bridge %s "
"when configuring PIF %s",
(bridge_name, name))
# initialise storage
saved_srs = self.state_store.load_state('sr')
if saved_srs:
for sr_uuid, sr_cfg in saved_srs.items():
if sr_cfg['type'] == 'qcow_file':
self.srs[sr_uuid] = XendQCoWStorageRepo(sr_uuid)
elif sr_cfg['type'] == 'local':
self.srs[sr_uuid] = XendLocalStorageRepo(sr_uuid)
# Create missing SRs if they don't exist
if not self.get_sr_by_type('local'):
image_sr_uuid = uuid.createString()
self.srs[image_sr_uuid] = XendLocalStorageRepo(image_sr_uuid)
if not self.get_sr_by_type('qcow_file'):
qcow_sr_uuid = uuid.createString()
self.srs[qcow_sr_uuid] = XendQCoWStorageRepo(qcow_sr_uuid)
saved_pbds = self.state_store.load_state('pbd')
if saved_pbds:
for pbd_uuid, pbd_cfg in saved_pbds.items():
try:
XendPBD.recreate(pbd_uuid, pbd_cfg)
except CreateUnspecifiedAttributeError:
log.warn("Error recreating PBD %s", pbd_uuid)
## def network_destroy(self, net_uuid):
## del self.networks[net_uuid]
## self.save_networks()
def get_PIF_refs(self):
log.debug(XendPIF.get_all())
return XendPIF.get_all()
## def _PIF_create(self, name, mtu, vlan, mac, network, persist = True,
## pif_uuid = None, metrics_uuid = None):
## for pif in self.pifs.values():
## if pif.network == network:
## raise NetworkAlreadyConnected(pif.uuid)
## if pif_uuid is None:
## pif_uuid = uuid.createString()
## if metrics_uuid is None:
## metrics_uuid = uuid.createString()
## metrics = XendPIFMetrics(metrics_uuid)
## pif = XendPIF(pif_uuid, metrics, name, mtu, vlan, mac, network, self)
## metrics.set_PIF(pif)
## self.pif_metrics[metrics_uuid] = metrics
## self.pifs[pif_uuid] = pif
## if persist:
## self.save_PIFs()
## self.refreshBridges()
## return pif_uuid
## def PIF_destroy(self, pif_uuid):
## pif = self.pifs[pif_uuid]
## if pif.vlan == -1:
## raise PIFIsPhysical()
## del self.pifs[pif_uuid]
## self.save_PIFs()
def save(self):
# save state
host_record = {self.uuid: {'name_label':self.name,
'name_description':self.desc,
'metrics_uuid': self.host_metrics_uuid,
'other_config': self.other_config}}
self.state_store.save_state('host',host_record)
self.state_store.save_state('cpu', self.cpus)
self.save_PIFs()
self.save_networks()
self.save_PBDs()
self.save_SRs()
def save_PIFs(self):
pif_records = dict([(pif_uuid, XendAPIStore.get(
pif_uuid, "PIF").get_record())
for pif_uuid in XendPIF.get_all()])
self.state_store.save_state('pif', pif_records)
def save_networks(self):
net_records = dict([(network_uuid, XendAPIStore.get(
network_uuid, "network").get_record())
for network_uuid in XendNetwork.get_all()])
self.state_store.save_state('network', net_records)
def save_PBDs(self):
pbd_records = dict([(pbd_uuid, XendAPIStore.get(
pbd_uuid, "PBD").get_record())
for pbd_uuid in XendPBD.get_all()])
self.state_store.save_state('pbd', pbd_records)
def save_SRs(self):
sr_records = dict([(k, v.get_record(transient = False))
for k, v in self.srs.items()])
self.state_store.save_state('sr', sr_records)
def shutdown(self):
return 0
def reboot(self):
return 0
def notify(self, _):
return 0
#
# Ref validation
#
def is_valid_host(self, host_ref):
return (host_ref == self.uuid)
def is_valid_cpu(self, cpu_ref):
return (cpu_ref in self.cpus)
def is_valid_sr(self, sr_ref):
return (sr_ref in self.srs)
def is_valid_vdi(self, vdi_ref):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_ref):
return True
return False
#
# Storage Repositories
#
def get_sr(self, sr_uuid):
return self.srs.get(sr_uuid)
def get_sr_by_type(self, sr_type):
return [sr.uuid for sr in self.srs.values() if sr.type == sr_type]
def get_sr_by_name(self, name):
return [sr.uuid for sr in self.srs.values() if sr.name_label == name]
def get_all_sr_uuid(self):
return self.srs.keys()
def get_vdi_by_uuid(self, vdi_uuid):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_uuid):
return sr.get_vdi_by_uuid(vdi_uuid)
return None
def get_vdi_by_name_label(self, name):
for sr in self.srs.values():
vdi = sr.get_vdi_by_name_label(name)
if vdi:
return vdi
return None
def get_sr_containing_vdi(self, vdi_uuid):
for sr in self.srs.values():
if sr.is_valid_vdi(vdi_uuid):
return sr
return None
#
# Host Functions
#
def xen_version(self):
info = self.xc.xeninfo()
try:
from xen import VERSION
info = {'Xen': '%(xen_major)d.%(xen_minor)d' % info,
'Xend': VERSION}
except (ImportError, AttributeError):
info = {'Xen': '%(xen_major)d.%(xen_minor)d' % info,
'Xend': '3.0.3'}
# Add xend_config_format
info.update(self.xendinfo_dict())
# Add version info about machine
info.update(self.nodeinfo_dict())
# Add specific xen version info
xeninfo_dict = self.xeninfo_dict()
info.update({
"xen_major": xeninfo_dict["xen_major"],
"xen_minor": xeninfo_dict["xen_minor"],
"xen_extra": xeninfo_dict["xen_extra"],
"cc_compiler": xeninfo_dict["cc_compiler"],
"cc_compile_by": xeninfo_dict["cc_compile_by"],
"cc_compile_domain": xeninfo_dict["cc_compile_domain"],
"cc_compile_date": xeninfo_dict["cc_compile_date"],
"xen_changeset": xeninfo_dict["xen_changeset"]
})
return info
def get_name(self):
return self.name
def set_name(self, new_name):
self.name = new_name
def get_description(self):
return self.desc
def set_description(self, new_desc):
self.desc = new_desc
def get_uuid(self):
return self.uuid
def get_capabilities(self):
return self.xc.xeninfo()['xen_caps'].split(" ")
#
# Host CPU Functions
#
def get_host_cpu_by_uuid(self, host_cpu_uuid):
if host_cpu_uuid in self.cpus:
return host_cpu_uuid
raise XendError('Invalid CPU UUID')
def get_host_cpu_refs(self):
return self.cpus.keys()
def get_host_cpu_uuid(self, host_cpu_ref):
if host_cpu_ref in self.cpus:
return host_cpu_ref
else:
raise XendError('Invalid CPU Reference')
def get_host_cpu_field(self, ref, field):
try:
return self.cpus[ref][field]
except KeyError:
raise XendError('Invalid CPU Reference')
def get_host_cpu_load(self, host_cpu_ref):
host_cpu = self.cpus.get(host_cpu_ref)
if not host_cpu:
return 0.0
vcpu = int(host_cpu['number'])
cpu_loads = self.monitor.get_domain_vcpus_util()
if 0 in cpu_loads and vcpu in cpu_loads[0]:
return cpu_loads[0][vcpu]
return 0.0
def get_vcpus_policy(self):
sched_id = self.xc.sched_id_get()
if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
return 'sedf'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
return 'credit'
else:
return 'unknown'
def get_cpu_configuration(self):
phys_info = self.physinfo_dict()
cpu_info = {
"nr_nodes": phys_info["nr_nodes"],
"nr_cpus": phys_info["nr_cpus"],
"cores_per_socket": phys_info["cores_per_socket"],
"threads_per_core": phys_info["threads_per_core"]
}
return cpu_info
#
# Network Functions
#
def bridge_to_network(self, bridge):
"""
Determine which network a particular bridge is attached to.
@param bridge The name of the bridge. If empty, the default bridge
will be used instead (the first one in the list returned by brctl
show); this is the behaviour of the vif-bridge script.
@return The XendNetwork instance to which this bridge is attached.
@raise Exception if the interface is not connected to a network.
"""
if not bridge:
rc, bridge = commands.getstatusoutput(
'brctl show | cut -d "\n" -f 2 | cut -f 1')
if rc != 0 or not bridge:
raise Exception(
'Could not find default bridge, and none was specified')
for network_uuid in XendNetwork.get_all():
network = XendAPIStore.get(network_uuid, "network")
if network.get_name_label() == bridge:
return network
else:
raise Exception('Cannot find network for bridge %s' % bridge)
#
# Debug keys.
#
def send_debug_keys(self, keys):
return self.xc.send_debug_keys(keys)
#
# Getting host information.
#
def info(self):
return (self.nodeinfo() + self.physinfo() + self.xeninfo() +
self.xendinfo())
def nodeinfo(self):
(sys, host, rel, ver, mch) = os.uname()
return [['system', sys],
['host', host],
['release', rel],
['version', ver],
['machine', mch]]
def list_to_rangepairs(self,cmap):
cmap.sort()
pairs = []
x = y = 0
for i in range(0,len(cmap)):
try:
if ((cmap[y+1] - cmap[i]) > 1):
pairs.append((cmap[x],cmap[y]))
x = y = i+1
else:
y = y + 1
# if we go off the end, then just add x to y
except IndexError:
pairs.append((cmap[x],cmap[y]))
return pairs
def format_pairs(self,pairs):
if not pairs:
return "no cpus"
out = ""
for f,s in pairs:
if (f==s):
out += '%d'%f
else:
out += '%d-%d'%(f,s)
out += ','
# trim trailing ','
return out[:-1]
def list_to_strrange(self,list):
return self.format_pairs(self.list_to_rangepairs(list))
def format_node_to_cpu(self, pinfo):
str=''
whitespace=''
try:
node_to_cpu=pinfo['node_to_cpu']
for i in range(0, pinfo['nr_nodes']):
str+='%snode%d:%s\n' % (whitespace,
i,
self.list_to_strrange(node_to_cpu[i]))
whitespace='%25s' % ''
except:
str='none\n'
return str[:-1];
def physinfo(self):
info = self.xc.physinfo()
info['cpu_mhz'] = info['cpu_khz'] / 1000
# physinfo is in KiB, need it in MiB
info['total_memory'] = info['total_memory'] / 1024
info['free_memory'] = info['free_memory'] / 1024
info['node_to_cpu'] = self.format_node_to_cpu(info)
ITEM_ORDER = ['nr_cpus',
'nr_nodes',
'cores_per_socket',
'threads_per_core',
'cpu_mhz',
'hw_caps',
'total_memory',
'free_memory',
'node_to_cpu'
]
return [[k, info[k]] for k in ITEM_ORDER]
def xenschedinfo(self):
sched_id = self.xc.sched_id_get()
if sched_id == xen.lowlevel.xc.XEN_SCHEDULER_SEDF:
return 'sedf'
elif sched_id == xen.lowlevel.xc.XEN_SCHEDULER_CREDIT:
return 'credit'
else:
return 'unknown'
def xeninfo(self):
info = self.xc.xeninfo()
info['xen_scheduler'] = self.xenschedinfo()
ITEM_ORDER = ['xen_major',
'xen_minor',
'xen_extra',
'xen_caps',
'xen_scheduler',
'xen_pagesize',
'platform_params',
'xen_changeset',
'cc_compiler',
'cc_compile_by',
'cc_compile_domain',
'cc_compile_date',
]
return [[k, info[k]] for k in ITEM_ORDER]
def xendinfo(self):
return [['xend_config_format', 4]]
#
# utilisation tracking
#
def get_vcpu_util(self, domid, vcpuid):
cpu_loads = self.monitor.get_domain_vcpus_util()
if domid in cpu_loads:
return cpu_loads[domid].get(vcpuid, 0.0)
return 0.0
def get_vif_util(self, domid, vifid):
vif_loads = self.monitor.get_domain_vifs_util()
if domid in vif_loads:
return vif_loads[domid].get(vifid, (0.0, 0.0))
return (0.0, 0.0)
def get_vif_stat(self, domid, vifid):
vif_loads = self.monitor.get_domain_vifs_stat()
if domid in vif_loads:
return vif_loads[domid].get(vifid, (0.0, 0.0))
return (0.0, 0.0)
def get_vbd_util(self, domid, vbdid):
vbd_loads = self.monitor.get_domain_vbds_util()
if domid in vbd_loads:
return vbd_loads[domid].get(vbdid, (0.0, 0.0))
return (0.0, 0.0)
# dictionary version of *info() functions to get rid of
# SXPisms.
def nodeinfo_dict(self):
return dict(self.nodeinfo())
def xendinfo_dict(self):
return dict(self.xendinfo())
def xeninfo_dict(self):
return dict(self.xeninfo())
def physinfo_dict(self):
return dict(self.physinfo())
def info_dict(self):
return dict(self.info())
