Synnefo

        if (subnet is None) and (subnet6 is None):

            raise CommandError("subnet or subnet6 is required")

        if subnet is None and gateway is not None:

        if subnet6 is None and gateway6 is not None:

        if public and not (backend_ids or floating_ip_pool):

            raise CommandError("backend-ids is required")

        if not userid and not public:

            floating_ip_pool = parse_bool(floating_ip_pool)

            if floating_ip_pool is False and network.floating_ip_pool is True:

                if network.ips.filter(deleted=False, floating_ip=True).exists():

                           " There are still reserved floating IPs.")

                    raise CommandError(msg)

            network.floating_ip_pool = floating_ip_pool

            backend = get_backend(remove_from_backend)

            if network.nics.filter(machine__backend=backend,

                                   machine__deleted=False).exists():

                      " network"

                raise CommandError(msg)

            backend_mod.delete_network(network, backend, disconnect=True)

    jobid = backend_client.ModifyInstance(instance_name, nics=op)

    (status, error) = wait_for_job(backend_client, jobid)

    if status != 'success':

def add_public_nic(instance_name, nic, backend_client, stream=sys.stdout):

    jobid = backend_client.ModifyInstance(instance_name, nics=[('add', nic)])

    (status, error) = wait_for_job(backend_client, jobid)

    if status != 'success':

def shutdown_instance(instance, backend_client, stream=sys.stdout):

        jobid = backend_client.ShutdownInstance(instance_name)

        (status, error) = wait_for_job(backend_client, jobid)

        if status != 'success':

def rename_instance(old_name, new_name, backend_client, stream=sys.stdout):

                                          ip_check=False, name_check=False)

    (status, error) = wait_for_job(backend_client, jobid)

    if status != 'success':

def startup_instance(name, backend_client, stream=sys.stdout):

    jobid = backend_client.StartupInstance(name)

    (status, error) = wait_for_job(backend_client, jobid)

    if status != 'success':

    if flavor not in Network.FLAVORS.keys():

        raise api.faults.BadRequest("Invalid network type '%s'" % flavor)

    if flavor not in settings.API_ENABLED_NETWORK_FLAVORS:

                                   flavor)

    name = api.utils.get_attribute(network_dict, "name", required=False)

    network = util.get_network(network_id, request.user_uniq, for_update=True)

    if network.public:

    network = networks.rename(network, new_name)

    return render_network(request, network_to_dict(network), 200)

    log.info('delete_network %s', network_id)

    network = util.get_network(network_id, request.user_uniq, for_update=True)

    if network.public:

    networks.delete(network)

    return HttpResponse(status=204)

    elif flavor not in Network.FLAVORS.keys():

        raise faults.BadRequest("Invalid network type '%s'" % flavor)

    elif flavor not in settings.API_ENABLED_NETWORK_FLAVORS:

                               flavor)

    public = d.get("public", False)

    if public:

    dhcp = d.get('dhcp', True)

    network = util.get_network(network_id, request.user_uniq)

    if network.public:

    network = networks.rename(network, name)

    return HttpResponse(status=204)

    log.info('delete_network %s', network_id)

    network = util.get_network(network_id, request.user_uniq, for_update=True)

    if network.public:

    networks.delete(network)

    return HttpResponse(status=204)

    net = util.get_network(network_id, request.user_uniq)

    if net.public:

    if net.deleted:

        raise faults.BadRequest("Network has been deleted.")

        network = ip.network

        network.public = False

        network.save()

        with mocked_quotaholder():

            response = self.delete(NETWORKS_URL + "/%s" % self.pool.id,

                                   self.pool.userid)

        if for_update:

            objects = objects.select_for_update()

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

        return objects.get(id=port_id)

    except (ValueError, NetworkInterface.DoesNotExist):

        raise faults.ItemNotFound("Port '%s' not found." % port_id)

    plaintext = plaintext[SALT_LEN:]

    if salt != pure_salt:

    else:

        return plaintext

    def backwards(self, orm):

        "Write your backwards methods here."

    models = {

        'db.backend': {

    plaintext = plaintext[SALT_LEN:]

    if salt != pure_salt:

    else:

        return plaintext

    plaintext = plaintext[SALT_LEN:]

    if salt != pure_salt:

    else:

        return plaintext

                first_free = [x for x in xrange(0, 16) if x not in indexes][0]

                self.index = first_free

            except IndexError:

    def use_hotplug(self):

        return self.hypervisor == "kvm" and snf_settings.GANETI_USE_HOTPLUG

                    ip_pool.put(self.address)

                    ip_pool.save()

                    return

                      " belong to any of the IP pools of the subnet %s !",

                      self.address, self.nic, self.subnet_id)

        if backend.offline:

            log.warning("Trying to connect with offline backend: %s", backend)

                                            " backend: %s" % backend)

        b = backend

        size = self.pool_size

        tmp = self.available[(size - bits_num): size]

        if tmp.count(UNAVAILABLE):

        self.resize(-bits_num)

    def resize(self, bits_num):

    if len(backends) == 1:

        return backends[0]

    capable_backends = [backend for backend in backends

                        if vm_fits_in_backend(backend, vm)]

                                        disk=old_flavor.disk,

                                        disk_template=old_flavor.disk_template)

    except Flavor.DoesNotExist:

    vm.flavor = new_flavor

    vm.save()

                                               active=True)

    except IPAddressLog.MultipleObjectsReturned:

        logmsg = ("Multiple active log entries for IP %s, Network %s,"

                  % (ip.address, ip.network, nic.machine))

        log.error(logmsg)

        raise

    # Release the resources on the deletion of the Network

    if deleted:

        if network.ips.filter(deleted=False, floating_ip=True).exists():

            log.error(msg % network)

            raise Exception(msg % network)

        log.info("Network %r deleted. Releasing link %r mac_prefix %r",

            log.error("VM for instance %s with id %d not found in DB.",

                      msg['instance'], vm_id)

        except Network.InvalidBackendIdError, Network.DoesNotExist:

    return wrapper

    (opts, args) = parse_arguments(sys.argv[1:])

    # Rename this process so 'ps' output looks like this is a native

    # the executable by NUL bytes, so only show the name of the executable

    # instead.  setproctitle.setproctitle("\x00".join(sys.argv))

    setproctitle.setproctitle(sys.argv[0])

def allocate_ip(network, userid, address=None, floating_ip=False):

    """Try to allocate an IP from networks IP pools."""

    if network.action == "DESTROY":

                              " deleted" % network.id)

    ip_pools = IPPoolTable.objects.select_for_update()\

        .filter(subnet__network=network)

        if backend is not None:

            log_msg += " Backend: %s" % backend

        log.error(log_msg)

        raise faults.Conflict(exception_msg)

        floating_ip = allocate_public_ip(userid, floating_ip=True)

    else:

        if not network.floating_ip_pool:

                   " not a floating IP pool.")

            raise faults.Conflict(msg % network.id)

        if network.action == "DESTROY":

            raise faults.Conflict(msg % network.id)

        # Allocate the floating IP

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

        if backend.virtual_machines.filter(deleted=False).exists():

        # Get networks before deleting backend, because after deleting the

        # backend, all BackendNetwork objects are deleted!

        try:

            delete_backend(backend)

        except models.ProtectedError as e:

                   "non-deleted VMs:\n%s" % e)

            raise CommandError(msg)

        raise faults.BadRequest("Invalid network type '%s'" % flavor)

    if mac_prefix is not None and flavor == "MAC_FILTERED":

    if link is not None and flavor == "PHYSICAL_VLAN":

    if subnet is None and floating_ip_pool:

                                " pools.")

    # Check that network parameters are valid

    subnets.validate_subnet_params(subnet, gateway, subnet6, gateway6)

