Synnefo » snf-ganeti » ganeti-local

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

def _CopyLockList(names):

  """Makes a copy of a list of lock names.

  """

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

  return _CreateBlockDevInner(lu, node, instance, disk, force_create, info,

def _CreateBlockDevInner(lu, node, instance, device, force_create,

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

  If this device type has to be created on secondaries, create it and

      L{backend.BlockdevCreate} function where it specifies

      whether we run on primary or not, and it affects both

      the child assembly and the device own Open() execution

  """

  if device.CreateOnSecondary():

  if device.children:

    for child in device.children:

      _CreateBlockDevInner(lu, node, instance, child, force_create,

  if not force_create:

    return

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

  This will not recurse over children of the device, so they must be

      L{backend.BlockdevCreate} function where it specifies

      whether we run on primary or not, and it affects both

      the child assembly and the device own Open() execution

  """

  lu.cfg.SetDiskID(device, node)

  result = lu.rpc.call_blockdev_create(node, device, device.size,

                                       instance.name, force_open, info,

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

               " node %s for instance %s" % (device, node, instance.name))

  if device.physical_id is None:

      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:

        _CreateBlockDevInner(self.lu, node_name, self.instance, new_lv, True,

    return iv_names

    # 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" %

                      (self.new_node, idx))

      # we pass force_create=True to force LVM creation

      for new_lv in dev.children:

        _CreateBlockDevInner(self.lu, self.new_node, self.instance, new_lv,

    # Step 4: dbrd minors and drbd setups changes

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

      try:

        _CreateSingleBlockDev(self.lu, self.new_node, self.instance,

                              anno_new_drbd,

      except errors.GenericError:

        self.cfg.ReleaseDRBDMinors(self.instance.name)

        raise

                                      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

      _CreateSingleBlockDev(self, pnode, instance, disk.children[1],

      for child in disk.children:

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

    # old ones

    feedback_fn("Renaming original volumes...")

    feedback_fn("Initializing DRBD devices...")

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

    for disk in anno_disks:

        f_create = node == pnode

    # at this point, the instance has been modified

    instance.disk_template = constants.DT_DRBD8