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))