Synnefo » snf-ganeti

    uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),

    name=constants.INITIAL_NODE_GROUP_NAME,

    members=[master_node_config.name],

    )

  nodegroups = {

    default_nodegroup.uuid: default_nodegroup,

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)

    """

    node = self._UnlockedGetNodeInfo(instance.primary_node)

    nodegroup = self._UnlockedGetNodeGroup(node.group)

  @locking.ssynchronized(_config_lock, shared=1)

  def GenerateMAC(self, ec_id):

  @return: the upgraded disk parameters dict

  """

  else:

    result = FillDiskParams(constants.DISK_DT_DEFAULTS, diskparams)

    if self.use_external_mip_script is None:

      self.use_external_mip_script = False

    # instance policy added before 2.6

    if self.ipolicy is None:

import shutil

import operator

import itertools

from ganeti import constants

from ganeti import mcpu

  def GenerateDRBDSecret(self, ec_id):

    return "ec%s-secret%s" % (ec_id, self._secret.next())

class _FakeProcForGenDiskTemplate:

  def GetECId(self):

    self.lu = _FakeLU(cfg=cfg, proc=proc)

    self.nodegroup = nodegroup

  def testWrongDiskTemplate(self):

    gdt = cmdlib._GenerateDiskTemplate

    disk_template = "##unknown##"

    self.assertRaises(errors.ProgrammerError, gdt, self.lu, disk_template,

                      "inst26831.example.com", "node30113.example.com", [], [],

                      NotImplemented, NotImplemented, 0, self.lu.LogInfo,

  def testDiskless(self):

    gdt = cmdlib._GenerateDiskTemplate

    result = gdt(self.lu, constants.DT_DISKLESS, "inst27734.example.com",

                 "node30113.example.com", [], [],

                 NotImplemented, NotImplemented, 0, self.lu.LogInfo,

    self.assertEqual(result, [])

  def _TestTrivialDisk(self, template, disk_info, base_index, exp_dev_type,

                      template, "inst25088.example.com",

                      "node185.example.com", ["node323.example.com"], [],

                      NotImplemented, NotImplemented, base_index,

                      _req_file_storage=req_file_storage,

                      _req_shr_file_storage=req_shr_file_storage)

    result = gdt(self.lu, template, "inst21662.example.com",

                 "node21741.example.com", [],

                 disk_info, file_storage_dir, file_driver, base_index,

                 _req_file_storage=req_file_storage,

                 _req_shr_file_storage=req_shr_file_storage)

    self.assertRaises(errors.ProgrammerError, gdt, self.lu, constants.DT_DRBD8,

                      "inst827.example.com", "node1334.example.com", [],

                      disk_info, NotImplemented, NotImplemented, 0,

    result = gdt(self.lu, constants.DT_DRBD8, "inst827.example.com",

                 "node1334.example.com", ["node12272.example.com"],

                 disk_info, NotImplemented, NotImplemented, 0, self.lu.LogInfo,

    for (idx, disk) in enumerate(result):

      self.assertTrue(isinstance(disk, objects.Disk))