class SetLogicalNVDIMMDrivesCommand(RdmcCommandBase):
def __init__(self, rdmcObj):
RdmcCommandBase.__init__(self, \
name='setbackupdevices', \
usage='setbackupdevices (--device=ID... | --remove-all)\n\n'\
'\tSelect the devices to use for Scalable Persistent Memory '\
'backup storage.\n\n\texample: setbackupdevices --device=1@1 '\
'--device=1@2', \
summary='Set backup storage devices.', \
aliases=['spmem-setdrives', 'spmsetd', 'setbackupdrives'], \
optparser=OptionParser())
self.definearguments(self.parser)
self._rdmc = rdmcObj
self._helpers = Helpers()
self._restHelpers = RestHelpers(self._rdmc)
self._validator = LogicalNvdimmValidator()
self._chif_lib = self._helpers.gethprestchifhandle()
def common_setup(self):
""" function to get the config setup """
scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers, \
self._validator, self._chif_lib)
scalable_pmem_config.refresh()
# pre-validation
self._helpers.validateAllConfigurationPolicies(scalable_pmem_config)
return scalable_pmem_config
def removeAllDrives(self):
""" setlogicalnvdimmdrives command worker function """
scalable_pmem_config = self.common_setup()
if scalable_pmem_config.hasConfiguredRegions:
raise NoChangesFoundOrMadeError(u"Backup drives cannot be removed "\
"while logical NVDIMMs are configured")
self._restHelpers.setDrives(
old_drives=scalable_pmem_config.drives.selectedDrives)
#self._restHelpers.enableConfiguration()
scalable_pmem_config.refresh()
self._helpers.displayDrivesConfiguration(scalable_pmem_config)
return ReturnCodes.SUCCESS
def setDrives(self, options=None):
""" Main setlogicalnvdimmdrives command worker function
:param options: command options
:type options: options.
"""
drivesToUse = []
if not options.driveId:
raise InvalidCommandLineError(u"No device IDs specified")
if len(options.driveId) > len(set(options.driveId)):
raise InvalidCommandLineError(u"Duplicate device IDs specified")
scalable_pmem_config = self.common_setup()
for userProvidedId in options.driveId:
matchingDrive = scalable_pmem_config.drives.findDrive(
userProvidedId)
if not matchingDrive:
raise InvalidCommandLineError(
u"Invalid device ID: {}".format(userProvidedId))
drivesToUse.append(matchingDrive)
if scalable_pmem_config.hasConfiguredRegions:
# allow drives to be added but not removed
if not set(scalable_pmem_config.drives.selectedDrives).issubset(
drivesToUse):
raise NoChangesFoundOrMadeError(u"Backup devices cannot be "\
"removed while logical NVDIMMs are configured")
# check the configuration policies
(isValidDrivePolicies, drivePoliciesMessage) = self._validator.\
checkLogicalNvdimmDrivePolicies(scalable_pmem_config.config_resource,\
drivesToUse)
if not isValidDrivePolicies:
sys.stdout.write(
u"\nThe set of devices specified is not a valid configuration:\n"
)
sys.stdout.write(drivePoliciesMessage)
sys.stdout.write(u"\n\n")
raise NoChangesFoundOrMadeError(u"Unable to continue")
# calculate maximum persistent memory supported
maxPmem = self._validator.calculateMaxPmemGiB(self._chif_lib, scalable_pmem_config.\
config_resource, drivesToUse)
# compare this to the TOTAL of the pmem regions in the current/pending settings
totalPmemAllocated = scalable_pmem_config.regions.totalSizeGiB
if totalPmemAllocated != 0 and maxPmem < totalPmemAllocated:
sys.stdout.write(
u"\nThe set of devices specified is not a valid configuration:\n"
)
sys.stdout.write(
u"\nScalable Persistent Memory supported by requested configuration: {} GiB" \
u"\nAllocated Scalable Persistent Memory: {} GiB.".\
format(maxPmem, totalPmemAllocated))
sys.stdout.write(u"\n\n")
raise NoChangesFoundOrMadeError(u"Unable to continue")
# if all is valid, configure the related BIOS setting
if self._rdmc.interactive:
self._helpers.confirmBeforeConfigCausesDataLoss(
scalable_pmem_config)
self._restHelpers.setDrives(new_drives=drivesToUse, old_drives=scalable_pmem_config.\
drives.selectedDrives)
scalable_pmem_config.refresh()
self._helpers.displayDrivesConfiguration(scalable_pmem_config)
return ReturnCodes.SUCCESS
def run(self, line):
""" Wrapper function for setbackupdrives command main function
:param line: command line input
:type line: string.
"""
LOGGER.info("Scalable PMEM: {}".format(self.name))
try:
(options, _) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
LOGGER.info("Options: {}".format(options))
if not self._chif_lib:
self._helpers.failNoChifLibrary()
if options.removeAll and options.driveId:
raise InvalidCommandLineError(u"--device and --remove-all may not "\
"be used at the same time")
if options.removeAll:
return self.removeAllDrives()
else:
return self.setDrives(options)
def definearguments(self, customparser):
""" Define arguments for the command
:param customparser: command line input
:type customparser: parser.
"""
groupDanger = OptionGroup(customparser, "Dangerous Options", \
"Use of these options will alter the backup storage devices configured\n" \
"for use with Scalable Persistent Memory and could cause data loss. " \
" Back up all\ndata first.")
groupDanger.add_option(
'--device',
'--drive',
action="append",
dest="driveId",
metavar="ID",
help="ID of the backup device to set, e.g. '1@1'")
groupDanger.add_option(
'--remove-all',
action="store_true",
dest="removeAll",
help="Remove all currently-configured backup devices")
customparser.add_option_group(groupDanger)
class AutoSelectBackupDevicesCommand(RdmcCommandBase):
""" Main autoselectbackupdevices command class """
def __init__(self, rdmcObj):
RdmcCommandBase.__init__(self,\
name='autoselectbackupdevices', \
usage='autoselectbackupdevices --size=SIZE [--confirm]\n\n'\
'\tAutomatically select the devices for use as Scalable '\
'Persistent Memory backup storage.\n\n'\
"\tDevices selected for backup storage will be initialized.\n"\
"\tBack up all data first.\n" \
'\n\texample: autoselectbackupdevices --size=1024 --confirm\n', \
summary='Automatically select backup storage devices.', \
aliases=['spmem-autosetd', 'spmemautosetd'],\
optparser=OptionParser())
self.definearguments(self.parser)
self._rdmc = rdmcObj
self._helpers = Helpers()
self._restHelpers = RestHelpers(self._rdmc)
self._validator = LogicalNvdimmValidator()
self._chif_lib = self._helpers.gethprestchifhandle()
def autoselectdrives(self, pmem_size_GiB, confirm):
""" function to perform the automatic selection of backup drives
:param pmem_size_GiB: requested scalable persistent memory size
:type pmem_size_GiB: int
:param confirm: whether or not to automatically confirm the selected drives
:type confirm: Boolean
"""
scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
self._validator, self._chif_lib)
scalable_pmem_config.refresh()
# pre-validation
self._helpers.validateAllConfigurationPolicies(scalable_pmem_config)
# make sure this is an un-configured system
if scalable_pmem_config.isConfiguredSystem:
raise InvalidCommandLineError(u"This operation is not supported on "\
"a configured system")
# get policies
policies = resolve_pointer(scalable_pmem_config.config_resource, \
"/Attributes/Policy", None)
sameModel = False
sameSize = False
if policies:
sameModel = policies.get("SameModelNVMe", False)
sameSize = policies.get("SameSizeNVMe", False)
# separate the supported drives into supported groups, based on model or size
# if same model or size, then order doesn't matter; else the
# drives should be sorted largest to smallest
supported_drives_groups = self.sort_drives(sameModel, sameSize, \
scalable_pmem_config.drives.supportedDrives)
# loop through the group until a valid config is found or all drives
# have been tested
isValid = False
i = 0
num_groups = len(supported_drives_groups)
while not isValid and i < num_groups:
drive_group = supported_drives_groups[i]
drivesToUse = []
for drive in drive_group:
drivesToUse.append(drive)
# calculate the maximum supported by the new configuration,
# which may be different from the requested capacity
max_pmem_supported = self._validator.calculateMaxPmemGiB(\
self._chif_lib, scalable_pmem_config.config_resource, \
drivesToUse)
if max_pmem_supported >= pmem_size_GiB:
# check drive policies
(isValidDrivePolicies, _) = self._validator.\
checkLogicalNvdimmDrivePolicies(scalable_pmem_config.\
config_resource, drivesToUse)
if isValidDrivePolicies:
isValid = True
break
i += 1
if not isValid:
# TODO: more info? maybe build a list of reasons why certain drives will not work
raise InvalidCommandLineError(u"Requested size of {} GiB is not "\
"supported by the installed backup "\
"devices".format(pmem_size_GiB))
# get a list of the drives to show to the user
summary_drive_list = ["{:15} ({} GB)".format(d.formattedLocation, \
d.sizeGB) for d in drivesToUse]
# Make sure the user confirms the changes
sys.stdout.write(u"\nThe following backup devices have been "\
"automatically selected for Scalable PMEM:\n")
self._helpers.printLimitedMessageList(summary_drive_list, 99)
sys.stdout.write(u"\n")
if not confirm:
if self._rdmc.interactive:
# TODO: timeout
s = raw_input(
u"\nConfirm changes? Y(y) to confirm. N(n) to cancel: ")
if s == 'y' or s == 'Y':
confirm = True
else:
raise NoChangesFoundOrMadeError(
u"No changes have been made")
else:
raise NoChangesFoundOrMadeError(u"No changes have been made. "\
"To confirm the changes, specify --confirm")
if confirm:
# if all is valid, configure the related BIOS setting
self._restHelpers.setDrives(new_drives=drivesToUse)
#self._restHelpers.enableConfiguration()
scalable_pmem_config.refresh()
self._helpers.displayDrivesConfiguration(scalable_pmem_config)
def sort_drives(self, sameModel, sameSize, supported_drives):
""" sort drives into separate groups based on model or size.
if same model or size, then order doesn't matter
else the drives are sorted largest to smallest size
:param sameModel: specifies if drives need to be the same model
:type sameModel: Boolean
:param sameSize: specifies is drives need to be the same size, model takes precedence
:type sameSize: Boolean
:param supported_drives: list of all supported drives
:type supported_drives: list of Drives
:returns: 2D list of supported drives, where a row is a group of """\
"""drives based on model or size
:rtype: 2D list of Drive
"""
supported_drives_groups = [] # 2D Array, row=model or size
if sameModel:
# separate drives by model
# for each model, build a list of drives
models = set([drive.model for drive in supported_drives])
for model_to_find in models:
drive_model_group = [drive for drive in supported_drives if \
drive.model == model_to_find]
supported_drives_groups.append(drive_model_group)
elif sameSize:
# separate drives by size
sizes = set([drive.sizeMB for drive in supported_drives])
for size_to_find in sizes:
drive_size_group = [drive for drive in supported_drives if \
drive.sizeMB == size_to_find]
supported_drives_groups.append(drive_size_group)
else:
# contains one list of all supported drives, regardless of size or model
# sort by the size, descending from largest to smallest
sorted_supported_drives = sorted(supported_drives, key=lambda d: d.sizeMB,\
reverse=True)
supported_drives_groups.append(sorted_supported_drives)
return supported_drives_groups
def run(self, line):
""" Wrapper function for new command main function
:param line: command line input
:type line: string.
"""
LOGGER.info("Scalable PMEM: {}".format(self.name))
try:
(options, _) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
LOGGER.info("Options: {}".format(options))
if options.size <= 0:
self.parser.print_help()
raise InvalidCommandLineError("Invalid value for --size")
self.autoselectdrives(options.size, options.confirm)
#Return code
return ReturnCodes.SUCCESS
def definearguments(self, customparser):
""" Wrapper function for new command main function
:param customparser: command line input
:type customparser: parser.
"""
customparser.add_option(
'--size',
'-s',
dest='size',
default=-1,
action="store",
help="Amount (in GiB) of Scalable Persistent Memory to be supported"\
" by the new backup storage device configuration.",
type="int"
)
groupDanger = OptionGroup(customparser, "Dangerous Options", \
"Use of these options will alter the Scalable Persistent Memory " \
"configuration\nand will cause data loss. Back up all data first.")
groupDanger.add_option(
'--confirm',
action="store_true",
default=False,
dest="confirm",
help="Confirm the configuration of the automatically selected backup"\
" devices. If not specified, no changes will occur."
)
customparser.add_option_group(groupDanger)
class RemoveLogicalNVDIMMRegionCommand(RdmcCommandBase):
""" Main removelogicalnvdimm command class """
def __init__(self, rdmcObj):
RdmcCommandBase.__init__(self, \
name='removelogicalnvdimm', \
usage='removelogicalnvdimm (--processor=NUMBER --index=INDEX | '\
'--pair=PAIR)\n\n\tRemove a logical NVDIMM. All data will be lost.\n'\
'\n\texample: removelogicalnvdimm --processor=1 --index=1'\
'\n\texample: removelogicalnvdimm --processors=1,2', \
summary='Remove an existing logical NVDIMM.', \
aliases=['lnvdimm-remove', 'lnr'], \
optparser=OptionParser())
self.definearguments(self.parser)
self._rdmc = rdmcObj
self._helpers = Helpers()
self._restHelpers = RestHelpers(self._rdmc)
self._chif_lib = self._helpers.gethprestchifhandle()
def removeRegion(self, options):
""" Removes the Logical NVDIMM specified
:param socketIdx: the socket of the NUMA region, or None for Non-NUMA
:type socketIdx: string or int
:param regionIdx: the index of the region
:type regionIdx: string or int
"""
validator = LogicalNvdimmValidator()
scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
validator, self._chif_lib)
scalable_pmem_config.refresh()
# pre-validation
self._helpers.validateAllConfigurationPolicies(scalable_pmem_config)
matchingRegion = None
if options.processorPair:
matchingPair = next((p for _, p in scalable_pmem_config.regions.\
socketPairs.items() if p.labelString == options.\
processorPair), None)
if matchingPair:
matchingRegion = matchingPair.nonNumaRegion
else:
matchingSocket = next((s for _, s in scalable_pmem_config.regions.\
sockets.items() if s.labelString == options.\
processorNumber), None)
if matchingSocket:
matchingRegion = matchingSocket.numaRegions.get(options.index)
if matchingRegion and matchingRegion.isConfigured:
if self._rdmc.interactive:
if matchingRegion.isActivelyConfigured:
self._helpers.confirmBeforeConfigCausesDataLoss(scalable_pmem_config)
patchAttributes = {
matchingRegion.settingName : 0
}
_ = self._restHelpers.patchScalablePmemSettingAttributes(patchAttributes)
else:
self._helpers.displayRegionConfiguration(scalable_pmem_config)
raise InvalidCommandLineError(u"Unable to identify an existing logical NVDIMM")
# display the new state
scalable_pmem_config.refresh()
self._helpers.displayRegionConfiguration(scalable_pmem_config)
sys.stdout.write(u"\n")
def run(self, line):
""" Wrapper function for the Remove logical NVDIMM command
:param line: command line input
:type line: string.
"""
LOGGER.info("Scalable PMEM: {}".format(self.name))
try:
(options, _) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
LOGGER.info("Options: {}".format(options))
if not self._chif_lib:
self._helpers.failNoChifLibrary()
if not options.processorNumber and not options.processorPair:
self.parser.print_help()
raise InvalidCommandLineError(u"One of --processor or --processors"\
" is required")
if options.processorNumber and options.processorPair:
self.parser.print_help()
raise InvalidCommandLineError(u"--processor and --processors may not"\
" be used at the same time")
if options.processorNumber:
if options.index is None:
self.parser.print_help()
raise InvalidCommandLineError(u"--index must be specified with "\
"--processor")
self.removeRegion(options)
if options.processorPair:
if not options.index is None:
self.parser.print_help()
raise InvalidCommandLineError(u"--index is not a valid option to"\
" use with --processors")
self.removeRegion(options)
#Return code
return ReturnCodes.SUCCESS
def definearguments(self, customparser):
""" Define the arguments in the remove region function
:param customparser: command line input
:type customparser: parser.
"""
groupDanger = OptionGroup(customparser, "Dangerous Options", \
"Use of these options will alter the backup storage devices configured\n" \
"for use with Scalable Persistent Memory and could cause data loss. "\
"Back up all\ndata first.")
groupDanger.add_option(
'--proc',
'--processor',
action="store",
type="string",
default=None,
dest="processorNumber",
metavar="NUMBER",
help="Specify the processor number of the logical NVDIMM to remove (1, 2)."
)
groupDanger.add_option(
'-i',
'--index',
type="int",
default=None,
dest="index",
help="Specify the index of the logical NVDIMM to remove (use with --processor).")
groupDanger.add_option(
'--pair',
'--processors',
action="store",
type="string",
default=None,
dest="processorPair",
metavar="PAIR",
help="Specify the pair of processors of the spanned logical NVDIMM to remove (1,2)."
)
customparser.add_option_group(groupDanger)
class ShowLogicalNVDIMMConfigurationCommand(RdmcCommandBase):
""" Main showscalablepmemconfig command class """
def __init__(self, rdmcObj):
RdmcCommandBase.__init__(self,\
name='showscalablepmemconfig', \
usage='showscalablepmemconfig [OPTIONS]\n\n'\
'\tDisplay the Scalable Persistent Memory configuration.\n'\
'\tIf system is configured, reports the estimated time to complete a backup boot.\n\n'\
'\texample: showscalablepmemconfig', \
summary='Display the Scalable Persistent Memory configuration.', \
aliases=['spmem-showcfg', 'spmemsc'], \
optparser=OptionParser())
self.definearguments(self.parser)
self._rdmc = rdmcObj
self._helpers = Helpers()
self._chif_lib = self._helpers.gethprestchifhandle()
self._restHelpers = RestHelpers(rdmcObject=self._rdmc)
self._options = None
def showLogicalNvdimmConfig(self, options):
""" Main showlogicalnvdimmconfig command worker function
:param options: command options
:type options: options.
"""
if self._rdmc.app.config._ac__format.lower() == 'json':
options.json = True #pragma: no cover
validator = LogicalNvdimmValidator()
scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
validator, self._chif_lib)
scalable_pmem_config.refresh()
# overall config status
self._helpers.validateAllConfigurationPolicies(scalable_pmem_config, \
output_as_json=options.json)
if options.available:
if not options.json:
self._helpers.writeHeader2(u"Available Scalable Persistent Memory")
sys.stdout.write("Available capacity to create logical NVDIMMs "\
"is constrained by the system\n hardware, including"\
" the number of backup storage devices selected.\n")
self._helpers.displayAvailableCapacity(scalable_pmem_config, \
output_as_json=options.json)
else:
if not options.json:
# overall config enabled and capacity graph
self._helpers.writeHeader2(u"Overall Allocated Scalable Persistent Memory")
sys.stdout.write(u"\n")
self._helpers.displayOverallCapacityBarGraph(scalable_pmem_config, 60)
self._helpers.printBackupBootTimeMessage(scalable_pmem_config)
if len(scalable_pmem_config.drives.selectedDrives) == 0:
sys.stdout.write("* No backup storage devices have been selected")
sys.stdout.write(u"\n")
# allocated logical nvdimms
self._helpers.writeHeader2(u"Logical NVDIMMs")
self._helpers.displayRegionConfiguration(scalable_pmem_config, \
output_as_json=options.json, \
print_backup_time_message=False)
sys.stdout.write(u"\n\n")
def run(self, line):
""" Wrapper function for showlogicalnvdimmconfiguration command main function
:param line: command line input
:type line: string.
"""
LOGGER.info("Scalable PMEM: {}".format(self.name))
try:
(options, args) = self._parse_arglist(line)
if options:
self._options = options
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if len(args):
InvalidCommandLineError("This command takes no parameters.")
LOGGER.info("Options: {}".format(options))
if not self._chif_lib:
self._helpers.failNoChifLibrary()
self.showLogicalNvdimmConfig(options)
#Return code
return ReturnCodes.SUCCESS
def definearguments(self, customparser):
""" Defines argument for the command
:param customparser: command line input
:type customparser: parser.
"""
customparser.add_option(
'-a',
'--available',
action="store_true",
dest="available",
help="Show the available capacity per processor or processor pair."
)
customparser.add_option(
'-j',
'--json',
action="store_true",
dest="json",
help="Optionally include this flag to change the output to JSON format.",
default=False
)
