def get_remote_schema(self, uri):
"""Attempt to retrieve schema by URI (or find it in our cache)"""
if '#' in uri:
uri, path = uri.split('#')
schema_data = self.remote_schemas.get(uri)
if schema_data:
return schema_data
# Do we have a mapping for this remote URI to a local path?
if '://' in uri:
protocol, uri_part = uri.split('://')
else:
uri_part = uri
for partial_uri in self.uri_to_local.keys():
if uri_part.startswith(partial_uri):
local_uri = self.uri_to_local[partial_uri] + uri_part[len(partial_uri):]
schema_data = DocGenUtilities.load_as_json(local_uri)
# This will fall through to getting the schema remotely if this fails. Correct?
if schema_data:
return schema_data
schema_data = DocGenUtilities.http_load_as_json(uri)
if schema_data:
schema_data['_schema_name'] = self.find_schema_name(uri, schema_data)
self.remote_schemas[uri] = schema_data
return schema_data
return None
def merge_required_profile(self, profile_resources, req_profile_name,
req_profile_info):
""" Merge a required profile into profile_resources (a dict). May result in recursive calls. """
req_profile_repo = req_profile_info.get(
'Repository', 'http://redfish.dmtf.org/profiles')
req_profile_minversion = req_profile_info.get('MinVersion', '1.0.0')
version_string = req_profile_minversion.replace('.', '_')
req_profile_data = None
# Retrieve profile.
# req_profile_repo will be a fully-qualified URI. It may be overridden by
# uri-to-local mapping.
base_uri = '/'.join([req_profile_repo, req_profile_name])
if '://' in base_uri: # This is expected.
protocol, base_uri = base_uri.split('://')
is_local_file = False
for partial_uri in self.config['profile_uri_to_local'].keys():
if base_uri.startswith(partial_uri):
local_path = self.config['profile_uri_to_local'][partial_uri]
if partial_uri.endswith(req_profile_name):
req_profile_repo = local_path[0:-len(req_profile_name)]
pass
else:
req_profile_repo = local_path
is_local_file = True
break
req_profile_uri = self.get_versioned_uri(req_profile_name,
req_profile_repo,
version_string, is_local_file)
if not req_profile_uri:
warnings.warn("Unable to find Profile for " + req_profile_repo +
", " + req_profile_name + ", minimum version: " +
req_profile_minversion)
return profile_resources
if is_local_file:
req_profile_data = DocGenUtilities.load_as_json(req_profile_uri)
else:
req_profile_data = DocGenUtilities.http_load_as_json(
req_profile_uri)
if req_profile_data:
if 'RequiredProfiles' in req_profile_data:
for req_profile_name in req_profile_data[
'RequiredProfiles'].keys():
profile_resources = self.merge_required_profile(
profile_resources, req_profile_name,
req_profile_data['RequiredProfiles'][req_profile_name])
profile_resources = self.merge_dicts(
profile_resources, req_profile_data.get('Resources', {}))
return profile_resources
def process_registry(self, reg_name, registry_profile):
""" Given registry requirements from a profile, retrieve the registry data and produce
a summary based on the profile's requirements.
"""
registry_reqs = {'name': reg_name}
# Retrieve registry
reg_repo = registry_profile.get('Repository')
reg_minversion = registry_profile.get('MinVersion', '1.0.0')
registry_reqs['minversion'] = reg_minversion
registry_reqs['profile_requirement'] = registry_profile.get(
'ReadRequirement', 'Mandatory')
reg_uri = self.get_versioned_uri(reg_name, reg_repo, reg_minversion)
if not reg_uri:
warnings.warn("Unable to find registry file for " + reg_repo +
", " + reg_name + ", minimum version " +
reg_minversion)
return registry_reqs
# Generate data based on profile
registry_data = DocGenUtilities.http_load_as_json(reg_uri)
if registry_data:
registry_reqs['current_release'] = registry_data['RegistryVersion']
registry_reqs.update(registry_data)
for msg in registry_profile['Messages']:
if msg in registry_reqs['Messages']:
registry_reqs['Messages'][msg][
'profile_requirement'] = registry_profile['Messages'][
msg].get('ReadRequirement', 'Mandatory')
else:
warnings.warn(
"Profile specifies requirement for nonexistent Registry Message: "
+ reg_name + " " + msg)
return registry_reqs
