Synnefo » snf-ganeti » ganeti-local

def _GenerateDRBD8Branch(lu, primary, secondary, size, vgnames, names,

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

  """

  dev_data = objects.Disk(dev_type=constants.LD_LV, size=size,

                          logical_id=(vgnames[0], names[0]),

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

                          logical_id=(vgnames[1], names[1]),

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

                          logical_id=(primary, secondary, port,

                                      p_minor, s_minor,

                                      shared_secret),

                          children=[dev_data, dev_meta],

  return drbd_dev

def _GenerateDiskTemplate(lu, template_name, instance_name, primary_node,

    secondary_nodes, disk_info, file_storage_dir, file_driver, base_index,

    _req_shr_file_storage=opcodes.RequireSharedFileStorage):

  """Generate the entire disk layout for a given template type.

  vgname = lu.cfg.GetVGName()

  disk_count = len(disk_info)

  disks = []

  if template_name == constants.DT_DISKLESS:

    pass

  elif template_name == constants.DT_DRBD8:

    if len(secondary_nodes) != 1:

      raise errors.ProgrammerError("Wrong template configuration")

    remote_node = secondary_nodes[0]

    minors = lu.cfg.AllocateDRBDMinor(

      [primary_node, remote_node] * len(disk_info), instance_name)

    names = []

    for lv_prefix in _GenerateUniqueNames(lu, [".disk%d" % (base_index + i)

                                               for i in range(disk_count)]):

      names.append(lv_prefix + "_meta")

    for idx, disk in enumerate(disk_info):

      disk_index = idx + base_index

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

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

      disk_dev = _GenerateDRBD8Branch(lu, primary_node, remote_node,

                                      [data_vg, meta_vg],

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

                                      "disk/%d" % disk_index,

      disk_dev.mode = disk[constants.IDISK_MODE]

      disks.append(disk_dev)

  else:

                                        (name_prefix, base_index + i)

                                        for i in range(disk_count)])

    if template_name == constants.DT_PLAIN:

      def logical_id_fn(idx, _, disk):

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

    else:

      raise errors.ProgrammerError("Unknown disk template '%s'" % template_name)

    for idx, disk in enumerate(disk_info):

      disk_index = idx + base_index

      size = disk[constants.IDISK_SIZE]

                                logical_id=logical_id_fn(idx, disk_index, disk),

                                iv_name="disk/%d" % disk_index,

                                mode=disk[constants.IDISK_MODE],

  return disks

                                                    utils.CommaJoin(res)),

                                  errors.ECODE_INVAL)

    if not self.adopt_disks:

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

        # _CheckRADOSFreeSpace() is just a placeholder.

    else:

      network_port = None

    disks = _GenerateDiskTemplate(self,

                                  self.op.disk_template,

                                  instance, pnode_name,

                                  self.op.file_driver,

                                  0,

                                  feedback_fn,

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

                            primary_node=pnode_name,

      _CheckTargetNodeIPolicy(self, ipolicy, instance, self.remote_node_info,

                              ignore=self.ignore_ipolicy)

    for node in check_nodes:

      _CheckNodeOnline(self.lu, node)

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

      names = _GenerateUniqueNames(self.lu, lv_names)

      vg_data = dev.children[0].logical_id[0]

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

      vg_meta = dev.children[1].logical_id[0]

      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]

      iv_names[idx] = (dev, dev.children, new_net_id)

      logging.debug("Allocated new_minor: %s, new_logical_id: %s", new_minor,

                    new_net_id)

      new_drbd = objects.Disk(dev_type=constants.LD_DRBD8,

                              logical_id=new_alone_id,

                              children=dev.children,

                              size=dev.size,

      try:

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

                              _GetInstanceInfoText(self.instance), False)

    pnode = instance.primary_node

    nodelist = list(instance.all_nodes)

    pnode_info = self.cfg.GetNodeInfo(pnode)

    # Prepare disk/NIC modifications

    self.diskmod = PrepareContainerMods(self.op.disks, None)