Synnefo

        return u"<vm:%s@backend:%s>" % (self.id, self.backend_id)

    # Error classes

        def __init__(self, value):

            self.value = value

            free += ip_pool.count_available()

        return total, free

        def __init__(self, value):

            self.value = value

#

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

# without modification, are permitted provided that the following

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

from synnefo.db.models import Backend

from snf_django.management.utils import parse_bool

HYPERVISORS = [h[0] for h in Backend.HYPERVISORS]

        if len(args) != 1:

            raise CommandError("Please provide a backend ID")

        # Ensure fields correspondence with options and Backend model

        credentials_changed = False

        if credentials_changed:

                # check credentials, if any of them changed!

        if options['drained']:

            backend.drained = parse_bool(options['drained'], strict=True)

        if options['offline']:

#

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

# modification, are permitted provided that the following conditions

#

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

from synnefo.logic import backend as backend_mod

from synnefo.db.models import Backend

from django.db import transaction, models

        if len(args) < 1:

            raise CommandError("Please provide a backend ID")

        write("Trying to remove backend: %s\n" % backend.clustername)

#

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

# without modification, are permitted provided that the following

from optparse import make_option

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

from snf_django.management.utils import parse_bool

        if len(args) != 1:

            raise CommandError("Please provide a flavor ID")

        deleted = options['deleted']

#

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

# without modification, are permitted provided that the following

            raise CommandError('Please give either a server or a router id')

        #get the vm

        servers.create_port(vm.userid, floating_ip.network,

                            use_ipaddress=floating_ip, machine=vm)

#

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

# without modification, are permitted provided that the following

            raise CommandError("'owner' is required for floating IP creation")

        if network_id is not None:

            if not network.floating_ip_pool:

                raise CommandError("Network '%s' is not a floating IP pool."

                                   % network)

#

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

# without modification, are permitted provided that the following

        floating_ip_id = args[0]

        #get the floating-ip

        if not floating_ip.nic:

            raise CommandError('This floating IP is not attached to a device')

#

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

# without modification, are permitted provided that the following

        for floating_ip_id in args:

            self.stdout.write("\n")

            try:

                ips.delete_floating_ip(floating_ip)

                self.stdout.write("Deleted floating IP '%s'.\n" %

                                  floating_ip_id)

#

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

# without modification, are permitted provided that the following

        if len(args) != 1:

            raise CommandError("Please provide a network ID.")

        displayname = options['displayname']

        pprint.pprint_network(network, display_mails=displayname,

#

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

# without modification, are permitted provided that the following

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

from synnefo.db.models import Backend

from snf_django.management.utils import parse_bool

from synnefo.logic import networks, backend as backend_mod

from django.db import transaction

        if len(args) != 1:

            raise CommandError("Please provide a network ID")

        new_name = options.get("name")

        if new_name is not None:

        add_to_backend = options["add_to_backend"]

        if add_to_backend is not None:

            bnet, jobs = backend_mod.ensure_network_is_active(backend,

                                                              network.id)

            if jobs:

        remove_from_backend = options["remove_from_backend"]

        if remove_from_backend is not None:

            if network.nics.filter(machine__backend=backend,

                                   machine__deleted=False).exists():

                msg = "Cannot remove. There are still connected VMs to this"\

#

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

# modification, are permitted provided that the following conditions

from snf_django.management.commands import RemoveCommand

from snf_django.lib.api import faults

from synnefo.logic import networks

class Command(RemoveCommand):

    args = "<Network ID> [<Network ID> ...]"

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

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

        if not args:

            raise CommandError("Please provide a network ID")

        for network_id in args:

            self.stdout.write("\n")

            try:

                self.stdout.write('Removing network: %s\n' %

                                  network.backend_id)

#

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

# without modification, are permitted provided that the following

        owner = None

        if server_id:

            owner = "vm"

            #if vm.router:

            #    raise CommandError("Server '%s' does not exist." % server_id)

        elif router_id:

            owner = "router"

            if not vm.router:

                raise CommandError("Router '%s' does not exist." % router_id)

                raise CommandError("Please specify the owner of the port.")

        # get the network

        # Get either floating IP or fixed ip address

        ipaddress = None

        floating_ip_id = options["floating_ip_id"]

        ipv4_address = options["ipv4_address"]

        if floating_ip_id:

            if ipv4_address is not None and ipaddress.address != ipv4_address:

                raise CommandError("Floating IP address '%s' is different from"

                                   " specified address '%s'" %

                                   (ipaddress.address, ipv4_address))

        # validate security groups

        sg_list = []

        if security_group_ids:

#

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

# without modification, are permitted provided that the following

        if len(args) != 1:

            raise CommandError("Please provide a port ID")

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

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

#

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

# modification, are permitted provided that the following conditions

        for port_id in args:

            self.stdout.write("\n")

            try:

                servers.delete_port(port)

#

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

# modification, are permitted provided that the following conditions

import subprocess

from optparse import make_option

from django.core.management.base import BaseCommand

from synnefo.logic import reconciliation

from snf_django.management.utils import parse_bool

    def handle(self, **options):

        backend_id = options['backend-id']

        if backend_id:

        else:

            backends = reconciliation.get_online_backends()

#

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

# without modification, are permitted provided that the following

        if not image_id:

            raise CommandError("image-id is mandatory")

        image = common.get_image(image_id, user_id)

        if backend_id:

        else:

            backend = None

                    val = {"port": port_id}

                elif con_kind == "floatingip":

                    fip_id = opt.split(":")[1]

                    val = {"uuid": fip.network_id, "fixed_ip": fip.address}

                else:

                    raise CommandError("Unknown argument for option --port")

def import_server(instance_name, backend_id, flavor_id, image_id, user_id,

                  new_public_nic, stream=sys.stdout):

    backend_client = backend.get_client()

#

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

# without modification, are permitted provided that the following

        if len(args) != 1:

            raise CommandError("Please provide a server ID")

        displayname = options['displayname']

#

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

# without modification, are permitted provided that the following

from snf_django.management.commands import ListCommand

from synnefo.db.models import VirtualMachine

from synnefo.api.util import get_image

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

                              ASTAKOS_AUTH_URL)

            self.filters["suspended"] = True

        if options["backend_id"]:

            self.filters["backend"] = backend.id

        if options["build"]:

