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 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, 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 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 BIOS defaults worker function """ 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.defaultsvalidation(options) sys.stdout.write(u'Resetting the currently logged in server\'s BIOS' \ ' settings to defaults.\n') put_path = self.typepath.defs.biospath body = None if self.typepath.defs.isgen10 and not options.manufdefaults: bodydict = self._rdmc.app.get_handler(self.typepath.defs.biospath,\ verbose=self._rdmc.opts.verbose,\ service=True, silent=True).dict for item in bodydict['Actions']: if 'ResetBios' in item: action = item.split('#')[-1] path = bodydict['Actions'][item]['target'] break body = {"Action": action} if options.userdefaults: body["ResetType"] = "default.user" else: body["ResetType"] = "default" self._rdmc.app.post_handler(path, body) else: if options.userdefaults: body = {'BaseConfig': 'default.user'} elif not options.manufdefaults: body = {'BaseConfig': 'default'} if body: self._rdmc.app.put_handler(put_path + '/settings', body=body, \ optionalpassword=options.biospassword) if not body and options.manufdefaults: self.setobj.run("RestoreManufacturingDefaults=Yes "\ "--selector=HpBios. --commit") if options.reboot: self.rebootobj.run(options.reboot) #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 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 args: raise InvalidCommandLineError("factorydefaults 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.factorydefaultsvalidation(options) sys.stdout.write("Resetting iLO to factory default settings.\n"\ "Current session will be terminated.\n") select = 'Manager.' results = self._rdmc.app.filter(select, None, None) 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.typepath.defs.oemhp] try: for item in bodydict['Actions']: if 'ResetToFactoryDefaults' in item: if self.typepath.defs.isgen10: action = item.split('#')[-1] else: action = "ResetToFactoryDefaults" path = bodydict['Actions'][item]['target'] body = {"Action": action, "ResetType": "Default"} break except: body = {"Action": "ResetToFactoryDefaults", \ "Target": "/Oem/Hp", "ResetType": "Default"} self._rdmc.app.post_handler(path, body, service=True) return ReturnCodes.SUCCESS
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: 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.") if options.encode and options.user and options.password: options.user = Encryption.decode_credentials(options.user) options.password = Encryption.decode_credentials(options.password) self.pendingvalidation(options) self.pendingfunction() return ReturnCodes.SUCCESS
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 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._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.listcomponentvalidation(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 comps: self.printcomponents(comps, options) else: sys.stdout.write('No components found.\n') 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 commitfunction(self, options=None): """ Main commit worker function :param options: command line options :type options: list. """ if options.encode and options.user and options.password: options.user = Encryption.decode_credentials(options.user) options.password = Encryption.decode_credentials(options.password) self.commitvalidation(options) sys.stdout.write(u"Committing changes...\n") if options: if options.biospassword: self._rdmc.app.update_bios_password(options.biospassword) try: if not self._rdmc.app.commit(verbose=self._rdmc.opts.verbose): raise NoChangesFoundOrMadeError("No changes found or made " \ "during commit operation.") except Exception, excp: raise excp
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("") if options.encode and options.user and options.password: options.user = Encryption.decode_credentials(options.user) options.password = Encryption.decode_credentials(options.password) self.deletelogicaldrivevalidation(options) self.selobj.selectfunction("SmartStorageConfig.") content = self._rdmc.app.get_save() if not args and not options.all: raise InvalidCommandLineError('You must include a logical drive '\ 'to delete.') elif not options.controller: raise InvalidCommandLineError('You must include a controller '\ 'to select.') else: if len(args) > 1: logicaldrives = args elif len(args) == 1: logicaldrives = args[0].replace(', ', ',').split(',') else: logicaldrives = None 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: self.deletelogicaldrives(controllist, logicaldrives, options.all,\ options.force) #Return code return ReturnCodes.SUCCESS
def loginvalidation(self, options, args): """ Login helper function for login validations :param options: command line options :type options: list. :param args: command line arguments :type args: list. """ # Fill user name/password from config file if not options.user: options.user = self._rdmc.app.config.get_username() if not options.password: options.password = self._rdmc.app.config.get_password() if not options.biospassword: options.biospassword = self._rdmc.app.config.get_bios_password() # Password and user name validation if options.user and not options.password: # Option for interactive entry of password tempinput = getpass.getpass() if tempinput: options.password = tempinput else: raise InvalidCommandLineError( "Empty or invalid password was entered.") if options.user: self.username = options.user if options.password: self.password = options.password if options.encode: self.username = Encryption.decode_credentials(self.username) self.password = Encryption.decode_credentials(self.password) if options.biospassword: self.biospassword = options.biospassword # Assignment of url in case no url is entered self.url = 'blobstore://.' if args: # Any argument should be treated as an URL self.url = args[0] # Verify that URL is properly formatted for https:// if "https://" not in self.url: self.url = "https://" + self.url if not self.username or not self.password: raise InvalidCommandLineError( "Empty username or password was entered.") else: # Check to see if there is a URL in config file if self._rdmc.app.config.get_url(): self.url = self._rdmc.app.config.get_url()
def run(self, line): """ Wrapper function for download command main 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("") 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: url = None self.downloadcomponentvalidation(options) if options.sessionid and not url: raise InvalidCommandLineError('Url muse be included with ' \ 'sessionid. Session is not required for local mode.') if not options.sessionid and self.typepath.defs.isgen9: raise IncompatibleiLOVersionError('iLO Repository commands are ' \ 'only available on iLO 5.') if len(args) > 1: raise InvalidCommandLineError("Download component only takes 1 " \ "component path argument.\n") elif not args: raise InvalidCommandLineError("Download component missing " \ "component path.\n") start_time = time.time() ret = ReturnCodes.FAILED_TO_DOWNLOAD_COMPONENT sys.stdout.write("Downloading component, this may take a while...\n") if not url and 'blobstore' in self._rdmc.app.get_current_client()\ ._rest_client.get_base_url(): ret = self.downloadlocally(args[0], options) else: ret = self.downloadfunction(args[0], options, url) sys.stdout.write("%s\n" % human_readable_time(time.time() - start_time)) if options.logout: self.logoutobj.run("") return ret
def uploadcommandvalidation(self, options): """ upload command method validation function :param options: command line options :type options: list. """ inputline = list() client = None if not options.component: raise InvalidCommandLineError("The component option is required"\ " for this operation.") if not os.path.exists(options.component): raise InvalidPathError("Component not found at specified path.") if options.componentsig and (not os.path.exists(options.componentsig)): raise InvalidCommandLineError("Component signature not found.") 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 not inputline and not client: sys.stdout.write('Local login initiated...\n') if not client or inputline: self.lobobj.loginfunction(inputline)
def run(self, line): """ Main clearrestapistate 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("clearrestapistate 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.clearrestapistatevalidation(options) select = 'Manager.' results = self._rdmc.app.filter(select, None, None) 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.typepath.defs.oemhp] try: for item in bodydict['Actions']: if 'ClearRestApiState' in item: if self.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) 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') if options.encode and options.user and options.password: options.user = Encryption.decode_credentials(options.user) options.password = Encryption.decode_credentials(options.password) 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 typesvalidation(self, options): """ types method validation function :param options: command line options :type options: list. """ client = None inputline = list() runlogin = False 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: runlogin = True if not inputline: sys.stdout.write('Local login initiated...\n') if options.includelogs: inputline.extend(["--includelogs"]) if options.path: inputline.extend(["--path", options.path]) if runlogin: self.lobobj.loginfunction(inputline)
def statusvalidation(self, options): """ Status method validation function """ if options.encode and options.user and options.password: options.user = Encryption.decode_credentials(options.user) options.password = Encryption.decode_credentials(options.password) try: _ = self._rdmc.app.current_client except: raise NoCurrentSessionEstablished("Please login and make setting" \ " changes before using status command.")
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("") if options.encode and options.user and options.password: options.user = Encryption.decode_credentials(options.user) options.password = Encryption.decode_credentials(options.password) 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): """ 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("") if options.encode and options.user and options.password: options.user = Encryption.decode_credentials(options.user) options.password = Encryption.decode_credentials(options.password) self.factoryresetcontrollervalidation(options) self.selobj.selectfunction("SmartStorageConfig.") content = self._rdmc.app.get_save() 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 bootordervalidation(self, options): """ Boot order method validation function :param options: command line options :type options: list. """ inputline = list() if self._rdmc.app.config._ac__commit.lower() == 'true': options.commit = True try: client = self._rdmc.app.current_client if options.biospassword: client.bios_password = options.biospassword 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) if options.encode: options.biospassword = Encryption.decode_credentials( options.biospassword)
def frcontrollervalidation(self, options): """ Factory reset controller validation function :param options: command line options :type options: list. """ client = None inputline = list() runlogin = False 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 or not client: runlogin = True if not inputline: sys.stdout.write('Local login initiated...\n') if runlogin: self.lobobj.loginfunction(inputline) if not options.all and not options.controller: raise InvalidCommandLineErrorOPTS( "Please specify a controller or use \'--all\'.")
def fwpkgvalidation(self, options): """ fwpkg validation function :param options: command line options :type options: list. """ inputline = list() client = None try: client = self._rdmc.app.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: 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 not inputline and not client: sys.stdout.write('Local login initiated...\n') if not client or inputline: self.lobobj.loginfunction(inputline)
def run(self, line): """ Main listcomp 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.installsetvalidation(options) if self.typepath.defs.isgen9: raise IncompatibleiLOVersionError('iLO Repository commands are ' \ 'only available on iLO 5.') if args and args[0] in ['delete', 'invoke'] and not options.name: raise InvalidCommandLineError('Name option is required for ' \ 'delete and invoke commands.') if options.name: if options.name.startswith('"') and options.name.endswith('"'): options.name = options.name[1:-1] if options.removeall: self.removeinstallsets() elif not args: self.printinstallsets(options) elif args[0].lower() == 'add': if not len(args) == 2: raise InvalidCommandLineError('add command requires an ' \ 'install set file.') else: self.addinstallset(args[1], options.name) elif args[0].lower() == 'delete': self.deleteinstallset(options.name) elif args[0].lower() == 'invoke': self.invokeinstallset(options) else: raise InvalidCommandLineError('%s is not a valid command.' % args[0]) return ReturnCodes.SUCCESS
def selectvalidation(self, options): """ Select data validation function :param options: command line options :type options: list. """ client = None runlogin = False 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 not inputline and not client: sys.stdout.write('Local login initiated...\n') if inputline: runlogin = True if options.includelogs: inputline.extend(["--includelogs"]) if options.path: inputline.extend(["--path", options.path]) if not client or runlogin: self.lobobj.loginfunction(inputline)
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 load_clone(self, filename, options): """ load the clone file onto the server :param filename: filename containing the clone config data :type filename: str :param options: command line options :type options: list. """ loadcontents = None if not filename: filename = 'clone.json' if not os.path.isfile(filename): raise InvalidFileInputError("File '%s' doesn't exist. Please " \ "create file by running save command." % file) if options.encryption: with open(filename, "rb") as myfile: data = myfile.read() data = Encryption().decrypt_file(data, \ options.encryption) else: myfile = open(filename, 'r') data = myfile.read() myfile.close() try: loadcontents = json.loads(data) except: raise InvalidFileFormattingError("Invalid file formatting " \ "found in file %s" % file) return loadcontents