# Copyright 2011-2012 GRNET S.A. All rights reserved. # # Redistribution and use in source and binary forms, with or # without modification, are permitted provided that the following # conditions are met: # # 1. Redistributions of source code must retain the above # copyright notice, this list of conditions and the following # disclaimer. # # 2. Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following # disclaimer in the documentation and/or other materials # provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # # The views and conclusions contained in the software and # documentation are those of the authors and should not be # interpreted as representing official policies, either expressed # or implied, of GRNET S.A. from base64 import b64decode from logging import getLogger from django.conf import settings from django.conf.urls.defaults import patterns from django.http import HttpResponse from django.template.loader import render_to_string from django.utils import simplejson as json from synnefo.api import faults, util from synnefo.api.actions import server_actions from synnefo.api.common import method_not_allowed from synnefo.db.models import Backend, VirtualMachine, VirtualMachineMetadata from synnefo.logic.backend import create_instance, delete_instance from synnefo.logic.utils import get_rsapi_state from synnefo.util.rapi import GanetiApiError from synnefo.logic.backend_allocator import BackendAllocator from django.utils import importlib log = getLogger('synnefo.api') urlpatterns = patterns('synnefo.api.servers', (r'^(?:/|.json|.xml)?$', 'demux'), (r'^/detail(?:.json|.xml)?$', 'list_servers', {'detail': True}), (r'^/(\d+)(?:.json|.xml)?$', 'server_demux'), (r'^/(\d+)/action(?:.json|.xml)?$', 'server_action'), (r'^/(\d+)/ips(?:.json|.xml)?$', 'list_addresses'), (r'^/(\d+)/ips/(.+?)(?:.json|.xml)?$', 'list_addresses_by_network'), (r'^/(\d+)/meta(?:.json|.xml)?$', 'metadata_demux'), (r'^/(\d+)/meta/(.+?)(?:.json|.xml)?$', 'metadata_item_demux'), (r'^/(\d+)/stats(?:.json|.xml)?$', 'server_stats'), ) def demux(request): if request.method == 'GET': return list_servers(request) elif request.method == 'POST': return create_server(request) else: return method_not_allowed(request) def server_demux(request, server_id): if request.method == 'GET': return get_server_details(request, server_id) elif request.method == 'PUT': return update_server_name(request, server_id) elif request.method == 'DELETE': return delete_server(request, server_id) else: return method_not_allowed(request) def metadata_demux(request, server_id): if request.method == 'GET': return list_metadata(request, server_id) elif request.method == 'POST': return update_metadata(request, server_id) else: return method_not_allowed(request) def metadata_item_demux(request, server_id, key): if request.method == 'GET': return get_metadata_item(request, server_id, key) elif request.method == 'PUT': return create_metadata_item(request, server_id, key) elif request.method == 'DELETE': return delete_metadata_item(request, server_id, key) else: return method_not_allowed(request) def nic_to_dict(nic): network = nic.network network_id = str(network.id) if not network.public else 'public' ipv4 = nic.ipv4 if nic.ipv4 else None ipv6 = nic.ipv6 if nic.ipv6 else None d = {'id': util.construct_nic_id(nic), 'network_id': network_id, 'mac_address': nic.mac, 'ipv4': ipv4, 'ipv6': ipv6} if nic.firewall_profile: d['firewallProfile'] = nic.firewall_profile return d def vm_to_dict(vm, detail=False): d = dict(id=vm.id, name=vm.name) if detail: d['status'] = get_rsapi_state(vm) d['progress'] = 100 if get_rsapi_state(vm) == 'ACTIVE' \ else vm.buildpercentage d['hostId'] = vm.hostid d['updated'] = util.isoformat(vm.updated) d['created'] = util.isoformat(vm.created) d['flavorRef'] = vm.flavor.id d['imageRef'] = vm.imageid metadata = dict((m.meta_key, m.meta_value) for m in vm.metadata.all()) if metadata: d['metadata'] = {'values': metadata} attachments = [nic_to_dict(nic) for nic in vm.nics.all()] if attachments: d['attachments'] = {'values': attachments} return d def render_server(request, server, status=200): if request.serialization == 'xml': data = render_to_string('server.xml', { 'server': server, 'is_root': True}) else: data = json.dumps({'server': server}) return HttpResponse(data, status=status) @util.api_method('GET') def list_servers(request, detail=False): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # overLimit (413) log.debug('list_servers detail=%s', detail) user_vms = VirtualMachine.objects.filter(userid=request.user_uniq) since = util.isoparse(request.GET.get('changes-since')) if since: user_vms = user_vms.filter(updated__gte=since) if not user_vms: return HttpResponse(status=304) else: user_vms = user_vms.filter(deleted=False) servers = [vm_to_dict(server, detail) for server in user_vms] if request.serialization == 'xml': data = render_to_string('list_servers.xml', { 'servers': servers, 'detail': detail}) else: data = json.dumps({'servers': {'values': servers}}) return HttpResponse(data, status=200) @util.api_method('POST') def create_server(request): # Normal Response Code: 202 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badMediaType(415), # itemNotFound (404), # badRequest (400), # serverCapacityUnavailable (503), # overLimit (413) req = util.get_request_dict(request) log.debug('create_server %s', req) try: server = req['server'] name = server['name'] metadata = server.get('metadata', {}) assert isinstance(metadata, dict) image_id = server['imageRef'] flavor_id = server['flavorRef'] personality = server.get('personality', []) assert isinstance(personality, list) except (KeyError, AssertionError): raise faults.BadRequest("Malformed request") if len(personality) > settings.MAX_PERSONALITY: raise faults.OverLimit("Maximum number of personalities exceeded") for p in personality: # Verify that personalities are well-formed try: assert isinstance(p, dict) keys = set(p.keys()) allowed = set(['contents', 'group', 'mode', 'owner', 'path']) assert keys.issubset(allowed) contents = p['contents'] if len(contents) > settings.MAX_PERSONALITY_SIZE: # No need to decode if contents already exceed limit raise faults.OverLimit("Maximum size of personality exceeded") if len(b64decode(contents)) > settings.MAX_PERSONALITY_SIZE: raise faults.OverLimit("Maximum size of personality exceeded") except AssertionError: raise faults.BadRequest("Malformed personality in request") image = {} img = util.get_image(image_id, request.user_uniq) properties = img.get('properties', {}) image['backend_id'] = img['location'] image['format'] = img['disk_format'] image['metadata'] = dict((key.upper(), val) \ for key, val in properties.items()) flavor = util.get_flavor(flavor_id) password = util.random_password() count = VirtualMachine.objects.filter(userid=request.user_uniq, deleted=False).count() # get user limit vms_limit_for_user = \ settings.VMS_USER_QUOTA.get(request.user_uniq, settings.MAX_VMS_PER_USER) if count >= vms_limit_for_user: raise faults.OverLimit("Server count limit exceeded for your account.") backend_allocator = BackendAllocator() backend = backend_allocator.allocate(flavor) if backend is None: raise Exception # We must save the VM instance now, so that it gets a valid # vm.backend_vm_id. vm = VirtualMachine.objects.create( name=name, backend=backend, userid=request.user_uniq, imageid=image_id, flavor=flavor) try: jobID = create_instance(vm, flavor, image, password, personality) except GanetiApiError: vm.delete() raise vm.backendjobid = jobID vm.save() for key, val in metadata.items(): VirtualMachineMetadata.objects.create( meta_key=key, meta_value=val, vm=vm) log.info('User %s created vm with %s cpus, %s ram and %s storage', request.user_uniq, flavor.cpu, flavor.ram, flavor.disk) server = vm_to_dict(vm, detail=True) server['status'] = 'BUILD' server['adminPass'] = password return render_server(request, server, status=202) @util.api_method('GET') def get_server_details(request, server_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # itemNotFound (404), # overLimit (413) log.debug('get_server_details %s', server_id) vm = util.get_vm(server_id, request.user_uniq) server = vm_to_dict(vm, detail=True) return render_server(request, server) @util.api_method('PUT') def update_server_name(request, server_id): # Normal Response Code: 204 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # badMediaType(415), # itemNotFound (404), # buildInProgress (409), # overLimit (413) req = util.get_request_dict(request) log.debug('update_server_name %s %s', server_id, req) try: name = req['server']['name'] except (TypeError, KeyError): raise faults.BadRequest("Malformed request") vm = util.get_vm(server_id, request.user_uniq) vm.name = name vm.save() return HttpResponse(status=204) @util.api_method('DELETE') def delete_server(request, server_id): # Normal Response Codes: 204 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # itemNotFound (404), # unauthorized (401), # buildInProgress (409), # overLimit (413) log.debug('delete_server %s', server_id) vm = util.get_vm(server_id, request.user_uniq) delete_instance(vm) return HttpResponse(status=204) @util.api_method('POST') def server_action(request, server_id): req = util.get_request_dict(request) log.debug('server_action %s %s', server_id, req) vm = util.get_vm(server_id, request.user_uniq) if len(req) != 1: raise faults.BadRequest("Malformed request") key = req.keys()[0] val = req[key] try: assert isinstance(val, dict) return server_actions[key](request, vm, req[key]) except KeyError: raise faults.BadRequest("Unknown action") except AssertionError: raise faults.BadRequest("Invalid argument") @util.api_method('GET') def list_addresses(request, server_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # overLimit (413) log.debug('list_addresses %s', server_id) vm = util.get_vm(server_id, request.user_uniq) addresses = [nic_to_dict(nic) for nic in vm.nics.all()] if request.serialization == 'xml': data = render_to_string('list_addresses.xml', {'addresses': addresses}) else: data = json.dumps({'addresses': {'values': addresses}}) return HttpResponse(data, status=200) @util.api_method('GET') def list_addresses_by_network(request, server_id, network_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # itemNotFound (404), # overLimit (413) log.debug('list_addresses_by_network %s %s', server_id, network_id) machine = util.get_vm(server_id, request.user_uniq) network = util.get_network(network_id, request.user_uniq) nic = util.get_nic(machine, network) address = nic_to_dict(nic) if request.serialization == 'xml': data = render_to_string('address.xml', {'address': address}) else: data = json.dumps({'network': address}) return HttpResponse(data, status=200) @util.api_method('GET') def list_metadata(request, server_id): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # overLimit (413) log.debug('list_server_metadata %s', server_id) vm = util.get_vm(server_id, request.user_uniq) metadata = dict((m.meta_key, m.meta_value) for m in vm.metadata.all()) return util.render_metadata(request, metadata, use_values=True, status=200) @util.api_method('POST') def update_metadata(request, server_id): # Normal Response Code: 201 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # buildInProgress (409), # badMediaType(415), # overLimit (413) req = util.get_request_dict(request) log.debug('update_server_metadata %s %s', server_id, req) vm = util.get_vm(server_id, request.user_uniq) try: metadata = req['metadata'] assert isinstance(metadata, dict) except (KeyError, AssertionError): raise faults.BadRequest("Malformed request") for key, val in metadata.items(): meta, created = vm.metadata.get_or_create(meta_key=key) meta.meta_value = val meta.save() vm.save() vm_meta = dict((m.meta_key, m.meta_value) for m in vm.metadata.all()) return util.render_metadata(request, vm_meta, status=201) @util.api_method('GET') def get_metadata_item(request, server_id, key): # Normal Response Codes: 200, 203 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # itemNotFound (404), # badRequest (400), # overLimit (413) log.debug('get_server_metadata_item %s %s', server_id, key) vm = util.get_vm(server_id, request.user_uniq) meta = util.get_vm_meta(vm, key) d = {meta.meta_key: meta.meta_value} return util.render_meta(request, d, status=200) @util.api_method('PUT') def create_metadata_item(request, server_id, key): # Normal Response Code: 201 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # itemNotFound (404), # badRequest (400), # buildInProgress (409), # badMediaType(415), # overLimit (413) req = util.get_request_dict(request) log.debug('create_server_metadata_item %s %s %s', server_id, key, req) vm = util.get_vm(server_id, request.user_uniq) try: metadict = req['meta'] assert isinstance(metadict, dict) assert len(metadict) == 1 assert key in metadict except (KeyError, AssertionError): raise faults.BadRequest("Malformed request") meta, created = VirtualMachineMetadata.objects.get_or_create( meta_key=key, vm=vm) meta.meta_value = metadict[key] meta.save() vm.save() d = {meta.meta_key: meta.meta_value} return util.render_meta(request, d, status=201) @util.api_method('DELETE') def delete_metadata_item(request, server_id, key): # Normal Response Code: 204 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # itemNotFound (404), # badRequest (400), # buildInProgress (409), # badMediaType(415), # overLimit (413), log.debug('delete_server_metadata_item %s %s', server_id, key) vm = util.get_vm(server_id, request.user_uniq) meta = util.get_vm_meta(vm, key) meta.delete() vm.save() return HttpResponse(status=204) @util.api_method('GET') def server_stats(request, server_id): # Normal Response Codes: 200 # Error Response Codes: computeFault (400, 500), # serviceUnavailable (503), # unauthorized (401), # badRequest (400), # itemNotFound (404), # overLimit (413) log.debug('server_stats %s', server_id) vm = util.get_vm(server_id, request.user_uniq) #secret = util.encrypt(vm.backend_vm_id) secret = vm.backend_vm_id # XXX disable backend id encryption stats = { 'serverRef': vm.id, 'refresh': settings.STATS_REFRESH_PERIOD, 'cpuBar': settings.CPU_BAR_GRAPH_URL % secret, 'cpuTimeSeries': settings.CPU_TIMESERIES_GRAPH_URL % secret, 'netBar': settings.NET_BAR_GRAPH_URL % secret, 'netTimeSeries': settings.NET_TIMESERIES_GRAPH_URL % secret} if request.serialization == 'xml': data = render_to_string('server_stats.xml', stats) else: data = json.dumps({'stats': stats}) return HttpResponse(data, status=200)