#

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

# without modification, are permitted provided that the following

from django.db import transaction

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

                                       wait_server_task)

from snf_django.management.utils import parse_bool

from synnefo.logic import servers

        if len(args) != 1:

            raise CommandError("Please provide a server ID")

        new_name = options.get("name", None)

        if new_name is not None:

        wait = parse_bool(options["wait"])

        new_flavor_id = options.get("flavor")

        if new_flavor_id is not None:

            old_flavor = server.flavor

            msg = "Resizing server '%s' from flavor '%s' to '%s'.\n"

            self.stdout.write(msg % (server, old_flavor, new_flavor))

#

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

# without modification, are permitted provided that the following

from optparse import make_option

from django.core.management.base import CommandError

                                       wait_server_task)

from synnefo.logic import servers

from snf_django.management.commands import RemoveCommand

        for server_id in args:

            self.stdout.write("\n")

            try:

                self.stdout.write("Trying to remove server '%s' from backend "

                                  "'%s' \n" % (server.backend_vm_id,

#

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

# without modification, are permitted provided that the following

from django.core.management.base import CommandError

from snf_django.management.commands import SynnefoCommand

                                       get_image)

from snf_django.lib.astakos import UserCache

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

        if len(args) != 1:

            raise CommandError("Please provide a server ID")

        flavor = '%s (%s)' % (server.flavor.id, server.flavor.name)

        userid = server.userid

#

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

# without modification, are permitted provided that the following

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import json

import string

from snf_django.management.utils import pprint_table, parse_bool

from snf_django.management.commands import SynnefoCommand, CommandError

from synnefo.admin import stats as statistics

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

        if options["backend"] is not None:

        else:

            backend = None

#

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

# without modification, are permitted provided that the following

from synnefo.management import pprint

from synnefo.logic import subnets

HELP_MSG = """

Create a new subnet without authenticating the user. The limit of one

        if not cidr:

            raise CommandError("cidr is mandatory")

        name = options["name"] or ""

        allocation_pools = options["allocation_pools"]

        ipversion = options["ipversion"] or 4

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

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

from synnefo.management import pprint, common

        if len(args) != 1:

            raise CommandError("Please provide a subnet ID.")

        pprint.pprint_subnet_in_db(subnet, stdout=self.stdout)

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

#

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

# without modification, are permitted provided that the following

        if not name:

            raise CommandError("--name is mandatory")

        subnets.update_subnet(sub_id=subnet_id,

                              name=name,

#

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

# without modification, are permitted provided that the following

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

                               Flavor, IPAddress, Subnet,

                               BridgePoolTable, MacPrefixPoolTable,

from functools import wraps

from snf_django.lib.api import faults

from synnefo.api import util

from synnefo.logic import backend as backend_mod

from synnefo.logic.rapi import GanetiApiError, GanetiRapiClient

from synnefo.logic.utils import (id_from_instance_name,

import logging

log = logging.getLogger(__name__)

    else:

        return vm.operstate

    try:

def get_image(image_id, user_id):

        raise CommandError("image-id is mandatory")

def check_backend_credentials(clustername, port, username, password):

    try:

        client = GanetiRapiClient(clustername, port, username, password)

from django.db import close_connection

from synnefo.db.models import Backend, pooled_rapi_client

import logging

logger = logging.getLogger("migrate_nics")

    options, args = parser.parse_args()

    if options.backend_id:

    else:

        if Backend.objects.filter(offline=True).exists():

            msg = "Can not update intances. An 'offline' backend exists."