Synnefo

from django.core.management.base import BaseCommand, CommandError

from synnefo.management.common import convert_api_faults

class Command(BaseCommand):

        if len(args) != 1:

            raise CommandError("Please provide a port ID")

        pprint.pprint_port(port, stdout=self.stdout)

        self.stdout.write('\n\n')

from optparse import make_option

from django.core.management.base import BaseCommand, CommandError

from synnefo.logic import servers

from synnefo.management import common

from snf_django.management.utils import parse_bool

        if len(args) < 1:

            raise CommandError("Please provide a port ID")

        servers.delete_port(port)

    def test_get_port(self):

        nic = dbmf.NetworkInterfaceFactory()

        url = join_urls(PORTS_URL, str(nic.id))

        self.assertEqual(response.status_code, 200)

    @patch("synnefo.db.models.get_rapi_client")

        url = join_urls(PORTS_URL, str(nic.id))

        mrapi().ModifyInstance.return_value = 42

        with override_settings(settings, GANETI_USE_HOTPLUG=True):

        self.assertEqual(response.status_code, 204)

        with override_settings(settings, GANETI_USE_HOTPLUG=False):

        self.assertEqual(response.status_code, 400)

    def test_remove_nic_malformed(self):

        url = join_urls(PORTS_URL, str(nic.id))

        request = {'port': {"name": "test-name"}}

        response = self.put(url, params=json.dumps(request),

        self.assertEqual(response.status_code, 200)

        res = json.loads(response.content)

        self.assertEqual(res['port']['name'], "test-name")

        url = join_urls(PORTS_URL, str(nic.id))

        request = {'port': {"security_groups": ["123"]}}

        response = self.put(url, params=json.dumps(request),

        self.assertEqual(response.status_code, 404)

    def test_update_port_sg(self):

        url = join_urls(PORTS_URL, str(nic.id))

        request = {'port': {"security_groups": [str(sg2.id), str(sg3.id)]}}

        response = self.put(url, params=json.dumps(request),

        res = json.loads(response.content)

        self.assertEqual(res['port']['security_groups'],

                         [str(sg2.id), str(sg3.id)])

    def test_create_server_with_port(self, mrapi):

        mrapi().CreateInstance.return_value = 42

        request = deepcopy(self.request)

        request["server"]["networks"] = [{"port": port1.id}]

        with mocked_quotaholder():

                                   json.dumps(request), 'json')

        self.assertConflict(response)

        # Test permissions

        request["server"]["networks"] = [{"port": port2.id}]

        with mocked_quotaholder():

            response = self.mypost("servers", "user2",

    Return a NetworkInteface instance or raise ItemNotFound.

    """

    try:

        if for_update:

            objects = objects.select_for_update()

        # if (port.device_owner != "vm") and for_update:

        #     raise faults.BadRequest('Can not update non vm port')

    except (ValueError, NetworkInterface.DoesNotExist):

def get_security_group(sg_id):

class NetworkInterfaceFactory(factory.DjangoModelFactory):

    FACTORY_FOR = models.NetworkInterface

    name = factory.LazyAttribute(lambda self: random_string(30))

    machine = factory.SubFactory(VirtualMachineFactory, operstate="STARTED")

    network = factory.SubFactory(NetworkFactory, state="ACTIVE")

        factory.LazyAttributeSequence(lambda self, n: self.subnet.cidr[:-4] +

                                      '{0}'.format(int(n) + 2))

    nic = factory.SubFactory(NetworkInterfaceFactory,

                             network=factory.SelfAttribute('..network'))

        ports.append(port)

    for floating_ip_id in floating_ips:

                                                 for_update=True)

        port = _create_port(userid, network=floating_ip.network,

                            use_ipaddress=floating_ip)

from django.core.management import CommandError

from synnefo.db.models import (Backend, VirtualMachine, Network,

                               Flavor, IPAddress, Subnet,

from functools import wraps

from snf_django.lib.api import faults

def get_subnet(subnet_id, for_update=True):

    """Get a Subnet object by its ID."""

    try:

    except Subnet.DoesNotExist:

        raise CommandError("Subnet with ID %s not found in DB."

                           " Use snf-manage subnet-list to find out"

                           " available subnet IDs" % subnet_id)

def get_flavor(flavor_id):

    try:

        flavor_id = int(flavor_id)