Synnefo » snf-ganeti

import ipaddr

from ganeti import network

  """Logical unit for creating node groups.

  """

  HPATH = "network-add"

  HTYPE = constants.HTYPE_NETWORK

  REQ_BGL = False

  def BuildHooksNodes(self):

    """Build hooks nodes.

    """

    mn = self.cfg.GetMasterNode()

    return ([mn], [mn])

  def ExpandNames(self):

    self.needed_locks = {

      locking.LEVEL_NODE: locking.ALL_SET,

    }

    self.share_locks[locking.LEVEL_NODE] = 1

  def CheckPrereq(self):

    """Check prerequisites.

    This checks that the given group name is not an existing node group

    already.

    """

    if self.op.network is None:

      raise errors.OpPrereqError("Network must be given",

                                 errors.ECODE_INVAL)

    uuid = self.cfg.LookupNetwork(self.op.network_name)

    if uuid:

      raise errors.OpPrereqError("Network '%s' already defined" %

                                 self.op.network, errors.ECODE_EXISTS)

    if (self.op.network_type and

        self.op.network_type not in constants.NETWORK_VALID_TYPES):

      raise errors.OpPrereqError("Invalid network type", errors.ECODE_INVAL)

    self.mac_prefix = None

    if self.op.mac_prefix:

      if self.op.mac_prefix == constants.VALUE_NONE:

        self.mac_prefix = None

      else:

        self.mac_prefix = self.op.mac_prefix

    if self.op.network6:

      ipaddr.IPv6Network(self.op.network6)

    if self.op.gateway6:

      ipaddr.IPv6Address(self.op.gateway6)

  def BuildHooksEnv(self):

    """Build hooks env.

    """

    env = {

      "NETWORK_NAME": self.op.network_name,

      "NETWORK_SUBNET": self.op.network,

      "NETWORK_GATEWAY": self.op.gateway,

      "NETWORK_SUBNET6": self.op.network6,

      "NETWORK_GATEWAY6": self.op.gateway6,

      "NETWORK_MAC_PREFIX": self.mac_prefix,

      "NETWORK_TYPE": self.op.network_type,

      }

    return env

  def Exec(self, feedback_fn):

    """Add the ip pool to the cluster.

    """

    nobj = objects.Network(name=self.op.network_name,

                           network=self.op.network,

                           gateway=self.op.gateway,

                           network6=self.op.network6,

                           gateway6=self.op.gateway6,

                           mac_prefix=self.mac_prefix,

                           network_type=self.op.network_type,

                           family=4)

    # Initialize the associated address pool

    try:

      pool = network.AddressPool.InitializeNetwork(nobj)

    except:

      raise errors.OpExecError("Cannot create IP pool for this network",

                               errors.ECODE_INVAL)

    # Check if we need to reserve the nodes and the cluster master IP

    # These may not be allocated to any instances in routed mode, as

    # they wouldn't function anyway.

    for node in self.cfg.GetAllNodesInfo().values():

      for ip in [node.primary_ip, node.secondary_ip]:

        try:

          pool.Reserve(ip)

          self.LogInfo("Reserved node %s's IP (%s)", node.name, ip)

        except errors.AddressPoolError:

          pass

    master_ip = self.cfg.GetClusterInfo().master_ip

    try:

      pool.Reserve(master_ip)

      self.LogInfo("Reserved cluster master IP (%s)", master_ip)

    except errors.AddressPoolError:

      pass

    if self.op.reserved_ips:

      for ip in self.op.reserved_ips:

        try:

          pool.Reserve(ip, external=True)

        except:

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

                                   errors.ECODE_INVAL)

    self.cfg.AddNetwork(nobj, self.proc.GetECId())

  HPATH = "network-remove"

  HTYPE = constants.HTYPE_NETWORK

  REQ_BGL = False

  def ExpandNames(self):

    self.network_uuid = self.cfg.LookupNetwork(self.op.network_name)

    self.needed_locks = {

      locking.LEVEL_NODE: locking.ALL_SET,

      }

    self.share_locks[locking.LEVEL_NODE] = 1

  def CheckPrereq(self):

    """Check prerequisites.

    This checks that the given network name exists as a network, that is

    empty (i.e., contains no nodes), and that is not the last group of the

    cluster.

    """

    if not self.network_uuid:

      raise errors.OpPrereqError("Network %s not found" % self.op.network_name,

                                 errors.ECODE_INVAL)

    # Verify that the network is not conncted.

    node_groups = [group.name

                   for group in self.cfg.GetAllNodeGroupsInfo().values()

                   for network in group.networks.keys()

                   if network == self.network_uuid]

    if node_groups:

      self.LogWarning("Nework '%s' is connected to the following"

                      " node groups: %s" % (self.op.network_name,

                      utils.CommaJoin(utils.NiceSort(node_groups))))

      raise errors.OpPrereqError("Network still connected",

                                 errors.ECODE_STATE)

  def BuildHooksEnv(self):

    """Build hooks env.

    """

    return {

      "NETWORK_NAME": self.op.network_name,

      }

  def BuildHooksNodes(self):

    """Build hooks nodes.

    """

    mn = self.cfg.GetMasterNode()

    return ([mn], [mn])

  def Exec(self, feedback_fn):

    """Remove the network.

    """

    try:

      self.cfg.RemoveNetwork(self.network_uuid)

    except errors.ConfigurationError:

      raise errors.OpExecError("Network '%s' with UUID %s disappeared" %

                               (self.op.network_name, self.network_uuid))

