def run(self, line):
""" Main clearrestapistate function.
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self.rdmc.rdmc_parse_arglist(self, line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if args:
raise InvalidCommandLineError(
"clearrestapistate command takes no arguments.")
self.clearrestapistatevalidation(options)
select = 'Manager.'
results = self.rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
path = results.resp.request.path
else:
raise NoContentsFoundForOperationError("Manager. not found.")
bodydict = results.resp.dict['Oem'][self.rdmc.app.typepath.defs.oemhp]
try:
for item in bodydict['Actions']:
if 'ClearRestApiState' in item:
if self.rdmc.app.typepath.defs.isgen10:
action = item.split('#')[-1]
else:
action = "ClearRestApiState"
path = bodydict['Actions'][item]['target']
body = {"Action": action}
break
except:
body = {"Action": "ClearRestApiState", "Target": "/Oem/Hp"}
self.rdmc.app.post_handler(path, body)
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
class RawPostCommand(RdmcCommandBase):
""" Raw form of the post command """
def __init__(self, rdmcObj):
RdmcCommandBase.__init__(self,\
name='rawpost',\
usage='rawpost [FILENAME] [OPTIONS]\n\n\tRun to send a post from ' \
'the data in the input file.\n\texample: rawpost rawpost.' \
'txt\n\n\tExample input file:\n\t{\n\t "path": "/' \
'redfish/v1/systems/(system ID)/Actions/ComputerSystem.'
'Reset",\n\t "body": {\n\t "ResetType": '\
'"ForceRestart"\n\t }\n\t}',\
summary='This is the raw form of the POST command.',\
aliases=['rawpost'],\
optparser=OptionParser())
self.definearguments(self.parser)
self._rdmc = rdmcObj
self.lobobj = rdmcObj.commandsDict["LoginCommand"](rdmcObj)
def run(self, line):
""" Main raw patch worker function
:param line: command line input
:type line: string.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
url = None
headers = {}
results = None
if options.sessionid:
url = self.sessionvalidation(options)
else:
self.postvalidation(options)
contentsholder = None
if len(args) == 1:
try:
inputfile = open(args[0], 'r')
contentsholder = json.loads(inputfile.read())
except Exception, excp:
raise InvalidFileInputError("%s" % excp)
elif len(args) > 1:
raise InvalidCommandLineError("Raw post only takes 1 argument.\n")
def secureboothelper(self, securebootoption):
""" Helper function for secure boot function
:param securebootoption: option passed in for secure boot
:type securebootoption: string.
"""
actionlist = ['defaultkeys', 'deletekeys', 'deletepk']
if not securebootoption.lower() in actionlist:
raise InvalidCommandLineError('%s is not a valid option for '\
'the securebootkeys flag.' % securebootoption)
if securebootoption == actionlist[0]:
action = 'ResetAllKeysToDefault'
elif securebootoption == actionlist[1]:
action = 'DeleteAllKeys'
elif securebootoption == actionlist[2]:
action = 'DeletePK'
results = self.rdmc.app.select(
selector=self.rdmc.app.typepath.defs.hpsecureboot)
try:
results = results[0]
except:
pass
if results:
path = results.resp.request.path
results = results.resp.dict
try:
for item in results['Actions']:
if 'ResetKeys' in item:
path = results['Actions'][item]['target']
break
body = {"ResetKeysType": action}
self.rdmc.app.post_handler(path, body)
except:
if securebootoption == actionlist[0]:
self.auxcommands['select'].selectfunction(
self.rdmc.app.typepath.defs.hpsecureboot)
self.auxcommands['set'].run('ResetToDefaultKeys=True --commit')
elif securebootoption == actionlist[1]:
self.auxcommands['select'].selectfunction(
self.rdmc.app.typepath.defs.hpsecureboot)
self.auxcommands['set'].run('ResetAllKeys=True --commit')
else:
self.rdmc.ui.warn(
"DeletePK option is not available on Gen9.\n")
def validate_options(self, options):
"""
Validate whether options specified by user are valid or not
:param options: options specified by the user with the 'provisionpmm' command
:type options: instance of OptionParser class
"""
some_flag = options.memorymode or options.interleave or options.proc or options.force
if not some_flag:
raise InvalidCommandLineError("No flag specified.\n\nUsage: " +
self.usage)
# If the memory mode option value is not valid.
if options.memorymode < 0 or options.memorymode > 100:
raise InvalidCommandLineError("Specify the correct value (1-100)"
" to configure PMM")
if options.interleave:
if (options.interleave).lower() not in ['on', 'off']:
raise InvalidCommandLineError("Specify the correct value to set interleave"\
" state of persistent memory regions\n\n" + self.usage)
options.interleave = options.interleave.lower()
if options.proc and not options.memorymode and not options.interleave:
raise InvalidCommandLineError \
("Use '-m|--memory-mode' flag to specify the size in percentage"
" or '-i|--pmem-interleave' flag to set interleave"
" state of persistent memory regions")
# If not 100% memorymode, -i flag is mandatory to interleave memroy regions.
if options.memorymode >= 0 and options.memorymode < 100 and not options.interleave:
raise InvalidCommandLineError(
"Use '-i | --pmem-interleave' flag to"
" specify the interleave state of persistent"
" memory regions")
if options.proc:
for proc_id in options.proc:
if not proc_id.isdigit():
raise InvalidCommandLineError(
"Specify the correct processor id")
def run(self, line):
""" Main factorydefaults function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self.rdmc.rdmc_parse_arglist(self, line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if not len(args) == 1:
raise InvalidCommandLineError(
"backuprestore command takes one argument.")
self.ilobackuprestorevalidation(options)
if 'blobstore' in self.rdmc.app.current_client.base_url:
raise InvalidCommandLineError(
"This command is only available remotely.")
sessionkey = self.rdmc.app.current_client.session_key
#sessionkey = (sessionkey).encode('ascii', 'ignore')
if args[0].lower() == 'backup':
self.backupserver(options, sessionkey)
elif args[0].lower() == 'restore':
self.restoreserver(options, sessionkey)
else:
raise InvalidCommandLineError("%s is not a valid option for this "\
"command."% str(args[0]))
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main disk inventory worker function
:param line: command line input
:type line: string.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.createlogicaldrivevalidation(options)
self.selobj.selectfunction("SmartStorageConfig.")
content = self._rdmc.app.get_save()
if not options.controller:
raise InvalidCommandLineError('You must include a controller '\
'to select.')
controllist = []
if not args:
raise InvalidCommandLineError('Please choose customdrive or '\
'quickdrive creation.')
elif args[0].lower() == 'customdrive' and not len(args) == 3:
raise InvalidCommandLineError('customdrive takes 2 arguments')
elif args[0].lower() == 'quickdrive' and not len(args) == 6:
raise InvalidCommandLineError('quickdrive takes 5 arguments')
elif not args[0] in ['quickdrive', 'customdrive']:
raise InvalidCommandLineError('Please choose customdrive or '\
'quickdrive creation.')
if options.controller.isdigit() and not options.controller == '0':
try:
controllist.append(content[int(options.controller) - 1])
except:
pass
else:
for control in content:
if options.controller.lower() == control["Location"].lower():
controllist.append(control)
if not controllist:
raise InvalidCommandLineError("Selected controller not " \
"found in the current inventory list.")
else:
for controller in controllist:
if self.createlogicaldrive(args[0], args[1:], options,
controller):
controller['DataGuard'] = "Disabled"
self._rdmc.app.put_handler(controller["@odata.id"], \
controller, headers={'If-Match': \
self.getetag(controller['@odata.id'])})
self._rdmc.app.reloadmonolith(controller["@odata.id"])
#Return code
return ReturnCodes.SUCCESS
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 validate_options(self, options):
"""
Validate whether options specified by user are valid.
:param options: options specified by the user.
:type options: instance of OptionParser class.
"""
# Set of valid configIDs
valid_config_ids = {config_id.get("name").lower() for config_id
in self.config_ids}
if not options.config and not options.list and not options.force:
raise InvalidCommandLineError(
"No flag specified.\n\nUsage: " + self.usage)
if not options.config and options.force:
raise InvalidCommandLineError("'--force | -f' flag mandatorily requires the "
"'--config | -C' flag.")
if options.config and options.list:
raise InvalidCommandLineError("Only one of '--config | -C' or '--list | -L' "
"may be specified")
# Check whether the user entered configID is valid
if options.config and not options.config.lower() in valid_config_ids:
raise InvalidCommandLineError("Invalid configID.\nTo view a list of pre-defined "
"configIDs, use 'applypmmconfig --list'")
def run(self, line):
""" Main deletecomp worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self.rdmc.rdmc_parse_arglist(self, line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.deletecomponentvalidation(options)
if self.rdmc.app.typepath.defs.isgen9:
raise IncompatibleiLOVersionError('iLO Repository commands are ' \
'only available on iLO 5.')
comps = self.rdmc.app.getcollectionmembers(\
'/redfish/v1/UpdateService/ComponentRepository/')
if not comps:
self.rdmc.ui.warn('No components found to delete\n')
elif options.deleteall:
delopts = []
for comp in comps:
try:
if comp['Locked']:
self.rdmc.ui.warn("Unable to delete %s. It is in use by "\
"an install set or update task.\n" % comp['Filename'])
continue
except KeyError:
pass
delopts.append(comp['@odata.id'])
self.deletecomponents(comps, delopts)
elif args:
self.deletecomponents(comps, args)
else:
InvalidCommandLineError(
"Please include the component(s) you wish to delete")
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main firmware update worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if args:
raise InvalidCommandLineError('fwintegritycheck command takes no ' \
'arguments')
self.firmwareintegritycheckvalidation(options)
if self.typepath.defs.isgen9:
raise IncompatibleiLOVersionError('fwintegritycheck command is ' \
'only available on iLO 5.')
licenseres = self._rdmc.app.filter('HpeiLOLicense.', None, None)
try:
licenseres = licenseres[0]
except:
pass
if not licenseres.dict['LicenseFeatures']['FWScan']:
raise IloLicenseError(
"This command is not available with this iLO license.")
select = self.typepath.defs.hpilofirmwareupdatetype
results = self._rdmc.app.filter(select, None, None)
try:
results = results[0]
except:
pass
bodydict = results.resp.dict
path = bodydict['Oem']['Hpe']['Actions']\
['#HpeiLOUpdateServiceExt.StartFirmwareIntegrityCheck']['target']
self._rdmc.app.post_handler(path, {})
return ReturnCodes.SUCCESS
def selection_output(self, options, content):
""" Selection of output for smart array command
:param options: command line options
:type options: list.
:param options: list of contents
:type options: list.
"""
controllist = []
outputcontent = False
if options.controller.isdigit() and not options.controller == '0':
try:
controllist.append(content[int(options.controller) - 1])
except:
pass
else:
for control in content:
if options.controller.lower() == control["Location"].lower():
controllist.append(control)
if not controllist:
raise InvalidCommandLineError("Selected controller not " \
"found in the current inventory list.")
else:
for controller in controllist:
if options.physicaldrives or options.pdrive:
outputcontent = True
try:
self.get_drives(options,
controller["PhysicalDrives"],
physical=True)
except KeyError as excp:
if excp.message == "PhysicalDrives":
raise IncompatableServerTypeError("Cannot "\
"configure physical drives using this controller.")
if options.logicaldrives or options.ldrive:
outputcontent = True
self.get_drives(options,
controller["LogicalDrives"],
logical=True)
if not outputcontent:
for k in list(controller.keys()):
if k.lower() in HARDCODEDLIST or '@odata' in k.lower():
del controller[k]
UI().print_out_json_ordered(controller)
def run(self, line):
""" Main iscsi configuration worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.iscsiconfigurationvalidation(options)
if self.typepath.defs.biospath[-1] == '/':
iscsipath = self.typepath.defs.biospath + 'iScsi/'
iscsisettingspath = self.typepath.defs.biospath + 'iScsi/settings/'
bootpath = self.typepath.defs.biospath + 'Boot/'
else:
iscsipath = self.typepath.defs.biospath + '/iScsi'
iscsisettingspath = self.typepath.defs.biospath + '/iScsi/settings'
bootpath = self.typepath.defs.biospath + '/Boot'
if options.list:
self.listoptionhelper(options, iscsipath, iscsisettingspath, \
bootpath)
elif options.modify:
self.modifyoptionhelper(options, iscsisettingspath)
elif options.add:
self.addoptionhelper(options, iscsipath, iscsisettingspath, \
bootpath)
elif options.delete:
self.deleteoptionhelper(options, iscsisettingspath)
elif not args:
self.defaultsoptionhelper(options, iscsipath, bootpath)
else:
if len(args) < 2:
self.iscsiconfigurationvalidation(options)
else:
raise InvalidCommandLineError("Invalid number of parameters. " \
"Iscsi configuration takes a maximum of 1 parameter.")
if options.reboot:
self.rebootobj.run(options.reboot)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
"""
Wrapper function for new command main function
:param line: command line input
:type line: string.
"""
LOGGER.info("PMM Pending Configuration: %s", self.ident['name'])
try:
(options, args) = self.rdmc.rdmc_parse_arglist(self, line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineError("Failed to parse options")
if args:
raise InvalidCommandLineError(
"Chosen command or flag doesn't expect additional arguments")
# Raise exception if server is in POST
if RestHelpers(rdmcObject=self.rdmc).in_post():
raise NoContentsFoundForOperationError("Unable to retrieve resources - "\
"server might be in POST or powered off")
self.show_pending_config(options)
return ReturnCodes.SUCCESS
def run(self, line):
"""
Wrapper function for new command main function
:param line: command line input
:type line: string.
"""
LOGGER.info("Show Recommended Configuration: %s", self.name)
try:
(_, args) = self._parse_arglist(line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineError("Failed to parse options")
if args:
raise InvalidCommandLineError(
"Chosen command doesn't expect additional arguments")
# Raise exception if server is in POST
if self._rest_helpers.in_post():
raise NoContentsFoundForOperationError("Unable to retrieve resources - "\
"server might be in POST or powered off")
self.show_recommended_config()
return ReturnCodes.SUCCESS
def run(self, line):
""" Main serverinfo function.
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self._parse_arglist(line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if args:
raise InvalidCommandLineError("serverinfo command takes no "\
"arguments.")
self.serverinfovalidation(options)
self.optionsvalidation(options)
info = self.gatherinfo(options)
if not info:
raise InvalidCommandLineError("Please verify the commands entered "\
"and try again.")
if options.json:
UI().print_out_json(info)
else:
self.prettyprintinfo(info, options.showabsent)
logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main disk inventory worker function
:param line: command line input
:type line: string.
"""
try:
(options, _) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.frcontrollervalidation(options)
self.selobj.selectfunction("SmartStorageConfig.")
content = self._rdmc.app.getprops()
if options.controller:
controllist = []
if options.controller.isdigit() and not options.controller == '0':
try:
controllist.append(content[int(options.controller) - 1])
except:
pass
else:
for control in content:
if options.controller.lower() == control["Location"].lower(
):
controllist.append(control)
if not controllist:
raise InvalidCommandLineError("Selected controller not " \
"found in the current inventory list.")
else:
for controller in controllist:
contentsholder = {"Actions": [{"Action": "FactoryReset"}], \
"DataGuard": "Disabled"}
self._rdmc.app.patch_handler(controller["@odata.id"],
contentsholder)
else:
for idx, val in enumerate(content):
sys.stdout.write("[%d]: %s\n" % (idx + 1, val["Location"]))
#Return code
return ReturnCodes.SUCCESS
def serverinfovalidation(self, options):
""" serverinfo method validation function.
:param options: command line options
:type options: list.
"""
client = None
inputline = list()
try:
client = self._rdmc.app.current_client
except:
if options.user or options.password or options.url:
if options.url:
inputline.extend([options.url])
if options.user:
if options.encode:
options.user = Encryption.decode_credentials(
options.user)
inputline.extend(["-u", options.user])
if options.password:
if options.encode:
options.password = Encryption.decode_credentials(
options.password)
inputline.extend(["-p", options.password])
if options.https_cert:
inputline.extend(["--https", options.https_cert])
else:
if self._rdmc.app.config.get_url():
inputline.extend([self._rdmc.app.config.get_url()])
if self._rdmc.app.config.get_username():
inputline.extend(
["-u", self._rdmc.app.config.get_username()])
if self._rdmc.app.config.get_password():
inputline.extend(
["-p", self._rdmc.app.config.get_password()])
if self._rdmc.app.config.get_ssl_cert():
inputline.extend(
["--https",
self._rdmc.app.config.get_ssl_cert()])
if inputline or not client:
if not inputline:
sys.stdout.write('Local login initiated...\n')
self.lobobj.loginfunction(inputline)
elif not client:
raise InvalidCommandLineError("Please login or pass credentials" \
" to complete the operation.")
def defaultsvalidation(self, options):
""" BIOS defaults method validation function """
client = None
inputline = list()
try:
client = self._rdmc.app.current_client
except:
if options.user or options.password or options.url:
if options.url:
inputline.extend([options.url])
if options.user:
if options.encode:
options.user = Encryption.decode_credentials(
options.user)
inputline.extend(["-u", options.user])
if options.password:
if options.encode:
options.password = Encryption.decode_credentials(
options.password)
inputline.extend(["-p", options.password])
if options.https_cert:
inputline.extend(["--https", options.https_cert])
else:
if self._rdmc.app.config.get_url():
inputline.extend([self._rdmc.app.config.get_url()])
if self._rdmc.app.config.get_username():
inputline.extend(
["-u", self._rdmc.app.config.get_username()])
if self._rdmc.app.config.get_password():
inputline.extend(
["-p", self._rdmc.app.config.get_password()])
if self._rdmc.app.config.get_ssl_cert():
inputline.extend(
["--https",
self._rdmc.app.config.get_ssl_cert()])
if inputline:
self.lobobj.loginfunction(inputline)
elif not client:
raise InvalidCommandLineError("Please login or pass credentials" \
" to complete the operation.")
if options.encode:
options.biospassword = Encryption.decode_credentials(
options.biospassword)
def modifyoptionhelper(self, options, iscsisettingspath):
""" Helper function to modify options for iscsi
:param options: command line options
:type options: list.
:param iscsisettingspath: current iscsi settings path
:type iscsisettingspath: str.
"""
try:
inputfile = open(options.modify, 'r')
contentsholder = json.loads(inputfile.read())
except Exception as excp:
raise InvalidCommandLineError("%s" % excp)
iscsibootsources = self.rawdatahandler(action="GET",
silent=True,
jsonflag=True,
path=iscsisettingspath)
count = 0
resultsdict = list()
for item in contentsholder:
for entry in item.values():
enteredsection = False
for key, value in entry.items():
enteredsection = True
resultsdict.append(
self.modifyfunctionhelper(
key, value, iscsibootsources[
self.rdmc.app.typepath.defs.iscsisource]))
if not enteredsection:
resultsdict.append(iscsibootsources[
self.rdmc.app.typepath.defs.iscsisource][count])
count += 1
contentsholder = {self.rdmc.app.typepath.defs.iscsisource: resultsdict}
self.rdmc.app.patch_handler(iscsisettingspath,
contentsholder,
optionalpassword=options.biospassword)
self.rdmc.app.get_handler(iscsisettingspath, silent=True)
def vmbootnextreset(self, args, paths):
"""Worker function to boot virtual media on next serverreset
:param args: arguments passed from command line
:type args: list
:param paths: all virtual media paths
:type paths: list
"""
try:
path = paths[int(args[0])]
except:
raise InvalidCommandLineError("Invalid input value for virtual media"\
" please run the command with no " \
"arguments for possible values.")
self.rdmc.app.patch_handler(path, \
{"Oem":{self.rdmc.app.typepath.defs.oemhp:{"BootOnNextServerReset":\
True}}}, service=True, silent=True)
def run(self, line):
""" Main deletecomp worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
self.deletecomponentvalidation(options)
if self.typepath.defs.isgen9:
raise IncompatibleiLOVersionError('iLO Repository commands are ' \
'only available on iLO 5.')
comps = self._rdmc.app.getcollectionmembers(\
'/redfish/v1/UpdateService/ComponentRepository/')
if not comps:
sys.stdout.write('No components found to delete\n')
elif options.deleteall:
delopts = []
for comp in comps:
delopts.append(comp['@odata.id'])
self.deletecomponents(comps, delopts)
elif args:
self.deletecomponents(comps, args[0])
else:
InvalidCommandLineError("Please include the component(s) you wish "\
"to delete")
return ReturnCodes.SUCCESS
def run(self, line):
""" Wrapper function for help main function
:param line: command line input
:type line: string.
"""
try:
(_, args) = self._parse_arglist(line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if not args or not line:
RdmcOptionParser().print_help()
if self._rdmc:
cmddict = self._rdmc.get_commands()
sorted_keys = sorted(list(cmddict.keys()))
for key in sorted_keys:
if key[0] == '_':
continue
else:
sys.stdout.write('\n%s\n' % key)
for cmd in cmddict[key]:
cmd.print_summary()
else:
if self._rdmc:
cmddict = self._rdmc.get_commands()
sorted_keys = list(cmddict.keys())
for key in sorted_keys:
for cmd in cmddict[key]:
if cmd.ismatch(args[0]):
cmd.print_help()
return ReturnCodes.SUCCESS
raise InvalidCommandLineError("Command '%s' not found." %
args[0])
#Return code
return ReturnCodes.SUCCESS
def clonevalidation(self, options):
""" results method validation function
:param options: command line options
:type options: list.
"""
client = None
inputline = list()
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
try:
client = self._rdmc.app.get_current_client()
if options.user and options.password:
if not client.get_username():
client.set_username(options.user)
if not client.get_password():
client.set_password(options.password)
except:
if options.user or options.password or options.url:
if options.url:
inputline.extend([options.url])
if options.user:
inputline.extend(["-u", options.user])
if options.password:
inputline.extend(["-p", options.password])
else:
if self._rdmc.app.config.get_url():
inputline.extend([self._rdmc.app.config.get_url()])
if self._rdmc.app.config.get_username():
inputline.extend(["-u", \
self._rdmc.app.config.get_username()])
if self._rdmc.app.config.get_password():
inputline.extend(["-p", \
self._rdmc.app.config.get_password()])
if inputline:
self.loginobj.loginfunction(inputline)
elif not client:
raise InvalidCommandLineError("Please login or pass credentials" \
" to complete the operation.")
def typesfunction(self, line, returntypes=False):
""" Main types worker function
:param line: command line input
:type line: string.
:param returntypes: flag to determine if types should be printed
:type returntypes: boolean.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
self.typesvalidation(options)
try:
if not args:
typeslist = list()
typeslist = list(set(self._rdmc.app.types(options.fulltypes)))
typeslist.sort()
if not returntypes:
sys.stdout.write("Type options:")
sys.stdout.write('\n')
for item in typeslist:
sys.stdout.write(item)
sys.stdout.write('\n')
else:
return typeslist
else:
raise InvalidCommandLineError("The 'types' command does not "\
"take any arguments.")
except redfish.ris.InstanceNotFoundError, infe:
raise redfish.ris.InstanceNotFoundError(infe)
def run(self, line):
"""
Wrapper function for new command main function
:param line: command line input
:type line: string.
"""
LOGGER.info("PMM Apply Pre-Defined Configuration: %s", self.name)
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineError("Failed to parse options")
if args:
self.validate_args(options)
self.validate_options(options)
self.apply_pmm_config(options)
return ReturnCodes.SUCCESS
def ilofunctionalityvalidation(self, options):
""" ilofunctionalityvalidation method validation function
:param options: command line options
:type options: list.
"""
client = None
inputline = list()
try:
client = self._rdmc.app.get_current_client()
if options.user and options.password:
if not client.get_username():
client.set_username(options.user)
if not client.get_password():
client.set_password(options.password)
except:
if options.user or options.password or options.url:
if options.url:
inputline.extend([options.url])
if options.user:
inputline.extend(["-u", options.user])
if options.password:
inputline.extend(["-p", options.password])
else:
if self._rdmc.app.config.get_url():
inputline.extend([self._rdmc.app.config.get_url()])
if self._rdmc.app.config.get_username():
inputline.extend(["-u", \
self._rdmc.app.config.get_username()])
if self._rdmc.app.config.get_password():
inputline.extend(["-p", \
self._rdmc.app.config.get_password()])
if inputline or not client:
if not inputline:
sys.stdout.write(u'Local login initiated...\n')
self.lobobj.loginfunction(inputline)
elif not client:
raise InvalidCommandLineError("Please login or pass credentials" \
" to complete the operation.")
def run(self, line):
""" Show pending changes of settings objects
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self._parse_arglist(line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if args:
raise InvalidCommandLineError("Pending command does not take any arguments.")
self.pendingvalidation(options)
self.pendingfunction()
return ReturnCodes.SUCCESS
def firmwareintegritycheckvalidation(self, options):
""" Firmware update method validation function
:param options: command line options
:type options: list.
"""
client = None
inputline = list()
try:
client = self._rdmc.app.get_current_client()
if options.user and options.password:
if not client.get_username():
client.set_username(options.user)
if not client.get_password():
client.set_password(options.password)
except Exception:
if options.user or options.password or options.url:
if options.url:
inputline.extend([options.url])
if options.user:
inputline.extend(["-u", options.user])
if options.password:
inputline.extend(["-p", options.password])
else:
if self._rdmc.app.config.get_url():
inputline.extend([self._rdmc.app.config.get_url()])
if self._rdmc.app.config.get_username():
inputline.extend(["-u", \
self._rdmc.app.config.get_username()])
if self._rdmc.app.config.get_password():
inputline.extend(["-p", \
self._rdmc.app.config.get_password()])
if inputline:
self.lobobj.loginfunction(inputline)
elif not client:
raise InvalidCommandLineError("Please login or pass credentials" \
" to complete the operation.")
def vmremovehelper(self, args, options, paths, isredfish, ilover):
"""Worker function to remove virtual media
:param args: arguments passed from command line
:type args: list
:param paths: virtual media paths
:type paths: list
:param isredfish: redfish flag
:type isredfish: bool
:param ilover: iloversion
:type ilover: int
:param options: command line options
:type options: list.
"""
path = None
if isredfish:
path, body = self.vmredfishhelper('remove', args[0])
else:
if ilover <= 4.230:
body = {"Image": None}
else:
body = {"Action": "EjectVirtualMedia", "Target": "/Oem/Hp"}
try:
path = paths[int(args[0])] if not path else path
except:
raise InvalidCommandLineError("Invalid input value for virtual " \
"media please run the command with no " \
"arguments for possible values.")
if ilover <= 4.230:
self.rdmc.app.patch_handler(path, body)
else:
self.rdmc.app.post_handler(path, body)
if options.reboot:
self.auxcommands['reboot'].run(options.reboot)
def deletecomponents(self, comps, delopts):
""" component validation function
:param comps: component list
:type comps: list.
:param delopts: delete items list
:type delopts: list.
"""
if ',' in delopts:
delopts = delopts.split(',')
elif not isinstance(delopts, list):
delopts = [delopts]
for opt in delopts:
deleted = False
if '/' in opt:
self._rdmc.app.delete_handler(opt)
deleted = True
else:
for comp in comps:
if opt == comp['Id'] or opt == comp['Filename']:
try:
if comp['Locked']:
sys.stdout.write("Unable to delete %s. It is in use by "\
"an install set or update task.\n" % comp['Filename'])
continue
except KeyError:
pass
self._rdmc.app.delete_handler(comp['@odata.id'])
deleted = True
if deleted:
sys.stdout.write('Deleted %s\n' % opt)
else:
raise InvalidCommandLineError('Cannot find or unable to delete component %s' \
% opt)
