Synnefo

from synnefo.db.models import Network, Backend

        make_option('--backend-id',

            dest='backend_id',

            default=None,

            help='ID of the backend that the network will be created. Only for'

                 ' public networks')

        backend_id = options['backend_id']

        public = options['public']

        if public and not backend_id:

            raise CommandError("backend-id is required")

        if backend_id and not public:

            raise CommandError("Private networks must be created to"

                               " all backends")

        if backend_id:

            try:

                backend_id = int(backend_id)

                backend = Backend.objects.get(id=backend_id)

            except ValueError:

                raise CommandError("Invalid backend ID")

            except Backend.DoesNotExist:

                raise CommandError("Backend not found in DB")

                public=public,

        if public:

            # Create BackendNetwork only to the specified Backend

            network.create_backend_network(backend)

            create_network(network, backends=[backend])

        else:

            # Create BackendNetwork entries for all Backends

            network.create_backend_network()

            create_network(network)

# Copyright 2011-2012 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

#   1. Redistributions of source code must retain the above copyright

#      notice, this list of conditions and the following disclaimer.

#

#  2. Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

# SUCH DAMAGE.

#

# The views and conclusions contained in the software and documentation are

# those of the authors and should not be interpreted as representing official

# policies, either expressed or implied, of GRNET S.A.

#

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

from synnefo.db.models import Network

from synnefo.api.networks import delete_network as api_delete_network

from synnefo.logic.backend import delete_network as backend_delete_network

class Command(BaseCommand):

    can_import_settings = True

    help = "Remove a network from the Database, and Ganeti"

    output_transaction = True  # The management command runs inside

                               # an SQL transaction

    def handle(self, *args, **options):

        if len(args) < 1:

            raise CommandError("Please provide a network ID")

        try:

            network_id = int(args[0])

            network = Network.objects.get(id=network_id)

        except ValueError:

            raise CommandError("Invalid network ID")

        except network.DoesNotExist:

            raise CommandError("Network not found in DB")

        self.stdout.write('Trying to remove network: %s\n' % str(network))

        if network.machines.exists():

            raise CommandError('Network is not empty. Can not delete')

        if network.public:

            network.action = 'DESTROY'

            backend_delete_network(network)

        else:

            api_delete_network(network)

        self.stdout.write('Successfully removed network.\n')

    d = {'id': str(network.id), 'name': network.name}

        d['public'] = network.public

        attachments = [util.construct_nic_id(nic)

                       for nic in network.nics.filter(machine__userid=user_id)]

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

def nic_to_dict(nic):

    d = {'id': util.construct_nic_id(nic),

         'network_id': str(nic.network.id),

         'mac_address': nic.mac,

         'ipv4': nic.ipv4 if nic.ipv4 else None,

         'ipv6': nic.ipv6 if nic.ipv6 else None}

                                BadMediaType)

                               Network, BackendNetwork, NetworkInterface,

                               BridgePool)

from synnefo.logic import ippool

        network_id = int(network_id)

        return Network.objects.get(id=network_id, userid=user_id)

def backend_public_networks(backend):

    """Return available public networks of the backend.

    Iterator for non-deleted public networks that are available

    to the specified backend.

    """

    for network in Network.objects.filter(public=True, deleted=False):

        if BackendNetwork.objects.filter(network=network,

                                         backend=backend).exists():

            yield network

def get_network_free_address(network):

    """Reserve an IP address from the IP Pool of the network.

    Raises Network.DoesNotExist , ippool.IPPool.IPPoolExhausted

    """

    # Get the Network object in exclusive mode in order to

    # safely (isolated) reserve an IP address

    network = Network.objects.select_for_update().get(id=network.id)

    pool = ippool.IPPool(network)

    address = pool.get_free_address()

    pool.save()

    return address

            except BaseException:

from synnefo.api.util import backend_public_networks

        return backends[0]

    capable_backends = [backend for backend in backends

                        if vm_fits_in_backend(backend, vm)]

    backend_scores = [(backend, backend_score(backend, vm))

                      for backend in capable_backends]

    result = min(backend_scores, key=lambda (b, b_score): b_score)

    backend = result[0]

    return backend

    return backend.dfree > vm['disk'] and backend.mfree > vm['ram'] and\

           has_free_ip(backend)

    mratio = 1 - (backend.mfree / backend.mtotal)

    dratio = 1 - (backend.dfree / backend.dtotal)

    cratio = (backend.pinst_cnt + 1) / (backend.ctotal * 4)

def has_free_ip(backend):

    """Find if Backend has any free public IP."""

    for network in backend_public_networks(backend):

        if not network.pool.is_full():

            return True

    return False

from synnefo.api.util import backend_public_networks, get_network_free_address

        (network, address) = allocate_public_address(vm)

        if address is None:

                            " Public networks are full.")

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

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

def allocate_public_address(vm):

    """Allocate a public IP for a vm."""

    for network in backend_public_networks(vm.backend):

        try:

            address = get_network_free_address(network)

            return (network, address)

        except ippool.IPPool.IPPoolExhausted:

            pass

    return (None, None)

        backend = self.strategy_mod.allocate(available_backends, vm)

    return Backend.objects.filter(drained=False, offline=False)

            if net.public:

                # Do not create public networks since are backend-specific

                continue

            if network.public and not \

                BackendNetwork.objects.filter(network=network,

                                              backend=b).exists():

                    continue