Synnefo » snf-ganeti » ganeti-local

        return self._ExecMigration()

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

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

  If not, just recurse to children keeping the same 'force' value.

  @param lu: the lu on whose behalf we execute

  @param node: the node on which to create the device

  @type instance: L{objects.Instance}

  if device.children:

    for child in device.children:

  if not force_create:

    return

    """

    iv_names = {}

      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)

      lv_data = objects.Disk(dev_type=constants.LD_LV, size=dev.size,

      lv_meta = objects.Disk(dev_type=constants.LD_LV, size=DRBD_META_SIZE,

      new_lvs = [lv_data, lv_meta]

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

      # we pass force_create=True to force the LVM creation

      for new_lv in new_lvs:

    return iv_names

    # Step: create new storage

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

      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:

    # Step 4: dbrd minors and drbd setups changes

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

                              children=dev.children,

                              size=dev.size,

                              params={})

      try:

                              _GetInstanceInfoText(self.instance), False)

      except errors.GenericError:

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

                                      instance.name, pnode, [snode],

                                      disk_info, None, None, 0, feedback_fn,

                                      self.diskparams)

    info = _GetInstanceInfoText(instance)

    feedback_fn("Creating additional volumes...")

    # first, create the missing data and meta devices

      # unfortunately this is... not too nice

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

                            info, True)

    feedback_fn("Initializing DRBD devices...")

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

      for node in [pnode, snode]:

        f_create = node == pnode

        _CreateSingleBlockDev(self, node, instance, disk, info, f_create)