Synnefo » snf-ganeti » ganeti-local

from ganeti import rpc

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

from ganeti.cmdlib.common import INSTANCE_DOWN, INSTANCE_NOT_RUNNING, \

  CheckNodeOnline, CheckInstanceNodeGroups, CheckInstanceState, \

from ganeti.cmdlib.instance_utils import GetInstanceInfoText, \

  CopyLockList, ReleaseLocks, CheckNodeVmCapable, \

  BuildInstanceHookEnvByObject, CheckNodeNotDrained, CheckTargetNodeIPolicy

  }

                         excl_stor):

  """Create a single block device on a given node.

  created in advance.

  @param lu: the lu on whose behalf we execute

  @type instance: L{objects.Instance}

  @param instance: the instance which owns the device

  @type device: L{objects.Disk}

  @param excl_stor: Whether exclusive_storage is active for the node

  """

                                       instance.name, force_open, info,

                                       excl_stor)

  result.Raise("Can't create block device %s on"

  if device.physical_id is None:

    device.physical_id = result.payload

                         info, force_open, excl_stor):

  """Create a tree of block devices on a given node.

  @attention: The device has to be annotated already.

  @param lu: the lu on whose behalf we execute

  @type instance: L{objects.Instance}

  @param instance: the instance which owns the device

  @type device: L{objects.Disk}

    if device.children:

      for child in device.children:

        created_devices.extend(devs)

    if not force_create:

      return created_devices

                         excl_stor)

    # The device has been completely created, so there is no point in keeping

    # its subdevices in the list. We just add the device itself instead.

    return created_devices

  except errors.DeviceCreationError, e:

    raise errors.DeviceCreationError(str(e), created_devices)

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

  @type cfg: L{config.ConfigWriter}

  @param cfg: The cluster configuration

  @rtype: bool

  @return: The effective value of exclusive_storage

  @raise errors.OpPrereqError: if no node exists with the given name

  """

  if ni is None:

                               errors.ECODE_NOENT)

  return IsExclusiveStorageEnabledNode(cfg, ni)

                    force_open):

  """Wrapper around L{_CreateBlockDevInner}.

  """

  (disk,) = AnnotateDiskParams(instance, [device], lu.cfg)

                              force_open, excl_stor)

  @param disks_created: the result returned by L{CreateDisks}

  """

    result.Warn("Failed to remove newly-created disk %s on node %s" %

  """Create all disks for an instance.

  This abstracts away some work from AddInstance.

  @param instance: the instance whose disks we should create

  @type to_skip: list

  @param to_skip: list of indices to skip

  @type disks: list of {objects.Disk}

  @param disks: the disks to create; if not specified, all the disks of the

      instance are created

  """

  info = GetInstanceInfoText(instance)

  else:

  if disks is None:

    disks = instance.disks

  if instance.disk_template in constants.DTS_FILEBASED:

    file_storage_dir = os.path.dirname(instance.disks[0].logical_id[1])

    result.Raise("Failed to create directory '%s' on"

  disks_created = []

  for idx, device in enumerate(disks):

    if to_skip and idx in to_skip:

      continue

    logging.info("Creating disk %s for instance '%s'", idx, instance.name)

      try:

      except errors.DeviceCreationError, e:

        logging.warning("Creating disk %s for instance '%s' failed",

                        idx, instance.name)

  pass

                         iv_name, p_minor, s_minor):

  """Generate a drbd8 device complete with its children.

                          params={})

  dev_meta.uuid = lu.cfg.GenerateUniqueID(lu.proc.GetECId())

  drbd_dev = objects.Disk(dev_type=constants.LD_DRBD8, size=size,

                                      p_minor, s_minor,

                                      shared_secret),

                          children=[dev_data, dev_meta],

