def ilodisablechecks(self, options):
""" Verify it is safe to actually disable iLO
:param options: command line options
:type options: values, attributes of class obj
"""
if options.force:
sys.stdout.write(
'Force Enabled: Ignoring critical operation/mode checking.\n')
return True
else:
keyword_list = 'idle', 'complete'
try:
results = self._rdmc.app.select(selector='UpdateService.')[0]
except:
raise NoContentsFoundForOperationError(
"UpdateService. not found.")
try:
state = results.resp.dict['Oem']['Hpe']['State'].lower()
for val in keyword_list:
if val in state:
return True
return False
except:
raise NoContentsFoundForOperationError(
"iLO state not identified")
def run(self, line):
""" Wrapper function for main list function
:param line: command line input
:type line: string.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.listvalidation(options)
if args:
for arg in args:
newargs = list()
if "/" in arg:
newargs = arg.split("/")
arg = newargs[0]
if not self.getobj.getworkerfunction(arg, options, line,\
newargs=newargs, uselist=True):
raise NoContentsFoundForOperationError('No contents found '\
'for entry: %s\n' % arg)
else:
if not self.getobj.getworkerfunction(args, options, line, \
uselist=True):
raise NoContentsFoundForOperationError('No contents found.')
#Return code
return ReturnCodes.SUCCESS
def 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 run(self, line):
""" Main get worker function
:param line: command line input
:type line: string.
"""
try:
(options, args) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.getvalidation(options)
multiargs = False
content = []
if args:
for arg in args:
newargs = list()
if "/" in arg:
newargs = arg.split("/")
arg = newargs[0]
if len(args) > 1 and options.json:
multiargs = True
item = self.getworkerfunction(arg, options, line,\
newargs=newargs, results=True, multivals=True)
if item:
content.append(item)
else:
if not newargs:
raise NoContentsFoundForOperationError('No ' \
'contents found for entry: %s' % arg)
else:
raise NoContentsFoundForOperationError('No ' \
'contents found for entry: %s' % line[0])
else:
if not self.getworkerfunction(arg, options, line,\
newargs=newargs):
if not newargs:
raise NoContentsFoundForOperationError('No ' \
'contents found for entry: %s' % arg)
else:
raise NoContentsFoundForOperationError('No ' \
'contents found for entry: %s' % line[0])
else:
if not self.getworkerfunction(args, options, line):
raise NoContentsFoundForOperationError('No contents found')
if multiargs and options.json:
self.jsonprinthelper(content)
if options.logout:
self.logoutobj.logoutfunction("")
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main iLO reset worker function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, _) = self._parse_arglist(line)
except:
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
self.iloresetvalidation(options)
sys.stdout.write('\nAfter iLO resets the session will be terminated.' \
'\nPlease wait for iLO to initialize completely ' \
'before logging in again.\n')
sys.stdout.write('This process may take up to 3 minutes.\n\n')
select = "Manager."
results = self._rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
put_path = results.resp.request.path
else:
raise NoContentsFoundForOperationError("Unable to find %s" % select)
bodydict = results.resp.dict
try:
for item in bodydict['Actions']:
if 'Reset' in item:
if self.typepath.defs.isgen10:
action = item.split('#')[-1]
else:
action = 'Reset'
put_path = bodydict['Actions'][item]['target']
break
except:
action = "Reset"
body = {"Action": action}
postres = self._rdmc.app.post_handler(put_path, body, silent=True, \
service=True, response=True)
if postres.status == 200:
sys.stdout.write("A management processor reset is in progress.\n")
else:
sys.stderr.write("An error occured during iLO reset.\n")
raise IloResponseError("")
#Return code
return ReturnCodes.SUCCESS
def copyjobtoipqueue(self, ipjobs, jobkey):
"""
Copies HpeIpJob to Job queue. Function assumes there is a job to copy.
A check was already done to make sure we have a job to copy in hasipjobs()
:param ipjobs: url path of heip.
:type ipjobs: list of dictionary.
:param jobkey: key of job to copy.
:type jokbey: str.
"""
get_results = self._rdmc.app.get_handler(self.path,\
verbose=self._rdmc.opts.verbose, silent=True)
j2python = json.loads(get_results.read)
copy_job = {}
for ipj in j2python:
if jobkey == ipj:
copy_job = j2python[ipj]
copy_job = json.loads(self.decode_base64_string(copy_job))
break
if not copy_job:
raise NoContentsFoundForOperationError(
"Job key does not match any ipprofile")
copy_job['log'] = [{"msg": "WAITINGTOBEPROCESSED", "percent": 0}]
copy_job['status'] = "waiting"
payload = {}
payload["path"] = self.ipjobs
payload["body"] = copy_job
self._rdmc.app.put_handler(payload["path"], payload["body"],\
verbose=self._rdmc.opts.verbose)
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 importcrlhelper(self, args):
""" Helper function for importing CRL certificate
:param args: list of args
:type args: list.
"""
if not self.typepath.flagiften:
raise IncompatibleiLOVersionError(
"This certificate is not available on this system.")
select = 'HpeCertAuth.'
results = self._rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
bodydict = results.resp.dict
else:
raise NoContentsFoundForOperationError("Unable to find %s" %
select)
for item in bodydict['Actions']:
if 'ImportCRL' in item:
action = item.split('#')[-1]
path = bodydict['Actions'][item]['target']
break
body = {"Action": action, "ImportUri": args[1]}
self._rdmc.app.post_handler(path, body)
def run(self, line):
"""Main serverstate 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("Invalid number of parameters, "\
"serverstate command does not take any parameters.")
self.serverstatevalidation(options)
path = self.typepath.defs.systempath
results = self._rdmc.app.get_handler(path, silent=True,
uncache=True).dict
if results:
results = results['Oem'][self.typepath.defs.oemhp]['PostState']
sys.stdout.write("The server is currently in state: " + results +
'\n')
else:
raise NoContentsFoundForOperationError(
"Unable to retrieve server state")
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 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(options)
self.validate_show_pmem_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.show_pmem_modules(options)
return ReturnCodes.SUCCESS
def search_helper(self, new_searches, curr_searches):
""" Helper to prepare search strings for patching
:param new_serches: dictionary of new searches to add
:type new_searches: dict.
:param curr_searches: list of current searches
:type curr_searches: dict.
"""
final_searches = curr_searches
if 'add' in new_searches:
if 'BaseDistinguishedNames' in final_searches:
for search in new_searches['add']:
final_searches['BaseDistinguishedNames'].append(search)
else:
final_searches['BaseDistinguishedNames'] = new_searches['add']
elif 'remove' in new_searches:
to_remove = []
if 'BaseDistinguishedNames' not in curr_searches:
raise NoContentsFoundForOperationError("No search strings to remove")
for search in new_searches['remove']:
if search in curr_searches['BaseDistinguishedNames']:
to_remove.append(search)
else:
raise InvalidCommandLineError("Unable to find search %s to delete" % search)
for item in to_remove:
final_searches['BaseDistinguishedNames'].remove(item)
return final_searches
def run(self, line):
"""
Wrapper function for new command main function
:param line: command line input
:type line: string.
"""
LOGGER.info("Clear Pending Configuration: %s", self.name)
# pylint: disable=unused-variable
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 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")
memory_chunk_tasks = self.get_memory_chunk_tasks()
self.delete_tasks(memory_chunk_tasks, verbose=True)
return ReturnCodes.SUCCESS
def update_mapping_privs(self, roles_to_update):
""" Helper function to update created role mappings to match user privileges.
:param roles_to_update: Dictionary of privileges to update.
:type roles_to_update: dict
"""
sys.stdout.write("Updating privileges of created role maps...\n")
try:
results = self._rdmc.app.select(selector='AccountService.', path_refresh=True)[0].dict
roles = self._rdmc.app.getcollectionmembers(\
self._rdmc.app.getidbytype('RoleCollection.')[0])
except (KeyError, IndexError):
raise NoContentsFoundForOperationError("Unable to gather Role settings. Roles may not "\
"be updated to match privileges requested.")
for rolemap in results['LDAP']['RemoteRoleMapping']:
for role in roles:
if role['RoleId'] == rolemap['LocalRole']:
role['RemoteGroup'] = rolemap['RemoteGroup']
break
for role in roles:
privs = {'AssignedPrivileges' : [], 'OemPrivileges': []}
for update_role in roles_to_update.keys():
if role.get('RemoteGroup', None) == update_role:
for priv in roles_to_update[update_role]:
privs[PRIVKEY[priv][1]].append(PRIVKEY[priv][0])
try:
self._rdmc.app.patch_handler(role['@odata.id'], privs)
sys.stdout.write("Updated privileges for %s\n" % update_role)
except IloResponseError:
sys.stdout.write("Unable to update privileges for %s\n" % update_role)
break
def show_pending_config(self, options):
"""
Command to display information about pending Persistent Memory Configuration
:param options: command options
:type options: options.
"""
# retrieving task members
task_members = self._rest_helpers.retrieve_task_members()
# filtering task members
filtered_task_members = self._rest_helpers.filter_task_members(
task_members)
if not filtered_task_members:
sys.stdout.write("\nNo pending configuration tasks found.\n\n")
return None
# retrieving memory members
memory = self._rest_helpers.retrieve_memory_resources()
if memory:
memory_members = memory.get("Members")
else:
raise NoContentsFoundForOperationError(
"Failed to retrieve Memory Resources")
attributes = ["Operation", "PmemSize", "VolatileSize", "DimmIds"]
display_output = list()
for task in filtered_task_members:
# finding operation of task
operation = self._mapper.get_single_attribute(
task, "Operation", MappingTable.tasks.value, True)
# displaying existing configuration for DELETE operation
if operation.get("Operation", "") == "DELETE":
target_uri = task.get("Payload").get("TargetUri")
data = self._rest_helpers.get_resource(target_uri)
table = MappingTable.delete_task.value
else:
task_type = self._mapper.get_single_attribute(
task, "Type", MappingTable.tasks.value, True)
task_type = task_type.get("Type", "")
if task_type != "PMEM":
sys.stdout.write(
"Unsupported interleave set type found: " + task_type)
continue
data = task
table = MappingTable.tasks.value
task_output = self._mapper.get_multiple_attributes(
data,
attributes,
table,
output_as_json=options.json,
memory=memory_members)
display_output.append(task_output)
if options.json:
self._display_helpers.display_data(display_output,
OutputFormats.json)
else:
self._display_helpers.display_data(display_output,
OutputFormats.table)
def run(self, line):
""" Main factorydefaults function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self.rdmc.rdmc_parse_arglist(self, line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if args:
raise InvalidCommandLineError(
"factorydefaults command takes no arguments.")
self.factorydefaultsvalidation(options)
self.rdmc.ui.warn("Resetting iLO to factory default settings.\n"\
"Current session will be terminated.\n")
select = 'Manager.'
results = self.rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
path = results.resp.request.path
else:
raise NoContentsFoundForOperationError("Manager. not found.")
bodydict = results.resp.dict['Oem'][self.rdmc.app.typepath.defs.oemhp]
try:
for item in bodydict['Actions']:
if 'ResetToFactoryDefaults' in item:
if self.rdmc.app.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)
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def run(self, line):
""" Main ESKMCommand function
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self.rdmc.rdmc_parse_arglist(self, line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if not len(args) == 1:
raise InvalidCommandLineError("eskm command only takes one parameter.")
self.eskmvalidation(options)
select = self.rdmc.app.typepath.defs.hpeskmtype
results = self.rdmc.app.select(selector=select)
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.rdmc.app.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)
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def timer(self, minutes=1, ping=False):
""" helper that waits a certain number of minutes before returning or
pings a server until service is restored (ping only available in local)
:param minutes: time in minutes
:type minutes: int
:param ping: value indicating if ping or timer function
:type ping: bool
"""
if ping:
results = None
timeout = 0
while True:
if not results:
try:
if timeout == 0:
time.sleep(10)
self._rdmc.app.login(is_redfish=True)
results = self._rdmc.app.get_handler(self.typepath.\
defs.startpath, silent=True)
timeout = 0
self._rdmc.app.logout()
except:
self._rdmc.app.logout()
time.sleep(5)
timeout += 1
else:
try:
if timeout == 0:
time.sleep(10)
self._rdmc.app.login(is_redfish=True)
self._rdmc.app.select(
selector=self.typepath.defs.biostype)
time.sleep(10)
self._rdmc.app.logout()
return
except:
self._rdmc.app.logout()
time.sleep(5)
timeout += 1
if timeout >= 60:
raise NoContentsFoundForOperationError("Unable to connect" \
" to iLO.")
else:
for minute in range(minutes):
if minute + 1 == minutes:
sys.stdout.write("1 minute remaining...\n")
else:
sys.stdout.write("%s minutes remaining...\n" \
% str(minutes-minute))
time.sleep(60)
def backupserver(self, options, skey):
"""Create .bak file for a server
:param options: command options
:type options: list.
:param skey: sessionkey of the currently logged in server
:type skey: str.
"""
select = "HpeiLOBackupRestoreService."
backupfile = None
results = self.rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
service = results.resp.dict
else:
raise NoContentsFoundForOperationError("%s not found.It may not " \
"be available on this system." % select)
backuplocation = service['BackupFileLocation']
backupname = backuplocation.split('/')[-1]
postdata = []
postdata.append(('sessionKey', skey))
if options.fpass:
postdata.append(('password', options.fpass))
self.rdmc.ui.printer("Downloading backup file %s..." % backupname)
backupfile = self.rdmc.app.post_handler(backuplocation, postdata,\
service=True, silent=True)
if backupfile:
self.rdmc.ui.printer("Download complete.\n")
outfile = open(backupname, 'wb')
outfile.write(backupfile.ori)
outfile.close()
else:
raise NoContentsFoundForOperationError(
"Unable to download file.\n")
def configure_pmm(self, options):
"""
Applies selected configuration to the PMMs
:param options: options specified by user
:returns: None
"""
# Retrieve Memory Chunks and Task Resources from server.
(task_members, domain_members, memory_chunks) = self._rest_helpers \
.retrieve_task_members_and_mem_domains()
# Filter Task Resources to include only Pending Configuration Tasks.
memory_chunk_tasks = self._rest_helpers.filter_task_members(task_members)
if not domain_members:
raise NoContentsFoundForOperationError("Failed to retrieve Memory Domain Resources")
# Dict with input config data
config_data = {"size": options.memorymode,
"pmeminterleave": options.interleave,
"proc": options.proc}
# Check for given processor id list is valid or not.
if options.proc:
config_data["proc"] = self.get_valid_processor_list(config_data["proc"], domain_members)
memory_chunks = self.filter_memory_chunks(memory_chunks,
domain_members,
config_data["proc"])
# In case of 100% Volatile, Interleaving memory regions is not applicable.
if config_data["size"] == 100 and config_data["pmeminterleave"] and \
config_data["pmeminterleave"].lower() == "on":
raise InvalidCommandLineError("Selected configuration is invalid. "
"Interleaving not supported in 100% volatile.")
if options.force:
self.delete_existing_chunks_and_tasks(memory_chunk_tasks, memory_chunks)
else:
self.warn_existing_chunks_and_tasks(memory_chunk_tasks, memory_chunks)
for member in domain_members:
proc_id = member['Id'].encode('ascii', 'ignore')
# If given proc list is not empty, applies configuration to selected processors
if not config_data["proc"] or (proc_id in config_data["proc"]):
path = member['MemoryChunks'].get('@odata.id').encode('ascii', 'ignore')
data = self.get_post_data(config_data, member['InterleavableMemorySets'])
for body in data:
resp = self._rest_helpers.post_resource(path, body)
if resp is None:
raise NoChangesFoundOrMadeError("Error occurred while applying configuration")
# Display warning
sys.stdout.write("\n***WARNING: Configuration changes require reboot to take effect***\n")
# Display pending configuration
self._show_pmem_config.show_pending_config(type("MyOptions", (object, ), dict(json=False)))
return None
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 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 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 addinstallset(self, setfile, name):
"""Adds an install set
:param setfile: filename of install set
:type setfile: str.
:param name: string of the install set name to add
:type name: str.
"""
path = '/redfish/v1/UpdateService/InstallSets/'
comps = self._rdmc.app.getcollectionmembers(\
'/redfish/v1/UpdateService/ComponentRepository/')
sets = self._rdmc.app.getcollectionmembers(path)
if not name:
name = str(datetime.datetime.now())
name = name.replace(':', '')
name = name.replace(' ', 'T')
try:
inputfile = open(setfile, 'r')
sequences = json.loads(inputfile.read())
except Exception as excp:
raise InvalidFileInputError("%s" % excp)
listtype = self.validatefile(sequences)
if listtype:
body = {"Name": name, "Sequence": sequences}
else:
body = sequences
if "Sequence" in body:
sequences = body['Sequence']
else:
raise InvalidFileInputError("Invalid install set file.")
sequences = body["Sequence"]
filenamelist = [x['Filename'] for x in comps]
for sequence in sequences:
if sequence['Command'] == 'ApplyUpdate':
if 'Filename' in list(sequence.keys()):
if not sequence['Filename'] in filenamelist:
raise NoContentsFoundForOperationError('Component' \
' referenced in install set is not present on' \
' iLO Drive: %s' % sequence['Filename'])
elif sequence['Command'] == 'WaitTimeSeconds':
sequence['WaitTimeSeconds'] = int(sequence['WaitTimeSeconds'])
for setvar in sets:
if setvar['Name'] == body['Name']:
raise InvalidCommandLineError(
'Install set name is already in use.')
self._rdmc.app.post_handler(path, body)
def getcerthelper(self, _, options):
""" Helper function for importing CRL certificate
:param options: list of options
:type options: list.
"""
select = self.typepath.defs.hphttpscerttype
results = self._rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
try:
csr = results.resp.dict['CertificateSigningRequest']
if not csr:
raise ValueError
except (KeyError, ValueError):
raise NoContentsFoundForOperationError('Unable to find a valid certificate. If '\
'you just generated a new certificate '\
'signing request the process may take '\
'up to 10 minutes.')
if not options.filename:
filename = __filename__
else:
filename = options.filename[0]
outfile = open(filename, 'w')
outfile.write(csr)
outfile.close()
sys.stdout.write("Certificate saved to: %s\n" % filename)
else:
raise NoContentsFoundForOperationError("Unable to find %s" %
select)
def run(self, line):
""" Main clearrestapistate function.
:param line: string of arguments passed in
:type line: str.
"""
try:
(options, args) = self.rdmc.rdmc_parse_arglist(self, line)
except (InvalidCommandLineErrorOPTS, SystemExit):
if ("-h" in line) or ("--help" in line):
return ReturnCodes.SUCCESS
else:
raise InvalidCommandLineErrorOPTS("")
if args:
raise InvalidCommandLineError(
"clearrestapistate command takes no arguments.")
self.clearrestapistatevalidation(options)
select = 'Manager.'
results = self.rdmc.app.select(selector=select)
try:
results = results[0]
except:
pass
if results:
path = results.resp.request.path
else:
raise NoContentsFoundForOperationError("Manager. not found.")
bodydict = results.resp.dict['Oem'][self.rdmc.app.typepath.defs.oemhp]
try:
for item in bodydict['Actions']:
if 'ClearRestApiState' in item:
if self.rdmc.app.typepath.defs.isgen10:
action = item.split('#')[-1]
else:
action = "ClearRestApiState"
path = bodydict['Actions'][item]['target']
body = {"Action": action}
break
except:
body = {"Action": "ClearRestApiState", "Target": "/Oem/Hp"}
self.rdmc.app.post_handler(path, body)
self.cmdbase.logout_routine(self, options)
#Return code
return ReturnCodes.SUCCESS
def copyjobtoipqueue(self, ipjobs, jobkey):
"""
Copies HpeIpJob to Job queue. Function assumes there is a job to copy.
A check was already done to make sure we have a job to copy in hasipjobs()
:param ipjobs: url path of heip.
:type ipjobs: list of dictionary.
:param jobkey: key of job to copy.
:type jokbey: str.
"""
get_results = self._rdmc.app.get_handler(self.path,\
verbose=self._rdmc.opts.verbose, silent=True)
j2python = json.loads(get_results.read)
copy_job = {}
for ipj in j2python:
if jobkey == ipj:
_decode = self.decode_base64_string(j2python[ipj])
if _decode is not None:
_critical_props = {
"log": "[{\"msg\": \"WAITINGTOBEPROCESSED\", \"percent\": 0}]",
"status": "waiting"
}
copy_job.update({k: v.update(_critical_props) or v \
for k, v in json.loads(_decode).items() if k in self.ipjobtype})
else:
raise NoContentsFoundForOperationError(\
"Not supported profile content")
break
if not copy_job:
raise NoContentsFoundForOperationError(\
"The ID %s does not match any ipprofile" % jobkey)
payload = {}
payload["path"] = self.ipjobs
payload["body"] = copy_job
self._rdmc.app.put_handler(payload["path"], payload["body"],\
verbose=self._rdmc.opts.verbose)
def apply_pmm_config(self, options):
"""
Calls relevant functions based on the flags specified by the user.
:param options: options specified by the user.
:type options: instance of OptionParser class.
"""
if options.list:
self.show_predefined_config_options()
elif options.config:
# 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.apply_predefined_config(options)
def apply_predefined_config(self, options):
"""
Apply the selected pre-defined configuration to Persistent Memory Modules.
:param options: option specified by the user.
:returns: None
"""
# Retrieve Memory Chunks and Task Resources from server
(task_members, domain_members, memory_chunks) = self._rest_helpers \
.retrieve_task_members_and_mem_domains()
# Filter Task Resources to include only Pending Configuration Tasks
memory_chunk_tasks = self._rest_helpers.filter_task_members(
task_members)
if options.force:
self.delete_existing_chunks_and_tasks(memory_chunk_tasks,
memory_chunks)
else:
self.warn_existing_chunks_and_tasks(memory_chunk_tasks,
memory_chunks)
if not domain_members:
raise NoContentsFoundForOperationError(
"Failed to retrive Memory Domain Resources")
# Get the user specified configID
config_data = next((config_id for config_id in self.config_ids \
if config_id.get("name").lower() == options.config.lower()), None)
for proc in domain_members:
path = proc['MemoryChunks'].get('@odata.id').encode(
'ascii', 'ignore')
data = self.get_post_data(config_data,
proc['InterleavableMemorySets'])
for body in data:
resp = self._rest_helpers.post_resource(path, body)
if resp is None:
raise NoChangesFoundOrMadeError(
"Error occured while applying configuration")
# display warning
sys.stdout.write(
"\n***WARNING: Configuration changes require reboot to take effect***\n"
)
# display pending configuration
self._show_pmem_config.show_pending_config(
type("MyOptions", (object, ), dict(json=False)))
def createtask(self, tasks):
""" Creates a task in the update task queue
:param tasks: arguments for creating tasks
:type tasks: list.
"""
path = '/redfish/v1/UpdateService/UpdateTaskQueue/'
comps = self._rdmc.app.getcollectionmembers('/redfish/v1/UpdateService/'\
'ComponentRepository/')
for task in tasks:
usedcomp = None
newtask = None
try:
usedcomp = int(task)
newtask = {'Name': 'Wait-%s %s seconds' % (str(randint(0, \
1000000)), str(usedcomp)), 'Command': 'Wait', \
'WaitTimeSeconds':usedcomp, 'UpdatableBy':[\
'RuntimeAgent', 'Uefi']}
except:
pass
if task.lower() == 'reboot':
newtask = {'Name': 'Reboot-%s' % str(randint(0, 1000000)), \
'Command': 'ResetServer', 'UpdatableBy': \
['RuntimeAgent']}
elif not newtask:
try:
for comp in comps:
if comp['Filename'] == task:
usedcomp = comp
break
except:
pass
if not usedcomp:
raise NoContentsFoundForOperationError('Component ' \
'referenced is not present on iLO Drive: %s' % task)
newtask = {'Name': 'Update-%s %s' % (str(randint(0, 1000000)), \
usedcomp['Name']), 'Command': 'ApplyUpdate',\
'Filename': usedcomp['Filename'], 'UpdatableBy': usedcomp\
['UpdatableBy'], 'TPMOverride': True}
sys.stdout.write('Creating task: "%s"\n' % newtask['Name'])
self._rdmc.app.post_handler(path, newtask)