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 RevertScalablePmemConfigurationCommand(RdmcCommandBase):
""" Main revertscalablepmemconfig command class """
def __init__(self, rdmcObj):
RdmcCommandBase.__init__(self, \
name='revertscalablepmemconfig', \
usage='revertscalablepmemconfig\n\n'\
'\tDiscards any pending Scalable Persistent Memory configuration '\
'changes.\n\n\texample: revertscalablepmemconfig', \
summary='Discard pending Scalable Persistent Memory configuration changes.',\
aliases=['spmem-revertcfg', 'spmem-undocfg', 'spmemrc'], \
optparser=OptionParser())
self._rdmc = rdmcObj
self._helpers = Helpers()
self._restHelpers = RestHelpers(self._rdmc)
self._validator = LogicalNvdimmValidator()
self._chif_lib = self._helpers.gethprestchifhandle()
def revertPendingChanges(self):
""" Reverts any pending changes """
scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
self._validator, self._chif_lib)
scalable_pmem_config.refresh()
self._restHelpers.revertSettings()
scalable_pmem_config.refresh()
self._helpers.writeHeader2(u"Logical NVDIMMs")
self._helpers.displayRegionConfiguration(scalable_pmem_config)
self._helpers.writeHeader2(
u"Scalable Persistent Memory Backup Storage Devices")
self._helpers.displayDrivesConfiguration(scalable_pmem_config)
sys.stdout.write("\n\n")
def run(self, line):
""" Wrapper function for the revert configuration 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()
self.revertPendingChanges()
#Return code
return ReturnCodes.SUCCESS
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
)
