def _get_oneview_resource(uuid):
drives_param = "/rest/drives/" + uuid
cached_categ = category_resource.get_category_by_resource_id(uuid) or \
category_resource.get_category_by_resource_id(drives_param)
if cached_categ:
resource_uuid = uuid
if cached_categ.resource == 'index_resources':
resource_uuid = drives_param
resource = getattr(g.oneview_client, cached_categ.resource)
function = getattr(resource, cached_categ.function)
result = function(resource_uuid)
if isinstance(result, dict):
return result
else:
return result.data
categories = [{
"func": g.oneview_client.server_hardware.get_by_id,
"param": uuid
}, {
"func": g.oneview_client.server_profile_templates.get_by_id,
"param": uuid
}, {
"func": g.oneview_client.index_resources.get,
"param": drives_param
}, {
"func": g.oneview_client.volumes.get_by_id,
"param": uuid
}]
for category in categories:
try:
resource = category["func"](category["param"])
if isinstance(resource, dict):
return resource
return resource.data
except HPOneViewException as e:
if e.oneview_response["errorCode"] == 'RESOURCE_NOT_FOUND':
pass
else:
raise # Raise any unexpected errors
abort(status.HTTP_404_NOT_FOUND,
"Could not find resource block with id " + uuid)
def _get_oneview_resource(uuid):
"""Gets a Server hardware or Server profile templates"""
cached_category = category_resource.get_category_by_resource_id(uuid)
if cached_category:
resource = getattr(g.oneview_client, cached_category.resource)
function = getattr(resource, cached_category.function)
return function(uuid)
categories = [
{"func": g.oneview_client.server_profiles.get, "param": uuid},
{"func": g.oneview_client.server_profile_templates.get, "param": uuid}
]
for category in categories:
try:
resource = category["func"](category["param"])
return resource
except HPOneViewException as e:
if e.oneview_response["errorCode"] in \
['RESOURCE_NOT_FOUND', 'ProfileNotFoundException']:
pass
else:
raise # Raise any unexpected errors
abort(status.HTTP_404_NOT_FOUND,
"Could not find computer system with id " + uuid)
def get_thermal(uuid):
"""Get the Redfish Thermal for a given UUID.
Return Thermal Redfish JSON for a given hardware UUID.
Logs exception of any error and return abort(500)
Internal Server Error.
Returns:
JSON: Redfish json with Thermal
When hardware is not found calls abort(404)
Exceptions:
Logs the exception and call abort(500)
"""
try:
category = ''
cached_category = category_resource.get_category_by_resource_id(uuid)
if cached_category:
category = cached_category.resource.replace('_', '-')
else:
index_obj = g.oneview_client.index_resources.get_all(
filter='uuid=' + uuid)
if index_obj:
category = index_obj[0]["category"]
else:
abort(status.HTTP_404_NOT_FOUND, 'Cannot find Index resource')
if category == 'server-hardware':
server_hardware = g.oneview_client.server_hardware. \
get_utilization(uuid, fields='AmbientTemperature')
thrml = Thermal(server_hardware, uuid, 'Blade')
elif category == 'enclosures':
enclosure = g.oneview_client.enclosures. \
get_utilization(uuid, fields='AmbientTemperature')
thrml = Thermal(enclosure, uuid, 'Enclosure')
elif category == 'racks':
rack = g.oneview_client.racks.\
get_device_topology(uuid)
thrml = Thermal(rack, uuid, 'Rack')
else:
abort(status.HTTP_404_NOT_FOUND, 'OneView resource not found')
json_str = thrml.serialize()
return Response(response=json_str,
status=status.HTTP_200_OK,
mimetype="application/json")
except HPOneViewException as e:
# In case of error print exception and abort
logging.exception(e)
if e.oneview_response['errorCode'] == "RESOURCE_NOT_FOUND":
abort(status.HTTP_404_NOT_FOUND, "Resource not found")
else:
abort(status.HTTP_500_INTERNAL_SERVER_ERROR)
def test_get_blade_thermal_cached(self):
""""Tests BladeThermal with a known SH"""
# Loading ServerHardwareUtilization mockup value
with open(
'oneview_redfish_toolkit/mockups/oneview/'
'ServerHardwareUtilization.json'
) as f:
server_hardware_utilization = json.load(f)
# Loading BladeChassisThermal mockup result
with open(
'oneview_redfish_toolkit/mockups/redfish/'
'BladeChassisThermal.json'
) as f:
blade_chassis_thermal_mockup = json.load(f)
self.oneview_client.index_resources.get_all.return_value = \
[{"category": "server-hardware"}]
self.oneview_client.server_hardware.get_utilization.return_value = \
server_hardware_utilization
uri = "/redfish/v1/Chassis/36343537-3338-4448-3538-4E5030333434/"\
"Thermal"
uuid = "36343537-3338-4448-3538-4E5030333434"
# Get BladeThermal
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(blade_chassis_thermal_mockup, result)
# Get cached BladeThermal
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(blade_chassis_thermal_mockup, result)
# Check for cached calls
self.oneview_client.index_resources.get_all.assert_called_once_with(
filter='uuid=' + uuid
)
assert self.oneview_client.server_hardware.get.has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
def test_get_encl_thermal_cached(self):
""""Tests EnclosureThermal with a known Enclosure"""
# Loading EnclosureUtilization mockup value
with open(
'oneview_redfish_toolkit/mockups/oneview/'
'EnclosureUtilization.json'
) as f:
enclosure_utilization = json.load(f)
# Loading EnclosureChassisThermal mockup result
with open(
'oneview_redfish_toolkit/mockups/redfish/'
'EnclosureChassisThermal.json'
) as f:
enclosure_chasssis_thermal_mockup = json.load(f)
self.oneview_client.index_resources.get_all.return_value = \
[{"category": "enclosures"}]
self.oneview_client.enclosures.get_utilization.return_value = \
enclosure_utilization
uri = "/redfish/v1/Chassis/0000000000A66101/Thermal"
uuid = "0000000000A66101"
# Get EnclosureThermal
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(enclosure_chasssis_thermal_mockup, result)
# Get cached EnclosureThermal
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(enclosure_chasssis_thermal_mockup, result)
# Check for cached calls
self.oneview_client.index_resources.get_all.assert_called_once_with(
filter='uuid=' + uuid
)
assert self.oneview_client.enclosures.get.has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
def test_get_rack_thermal_cached(self):
""""Tests RackThermal with a known Rack"""
# Loading RackDeviceTopology mockup value
with open(
'oneview_redfish_toolkit/mockups/oneview/'
'RackDeviceTopology.json'
) as f:
rack_topology = json.load(f)
# Loading RackChassisThermal mockup result
with open(
'oneview_redfish_toolkit/mockups/redfish/RackChassisThermal.json'
) as f:
rack_chassis_thermal_mockup = json.load(f)
self.oneview_client.index_resources.get_all.return_value = \
[{"category": "racks"}]
self.oneview_client.\
racks.get_device_topology.return_value = rack_topology
uri = "/redfish/v1/Chassis/2AB100LMNB/Thermal"
uuid = '2AB100LMNB'
# Get RackThermal
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(rack_chassis_thermal_mockup, result)
# Get cached RackThermal
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(rack_chassis_thermal_mockup, result)
# Check for cached calls
self.oneview_client.index_resources.get_all.assert_called_once_with(
filter='uuid=' + uuid
)
assert self.oneview_client.rackes.get.has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
def test_get_storage_resource_block_cached(self):
with open(
'oneview_redfish_toolkit/mockups/redfish/StorageResourceBlock.json'
) as f:
expected_resource_block = json.load(f)
self.oneview_client.server_hardware.get_by_id.side_effect = \
self.resource_not_found
self.oneview_client.server_profile_templates.get_by_id.side_effect = \
self.resource_not_found
self.oneview_client.index_resources.get.return_value = self.drive
self.oneview_client.connection.get.side_effect = [
self.drive_index_tree,
self.drive_index_tree,
]
self.oneview_client.server_profile_templates.get_all.return_value = \
self.server_profile_templates
self.oneview_client. \
logical_enclosures.get_all.return_value = self.log_encl_list
self.oneview_client.drive_enclosures.get_all.return_value = \
self.drive_enclosure_list
uri = "/redfish/v1/CompositionService/ResourceBlocks/" \
"c4f0392d-fae9-4c2e-a2e6-b22e6bb7533e"
uuid = uri.split('/')[-1]
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(expected_resource_block, result)
# Get cached storage resource block
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(expected_resource_block, result)
self.oneview_client.server_profile_templates.get_all.has_calls(
[call(uri), call(uri)])
self.oneview_client.server_hardware.get_by_id.assert_called_once_with(
uuid)
self.oneview_client.index_resources.get.assert_has_calls(
[call('/rest/drives/' + uuid),
call('/rest/drives/' + uuid)])
self.assertTrue(
category_resource.get_category_by_resource_id(
('/rest/drives/' + uuid)))
def test_get_computer_system_spt_cached(self):
"""Tests ComputerSystem with a known Server Profile Templates"""
with open(
'oneview_redfish_toolkit/mockups/oneview/'
'ServerProfileTemplate.json'
) as f:
server_profile_template = json.load(f)
with open(
'oneview_redfish_toolkit/mockups/redfish/CapabilitiesObject.json'
) as f:
capabilities_obj_mockup = json.load(f)
# Create mock response
self.oneview_client.\
server_profiles.get_by_id.side_effect = self.not_found_error
self.oneview_client.server_profile_templates.get_by_id.return_value = \
server_profile_template
uri = "/redfish/v1/Systems/1f0ca9ef-7f81-45e3-9d64-341b46cf87e0"
uuid = uri.split('/')[-1]
# Get ComputerSystem
response = self.client.get(uri)
# Gets json from response
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(capabilities_obj_mockup, result)
# Get cached ComputerSystem
response = self.client.get(uri)
# Gets json from response
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(capabilities_obj_mockup, result)
self.oneview_client.server_profiles.get_by_id \
.assert_called_once_with(uuid)
self.oneview_client.server_profile_templates.get_by_id \
.assert_has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
def test_get_blade_chassis_with_computer_system_cached(self,
get_map_appliances,
get_map_resources):
""""Tests BladeChassis with a known Server Hardware"""
serverhw_obj = ServerHardware(self.oneview_client, self.server_hardware)
get_map_resources.return_value = OrderedDict({
"30303437-3034-4D32-3230-313133364752": "10.0.0.1",
})
get_map_appliances.return_value = self.map_appliance
self.oneview_client.index_resources.get_all.return_value = \
[{"category": "server-hardware"}]
self.oneview_client.server_hardware.get_by_id.return_value = \
serverhw_obj
self.oneview_client.appliance_node_information.get_version.return_value = \
self.appliance_info
uri = "/redfish/v1/Chassis/30303437-3034-4D32-3230-313133364752"
uuid = uri.split('/')[-1]
# Get BladeChassis
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
# Get cached BladeChassis
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(self.blade_chassis_mockup, result)
self.assertEqual(
"{}{}".format("W/", self.server_hardware["eTag"]),
response.headers["ETag"])
# Check for cached calls
self.oneview_client.index_resources.get_all.assert_called_once_with(
filter='uuid=' + uuid
)
assert self.oneview_client.server_hardware.get.has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
def test_get_enclosure_chassis_cached(self, get_map_appliances,
get_map_resources, get_env):
""""Tests EnclosureChassis with a known Enclosure"""
enclosure_obj = Enclosures(self.oneview_client, self.enclosure)
get_env.return_value = self.enclosure_environment_configuration_mockup
get_map_resources.return_value = OrderedDict({
"0000000000A66101": "10.0.0.1",
})
get_map_appliances.return_value = self.map_appliance
self.oneview_client.index_resources.get_all.return_value = \
[{"category": "enclosures"}]
self.oneview_client.enclosures.get_by_id.return_value = enclosure_obj
Enclosures.get_environmental_configuration. \
return_value = get_env.return_value
self.oneview_client.appliance_node_information.get_version.return_value = \
self.appliance_info
uri = "/redfish/v1/Chassis/0000000000A66101"
uuid = uri.split('/')[-1]
# Get EnclosureChassis
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
# Get cached EnclosureChassis
response = self.client.get(uri)
# Tests cached response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(self.enclosure_chassis_mockup, result)
self.assertEqual(
"{}{}".format("W/", self.enclosure["eTag"]),
response.headers["ETag"])
# Check for cached calls
self.oneview_client.index_resources.get_all.assert_called_once_with(
filter='uuid=' + uuid
)
assert self.oneview_client.enclosures.get.has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
def get_chassis(uuid):
"""Get the Redfish Chassis.
Get method to return Chassis JSON when
/redfish/v1/Chassis/id is requested.
Returns:
JSON: JSON with Chassis.
"""
category = ''
cached_category = category_resource.get_category_by_resource_id(uuid)
if cached_category:
category = cached_category.resource.replace('_', '-')
else:
resource_index = g.oneview_client.index_resources.get_all(
filter='uuid=' + uuid
)
if not resource_index:
abort(status.HTTP_404_NOT_FOUND,
"Chassis {} not found".format(uuid))
category = resource_index[0]["category"]
manager_uuid = get_manager_uuid(uuid)
if category == 'server-hardware':
server_hardware = g.oneview_client.server_hardware.get(uuid)
etag = server_hardware['eTag']
ch = BladeChassis(server_hardware, manager_uuid)
elif category == 'enclosures':
enclosure = g.oneview_client.enclosures.get(uuid)
etag = enclosure['eTag']
enclosure_environment_config = g.oneview_client.enclosures. \
get_environmental_configuration(uuid)
ch = EnclosureChassis(
enclosure,
enclosure_environment_config,
manager_uuid
)
elif category == 'racks':
racks = g.oneview_client.racks.get(uuid)
etag = racks['eTag']
ch = RackChassis(racks)
return ResponseBuilder.success(ch, {"ETag": "W/" + etag})
def test_get_rack_chassis_cached(self, get_map_appliances,
get_map_resources):
""""Tests RackChassis with a known Rack"""
get_map_resources.return_value = OrderedDict({
"2AB100LMNB": "10.0.0.1",
})
get_map_appliances.return_value = self.map_appliance
self.oneview_client.index_resources.get_all.return_value = \
[{"category": "racks"}]
self.oneview_client.racks.get.return_value = self.rack
uri = "/redfish/v1/Chassis/2AB100LMNB"
uuid = uri.split('/')[-1]
# Get RackChassis
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
# Get cached RackChassis
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
# Tests response
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(self.rack_chassis_mockup, result)
self.assertEqual(
"{}{}".format("W/", self.rack["eTag"]),
response.headers["ETag"])
# Check for cached calls
self.oneview_client.index_resources.get_all.assert_called_once_with(
filter='uuid=' + uuid
)
assert self.oneview_client.racks.get.has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
def test_get_spt_resource_block_cached(self):
with open(
'oneview_redfish_toolkit/mockups/redfish'
'/ServerProfileTemplateResourceBlock.json'
) as f:
expected_resource_block = json.load(f)
self.oneview_client.server_hardware.get.side_effect = \
self.resource_not_found
self.oneview_client.server_profile_templates.get.return_value = \
self.server_profile_template
self.oneview_client.logical_enclosures.get_all.return_value = \
self.log_encl_list
self.oneview_client.drive_enclosures.get_all.return_value = \
self.drive_enclosure_list
uri = "/redfish/v1/CompositionService/ResourceBlocks"\
"/1f0ca9ef-7f81-45e3-9d64-341b46cf87e0"
uuid = uri.split('/')[-1]
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(expected_resource_block, result)
# Get cached spt resource block
response = self.client.get(uri)
result = json.loads(response.data.decode("utf-8"))
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual("application/json", response.mimetype)
self.assertEqualMockup(expected_resource_block, result)
self.oneview_client.server_hardware.get.assert_called_once_with(uuid)
self.oneview_client.server_profile_templates.get.assert_has_calls(
[call(uuid),
call(uuid)]
)
self.assertTrue(category_resource.get_category_by_resource_id(uuid))
