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.name)
try:
(options, 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 or flag 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_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("PMM: %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(args, options)
self.validate_options(options)
# 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.configure_pmm(options)
return ReturnCodes.SUCCESS
def handle_exceptions(self, excp):
""" Main exception handler for both shell and interactive modes
:param excp: captured exception to be handled
:type excp: exception.
"""
try:
if excp:
errorstr = "Exception: {0}".format(excp.__class__.__name__)
errorstr = errorstr+"({0})".format(excp.message) if \
hasattr(excp, "message") else errorstr
LOGGER.info(errorstr)
raise
# ****** RDMC ERRORS ******
except ConfigurationFileError as excp:
self.retcode = ReturnCodes.CONFIGURATION_FILE_ERROR
UI().error(excp)
sys.exit(excp.errcode)
except CommandNotEnabledError as excp:
self.retcode = ReturnCodes.COMMAND_NOT_ENABLED_ERROR
UI().command_not_enabled(excp)
extensions.Commands['HelpCommand'](rdmc=self).run("")
except InvalidCommandLineError as excp:
self.retcode = ReturnCodes.INVALID_COMMAND_LINE_ERROR
UI().invalid_commmand_line(excp)
except NoCurrentSessionEstablished as excp:
self.retcode = ReturnCodes.NO_CURRENT_SESSION_ESTABLISHED
UI().error(excp)
except NoChangesFoundOrMadeError as excp:
self.retcode = ReturnCodes.NO_CHANGES_MADE_OR_FOUND
UI().invalid_commmand_line(excp)
except StandardBlobErrorHandler as excp:
self.retcode = ReturnCodes.GENERAL_ERROR
UI().standard_blob_error(excp)
except InvalidFileInputError as excp:
self.retcode = ReturnCodes.INVALID_FILE_INPUT_ERROR
UI().invalid_commmand_line(excp)
except InvalidCommandLineErrorOPTS as excp:
self.retcode = ReturnCodes.INVALID_COMMAND_LINE_ERROR
except InvalidFileFormattingError as excp:
self.retcode = ReturnCodes.INVALID_FILE_FORMATTING_ERROR
UI().invalid_file_formatting(excp)
except NoContentsFoundForOperationError as excp:
self.retcode = ReturnCodes.NO_CONTENTS_FOUND_FOR_OPERATION
UI().no_contents_found_for_operation(excp)
except InfoMissingEntriesError as excp:
self.retcode = ReturnCodes.NO_VALID_INFO_ERROR
UI().error(excp)
except (InvalidOrNothingChangedSettingsError, redfish.ris.rmc_helper.\
IncorrectPropValue) as excp:
self.retcode = ReturnCodes.SAME_SETTINGS_ERROR
UI().error(excp)
except NoDifferencesFoundError as excp:
self.retcode = ReturnCodes.NO_CHANGES_MADE_OR_FOUND
UI().no_differences_found(excp)
except MultipleServerConfigError as excp:
self.retcode = ReturnCodes.MULTIPLE_SERVER_CONFIG_FAIL
UI().multiple_server_config_fail(excp)
except InvalidMSCfileInputError as excp:
self.retcode = ReturnCodes.MULTIPLE_SERVER_INPUT_FILE_ERROR
UI().multiple_server_config_input_file(excp)
except FirmwareUpdateError as excp:
self.retcode = ReturnCodes.FIRMWARE_UPDATE_ERROR
UI().error(excp)
except FailureDuringCommitError as excp:
self.retcode = ReturnCodes.FAILURE_DURING_COMMIT_OPERATION
UI().error(excp)
except BootOrderMissingEntriesError as excp:
self.retcode = ReturnCodes.BOOT_ORDER_ENTRY_ERROR
UI().error(excp)
except NicMissingOrConfigurationError as excp:
self.retcode = ReturnCodes.NIC_MISSING_OR_INVALID_ERROR
UI().error(excp)
except (IncompatibleiLOVersionError, redfish.ris.rmc_helper.\
IncompatibleiLOVersionError) as excp:
self.retcode = ReturnCodes.INCOMPATIBLE_ILO_VERSION_ERROR
UI().printmsg(excp)
except IncompatableServerTypeError as excp:
self.retcode = ReturnCodes.INCOMPATIBLE_SERVER_TYPE
UI().printmsg(excp)
except IloLicenseError as excp:
UI().printmsg(excp)
self.retcode = ReturnCodes.ILO_LICENSE_ERROR
except InvalidCListFileError as excp:
self.retcode = ReturnCodes.INVALID_CLIST_FILE_ERROR
UI().error(excp)
except PartitionMoutingError as excp:
self.retcode = ReturnCodes.UNABLE_TO_MOUNT_BB_ERROR
UI().error(excp)
except TimeOutError as excp:
self.retcode = ReturnCodes.UPDATE_SERVICE_BUSY
UI().error(excp)
except DownloadError as excp:
self.retcode = ReturnCodes.FAILED_TO_DOWNLOAD_COMPONENT
UI().error(excp)
except UploadError as excp:
self.retcode = ReturnCodes.FAILED_TO_UPLOAD_COMPONENT
UI().error(excp)
except BirthcertParseError as excp:
self.retcode = ReturnCodes.BIRTHCERT_PARSE_ERROR
UI().error(excp)
except ResourceExists as excp:
self.retcode = ReturnCodes.RESOURCE_EXISTS_ERROR
UI().error(excp)
except InvalidKeyError as excp:
self.retcode = ReturnCodes.ENCRYPTION_ERROR
UI().error("Invalid key has been entered for " \
"encryption/decryption.")
except UnableToDecodeError as excp:
self.retcode = ReturnCodes.ENCRYPTION_ERROR
UI().error(excp)
except UnabletoFindDriveError as excp:
self.retcode = ReturnCodes.DRIVE_MISSING_ERROR
UI().error(excp)
UI().printmsg("Error occurred while reading device labels.")
except PathUnavailableError as excp:
self.retcode = ReturnCodes.PATH_UNAVAILABLE_ERROR
if excp:
UI().error(excp)
else:
UI().printmsg("Requested path is unavailable.")
except TaskQueueError as excp:
self.retcode = ReturnCodes.TASKQUEUE_ERROR
UI().error(excp)
# ****** CLI ERRORS ******
except cliutils.CommandNotFoundException as excp:
self.retcode = ReturnCodes.UI_CLI_COMMAND_NOT_FOUND_EXCEPTION
UI().command_not_found(excp)
extensions.Commands['HelpCommand'](rdmc=self).run("")
# ****** RMC/RIS ERRORS ******
except redfish.ris.UndefinedClientError:
self.retcode = ReturnCodes.RIS_UNDEFINED_CLIENT_ERROR
UI().error("Please login before making a selection")
except (redfish.ris.InstanceNotFoundError, redfish.ris.\
RisInstanceNotFoundError) as excp:
self.retcode = ReturnCodes.RIS_INSTANCE_NOT_FOUND_ERROR
UI().printmsg(excp)
except redfish.ris.CurrentlyLoggedInError as excp:
self.retcode = ReturnCodes.RIS_CURRENTLY_LOGGED_IN_ERROR
UI().error(excp)
except redfish.ris.NothingSelectedError as excp:
self.retcode = ReturnCodes.RIS_NOTHING_SELECTED_ERROR
UI().nothing_selected()
except redfish.ris.NothingSelectedFilterError as excp:
self.retcode = ReturnCodes.RIS_NOTHING_SELECTED_FILTER_ERROR
UI().nothing_selected_filter()
except redfish.ris.NothingSelectedSetError as excp:
self.retcode = ReturnCodes.RIS_NOTHING_SELECTED_SET_ERROR
UI().nothing_selected_set()
except redfish.ris.InvalidSelectionError as excp:
self.retcode = ReturnCodes.RIS_INVALID_SELECTION_ERROR
UI().error(excp)
except redfish.ris.rmc_helper.UnableToObtainIloVersionError as excp:
self.retcode = ReturnCodes.INCOMPATIBLE_ILO_VERSION_ERROR
UI().error(excp)
except redfish.ris.IdTokenError as excp:
if excp.message:
UI().printmsg(excp.message)
else:
UI().printmsg(u"Logged-in account does not have the privilege "\
" required to fulfill the request or a required "\
" token is missing."\
"\nEX: biospassword flag if bios password present "\
"or tpmenabled flag if TPM module present.")
self.retcode = ReturnCodes.RIS_MISSING_ID_TOKEN
except redfish.ris.SessionExpired as excp:
self.retcode = ReturnCodes.RIS_SESSION_EXPIRED
self.app.logout()
UI().printmsg("Current session has expired or is invalid, "\
"please login again with proper credentials to continue.\n")
except redfish.ris.ValidationError as excp:
self.retcode = ReturnCodes.RIS_VALIDATION_ERROR
except redfish.ris.ValueChangedError as excp:
self.retcode = ReturnCodes.RIS_VALUE_CHANGED_ERROR
except redfish.ris.ris.SchemaValidationError as excp:
UI().printmsg("Error found in schema, try running with the "\
"--latestschema flag.")
self.retcode = ReturnCodes.RIS_SCHEMA_PARSE_ERROR
# ****** RMC/RIS ERRORS ******
except redfish.rest.v1.RetriesExhaustedError as excp:
self.retcode = ReturnCodes.V1_RETRIES_EXHAUSTED_ERROR
UI().retries_exhausted_attemps()
except redfish.rest.v1.InvalidCredentialsError as excp:
self.retcode = ReturnCodes.V1_INVALID_CREDENTIALS_ERROR
UI().invalid_credentials(excp)
except redfish.rest.v1.JsonDecodingError as excp:
self.retcode = ReturnCodes.JSON_DECODE_ERROR
UI().error(excp)
except redfish.rest.v1.ServerDownOrUnreachableError as excp:
self.retcode = \
ReturnCodes.V1_SERVER_DOWN_OR_UNREACHABLE_ERROR
UI().error(excp)
except redfish.rest.v1.ChifDriverMissingOrNotFound as excp:
self.retcode = ReturnCodes.V1_CHIF_DRIVER_MISSING_ERROR
UI().printmsg("Chif driver not found, please check that the " \
"chif driver is installed.")
except redfish.rest.v1.SecurityStateError as excp:
self.retcode = ReturnCodes.V1_SECURITY_STATE_ERROR
if isinstance(excp.message, int):
UI().printmsg("High security mode [%s] has been enabled. " \
"Please provide credentials." % excp.message)
else:
UI().error(excp)
except redfish.hpilo.risblobstore2.ChifDllMissingError as excp:
self.retcode = ReturnCodes.REST_ILOREST_CHIF_DLL_MISSING_ERROR
UI().printmsg("iLOrest Chif dll not found, please check that the "\
"chif dll is present.")
except redfish.hpilo.risblobstore2.UnexpectedResponseError as excp:
self.retcode = ReturnCodes.REST_ILOREST_UNEXPECTED_RESPONSE_ERROR
UI().printmsg("Unexpected data received from iLO.")
except redfish.hpilo.risblobstore2.HpIloError as excp:
self.retcode = ReturnCodes.REST_ILOREST_ILO_ERROR
UI().printmsg("iLO returned a failed error code.")
except redfish.hpilo.risblobstore2.Blob2CreateError as excp:
self.retcode = ReturnCodes.REST_ILOREST_CREATE_BLOB_ERROR
UI().printmsg("Blob create operation failed.")
except redfish.hpilo.risblobstore2.Blob2ReadError as excp:
self.retcode = ReturnCodes.REST_ILOREST_READ_BLOB_ERROR
UI().printmsg("Blob read operation failed.")
except redfish.hpilo.risblobstore2.Blob2WriteError as excp:
self.retcode = ReturnCodes.REST_ILOREST_WRITE_BLOB_ERROR
UI().printmsg("Blob write operation failed.")
except redfish.hpilo.risblobstore2.Blob2DeleteError as excp:
self.retcode = ReturnCodes.REST_ILOREST_BLOB_DELETE_ERROR
UI().printmsg("Blob delete operation failed.")
except redfish.hpilo.risblobstore2.Blob2OverrideError as excp:
self.retcode = ReturnCodes.REST_ILOREST_BLOB_OVERRIDE_ERROR
UI().error(excp)
UI().printmsg("\nBlob was overwritten by another user. Please " \
"ensure only one user is making changes at a time locally.")
except redfish.hpilo.risblobstore2.BlobRetriesExhaustedError as excp:
self.retcode = ReturnCodes.REST_BLOB_RETRIES_EXHAUSETED_ERROR
UI().printmsg("\nBlob operation still fails after max retries.")
except redfish.hpilo.risblobstore2.Blob2FinalizeError as excp:
self.retcode = ReturnCodes.REST_ILOREST_BLOB_FINALIZE_ERROR
UI().printmsg("Blob finalize operation failed.")
except redfish.hpilo.risblobstore2.BlobNotFoundError as excp:
self.retcode = ReturnCodes.REST_ILOREST_BLOB_NOT_FOUND_ERROR
UI().printmsg("Blob not found with key and namespace provided.")
except redfish.ris.rmc_helper.InvalidPathError as excp:
self.retcode = ReturnCodes.RIS_REF_PATH_NOT_FOUND_ERROR
UI().printmsg("Reference path not found.")
except redfish.ris.rmc_helper.IloResponseError as excp:
self.retcode = ReturnCodes.RIS_ILO_RESPONSE_ERROR
except redfish.ris.rmc_helper.UserNotAdminError as excp:
UI().user_not_admin()
self.retcode = ReturnCodes.USER_NOT_ADMIN
except redfish.hpilo.rishpilo.HpIloInitialError as excp:
UI().error(excp)
self.retcode = ReturnCodes.RIS_ILO_INIT_ERROR
except redfish.hpilo.rishpilo.HpIloWriteError as excp:
UI().error(excp)
self.retcode = ReturnCodes.RESOURCE_ALLOCATION_ISSUES_ERROR
except redfish.hpilo.rishpilo.HpIloReadError as excp:
UI().error(excp)
self.retcode = ReturnCodes.RESOURCE_ALLOCATION_ISSUES_ERROR
# ****** RIS OBJECTS ERRORS ******
except redfish.ris.ris.BiosUnregisteredError as excp:
self.retcode = ReturnCodes.RIS_RIS_BIOS_UNREGISTERED_ERROR
UI().bios_unregistered_error()
# ****** GENERAL ERRORS ******
except SystemExit:
self.retcode = ReturnCodes.GENERAL_ERROR
raise
except Exception as excp:
self.retcode = ReturnCodes.GENERAL_ERROR
sys.stderr.write('ERROR: %s\n' % excp)
if self.opts.debug:
traceback.print_exc(file=sys.stderr)
def cmdloop(self, opts):
""" Interactive mode worker function
:param opts: command options
:type opts: options.
"""
self.interactive = True
if not opts.nologo:
sys.stdout.write(FIPSSTR)
CLI.version(self._progname, versioning.__version__,\
versioning.__extracontent__, fileh=sys.stdout)
if not self.app.typepath.adminpriv:
UI().user_not_admin()
if opts.debug:
LOGGER.setLevel(logging.DEBUG)
LERR.setLevel(logging.DEBUG)
#**********Handler for GUI tab tab ***************
for section in self._commands:
if section.startswith('_'):
continue
for command in self._commands[section]:
self.commlist.append(command.name)
for item in self.commlist:
if item == "help":
self.candidates[item] = self.commlist
else:
self.candidates[item] = []
self._redobj = TabAndHistoryCompletionClass(dict(self.candidates))
try:
session = PromptSession(completer=self._redobj, \
complete_style=CompleteStyle.READLINE_LIKE)
except:
LOGGER.info("Console error: Tab complete is unavailable.")
session = None
while True:
try:
if session:
line = session.prompt(versioning.__shortname__+ u' > ', \
bottom_toolbar=self._redobj.bottom_toolbar)
else:
line = input(versioning.__shortname__ + u' > ')
except (EOFError, KeyboardInterrupt) as error:
line = "quit\n"
if not len(line):
continue
elif line.endswith(os.linesep):
line.rstrip(os.linesep)
nargv = shlex.split(line, posix=False)
try:
if not (any(x.startswith("-h") for x in nargv) or \
any(x.startswith("--h") for x in nargv) or "help" in line):
if "login " in line or line == 'login' or \
any(x.startswith("--url") for x in nargv):
self.app.logout()
self.retcode = self._run_command(opts, nargv)
self.check_for_tab_lists(nargv)
except Exception as excp:
self.handle_exceptions(excp)
if self.opts.verbose:
sys.stdout.write("iLOrest return code: %s\n" % self.retcode)
return self.retcode
