Synnefo » snf-ganeti

  LoadNodeEvacResult, CheckIAllocatorOrNode, CheckParamsNotGlobal, \

  IsExclusiveStorageEnabledNode, CheckHVParams, CheckOSParams, \

  AnnotateDiskParams, GetUpdatedParams, ExpandInstanceName, \

from ganeti.cmdlib.instance_storage import CreateDisks, \

  CheckNodesFreeDiskPerVG, WipeDisks, WipeOrCleanupDisks, WaitForSync, \

  CheckRADOSFreeSpace, ComputeDiskSizePerVG, GenerateDiskTemplate, \

  StartInstanceDisks, ShutdownInstanceDisks, AssembleInstanceDisks, \

  CheckSpindlesExclusiveStorage

                               errors.ECODE_INVAL)

  """Wrapper around IAReqInstanceAlloc.

  @param op: The instance opcode

  @param disks: The computed disks

  @param nics: The computed nics

  @param beparams: The full filled beparams

    allocator (unless the node is already marked offline)

  @returns: A filled L{iallocator.IAReqInstanceAlloc}

                                       disks=disks,

                                       nics=[n.ToDict() for n in nics],

                                       hypervisor=op.hypervisor,

def _ComputeFullBeParams(op, cluster):

  return nics

  """In case of conflicting IP address raise error.

  @type ip: string

  @param ip: IP address

  """

  if conf_net is not None:

    raise errors.OpPrereqError(("The requested IP address (%s) belongs to"

                                " network %s, but the target NIC does not." %

        self.opportunistic_locks[locking.LEVEL_NODE] = True

        self.opportunistic_locks[locking.LEVEL_NODE_RES] = True

    else:

      if self.op.snode is not None:

      self.needed_locks[locking.LEVEL_NODE] = nodelist

    # in case of import lock the source node too

                                     " requires a source node option",

                                     errors.ECODE_INVAL)

      else:

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

        if not os.path.isabs(src_path):

          self.op.src_path = src_path = \

            utils.PathJoin(pathutils.EXPORT_DIR, src_path)

    #     in a nodegroup that has the desired network connected to

    req = _CreateInstanceAllocRequest(self.op, self.disks,

                                      self.nics, self.be_full,

    ial = iallocator.IAllocator(self.cfg, self.rpc, req)

    ial.Run(self.op.iallocator)

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

                                 ecode)

    self.LogInfo("Selected nodes for instance %s via iallocator %s: %s",

                 self.op.instance_name, self.op.iallocator,

                 utils.CommaJoin(ial.result))

    assert req.RequiredNodes() in (1, 2), "Wrong node count from iallocator"

    if req.RequiredNodes() == 2:

  def BuildHooksEnv(self):

    """Build hooks env.

    env.update(BuildInstanceHookEnv(

      name=self.op.instance_name,

      status=self.op.start,

      os_type=self.op.os_type,

      minmem=self.be_full[constants.BE_MINMEM],

    """Build hooks nodes.

    """

    return nl, nl

  def _ReadExportInfo(self):

    """

    assert self.op.mode == constants.INSTANCE_IMPORT

    src_path = self.op.src_path

      locked_nodes = self.owned_locks(locking.LEVEL_NODE)

      exp_list = self.rpc.call_export_list(locked_nodes)

      found = False

          continue

        if src_path in exp_list[node].payload:

          found = True

          self.op.src_path = src_path = utils.PathJoin(pathutils.EXPORT_DIR,

                                                       src_path)

          break

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

                                   src_path, errors.ECODE_INVAL)

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

    export_info = objects.SerializableConfigParser.Loads(str(result.payload))

                                   errors.ECODE_ENVIRON)

    ei_version = export_info.get(constants.INISECT_EXP, "version")

      raise errors.OpPrereqError("Wrong export version %s (wanted %d)" %

                                 (ei_version, constants.EXPORT_VERSION),

                                 errors.ECODE_ENVIRON)

      self._RunAllocator()

    # Release all unneeded node locks

    ReleaseLocks(self, locking.LEVEL_NODE, keep=keep_locks)

    ReleaseLocks(self, locking.LEVEL_NODE_RES, keep=keep_locks)

    ReleaseLocks(self, locking.LEVEL_NODE_ALLOC)

    #### node related checks

    # check primary node

    assert self.pnode is not None, \

    if pnode.offline:

      raise errors.OpPrereqError("Cannot use offline primary node '%s'" %

                                 pnode.name, errors.ECODE_STATE)

      net_uuid = nic.network

      if net_uuid is not None:

        nobj = self.cfg.GetNetwork(net_uuid)

        if netparams is None:

          raise errors.OpPrereqError("No netparams found for network"

                                     " %s. Propably not connected to"

      # net is None, ip None or given

      elif self.op.conflicts_check:

    # mirror node verification

    if self.op.disk_template in constants.DTS_INT_MIRROR:

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

                                   " primary node", errors.ECODE_INVAL)

      if pnode.group != snode.group:

        self.LogWarning("The primary and secondary nodes are in two"

                        " different node groups; the disk parameters"

    for disk in self.disks:

      CheckSpindlesExclusiveStorage(disk, excl_stor, True)

    if not self.adopt_disks:

      if self.op.disk_template == constants.DT_RBD:

      elif self.op.disk_template in utils.GetLvmDiskTemplates():

        # Check lv size requirements, if not adopting

        req_sizes = ComputeDiskSizePerVG(self.op.disk_template, self.disks)

      else:

        # FIXME: add checks for other, non-adopting, non-lvm disk templates

        pass

          raise errors.OpPrereqError("LV named %s used by another instance" %

                                     lv_name, errors.ECODE_NOTUNIQUE)

      vg_names.Raise("Cannot get VG information from node %s" % pnode.name)

      node_lvs.Raise("Cannot get LV information from node %s" % pnode.name)

      node_lvs = node_lvs.payload

                                    constants.ADOPTABLE_BLOCKDEV_ROOT),

                                   errors.ECODE_INVAL)

      node_disks.Raise("Cannot get block device information from node %s" %

                       pnode.name)

      node_disks = node_disks.payload

             (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

    if self.op.start:

      hvfull = objects.FillDict(cluster.hvparams.get(self.op.hypervisor, {}),

                                self.op.hvparams)

                          "creating instance %s" % self.op.instance_name,

                          self.be_full[constants.BE_MAXMEM],

                          self.op.hypervisor, hvfull)

  def Exec(self, feedback_fn):

    """Create and add the instance to the cluster.

    # This is ugly but we got a chicken-egg problem here

    # We can only take the group disk parameters, as the instance

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

    disks = GenerateDiskTemplate(self,

                                 self.op.disk_template,

                                 self.secondaries,

                                 self.disks,

                                 self.instance_file_storage_dir,

                                 self.cfg.GetGroupDiskParams(nodegroup))

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

                            nics=self.nics, disks=disks,

                            disk_template=self.op.disk_template,

                            disks_active=False,

        for t_dsk, a_dsk in zip(tmp_disks, self.disks):

          rename_to.append(t_dsk.logical_id)

          t_dsk.logical_id = (t_dsk.logical_id[0], a_dsk[constants.IDISK_ADOPT])

                                               zip(tmp_disks, rename_to))

        result.Raise("Failed to rename adoped LVs")

    else:

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

      # Release unused nodes

    else:

      # Release all nodes

      ReleaseLocks(self, locking.LEVEL_NODE)

      # preceding code might or might have not done it, depending on

      # disk template and other options

      for disk in iobj.disks:

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

        if not self.op.no_install:

          pause_sync = (iobj.disk_template in constants.DTS_INT_MIRROR and

                        not self.op.wait_for_sync)

          if pause_sync:

            feedback_fn("* pausing disk sync to install instance OS")

                                                              (iobj.disks,

                                                               iobj), True)

            for idx, success in enumerate(result.payload):

          feedback_fn("* running the instance OS create scripts...")

          # FIXME: pass debug option from opcode to backend

          os_add_result = \

                                          self.op.debug_level)

          if pause_sync:

            feedback_fn("* resuming disk sync")

                                                              (iobj.disks,

                                                               iobj), False)

            for idx, success in enumerate(result.payload):

          import_result = \

            masterd.instance.TransferInstanceData(self, feedback_fn,

                                                  self.pnode.secondary_ip,

                                                  iobj, transfers)

          if not compat.all(import_result):

                             self.op.source_shutdown_timeout)

          timeouts = masterd.instance.ImportExportTimeouts(connect_timeout)

          disk_results = \

            masterd.instance.RemoteImport(self, feedback_fn, iobj, self.pnode,

                                          self.source_x509_ca,

        # Run rename script on newly imported instance

        assert iobj.name == instance

        feedback_fn("Running rename script for %s" % instance)

                                                   rename_from,

                                                   self.op.debug_level)

        result.Warn("Failed to run rename script for %s on node %s" %

      self.cfg.Update(iobj, feedback_fn)

      logging.info("Starting instance %s on node %s", instance, pnode_name)

      feedback_fn("* starting instance...")

                                            False, self.op.reason)

      result.Raise("Could not start instance")

                                                     new_file_storage_dir)

      result.Raise("Could not rename on node %s directory '%s' to '%s'"

                   " (but the instance has been renamed in Ganeti)" %

    StartInstanceDisks(self, inst, None)

    # update info on disks

    info = GetInstanceInfoText(inst)

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

    try:

      result = self.rpc.call_instance_run_rename(inst.primary_node, inst,

                                                 old_name, self.op.debug_level)

      result.Warn("Could not run OS rename script for instance %s on node %s"

                  " (but the instance has been renamed in Ganeti)" %

    finally:

      ShutdownInstanceDisks(self, inst)

    """

    instance = self.instance

    logging.info("Shutting down instance %s on node %s",

    result = self.rpc.call_instance_shutdown(instance.primary_node, instance,

                                             self.op.shutdown_timeout,

      result.Warn("Warning: can't shutdown instance", feedback_fn)

    else:

      result.Raise("Could not shutdown instance %s on node %s" %

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

            self.owned_locks(locking.LEVEL_NODE_RES))

  def ExpandNames(self):

    self._ExpandAndLockInstance()

    self.needed_locks[locking.LEVEL_NODE_RES] = []

    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND

    nl = [

      self.cfg.GetMasterNode(),

      self.instance.primary_node,

      ]

    return (nl, nl)

      raise errors.OpPrereqError("Disk template %s not suitable for copying" %

                                 instance.disk_template, errors.ECODE_STATE)

      "Cannot retrieve locked node %s" % self.op.target_node

      raise errors.OpPrereqError("Instance %s is already on the node %s" %

                                 errors.ECODE_STATE)

    bep = self.cfg.GetClusterInfo().FillBE(instance)

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

                                   " cannot copy" % idx, errors.ECODE_STATE)

    cluster = self.cfg.GetClusterInfo()

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

                           ignore=self.op.ignore_ipolicy)

    if instance.admin_state == constants.ADMINST_UP:

      # check memory requirements on the secondary node

      CheckNodeFreeMemory(

          instance.name, bep[constants.BE_MAXMEM], instance.hypervisor,

          self.cfg.GetClusterInfo().hvparams[instance.hypervisor])

    else:

                   " instance will not be started")

    # check bridge existance

  def Exec(self, feedback_fn):

    """Move an instance.

    """

    instance = self.instance

    self.LogInfo("Shutting down instance %s on source node %s",

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

            self.owned_locks(locking.LEVEL_NODE_RES))

                                             self.op.shutdown_timeout,

                                             self.op.reason)

    if self.op.ignore_consistency:

      result.Warn("Could not shutdown instance %s on node %s. Proceeding"

                  " anyway. Please make sure node %s is down. Error details" %

    else:

      result.Raise("Could not shutdown instance %s on node %s" %

    # create the target disks

    try:

    except errors.OpExecError:

      self.LogWarning("Device creation failed")

      self.cfg.ReleaseDRBDMinors(instance.name)

    # activate, get path, copy the data over

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

      self.LogInfo("Copying data for disk %d", idx)

      if result.fail_msg:

        self.LogWarning("Can't assemble newly created disk %d: %s",

                        idx, result.fail_msg)

        errs.append(result.fail_msg)

        break

      dev_path = result.payload

                                             cluster_name)

      if result.fail_msg:

        self.LogWarning("Can't copy data over for disk %d: %s",

    if errs:

      self.LogWarning("Some disks failed to copy, aborting")

      try:

      finally:

        self.cfg.ReleaseDRBDMinors(instance.name)

        raise errors.OpExecError("Errors during disk copy: %s" %

                                 (",".join(errs),))

    self.cfg.Update(instance, feedback_fn)

    self.LogInfo("Removing the disks on the original node")

    # Only start the instance if it's marked as up

    if instance.admin_state == constants.ADMINST_UP:

      self.LogInfo("Starting instance %s on node %s",

      disks_ok, _ = AssembleInstanceDisks(self, instance,

                                          ignore_secondaries=True)

        ShutdownInstanceDisks(self, instance)

        raise errors.OpExecError("Can't activate the instance's disks")

                                            (instance, None, None), False,

                                            self.op.reason)

      msg = result.fail_msg

      if msg:

        ShutdownInstanceDisks(self, instance)

        raise errors.OpExecError("Could not start instance %s on node %s: %s" %

class LUInstanceMultiAlloc(NoHooksLU):

    else:

      nodeslist = []

      for inst in self.op.instances:

        nodeslist.append(inst.pnode)

        if inst.snode is not None:

          nodeslist.append(inst.snode)

      self.needed_locks[locking.LEVEL_NODE] = nodeslist

    if self.op.opportunistic_locking:

      # Only consider nodes for which a lock is held

    else:

      node_whitelist = None

    (allocatable, failed) = self.ia_result

    jobs = []

      op = op2inst.pop(name)

      jobs.append([op])

  return [(op, idx, params, fn()) for (op, idx, params) in mods]

  """Checks if nodes have enough physical CPUs

  This function checks if all given nodes have the needed number of

  @type lu: C{LogicalUnit}

  @param lu: a logical unit from which we get configuration data

  @type requested: C{int}

  @param requested: the minimum acceptable number of physical CPUs

  @type hypervisor_specs: list of pairs (string, dict of strings)

      or we cannot check the node

  """

               prereq=True, ecode=errors.ECODE_ENVIRON)

    (_, _, (hv_info, )) = info.payload

    num_cpus = hv_info.get("cpu_total", None)

    if not isinstance(num_cpus, int):

      raise errors.OpPrereqError("Can't compute the number of physical CPUs"

                                 " on node %s, result was '%s'" %

    if requested > num_cpus:

      raise errors.OpPrereqError("Node %s has %s physical CPUs, but %s are "

                                 errors.ECODE_NORES)

                    self._VerifyNicModification)

    if self.op.pnode:

  def ExpandNames(self):

    self._ExpandAndLockInstance()

    elif level == locking.LEVEL_NODE:

      self._LockInstancesNodes()

      if self.op.disk_template and self.op.remote_node:

    elif level == locking.LEVEL_NODE_RES and self.op.disk_template:

      # Copy node locks

      self.needed_locks[locking.LEVEL_NODE_RES] = \

    return (nl, nl)

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

    update_params_dict = dict([(key, params[key])

                               for key in constants.NICS_PARAMETERS

      old_net_obj = self.cfg.GetNetwork(old_net_uuid)

    if new_net_uuid:

      if not netparams:

        raise errors.OpPrereqError("No netparams found for the network"

                                   " %s, probably not connected" %

    new_mode = new_filled_params[constants.NIC_MODE]

    if new_mode == constants.NIC_MODE_BRIDGED:

      bridge = new_filled_params[constants.NIC_LINK]

      if msg:

        if self.op.force:

          self.warn.append(msg)

        else:

                                       errors.ECODE_NOTUNIQUE)

        # new network is None so check if new IP is a conflicting IP

        elif self.op.conflicts_check:

      # release old IP if old network is not None

      if old_ip and old_net_uuid:

    """CheckPrereq checks related to a new disk template."""

    # Arguments are passed to avoid configuration lookups

    instance = self.instance

    cluster = self.cluster

    if instance.disk_template == self.op.disk_template:

      raise errors.OpPrereqError("Instance already has disk template %s" %

    CheckInstanceState(self, instance, INSTANCE_DOWN,

                       msg="cannot change disk template")

    if self.op.disk_template in constants.DTS_INT_MIRROR:

        raise errors.OpPrereqError("Given new secondary node %s is the same"

                                   " as the primary node of the instance" %

                                   self.op.remote_node, errors.ECODE_STATE)

      # FIXME: here we assume that the old instance type is DT_PLAIN

      assert instance.disk_template == constants.DT_PLAIN

      disks = [{constants.IDISK_SIZE: d.size,

                constants.IDISK_VG: d.logical_id[0]}

               for d in instance.disks]

      required = ComputeDiskSizePerVG(self.op.disk_template, disks)

      snode_group = self.cfg.GetNodeGroup(snode_info.group)

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

                                                              snode_group)

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

    excl_stor = compat.any(

      )

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

    assert self.instance is not None, \

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

    self.warn = []

        not self.op.force):

      # verify that the instance is not up

      instance_info = self.rpc.call_instance_info(

      if instance_info.fail_msg:

        self.warn.append("Can't get instance runtime information: %s" %

                         instance_info.fail_msg)

      elif instance_info.payload:

                                   errors.ECODE_STATE)

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

    assert pnode_info.group in self.owned_locks(locking.LEVEL_NODEGROUP)

      # local check

      hypervisor.GetHypervisorClass(hv_type).CheckParameterSyntax(hv_new)

      self.hv_proposed = self.hv_new = hv_new # the new actual values

      self.hv_inst = i_hvdict # the new dict (without defaults)

    else:

    # osparams processing

    if self.op.osparams:

      i_osdict = GetUpdatedParams(instance.osparams, self.op.osparams)

      self.os_inst = i_osdict # the new dict (without defaults)

    else:

      self.os_inst = {}

    #TODO(dynmem): do the appropriate check involving MINMEM

    if (constants.BE_MAXMEM in self.op.beparams and not self.op.force and

        be_new[constants.BE_MAXMEM] > be_old[constants.BE_MAXMEM]):

      if be_new[constants.BE_AUTO_BALANCE]:

        # either we changed auto_balance to yes or it was from before

        mem_check_list.extend(instance.secondary_nodes)

      instance_info = self.rpc.call_instance_info(

      hvspecs = [(instance.hypervisor, cluster.hvparams[instance.hypervisor])]

      nodeinfo = self.rpc.call_node_info(mem_check_list, None,

                                         hvspecs, False)

      msg = pninfo.fail_msg

      if msg:

        # Assume the primary node is unreachable and go ahead

        self.warn.append("Can't get info from primary node %s: %s" %

      else:

        (_, _, (pnhvinfo, )) = pninfo.payload

        if not isinstance(pnhvinfo.get("memory_free", None), int):

          self.warn.append("Node data from primary node %s doesn't contain"

        elif instance_info.fail_msg:

          self.warn.append("Can't get instance runtime information: %s" %

                           instance_info.fail_msg)

                                       miss_mem, errors.ECODE_NORES)

      if be_new[constants.BE_AUTO_BALANCE]:

            continue

          (_, _, (nhvinfo, )) = nres.payload

          if not isinstance(nhvinfo.get("memory_free", None), int):

            raise errors.OpPrereqError("Secondary node %s didn't return free"

                                       errors.ECODE_STATE)

          #TODO(dynmem): do the appropriate check involving MINMEM

          elif be_new[constants.BE_MAXMEM] > nhvinfo["memory_free"]:

            raise errors.OpPrereqError("This change will prevent the instance"

                                       " from failover to its secondary node"

                                       errors.ECODE_STATE)

    if self.op.runtime_mem:

      remote_info = self.rpc.call_instance_info(

         instance.primary_node, instance.name, instance.hypervisor,

         instance.hvparams)

      if not remote_info.payload: # not running already

        raise errors.OpPrereqError("Instance %s is not running" %

                                   instance.name, errors.ECODE_STATE)

    def _PrepareNicCreate(_, params, private):

      self._PrepareNicModification(params, private, None, None,

      return (None, None)

    def _PrepareNicMod(_, nic, params, private):

      self._PrepareNicModification(params, private, nic.ip, nic.network,

      return None

    def _PrepareNicRemove(_, params, __):

    """

    feedback_fn("Converting template to drbd")

    instance = self.instance

    assert instance.disk_template == constants.DT_PLAIN

                  constants.IDISK_NAME: d.name}

                 for d in instance.disks]

    new_disks = GenerateDiskTemplate(self, self.op.disk_template,

                                     disk_info, None, None, 0, feedback_fn,

                                     self.diskparams)

    anno_disks = rpc.AnnotateDiskParams(constants.DT_DRBD8, new_disks,

                                        self.diskparams)

    info = GetInstanceInfoText(instance)

    feedback_fn("Creating additional volumes...")

    # first, create the missing data and meta devices

    for disk in anno_disks:

      # unfortunately this is... not too nice

                           info, True, p_excl_stor)

      for child in disk.children:

                             s_excl_stor)

    # at this stage, all new LVs have been created, we can rename the

    # old ones

    feedback_fn("Renaming original volumes...")

    rename_list = [(o, n.children[0].logical_id)

                   for (o, n) in zip(instance.disks, new_disks)]

    result.Raise("Failed to rename original LVs")

    feedback_fn("Initializing DRBD devices...")

    # all child devices are in place, we can now create the DRBD devices

    try:

      for disk in anno_disks:

                               excl_stor)

    except errors.GenericError, e:

      feedback_fn("Initializing of DRBD devices failed;"

                  " renaming back original volumes...")

      for disk in new_disks:

      rename_back_list = [(n.children[0], o.logical_id)

                          for (n, o) in zip(new_disks, instance.disks)]

      result.Raise("Failed to rename LVs back after error %s" % str(e))

      raise

    assert len(instance.secondary_nodes) == 1

    assert instance.disk_template == constants.DT_DRBD8

    feedback_fn("Converting template to plain")

    old_disks = AnnotateDiskParams(instance, instance.disks, self.cfg)

    feedback_fn("Removing volumes on the secondary node...")

    for disk in old_disks:

      if msg:

        self.LogWarning("Could not remove block device %s on node %s,"

    feedback_fn("Removing unneeded volumes on the primary node...")

    for idx, disk in enumerate(old_disks):

      meta = disk.children[1]

      if msg:

        self.LogWarning("Could not remove metadata for disk %d on node %s,"

  def _CreateNewDisk(self, idx, params, _):

    """Creates a new disk.

    """

    (anno_disk,) = AnnotateDiskParams(self.instance, [root], self.cfg)

      if msg:

        self.LogWarning("Could not remove disk/%d on node '%s': %s,"

    # if this is a DRBD disk, return its port to the pool

    if root.dev_type in constants.LDS_DRBD:

    instance = self.instance

    # New primary node

    # runtime memory

    if self.op.runtime_mem:

    if self.op.disk_template:

      if __debug__:

        check_nodes = set(instance.all_nodes)

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

          owned = self.owned_locks(level)

          assert not (check_nodes - owned), \

        # Lock all nodes in all potential target groups

        lock_groups = (frozenset(self.owned_locks(locking.LEVEL_NODEGROUP)) -

                       self.cfg.GetInstanceNodeGroups(self.op.instance_name))

                        for group in lock_groups

        self.needed_locks[locking.LEVEL_NODE].extend(member_nodes)

      else:

        # Lock all nodes as all groups are potential targets