Synnefo » snf-ganeti

      all_instances = self.cfg.GetAllInstancesInfo().values()

      violations = set()

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

        new_ipolicy = objects.FillIPolicy(self.new_ipolicy, group.ipolicy)

        ipol = masterd.instance.CalculateGroupIPolicy(cluster, group)

        new = ComputeNewInstanceViolations(ipol, new_ipolicy, instances,

    for inst in self.my_inst_info.values():

      if inst.disk_template in constants.DTS_INT_MIRROR:

          if self.all_node_info[nuuid].group != self.group_uuid:

            extra_lv_nodes.add(nuuid)

                  utils.CommaJoin(secondary_nodes),

                  code=self.ETYPE_WARNING)

    if any(es_flags.values()):

      if instance.disk_template not in constants.DTS_EXCL_STORAGE:

        # Disk template not compatible with exclusive_storage: no instance

                      " gnt-cluster repair-disk-sizes", idx)

    if instance.disk_template in constants.DTS_INT_MIRROR:

      instance_groups = {}

      for node_uuid in instance_nodes:

                  instance.name, "instance has offline secondary node(s) %s",

                  utils.CommaJoin(self.cfg.GetNodeNames(inst_nodes_offline)))

    # ... or ghost/non-vm_capable nodes

      self._ErrorIf(node_image[node_uuid].ghost, constants.CV_EINSTANCEBADNODE,

                    instance.name, "instance lives on ghost node %s",

                    self.cfg.GetNodeName(node_uuid))

      instdisk[inst_uuid] = {}

    assert compat.all(len(statuses) == len(instanceinfo[inst].disks) and

                      compat.all(isinstance(s, (tuple, list)) and

                                 len(s) == 2 for s in statuses)

                      for inst, nuuids in instdisk.items()

      if instance.admin_state == constants.ADMINST_OFFLINE:

        i_offline += 1

        if nuuid not in node_image:

          gnode = self.NodeImage(uuid=nuuid)

          gnode.ghost = (nuuid not in self.all_node_info)

  be_full = cfg.GetClusterInfo().FillBE(instance)

  mem_size = be_full[constants.BE_MAXMEM]

  cpu_count = be_full[constants.BE_VCPUS]

  if any(es_flags.values()):

    # With exclusive storage use the actual spindles

    try:

  """

  for (uuid, inst) in instances.items():

      "Instance %s's nodes changed while we kept the lock" % inst.name

    inst_groups = CheckInstanceNodeGroups(cfg, uuid, owned_groups)

    self.cfg.AssignGroupNodes(mods)

    """Check for split instances after a node assignment.

    This method considers a series of node assignments as an atomic operation,

      if inst.disk_template not in constants.DTS_INT_MIRROR:

        continue

      if len(set(node_data[node_uuid].group

        previously_split_instances.add(inst.uuid)

      if len(set(changed_nodes.get(node_uuid, node_data[node_uuid].group)

        all_split_instances.add(inst.uuid)

    return (list(all_split_instances - previously_split_instances),

                                            False, self.op.reason)

      result.Raise("Could not start instance")

class LUInstanceRename(LogicalUnit):

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

    # update info on disks

    info = GetInstanceInfoText(renamed_inst)

    for (idx, disk) in enumerate(renamed_inst.disks):

        result = self.rpc.call_blockdev_setinfo(node_uuid,

                                                (disk, renamed_inst), info)

        result.Warn("Error setting info on node %s for disk %s" %

    """

    nl = [self.cfg.GetMasterNode()]

    return (nl, nl_post)

  def CheckPrereq(self):

    assert (self.owned_locks(locking.LEVEL_NODE) ==

            self.owned_locks(locking.LEVEL_NODE_RES))

                self.owned_locks(locking.LEVEL_NODE)), \

      "Not owning correct locks"

    """Build hooks nodes.

    """

    return (nl, nl)

  def _PrepareNicModification(self, params, private, old_ip, old_net_uuid,

    """

    self.diskparams = self.cfg.GetInstanceDiskParams(self.instance)

    excl_stor = compat.any(

      )

    # Check disk modifications. This is done here and not in CheckArguments

                                   errors.ECODE_STATE)

    assert pnode_uuid in self.owned_locks(locking.LEVEL_NODE)

    pnode_info = self.cfg.GetNodeInfo(pnode_uuid)

    #_CheckInstanceNodeGroups(self.cfg, self.op.instance_name, owned_groups)

        hvspecs = [(self.instance.hypervisor,

                    self.cfg.GetClusterInfo()

                      .hvparams[self.instance.hypervisor])]

                                max_requested_cpu + 1,

                                hvspecs)

    if self.op.disk_template:

      if __debug__:

        if self.op.remote_node_uuid:

          check_nodes.add(self.op.remote_node_uuid)

        for level in [locking.LEVEL_NODE, locking.LEVEL_NODE_RES]:

    self.instance = self.cfg.GetInstanceInfo(self.op.instance_uuid)

    # Check if node groups for locked instance are still correct

      ("Instance %s's nodes changed while we kept the lock" %

       self.op.instance_name)

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

      filled_hvp.update(self.op.hvparams)

      hv_type = hypervisor.GetHypervisorClass(self.instance.hypervisor)

      hv_type.CheckParameterSyntax(filled_hvp)

    CheckInstanceState(self, self.instance, INSTANCE_ONLINE)

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

  def _MergeValidateOsParams(self, instance):

    "Handle the OS parameter merging and validation for the target instance."

    self.op.osparams = self.op.osparams or {}

    self.op.osparams_private = self.op.osparams_private or {}

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

    cluster = self.cfg.GetClusterInfo()

    nodes = dict(self.cfg.GetMultiNodeInfo(node_uuids))

    groups = dict(self.cfg.GetMultiNodeGroupInfo(node.group

  info = GetInstanceInfoText(instance)

  if target_node_uuid is None:

    pnode_uuid = instance.primary_node

  else:

    pnode_uuid = target_node_uuid

    all_node_uuids = [pnode_uuid]

    ial.Run(self.op.iallocator)

    if not ial.success:

      raise errors.OpPrereqError("Can't compute nodes using iallocator '%s':"

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

    assert instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    if self.op.node_uuids:

        raise errors.OpPrereqError("Instance %s currently has %d nodes, but"

                                   " %d replacement nodes were specified" %

                                    len(self.op.node_uuids)),

                                   errors.ECODE_INVAL)

      assert instance.disk_template != constants.DT_DRBD8 or \

    if self.op.node_uuids:

      node_uuids = self.op.node_uuids

    else:

    excl_stor = compat.any(

      rpc.GetExclusiveStorageForNodes(self.cfg, node_uuids).values()

      )

    # All touched nodes must be locked

    mylocks = self.owned_locks(locking.LEVEL_NODE)

    new_disks = CreateDisks(self, self.instance, to_skip=to_skip)

    # TODO: Release node locks before wiping, or explain why it's not possible

    """Build hooks nodes.

    """

    return (nl, nl)

  def CheckPrereq(self):

    self.instance = self.cfg.GetInstanceInfo(self.op.instance_uuid)

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    for node_uuid in node_uuids:

      CheckNodeOnline(self, node_uuid)

    self.node_es_flags = rpc.GetExclusiveStorageForNodes(self.cfg, node_uuids)

                 utils.FormatUnit(self.target, "h")))

    # First run all grow ops in dry-run mode

      result = self.rpc.call_blockdev_grow(node_uuid,

                                           (self.disk, self.instance),

                                           self.delta, True, True,

    # We know that (as far as we can test) operations across different

    # nodes will succeed, time to run it for real on the backing storage

      result = self.rpc.call_blockdev_grow(node_uuid,

                                           (self.disk, self.instance),

                                           self.delta, False, True,

    @return: True if they are activated, False otherwise

    """

    for idx, dev in enumerate(instance.disks):

      for node_uuid in node_uuids:

    """

    return (instance.disk_template in constants.DTS_INT_MIRROR and

  def ExpandNames(self):

    if self.lock_all:

  """

class LUNodeEvacuate(NoHooksLU):

                                 " node is required", errors.ECODE_INVAL)

    for _, instance in self.cfg.GetAllInstancesInfo().items():

        raise errors.OpPrereqError("Instance %s is still running on the node,"

                                   " please remove first" % instance.name,

                                   errors.ECODE_INVAL)

    for inst in _GetNodeInstances(self.cfg, self.op.node_uuid):

      if not inst.disks_active:

        continue

      check_nodes.discard(self.op.node_uuid)

      for inst_node_uuid in check_nodes:

        self._CheckFaultyDisks(inst, inst_node_uuid)

    if primary_only:

      nodes = [instance.primary_node]

    else:

    return frozenset(self._UnlockedGetNodeInfo(node_uuid).group

                     for node_uuid in nodes)

    if primary_only:

      nodes_fn = lambda inst: [inst.primary_node]

    else:

    return frozenset(inst.uuid

                     for inst in self._config_data.instances.values()

    "serial_no",

    ] + _TIMESTAMPS + _UUID

  def MapLVsByNode(self, lvmap=None, devs=None, node_uuid=None):

    """Provide a mapping of nodes to LVs this instance owns.

      constants.ND_EXCLUSIVE_STORAGE: self.excl_stor,

      }

class TestComputeIPolicyInstanceViolation(unittest.TestCase):

  def test(self):

    disks = [objects.Disk(size=512, spindles=13)]

    cfg = _FakeConfigForComputeIPolicyInstanceViolation(beparams, False)

    instance = objects.Instance(beparams=beparams, disks=disks, nics=[],

                                disk_template=constants.DT_PLAIN)

    stub = _StubComputeIPolicySpecViolation(2048, 2, 1, 0, [512], 4,

                                            constants.DT_PLAIN)

                                                 cfg, _compute_fn=stub)

    self.assertEqual(ret, [])

    instance2 = objects.Instance(beparams={}, disks=disks, nics=[],

                                 disk_template=constants.DT_PLAIN)

    ret = common.ComputeIPolicyInstanceViolation(NotImplemented, instance2,

                                                 cfg, _compute_fn=stub)