Synnefo

from snf_django.lib.api import faults, utils

from synnefo.api import util

from synnefo import quotas

from logging import getLogger

    log.debug("list_floating_ips")

    userid = request.user_uniq

    floating_ips = utils.filter_modified_since(request, objects=floating_ips)

    floating_ips = map(ip_to_dict, floating_ips)

    """Return information for a floating IP."""

    userid = request.user_uniq

    try:

                                             deleted=False,

                                             userid=userid)

        raise faults.ItemNotFound("Floating IP '%s' does not exist" %

                                  floating_ip_id)

    request.serialization = "json"

            else:

                # User specified an IP address. Check that it is not a used

                # floating IP

                                             deleted=False,

                                             ipv4=address).exists():

                    msg = "Floating IP '%s' is reserved" % address

                    except NetworkInterface.DoesNotExist:

                        msg = "Address '%s' is already in use" % address

                        raise faults.Conflict(msg)

                                                userid=userid, machine=machine)

        quotas.issue_and_accept_commission(floating_ip)

    except:

    userid = request.user_uniq

    log.info("release_floating_ip '%s'. User '%s'.", floating_ip_id, userid)

    try:

                                        .get(id=floating_ip_id,

                                             deleted=False,

                                             userid=userid)

        raise faults.ItemNotFound("Floating IP '%s' does not exist" %

                                  floating_ip_id)

import json

from snf_django.utils.testing import BaseAPITest, mocked_quotaholder

                                       VirtualMachineFactory,

                                       NetworkInterfaceFactory,

                                       BackendNetworkFactory)

NETWORKS_URL = join_urls(compute_path, "networks")

SERVERS_URL = join_urls(compute_path, "servers")

                                floating_ip_pool=True)

    def test_no_floating_ip(self):

        response = self.get(URL)

        self.assertSuccess(response)

        self.assertEqual(json.loads(response.content)["floating_ips"], [])

    def test_list_ips(self):

        with mocked_quotaholder():

            response = self.get(URL, "user1")

        self.assertSuccess(response)

                          str(ip.network.id)})

    def test_get_ip(self):

        with mocked_quotaholder():

            response = self.get(URL + "/%s" % ip.id, "user1")

        self.assertSuccess(response)

                          str(ip.network.id)})

    def test_wrong_user(self):

        with mocked_quotaholder():

            response = self.delete(URL + "/%s" % ip.id, "user2")

        self.assertItemNotFound(response)

    def test_deleted_ip(self):

        with mocked_quotaholder():

            response = self.delete(URL + "/%s" % ip.id, "user1")

        self.assertItemNotFound(response)

    def test_reserve(self):

                                    subnet="192.168.2.0/24",

                                    gateway=None)

        request = {'pool': net.id}

        with mocked_quotaholder():

            response = self.post(URL, "test_user", json.dumps(request), "json")

        self.assertSuccess(response)

        self.assertEqual(ip.ipv4, "192.168.2.1")

        self.assertEqual(ip.machine, None)

        self.assertEqual(ip.network, net)

            response = self.post(URL, "test_user", json.dumps({}), "json")

        self.assertFault(response, 413, "overLimit")

        # Full network

                              subnet="192.168.2.0/32",

                              gateway=None)

        with mocked_quotaholder():

            response = self.post(URL, "test_user", json.dumps({}), "json")

        self.assertFault(response, 413, "overLimit")

        # Success

                                     subnet="192.168.2.0/24",

                                     gateway=None)

        with mocked_quotaholder():

            response = self.post(URL, "test_user", json.dumps({}), "json")

        self.assertSuccess(response)

        self.assertEqual(json.loads(response.content)["floating_ip"],

                         {"instance_id": None, "ip": "192.168.2.1",

                          "fixed_ip": None, "id": str(ip.id),

                          "pool": str(net2.id)})

    def test_reserve_full(self):

                                    subnet="192.168.2.0/32")

        request = {'pool': net.id}

        with mocked_quotaholder():

        self.assertEqual(response.status_code, 413)

    def test_reserve_with_address(self):

                                    subnet="192.168.2.0/24")

        request = {'pool': net.id, "address": "192.168.2.10"}

        with mocked_quotaholder():

            response = self.post(URL, "test_user", json.dumps(request), "json")

        self.assertSuccess(response)

        self.assertEqual(json.loads(response.content)["floating_ip"],

                         {"instance_id": None, "ip": "192.168.2.10",

                          "fixed_ip": None, "id": str(ip.id), "pool":

                          str(net.id)})

        # Already reserved

        request = {'pool': net.id, "address": "192.168.2.3"}

        with mocked_quotaholder():

            response = self.post(URL, "test_user", json.dumps(request), "json")

        self.assertBadRequest(response)

    def test_release_in_use(self):

        vm = ip.machine

        vm.operstate = "ACTIVE"

        vm.userid = ip.userid

        self.assertFault(response, 409, "conflict")

    def test_release(self):

        with mocked_quotaholder():

            response = self.delete(URL + "/%s" % ip.id, ip.userid)

        self.assertSuccess(response)

        self.assertEqual(len(ips_after), 0)

    @patch("synnefo.logic.backend", Mock())

    def test_delete_network_with_floating_ips(self):

        net = ip.network

        # Can not remove network with floating IPs

        with mocked_quotaholder():