def GenerateDiskTemplate(

  disk_info, file_storage_dir, file_driver, base_index,

  feedback_fn, full_disk_params, _req_file_storage=opcodes.RequireFileStorage,

  _req_shr_file_storage=opcodes.RequireSharedFileStorage):

  if template_name == constants.DT_DISKLESS:

    pass

  elif template_name == constants.DT_DRBD8:

      raise errors.ProgrammerError("Wrong template configuration")

    minors = lu.cfg.AllocateDRBDMinor(

    (drbd_params, _, _) = objects.Disk.ComputeLDParams(template_name,

                                                       full_disk_params)

      disk_index = idx + base_index

      data_vg = disk.get(constants.IDISK_VG, vgname)

      meta_vg = disk.get(constants.IDISK_METAVG, drbd_default_metavg)

                                      disk[constants.IDISK_SIZE],

                                      [data_vg, meta_vg],

                                      names[idx * 2:idx * 2 + 2],

      disk_dev.name = disk.get(constants.IDISK_NAME, None)

      disks.append(disk_dev)

  else:

      raise errors.ProgrammerError("Wrong template configuration")

    if template_name == constants.DT_FILE:

                                 " %s" % (self.op.iallocator, ial.info),

                                 errors.ECODE_NORES)

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

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

  def CheckArguments(self):

    if self.op.disks and ht.TNonNegativeInt(self.op.disks[0]):

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

    if self.op.nodes:

    else:

      self.needed_locks[locking.LEVEL_NODE] = []

      if self.op.iallocator:

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

    assert instance is not None, \

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

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

                                   " %d replacement nodes were specified" %

                                   (instance.name, len(instance.all_nodes),

                                   errors.ECODE_INVAL)

      assert instance.disk_template != constants.DT_DRBD8 or \

      assert instance.disk_template != constants.DT_PLAIN or \

    else:

      primary_node = instance.primary_node

    if not self.op.iallocator:

    # if we replace nodes *and* the old primary is offline, we don't

    # check the instance state

    old_pnode = self.cfg.GetNodeInfo(instance.primary_node)

      CheckInstanceState(self, instance, INSTANCE_NOT_RUNNING,

                         msg="cannot recreate disks")

      raise errors.OpPrereqError("Invalid disk index '%s'" % maxidx,

                                 errors.ECODE_INVAL)

         sorted(self.disks.keys()) != range(len(instance.disks))):

      raise errors.OpPrereqError("Can't recreate disks partially and"

                                 " change the nodes at the same time",

    if self.op.iallocator:

      self._RunAllocator()

      # Release unneeded node and node resource locks

      ReleaseLocks(self, locking.LEVEL_NODE_ALLOC)

    assert not self.glm.is_owned(locking.LEVEL_NODE_ALLOC)

    else:

    excl_stor = compat.any(

      )

    for new_params in self.disks.values():

      CheckSpindlesExclusiveStorage(new_params, excl_stor, False)

        continue

      # update secondaries for disks, if needed

        # need to update the nodes and minors

        assert len(disk.logical_id) == 6 # otherwise disk internals

                                         # have changed

        (_, _, old_port, _, _, old_secret) = disk.logical_id

                  new_minors[0], new_minors[1], old_secret)

        assert len(disk.logical_id) == len(new_id)

      else:

                    spindles=changes.get(constants.IDISK_SPINDLES, None))

    # change primary node, if needed

      self.LogWarning("Changing the instance's nodes, you will have to"

                      " remove any disks left on the older nodes manually")

      self.cfg.Update(instance, feedback_fn)

    # All touched nodes must be locked

      WipeOrCleanupDisks(self, instance, disks=wipedisks, cleanup=new_disks)

  """Checks if nodes have enough free disk space in the specified VG.

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

  @type lu: C{LogicalUnit}

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

  @type vg: C{str}

  @param vg: the volume group to check

  @type requested: C{int}

      or we cannot check the node

  """

  # FIXME: This maps everything to storage type 'lvm-vg' to maintain

  # the current functionality. Refactor to make it more flexible.

  hvname = lu.cfg.GetHypervisorType()

  hvparams = lu.cfg.GetClusterInfo().hvparams

                                   [(hvname, hvparams[hvname])], es_flags)

    info = nodeinfo[node]

               prereq=True, ecode=errors.ECODE_ENVIRON)

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

    vg_free = vg_info.get("vg_free", None)

    if not isinstance(vg_free, int):

      raise errors.OpPrereqError("Can't compute free disk space on node"

                                 " %s for vg %s, result was '%s'" %

    if requested > vg_free:

      raise errors.OpPrereqError("Not enough disk space on target node %s"

                                 " vg %s: required %d MiB, available %d MiB" %

                                 errors.ECODE_NORES)

  """Checks if nodes have enough free disk space in all the VGs.

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

  @type lu: C{LogicalUnit}

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

  @type req_sizes: C{dict}

  @param req_sizes: the hash of vg and corresponding amount of disk in

      MiB to check for

  """

  for vg, req_size in req_sizes.items():

def _DiskSizeInBytesToMebibytes(lu, size):

    start offset

  """

  if disks is None:

    disks = [(idx, disk, 0)

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

  for (_, device, _) in disks:

  logging.info("Pausing synchronization of disks of instance '%s'",

               instance.name)

                                                  (map(compat.snd, disks),

                                                   instance),

                                                  True)

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

    if not success:

      lu.LogInfo("* Wiping disk %s%s", idx, info_text)

      logging.info("Wiping disk %d for instance %s on node %s using"

      while offset < size:

        wipe_size = min(wipe_chunk_size, size - offset)

        logging.debug("Wiping disk %d, offset %s, chunk %s",

                      idx, offset, wipe_size)

        result.Raise("Could not wipe disk %d at offset %d for size %d" %

                     (idx, offset, wipe_size))

    logging.info("Resuming synchronization of disks for instance '%s'",

                 instance.name)

                                                    (map(compat.snd, disks),

                                                     instance),

                                                    False)

    if result.fail_msg:

      lu.LogWarning("Failed to resume disk synchronization on node '%s': %s",

    else:

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

        if not success:

  if not oneshot:

    lu.LogInfo("Waiting for instance %s to sync disks", instance.name)

  for dev in disks:

  # TODO: Convert to utils.Retry

    max_time = 0

    done = True

    cumul_degraded = False

    msg = rstats.fail_msg

    if msg:

      retries += 1

      if retries >= 10:

        raise errors.RemoteError("Can't contact node %s for mirror data,"

      time.sleep(6)

      continue

    rstats = rstats.payload

    for i, mstat in enumerate(rstats):

      if mstat is None:

        lu.LogWarning("Can't compute data for node %s/%s",

        continue

      cumul_degraded = (cumul_degraded or

  disks = ExpandCheckDisks(instance, disks)

  for disk in disks:

      msg = result.fail_msg

      if msg:

        lu.LogWarning("Could not shutdown block device %s on node %s: %s",

          all_result = False

  return all_result

  # 1st pass, assemble on all nodes in secondary mode

  for idx, inst_disk in enumerate(disks):

      if ignore_size:

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      msg = result.fail_msg

      if msg:

                                result.offline)

        lu.LogWarning("Could not prepare block device %s on node %s"

                      " (is_primary=False, pass=1): %s",

        if not (ignore_secondaries or is_offline_secondary):

          disks_ok = False

  for idx, inst_disk in enumerate(disks):

    dev_path = None

        continue

      if ignore_size:

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      msg = result.fail_msg

      if msg:

        lu.LogWarning("Could not prepare block device %s on node %s"

                      " (is_primary=True, pass=2): %s",

        disks_ok = False

      else:

        dev_path = result.payload

  # leave the disks configured for the primary node

  # this is a workaround that would be fixed better by

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

    assert instance is not None, \

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

    self.instance = instance

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

                                   errors.ECODE_INVAL)

    template = self.instance.disk_template

    if template not in (constants.DTS_NO_FREE_SPACE_CHECK):

      # TODO: check the free disk space for file, when that feature will be

      # supported

      es_nodes = filter(lambda n: IsExclusiveStorageEnabledNode(self.cfg, n),

                        nodes)

      if es_nodes:

        # at free space; for now, let's simply abort the operation.

        raise errors.OpPrereqError("Cannot grow disks when exclusive_storage"

                                   " is enabled", errors.ECODE_STATE)

  def Exec(self, feedback_fn):

    """Execute disk grow.

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

    # First run all grow ops in dry-run mode

    if wipe_disks:

      # Get disk size from primary node for wiping

    # 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

    # And now execute it for logical storage, on the primary node

    disk.RecordGrow(self.delta)

    self.cfg.Update(instance, feedback_fn)

      "Conflicting options"

    if self.op.remote_node is not None:

      # Warning: do not remove the locking of the new secondary here

      # unless DRBD8Dev.AddChildren is changed to work in parallel;

      # currently it doesn't since parallel invocations of

      # FindUnusedMinor will conflict

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

    else:

      self.needed_locks[locking.LEVEL_NODE] = []

    self.needed_locks[locking.LEVEL_NODE_RES] = []

    self.replacer = TLReplaceDisks(self, self.op.instance_name, self.op.mode,

                                   self.op.disks, self.op.early_release,

                                   self.op.ignore_ipolicy)

  def DeclareLocks(self, level):

    if level == locking.LEVEL_NODEGROUP:

      assert self.op.iallocator is not None

      assert not self.needed_locks[locking.LEVEL_NODEGROUP]

    elif level == locking.LEVEL_NODE:

      if self.op.iallocator is not None:

        assert not self.needed_locks[locking.LEVEL_NODE]

        assert locking.NAL in self.owned_locks(locking.LEVEL_NODE_ALLOC)

        # Lock member nodes of all locked groups

        self.needed_locks[locking.LEVEL_NODE] = \

           for group_uuid in self.owned_locks(locking.LEVEL_NODEGROUP)

      else:

        assert not self.glm.is_owned(locking.LEVEL_NODE_ALLOC)

    env = {

      "MODE": self.op.mode,

      "NEW_SECONDARY": self.op.remote_node,

      }

    env.update(BuildInstanceHookEnvByObject(self, instance))

    return env

      self.cfg.GetMasterNode(),

      instance.primary_node,

      ]

    return nl, nl

  def CheckPrereq(self):

      _SafeShutdownInstanceDisks(self, instance)

                               ldisk=False):

  """Check that mirrors are not degraded.

  the device(s)) to the ldisk (representing the local storage status).

  """

  result = True

  if on_primary or dev.AssembleOnSecondary():

    msg = rstats.fail_msg

    if msg:

      result = False

    elif not rstats.payload:

      result = False

    else:

      if ldisk:

  if dev.children:

    for child in dev.children:

  return result

  """Wrapper around L{_CheckDiskConsistencyInner}.

  """

  (disk,) = AnnotateDiskParams(instance, [dev], lu.cfg)

                                    ldisk=ldisk)

  """Wrapper around call_blockdev_find to annotate diskparams.

  @param lu: A reference to the lu object

  @param dev: The device to find

  @param instance: The instance object the device belongs to

  @returns The result of the rpc call

  """

  (disk,) = AnnotateDiskParams(instance, [dev], lu.cfg)

