Synnefo » snf-ganeti

import shutil

import itertools

import operator

from ganeti import ssh

from ganeti import utils

  """Wrapper over L{_ExpandItemName} for instance."""

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

                         network_type, mac_prefix, tags):

  env = dict()

  if name:

    env["NETWORK_NAME"] = name

  if gateway:

    env["NETWORK_GATEWAY"] = gateway

  if network6:

  return env

  args = {

  }

def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,

  }

  if nics:

    nic_count = len(nics)

      if ip is None:

        ip = ""

      env["INSTANCE_NIC%d_IP" % idx] = ip

      env["INSTANCE_NIC%d_MODE" % idx] = mode

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

      if network:

        if netinfo:

          nobj = objects.Network.FromDict(netinfo)

          if nobj.network:

  return env

def _NICToTuple(lu, nic):

  """Build a tupple of nic information.

  @param nic: nic to convert to hooks tuple

  """

  ip = nic.ip

  mac = nic.mac

  filled_params = cluster.SimpleFillNIC(nic.nicparams)

  mode = filled_params[constants.NIC_MODE]

  link = filled_params[constants.NIC_LINK]

  netinfo = None

    if net_uuid:

      nobj = lu.cfg.GetNetwork(net_uuid)

      netinfo = objects.Network.ToDict(nobj)

def _NICListToTuple(lu, nics):

  """Build a list of nic information tuples.

  """

  hooks_nics = []

  for nic in nics:

    hooks_nics.append(_NICToTuple(lu, nic))

  return hooks_nics

def _BuildInstanceHookEnvByObject(lu, instance, override=None):

  """Builds instance related env variables for hooks from an object.

  """

  nics = []

    nic_mode_req = nic.get(constants.INIC_MODE, None)

    nic_mode = nic_mode_req

    if nic_mode is None or nic_mode == constants.VALUE_AUTO:

                     (idx, netparams.values()))

        nic.nicparams = dict(netparams)

        if nic.ip is not None:

          if nic.ip.lower() == constants.NIC_IP_POOL:

            try:

              nic.ip = self.cfg.GenerateIp(net, self.proc.GetECId())

                                         errors.ECODE_NOTUNIQUE)

        elif new_ip.lower() == constants.NIC_IP_POOL:

          raise errors.OpPrereqError("ip=pool, but no network found",

        else:

          # new net is None

          if self.op.conflicts_check:

                                   nic.nicparams, cluster, pnode)

      return None

      ip = params.ip

      net = params.network

      if net is not None and ip is not None:

    """

    mac = params[constants.INIC_MAC]

    ip = params.get(constants.INIC_IP, None)

    #TODO: not private.filled?? can a nic have no nicparams??

    nicparams = private.filled

      ("nic.%d" % idx,

       "add:mac=%s,ip=%s,mode=%s,link=%s,network=%s" %

       (mac, ip, private.filled[constants.NIC_MODE],

       private.filled[constants.NIC_LINK],

      ])

  @staticmethod

    """

    args = {

      "name": self.op.network_name,

      "gateway": self.op.gateway,

      "network6": self.op.network6,

      "gateway6": self.op.gateway6,

      "network_type": self.op.network_type,

      "tags": self.op.tags,

      }

  def Exec(self, feedback_fn):

    """Add the ip pool to the cluster.

    # Verify that the network is not conncted.

    node_groups = [group.name

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

    if node_groups:

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

    """

    args = {

      "name": self.op.network_name,

      "gateway": self.gateway,

      "network6": self.network6,

      "gateway6": self.gateway6,

      "network_type": self.network_type,

      "tags": self.tags,

      }

  def BuildHooksNodes(self):

    """Build hooks nodes.

    do_instances = query.NETQ_INST in self.requested_data

    do_groups = do_instances or (query.NETQ_GROUP in self.requested_data)

    do_stats = query.NETQ_STATS in self.requested_data

    network_to_groups = None

    network_to_instances = None

    if do_groups:

      all_groups = lu.cfg.GetAllNodeGroupsInfo()

      network_to_groups = dict((uuid, []) for uuid in self.wanted)

      if do_instances:

        all_instances = lu.cfg.GetAllInstancesInfo()

    ret["GROUP_NAME"] = self.group_name

    ret["GROUP_NETWORK_MODE"] = self.network_mode

    ret["GROUP_NETWORK_LINK"] = self.network_link

    return ret

  def BuildHooksNodes(self):

      instances = [(instance.name, idx, nic.ip)

                   for instance in groupinstances

                   for idx, nic in enumerate(instance.nics)

      if instances:

        self.LogWarning("Following occurences use IPs from network %s"

                        " that is about to connect to nodegroup %s: %s" %

  def BuildHooksEnv(self):

    ret = dict()

    ret["GROUP_NAME"] = self.group_name

    return ret

  def BuildHooksNodes(self):

  @param node: node name

  """

  if conf_net is not None:

    raise errors.OpPrereqError("Conflicting IP found:"

                               " %s <> %s." % (ip, conf_net),