def run(self, line):
""" Main ESKMCommand 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 not len(args) == 1:
raise InvalidCommandLineError("eskm command only takes" \
" one parameter.")
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
self.eskmvalidation(options)
select = self.typepath.defs.hpeskmtype
results = self._rdmc.app.filter(select, None, None)
try:
results = results[0]
except:
pass
if results:
path = results.resp.request.path
else:
raise NoContentsFoundForOperationError("ESKM not found.")
if args[0].lower() == 'clearlog':
actionitem = "ClearESKMLog"
elif args[0].lower() == 'testconnections':
actionitem = "TestESKMConnections"
else:
raise InvalidCommandLineError('Invalid command.')
bodydict = results.resp.dict
try:
for item in bodydict['Actions']:
if actionitem in item:
if self.typepath.defs.isgen10:
actionitem = item.split('#')[-1]
path = bodydict['Actions'][item]['target']
break
except:
pass
body = {"Action": actionitem}
self._rdmc.app.post_handler(path, body)
return ReturnCodes.SUCCESS
def run(self, line):
""" Main Certificates Command function
:param options: list of options
:type options: list.
"""
try:
(options, _) = self._parse_arglist(line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.certificatesvalidation(options)
if options.command == 'csr':
self.generatecerthelper(options)
elif options.command == 'ca':
self.importcahelper(options)
elif options.command == 'getcsr':
self.getcerthelper(options)
elif options.command == 'crl':
self.importcrlhelper(options)
elif options.command == 'tls':
self.importtlshelper(options)
logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def logoutfunction(self, line):
""" Main logout 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("")
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
client = self._rdmc.app.get_current_client()
try:
if options.user and options.password:
client = self._rdmc.app.get_current_client()
if not client.get_username():
client.set_username(options.user)
if not client.get_password():
client.set_password(options.password)
except:
pass
self._rdmc.app.logout("")
def run(self, line):
""" Main listcomp worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, _) = 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.listcomponentvalidation(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 comps:
self.printcomponents(comps, options)
else:
self.rdmc.ui.warn('No components found.\n')
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main update task queue 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.updatetaskqueuevalidation(options)
if self.typepath.defs.isgen9:
raise IncompatibleiLOVersionError(\
'iLO Repository commands are only available on iLO 5.')
if options.resetqueue:
self.resetqueue()
elif options.cleanqueue:
self.cleanqueue()
elif not args:
self.printqueue(options)
elif args[0].lower() == 'create':
self.createtask(args[1:], options)
else:
raise InvalidCommandLineError('Invalid command entered.')
return ReturnCodes.SUCCESS
def run(self, line):
""" Wrapper function for main list 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.listvalidation(options)
if args:
for arg in args:
newargs = list()
if "/" in arg:
newargs = arg.split("/")
arg = newargs[0]
if not self.getobj.getworkerfunction(arg, options, line,\
newargs=newargs, uselist=True):
raise NoContentsFoundForOperationError('No contents found '\
'for entry: %s\n' % arg)
else:
if not self.getobj.getworkerfunction(args, options, line, \
uselist=True):
raise NoContentsFoundForOperationError('No contents found.')
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main status 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("")
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
self.statusvalidation(options)
contents = self._rdmc.app.status()
selector = self._rdmc.app.get_selector()
if contents:
self.outputpatches(contents, selector)
else:
sys.stdout.write("No changes found\n")
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main update maintenance window worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, _) = self._parse_arglist(line, default=True)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.maintenancewindowvalidation(options)
if self.typepath.defs.isgen9:
raise IncompatibleiLOVersionError(\
'iLO Repository commands are only available on iLO 5.')
windows = self._rdmc.app.getcollectionmembers(\
'/redfish/v1/UpdateService/MaintenanceWindows/')
if options.command.lower() == 'add':
self.addmaintenancewindow(options, windows, options.time_window)
elif options.command.lower() == 'delete':
self.deletemaintenancewindow(windows, options.identifier)
else:
self.listmainenancewindows(options, windows)
logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main iLO reset worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, _) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.iloresetvalidation(options)
sys.stdout.write('\nAfter iLO resets the session will be terminated.' \
'\nPlease wait for iLO to initialize completely ' \
'before logging in again.\n')
sys.stdout.write('This process may take up to 3 minutes.\n\n')
select = "Manager."
results = self._rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
put_path = results.resp.request.path
else:
raise NoContentsFoundForOperationError("Unable to find %s" % select)
bodydict = results.resp.dict
try:
for item in bodydict['Actions']:
if 'Reset' in item:
if self.typepath.defs.isgen10:
action = item.split('#')[-1]
else:
action = 'Reset'
put_path = bodydict['Actions'][item]['target']
break
except:
action = "Reset"
body = {"Action": action}
postres = self._rdmc.app.post_handler(put_path, body, silent=True, \
service=True, response=True)
if postres.status == 200:
sys.stdout.write("A management processor reset is in progress.\n")
else:
sys.stderr.write("An error occured during iLO reset.\n")
raise IloResponseError("")
#Return code
return ReturnCodes.SUCCESS
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 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("")
self.typesvalidation(options)
if not args:
typeslist = list()
typeslist = sorted(set(self._rdmc.app.types(options.fulltypes)))
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.")
def run(self, line):
"""Main ilolicense 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.addlicensevalidation(options)
if not len(args) == 1:
raise InvalidCommandLineError("ilolicense command only takes one "\
"argument")
path = self.typepath.defs.addlicensepath
body = {"LicenseKey": "%s" % args[0]}
self._rdmc.app.post_handler(path, body)
return ReturnCodes.SUCCESS
def run(self, line):
""" Main installset 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.loggedin = None
self.comps = None
self.loggedin = self.minstallsetvalidation()
if self.loggedin and self.typepath.defs.isgen9:
raise IncompatibleiLOVersionError('iLO Repository commands are ' \
'only available on iLO 5.')
sys.stdout.write(
"Warning: This command will run in interactive mode.\n")
if args:
raise InvalidCommandLineError("makeinstallset command takes no "\
"arguments.")
self.minstallsetworker(options)
return ReturnCodes.SUCCESS
def run(self, line, autotest=False):
""" Main info worker function
:param line: command line input
:type line: string.
:param autotest: flag to determine if running automatictesting
:type autotest: bool.
"""
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.infovalidation(options)
if args:
inforesp = ''
for item in args:
newargs = list()
if self._rdmc.app.get_selector().lower().startswith('bios.') \
and not 'attributes' in item.lower():
if not (item.lower() in HARDCODEDLIST or '@odata' in item.lower()):
item = "Attributes/" + item
if "/" in item:
newargs = item.split("/")
item = newargs[0]
(contents, outdata) = self._rdmc.app.info(selector=item, \
dumpjson=options.json, autotest=autotest, newarg=newargs, \
latestschema=options.latestschema)
if outdata and options.json:
UI().print_out_json(outdata)
elif outdata:
sys.stdout.write(outdata)
if isinstance(contents, list) and not autotest:
if 'none' in contents and inforesp != 'success':
inforesp = 'none'
elif 'Success' in contents:
inforesp = 'success'
try:
if not contents or inforesp == 'none':
raise InfoMissingEntriesError("There are no valid "\
"entries for info in the current instance.")
except Exception, excp:
raise excp
if len(args) > 1 and not item == args[-1]:
sys.stdout.write("\n************************************"\
"**************\n")
def run(self, line):
""" Main sigrecompute 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(
"Sigrecompute command takes no arguments.")
self.sigrecomputevalidation(options)
path = self.rdmc.app.typepath.defs.systempath
if self.rdmc.app.typepath.defs.flagforrest:
body = {"Action": "ServerSigRecompute", "Target": "/Oem/Hp"}
self.rdmc.app.post_handler(path, body)
else:
raise IncompatibleiLOVersionError(
"Sigrecompute action not available on redfish.")
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main status worker function
:param line: command line input
:type line: string.
"""
try:
(options, _) = 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.statusvalidation(options)
contents = self.rdmc.app.status()
selector = self.rdmc.app.selector
if contents and options.json:
self.jsonout(contents)
elif contents:
self.outputpatches(contents, selector)
else:
self.rdmc.ui.warn("No changes found\n")
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main sigrecompute 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("Sigrecompute command takes no " \
"arguments.")
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
self.sigrecomputevalidation(options)
path = self.typepath.defs.systempath
if self.typepath.defs.flagforrest:
body = {"Action": "ServerSigRecompute", "Target": "/Oem/Hp"}
self._rdmc.app.post_handler(path, body)
else:
raise IncompatibleiLOVersionError("Sigrecompute action not " \
"available on redfish.")
return ReturnCodes.SUCCESS
def run(self, line):
""" Wrapper function for showlogicalnvdimmdrives 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)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if args:
raise InvalidCommandLineError("No argument is required.")
LOGGER.info("Options: {}".format(options))
if not self._chif_lib:
self._helpers.failNoChifLibrary()
self.showDriveData()
#Return code
return ReturnCodes.SUCCESS
def loginfunction(self, line, skipbuild=None):
""" Main worker function for login class
:param line: entered command line
:type line: list.
:param skipbuild: flag to determine if monolith should be build
:type skipbuild: boolean.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.loginvalidation(options, args)
try:
self._rdmc.app.login(username=self.username, \
password=self.password, base_url=self.url, \
verbose=self._rdmc.opts.verbose, \
path=options.path, skipbuild=skipbuild, \
includelogs=options.includelogs)
except Exception, excp:
raise excp
def run(self, line):
"""Main ilolicense 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.addlicensevalidation(options)
if not len(args) == 1:
raise InvalidCommandLineError("ilolicense command only takes one argument")
path = self.rdmc.app.typepath.defs.addlicensepath
body = {"LicenseKey": "%s" % args[0]}
self.rdmc.app.post_handler(path, body)
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main raw put 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.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
if options.sessionid:
url = self.sessionvalidation(options)
else:
self.putvalidation(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)
def run(self, line):
""" Main update task queue worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, _) = self._parse_arglist(line, default=True)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.updatetaskqueuevalidation(options)
if self.typepath.defs.isgen9:
raise IncompatibleiLOVersionError(\
'iLO Repository commands are only available on iLO 5.')
if options.command.lower() == 'create':
self.createtask(options.keywords.split(), options)
else:
if options.resetqueue:
self.resetqueue()
elif options.cleanqueue:
self.cleanqueue()
self.printqueue(options)
logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main factorydefaults 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 not len(args) == 1:
raise InvalidCommandLineError("backuprestore command takes one argument.")
self.ilobackuprestorevalidation(options)
if self._rdmc.app.current_client.get_base_url() == "blobstore://.":
raise InvalidCommandLineError("This command is only available remotely.")
sessionkey = self._rdmc.app.get_current_client()._rest_client.get_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]))
return ReturnCodes.SUCCESS
def run(self, line):
""" Main smart array 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("")
if options.encode and options.user and options.password:
options.user = Encryption.decode_credentials(options.user)
options.password = Encryption.decode_credentials(options.password)
self.smartarrayvalidation(options)
self.selobj.selectfunction("SmartStorageConfig")
content = self._rdmc.app.get_save()
if options.controller:
self.selection_output(options, content)
else:
self.discovery_output(options, content)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main installset 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.loggedin = None
self.comps = None
self.loggedin = self.minstallsetvalidation()
if self.loggedin and self.rdmc.app.typepath.defs.isgen9:
raise IncompatibleiLOVersionError('iLO Repository commands are ' \
'only available on iLO 5.')
self.rdmc.ui.warn("This command will run in interactive mode.\n")
if args:
raise InvalidCommandLineError("makeinstallset command takes no arguments.")
self.minstallsetworker(options)
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def loginfunction(self, line, skipbuild=None):
""" Main worker function for login class
:param line: entered command line
:type line: list.
:param skipbuild: flag to determine if monolith should be build
:type skipbuild: boolean.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.loginvalidation(options, args)
try:
self._rdmc.app.login(username=self.username, \
password=self.password, base_url=self.url, \
verbose=self._rdmc.opts.verbose, \
path=options.path, skipbuild=skipbuild, \
includelogs=options.includelogs)
except Exception:
raise
# Warning for cache enabled, since we save session in plain text
if self._rdmc.app.config.get_cache() and not skipbuild:
sys.stdout.write(u"WARNING: Cache is activated. Session keys are" \
u" stored in plaintext.\n")
if self._rdmc.opts.debug:
sys.stdout.write(u"WARNING: Logger is activated. Logging is" \
u" stored in plaintext.\n")
if options.selector:
try:
sel = None
val = None
if options.filter:
try:
(sel, val) = options.filter.split('=')
sel = sel.strip()
val = val.strip()
if val.lower() == "true" or val.lower() == "false":
val = val.lower() in ("yes", "true", "t", "1")
except:
raise InvalidCommandLineError("Invalid filter" \
" parameter format. [filter_attribute]=[filter_value]")
self._rdmc.app.select(query=options.selector, sel=sel, val=val)
if self._rdmc.opts.verbose:
sys.stdout.write("Selected option: '%s'" % options.selector)
sys.stdout.write('\n')
except Exception as excp:
raise redfish.ris.InstanceNotFoundError(excp)
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 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("")
if len(args):
InvalidCommandLineError("This command takes no parameters.")
LOGGER.info("Options: {}".format(options))
if not self._chif_lib:
self._helpers.failNoChifLibrary()
enable = True
if options.enableFeature is False:
enable = False
self.enableOrDisableFeature(enable)
#Return code
return ReturnCodes.SUCCESS
def controller_parse(option, opt_str, value, parser):
""" Controller Option Parsing
:param option: command line option
:type option: attributes
:param opt_str: parsed option string
:type opt_str: string
:param value: parsed option value
:type value: attribute
:param parser: OptionParser instance
:type parser: object
"""
setattr(parser.values, option.dest, [])
use_slot = False
use_indx = False
for _opt in value.split(','):
if _opt.isdigit() and not use_slot:
use_indx = True
parser.values.controller.append(int(_opt))
elif "slot" in _opt.lower() and not use_indx:
use_slot = True
parser.values.controller.append((_opt.replace('\"', '')).strip())
else:
raise InvalidCommandLineErrorOPTS("An invalid option or combination of options were " \
"used to specify a smart array controller.")
if use_indx:
parser.values.controller.sort()
def run(self, line):
""" Wrapper function for main list function
:param line: command line input
:type line: string.
"""
try:
(options, args) = self._parse_arglist(line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.listvalidation(options)
fvals = (None, None)
if options.filter:
try:
if (str(options.filter)[0] == str(options.filter)[-1])\
and str(options.filter).startswith(("'", '"')):
options.filter = options.filter[1:-1]
(sel, val) = options.filter.split('=')
fvals = (sel.strip(), val.strip())
except:
raise InvalidCommandLineError("Invalid filter" \
" parameter format [filter_attribute]=[filter_value]")
self.getobj.getworkerfunction(args, options, filtervals=fvals, uselist=False)
return ReturnCodes.SUCCESS