def handle_error(self, error):
if issubclass(error.__class__, exception.ValenceError):
LOG.debug(traceback.format_exc())
return utils.make_response(error.status, error.as_dict())
elif hasattr(error, 'status'):
LOG.debug(traceback.format_exc())
return utils.make_response(error.code,
exception.httpexception(error))
else:
# Valence will not throw general exception in normal case, so use
# LOG.error() to record it.
LOG.error(traceback.format_exc())
exc = exception.generalexception(error,
http_client.INTERNAL_SERVER_ERROR)
return utils.make_response(http_client.INTERNAL_SERVER_ERROR, exc)
def post(self):
podm_id = None
if request.data:
podm_id = request.get_json().get('podm_id', None)
return utils.make_response(
http_client.OK,
pooled_devices.PooledDevices.synchronize_devices(podm_id))
def post(self):
# TODO(): podm_id should be passed in request body, if not passed
# scheduler will decide on podm_id
req = request.get_json()
return utils.make_response(
http_client.OK,
nodes.Node(podm_id=req['podm_id']).compose_node(req))
def get(self):
req = request.get_json()
filters = request.args.to_dict()
return utils.make_response(
http_client.OK,
racks.Rack(req['podm_id']).list_racks(req, filters))
def test_make_response_with_headers(self):
expect = {"key": "value"}
resp = utils.make_response(http_client.OK, expect,
headers={"header": "header_value"})
result = json.loads(resp.data.decode())
self.assertEqual(expect, result)
self.assertEqual(http_client.OK, resp.status_code)
self.assertEqual("header_value", resp.headers.get("header"))
def post(self):
req = request.get_json()
return utils.make_response(
http_client.OK,
nodes.Node(podm_id=req['podm_id']).manage_node(req))
def post(self, node_uuid):
return utils.make_response(
http_client.NO_CONTENT,
nodes.Node(node_id=node_uuid).node_action(request.get_json()))
def get(self, device_id):
return utils.make_response(
http_client.OK, pooled_devices.PooledDevices.get_device(device_id))
def get(self, systemid):
req = request.get_json()
return utils.make_response(
http_client.OK,
systems.System(req['podm_id']).get_system_by_id(systemid))
def delete(self, podm_uuid):
podmanagers.delete_podmanager(podm_uuid)
resp_dict = exception.confirmation(confirm_detail="DELETED")
return utils.make_response(http_client.OK, resp_dict)
def get(self, podm_uuid):
return utils.make_response(http_client.OK,
podmanagers.get_podm_by_uuid(podm_uuid))
def get(self):
return utils.make_response(http_client.OK, podmanagers.get_podm_list())
def delete(self, flavorid):
return utils.make_response(http_client.OK,
flavors.delete_flavor(flavorid))
def get(self, flavorid):
return utils.make_response(http_client.OK,
flavors.get_flavor(flavorid))
def post(self):
return utils.make_response(http_client.OK,
flavors.create_flavor(request.get_json()))
def get(self):
return utils.make_response(http_client.OK, flavors.list_flavors())
def get(self, rack_id):
req = request.get_json()
return utils.make_response(
http_client.OK,
racks.Rack(req['podm_id']).show_rack(rack_id))
def post(self, node_uuid):
return utils.make_response(
http_client.OK,
nodes.Node.node_register(node_uuid, request.get_json()))
def get(self):
obj = RootBase.convert()
return utils.make_response(http_client.OK, obj.as_dict())
def patch(self, flavorid):
return utils.make_response(
http_client.OK, flavors.update_flavor(flavorid,
request.get_json()))
def post(self):
values = flask.request.get_json()
return utils.make_response(http_client.OK,
podmanagers.create_podmanager(values))
def get(self):
filter_args = request.args
return utils.make_response(
http_client.OK,
nodes.Node.list_composed_nodes(filter_args.to_dict()))
def patch(self, podm_uuid):
values = flask.request.get_json()
return utils.make_response(
http_client.OK, podmanagers.update_podmanager(podm_uuid, values))
def test_make_response(self):
expect = {"key": "value"}
resp = utils.make_response(http_client.OK, expect)
result = json.loads(resp.data.decode())
self.assertEqual(expect, result)
self.assertEqual(http_client.OK, resp.status_code)
def get(self, node_uuid):
return utils.make_response(
http_client.OK,
nodes.Node(node_id=node_uuid).get_composed_node_by_uuid())
def get(self):
req = request.get_json()
filters = request.args.to_dict()
return utils.make_response(
http_client.OK,
systems.System(req['podm_id']).list_systems(filters))
def test_make_response_with_wrong_status_code(self):
with self.assertRaises(ValueError):
utils.make_response(status_code="wrong_code")
def delete(self, node_uuid):
return utils.make_response(
http_client.OK,
nodes.Node(node_id=node_uuid).delete_composed_node())
def test_make_response_with_wrong_headers(self):
with self.assertRaises(ValueError):
utils.make_response(http_client.OK,
headers=("header", "header_value"))
def get(self):
filters = request.args.to_dict()
return utils.make_response(
http_client.OK, pooled_devices.PooledDevices.list_devices(filters))