POOLS_URL = join_urls(compute_path, "os-floating-ip-pools")

    def test_no_pool(self):

        response = self.get(POOLS_URL)

        self.assertSuccess(response)

        self.assertEqual(json.loads(response.content)["floating_ip_pools"], [])

    def test_list_pools(self):

                                    gateway="192.168.0.1")

        NetworkFactory(public=True, deleted=True)

        NetworkFactory(public=False, deleted=False)

                         [{"name": str(net.id), "size": 4, "free": 1}])

    def setUp(self):

        vm = VirtualMachineFactory()

        vm.operstate = "ACTIVE"

        self.assertItemNotFound(response)

        # In use

        vm1 = VirtualMachineFactory()

        BackendNetworkFactory(network=ip1.network, backend=vm1.backend,

                              operstate='ACTIVE')

        request = {"addFloatingIp": {"address": ip1.ipv4}}

        response = self.post(url, self.vm.userid, json.dumps(request), "json")

        self.assertFault(response, 409, "conflict")

        # Success

        BackendNetworkFactory(network=ip1.network, backend=self.vm.backend,

                              operstate='ACTIVE')

        request = {"addFloatingIp": {"address": ip1.ipv4}}

        mock().ModifyInstance.return_value = 1

        response = self.post(url, self.vm.userid, json.dumps(request), "json")

        self.assertEqual(response.status_code, 202)

        self.assertEqual(ip1_after.machine, self.vm)

        self.assertTrue(ip1_after.in_use())

        nic = self.vm.nics.get(ipv4=ip1_after.ipv4)

        response = self.post(url, self.vm.userid, json.dumps(request), "json")

        self.assertItemNotFound(response)

        # Not In Use

        request = {"removeFloatingIp": {"address": ip1.ipv4}}

        response = self.post(url, self.vm.userid, json.dumps(request), "json")

        self.assertItemNotFound(response)

        # Success

        NetworkInterfaceFactory(machine=self.vm, ipv4=ip1.ipv4)

        request = {"removeFloatingIp": {"address": ip1.ipv4}}

        mock().ModifyInstance.return_value = 2

        response = self.post(url, self.vm.userid, json.dumps(request), "json")

        self.assertEqual(response.status_code, 202)

        # Yet used. Wait for the callbacks

        self.assertEqual(ip1_after.machine, self.vm)

        self.assertTrue(ip1_after.in_use())

from snf_django.utils.testing import (BaseAPITest, mocked_quotaholder,

                                      override_settings)

from synnefo.db.models import (VirtualMachine, VirtualMachineMetadata,

from synnefo.db import models_factory as mfactory

from synnefo.logic.utils import get_rsapi_state

from synnefo.cyclades_settings import cyclades_services

        mfactory.BackendNetworkFactory(network=network,

                                       backend=self.backend,

                                       operstate="ACTIVE")

                                         userid="test_user",

                                         network=network, machine=None)

                                         userid="test_user",

                                         machine=None)

        request["server"]["floating_ips"] = [fp1.ipv4, fp2.ipv4]

        self.assertEqual(response.status_code, 202)

        api_server = json.loads(response.content)['server']

        vm = VirtualMachine.objects.get(id=api_server["id"])

        self.assertEqual(fp1.machine, vm)

        self.assertEqual(fp2.machine, vm)

        name, args, kwargs = mrapi().CreateInstance.mock_calls[2]

