Synnefo » snf-ganeti

from ganeti import query

from ganeti import utils

  FIELDS = query.EXPORT_FIELDS

  #: The node name is not a unique key for this query

    # The following variables interact with _QueryBase._GetNames

    if self.names:

    else:

      self.wanted = locking.ALL_SET

    self.do_locking = self.use_locking

    if self.do_locking:

      lu.needed_locks = {

        locking.LEVEL_NODE: self.wanted,

        }

  REQ_BGL = False

  def CheckArguments(self):

  def ExpandNames(self):

    self.expq.ExpandNames(self)

    self.instance = self.cfg.GetInstanceInfo(instance_name)

    assert self.instance is not None, \

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

  def Exec(self, feedback_fn):

    """Prepares an instance for an export.

      "REMOVE_INSTANCE": str(bool(self.op.remove_instance)),

      }

    return env

    self.instance = self.cfg.GetInstanceInfo(instance_name)

    assert self.instance is not None, \

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

    if (self.op.remove_instance and

        self.instance.admin_state == constants.ADMINST_UP and

                                 " down before", errors.ECODE_STATE)

    if self.op.mode == constants.EXPORT_MODE_LOCAL:

      self.dst_node = self.cfg.GetNodeInfo(self.op.target_node)

      assert self.dst_node is not None

      self._cds = None

      self.dest_disk_info = None

                                    len(self.instance.disks)),

                                   errors.ECODE_INVAL)

      # Check X509 key name

      try:

    if activate_disks:

      # Activate the instance disks if we'exporting a stopped instance

      feedback_fn("Activating disks for %s" % instance.name)

    try:

      helper = masterd.instance.ExportInstanceHelper(self, feedback_fn,

          msg = result.fail_msg

          if msg:

            feedback_fn("Failed to start instance: %s" % msg)

            raise errors.OpExecError("Could not start instance: %s" % msg)

        if self.op.mode == constants.EXPORT_MODE_LOCAL:

    finally:

      if activate_disks:

        feedback_fn("Deactivating disks for %s" % instance.name)

    if not (compat.all(dresults) and fin_resu):

      failures = []

    # Remove instance if requested

    if self.op.remove_instance:

      feedback_fn("Removing instance %s" % instance.name)

    if self.op.mode == constants.EXPORT_MODE_LOCAL:

      self._CleanupExports(feedback_fn)

from ganeti import locking

from ganeti import query

from ganeti import utils

class ResultWithJobs:

    else:

      assert locking.LEVEL_INSTANCE not in self.needed_locks, \

        "_ExpandAndLockInstance called with instance-level locks set"

    self.needed_locks[locking.LEVEL_INSTANCE] = self.op.instance_name

  def _LockInstancesNodes(self, primary_only=False,

    raise NotImplementedError

  """Base for query utility classes.

  """

from ganeti import utils

from ganeti import vcluster

  ResultWithJobs

import ganeti.masterd.instance

  REQ_BGL = False

  def CheckArguments(self):

  def ExpandNames(self):

    self.cq.ExpandNames(self)

    master_params = self.cfg.GetMasterNetworkParameters()

    # Run post hooks on master node before it's removed

    ems = self.cfg.GetUseExternalMipScript()

    result = self.rpc.call_node_deactivate_master_ip(master_params.name,

    return True

  FIELDS = query.CLUSTER_FIELDS

  #: Do not sort (there is only one item)

      locking.LEVEL_NODE: locking.ALL_SET,

      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,

    }

  def Exec(self, feedback_fn):

    """Redistribute the configuration.

    """

    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)

class LUClusterRename(LogicalUnit):

        node_list.remove(master_params.name)

      except ValueError:

        pass

    finally:

      master_params.ip = new_ip

      result = self.rpc.call_node_activate_master_ip(master_params.name,

  def ExpandNames(self):

    if self.op.instances:

      # Not getting the node allocation lock as only a specific set of

      # instances (and their nodes) is going to be acquired

      self.needed_locks = {

      locking.LEVEL_NODEGROUP: locking.ALL_SET,

      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,

    }

  def BuildHooksEnv(self):

    """Build hooks env.

            constants.NDC_DEFAULTS[constants.ND_OOB_PROGRAM]

    if self.op.hv_state:

      self.new_hv_state = dict((hv, cluster.SimpleFillHvState(values))

                               for hv, values in new_hv_state.items())

    if self.op.disk_state:

      self.new_disk_state = \

        dict((storage, dict((name, cluster.SimpleFillDiskState(values))

                            for name, values in svalues.items()))

             for storage, svalues in new_disk_state.items())

    if self.op.ipolicy:

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

      violations = set()

                                             for node in inst.all_nodes)])

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

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

        if new:

          violations.update(new)

        if os_name not in self.new_osp:

          self.new_osp[os_name] = {}

        if not self.new_osp[os_name]:

          # we removed all parameters

          del self.new_osp[os_name]

        else:

          # check the parameter validity (remote check)

    # changes to the hypervisor list

    if self.op.enabled_hypervisors is not None:

          hv_class = hypervisor.GetHypervisorClass(hv_name)

          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)

          hv_class.CheckParameterSyntax(hv_params)

    self._CheckDiskTemplateConsistency()

          new_osp = objects.FillDict(cluster_defaults, hv_params)

          hv_class = hypervisor.GetHypervisorClass(hv_name)

          hv_class.CheckParameterSyntax(new_osp)

    if self.op.default_iallocator:

      alloc_script = utils.FindFile(self.op.default_iallocator,

    if self.op.candidate_pool_size is not None:

      self.cluster.candidate_pool_size = self.op.candidate_pool_size

      # we need to update the pool size here, otherwise the save will fail

    if self.op.maintain_node_health is not None:

      if self.op.maintain_node_health and not constants.ENABLE_CONFD:

  def ExpandNames(self):

    self.needed_locks = dict.fromkeys(locking.LEVELS, locking.ALL_SET)

  def CheckPrereq(self):

    """Check prerequisites.

      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,

      }

  def DeclareLocks(self, level):

    if level == locking.LEVEL_NODE:

      _ErrorIf(vgstatus, constants.CV_ENODELVM, node, vgstatus)

    # Check PVs

    for em in errmsgs:

      self._Error(constants.CV_ENODELVM, node, em)

    if pvminmax is not None:

    cluster = self.cfg.GetClusterInfo()

    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,

                                                            self.group_info)

    _ErrorIf(err, constants.CV_EINSTANCEPOLICY, instance, utils.CommaJoin(err),

             code=self.ETYPE_WARNING)

      # _AnnotateDiskParams makes already copies of the disks

      devonly = []

      for (inst, dev) in disks:

        self.cfg.SetDiskID(anno_disk, nname)

        devonly.append(anno_disk)

    # FIXME: verify OS list

    # File verification

    # do local checksums

    master_node = self.master_node = self.cfg.GetMasterNode()

    # Gather OOB paths

    oob_paths = []

    for node in self.all_node_info.values():

      if path and path not in oob_paths:

        oob_paths.append(path)

  REQ_BGL = False

  def ExpandNames(self):

    self.needed_locks = {

      locking.LEVEL_NODEGROUP: locking.ALL_SET,

      }

  return full_name

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

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

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

  return _ExpandItemName(cfg.ExpandNodeName, name, "Node")

  """Returns a dict declaring all lock levels shared.

  """

  return dict.fromkeys(locking.LEVELS, 1)

  """Checks if the instances in a node group are still correct.

  @type cfg: L{config.ConfigWriter}

  return wanted_instances

  """Returns list of checked and expanded node names.

  @type lu: L{LogicalUnit}

  """

  if nodes:

  return utils.NiceSort(lu.cfg.GetNodeList())

  """Returns list of checked and expanded instance names.

  @type lu: L{LogicalUnit}

  """

  if instances:

  else:

    wanted = utils.NiceSort(lu.cfg.GetInstanceList())

  return wanted

  """Runs the post-hook for an opcode on a single node.

  """

                  node_name, err)

  """Distribute additional files which are part of the cluster configuration.

  ConfigWriter takes care of distributing the config and ssconf files, but

  # Gather file lists

  (files_all, _, files_mc, files_vm) = \

  # Never re-distribute configuration file from here

  assert not (pathutils.CLUSTER_CONF_FILE in files_all or

  # Upload the files

  for (node_list, files) in filemap:

    for fname in files:

  """Compute files external to Ganeti which need to be consistent.

  @type redist: boolean

  return (files_all, files_opt, files_mc, files_vm)

  """Helper for uploading a file and showing warnings.

  """

        lu.LogWarning(msg)

  """Combines the hv state from an opcode with the one of the object

  @param op_input: The input dict from the opcode

  return None

  """Combines the disk state from an opcode with the one of the object

  @param op_input: The input dict from the opcode

  return None

  """OS parameters validation.

  @type lu: L{LogicalUnit}

                 osname, node)

  """Hypervisor parameter validation.

  This function abstract the hypervisor parameter validation to be

    info.Raise("Hypervisor parameter validation failed on node %s" % node)

  """Adjust the candidate pool after node operations.

  """

               (mc_now, mc_max))

  """Check node PVs.

  """

  return None

  """Verifies ipolicy against provided specs.

  @type ipolicy: dict

  return ret + min_errs

  """Compute if instance meets the specs of ipolicy.

  @type ipolicy: dict

  @type cfg: L{config.ConfigWriter}

  @param cfg: Cluster configuration

  @param _compute_fn: The function to verify ipolicy (unittest only)

  """

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

  """

  return frozenset([inst.name for inst in instances

  """Computes a set of any instances that would violate the new ipolicy.

  @param old_ipolicy: The current (still in-place) ipolicy

          _ComputeViolatingInstances(old_ipolicy, instances, cfg))

                      use_default=True, use_none=False):

  """Return the new version of a parameter dictionary.

  return params_copy

  """Return the new version of an instance policy.

  @param group_policy: whether this policy applies to a group and thus

        if group_policy:

          msg = "%s cannot appear in group instance specs" % key

          raise errors.OpPrereqError(msg, errors.ECODE_INVAL)

        utils.ForceDictType(ipolicy[key], constants.ISPECS_PARAMETER_TYPES)

      else:

        # FIXME: we assume all others are lists; this should be redone

  return ipolicy

  """Little helper wrapper to the rpc annotation method.

  @param instance: The instance object

                                cfg.GetInstanceDiskParams(instance))

  """Tells if node supports OOB.

  @type cfg: L{config.ConfigWriter}

  """

  def fn(old, value):

    utils.ForceDictType(new, type_check)

    return new

  return [name for name in nodenames if name not in vm_nodes]

  """Decides on which iallocator to use.

  @type cfg: L{config.ConfigWriter}

  return ialloc

  """Checks if node groups for locked instances are still correct.

  @type cfg: L{config.ConfigWriter}

    assert owned_nodes.issuperset(inst.all_nodes), \

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

    assert cur_group_uuid is None or cur_group_uuid in inst_groups, \

      "Instance %s has no node in group %s" % (name, cur_group_uuid)

  """Checks if the owned node groups are still correct for an instance.

  @type cfg: L{config.ConfigWriter}

  return inst_groups

  """Unpacks the result of change-group and node-evacuate iallocator requests.

  Iallocator modes L{constants.IALLOCATOR_MODE_NODE_EVAC} and

  return op

  """Creates a map from (node, volume) to instance name.

  @type instances: list of L{objects.Instance}

              for vol in vols)

  """Make sure that none of the given paramters is global.

  If a global parameter is found, an L{errors.OpPrereqError} exception is

    raise errors.OpPrereqError(msg, errors.ECODE_INVAL)

  """Whether exclusive_storage is in effect for the given node.

  @type cfg: L{config.ConfigWriter}

  return cfg.GetNdParams(node)[constants.ND_EXCLUSIVE_STORAGE]

  """Ensure that an instance is in one of the required states.

  @param lu: the LU on behalf of which we make the check

                     " is down")

  """Check the sanity of iallocator and node arguments and use the

  cluster-wide iallocator if appropriate.

                                 " iallocator", errors.ECODE_INVAL)

  faulty = []

  for dev in instance.disks:

  return faulty

  """Ensure that a given node is online.

  @param lu: the LU on behalf of which we make the check