from ganeti import network

    networks = ["%s %s" % (net.uuid, net.name) for net in

                self._config_data.networks.values()]

    networks_data = fn(utils.NiceSort(networks))

      constants.SS_NETWORKS: networks_data,

  @locking.ssynchronized(_config_lock)

  def AddNetwork(self, net, ec_id):

    """Add a network to the configuration.

    @type net: L{objects.Network}

    @param net: the Network object to add

    @type ec_id: string

    @param ec_id: unique id for the job to use when creating a missing UUID

    """

    self._UnlockedAddNetwork(net, ec_id)

    self._WriteConfig()

  def _UnlockedAddNetwork(self, net, ec_id):

    """Add a network to the configuration.

    """

    logging.info("Adding network %s to configuration", net.name)

    self._EnsureUUID(net, ec_id)

    existing_uuid = self._UnlockedLookupNetwork(net.name)

    if existing_uuid:

      raise errors.OpPrereqError("Desired network name '%s' already"

                                 " exists as a network (UUID: %s)" %

                                 (net.name, existing_uuid),

                                 errors.ECODE_EXISTS)

    net.serial_no = 1

    self._config_data.networks[net.uuid] = net

    self._config_data.cluster.serial_no += 1

  def _UnlockedLookupNetwork(self, target):

    """Lookup a network's UUID.

    @type target: string

    @param target: network name or UUID

    @rtype: string

    @return: network UUID

    @raises errors.OpPrereqError: when the target network cannot be found

    """

    if target in self._config_data.networks:

      return target

    for net in self._config_data.networks.values():

      if net.name == target:

        return net.uuid

    return None

  @locking.ssynchronized(_config_lock, shared=1)

  def LookupNetwork(self, target):

    """Lookup a network's UUID.

    This function is just a wrapper over L{_UnlockedLookupNetwork}.

    @type target: string

    @param target: network name or UUID

    @rtype: string

    @return: network UUID

    """

    return self._UnlockedLookupNetwork(target)

  @locking.ssynchronized(_config_lock)

  def RemoveNetwork(self, network_uuid):

    """Remove a network from the configuration.

    @type network_uuid: string

    @param network_uuid: the UUID of the network to remove

    """

    logging.info("Removing network %s from configuration", network_uuid)

    if network_uuid not in self._config_data.networks:

      raise errors.ConfigurationError("Unknown network '%s'" % network_uuid)

    del self._config_data.networks[network_uuid]

    self._config_data.cluster.serial_no += 1

    self._WriteConfig()