from synnefo.db.models import (Flavor, VirtualMachine, VirtualMachineMetadata,

                               Network, BackendNetwork, NetworkInterface,

                               BridgePoolTable, MacPrefixPoolTable, Backend,

from synnefo.db.pools import EmptyPool

from synnefo.plankton.utils import image_backend

def get_floating_ip(user_id, ipv4, for_update=False):

    try:

        if for_update:

            objects = objects.select_for_update()

        return objects.get(userid=user_id, ipv4=ipv4, deleted=False)

        raise faults.ItemNotFound("Floating IP does not exist.")

from datetime import datetime, timedelta

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

                               BackendNetwork, BACKEND_STATUSES,

                               pooled_rapi_client, VirtualMachineDiagnostic,

from synnefo.logic import utils

from synnefo import quotas

from synnefo.api.util import release_resource

    if nic.ipv4:

        if nic.ip_type == "FLOATING":

        else:

            nic.network.release_address(nic.ipv4)

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from snf_django.management.commands import ListCommand

from synnefo.settings import CYCLADES_SERVICE_TOKEN, ASTAKOS_BASE_URL

from logging import getLogger

class Command(ListCommand):

    help = "List Floating IPs"

    deleted_field = "deleted"

    user_uuid_field = "userid"

    astakos_url = ASTAKOS_BASE_URL

from synnefo.logic import backend

from synnefo.logic.backend_allocator import BackendAllocator

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

from vncauthproxy.client import request_forwarding as request_vnc_forwarding

def add_floating_ip_to_vm(vm, address):

    """Get a floating IP by it's address and add it to VirtualMachine.

    it with a VirtualMachine object (without adding the NIC in the Ganeti

    backend!). This function also checks if the floating IP is currently used

    by any instance and if it is available in the Backend that hosts the VM.

    try:

        # Get lock in VM, to guarantee that floating IP will only by assigned

        # once

                                        .get(userid=user_id, ipv4=address,

                                             deleted=False)

        raise faults.ItemNotFound("Floating IP '%s' does not exist" % address)

    if floating_ip.in_use():

def remove_floating_ip(vm, address):

    user_id = vm.userid

    try:

                                        .get(userid=user_id, ipv4=address,

                                             deleted=False, machine=vm)

        raise faults.ItemNotFound("Floating IP '%s' does not exist" % address)

    try:

from django.test import TestCase

                               Network, BridgePoolTable, MacPrefixPoolTable)

from synnefo.db import models_factory as mfactory

from synnefo.lib.utils import split_time

        self.assertTrue(nic.network.get_pool().is_available(nic.ipv4))

        vm2 = mfactory.VirtualMachineFactory()

        network = mfactory.NetworkFactory(floating_ip_pool=True)

        mfactory.NetworkInterfaceFactory(machine=vm2, network=network,

                                         ipv4=fp1.ipv4)

        mfactory.NetworkInterfaceFactory(machine=vm2, network=network,

        db_vm = VirtualMachine.objects.get(id=vm.id)

        self.assertEqual(db_vm.operstate, 'DESTROYED')

        self.assertTrue(db_vm.deleted)

        pool = network.get_pool()

        # Test that floating ips are not released

        self.assertFalse(pool.is_available(fp1.ipv4))

from snf_django.lib.api import faults

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

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

                              ASTAKOS_BASE_URL)

                'cyclades.active_ram': 1048576 * flavor.ram}

    elif isinstance(resource, Network):

        return {"cyclades.network.private": 1}

        return {"cyclades.floating_ip": 1}

    else:

        raise ValueError("Unknown Resource '%s'" % resource)

        self.assertEqual(holdings["user2"], user_holdings["user2"])

    def test_floating_ip_holdings(self):

        holdings = util.get_db_holdings()

        self.assertEqual(holdings["user1"]["cyclades.floating_ip"], 2)

        self.assertEqual(holdings["user2"]["cyclades.floating_ip"], 1)

from django.db.models import Sum, Count, Q

from synnefo.quotas import Quotaholder, ASTAKOS_TOKEN

    vms = VirtualMachine.objects.filter(deleted=False)

    networks = Network.objects.filter(deleted=False)

    if user is not None:

        vms = vms.filter(userid=user)