from ganeti import query

from ganeti import utils

from ganeti.masterd import iallocator

  ResultWithJobs

import ganeti.masterd.instance

      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)

    if self.op.hv_state:

    else:

      self.new_hv_state = None

    if self.op.disk_state:

    else:

      self.new_disk_state = None

  def ExpandNames(self):

    # These raise errors.OpPrereqError on their own:

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

    # We want to lock all the affected nodes and groups. We have readily

    # available the list of nodes, and the *destination* group. To gather the

            list(previously_split_instances & all_split_instances))

  FIELDS = query.GROUP_FIELDS

  def ExpandNames(self, lu):

  REQ_BGL = False

  def CheckArguments(self):

                          self.op.output_fields, False)

  def ExpandNames(self):

    """Updates and verifies disk parameters.

    """

    utils.ForceDictType(new_params, constants.DISK_DT_TYPES)

    return new_params

    owned_instances = frozenset(self.owned_locks(locking.LEVEL_INSTANCE))

    # Check if locked instances are still correct

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

    cluster = self.cfg.GetClusterInfo()

                               (self.op.group_name, self.group_uuid))

    if self.op.ndparams:

      utils.ForceDictType(new_ndparams, constants.NDS_PARAMETER_TYPES)

      self.new_ndparams = new_ndparams

                                   errors.ECODE_INVAL)

    if self.op.hv_state:

    if self.op.disk_state:

      self.new_disk_state = \

    if self.op.ipolicy:

      new_ipolicy = cluster.SimpleFillIPolicy(self.new_ipolicy)

      inst_filter = lambda inst: inst.name in owned_instances

      instances = self.cfg.GetInstancesInfoByFilter(inst_filter).values()

      gmi = ganeti.masterd.instance

      violations = \

      if violations:

        self.LogWarning("After the ipolicy change the following instances"

                                  utils.CommaJoin(self.req_target_uuids)),

                                 errors.ECODE_INVAL)

    self.needed_locks = {

      locking.LEVEL_INSTANCE: [],

      locking.LEVEL_NODEGROUP: [],

    assert self.group_uuid in owned_groups

    # Check if locked instances are still correct

    # Get instance information

    self.instances = dict(self.cfg.GetMultiInstanceInfo(owned_instances))

    # Check if node groups for locked instances are still correct

    if self.req_target_uuids:

      # User requested specific target groups

                                 (self.op.iallocator, ial.info),

                                 errors.ECODE_NORES)

    self.LogInfo("Iallocator returned %s job(s) for evacuating node group %s",

                 len(jobs), self.op.group_name)

    # Raises errors.OpPrereqError on its own if group can't be found

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

    self.needed_locks = {

      locking.LEVEL_INSTANCE: [],

      locking.LEVEL_NODEGROUP: [],

    assert self.group_uuid in owned_groups

    # Check if locked instances are still correct

    # Get instance information

    self.instances = dict(self.cfg.GetMultiInstanceInfo(owned_instances))

    # Check if node groups for locked instances are still correct

  def Exec(self, feedback_fn):

    """Verify integrity of cluster disks.

    res_instances = set()

    res_missing = {}

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

       if inst.admin_state == constants.ADMINST_UP])

from ganeti.cmdlib.base import NoHooksLU, LogicalUnit, ResultWithJobs

from ganeti.cmdlib.common import INSTANCE_DOWN, \

import ganeti.masterd.instance

#: callbacks

_TApplyContModsCbChanges = \

  ht.TMaybeListOf(ht.TAnd(ht.TIsLength(2), ht.TItems([

def _ComputeIPolicyInstanceSpecViolation(

  ipolicy, instance_spec, disk_template,

  """Compute if instance specs meets the specs of ipolicy.

  @type ipolicy: dict

  @type disk_template: string

  @param disk_template: the disk template of the instance

  @param _compute_fn: The function to verify ipolicy (unittest only)

  """

  mem_size = instance_spec.get(constants.ISPEC_MEM_SIZE, None)

      opcodes.RequireSharedFileStorage()

    ### Node/iallocator related checks

    if self.op.pnode is not None:

      if self.op.disk_template in constants.DTS_INT_MIRROR:

    _CheckOpportunisticLocking(self.op)

    if self.op.mode == constants.INSTANCE_IMPORT:

      # On import force_variant must be True, because if we forced it at

        self.opportunistic_locks[locking.LEVEL_NODE] = True

        self.opportunistic_locks[locking.LEVEL_NODE_RES] = True

    else:

      nodelist = [self.op.pnode]

      if self.op.snode is not None:

        nodelist.append(self.op.snode)

      self.needed_locks[locking.LEVEL_NODE] = nodelist

                                     " requires a source node option",

                                     errors.ECODE_INVAL)

      else:

        if self.needed_locks[locking.LEVEL_NODE] is not locking.ALL_SET:

          self.needed_locks[locking.LEVEL_NODE].append(src_node)

        if not os.path.isabs(src_path):

            utils.PathJoin(pathutils.EXPORT_DIR, src_path)

    self.needed_locks[locking.LEVEL_NODE_RES] = \

  def _RunAllocator(self):

    """Run the allocator based on input opcode.

      env["SRC_PATH"] = self.op.src_path

      env["SRC_IMAGES"] = self.src_images

      name=self.op.instance_name,

      primary_node=self.op.pnode,

      secondary_nodes=self.secondaries,

      minmem=self.be_full[constants.BE_MINMEM],

      maxmem=self.be_full[constants.BE_MAXMEM],

      vcpus=self.be_full[constants.BE_VCPUS],

      disk_template=self.op.disk_template,

      disks=[(d[constants.IDISK_NAME], d[constants.IDISK_SIZE],

              d[constants.IDISK_MODE]) for d in self.disks],

        raise errors.OpPrereqError("No export found for relative path %s" %

                                   src_path, errors.ECODE_INVAL)

    result = self.rpc.call_export_info(src_node, src_path)

    result.Raise("No export or invalid export found in dir %s" % src_path)

    hv_type.CheckParameterSyntax(filled_hvp)

    self.hv_full = filled_hvp

    # check that we don't specify global parameters on an instance

    # fill and remember the beparams dict

    self.be_full = _ComputeFullBeParams(self.op, cluster)

    # disk checks/pre-build

    default_vg = self.cfg.GetVGName()

    if self.op.mode == constants.INSTANCE_IMPORT:

      disk_images = []

    # Release all unneeded node locks

    keep_locks = filter(None, [self.op.pnode, self.op.snode, self.op.src_node])

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

            self.owned_locks(locking.LEVEL_NODE_RES)), \

      if self.op.snode == pnode.name:

        raise errors.OpPrereqError("The secondary node cannot be the"

                                   " primary node", errors.ECODE_INVAL)

      self.secondaries.append(self.op.snode)

      snode = self.cfg.GetNodeInfo(self.op.snode)

      nodes = [pnode]

      if self.op.disk_template in constants.DTS_INT_MIRROR:

        nodes.append(snode)

      if compat.any(map(has_es, nodes)):

        raise errors.OpPrereqError("Disk template %s not supported with"

                                   " exclusive storage" % self.op.disk_template,

        # _CheckRADOSFreeSpace() is just a placeholder.

        # Any function that checks prerequisites can be placed here.

        # Check if there is enough space on the RADOS cluster.

      elif self.op.disk_template == constants.DT_EXT:

        # FIXME: Function that checks prereqs if needed

        pass

      else:

        # Check lv size requirements, if not adopting

    elif self.op.disk_template == constants.DT_PLAIN: # Check the adoption data

      all_lvs = set(["%s/%s" % (disk[constants.IDISK_VG],

             (pnode.group, group_info.name, utils.CommaJoin(res)))

      raise errors.OpPrereqError(msg, errors.ECODE_INVAL)

    # check OS parameters (remotely)

    #TODO: _CheckExtParams (remotely)

    # Check parameters for extstorage

    # memory check on primary node

    #TODO(dynmem): use MINMEM for checking

    if self.op.start:

    self.dry_run_result = list(nodenames)

    # has no disks yet (we are generating them right here).

    node = self.cfg.GetNodeInfo(pnode_name)

    nodegroup = self.cfg.GetNodeGroup(node.group)

    iobj = objects.Instance(name=instance, os=self.op.os_type,

                            primary_node=pnode_name,

    else:

      feedback_fn("* creating instance disks...")

      try:

      except errors.OpExecError:

        self.LogWarning("Device creation failed")

        self.cfg.ReleaseDRBDMinors(instance)

    if self.op.mode == constants.INSTANCE_IMPORT:

      # Release unused nodes

    else:

      # Release all nodes

    disk_abort = False

    if not self.adopt_disks and self.cfg.GetClusterInfo().prealloc_wipe_disks:

      feedback_fn("* wiping instance disks...")

      try:

      except errors.OpExecError, err:

        logging.exception("Wiping disks failed")

        self.LogWarning("Wiping instance disks failed (%s)", err)

      # Something is already wrong with the disks, don't do anything else

      pass

    elif self.op.wait_for_sync:

    elif iobj.disk_template in constants.DTS_INT_MIRROR:

      # make sure the disks are not degraded (still sync-ing is ok)

      feedback_fn("* checking mirrors status")

    else:

      disk_abort = False

    if disk_abort:

      self.cfg.RemoveInstance(iobj.name)

      # Make sure the instance lock gets removed

      self.remove_locks[locking.LEVEL_INSTANCE] = iobj.name

                               " this instance")

    # Release all node resource locks

    if iobj.disk_template != constants.DT_DISKLESS and not self.adopt_disks:

      # we need to set the disks ID to the primary node, since the

    This runs on master, primary and secondary nodes of the instance.

    """

    env["INSTANCE_NEW_NAME"] = self.op.new_name

    return env

    This checks that the instance is in the cluster and is not running.

    """

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

    assert instance is not None

    self.instance = instance

    new_name = self.op.new_name

                   (inst.primary_node, old_file_storage_dir,

                    new_file_storage_dir))

    # update info on disks

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

      for node in inst.all_nodes:

        self.cfg.SetDiskID(disk, node)

               (inst.name, inst.primary_node, msg))

        self.LogWarning(msg)

    finally:

    return inst.name

    elif level == locking.LEVEL_NODE_RES:

      # Copy node locks

      self.needed_locks[locking.LEVEL_NODE_RES] = \

  def BuildHooksEnv(self):

    """Build hooks env.

    This runs on master, primary and secondary nodes of the instance.

    """

    env["SHUTDOWN_TIMEOUT"] = self.op.shutdown_timeout

    return env

                self.owned_locks(locking.LEVEL_NODE)), \

      "Not owning correct locks"

class LUInstanceMove(LogicalUnit):

  def ExpandNames(self):

    self._ExpandAndLockInstance()

    self.op.target_node = target_node

    self.needed_locks[locking.LEVEL_NODE] = [target_node]

    self.needed_locks[locking.LEVEL_NODE_RES] = []

    elif level == locking.LEVEL_NODE_RES:

      # Copy node locks

      self.needed_locks[locking.LEVEL_NODE_RES] = \

  def BuildHooksEnv(self):

    """Build hooks env.

      "TARGET_NODE": self.op.target_node,

      "SHUTDOWN_TIMEOUT": self.op.shutdown_timeout,

      }

    return env

  def BuildHooksNodes(self):

        raise errors.OpPrereqError("Instance disk %d has a complex layout,"

                                   " cannot copy" % idx, errors.ECODE_STATE)

    cluster = self.cfg.GetClusterInfo()

    group_info = self.cfg.GetNodeGroup(node.group)

    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster, group_info)

    if instance.admin_state == constants.ADMINST_UP:

      # check memory requirements on the secondary node