Synnefo

def network_to_dict(network, detail=True):

    if detail:

        d['updated'] = isoformat(network.updated)

        d['created'] = isoformat(network.created)

        raise BadRequest('Malformed request.')

    net = get_network(network_id, request.user)

    net.name = name

    net.save()

    return HttpResponse(status=204)

    #                       unauthorized (401),

    #                       overLimit (413)

    net = get_network(network_id, request.user)

    backend.delete_network(net)

    return HttpResponse(status=204)

@api_method('POST')

def network_action(request, network_id):

    net = get_network(network_id, request.user)

    req = get_request_dict(request)

    if len(req) != 1:

        raise BadRequest('Malformed request.')

def nic_to_dict(nic):

    if nic.ipv4 or nic.ipv6:

        d['values'] = []

        if nic.ipv4:

            d['metadata'] = {'values': metadata}

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

    return d

        return reply

    def get_network_details(self, network_id):

        response = self.client.get(path)

        self.assertEqual(response.status_code, 200)

        reply = json.loads(response.content)

        return reply['network']

    def update_network_name(self, network_id, new_name):

        data = json.dumps({'network': {'name': new_name}})

        response = self.client.put(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 204)

    def delete_network(self, network_id):

        response = self.client.delete(path)

        self.assertEqual(response.status_code, 204)

    def add_to_network(self, network_id, server_id):

        data = json.dumps({'add': {'serverRef': server_id}})

        response = self.client.post(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 202)

    def remove_from_network(self, network_id, server_id):

        data = json.dumps({'remove': {'serverRef': server_id}})

        response = self.client.post(path, data, content_type='application/json')

        self.assertEqual(response.status_code, 202)

    def test_list_networks(self):

        networks = self.list_networks()

        for net in Network.objects.all():

            self.assertEqual(network['name'], net.name)

        self.assertEqual(networks, [])

    def test_list_networks_detail(self):

        networks = self.list_networks(detail=True)

        for net in Network.objects.all():

            self.assertEqual(network['name'], net.name)

            machines = set(vm.id for vm in net.machines.all())

            self.assertEqual(set(network['servers']['values']), machines)

class UpdateNetworkName(BaseTestCase):

    def test_update_network_name(self):

        networks = self.list_networks(detail=True)

        network_id = network['id']

        new_name = network['name'] + '_2'

        self.update_network_name(network_id, new_name)

            self.create_network('net%d' % i)

        networks = self.list_networks()

        network_id = network['id']

        self.delete_network(network_id)

        net = self.get_network_details(network_id)

        self.assertEqual(net['status'], 'DELETED')

class NetworkActions(BaseTestCase):

    try:

        if network_id == 'public':

    except ValueError:

        raise BadRequest('Invalid network ID.')

    except Network.DoesNotExist:

#

from django.conf import settings

from synnefo.db.models import VirtualMachine, Network, NetworkLink

from synnefo.logic import utils

from synnefo.util.rapi import GanetiRapiClient

    vm.save()

def process_net_status(vm, nics):

    """Process a net status notification from the backend

        return NetworkLink.objects.create(index=index, name=name, available=True)

    return None     # All link slots are filled

def create_network(net):

    try:

        link = NetworkLink.objects.filter(available=True)[0]

    link.save()

    return True

def delete_network(net):

    link = net.link

    link.available = True

        if 'values' in net:

            addr = '[%s]' % ' '.join(ip['addr'] for ip in net['values'])

        print '%s %s' % (key, val)

def print_dict(d, show_empty=True):