def get_name(self):
return TypeHelper.resolve(self.enumid)
def __repr__(self):
return (TypeHelper.resolve(str(self.enid)) + "(port=" +
str(self.port) + ")" + "(timeout=" + str(self.timeout) +
")" / + "(nretries =" + str(self.nretries) + ")")
def _enumerate_view(self, index, views, bTrue):
if not index in views:
logger.debug("WARN: no " + str(index) + " for " + str(self.enumid))
return {'Status': 'Success', 'Message': 'Not supported'}
clsName = TypeHelper.resolve(index)
logger.debug("Collecting " + clsName + " ... via " + str(self.enumid) +
"...")
if Simulator.is_simulating():
retval = Simulator.simulate_proto(self.ipaddr, self.enumid,
clsName)
else:
# Changed True to False for having single session
wsprof = views[index]
filter = None
if isinstance(views[index],
list) and self.enumid == ProtocolEnum.WSMAN:
wsprof = views[index][0]
filter = views[index][1]
retval = self.proto.enumerate(clsName, wsprof, self.selectors,
False, filter)
if Simulator.is_recording():
Simulator.record_proto(self.ipaddr, self.enumid, clsName,
retval)
if not 'Data' in retval or retval['Data'] is None:
return retval
if index in self.classifier_cond:
chk_func = self.classifier_cond[index].get(self.enumid, None)
if chk_func:
(valid, flist) = chk_func(retval['Data'][clsName], clsName)
if valid:
retval['Data'][clsName] = flist
else:
return {
'Status': 'Failed',
'Message': 'Classifier condition not satisfied'
}
if index in self.classifier:
for attr in self.classifier[index]:
if not clsName in retval['Data']:
return {
'Status': 'Failed',
'Message': clsName + ' instance is not found!'
}
if not attr in retval['Data'][clsName]:
return {
'Status': 'Failed',
'Message': 'Classifier attribute not found!'
}
if not re.search(self.classifier[index][attr],
retval['Data'][clsName][attr]):
return {
'Status': 'Failed',
'Message': 'Classifier did not match!'
}
for en in self.view_fieldspec:
if en != index:
continue
for retobj in retval['Data']:
if isinstance(retval['Data'][retobj], dict):
self._apply_spec(retval['Data'][retobj], en)
else:
for i in retval['Data'][retobj]:
self._apply_spec(i, en)
return retval
def get_job_status(self, jobid):
"""
Get the job status
:param jobid: Job ID
:type jobid: str
:return: success/failure response
:rtype: JSON
.. code-block:: python
:caption: Examples
:name: Examples
# Get Job Status
job_status = idrac.job_mgr.get_job_status(jobid="jid_1234")
"""
if self.entity.use_redfish:
return self.get_job_status_redfish(jobid)
jobs = {}
jobret = {"Status": TypeHelper.resolve(JobStatusEnum.InProgress)}
if jobid.startswith('DCIM_OSD'):
# Poll for OSD Concrete Job
jobs = self._get_osd_job_details()
else:
jobs = self.get_job_details(jobid)
logger.debug(self.entity.ipaddr+": job: "+str(jobs))
if "Status" in jobs and jobs['Status'] != "Success":
logger.error(self.entity.ipaddr+" : get_job_status failed: jobid: " + jobid + " : Status " + jobs['Status'])
logger.error(self.entity.ipaddr+" : get_job_status failed: jobid: " + jobid + " : Message " + jobs['Message'])
return jobs
jb = jobs['Data']['Jobs']
if jb['InstanceID'] != jobid:
logger.error(self.entity.ipaddr + " : get_job_status failed: jobid: " + jobid + " : ERROR: Job instance not found")
return jobs
if 'JobStatus' in jb:
jobstatus = jb['JobStatus']
if jobstatus == 'Completed':
jobstaten = JobStatusEnum.Success
elif jobstatus == 'Failed':
jobstaten = JobStatusEnum.Failed
elif jobstatus == 'Pending':
jobstaten = JobStatusEnum.InProgress
elif jobstatus.endswith('In Progress'):
jobstaten = JobStatusEnum.InProgress
elif jobstatus.endswith('Scheduled'):
jobstaten = JobStatusEnum.InProgress
elif jobstatus.endswith('Running'):
jobstaten = JobStatusEnum.InProgress
elif jobstatus.endswith('Invalid'):
jobstaten = JobStatusEnum.InProgress
elif jobstatus.endswith('Success'):
jobstaten = JobStatusEnum.Success
elif jobstatus.endswith('Errors'):
jobstaten = JobStatusEnum.Failed
elif 'Message' in jb and jb['Message'] and 'completed' in jb['Message'] and 'errors' not in jb['Message']:
jobstaten = JobStatusEnum.Success
else:
jobstaten = JobStatusEnum.InProgress
jb['Status'] = TypeHelper.resolve(jobstaten)
return jb
def unset(self, scopeType):
n = TypeHelper.resolve(scopeType)
self.mix = (~(self.mix & n) & self.mix)
def print_components(self):
for comp in self.ComponentEnum:
print(TypeHelper.resolve(comp))
def __repr__(self):
return TypeHelper.resolve(self._value)
def __repr__(self):
return TypeHelper.resolve(self.enid)
def __repr__(self):
return (TypeHelper.resolve(self.enid) + "(community=" + self.community + ")")
def _create_virtual_drive(idrac, module):
"""
Create a virtual drive
Keyword arguments:
idrac -- iDRAC handle
module -- Ansible module
"""
msg = {}
span_length = module.params.get('span_length')
span_depth = module.params.get('span_depth')
pd_slots = module.params.get('pd_slots')
raid_level = TypeHelper.convert_to_enum(module.params['raid_level'],
RAIDTypesTypes)
read_policy = TypeHelper.convert_to_enum(module.params['read_policy'],
RAIDdefaultReadPolicyTypes)
write_policy = TypeHelper.convert_to_enum(module.params['write_policy'],
RAIDdefaultWritePolicyTypes)
disk_policy = TypeHelper.convert_to_enum(module.params['disk_policy'],
DiskCachePolicyTypes)
# Physical Disk filter
pd_filter = '((disk.parent.parent is Controller and disk.parent.parent.FQDD._value == "{0}")'.format(
module.params['controller_fqdd'])
pd_filter += ' or (disk.parent is Controller and disk.parent.FQDD._value == "{0}"))'.format(
module.params['controller_fqdd'])
pd_filter += ' and disk.MediaType == "{0}"'.format(
module.params['media_type'])
pd_filter += ' and disk.BusProtocol == "{0}"'.format(
module.params['bus_protocol'])
# Either one of Span Length and Physical Disks Slots must be defined
if not (span_length or pd_slots):
module.fail_json(
msg="Either span_length or pd_slots must be defined for VD creation"
)
elif pd_slots:
slots = ""
for i in pd_slots:
slots += "\"" + str(i) + "\","
slots_list = "[" + slots[0:-1] + "]"
pd_filter += " and disk.Slot._value in " + slots_list
span_length = len(pd_slots)
# check span_length
if span_length < MIN_SPAN_LENGTH[TypeHelper.resolve(raid_level)]:
module.fail_json(msg="Invalid span length for RAID Level: " +
TypeHelper.resolve(raid_level))
# Span depth must be at least 1 which is used for RAID 0, 1, 5 and 6
span_depth = 1 if (span_depth < 1) else span_depth
# Span depth must be at least 2 for RAID levels 10, 50 and 60
if raid_level in [
RAIDTypesTypes.RAID_10, RAIDTypesTypes.RAID_50,
RAIDTypesTypes.RAID_60
]:
span_depth = 2 if (span_depth < 2) else span_depth
msg = idrac.config_mgr.RaidHelper.new_virtual_disk(
Name=module.params['vd_name'],
Size=module.params['vd_size'],
RAIDaction=RAIDactionTypes.Create,
RAIDTypes=raid_level,
RAIDdefaultReadPolicy=read_policy,
RAIDdefaultWritePolicy=write_policy,
DiskCachePolicy=disk_policy,
SpanLength=span_length,
SpanDepth=span_depth,
StripeSize=module.params['stripe_size'],
NumberDedicatedHotSpare=module.params['dedicated_hot_spare'],
NumberGlobalHotSpare=module.params['global_hot_spare'],
PhysicalDiskFilter=pd_filter)
return msg
def json_encode(self):
retval = {}
for i in self.creds:
retval[TypeHelper.resolve(i)] = str(self.creds[i])
return retval
def _build_tree(self,
mTree,
device_json,
ctree,
parent=None,
parentClsName=None):
comp_tree = {}
if not ctree in mTree:
return comp_tree
for entry in mTree[ctree]:
if isinstance(entry, str):
comp_tree[entry] = self._build_tree(mTree, device_json, entry)
continue
# Enum
enname = TypeHelper.resolve(entry)
if not enname in device_json:
logger.debug("Component " + enname +
" is not present in device!")
continue
if isinstance(device_json[enname], dict):
if len(device_json[enname]) <= 0:
# Empty entry
continue
child_index = self._get_obj_index(enname, device_json[enname])
if parent == None or self._isin(parentClsName, parent, enname,
device_json[enname]):
if not entry in mTree:
# entry is a leaf node
comp_tree[enname] = child_index
else:
# entry is not a leaf node
comp_tree[enname] = {
child_index:
self._build_tree(mTree, device_json, entry,
device_json[enname], enname)
}
elif isinstance(device_json[enname], list):
if len(device_json[enname]) <= 0:
# Empty entry
continue
dict_list = {}
list_list = []
for tt in device_json[enname]:
child_index = self._get_obj_index(enname, tt)
if parent == None or self._isin(parentClsName, parent,
enname, tt):
if not entry in mTree:
# entry is a leaf node
list_list.append(child_index)
else:
# entry is not a leaf node
dict_list[child_index] = self._build_tree(
mTree, device_json, entry, tt, enname)
if len(dict_list) != 0 and len(list_list) == 0:
comp_tree[enname] = dict_list
elif len(dict_list) == 0 and len(list_list) != 0:
comp_tree[enname] = list_list
elif len(dict_list) != 0 and len(list_list) != 0:
comp_tree[enname] = dict_list
comp_tree[enname]["_unknown_"] = list_list
else:
logger.debug("Unexpected format!")
return comp_tree
def _get_xml_string(self, everything=True, space='', deleted=False):
s = UnicodeStringWriter()
if not self._fname:
# group object!!
for i in self.Properties:
if not self.__dict__[i].is_changed() and not everything:
continue
attr_name = i
if attr_name in self._ign_fields:
continue
if '_' in attr_name:
attr_name = re.sub('_.*', '', attr_name)
attr_name = "{0}.{1}#{2}".format(self._alias,
self._index, attr_name)
else:
attr_name = "{0}".format(attr_name)
if isinstance(self.__dict__[i], FieldType):
if self.__dict__[i]._composite:
continue
if not self.__dict__[i]._modifyAllowed and deleted:
continue
value = TypeHelper.resolve(self.__dict__[i]._value)
if deleted: value = self.__dict__[i]._default_on_delete
s._write_output(' <Attribute Name="{0}">{1}</Attribute>\n'.format(
attr_name, value))
else:
s._write_output(self.__dict__[i]._get_xml_string(everything, space + ' ', deleted))
return s.getvalue()
s._write_output(space + '<{0}'.format(self._fname))
for i in self._attribs:
if i not in self._ign_attribs:
s._write_output(' {0}="{1}"'.format(i, self._attribs[i]))
s._write_output('>\n')
orig_len = len(s.getvalue())
for i in self.Properties:
if not self.__dict__[i].is_changed() and not everything:
continue
attr_name = i
if attr_name in self._ign_fields:
continue
if isinstance(self.__dict__[i], FieldType):
if not self.__dict__[i]._composite:
if not self.__dict__[i]._modifyAllowed and deleted:
continue
value = TypeHelper.resolve(self.__dict__[i]._value)
if deleted: value = self.__dict__[i]._default_on_delete
values = [value]
if self.__dict__[i]._list:
values = value.split(',')
for val in values:
s._write_output(space +
' <Attribute Name="{0}">{1}</Attribute>\n'.format(
attr_name, val))
else:
s._write_output(self.__dict__[i]._get_xml_string(everything, space + ' ', deleted))
new_len = len(s.getvalue())
if new_len == orig_len:
return ""
s._write_output(space + '</{0}>\n'.format(self._fname))
return s.getvalue()
class SDKServer:
# SDK Server instance and services data (Singleton)
__sdk_server_instance = None
__http_protocol = TypeHelper.resolve(SDKServerProtocolEnum.HTTP)
__https_protocol = TypeHelper.resolve(SDKServerProtocolEnum.HTTPS)
__server = {
"http": {
"server_instance": None,
"server_config": {
"port": None,
"directory": None,
"state": SDKServerStateEnum.Stopped,
"handler": SDKHTTPServerRequestHandler,
}
},
"https": {
"server_instance": None,
"server_config": {
"port": None,
"directory": None,
"state": SDKServerStateEnum.Stopped,
"handler": SDKHTTPSServerRequestHandler,
"server_certificate": None,
"private_key": None,
"ca_chain_certificate": None
}
}
}
@staticmethod
def __load_config(path):
file_type = path.split(os.sep)[-1].split(".")[-1].lower()
try:
with open(path, 'rt') as f:
if file_type == "json":
config = json.load(f)
elif file_type == "yaml" or file_type == "yml":
config = yaml.safe_load(f.read())
return config
except IOError as e:
logger.error("I/O error({0}): {1}".format(e.errno, e.strerror))
return None
@staticmethod
def load_server_configuration(configuration_file=os.path.join(os.path.dirname(__file__), "config",
"sdk-server-config.json")):
configuration = SDKServer.__load_config(configuration_file)
if configuration is None:
logger.error("No configuration available...")
else:
# Load HTTP Server configuration
http_port = configuration[SDKServer.__http_protocol]["port"]
http_directory = configuration[SDKServer.__http_protocol]["directory"]
sdk_http_server = SDKServer.__server[SDKServer.__http_protocol]
sdk_http_server["server_config"]["port"] = choice(http_port) if type(
http_port) == range else http_port
sdk_http_server["server_config"]["directory"] = http_directory
# Load HTTPS Server configuration
https_port = configuration[SDKServer.__https_protocol]["port"]
https_directory = configuration[SDKServer.__https_protocol]["directory"]
https_server_certificate = configuration[SDKServer.__https_protocol]["certificate"]
https_private_key = configuration[SDKServer.__https_protocol]["private_key"]
https_ca_chain_certificate = configuration[SDKServer.__https_protocol]["ca_chain_certificate"]
sdk_https_server = SDKServer.__server[SDKServer.__https_protocol]
sdk_https_server["server_config"]["port"] = choice(https_port) if type(
https_port) == range else https_port
sdk_https_server["server_config"]["directory"] = https_directory
sdk_https_server["server_config"]["server_certificate"] = https_server_certificate
sdk_https_server["server_config"]["private_key"] = https_private_key
sdk_https_server["server_config"]["ca_chain_certificate"] = https_ca_chain_certificate
@staticmethod
def get_server_instance():
if SDKServer.__sdk_server_instance is None:
SDKServer()
sdk_http_server = SDKServer.__server[SDKServer.__http_protocol]
print(sdk_http_server["server_config"]["directory"])
if sdk_http_server["server_instance"] is None:
sdk_http_server["server_instance"] = SDKHTTPServer(
sdk_http_server["server_config"]["directory"],
("", sdk_http_server["server_config"]["port"]),
sdk_http_server["server_config"]["handler"])
sdk_https_server = SDKServer.__server[SDKServer.__https_protocol]
if sdk_https_server["server_instance"] is None:
sdk_https_server["server_instance"] = SDKHTTPServer(
sdk_https_server["server_config"]["directory"],
("", sdk_https_server["server_config"]["port"]),
sdk_https_server["server_config"]["handler"])
context = ssl.SSLContext(ssl.PROTOCOL_TLS)
context.verify_mode = ssl.CERT_NONE
context.check_hostname = False
context.load_cert_chain(certfile=sdk_https_server["server_config"]["server_certificate"],
keyfile=sdk_https_server["server_config"]["private_key"],
password="******")
if sdk_https_server["server_config"]["ca_chain_certificate"] is not None:
context.load_verify_locations(cafile=sdk_https_server["server_config"]["ca_chain_certificate"])
sdk_https_server["server_instance"].socket = context.wrap_socket(
sdk_https_server["server_instance"].socket, server_side=True)
return SDKServer.__sdk_server_instance
def __init__(self):
if SDKServer.__sdk_server_instance is not None:
logger.warning("SDK Server already instantiated..")
SDKServer.__sdk_server_instance = self
def start_server(self, protocol=SDKServerProtocolEnum.HTTP):
server_protocol = TypeHelper.resolve(protocol)
sdk_server = SDKServer.__server[server_protocol]
if sdk_server["server_instance"] is None:
logger.error("{} Server is not instantiated...".format(server_protocol))
elif sdk_server["server_config"]["state"] == SDKServerStateEnum.Running:
logger.warning("{} Server is already running...".format(server_protocol))
else:
server_address = sdk_server["server_instance"].socket.getsockname()
sdk_server["server_config"]["state"] = SDKServerStateEnum.Running
logger.debug("Starting {} server on {} at port {} ...".format(server_protocol, server_address[0],
server_address[1]))
sdk_server["server_instance"].serve_forever()
def stop_server(self, protocol=SDKServerProtocolEnum.HTTP):
server_protocol = TypeHelper.resolve(protocol)
sdk_server = SDKServer.__server[server_protocol]
if sdk_server["server_instance"] is None:
logger.error("{} Server is not instantiated...".format(server_protocol))
elif sdk_server["server_config"]["state"] == SDKServerStateEnum.Stopped:
logger.warning("{} Server is already stopped...".format(server_protocol))
else:
server_address = sdk_server["server_instance"].socket.getsockname()
logger.debug(
"Stopping {} server on {} at port {} ...".format(server_protocol, server_address[0], server_address[1]))
sdk_server["server_instance"].shutdown()
sdk_server["server_config"]["state"] = SDKServerStateEnum.Stopped
def get_server_status(self, protocol=SDKServerProtocolEnum.HTTP):
server_details = SDKServer.__server[TypeHelper.resolve(protocol)]
return {
"IPAddress": socket.gethostbyname(socket.gethostname()),
"Port": server_details["server_config"]["port"],
"State": server_details["server_config"]["state"]
}
def _parse_output(self, en, name=None):
retval = {}
if "Header" in en:
rgsp = "http://schemas.xmlsoap.org/ws/2004/09/transfer/GetResponse"
if "Action" in en["Header"] and en["Header"]["Action"] == rgsp:
retval['Status'] = 'Success'
retval['Data'] = en['Body']
rfault = "http://schemas.xmlsoap.org/ws/2004/08/addressing/fault"
if "Action" in en["Header"] and en["Header"]["Action"] == rfault:
retval['Status'] = 'Failed'
if not "Body" in en:
retval['Status'] = 'Invalid JSON. Does not have Body!'
elif "ClientFault" in en["Body"]:
retval['Status'] = 'Found Client (SDK) Side Fault'
retval['Fault.Data'] = en["Body"]["ClientFault"]
if "Reason" in en["Body"]["ClientFault"] and \
"Text" in en["Body"]["ClientFault"]["Reason"]:
retval['Message'] = WsManResponse().get_message(
en["Body"]["ClientFault"]["Reason"])
elif "Fault" in en["Body"]:
retval['Status'] = 'Found Fault'
retval['Fault.Data'] = en["Body"]["Fault"]
if "Reason" in en["Body"]["Fault"]:
retval['Message'] = WsManResponse().get_message(
en["Body"]["Fault"]["Reason"])
if retval['Message'] == "" and "Detail" in en["Body"]["Fault"]:
retval['Message'] = WsManResponse().get_message(
en["Body"]["Fault"]["Detail"])
elif "EnumerateResponse" in en["Body"]:
retval['Status'] = 'Success'
retval['Data'] = en["Body"]["EnumerateResponse"]["Items"]
elif "IdentifyResponse" in en["Body"]:
retval['Status'] = 'Success'
retval['Data'] = en["Body"]
else:
for entry in en["Body"]:
if not entry.endswith("_OUTPUT"):
continue
retval['Data'] = en["Body"]
retval['Status'] = 'Not understood the message. Sorry!'
if "Message" in en["Body"][entry]:
retval['Status'] = en["Body"][entry]["Message"]
retval['Message'] = en["Body"][entry]["Message"]
if "MessageID" in en["Body"][entry]:
retval['MessageID'] = en["Body"][entry]["MessageID"]
if "ReturnValue" in en["Body"][entry]:
ret = int(en["Body"][entry]["ReturnValue"])
retval['Return'] = TypeHelper.get_name(ret, ReturnValueMap)
retval['Status'] = retval['Return']
if ret == TypeHelper.resolve(ReturnValue.JobCreated):
retval['Job'] = {"ResourceURI": "", "JobId": ""}
ss = en["Body"][entry]
if "Job" in ss:
ss = ss["Job"]
if 'RebootJobID' in ss:
ss = ss['RebootJobID']
if "EndpointReference" in ss:
ss = ss["EndpointReference"]
if "ReferenceParameters" in ss:
ss = ss["ReferenceParameters"]
if "ResourceURI" in ss:
retval['Job']['ResourceURI'] = ss["ResourceURI"]
if "SelectorSet" in ss:
ss = ss["SelectorSet"]
if "Selector" in ss:
ss = ss["Selector"]
if len(ss) >= 1:
retval['Job']['JobId'] = ss[0]
retval['Job']['JobIdRest'] = [
ss[i] for i in range(1, len(ss))
]
else:
retval['Job']['JobId'] = 'Unknown'
retval['Job']['JobIdRest'] = ss
retval['Status'] = 'Success'
if not 'Status' in retval:
retval['Status'] = 'Dont understand the message'
retval['Data'] = en["Body"]
return retval
def __repr__(self):
return (TypeHelper.resolve(self.enid) + "(username="******")")
def sanitized_value(self):
if '_value' not in self.__dict__ or self._value is None:
return None
return TypeHelper.resolve(self._value)
def add(self, scopeType):
if self.check(scopeType):
self.mix = self.mix | TypeHelper.resolve(scopeType)
else:
raise AttributeError("Filter can only take Flag in argument")
def _should_i_include(self, component, entry):
if component == 'System':
if self.cfactory.work_protocols[0].name == "REDFISH":
entry['IPAddress'] = self.ipaddr
port = 443
if isinstance(self.pOptions, ProtocolOptionsFactory):
pOptions = self.pOptions.get(ProtocolEnum.REDFISH)
if pOptions:
port = pOptions.port
elif isinstance(self.pOptions, RedfishOptions):
port = self.pOptions.port
if ':' in self.ipaddr:
entry['URLString'] = "https://[" + str(
self.ipaddr) + "]:" + str(port)
else:
entry['URLString'] = "https://" + str(
self.ipaddr) + ":" + str(port)
if "Devices" in self.entityjson:
attrlist = ['PrimaryStatus', 'ServiceTag']
sysdict = self.entityjson.get('System', [None])[0]
devdict = self.entityjson.get('Devices', [None])[0]
if sysdict and devdict:
for attr in attrlist:
sysdict[attr] = devdict.get(attr, None)
if entry.get('ServiceTag', None):
entry['Key'] = entry.get('ServiceTag')
if entry.get("IPAddresses"):
ips = entry.get("IPAddresses").split(",")
IPv4Address = []
IPv6Address = []
for ip in ips:
if ':' in ip:
IPv6Address.append(ip)
else:
IPv4Address.append(ip)
if IPv6Address:
entry['IPv6Address'] = ", ".join(
str(i) for i in set(IPv6Address))
if IPv4Address:
entry['IPv4Address'] = ", ".join(
str(i) for i in set(IPv4Address))
if entry.get("URLs"):
ips = entry.get("URLs").split(",")
IPv4URL = []
IPv6URL = []
for ip in ips:
if '[' in ip:
IPv6URL.append(ip)
else:
IPv4URL.append(ip)
if IPv6URL:
entry['IPv6URL'] = ", ".join(str(i) for i in set(IPv6URL))
if IPv4URL:
entry['IPv4URL'] = ", ".join(str(i) for i in set(IPv4URL))
if component == "BladeSlot":
if entry.get('DeviceType') != TypeHelper.resolve(
NGMDeviceTypes.BladeSlot):
return False
if component == "ComputeModule":
model = entry.get('Model', "NA")
if 'MX740c' in model:
entry['FormFactor'] = 'Full length Single width'
if 'MX840c' in model:
entry['FormFactor'] = 'Full length Double width'
entry['ExtensionSlot'] = str(
int(entry.get('MasterSlotNumber', 0)) + 1)
if entry.get('DeviceType', "NA") != TypeHelper.resolve(
NGMDeviceTypes.ComputeModule) or entry.get(
"Occupied") != "True" or entry.get(
"IsPrimarySlot") != "True":
return False
if component == "StorageModule":
if entry.get('DeviceType', "NA") != TypeHelper.resolve(
NGMDeviceTypes.StorageModule) or entry.get(
"Occupied") != "True" or entry.get(
"IsPrimarySlot") != "True":
return False
entry['FormFactor'] = 'Full length Single width'
if component == "Slots_Summary":
if entry.get('DeviceType', "NA") != 3000 and entry.get(
'DeviceType', "NA") != 1000:
return False
if component == "PowerUsageByDevice":
values = ["", None, "NA"]
if entry.get('MinPower', "NA") in values:
entry['MinPower'] = "Not Available"
if entry.get('PeakPower', "NA") in values:
entry['PeakPower'] = "Not Available"
if component == 'Subsystem':
if entry['Key'] not in [
'PowerSupply', 'CMC', 'Fan', 'Temperature'
]:
return False
if component == "PowerSupply":
try:
values = ['Not Available', None, "", "NA"]
if entry.get('MemberId', 'NA') in values:
entry['Slot'] = 'Not Available'
else:
entry['Slot'] = entry['MemberId'][-1]
except (IndexError, KeyError, ValueError):
entry['Slot'] = 'Not Available'
if entry.get('EnableState', 'NA') == 'Absent':
entry.pop("PrimaryStatus", None)
if component == "IOModule":
if (entry.get("DeviceType") != 4000 and entry.get("DeviceType") != 8000) \
or entry.get("Occupied") != "True":
return False
if entry.get("IPAddresses"):
ips = entry.get("IPAddresses").split(",")
IPv4Address = []
IPv6Address = []
for ip in ips:
if ':' in ip:
IPv6Address.append(ip)
else:
IPv4Address.append(ip)
if IPv6Address:
entry['IPv6Address'] = ", ".join(
str(i) for i in set(IPv6Address))
if IPv4Address:
entry['IPv4Address'] = ", ".join(
str(i) for i in set(IPv4Address))
return True
def isset(self, scopeType):
n = TypeHelper.resolve(scopeType)
return ((self.mix & n) == n)
def _download_file(self, rfile, lfile):
try:
fstatus = self._validate_file(rfile, lfile)
if fstatus in [DownloadedFileStatusEnum.Same]:
# if the file is same, no need to download file
logger.debug(rfile['path'] + " is as expected!")
if self.protocol in [DownloadProtocolEnum.HashCheck]:
print("{0:16} {1}".format(TypeHelper.resolve(fstatus),
lfile))
return True
if self.protocol == DownloadProtocolEnum.HashCheck:
# in case of hashcheck, return the status after printing
if os.path.exists(lfile) and os.path.isfile(lfile):
print("{0:16} {1}".format(TypeHelper.resolve(fstatus),
lfile))
else:
print("{0:16} {1}".format('Does not exist', lfile))
return True
elif self.protocol == DownloadProtocolEnum.NoOp:
print('Downloading :' + rfile['path'])
print(' to :' + lfile)
return True
if not self.connect():
return False
if not self._create_dir(os.path.dirname(lfile)):
return False
file_metadata = {'dateTime': '1971-01-01T01:01:01Z', 'size': 0}
try:
if os.path.isfile(lfile + ".Metadata"):
with open(lfile + ".Metadata", "r") as f1:
file_metadata = json.load(f1)
logger.debug(
json.dumps(file_metadata,
sort_keys=True,
indent=4,
separators=(',', ': ')))
except Exception as ex:
logger.debug("Error opening metadata file:" + str(ex))
logger.debug('Downloading ' + rfile['path'] + " metadata")
response = None
if self.protocol == DownloadProtocolEnum.HTTP:
self.conn.request('GET', '/' + rfile['path'])
response = self.conn.getresponse()
rfile_metadata = self._get_file_metadata(rfile['path'], response)
fstatus = self._validate_file_metadata(rfile, file_metadata,
rfile_metadata)
logger.debug("_validate_file_metadata() returned" + str(fstatus))
if fstatus not in [
DownloadedFileStatusEnum.RemoteIsOld,
DownloadedFileStatusEnum.RemoteIsNew,
DownloadedFileStatusEnum.Different
]:
if response: response.close()
return True
logger.debug('Downloading ' + rfile['path'] + " to " + lfile)
print('Downloading ' + rfile['path'])
with open(lfile + ".Metadata", "w") as f1:
f1.write(
json.dumps(rfile_metadata,
sort_keys=True,
indent=4,
separators=(',', ': ')))
if self.protocol == DownloadProtocolEnum.HTTP:
with open(lfile, 'wb') as f:
f.write(response.read())
elif self.protocol == DownloadProtocolEnum.FTP:
f = open(lfile, 'wb')
self.conn.retrbinary('RETR ' + rfile['path'], f.write)
f.close()
fstatus = self._validate_file(rfile, lfile)
logger.debug("_validate_file() returned" + str(fstatus))
return (fstatus in [
DownloadedFileStatusEnum.Same, DownloadedFileStatusEnum.Present
])
except Exception as ex:
print(str(ex))
logger.debug("File Download failed:" + str(ex))
return False
def job_wait(self,
jobid,
track_jobid=True,
show_progress=False,
wait_for=2 * 60 * 60): # wait for a 2 hours (longgg time)
"""Wait for the job to finish(fail/success)
:param jobid: id of the job.
:param path: str. .
:returns: returns a json/dict containing job details
"""
logger.info(self.entity.ipaddr +
" : Waiting for the job to finish : " + jobid)
if track_jobid:
self.last_job = jobid
ret_json = {}
job_ret = False
wait_till = time.time() + wait_for
while True:
status = {}
if self.entity.use_redfish:
status = self.get_job_status_redfish(jobid)
else:
status = self.get_job_status(jobid)
if not 'Status' in status:
logger.debug(self.entity.ipaddr + " : " + jobid +
" : Invalid Status")
else:
logger.debug(self.entity.ipaddr + " : " + jobid +
": status: " + str(status))
pcc = "0"
msg = ""
if 'PercentComplete' in status:
pcc = status['PercentComplete']
if 'Message' in status:
msg = status['Message']
if show_progress:
logger.debug(
self.entity.ipaddr +
"{0} : {1} : Percent Complete: {2} | Message = {3}".
format(jobid, status['Status'], pcc, msg))
if status['Status'] == TypeHelper.resolve(
JobStatusEnum.Success):
if show_progress:
logger.debug(self.entity.ipaddr + " : " + jobid +
":Message:" + status['Message'])
job_ret = True
ret_json = status
break
elif status['Status'] != TypeHelper.resolve(
JobStatusEnum.InProgress):
if show_progress:
logger.debug(self.entity.ipaddr + " : " + jobid +
":Message:" + status['Message'])
job_ret = False
ret_json = status
break
else:
logger.debug(self.entity.ipaddr + " : " + jobid +
": status: " + str(status))
time.sleep(5)
if time.time() > wait_till:
ret_json['Status'] = 'Failed'
ret_json[
'Message'] = 'Job wait did not return for {0} seconds'.format(
wait_for)
break
ret_json['retval'] = job_ret
return ret_json
