def get_flavor(flavor_id):
manager = FlavorSynchronizer()
flavor = manager.get_flavor(flavor_id)
response_body = flavor.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def get_regions():
manager = FlavorSynchronizer()
region_collection = manager.get_nodes()
response_body = region_collection.serialize(request.accept_mimetypes)
#response_body = ""
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def get_region_flavors(region_name):
manager = FlavorSynchronizer()
if not manager.is_node_included(region_name):
return _create_not_found_region_response(region_name)
flavor_collection = manager.get_region_flavors(region_name)
response_body = flavor_collection.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def get_flavors():
promoted = request.args.get('promoted', False, type=bool)
public = request.args.get('public', False, type=bool)
manager = FlavorSynchronizer()
flavor_collection = manager.get_flavors(public, promoted)
response_body = flavor_collection.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def get_promotedflavor(flavor_id):
manager = FlavorSynchronizer()
flavor = manager.get_public_flavor(flavor_id)
if flavor is None:
return Response('Not Found Flavor', status=404)
if not flavor.promoted:
return Response('The requested resource is not promoted', status=404)
response_body = flavor.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def get_promotedflavors():
promoted = True
public = True
manager = FlavorSynchronizer()
#we get only the promoted flavors, not the privates
flavor_collection = manager.get_flavors(public, promoted)
response_body = flavor_collection.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def get_region_flavor(region_name, flavor_id):
manager = FlavorSynchronizer()
if not manager.is_node_included(region_name):
return _create_not_found_region_response(region_name)
flavor = manager.get_region_flavor(region_name, flavor_id)
if flavor is None:
return Response('Not Found Flavor for this region', status=404)
response_body = flavor.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def delete_promotedflavor(flavor_id):
#Only the users with the appropiate roles could manage the promoted flavors.
authorization()
manager = FlavorSynchronizer()
flavor = manager.get_public_flavor(flavor_id)
if flavor is None:
return Response('Not Found Flavor', status=404)
#validate if the flavor is promoted
if flavor.promoted and not flavor.nodes:
manager.delete_promoted_flavor(flavor_id)
return Response(status=204)
else:
#error
return Response("The method specified in the Request-Line is not allowed, since the flavor is not promoted or there are nodes associated to the flavor", status=405)
def create_flavor():
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_request_validator()
validator.validate(body)
flavor = Flavor.deserialize(content_type, body)
manager = FlavorSynchronizer()
created_flavor = manager.create_flavor(flavor)
response_body = created_flavor.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def register_infrastructure():
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_infrastructure_request_validator()
validator.validate(body)
infrastructure = Infrastructure.deserialize(content_type, body)
manager = FlavorSynchronizer()
manager.register_infrastructure(infrastructure)
response_body = infrastructure.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def publish_or_promote_flavor(flavor_id):
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_modification_request_validator()
validator.validate(body)
modified_flavor = Flavor.deserialize(content_type, request.data)
manager = FlavorSynchronizer()
if not modified_flavor.nodes:
modified_flavor = manager.publish_or_promote_flavor(flavor_id, modified_flavor)
else:
modified_flavor = manager.add_node_to_flavor(flavor_id, modified_flavor)
response_body = modified_flavor.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def modify_promotedflavor(flavor_id):
#TODO To be decided how to update promoted flavors.
#Only the users with the appropiate roles could manage the promoted flavors.
authorization()
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_modification_request_validator()
validator.validate(body)
modified_flavor = Flavor.deserialize(content_type, request.data)
manager = FlavorSynchronizer()
if not modified_flavor.nodes:
modified_flavor = manager.publish_or_promote_flavor(flavor_id, modified_flavor)
else:
return Response("The method specified in the Request-Line is not allowed for the node list of infrastructures.", status=405)
response_body = modified_flavor.serialize(request.accept_mimetypes)
return Response(response_body, mimetype=request.accept_mimetypes[0][0])
def create_region_flavor(region_name):
if not manager.is_node_included(region_name):
return _create_not_found_region_response(region_name)
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_request_validator()
validator.validate(body)
flavor = Flavor.deserialize(content_type, body)
flavor.promoted = False
flavor.public = False
manager = FlavorSynchronizer()
created_flavor = manager.create_region_flavor(region_name, flavor)
response_body = created_flavor.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def create_promotedflavor():
#Only the users with the appropiate roles could manage the promoted flavors.
authorization()
#if the user has the correct roles, they can manage the promoted flavors
body = util.remove_non_usable_characters(
util.remove_xml_header(request.data.decode("utf-8")))
content_type = request.content_type
validator_factory = factory_selector.get_factory(content_type)
validator = validator_factory.create_flavor_request_validator()
validator.validate(body)
flavor = Flavor.deserialize(content_type, body)
flavor.promoted = True
flavor.public = True
manager = FlavorSynchronizer()
created_flavor = manager.create_promoted_flavor(flavor)
print ("request.accept_mimetypes")
print (request.accept_mimetypes)
response_body = created_flavor.serialize(request.accept_mimetypes)
return Response(response_body, status=201, mimetype=request.accept_mimetypes[0][0])
def delete_flavor(flavor_id):
manager = FlavorSynchronizer()
manager.delete_flavor(flavor_id)
return Response(status=204)
def delete_region_flavor(region_name, flavor_id):
if not manager.is_node_included(region_name):
return _create_not_found_region_response(region_name)
manager = FlavorSynchronizer()
manager.delete_region_flavor(region_name, flavor_id)
return Response(status=204)
def unregister_infrastructure(name):
manager = FlavorSynchronizer()
manager.unregister_infrastructure(name)
return Response(status=204)
