def change_xenstore(self, action, device, major, minor): for type in DEVICE_TYPES: path = self.dbpath + '/' + type domains = xstransact.List(path) log.debug('domains: %s', domains) for domain in domains: # for each domain devices = xstransact.List(path + '/' + domain) log.debug('devices: %s', devices) for device in devices: # for each vbd device str = device.split('/') vbd_type = None vbd_physical_device = None vbd_media = None vbd_device_path = path + '/' + domain + '/' + device listing = xstransact.List(vbd_device_path) for entry in listing: # for each entry item = path + '/' + entry value = xstransact.Read(vbd_device_path + '/' + entry) log.debug('%s=%s', item, value) if item.find('media-present') != -1: vbd_media = item vbd_media_path = item if item.find('physical-device') != -1: vbd_physical_device = value if item.find('type') != -1: vbd_type = value if vbd_type is not None and vbd_physical_device is not None and vbd_media is not None: inode = vbd_physical_device.split(':') imajor = parse_hex(inode[0]) iminor = parse_hex(inode[1]) log.debug( "action:%s major:%s- minor:%s- imajor:%s- iminor:%s- inode: %s", action, major, minor, imajor, iminor, inode) if int(imajor) == int(major) and int(iminor) == int( minor): if action == "add": xs_dict = {'media': "1"} xstransact.Write(vbd_device_path, 'media-present', "1") log.debug( "wrote xenstore media-present 1 path:%s", vbd_media_path) else: xstransact.Write(vbd_device_path, 'media-present', "0") log.debug("wrote xenstore media 0 path:%s", vbd_media_path)
def recreate_active_pools(cls): """ Read active pool config from hypervisor and create pool instances. - Query pool ids and assigned CPUs from hypervisor. - Query additional information for any pool from xenstore. If an entry for a pool id is missing in xenstore, it will be recreated with a new uuid and generic name (this is an error case) - Create an XendCPUPool instance for any pool id Function have to be called after recreation of managed pools. """ log.debug('recreate_active_pools') for pool_rec in xc.cpupool_getinfo(): pool = pool_rec['cpupool'] # read pool data from xenstore path = XS_POOLROOT + "%s/" % pool uuid = xstransact.Read(path, 'uuid') if not uuid: # xenstore entry missing / invaild; create entry with new uuid uuid = genuuid.createString() name = "Pool-%s" % pool try: inst = XendCPUPool({'name_label': name}, uuid, False) inst.update_XS(pool) except PoolError, ex: # log error and skip domain log.error('cannot recreate pool %s; skipping (reason: %s)' \ % (name, ex)) else: (name, descr) = xstransact.Read(path, 'name', 'description') other_config = {} for key in xstransact.List(path + 'other_config'): other_config[key] = xstransact.Read(path + 'other_config/%s' % key) # check existance of pool instance inst = XendAPIStore.get(uuid, cls.getClass()) if inst: # update attributes of existing instance inst.name_label = name inst.name_description = descr inst.other_config = other_config else: # recreate instance try: inst = XendCPUPool( { 'name_label': name, 'name_description': descr, 'other_config': other_config, 'proposed_CPUs': pool_rec['cpulist'], 'ncpu': len(pool_rec['cpulist']), }, uuid, False) except PoolError, ex: # log error and skip domain log.error( 'cannot recreate pool %s; skipping (reason: %s)' \ % (name, ex))
def deviceIDs(self, transaction = None): """@return The IDs of each of the devices currently configured for this instance's deviceClass. """ fe = self.frontendRoot() if transaction: return map(lambda x: int(x.split('/')[-1]), transaction.list(fe)) else: return map(int, xstransact.List(fe))
def diagnose_devices(): global deviceClass global device global frontendPath global backendPath device_path = dompath + '/device' device_classes = xstransact.List(device_path) print "Found %d device classes in use." % len(device_classes) for dc in device_classes: deviceClass = dc device_class_path = device_path + '/' + deviceClass devices = xstransact.List(device_class_path) print "Found %d %s devices." % (len(devices), deviceClass) for d in devices: device = d print "Found device %s, %s." % (deviceClass, device) frontendPath = device_class_path + '/' + device backendPath = xstransact.Read(frontendPath, 'backend') if not backendPath: print("Cannot find backend path for device %s, %s." % (deviceClass, device)) else: frontend_state = xstransact.Read(frontendPath, 'state') backend_state = xstransact.Read(backendPath, 'state') print "Backend is in state %s." % stateString(backend_state) print "Frontend is in state %s." % stateString(frontend_state) check_for_error(True) check_for_error(False) diagnose_hotplugging()
def get_all_assigned_pci_devices(domid=0): dom_list = xstransact.List('/local/domain') pci_str_list = [] ti = 0 ts = xstransact.Read('/local/domain/' + str(domid) + '/target') if ts is not None: ti = int(ts) for d in dom_list: target = xstransact.Read('/local/domain/' + d + '/target') if int(d) is not ti and target is None: pci_str_list = pci_str_list + get_assigned_pci_devices(int(d)) return pci_str_list
def __init__(self): # Table of vnet info indexed by vnet id. self.vnet = {} listing = xstransact.List(self.dbpath) for entry in listing: try: info = XendVnetInfo(self.dbpath + '/' + entry) self.vnet[info.id] = info info.configure() except XendError, ex: log.warning("Failed to configure vnet %s: %s", str(info.id), str(ex)) except Exception, ex: log.exception("Vnet error") xstransact.Remove(self.dbpath + '/' + entry)
def query_pool_id(self): """ Get corresponding pool-id of pool instance from XenStore. @return: pool id or None @rytpe: int """ self.pool_lock.acquire() try: for pool_id in xstransact.List(XS_POOLROOT): uuid = xstransact.Read(XS_POOLROOT + "%s/" % pool_id, 'uuid') if uuid == self.get_uuid(): return int(pool_id) finally: self.pool_lock.release() return None
def readBackendList(self, devid, *args): frontpath = self.frontendPath(devid) backpath = xstransact.Read(frontpath + "/backend") if backpath: paths = map(lambda x: backpath + "/" + x, args) return xstransact.List(*paths)