def _GenerateUniqueNames(lu, exts):

  Note: Locking is not within the scope of this class.

  """

               disks, early_release, ignore_ipolicy):

    """Initializes this class.

    self.instance_name = instance_name

    self.mode = mode

    self.iallocator_name = iallocator_name

    self.disks = disks

    self.early_release = early_release

    self.ignore_ipolicy = ignore_ipolicy

    # Runtime data

    self.instance = None

    self.remote_node_info = None

    self.node_secondary_ip = None

  @staticmethod

    """Compute a new secondary node using an IAllocator.

    """

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

    ial.Run(iallocator_name)

                                 errors.ECODE_NORES)

    remote_node_name = ial.result[0]

    lu.LogInfo("Selected new secondary for instance '%s': %s",

               instance_name, remote_node_name)

    """Wrapper for L{FindFaultyInstanceDisks}.

    """

    return FindFaultyInstanceDisks(self.cfg, self.rpc, self.instance,

  def _CheckDisksActivated(self, instance):

    """Checks if the instance disks are activated.

    @return: True if they are activated, False otherwise

    """

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

        if result.offline:

          continue

                                 errors.ECODE_FAULT)

    instance = self.instance

    if self.iallocator_name is None:

    else:

      self.remote_node_info = None

    else:

      assert self.remote_node_info is not None, \

      raise errors.OpPrereqError("The specified node is the primary node of"

                                 " the instance", errors.ECODE_INVAL)

      raise errors.OpPrereqError("The specified node is already the"

                                 " secondary node of the instance",

                                 errors.ECODE_INVAL)

                                   " first" % self.instance_name,

                                   errors.ECODE_STATE)

      faulty_primary = self._FindFaultyDisks(instance.primary_node)

      if faulty_primary and faulty_secondary:

        raise errors.OpPrereqError("Instance %s has faulty disks on more than"

      if faulty_primary:

        self.disks = faulty_primary

      elif faulty_secondary:

        self.disks = faulty_secondary

      else:

        self.disks = []

        check_nodes = []

    else:

      # Non-automatic modes

      if self.mode == constants.REPLACE_DISK_PRI:

      elif self.mode == constants.REPLACE_DISK_SEC:

      elif self.mode == constants.REPLACE_DISK_CHG:

        assert old_node_info is not None

        if old_node_info.offline and not self.early_release:

          # doesn't make sense to delay the release

          self.early_release = True

          self.lu.LogInfo("Old secondary %s is offline, automatically enabling"

      else:

        raise errors.ProgrammerError("Unhandled disk replace mode (%s)" %

      CheckTargetNodeIPolicy(self, ipolicy, instance, self.remote_node_info,

                             self.cfg, ignore=self.ignore_ipolicy)

    # Release unneeded node and node resource locks

    ReleaseLocks(self.lu, locking.LEVEL_NODE, keep=touched_nodes)

      instance.FindDisk(disk_idx)

    # Get secondary node IP addresses

                                  in self.cfg.GetMultiNodeInfo(touched_nodes))

  def Exec(self, feedback_fn):

    feedback_fn("Replacing disk(s) %s for instance '%s'" %

                (utils.CommaJoin(self.disks), self.instance.name))

    feedback_fn("Current seconary node: %s" %

    activate_disks = not self.instance.disks_active

    try:

      # Should we replace the secondary node?

        fn = self._ExecDrbd8Secondary

      else:

        fn = self._ExecDrbd8DiskOnly

    return result

    self.lu.LogInfo("Checking volume groups")

    vgname = self.cfg.GetVGName()

    # Make sure volume group exists on all involved nodes

    if not results:

      raise errors.OpExecError("Can't list volume groups on the nodes")

      if vgname not in res.payload:

        raise errors.OpExecError("Volume group '%s' not found on node %s" %

    # Check disk existence

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

      if idx not in self.disks:

        continue

        msg = result.fail_msg

        if msg or not result.payload:

          if not msg:

            msg = "disk not found"

          raise errors.OpExecError("Can't find disk/%d on node %s: %s" %

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

      if idx not in self.disks:

        continue

      self.lu.LogInfo("Checking disk/%d consistency on node %s" %

                                  on_primary, ldisk=ldisk):

        raise errors.OpExecError("Node %s has degraded storage, unsafe to"

                                 " replace disks for instance %s" %

    """Create new storage on the primary or secondary node.

    This is only used for same-node replaces, not for changing the

      if idx not in self.disks:

        continue

      lv_names = [".disk%d_%s" % (idx, suffix) for suffix in ["data", "meta"]]

      names = _GenerateUniqueNames(self.lu, lv_names)

      new_lvs = [lv_data, lv_meta]

      old_lvs = [child.Copy() for child in dev.children]

      iv_names[dev.iv_name] = (dev, old_lvs, new_lvs)

      # we pass force_create=True to force the LVM creation

      for new_lv in new_lvs:

                             GetInstanceInfoText(self.instance), False,

                             excl_stor)

    return iv_names

    for name, (dev, _, _) in iv_names.iteritems():

      msg = result.fail_msg

      if msg or not result.payload:

      if result.payload.is_degraded:

        raise errors.OpExecError("DRBD device %s is degraded!" % name)

    for name, (_, old_lvs, _) in iv_names.iteritems():

      self.lu.LogInfo("Remove logical volumes for %s", name)

      for lv in old_lvs:

        if msg:

          self.lu.LogWarning("Can't remove old LV: %s", msg,

                             hint="remove unused LVs manually")

    # Step: check device activation

    self.lu.LogStep(1, steps_total, "Check device existence")

    # Step: check other node consistency

    self.lu.LogStep(2, steps_total, "Check peer consistency")

    # Step: create new storage

    self.lu.LogStep(3, steps_total, "Allocate new storage")

    # Step: for each lv, detach+rename*2+attach

    self.lu.LogStep(4, steps_total, "Changing drbd configuration")

    for dev, old_lvs, new_lvs in iv_names.itervalues():

      self.lu.LogInfo("Detaching %s drbd from local storage", dev.iv_name)

                                                     old_lvs)

      result.Raise("Can't detach drbd from local storage on node"

      #dev.children = []

      #cfg.Update(instance)

      # Build the rename list based on what LVs exist on the node

      rename_old_to_new = []

      for to_ren in old_lvs:

        if not result.fail_msg and result.payload:

          # device exists

          rename_old_to_new.append((to_ren, ren_fn(to_ren, temp_suffix)))

      self.lu.LogInfo("Renaming the old LVs on the target node")

                                             rename_old_to_new)

      # Now we rename the new LVs to the old LVs

      self.lu.LogInfo("Renaming the new LVs on the target node")

      rename_new_to_old = [(new, old.physical_id)

                           for old, new in zip(old_lvs, new_lvs)]

                                             rename_new_to_old)

      # Intermediate steps of in memory modifications

      for old, new in zip(old_lvs, new_lvs):

        new.logical_id = old.logical_id

      # We need to modify old_lvs so that removal later removes the

      # right LVs, not the newly added ones; note that old_lvs is a

      # copy here

      for disk in old_lvs:

        disk.logical_id = ren_fn(disk, temp_suffix)

      # Now that the new lvs have the old name, we can add them to the device

                                                  (dev, self.instance), new_lvs)

      msg = result.fail_msg

      if msg:

        for new_lv in new_lvs:

                                               new_lv).fail_msg

          if msg2:

            self.lu.LogWarning("Can't rollback device %s: %s", dev, msg2,

    if self.early_release:

      self.lu.LogStep(cstep.next(), steps_total, "Removing old storage")

      # TODO: Check if releasing locks early still makes sense

      ReleaseLocks(self.lu, locking.LEVEL_NODE_RES)

    else:

    # Step: remove old storage

    if not self.early_release:

      self.lu.LogStep(cstep.next(), steps_total, "Removing old storage")

  def _ExecDrbd8Secondary(self, feedback_fn):

    """Replace the secondary node for DRBD 8.

    # Step: create new storage

    self.lu.LogStep(3, steps_total, "Allocate new storage")

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

    for idx, dev in enumerate(disks):

      self.lu.LogInfo("Adding new local storage on %s for disk/%d" %

      # we pass force_create=True to force LVM creation

      for new_lv in dev.children:

                             True, GetInstanceInfoText(self.instance), False,

                             excl_stor)

    # after this, we must manually remove the drbd minors on both the

    # error and the success paths

    self.lu.LogStep(4, steps_total, "Changing drbd configuration")

                                        self.instance.name)

    logging.debug("Allocated minors %r", minors)

    iv_names = {}

    for idx, (dev, new_minor) in enumerate(zip(self.instance.disks, minors)):

      self.lu.LogInfo("activating a new drbd on %s for disk/%d" %

      # create new devices on new_node; note that we create two IDs:

      # one without port, so the drbd will be activated without

      # networking information on the new node at this stage, and one

        assert self.instance.primary_node == o_node2, "Three-node instance?"

        p_minor = o_minor2

                      p_minor, new_minor, o_secret)

                    p_minor, new_minor, o_secret)