Synnefo

        metadata = dict((m.meta_key, m.meta_value) for m in vm.metadata.all())

        d['metadata'] = metadata

        attachments = map(nic_to_dict, vm_nics)

        d['attachments'] = attachments

        d['addresses'] = attachments_to_addresses(attachments)

    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)

    addresses = attachments_to_addresses(map(nic_to_dict, nics))

    if request.serialization == 'xml':

    if attachment is None:

        raise faults.BadRequest("Missing 'attachment' attribute.")

    try:

        server_id = int(server_id)

    except (ValueError, TypeError):

        raise faults.BadRequest("Invalid 'attachment' attribute.")

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

    return HttpResponse(status=202)

            self.assertEqual(db_net.gateway6, api_net['gateway6'])

            self.assertEqual(db_net.dhcp, api_net['dhcp'])

            self.assertEqual(db_net.public, api_net['public'])

                       db_net.nics.filter(machine__userid=db_net.userid)]

            self.assertEqual(db_nics, api_net['attachments'])

        net = mfactory.NetworkFactory(state='ACTIVE', userid=user)

        nic = mfactory.NetworkInterfaceFactory(machine=vm, network=net)

        mrapi().ModifyInstance.return_value = 1

        response = self.mypost('networks/%d/action' % net.id,

                               net.userid, json.dumps(request), 'json')

        self.assertEqual(response.status_code, 202)

        vm.task = None

        vm.task_job_id = None

        vm.save()

    def test_remove_nic_malformed(self, mrapi):

        user = 'userr'

        net = mfactory.NetworkFactory(state='ACTIVE', userid=user)

        nic = mfactory.NetworkInterfaceFactory(machine=vm, network=net)

        request = {'remove':

                  }

        response = self.mypost('networks/%d/action' % net.id,

                               net.userid, json.dumps(request), 'json')

        self.assertEqual(api_nic['ipv4'], nic.ipv4)

        self.assertEqual(api_nic['ipv6'], nic.ipv6)

        self.assertEqual(api_nic['OS-EXT-IPS:type'], "fixed")

        api_address = server["addresses"]

        self.assertEqual(api_address[str(net.id)], [

            {"version": 4, "addr": nic.ipv4, "OS-EXT-IPS:type": "fixed"},

    return address

    try:

    except NetworkInterface.DoesNotExist:

        raise faults.ItemNotFound('Server not connected to this network.')

def render_metadata(request, metadata, use_values=False, status=200):

    if request.serialization == 'xml':

        data = render_to_string('metadata.xml', {'metadata': metadata})

def construct_nic_id(nic):

def verify_personality(personality):

        get_latest_by = 'created'

    def __unicode__(self):

    # Error classes

    class InvalidBackendIdError(Exception):

    ipv6 = models.CharField(max_length=100, null=True)

    firewall_profile = models.CharField(choices=FIREWALL_PROFILES,

                                        max_length=30, null=True)

    state = models.CharField(max_length=32, null=False, default="ACTIVE",

                             choices=STATES)

    def __unicode__(self):

        return "<%s:vm:%s network:%s ipv4:%s ipv6:%s>" % \

             self.ipv6)

    @property

        if ipv4:

            net.reserve_address(ipv4)

        vm.nics.create(**nic)

        # Dummy save the network, because UI uses changed-since for VMs

        # and Networks in order to show the VM NICs

        kw['disks'][0]['provider'] = provider

        kw['disks'][0]['origin'] = flavor.disk_origin

                  for nic in nics]

    backend = vm.backend

    depend_jobs = []

    depends = [[job, ["success", "error", "canceled"]] for job in depend_jobs]

    kwargs = {

        "instance": vm.backend_vm_id,

def disconnect_from_network(vm, nic):

    kwargs = {

        "instance": vm.backend_vm_id,

    if network.subnet is not None and network.dhcp:

        # Get a free IP from the address pool.

        address = util.get_network_free_address(network)

    return backend.connect_to_network(vm, nic)

@server_command("DISCONNECT")

    return backend.disconnect_from_network(vm, nic)