Synnefo

from synnefo.logic import backend

from synnefo.logic.utils import get_rsapi_state

server_actions = {}

network_actions = {}

    raise ServiceUnavailable('Changing password is not supported.')

@server_action('reboot')

def reboot(request, vm, args):

    # Normal Response Code: 202

    #                       buildInProgress (409),

    #                       overLimit (413)

    reboot_type = args.get('type', '')

    if reboot_type not in ('SOFT', 'HARD'):

        raise BadRequest('Malformed Request.')

    backend.reboot_instance(vm, reboot_type.lower())

    return HttpResponse(status=202)

@server_action('start')

def start(request, vm, args):

    # Normal Response Code: 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404)

    if args:

        raise BadRequest('Malformed Request.')

    backend.startup_instance(vm)

    return HttpResponse(status=202)

@server_action('shutdown')

def shutdown(request, vm, args):

    # Normal Response Code: 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404)

    if args:

        raise BadRequest('Malformed Request.')

    backend.shutdown_instance(vm)

    return HttpResponse(status=202)

@server_action('rebuild')

def rebuild(request, vm, args):

    # Normal Response Code: 202

    raise ServiceUnavailable('Rebuild not supported.')

@server_action('resize')

def resize(request, vm, args):

    # Normal Response Code: 202

    raise ServiceUnavailable('Resize not supported.')

@server_action('confirmResize')

def confirm_resize(request, vm, args):

    # Normal Response Code: 204

    raise ServiceUnavailable('Resize not supported.')

@server_action('revertResize')

def revert_resize(request, vm, args):

    # Normal Response Code: 202

    #                       buildInProgress (409),

    #                       overLimit (413)

    console_type = args.get('type', '')

    if console_type != 'vnc':

        raise BadRequest('Type can only be "vnc".')

    #                       overLimit (413)

    profile = args.get('profile', '')

    if profile not in [x[0] for x in NetworkInterface.FIREWALL_PROFILES]:

        raise BadRequest("Unsupported firewall profile")

    backend.set_firewall_profile(vm, profile)

        raise BadRequest('Malformed Request.')

    vm = get_vm(server_id, request.user_uniq)

    net = Network.objects.get(id=net.id)

    if net.state != 'ACTIVE':

    except EmptyPool:

        raise ServiceUnavailable('Network is full')

    backend.connect_to_network(vm, net, address)

    return HttpResponse(status=202)

    vm = get_vm(server_id, request.user_uniq)

    nic = get_nic_from_index(vm, nic_index)

    if nic.dirty:

        raise BuildInProgress('Machine is busy.')

    else:

    #                       badRequest (400),

    #                       overLimit (413)

    backend = ImageBackend(request.user_uniq)

    since = isoparse(request.GET.get('changes-since'))

    #                       itemNotFound (404),

    #                       overLimit (413)

    image = util.get_image(image_id, request.user_uniq)

    reply = image_to_dict(image)

    #                       itemNotFound (404),

    #                       overLimit (413)

    backend = ImageBackend(request.user_uniq)

    backend.delete(image_id)

    backend.close()

    #                       badRequest (400),

    #                       overLimit (413)

    image = util.get_image(image_id, request.user_uniq)

    metadata = image['properties']

    return util.render_metadata(request, metadata, use_values=True, status=200)

    #                       overLimit (413)

    req = util.get_request_dict(request)

    image = util.get_image(image_id, request.user_uniq)

    try:

        metadata = req['metadata']

    #                       badRequest (400),

    #                       overLimit (413)

    image = util.get_image(image_id, request.user_uniq)

    val = image['properties'].get(key)

    if val is None:

    #                       overLimit (413)

    req = util.get_request_dict(request)

    try:

        metadict = req['meta']

        assert isinstance(metadict, dict)

    #                       badMediaType(415),

    #                       overLimit (413),

    image = util.get_image(image_id, request.user_uniq)

    properties = image['properties']

    properties.pop(key, None)

    #                       badRequest (400),

    #                       overLimit (413)

    since = util.isoparse(request.GET.get('changes-since'))

    user_networks = Network.objects.filter(Q(userid=request.user_uniq) |

                                           Q(public=True))

    #                       overLimit (413)

    req = util.get_request_dict(request)

    try:

        d = req['network']

    #                       itemNotFound (404),

    #                       overLimit (413)

    net = util.get_network(network_id, request.user_uniq)

    netdict = network_to_dict(net, request.user_uniq)

    return render_network(request, netdict)

    #                       overLimit (413)

    req = util.get_request_dict(request)

    try:

        name = req['network']['name']

    #                       unauthorized (401),

    #                       overLimit (413)

    net = util.get_network(network_id, request.user_uniq, for_update=True)

    if net.public:

        raise Unauthorized('Can not delete the public network.')

@util.api_method('POST')

def network_action(request, network_id):

    req = util.get_request_dict(request)

    if len(req) != 1:

        raise BadRequest('Malformed request.')

# or implied, of GRNET S.A.

from base64 import b64decode

from django.conf import settings

from django.conf.urls.defaults import patterns

from synnefo.api import faults, util

