def grubDiskAndPartitionIndicies(part): '''Grub defines disks and partitions by their indicies as they are found in the boot order. It has no knowledge of sdX versus hdX versus CCISS versus DAC960. It just knows the first, second, third, etc. and expects them to be indicated in its conf files in a format like (hd0,0) So this function, for a given partition, gets the index of the disk and the index of the partition on said disk. Raise a KeyError if it can not be found in the DiskSet. ''' disks = devices.DiskSet() orderedDrives = disks.getOrderedDrives() for diskIndex, drive in enumerate(orderedDrives): for candidatePart in drive.partitions: if candidatePart == part: # logical partitions ALWAYS start at 4, so use partitionId grubPartitionNum = candidatePart.partitionId - 1 log.debug('Disk/partition %s/%s enumerated as %d,%d ' 'for grub' % (drive.name, candidatePart.name, diskIndex, grubPartitionNum)) return (diskIndex, grubPartitionNum) nonStandardDisk = disks.findDiskContainingPartition(part) if nonStandardDisk: # XXX this should disappear... # logical partitions ALWAYS start at 4, so use partitionId grubPartitionNum = part.partitionId - 1 log.debug('Non-standard disk/partition 0/%d' % (grubPartitionNum)) return (0, grubPartitionNum) partName = part.getName() raise KeyError('Partition not found in disk set: %s' % partName)
def findUSBMedia(showAll=False): """Scan attached USB devices for installation media. If showAll is True, all CD devices are returned even if they do not contain any installation media. """ diskSet = devices.DiskSet(forceReprobe=True) retval = [] util.umount(USB_MEDIA_PATH) for disk in diskSet.values(): if disk.driverName != devices.DiskDev.DRIVER_USB_STORAGE: log.debug("skipping non-usb device -- %s" % disk.name) continue diskMedia = [] for part in disk.partitions: if not part.consoleDevicePath: continue diskMedia += _tryDevice(disk, part) if not diskMedia and showAll: # No installation media was found on the device, but the caller # wants the list of potential media devices, so add that in. diskMedia = [media.MediaDescriptor(disk.name)] retval += diskMedia return retval
def getKernelOptions(kernelMemInMB): '''Create the list of options that get appended onto the "kernel" line of the grub.conf file. ''' disks = devices.DiskSet() rootPartition = disks.findPartitionContaining('/', searchVirtual=True) if not rootPartition: raise PartitionNotFound('/') devPartName = rootPartition.consoleDevicePath if not devPartName: # expected /dev/sda1 for the 1-disk case raise MissingConsoleDevicePath(rootPartition) rootPartUuid = getUuid(devPartName) # ro: mount "/" read-only in the initrd environment but when the init # scripts start up it magically gets remounted rw. options = 'ro' # root: tell the kernel where to find "/" options += ' root=UUID=' + rootPartUuid # mem: tell the kernel how much memory it can use options += ' mem=' + kernelMemInMB + 'M' choices = userchoices.getBoot() if choices and choices['kernelParams']: options += ' ' + choices['kernelParams'] return options
def start(self): "Initial step." # ESX device is previous user choice or location of /boot. self.esxDeviceName = userchoices.getEsxPhysicalDevice() devs = userchoices.getPhysicalPartitionRequestsDevices() for dev in devs: request = userchoices.getPhysicalPartitionRequests(dev) if request.findRequestByMountPoint('/boot'): self.esxDeviceName = dev assert self.esxDeviceName self.clearDrives = [self.esxDeviceName] createNewDataStoreFunc = self.createNewDataStore if not devices.DiskSet()[self.esxDeviceName].supportsVmfs: createNewDataStoreFunc = self.createNewDataStoreDiffDev ui = { 'title': title, 'body': dataStoreText, 'menu': { '1': createNewDataStoreFunc, '2': self.useExistingDataStore, '<': self.stepBack, '?': self.help, } } self.setSubstepEnv(ui)
def commit(self): """Commit updates. By the time we get here, we assume: * volume name has been sanity checked * requested size has been checked """ assert self.deviceName, 'datastore device name not set' assert self.volumeName, 'datastore volume name not set' log.debug("DataStoreWindow.commit device %s volume %s" % (self.deviceName, self.volumeName)) # Check if drives to clear are in use; if so stop this madness. diskSet = devices.DiskSet() if self.deviceName == self.esxDeviceName: clearDrives = [self.deviceName] else: clearDrives = [self.deviceName, self.esxDeviceName] # presumably self.choseCreateNewDatastoreOnEsxDevice == False log.debug("Cleared drives = %s" % (', '.join(clearDrives))) volumePath = os.path.join('/vmfs/volumes', self.volumeName) if (os.path.exists(volumePath) or os.path.islink(volumePath)) \ and not checkForClearedVolume(clearDrives, self.datastoreSet, self.volumeName): log.debug("Volume name in use") self.setSubstepEnv({'next': self.warnInUse}) return # build partition requests, add to userchoices partition.addDefaultPartitionRequests(diskSet[self.esxDeviceName], False) if self.choseCreateNewDatastore: physicalRequests = [ (None, 100, 0, True, fsset.vmfs3FileSystem(self.volumeName)), ] dev = diskSet[self.deviceName] userchoices.addPhysicalPartitionRequests( self.deviceName, partition.createPartitionRequestSet(dev, physicalRequests)) userchoices.setClearPartitions(drives=clearDrives) userchoices.setEsxDatastoreDevice(dev.name) userchoices.setVmdkDatastore(self.volumeName) else: # use existing datastore userchoices.setClearPartitions(drives=[self.esxDeviceName]) userchoices.clearVirtualDevices() userchoices.setEsxDatastoreDevice(None) userchoices.setVmdkDatastore(self.volumeName) # size check size = partition.getRequestsSize(partition.getDefaultVirtualRequests()) if size > devices.runtimeActionFindMaxVmdkSize(): self.setSubstepEnv({'next': self.warnTooSmall}) return self.setSubstepEnv({'next': self.stepForward})
def __init__(self, controlState, xml): controlState.displayHeaderBar = True controlState.windowTitle = "ESX Storage Device" controlState.windowText = "Select a location to install ESX" controlState.windowIcon = "drive.png" self.xml = xml self.controlState = controlState self.view = xml.get_widget("EsxlocationView") self.scrolled = xml.get_widget("EsxlocationScrolled") storage_widgets.setupStorageView(self.view) # only repopulate the esxlocation if we need to if userchoices.getResetEsxLocation(): model = \ storage_widgets.populateStorageModel(self.view, self.scrolled, devices.DiskSet(), vmfsSupport=False) storage_widgets.findFirstSelectableRow(model, self.view, SUPPORTED_DISK_ENTRY) connectSignalHandlerByDict( self, EsxLocationWindow, self.xml, { ('EsxlocationDetailsButton', 'clicked'): 'showDetails', })
def bldStorDisplayList(self): " build displayable storage list" # only repopulate esxlocation if we need to if userchoices.getResetEsxLocation(): self.storList = \ storage_utils.getStorageList(devices.DiskSet(), vmfsSupport=(self.partMode=="basic"), esxAndCos=(self.partMode=="basic")) # build storage list storListText = [] storEnumStr = "%2d) %-51s %3s %4s %11s" storEnumPath = " %s" storListText.append(diskHeaderText) for num, storLine in enumerate(self.storList): deviceModel, lunid, disksize, entry, pathString, targetid = storLine storListText.append( storEnumStr % (num + 1, deviceModel, lunid, targetid, disksize)) for path in pathString: tempEnumPath = storEnumPath % path while tempEnumPath: storListText.append(tempEnumPath[:80]) tempEnumPath = tempEnumPath[80:] self.setScrollEnv(storListText, SCROLL_LIMIT) self.setSubstepEnv({'next': self.scrollDisplay})
def hostActionClearPartitions(context): clearParts = userchoices.getClearPartitions() if 'drives' in clearParts and 'whichParts' in clearParts: # XXX A side-effect of getting the list of vmfs volumes in DatastoreSet # is that any existing vmfs volumes will get put into a cache in the # kernel. While in this cache, some SCSI handles are left open which # prevent us from clearing the partition table completely. # # See pr 237236 for more information. fsset.flushVmfsVolumes() context.cb.pushStatusGroup(len(clearParts['drives'])) for deviceName in clearParts['drives']: device = devices.DiskSet()[deviceName] if device.name in userchoices.getDrivesInUse(): log.info("skipping clearing drive -- %s" % device.name) continue context.cb.pushStatus("Clearing Partition %s (%s)" % (device.name, device.path)) if clearParts['whichParts'] == userchoices.CLEAR_PARTS_ALL: device.partitions.clear() else: #TODO: finish this for the other options. assert False, "clearPartitions not completely implemented" device.partitions.partedDisk.commit() # XXX context.cb.popStatus() context.cb.popStatusGroup() # rescan the vmfs volumes in case we need to disconnect any since # we have a new partition table fsset.rescanVmfsVolumes()
def runtimeActionExtractVmdkPathFromInitrd(driveName): '''Open the initrd.img file on a disk and find the location of the Console VMDK file from esx.conf. ''' diskSet = devices.DiskSet() drive = diskSet[driveName] partition = drive.findFirstPartitionMatching(fsTypes=('ext3')) if not partition or partition.partitionId != 1: return '' tmpMntDir = tempfile.mkdtemp(prefix='weasel', dir='/mnt') partition.fsType.mount(partition.consoleDevicePath, tmpMntDir) tmpDir = tempfile.mkdtemp(prefix='weasel') initrdFilePath = os.path.join(tmpMntDir, 'initrd.img') cmd = "cd %s && zcat %s | cpio -id %s" % \ (tmpDir, initrdFilePath, ESXCONF_FILE[1:]) util.execCommand(cmd) vmdkPath = getValueFromConfig(os.path.join(tmpDir, ESXCONF_FILE[1:]), '/boot/cosvmdk') partition.fsType.umount(tmpMntDir) shutil.rmtree(tmpMntDir) shutil.rmtree(tmpDir) return vmdkPath
def preserveDatastoreOnDrive(driveName): import userchoices diskSet = devices.DiskSet() datastoreSet = DatastoreSet() # find the /boot partition disk = diskSet[driveName] part = disk.findFirstPartitionMatching( fsTypes=('ext2', 'ext3'), minimumSize=partition.BOOT_MINIMUM_SIZE) assert part # wipe the partition part.mountPoint = "/boot" req = partition.PartitionRequest(mountPoint=part.mountPoint, minimumSize=part.getSizeInMegabytes(), fsType=part.fsType, consoleDevicePath=part.consoleDevicePath, clearContents=True) # get the datastores for a given drive datastores = datastoreSet.getEntriesByDriveName(driveName) userchoices.addPartitionMountRequest(req) userchoices.clearVirtualDevices() # XXX - assuming there is only one datastore on the drive partition.addDefaultVirtualDriveAndRequests(driveName, vmfsVolume=datastores[0].name)
def getName(self): """Get a descriptive name for this installation media.""" if self.diskName: diskSet = devices.DiskSet() return diskSet[self.diskName].getVendorModelString() else: return self.partPath
def _usbOption(match): '''Handle the "ks=usb" and "ks=usb:<path>" option.''' try: ksFile = match.group(1) except IndexError: ksFile = "ks.cfg" firstTime = True while True: if not firstTime: # XXX Maybe we should just stop retrying after awhile? log.info("Insert a USB storage device that contains '%s' " "file to perform a scripted install..." % ksFile) util.rawInputCountdown("\rrescanning in %2d second(s), " "press <enter> to rescan immediately", 10) firstTime = False diskSet = devices.DiskSet(forceReprobe=True) usbDisks = [disk for disk in diskSet.values() if disk.driverName == devices.DiskDev.DRIVER_USB_STORAGE] if not usbDisks: log.info("") # XXX just for spacing log.warn("No USB storage found.") continue kickstartPath = os.path.join(USB_MOUNT_PATH, ksFile.lstrip('/')) if not os.path.exists(USB_MOUNT_PATH): os.makedirs(USB_MOUNT_PATH) for disk in usbDisks: for part in disk.partitions: if part.partitionId == -1: continue if (part.getFsTypeName() not in ("ext2", "ext3", "vfat")): # Don't try mounting partitions with filesystems that aren't # likely to be on a usb key. continue if util.mount(part.consoleDevicePath, USB_MOUNT_PATH, fsTypeName=part.getFsTypeName()): log.warn("Unable to mount '%s'" % part.consoleDevicePath) continue if os.path.exists(kickstartPath): userchoices.addDriveUse(disk.name, 'kickstart') return [('-s', kickstartPath)] if util.umount(USB_MOUNT_PATH): failWithLog("Unable to umount '%s'" % USB_MOUNT_PATH) log.info("") log.warn("%s was not found on any attached USB storage." % ksFile)
def __init__(self, parent, skipEsxDevice=True): """Initialize using parent's environment. Generates self.storDevList - list of allowable storage devices. """ super(ChooseDataStoreDevice, self).__init__() self.substep = self.start = self.showDevices self.scrollable = None self.parent = parent self.selectedDevice = None if skipEsxDevice: allowedDiskSet = pruneDiskSet(devices.DiskSet(), [self.parent.esxDeviceName]) else: allowedDiskSet = devices.DiskSet() self.storDevList = storage_utils.getStorageList( allowedDiskSet, esxAndCos=not skipEsxDevice)
def findGrubInstallDevice(slashBootPartition): '''Find the device (the disk) to install grub onto (write the MBR). In the future, this might return something other than the disk containing the /boot partition. For example, a userchoices attribute may override the selection, or the policy might change to "the first device in GetOrderedDrives()". ''' disks = devices.DiskSet() disk = disks.findDiskContainingPartition(slashBootPartition) assert disk, "Just found /boot partition, but then it's disk vanished!" return disk
def grubDiskIndex(disk): '''Operates like grubDiskAndPartitionIndicies but it only cares about the disk index. ''' disks = devices.DiskSet() orderedDrives = disks.getOrderedDrives() for diskIndex, candidateDisk in enumerate(orderedDrives): if candidateDisk == disk: return diskIndex raise KeyError('Disk not found in disk set: %s' % disk.name)
def __init__(self, partMode="basic"): super(EsxLocationWindow, self).__init__() self.storList = \ storage_utils.getStorageList(devices.DiskSet(), vmfsSupport=(partMode=="basic"), esxAndCos=(partMode=="basic")) self.partMode = partMode # basic or advanced self.driveName = None self.start = self.bldStorDisplayList self.substep = self.start self.scrollable = None
def __init__(self, controlState, xml): controlState.displayHeaderBar = True controlState.windowIcon = 'partitioning.png' controlState.windowTitle = "Service Console Virtual Disk Image" controlState.windowText = \ "Configure the service console virtual disk image" global _resetPartitions, _datastoreDevice # reset the vmdk partitions if the datastore device has been changed if userchoices.getEsxDatastoreDevice() != _datastoreDevice: _resetPartitions = True _datastoreDevice = userchoices.getEsxDatastoreDevice() self.xml = xml self.diskSet = devices.DiskSet() self.maxVmdkSize = devices.runtimeActionFindMaxVmdkSize() self.consoleVMSizeLabel = xml.get_widget("SetupvmdksizeLabel") self.view = xml.get_widget("SetupvmdkTreeView") self.scrolled = xml.get_widget("SetupvmdkScrolledWindow") # Download the package data so we can figure out the minimum partition # sizes weaselConfig = systemsettings.WeaselConfig() packagesXML = packages.getPackagesXML(weaselConfig.packageGroups) packageData = packages.PackageData(packagesXML.fullInstallDepot) self.fileSizes = packageData.fileDict self.requests = None self.newButton = xml.get_widget("SetupvmdkNewButton") self.deleteButton = xml.get_widget("SetupvmdkDeleteButton") if _resetPartitions: self._resetPartitions() _resetPartitions = False self.setupVirtualDevice() connectSignalHandlerByDict(self, SetupVmdkWindow, self.xml, { ('SetupvmdkNewButton', 'clicked') : 'newPartition', ('SetupvmdkEditButton', 'clicked') : 'editPartition', ('SetupvmdkDeleteButton', 'clicked') : 'deletePartition', ('SetupvmdkResetButton', 'clicked') : 'resetPartitions', }) self.partitionWindow = PartitionWindow(xml, self) self.setButtons()
def getDeviceHasExistingDataText(deviceName): foundEsx = devices.runtimeActionFindExistingEsx(deviceName) foundVmfs = False for part in devices.DiskSet()[deviceName].partitions: if part.nativeType == 0xfb: foundVmfs = True break if foundEsx and foundVmfs: warnText = """ARE YOU TRYING TO PERFORM AN UPGRADE? The selected storage device contains an existing ESX installation and datastore. Continuing installation on this storage device will RESULT IN DATA LOSS, causing any ESX settings and virtual machines to be lost. To UPGRADE the existing installation without incurring data loss, use the vSphere Host Update Utility installed along with vSphere Client or use vCenter Update Manager.\n""" elif foundEsx: warnText = """ARE YOU TRYING TO PERFORM AN UPGRADE? The selected storage device contains an existing ESX installation. Continuing installation on this storage device will RESULT IN DATA LOSS, causing any ESX settings to be lost. To UPGRADE the existing installation without incurring data loss, use the vSphere Host Update Utility installed along with vSphere Client or use vCenter Update Manager.\n""" elif foundVmfs: warnText = """DATA LOSS WARNING: The selected storage device contains a datastore that will be erased before installing ESX. Continuing installation will cause any virtual machines on this datastore to be lost. If you want to save this content, please cancel out and choose another option.\n""" else: warnText = """DATA LOSS WARNING: The contents of the selected storage device will be erased before installing ESX. All existing data will be lost. If you want to save this content, please cancel out and choose another option.\n""" return warnText
def promptDeviceHasExistingData(deviceName, allowPreserve=True): foundVmfs = False foundEsx = False foundVmfs2 = False datastoreName = "" foundEsx = devices.runtimeActionFindExistingEsx(deviceName) datastoreSet = datastore.DatastoreSet() for part in devices.DiskSet()[deviceName].partitions: if part.nativeType == 0xfb: foundVmfs = True break # if we found vmfs2 partitions don't attempt to preserve them if foundVmfs: datastores = datastoreSet.getEntriesByDriveName(deviceName) if len(datastores) > 0: datastoreName = datastores[0].name else: foundVmfs2 = True if foundEsx and foundVmfs and allowPreserve and not foundVmfs2: return PreserveDatastoreWindow(datastoreName).run() elif foundEsx and foundVmfs and not foundVmfs2: text = STORAGE_DATASTORE_TEXT % datastoreName return ConfirmDatastoreDeletionWindow(text).run() elif foundEsx and not foundVmfs2: text = STORAGE_ESX_TEXT elif foundVmfs: text = STORAGE_DATASTORE_VMFS2_TEXT if datastoreName: text = STORAGE_DATASTORE_TEXT % datastoreName return ConfirmDatastoreDeletionWindow(text).run() else: text = STORAGE_TEXT window = MessageWindow(None, '', text, type='okcancel', useMarkup=True) if window.affirmativeResponse: return EXISTING_DATA_CLEAR_DRIVE return EXISTING_DATA_STAY_ON_SCREEN
def validateScriptedInstallValidate(fileName, expResult=Result.SUCCESS, expErrors=[], expWarnings=[], expVerify=[]): configToLoad = DEFAULT_CONFIG_NAME # XXX Need to do a reload here to restore defaults since the tests will # update userchoices. reload(userchoices) try: fauxroot.FAUXROOT = [configToLoad] # XXX Need to force a reprobe since the disk config might change. devices.DiskSet(forceReprobe=True) si = ScriptedInstallPreparser(fileName) si.warnedPhysicalPartition = True # XXX Take this out (result, errors, warnings) = si.parseAndValidate() if not errors: writeAction(None) finally: # Leave the fauxroot turned on if it's needed by the test, mostly we # just need it for the device scan. fauxroot.FAUXROOT = None print "Expected...." print expResult.__str__() print expErrors.__str__() print expWarnings.__str__() print "Actuall...." print fileName print result.__str__() print errors.__str__() print warnings.__str__() assert result == expResult assert validateListContents(errors, expErrors) == 1 assert validateListContents(warnings, expWarnings) == 1 for v in expVerify: # Evaluate the verify expression, use the current globals and add a # local named 'sip' that contains a reference to the parser object. assert eval(v, globals(), { 'sip' : si }), v
def __init__(self, drive): CommonWindow.__init__(self) gladePath = os.path.join(os.path.dirname(__file__), 'glade/storage-widgets.glade') self.xml = gtk.glade.XML(gladePath) self.drive = drive self.diskSet = devices.DiskSet() self.disk = self.diskSet[drive] self.datastoreSet = datastore.DatastoreSet() self.dialog = self.xml.get_widget('details') self.setLabels() self.addFrameToWindow() self.dialog.set_position(gtk.WIN_POS_CENTER) self.dialog.show_all()
def getEligibleDisks(disks=None, vmfsSupport=True, esxAndCos=True): '''Return a list of DiskDevs that are supported and large enough to support the default installation.''' if disks is None: disks = devices.DiskSet() defaultRequests = list(DEFAULT_PHYSICAL_REQUESTS) if vmfsSupport and esxAndCos: minSizeInMB = getRequestsSize(defaultRequests + getDefaultVirtualRequests()) + \ devices.VMDK_OVERHEAD_SIZE elif vmfsSupport and not esxAndCos: minSizeInMB = getRequestsSize(getDefaultVirtualRequests()) + \ devices.VMDK_OVERHEAD_SIZE else: minSizeInMB = getRequestsSize(defaultRequests) maxSizeInMB = 2 * 1024 * 1024 # 2 TB retval = [] for disk in disks.values(): log.debug("checking disk for install eligibility -- %s" % str(disk)) if vmfsSupport and not disk.supportsVmfs: log.debug(" vmfs not supported") continue if disk.getSizeInMegabytes() < minSizeInMB: log.debug(" too small") continue if disk.getSizeInMegabytes() >= maxSizeInMB: # XXX bug #290262 log.debug(" too big") continue if disk.name in userchoices.getDrivesInUse(): log.debug(" already in use") continue log.debug(" disk is eligible") retval.append(disk) return retval
def _ksFileUUIDOption(match): uuid = match.group(1) path = match.group(2) diskSet = devices.DiskSet(forceReprobe=True) diskPartTuple = diskSet.findFirstPartitionMatching(uuid=uuid) if diskPartTuple: disk, _part = diskPartTuple userchoices.addDriveUse(disk.name, 'kickstart') mountPath = os.path.join(UUID_MOUNT_PATH, uuid) if not os.path.exists(mountPath): os.makedirs(mountPath) if util.mount(uuid, mountPath, isUUID=True): os.rmdir(mountPath) failWithLog("error: cannot mount partition with UUID: %s\n" % uuid) ksPath = os.path.join(mountPath, path[1:]) return [('-s', ksPath)]
def __init__(self): super(SetupVmdkWindow, self).__init__() self.substep = self.start self.diskSet = devices.DiskSet() self.maxVmdkSize = devices.runtimeActionFindMaxVmdkSize() self.requests = None # Download the package data so we can figure out the minimum partition # sizes weaselConfig = systemsettings.WeaselConfig() packagesXML = packages.getPackagesXML(weaselConfig.packageGroups) packageData = packages.PackageData(packagesXML.fullInstallDepot) self.fileSizes = packageData.fileDict if not userchoices.getVirtualDevices(): self.reset() else: self.setupVirtualDevice()
def __init__(self, controlState, xml): controlState.displayHeaderBar = True controlState.windowIcon = 'datastore.png' controlState.windowTitle = "Datastore" controlState.windowText = "Specify a datastore for ESX" self.xml = xml self.diskSet = devices.DiskSet() self.datastoreSet = datastore.DatastoreSet() self.datastoreExistTable = xml.get_widget("DatastoreexistingTable") self.datastoreCreateTable = xml.get_widget("DatastorecreateTable") connectSignalHandlerByDict( self, DataStoreWindow, self.xml, { ('DatastoredeviceButton', 'clicked'): 'createNewDatastore', ('DatastorepartitionButton', 'clicked'): 'selectDatastore', ('DatastorecreateRadioButton', 'toggled'): 'toggleDatastoreChoice', ('DatastoreCheckButton', 'toggled'): 'toggleSameDevice', }) self.defaultDeviceName = userchoices.getEsxPhysicalDevice() # set up the aux. helper windows self.createDataStoreWindow = \ CreateDataStoreWindow(self.xml, self.diskSet, self) self.selectDataStoreWindow = \ SelectDataStoreWindow(self.xml, self.datastoreSet, self) # find the existing vmdk size that we're going to remove vmdkPath = userchoices.getExistingVmdkLocation().get('vmdkLocation') self.vmdkSize = devices.runtimeActionFindExistingVmdkSize(vmdkPath) self.preserveVmfs = bool(userchoices.getPartitionMountRequests()) if userchoices.getResetEsxLocation(): self.setup() userchoices.setResetEsxLocation(False)
def addPartRequest(self): """Add the default partition request. May be configured for basic or advanced.""" self.popSubstep() # kludge, pop state from warn() # schedule default partition operation request = devices.DiskSet()[self.driveName] if self.partMode == 'basic': partition.addDefaultPartitionRequests(request) else: # partMode == 'advanced' partition.addDefaultPartitionRequests(request, addVirtualPartitions=False) # If ESX location is changing (or this is first time), tell # DataStoreWindow via userchoices so it can clear options. if self.driveName != userchoices.getEsxPhysicalDevice(): userchoices.setResetEsxLocation(True) else: userchoices.setResetEsxLocation(False) self.setSubstepEnv({'next': self.stepForward})
def validateComplexValidate(fileName): (result, errors, warnings, verify) = \ buildExpectedResultSet(fileName) validateScriptedInstallValidate(fileName, result, errors, warnings, verify) if False and not errors: # XXX The following should check the generated ks.cfg file, but it does # not work quite right. Just checking the results is not enough and # any default settings will be filled so there won't be any warnings # about the defaults being used (same for deprecated commands, unknown # commands, and so on). Checking userchoices does not quite work # because we don't have __str__ methods on all the objects and some # unrelated quirks cause other problems (unicode and shlex not getting # along). savedChoices = re.sub(r'0x\w+', 'XXX', userchoices.dumpToString()) reload(userchoices) try: fauxroot.FAUXROOT = [DEFAULT_CONFIG_NAME] # XXX Need to force a reprobe since the disk config might change. devices.DiskSet(forceReprobe=True) si = ScriptedInstallPreparser("/mnt/sysimage/root/ks.cfg") (result, errors, warnings) = si.parseAndValidate() newChoices = re.sub(r'0x\w+', 'XXX', userchoices.dumpToString()) import difflib for line in difflib.unified_diff( savedChoices.split('\n'), newChoices.split('\n')): print line assert savedChoices == newChoices finally: fauxroot.FAUXROOT = None # XXX Need to be nice to other tests, do another reload... reload(userchoices)
def __init__(self, controlState, xml): controlState.displayHeaderBar = True controlState.windowTitle = "ESX Storage Device" controlState.windowText = "Select a location to install ESX" controlState.windowIcon = "drive.png" self.controlState = controlState self.xml = xml self.view = xml.get_widget("InstalllocationView") self.scrolled = xml.get_widget("InstalllocationScrolled") storage_widgets.setupStorageView(self.view) model = storage_widgets.populateStorageModel(self.view, self.scrolled, devices.DiskSet()) storage_widgets.findFirstSelectableRow(model, self.view, SUPPORTED_DISK_ENTRY) connectSignalHandlerByDict( self, InstallLocationWindow, self.xml, { ('InstalllocationDetailsButton', 'clicked'): 'showDetails', })
def _getDevice(self): if self._deviceObj or self.deviceName: return self._deviceObj or devices.DiskSet()[self.deviceName] else: return None
for request in requests: if not request.mountPoint: continue mountPoint = os.path.normpath(consts.HOST_ROOT + request.mountPoint) if os.path.exists(mountPoint): log.debug("Unmounting %s" % (mountPoint)) util.umount(mountPoint) if __name__ == "__main__": import doctest doctest.testmod() diskSet = devices.DiskSet() disks = diskSet.keys() disks.sort() # for entry in diskSet["vmhba32:0:0"].partitions: # print "%d: start=%d end=%d size=%d" % (entry.partitionId, entry.startSector, entry.endSector, entry.getLength()) requests = PartitionRequestSet(deviceName="vmhba32:0:0") #requests.append(PartitionRequest(minimumSize=100, maximumSize=100)) #requests.append(PartitionRequest(minimumSize=256, maximumSize=256)) #requests.append(PartitionRequest(minimumSize=3000, maximumSize=3000)) requests.append(PartitionRequest(minimumSize=100, grow=True)) requests.append(PartitionRequest(minimumSize=100, maximumSize=100)) requests.append(