@network_command("DESTROY")

def delete(network):

    if network.nics.exists():

                              " configured on network network %s" % network.id)

    if network.ips.filter(deleted=False, floating_ip=True).exists():

        raise faults.Conflict(msg)

    network.action = "DESTROY"

      conflicts = set(kwargs.iterkeys()) & set(body.iterkeys())

      if conflicts:

                             " keywords: %s" % ", ".join(conflicts))

      body.update((key, value) for key, value in kwargs.iteritems()

    if pending_action:

        if pending_action == "BUILD":

            raise faults.BuildInProgress("Server '%s' is being build." % vm.id)

                                " pending '%s'." % (action, pending_action))

    # Check if action can be performed to VM's operstate

    operstate = vm.operstate

    if operstate == "ERROR":

                                " in 'ERROR' state." % action)

    elif operstate == "BUILD" and action != "BUILD":

        raise faults.BuildInProgress("Server '%s' is being build." % vm.id)

         (action == "RESIZE" and operstate != "STOPPED") or\

         (action in ["CONNECT", "DISCONNECT"] and operstate != "STOPPED"

          and not settings.GANETI_USE_HOTPLUG):

                                " in '%s' state." % (action, operstate))

    return

        return None

    # Check that resize can be performed

    if old_flavor.disk != flavor.disk:

    if old_flavor.disk_template != flavor.disk_template:

    log.info("Resizing VM from flavor '%s' to '%s", old_flavor, flavor)

    commission_info = {"cyclades.cpu": flavor.cpu - old_flavor.cpu,

    """

    if network.state != "ACTIVE":

                                     " state %s" % network.state)

    if network.action == "DESTROY":

        raise faults.Conflict(msg % network.id)

    ipaddress = None

    if use_ipaddress is not None:

    if port.network.public and not port.ips.filter(floating_ip=True,

                                                   deleted=False).exists():

    if port.machine is not None:

        vm = disconnect(port.machine, port)

        kw = copy(kwargs)

        kw["gateway6"] = "2001:64q:2ffc:1119::1"

        self.assertRaises(faults.BadRequest, networks.create, **kw)

        kw = copy(kwargs)

        kw["floating_ip_pool"] = True

        self.assertRaises(faults.BadRequest, networks.create, **kw)

    to accepted and rejected, according to the state of the

    QuotaHolderSerial DB table. A pending commission in the quotaholder

    can exist in the QuotaHolderSerial table and be either accepted or

    """