from synnefo.api.actions import server_actions

from synnefo.api.common import method_not_allowed

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

log = getLogger('synnefo.api')

urlpatterns = patterns('synnefo.api.servers',

    #                       badRequest (400),

    #                       overLimit (413)

    user_vms = VirtualMachine.objects.filter(userid=request.user_uniq)

    since = util.isoparse(request.GET.get('changes-since'))

    #                       serverCapacityUnavailable (503),

    #                       overLimit (413)

    req = util.get_request_dict(request)

    try:

        server = req['server']

        imageid=image_id,

        flavor=flavor)

    try:

        jobID = create_instance(vm, nic, flavor, image, password, personality)

    except GanetiApiError:

    #                       itemNotFound (404),

    #                       overLimit (413)

    vm = util.get_vm(server_id, request.user_uniq)

    server = vm_to_dict(vm, detail=True)

    return render_server(request, server)

    #                       overLimit (413)

    req = util.get_request_dict(request)

    try:

        name = req['server']['name']

    #                       buildInProgress (409),

    #                       overLimit (413)

    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)

    vm = util.get_vm(server_id, request.user_uniq)

    if len(req) != 1:

        raise faults.BadRequest("Malformed request")

    #                       badRequest (400),

    #                       overLimit (413)

    vm = util.get_vm(server_id, request.user_uniq)

    addresses = [nic_to_dict(nic) for nic in vm.nics.all()]

    #                       itemNotFound (404),

    #                       overLimit (413)

    machine = util.get_vm(server_id, request.user_uniq)

    network = util.get_network(network_id, request.user_uniq)

    nic = util.get_nic(machine, network)

    #                       badRequest (400),

    #                       overLimit (413)

    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)

    #                       overLimit (413)

    req = util.get_request_dict(request)

    vm = util.get_vm(server_id, request.user_uniq)

    try:

        metadata = req['metadata']

    #                       badRequest (400),

    #                       overLimit (413)

    vm = util.get_vm(server_id, request.user_uniq)

    meta = util.get_vm_meta(vm, key)

    d = {meta.meta_key: meta.meta_value}

    #                       overLimit (413)

    req = util.get_request_dict(request)

    vm = util.get_vm(server_id, request.user_uniq)

    try:

        metadict = req['meta']

    #                       badMediaType(415),

    #                       overLimit (413),

    vm = util.get_vm(server_id, request.user_uniq)

    meta = util.get_vm_meta(vm, key)

    meta.delete()

    #                       itemNotFound (404),

    #                       overLimit (413)

    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

        ordering = ["clustername"]

    def __unicode__(self):

    @property

    def backend_id(self):

        get_latest_by = 'created'

    def __unicode__(self):

class VirtualMachineMetadata(models.Model):

        return getattr(snf_settings, self.type + '_TAGS')

    def __unicode__(self):

    @transaction.commit_on_success

    def update_state(self):

def start_action(vm, action):

    """Update the state of a VM when a new action is initiated."""

    if not action in [x[0] for x in VirtualMachine.ACTIONS]:

        raise VirtualMachine.InvalidActionError(action)

    # Defined in settings.GANETI_CREATEINSTANCE_KWARGS

    # kw['hvparams'] = dict(serial_console=False)

    with pooled_rapi_client(vm) as client:

        return client.CreateInstance(**kw)

def reboot_instance(vm, reboot_type):

    assert reboot_type in ('soft', 'hard')

    with pooled_rapi_client(vm) as client:

def startup_instance(vm):

    #          the instance's primary node, and is probably

    #          hypervisor-specific.

    #

    console = {}

    console['kind'] = 'vnc'

    if not backends:

        backends = Backend.objects.exclude(offline=True)

    for backend in backends:

        create_jobID = _create_network(network, backend)

        if connect:

def connect_network(network, backend, depend_job=None, group=None):

    """Connect a network to nodegroups."""

    mode = "routed" if "ROUTED" in network.type else "bridged"

    with pooled_rapi_client(backend) as client:

    if not backends:

        backends = Backend.objects.exclude(offline=True)

    for backend in backends:

        disconnect_jobIDs = []

        if disconnect:

def disconnect_network(network, backend, group=None):

    with pooled_rapi_client(backend) as client:

        if group:

            return [client.DisconnectNetwork(network.backend_id, group)]

def connect_to_network(vm, network, address):

    nic = {'ip': address, 'network': network.backend_id}

    with pooled_rapi_client(vm) as client:

        return client.ModifyInstance(vm.backend_vm_id, nics=[('add',  nic)],

                                     hotplug=settings.GANETI_USE_HOTPLUG,

def disconnect_from_network(vm, nic):

    op = [('remove', nic.index, {})]

    with pooled_rapi_client(vm) as client:

        return client.ModifyInstance(vm.backend_vm_id, nics=op,

                                     hotplug=settings.GANETI_USE_HOTPLUG,

    except KeyError:

        raise ValueError("Unsopported Firewall Profile: %s" % profile)

    with pooled_rapi_client(vm) as client:

        # Delete all firewall tags

        for t in _firewall_tags.values():