def checktoprint(self, options, contents, nocontent, arg): """ function to decide what/how to print :param options: list of options :type options: list. :param contents: dictionary value returned by getprops. :type contents: dict. :param nocontent: props not found are added to the list. :type nocontent: list. :param arg: string of args :type arg: string """ if options and options.json and contents: UI().print_out_json(contents) elif contents: UI().print_out_human_readable(contents) else: try: if nocontent or not any(next(iter(contents))): raise Exception() except: strtoprint = ', '.join(str(val) for val in nocontent) if not strtoprint and arg: strtoprint = arg raise NoContentsFoundForOperationError('No get contents '\ 'found for entry: %s' % strtoprint) else: raise NoContentsFoundForOperationError('No get contents '\ 'found for selected type.')
def getworkerhelper(self, results, content, newlist, newargs, jsono=False): """ helper function for list items :param results: current results collected :type results: string. :param content: current content to work on :type content: string. :param newlist: new style list :type newlist: list. :param newargs: new style arguments :type newargs: list. :param jsono: boolean to determine output style :type jsono: boolean. """ somethingfound = False innerresults = OrderedDict() listitem = False for item in newargs: if isinstance(content, list): if not content: return if len(content) > 1: argleft = [x for x in newargs if x not in newlist] _ = [self.getworkerhelper(results, content[x], newlist[:],\ argleft, jsono) for x in range(len(content))] listitem = True break else: content = content[0] for key in content.keys(): if item.lower() == key.lower(): newlist.append(key) content = content.get(key) somethingfound = True break else: somethingfound = False if not somethingfound: return somethingfound counter = 0 for item in reversed(newlist): if counter == 0: innerresults = {item: content} counter += 1 else: innerresults = {item: innerresults} content = innerresults if somethingfound and results: return content elif somethingfound and not listitem: if jsono: UI().print_out_json(content) else: UI().print_out_human_readable(content)
def __init__(self, name, usage, summary, aliases, argparser, Args=None): super().__init__(name, usage, summary, aliases, argparser) self._commands = collections.OrderedDict() self.ui = UI(1) self.commands_dict = dict() self.interactive = False self._progname = '%s : %s' % (versioning.__shortname__, \ versioning.__longname__) self.opts = None self.encoding = None self.config = RdmcConfig() self.app = redfish.ris.RmcApp(showwarnings=True) self.retcode = 0 self.candidates = dict() self.comm_map = dict() #point command id names or alias to handle self.commlist = list() self._redobj = None self.loaded_commands = [] #import all extensions dynamically for name in extensions.classNames: pkgName, cName = name.rsplit('.', 1) pkgName = 'extensions' + pkgName try: if '__pycache__' not in pkgName and 'Command' in cName: self.commands_dict[cName] = getattr( importlib.import_module(pkgName), cName)() sName = pkgName.split('.')[1] self.add_command(cName, section=sName) except cliutils.ResourceAllocationError as excp: self.ui.error(excp) retcode = ReturnCodes.RESOURCE_ALLOCATION_ISSUES_ERROR self.ui.error("Unable to allocate more resources.") self.ui.printer(("ILOREST return code: %s\n" % retcode)) sys.exit(retcode) except Exception as excp: self.ui.error(("loading command: %s" % cName), None) #command mapping commands_to_remove = [] for command in self.commands_dict: try: self.comm_map[self.commands_dict[command].ident.get( 'name')] = command for alias in self.commands_dict[command].ident.get('aliases'): self.comm_map[alias] = command except Exception as excp: self.ui.command_not_enabled(("Command \'%s\' unable to be "\ "initialized...Removing" % command), excp) commands_to_remove.append(command) # removing commands marked for deletion for cmd in commands_to_remove: del self.commands_dict[cmd] del commands_to_remove
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) info = self.gatherinfo(options) if not info: raise InvalidCommandLineError( "Please add options to view server info.") if options.json: UI().print_out_json(info) else: self.prettyprintinfo(info, options.showabsent) 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 get_running_job(self): """ Retrieves and decodes, running job :return returncode: int """ results = self._rdmc.app.get_handler(self.running_jobs, silent=True) if results.status == 404: raise PathUnavailableError("The Intelligent Provisioning resource "\ "is not available on this system. You may need"\ " to run IP at least once to add the resource.") if results and results.status == 200: j2python = json.loads(results.read) for _, val in enumerate(j2python.keys()): if isinstance(val, six.string_types): result = self.decode_base64_string(str(j2python[val])) if result is not None: j2python[val] = result results.read = json.dumps(j2python, ensure_ascii=False) if results.dict: UI().print_out_json(results.dict) else: sys.stdout.write("No IP profiles found\n")
def run(self, line): """ Main raw head worker 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.headvalidation(options) if len(args) > 1: raise InvalidCommandLineError("Raw head only takes 1 argument.\n") elif not args: raise InvalidCommandLineError("Missing raw head input path.\n") if args[0].startswith('"') and args[0].endswith('"'): args[0] = args[0][1:-1] results = self._rdmc.app.head_handler(args[0], silent=options.silent, \ service=options.service) content = None tempdict = dict() if results and results.status == 200: if results._http_response: content = results.getheaders() else: content = results._headers tempdict = dict(content) if options.filename: output = json.dumps(tempdict, indent=2, cls=redfish.ris.JSONEncoder, sort_keys=True) filehndl = open(options.filename[0], "w") filehndl.write(output) filehndl.close() sys.stdout.write("Results written out to '%s'.\n" % options.filename[0]) else: if options.service: sys.stdout.write("%s\n" % tempdict) else: UI().print_out_json(tempdict) else: return ReturnCodes.NO_CONTENTS_FOUND_FOR_OPERATION #Return code return ReturnCodes.SUCCESS
def vmdefaulthelper(self, options, paths): """Worker function to reset virtual media config to default :param paths: virtual media paths :type paths: list :param options: command line options :type options: list. """ images = {} count = 0 mediatypes = self.auxcommands['get'].getworkerfunction(\ "MediaTypes", options, results=True, uselist=False) ids = self.auxcommands['get'].getworkerfunction("Id", options, results=True, uselist=False) ids = {ind: id for ind, id in enumerate(ids)} mediatypes = {ind: med for ind, med in enumerate(mediatypes)} # To keep indexes consistent between versions if not list(ids.keys())[0] == list(list(ids.values())[0].values())[0]: finalmet = {} for mount in mediatypes: finalmet.update( {int(list(ids[mount].values())[0]): mediatypes[mount]}) mediatypes = finalmet for path in paths: count += 1 image = self.rdmc.app.get_handler(paths[path], service=True, silent=True) image = image.dict['Image'] images.update({path: image}) self.rdmc.ui.printer("Available Virtual Media Options:\n") if getattr(options, "json", False): json_str = dict() json_str['MediaTypes'] = dict() else: self.rdmc.ui.printer("Available Virtual Media Options:\n") for image in images: media = "" if images[image]: imagestr = images[image] else: imagestr = "None" for medtypes in mediatypes[image]['MediaTypes']: media += medtypes + " " if getattr(options, "json", False): json_str['MediaTypes'][str(media)] = imagestr else: self.rdmc.ui.printer("[%s] Media Types Available: %s Image Inserted:" \ " %s\n" %(str(image), str(media), imagestr)) if getattr(options, "json", False): UI().print_out_json(json_str)
def selection_output(self, options, content): """ Selection of output for smart array command :param options: command line options :type options: attributes :param content: ordered dictionary of properties :type content: dictionary """ controldict = {} outputcontent = False use_slot = False use_indx = False for _opt in options.controller: found = False for pos, control in enumerate(content): if isinstance(_opt, int) and not use_slot: if pos == (_opt - 1): controldict[_opt] = content[control] found = True use_indx = True elif _opt.lower() == content[control]["Location"].lower() and not use_indx: controldict[int(content[control]["Location"].split(' ')[-1])] = content[control] found = True use_slot = True if found: break if not found: sys.stderr.write("\nController \'%s\' not found in the current inventory " \ "list.\n" % _opt) if controldict: for controller in controldict: if options.physicaldrives or options.pdrive: outputcontent = True try: self.get_drives(options, controldict[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, controldict[controller]["LogicalDrives"], logical=True) if not outputcontent: for k in list(controldict[controller].keys()): if k.lower() in HARDCODEDLIST or '@odata' in k.lower(): del controldict[controller][k] UI().print_out_json_ordered(controldict[controller])
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 try: if options.controller.isdigit(): if int(options.controller) > 0: controllist.append(content[int(options.controller) - 1]) else: slotcontrol = options.controller.lower().strip('\"').split( 'slot')[-1].lstrip() for control in content: if slotcontrol.lower() == control["Location"].lower( ).split('slot')[-1].lstrip(): controllist.append(control) if not controllist: raise InvalidCommandLineError("") except InvalidCommandLineError: raise InvalidCommandLineError("Selected controller not found in the current inventory "\ "list.") 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(controller)
def jsonprinthelper(self, content): """ Helper for JSON UI print out :param content: current content to work on :type content: string. """ final = dict() for item in content: for num, _ in item.iteritems(): self.dict_merge(final, item) for num in final: UI().print_out_json(final[num])
def displayAvailableCapacity(self, scalable_pmem_config, output_as_json=False): if output_as_json: data = { "TotalSupported": scalable_pmem_config.regions.maxPmemGiB, "TotalAvailable": scalable_pmem_config.regions.availableSizeGiB, "Processor": {}, "ProcessorPair": {} } for _, socket in scalable_pmem_config.regions.sockets.items(): availableSize, isSlotAvailable = socket.availableSizeGiBHint data["Processor"][socket.labelString] = { 'AvailableSize': availableSize, 'MaxLogicalNvdimmsCreated': not isSlotAvailable, 'MaximumLogicalNvdimms': socket.maxRegions } for _, pair in scalable_pmem_config.regions.socketPairs.items(): availableSize, isSlotAvailable = pair.availableSizeGiBHint data["ProcessorPair"][pair.labelString] = { 'AvailableSize': availableSize, 'MaxLogicalNvdimmsCreated': not isSlotAvailable } UI().print_out_json(data) else: self.writeHeader3( "By Processor (for single processor logical NVDIMMs):") self.writeTableHeader(u"{:12} {:40}".format( "Processor", "Available For Scalable PMEM")) for _, socket in scalable_pmem_config.regions.sockets.items(): availableSize, isSlotAvailable = socket.availableSizeGiBHint sys.stdout.write(u"\n {:12} {}".format( socket.labelString, "{:4} GiB {}".format( availableSize, "(Max logical NVDIMMs created)" if not isSlotAvailable else ""))) sys.stdout.write(u"\n") self.writeHeader3( "By Processor Pair (for spanned logical NVDIMMs):") self.writeTableHeader(u"{:12} {:40}".format( "Processors", "Available For Scalable PMEM")) for _, pair in scalable_pmem_config.regions.socketPairs.items(): availableSize, isSlotAvailable = pair.availableSizeGiBHint sys.stdout.write(u"\n {:12} {}".format( pair.labelString, "{:4} GiB {}".format( availableSize, "(Max logical NVDIMMs created)" if not isSlotAvailable else ""))) self.noticeRestartRequired(scalable_pmem_config) sys.stdout.write(u"\n")
def get_data_drives(self, options, drives, print_ctrl=False, single_use=False): """ Identify/parse a physical component drive collection of a respective logical drive. The physical disk properties as well as some logical RAID parameters within each respective member. :param options: command line options :type options: object attributes :param content: collection of data drives href or @odata.id paths (as members) as attributed to a respective logical drive. :type content: dict :param print_ctrl: flag for console print enablement/disablement (default disabled) :type print_ctrl: bool :param single_use: singular usage, returns dictionary of results to calling function (default disabled) :type single_use: bool :returns: None, dictionary of all physical drives composing a parent logical drive, each instance identified by 'Id' """ if not (getattr(options, "json", False)) and print_ctrl: sys.stdout.write("\t\tData Drives:\n") if single_use: subsetdrives = {} found_entries = False for member in drives.get('Members', {}): try: tmp = member[self.rdmc.app.typepath.defs.hrefstring] except: tmp = member[next(iter(member))] finally: tmp = self.rdmc.app.get_handler(tmp, silent=True).dict found_entries = True if single_use: subsetdrives[tmp['Id']] = tmp if print_ctrl: sys.stdout.write("\t\t[%s]: Model %s, Serial %s - %s MiB\n" % (tmp['Location'], \ tmp['Model'], tmp['SerialNumber'], tmp['CapacityMiB'])) sys.stdout.write("\t\t\tLocation: %s\n" % (tmp['Location'])) elif getattr(options, "json", False): UI().print_out_json(tmp) if not found_entries and print_ctrl: sys.stdout.write("\t\tComponent drives not found.\n") if single_use: return subsetdrives
def get_selected_drive(self, location): """ Function to get all selected drives :param location: list of all locations :type location: list. """ self.selobj.selectfunction("HpSmartStorageDiskDrive.") for drive in self._rdmc.app.getprops(): if drive["Location"] in location: for k in list(drive.keys()): if k.lower() in HARDCODEDLIST or '@odata' in k.lower(): del drive[k] UI().print_out_json(drive)
def jsonprinthelper(self, content): """ Helper for JSON UI print out :param content: current content to work on :type content: string. """ final = dict() for item in content: for num, _ in item.iteritems(): try: final[num].update(item[num]) except: final[num] = item[num] for num in final: UI().print_out_json(final[num])
def pendingfunction(self): """ Main pending command worker function """ settingsuri = [] ignorekeys = ['@odata.id', '@odata.etag', '@redfish.settings', 'oem'] ignoreuri = [unicode('hpsut*')] ignorekeys.extend(HARDCODEDLIST) resourcedir = self._rdmc.app.get_handler(self._rdmc.app.monolith._resourcedir, \ service=True, silent=True) for resource in resourcedir.dict['Instances']: if (resource['@odata.id'].split('/').__len__() - 1) > 4: splitstr = resource['@odata.id'].split('/')[5] for element in ignoreuri: if '/settings' in resource['@odata.id'] and not \ self.wildcard_str_match(element, splitstr): settingsuri.append(resource['@odata.id']) sys.stdout.write('Current Pending Changes:\n') for uri in settingsuri: diffprint = {} baseuri = uri.split('settings')[0] base = self._rdmc.app.get_handler(baseuri, service=True, silent=True) settings = self._rdmc.app.get_handler(uri, service=True, silent=True) typestring = self._rdmc.app.monolith.typepath.defs.typestring currenttype = '.'.join( base.dict[typestring].split('#')[-1].split('.')[:-1]) differences = json.loads(jsondiff.diff(base.dict, settings.dict, \ syntax='symmetric', dump=True)) diffprint = self.recursdict(differences, ignorekeys) sys.stdout.write('\n%s:' % currenttype) if not diffprint: sys.stdout.write('\nNo pending changes found.\n') else: UI().pretty_human_readable(diffprint) sys.stdout.write('\n')
def validateFeatureEnabledByUser(self, scalable_pmem_config, output_as_json=False): (isEnabled, overallMessage, messages) = scalable_pmem_config.isEnabledByUser if not isEnabled: if output_as_json: UI().print_out_json({ "IsEnabled": isEnabled, "OverallMessage": overallMessage, "Messages": messages }) raise NoChangesFoundOrMadeError(u"") else: sys.stdout.write(u"\n\n{}:\n".format(overallMessage)) self.printLimitedMessageList(messages, 3) sys.stdout.write(u"\n\n") raise NoChangesFoundOrMadeError(u"Unable to continue")
def validateAllConfigurationPolicies(self, scalable_pmem_config, output_as_json=False): (isValid, overallMessage, messages) = scalable_pmem_config.validateConfigurationPolicies() if not isValid: if output_as_json: UI().print_out_json({ "IsValid": isValid, "OverallMessage": overallMessage, "Messages": messages }) raise NoChangesFoundOrMadeError(u"") else: sys.stdout.write(u"\n\n{}:\n".format(overallMessage)) self.printLimitedMessageList(messages, 3) sys.stdout.write(u"\n\n") raise NoChangesFoundOrMadeError(u"Unable to continue")
def getipprofiledataanddecode(self, options): """ Retrieves and decodes, if encoded, data from hpeprofile data store :param options: command line options :type options: list. :return returncode: int """ results = self._rdmc.app.get_handler(self.path, silent=True, response=True) if results.status == 404: raise PathUnavailableError("The Intelligent Provisioning resource "\ "is not available on this system. You may need"\ " to run IP at least once to add the resource.") if results and results.status == 200: j2python = json.loads(results.read) for _, val in enumerate(j2python.keys()): if isinstance(val, six.string_types): result = self.decode_base64_string(str(j2python[val])) if result is not None: j2python[val] = result results.read = json.dumps(j2python, ensure_ascii=False, sort_keys=True) if results.dict: if options.filename: output = json.dumps(results.dict, indent=2, cls=redfish.ris.JSONEncoder, \ sort_keys=True) filehndl = open(options.filename[0], "w") filehndl.write(output) filehndl.close() sys.stdout.write("Results written out to '%s'.\n" % options.filename[0]) else: UI().print_out_json(results.dict) else: sys.stdout.write("No IP profiles found\n")
def get_hvt_output(self): """ Retrieves and decodes, running job :return returncode: int """ return_value = {} results = self._rdmc.app.get_handler(self.hvt_output, silent=True, response=True) if results.status == 404: raise PathUnavailableError("The Intelligent Provisioning resource "\ "is not available on this system. You may need"\ " to run IP at least once to add the resource.") if results and results.status == 200: j2python = json.loads(results.read) for _, val in enumerate(j2python.keys()): if isinstance(val, six.string_types) and '@' not in val: return_value = json.loads(self.decode_base64_string(str(j2python[val]))) UI().print_out_json(return_value) else: sys.stdout.write("No IP profiles found\n")
def test_directory(self, options, json=False): """ Function to perform directory testing :param options: namespace of custom parser attributes which contain the original command arguments for 'start/stop/viewresults' :type options: namespace :param json: Bool to print in json format or not. :type json: bool. """ results = self._rdmc.app.select(selector='HpeDirectoryTest.', path_refresh=True)[0].dict if options.start_stop_view.lower() == 'start': path = None for item in results['Actions']: if 'StartTest' in item: path = results['Actions'][item]['target'] break if not path: raise NoContentsFoundForOperationError("Unable to start directory test.") sys.stdout.write("Starting the directory test. Monitor results with command: directory"\ " viewresults\n") self._rdmc.app.post_handler(path, {}) elif options.start_stop_view.lower() == 'stop': path = None for item in results['Actions']: if 'StopTest' in item: path = results['Actions'][item]['target'] break if not path: raise NoContentsFoundForOperationError("Unable to stop directory test.") sys.stdout.write("Stopping the directory test.\n") self._rdmc.app.post_handler(path, {}) elif options.start_stop_view.lower() == 'viewresults': if json: UI().print_out_json(results['TestResults']) else: for test in results['TestResults']: sys.stdout.write('Test: %s\n' % test['TestName']) sys.stdout.write("------------------------\n") sys.stdout.write('Status: %s\n' % test['Status']) sys.stdout.write('Notes: %s\n' % test['Notes']) sys.stdout.write("\n")
def getipprofiledataanddecode(self, options): """ Retrieves and decodes, if encoded, data from hpeprofile data store :param options: command line options :type options: list. :return returncode: int """ try: results = self._rdmc.app.get_handler(self.path, \ verbose=self._rdmc.opts.verbose, silent=True) except: raise PathUnavailableError("The Intelligent Provisioning resource "\ "is not available on this system.") j2python = json.loads(results.read) for _, val in enumerate(j2python.keys()): if isinstance(val, basestring): result = self.decode_base64_string(str(j2python[val])) if result is not None: j2python[val] = result results.read = json.dumps(j2python, ensure_ascii=False) if results and results.status == 200: if results.dict: if options.filename: output = json.dumps(results.dict, indent=2,\ cls=redfish.ris.JSONEncoder) filehndl = open(options.filename[0], "w") filehndl.write(output) filehndl.close() sys.stdout.write(u"Results written out to '%s'.\n" % \ options.filename[0]) else: UI().print_out_json(results.dict) else: return ReturnCodes.NO_CONTENTS_FOUND_FOR_OPERATION
def test_directory(self, command, json=False): """ Function to perform directory testing :param command: command to run against directory test. (start/stop/viewresults) :type command: str. :param json: Bool to print in json format or not. :type json: bool. """ results = self._rdmc.app.select(selector='HpeDirectoryTest.', rel=True)[0].dict if command.lower() == 'start': path = None for item in results['Actions']: if 'StartTest' in item: path = results['Actions'][item]['target'] break if not path: raise NoContentsFoundForOperationError("Unable to start directory test.") sys.stdout.write("Starting the directory test. Monitor results with command: directory"\ " viewresults\n") self._rdmc.app.post_handler(path, {}) elif command.lower() == 'stop': path = None for item in results['Actions']: if 'StopTest' in item: path = results['Actions'][item]['target'] break if not path: raise NoContentsFoundForOperationError("Unable to stop directory test.") sys.stdout.write("Stopping the directory test.\n") self._rdmc.app.post_handler(path, {}) elif command.lower() == 'viewresults': if json: UI().print_out_json(results['TestResults']) else: for test in results['TestResults']: sys.stdout.write('Test: %s\n' % test['TestName']) sys.stdout.write("------------------------\n") sys.stdout.write('Status: %s\n' % test['Status']) sys.stdout.write('Notes: %s\n' % test['Notes']) sys.stdout.write("\n")
def pendingfunction(self): """ Main pending command worker function """ settingsuri = [] ignorekeys = ['@odata.id', '@odata.etag', '@redfish.settings'] ignorekeys.extend(HARDCODEDLIST) resourcedir = self._rdmc.app.get_handler(self._rdmc.app.current_client.\ monolith._resourcedir, \ verbose=self._rdmc.opts.verbose, service=True, silent=True) for resource in resourcedir.dict['Instances']: if '/settings' in resource['@odata.id']: settingsuri.append(resource['@odata.id']) sys.stdout.write('Current Pending Changes:\n') for uri in settingsuri: diffprint = {} baseuri = uri.split('settings')[0] base = self._rdmc.app.get_handler(baseuri, \ verbose=self._rdmc.opts.verbose, service=True, silent=True) settings = self._rdmc.app.get_handler(uri, \ verbose=self._rdmc.opts.verbose, service=True, silent=True) typestring = self._rdmc.app._rmc_clients._monolith._typestring currenttype = '.'.join(base.dict[typestring].split('#')\ [-1].split('.')[:-1]) differences = json.loads(jsondiff.diff(base.dict, settings.dict, \ syntax='symmetric', dump=True)) diffprint = self.recursdict(differences, ignorekeys) sys.stdout.write('\n%s:' % currenttype) if not diffprint: sys.stdout.write('\nNo pending changes found.\n') else: UI().pretty_human_readable(diffprint) sys.stdout.write('\n')
def run(self, line): """ Main serverinfo 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("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) self.cmdbase.logout_routine(self, options) #Return code return ReturnCodes.SUCCESS
def getworkerfunction(self, args, options, line, newargs=None, readonly=False,\ results=None, uselist=False, multivals=False): """ main get worker function :param args: command line arguments :type args: list. :param options: command line options :type options: list. :param line: command line input :type line: string. :param newargs: new style arguments :type newargs: list. :param readonly: remove readonly properties :type newargs: bool :param results: current results collected :type results: string. :param uselist: use reserved properties list to filter results :type uselist: boolean. :param multivals: multiple values :type multivals: boolean. """ listitem = False somethingfound = False if readonly: try: contents = self._rdmc.app.get_save(args, remread=True) uselist = False except redfish.ris.rmc_helper.EmptyRaiseForEAFP: contents = self._rdmc.app.get_save(args) else: contents = self._rdmc.app.get_save(args) values = {} itemnum = 0 if not contents: raise NoContentsFoundForOperationError('No contents '\ 'found for entries: %s' % line) for content in contents: if 'bios.' in self._rdmc.app.get_selector().lower(): if 'Attributes' in content.keys(): content.update(content['Attributes']) del content['Attributes'] try: for item in newargs: if item.lower() == 'attributes': newargs.remove(item) break except: pass content = OrderedDict(sorted(content.items(), key=lambda x: x[0])) if uselist: self.removereserved(content) if len(content): itemnum += 1 if not newargs: somethingfound = True else: innerresults = OrderedDict() newlist = list() for item in newargs: somethingfound = False if isinstance(content, list): if not content: break if len(content) > 1: argleft = [x for x in newargs if x not in \ newlist] _ = [self.getworkerhelper(results, content[x], \ newlist[:], argleft, jsono=options.json) \ for x in range(len(content))] somethingfound = True listitem = True break else: content = content[0] for key in content.keys(): if item.lower() == key.lower(): newlist.append(key) content = content.get(key) somethingfound = True break else: somethingfound = False if not somethingfound: return somethingfound counter = 0 for item in reversed(newlist): if counter == 0: innerresults = {item: content} counter += 1 else: innerresults = {item: innerresults} content = innerresults else: continue if somethingfound and results: if multivals: values[itemnum] = content else: return content elif somethingfound and not listitem: if options.json: UI().print_out_json(content) else: UI().print_out_human_readable(content) if multivals: return values return somethingfound
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)) readline.set_completer(self._redobj.main_completer_handler) readline.parse_and_bind("tab: complete") #*************************************************** while True: line = input(versioning.__shortname__ + ' > ') readline.add_history(line) 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
for cName in extensions.classNames: sName = cName.split('.')[1] cName = cName.split('.')[-1] if not cName.endswith("Command"): continue if cName == 'HelpCommand': RDMC.add_command(extensions.Commands[cName](rdmc=RDMC), section=sName) else: try: RDMC.add_command(extensions.Commands[cName](RDMC), section=sName) except cliutils.ResourceAllocationError as excp: UI().error(excp) retcode = ReturnCodes.RESOURCE_ALLOCATION_ISSUES_ERROR UI().printmsg("Unable to allocate more resources.") sys.stdout.write("ILOREST return code: %s\n" % retcode) sys.exit(retcode) except Exception as excp: sys.stderr.write("Error loading extension: %s\n" % cName) sys.stderr.write("\t" + str(excp) + '\n') # Main execution function call wrapper if os.name != 'nt': FOUND = False VARIABLE = setproctitle.getproctitle() for items in VARIABLE.split(" "): if FOUND:
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("") self.infovalidation(options) if args: for item in args: 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 outdata = self._rdmc.app.info(selector=item, dumpjson=options.json, \ latestschema=options.latestschema) if autotest: return outdata if outdata and options.json: UI().print_out_json(outdata) elif outdata: sys.stdout.write(outdata) if not outdata: raise InfoMissingEntriesError("There are no valid "\ "entries for info in the current instance.") else: if len(args) > 1 and not item == args[-1]: sys.stdout.write("\n************************************"\ "**************\n") else: results = sorted(self._rdmc.app.info(selector=None,\ ignorelist=HARDCODEDLIST, latestschema=options.latestschema)) if results and autotest: return results elif results: sys.stdout.write("Info options:\n") for item in results: sys.stdout.write("%s\n" % item) else: raise InfoMissingEntriesError('No info items '\ 'available for this selected type. Try running with the '\ '--latestschema flag.') if options.logout: self.logoutobj.run("") #Return code return ReturnCodes.SUCCESS