Synnefo » snf-ganeti » ganeti-local

    retval = kind, None

  elif kind in (constants.TAG_NODEGROUP,

                constants.TAG_NODE,

                constants.TAG_INSTANCE):

    if not args:

      raise errors.OpPrereqError("no arguments passed to the command",

#: default list of fields for L{ListNetworks}

_LIST_DEF_FIELDS = ["name", "network", "gateway",

def _HandleReservedIPs(ips):

  """

  (network_name, ) = args

  op = opcodes.OpNetworkAdd(network_name=network_name,

                            gateway=opts.gateway,

                            network=opts.network,

                            network6=opts.network6,

                            mac_prefix=opts.mac_prefix,

                            network_type=opts.network_type,

  SubmitOpCode(op, opts=opts)

  fmtoverride = {

    "group_list": (",".join, False),

    "inst_list": (",".join, False),

  }

  return GenericList(constants.QR_NETWORK, desired_fields, args, None,

commands = {

  "add": (

    AddNetwork, ARGS_ONE_NETWORK,

     MAC_PREFIX_OPT, NETWORK_TYPE_OPT, NETWORK6_OPT, GATEWAY6_OPT],

    "<network_name>", "Add a new IP network to the cluster"),

  "list": (

    RemoveNetwork, ARGS_ONE_NETWORK, [FORCE_OPT, DRY_RUN_OPT],

    "[--dry-run] <network_id>",

    "Remove an (empty) network from the cluster"),

}

def Main():

  return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")

def _BuildNetworkHookEnv(name, network, gateway, network6, gateway6,

  env = dict()

  if name:

    env["NETWORK_NAME"] = name

    env["NETWORK_MAC_PREFIX"] = mac_prefix

  if network_type:

    env["NETWORK_TYPE"] = network_type

  return env

    "gateway6": network.gateway6,

    "network_type": network.network_type,

    "mac_prefix": network.mac_prefix,

  }

  return _BuildNetworkHookEnv(**args)

            env["INSTANCE_NIC%d_NETWORK_MAC_PREFIX" % idx] = nobj.mac_prefix

          if nobj.network_type:

            env["INSTANCE_NIC%d_NETWORK_TYPE" % idx] = nobj.network_type

      if mode == constants.NIC_MODE_BRIDGED:

        env["INSTANCE_NIC%d_BRIDGE" % idx] = link

  else:

      self.group_uuid = self.cfg.LookupNodeGroup(self.op.name)

      lock_level = locking.LEVEL_NODEGROUP

      lock_name = self.group_uuid

    else:

      lock_level = None

      lock_name = None

      self.target = self.cfg.GetInstanceInfo(self.op.name)

    elif self.op.kind == constants.TAG_NODEGROUP:

      self.target = self.cfg.GetNodeGroup(self.group_uuid)

    else:

      raise errors.OpPrereqError("Wrong tag type requested (%s)" %

                                 str(self.op.kind), errors.ECODE_INVAL)

    if self.op.mac_prefix:

      utils.NormalizeAndValidateMac(self.op.mac_prefix+":00:00:00")

  def BuildHooksEnv(self):

    """Build hooks env.

      "gateway6": self.op.gateway6,

      "mac_prefix": self.op.mac_prefix,

      "network_type": self.op.network_type,

      }

    return _BuildNetworkHookEnv(**args)

        except errors.AddressPoolError, e:

          raise errors.OpExecError("Cannot reserve IP %s. %s " % (ip, e))

    self.cfg.AddNetwork(nobj, self.proc.GetECId(), check_uuid=False)

    del self.remove_locks[locking.LEVEL_NETWORK]

    self.mac_prefix = self.network.mac_prefix

    self.network6 = self.network.network6

    self.gateway6 = self.network.gateway6

    self.pool = network.AddressPool(self.network)

      "gateway6": self.gateway6,

      "mac_prefix": self.mac_prefix,

      "network_type": self.network_type,

      }

    return _BuildNetworkHookEnv(**args)

TAG_NODEGROUP = "nodegroup"

TAG_NODE = "node"

TAG_INSTANCE = "instance"

VALID_TAG_TYPES = frozenset([

  TAG_CLUSTER,

  TAG_NODEGROUP,

  TAG_NODE,

  TAG_INSTANCE,

  ])

MAX_TAG_LEN = 128

MAX_TAGS_PER_OBJ = 4096

    return True

  """Object representing a network definition for ganeti.

  """

    ("mac_prefix", None, ht.TMaybeString, None),

    ("add_reserved_ips", None,

     ht.TOr(ht.TNone, ht.TListOf(_CheckCIDRAddrNotation)), None),

    ]

class OpNetworkRemove(OpCode):

  """Builds list of fields for network queries.

  """

  fields = [

    (_MakeField(name, title, kind, doc),

     NETQ_CONFIG, 0, _GetItemAttr(name))

  def _GetLength(getter):

    return lambda ctx, network: len(getter(ctx)[network.uuid])

  def CreateNetwork(self, network_name, network, gateway=None, network6=None,

                    gateway6=None, mac_prefix=None, network_type=None,

    """Creates a new network.

    @type name: str

    query = []

    _AppendDryRunIf(query, dry_run)

    body = {

      "network_name": network_name,

      "gateway": gateway,

      "network6": network6,

      "mac_prefix": mac_prefix,

      "network_type": network_type,

      }

    return self._SendRequest(HTTP_POST, "/%s/networks" % GANETI_RAPI_VERSION,

              "mac_prefix", "network_type",

              "free_count", "reserved_count",

              "map", "group_list", "inst_list",

             ] 

G_FIELDS = [