Synnefo » snf-ganeti

which are queried directly on the node (without hypervisor

involvment). The are stored in a separate attribute (``disk_state``),

which is indexed per storage type and name; currently this will be just

+-------------+-------------------------+--------------------+--------+

|Name         |Description              |Current state       |Type    |

    if constants.HV_DISK_TYPE in instance.hvparams:

      result["DISK_%d_FRONTEND_TYPE" % idx] = \

        instance.hvparams[constants.HV_DISK_TYPE]

      result["DISK_%d_BACKEND_TYPE" % idx] = "block"

      result["DISK_%d_BACKEND_TYPE" % idx] = \

        "file:%s" % disk.physical_id[0]

  @return: snapshot disk ID as (vg, lv)

  """

    if not disk.children:

      _Fail("DRBD device '%s' without backing storage cannot be snapshotted",

            disk.unique_id)

    return BlockdevSnapshot(disk.children[0])

    r_dev = _RecursiveFindBD(disk)

    if r_dev is not None:

      # FIXME: choose a saner value for the snapshot size

  """Formats the logical_id of a disk.

  """

    drbd_info = dev["drbd_info"]

    data = [

      ("nodeA", "%s, minor=%s" %

      ("port", str(compat.TryToRoman(drbd_info["port"], convert=roman))),

      ("auth key", str(drbd_info["secret"])),

      ]

    vg_name, lv_name = dev["logical_id"]

    data = ["%s/%s" % (vg_name, lv_name)]

  else:

    """Format one line for physical device status.

    @type dtype: str

    @type status: tuple

    @param status: a tuple as returned from L{backend.FindBlockDevice}

    @return: the string representing the status

      minor_string = str(compat.TryToRoman(minor, convert=roman))

    txt += ("%s (%s:%s)" % (path, major_string, minor_string))

      if syncp is not None:

        sync_text = "*RECOVERING* %5.2f%%," % syncp

        if estt:

      else:

        ldisk_text = ""

      txt += (" %s, status %s%s" % (sync_text, degr_text, ldisk_text))

      if ldisk_status == constants.LDS_FAULTY:

        ldisk_text = " *FAILED* (failed drive?)"

      else:

    # instance disk type verification

    # TODO: Implement export support for file-based disks

    for disk in self.instance.disks:

        raise errors.OpPrereqError("Export not supported for instances with"

                                   " file-based disks", errors.ECODE_INVAL)

    @param disk: an L{ganeti.objects.Disk} object

    """

      assert disk.children, "Empty children for DRBD8?"

      fchild = disk.children[0]

      mismatch = fchild.size < disk.size

                                   " enabling lvm-based disk-templates.")

    if self.op.vg_name is not None and not self.op.vg_name:

        raise errors.OpPrereqError("Cannot disable lvm storage while lvm-based"

                                   " instances exist", errors.ECODE_INVAL)

    """

    if self.op.drbd_helper is not None and not self.op.drbd_helper:

        raise errors.OpPrereqError("Cannot disable drbd helper while"

                                   " drbd-based instances exist",

                                   errors.ECODE_INVAL)

    bep = self.cfg.GetClusterInfo().FillBE(self.instance)

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

        raise errors.OpPrereqError("Instance disk %d has a complex layout,"

                                   " cannot copy" % idx, errors.ECODE_STATE)

  }

def CreateSingleBlockDev(lu, node_uuid, instance, device, info, force_open,

                         excl_stor):

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

  port = lu.cfg.AllocatePort()

  shared_secret = lu.cfg.GenerateDRBDSecret(lu.proc.GetECId())

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

                          params={})

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

                          size=constants.DRBD_META_SIZE,

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

                          params={})

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

                          logical_id=(primary_uuid, secondary_uuid, port,

                                      p_minor, s_minor,

                                      shared_secret),

    else:

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

    for idx, disk in enumerate(disk_info):

      params = {}

        continue

      # update secondaries for disks, if needed

        # need to update the nodes and minors

        assert len(self.op.node_uuids) == 2

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

    for idx, new_id, changes in mods:

      disk = self.instance.disks[idx]

      if new_id is not None:

        disk.logical_id = new_id

      if changes:

        disk.Update(size=changes.get(constants.IDISK_SIZE, None),

      (data_disk, meta_disk) = dev.children

      vg_data = data_disk.logical_id[0]

                             logical_id=(vg_data, names[0]),

                             params=data_disk.params)

      vg_meta = meta_disk.logical_id[0]

                             size=constants.DRBD_META_SIZE,

                             logical_id=(vg_meta, names[1]),

                             params=meta_disk.params)

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

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

                    new_net_id)

                              logical_id=new_alone_id,

                              children=dev.children,

                              size=dev.size,

    if disk.logical_id is None and disk.physical_id is not None:

      return

      pnode, snode, port, pminor, sminor, secret = disk.logical_id

      if node_uuid not in (pnode, snode):

        raise errors.ConfigurationError("DRBD device not knowing node %s" %

    """

    def _AppendUsedMinors(get_node_name_fn, instance, disk, used):

      duplicates = []

        node_a, node_b, _, minor_a, minor_b = disk.logical_id[:5]

        for node_uuid, minor in ((node_a, minor_a), (node_b, minor_b)):

          assert node_uuid in used, \

    inst.name = new_name

    for (idx, disk) in enumerate(inst.disks):

        # rename the file paths in logical and physical id

        file_storage_dir = os.path.dirname(os.path.dirname(disk.logical_id[1]))

        disk.logical_id = (disk.logical_id[0],

  DT_EXT,

  ])

  ])

# drbd constants

FD_BLKTAP = "blktap"

# the set of drbd-like disk types

# disk access mode

DISK_RDONLY = "ro"

  }

DSS_PARAMETERS = frozenset(DSS_PARAMETER_TYPES.keys())

# Backend parameter names

BE_MEMORY = "memory" # deprecated and replaced by max and min mem

  ND_EXCLUSIVE_STORAGE,

  ])

    LDP_RESYNC_RATE: CLASSIC_DRBD_SYNC_SPEED,

    LDP_BARRIERS: _autoconf.DRBD_BARRIERS,

    LDP_NO_META_FLUSH: _autoconf.DRBD_NO_META_FLUSH,

    LDP_MAX_RATE: CLASSIC_DRBD_SYNC_SPEED, # KiB/s

    LDP_MIN_RATE: 4 * 1024, # KiB/s

    },

    LDP_STRIPES: _autoconf.LVM_STRIPECOUNT

    },

    LDP_POOL: "rbd"

    },

  }

# readability shortcuts

DISK_DT_DEFAULTS = {

  DT_PLAIN: {

    },

  DT_DRBD8: {

    DRBD_RESYNC_RATE: _DRBD_DEFAULTS[LDP_RESYNC_RATE],

  DT_SHARED_FILE: {},

  DT_BLOCK: {},

  DT_RBD: {

    },

  DT_EXT: {},

  }

    else:

      mode = "r"

      driver = _FILE_DRIVER_MAP[cfdev.physical_id[0]]

    else:

      driver = "phy"

                            " result '%s'", idx, src_node, result.payload)

      else:

        disk_id = tuple(result.payload)

                               logical_id=disk_id, physical_id=disk_id,

                               iv_name=disk.iv_name,

                               params=disk_params)

  def HasAnyDiskOfType(self, dev_type):

    """Check if in there is at disk of the given type in the configuration.

    @param dev_type: the type to look for

    @rtype: boolean

    @return: boolean indicating if a disk of the given type was found or not

      # To decide if we set an helper let's check if at least one instance has

      # a DRBD disk. This does not cover all the possible scenarios but it

      # gives a good approximation.

        self.cluster.drbd_usermode_helper = constants.DEFAULT_DRBD_HELPER

    if self.networks is None:

      self.networks = {}

  def CreateOnSecondary(self):

    """Test if this device needs to be created on a secondary node."""

  def AssembleOnSecondary(self):

    """Test if this device needs to be assembled on a secondary node."""

  def OpenOnSecondary(self):

    """Test if this device needs to be opened on a secondary node."""

  def StaticDevPath(self):

    """Return the device path if this device type has a static one.

        should check that it is a valid path.

    """

      return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1])

      return self.logical_id[1]

      return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1])

    return None

    -1.

    """

      return 0

    return -1

  def IsBasedOnDiskType(self, dev_type):

    """Check if the disk or its children are based on the given type.

    @param dev_type: the type to look for

    @rtype: boolean

    @return: boolean indicating if a device of the given type was found or not

    devices needs to (or can) be assembled.

    """

      result = [node_uuid]

    elif self.dev_type in constants.LDS_DRBD:

      result = [self.logical_id[0], self.logical_id[1]]

    @return: a dictionary of volume-groups and the required size

    """

      return {self.logical_id[0]: amount}

      if self.children:

        return self.children[0].ComputeGrowth(amount)

      else:

    actual algorithms from bdev.

    """

      self.size += amount

      if self.children:

        self.children[0].RecordGrow(amount)

      self.size += amount

    """Apply changes to size, spindles and mode.

    """

      if self.children:

        self.children[0].Update(size=size, mode=mode)

    else:

    """Custom str() formatter for disks.

    """

      val = "<LogicalVolume(/dev/%s/%s" % self.logical_id

    elif self.dev_type in constants.LDS_DRBD:

      node_a, node_b, port, minor_a, minor_b = self.logical_id[:5]

    result = list()

    dt_params = disk_params[disk_template]

    if disk_template == constants.DT_DRBD8:

        constants.LDP_RESYNC_RATE: dt_params[constants.DRBD_RESYNC_RATE],

        constants.LDP_BARRIERS: dt_params[constants.DRBD_DISK_BARRIERS],

        constants.LDP_NO_META_FLUSH: dt_params[constants.DRBD_META_BARRIERS],

        }))

      # data LV

        constants.LDP_STRIPES: dt_params[constants.DRBD_DATA_STRIPES],

        }))

      # metadata LV

        constants.LDP_STRIPES: dt_params[constants.DRBD_META_STRIPES],

        }))

    elif disk_template in (constants.DT_FILE, constants.DT_SHARED_FILE):

    elif disk_template == constants.DT_PLAIN:

        constants.LDP_STRIPES: dt_params[constants.LV_STRIPES],

        }))

    elif disk_template == constants.DT_BLOCK:

    elif disk_template == constants.DT_RBD:

        constants.LDP_POOL: dt_params[constants.RBD_POOL],

        }))

    elif disk_template == constants.DT_EXT:

    return result

      devs = self.disks

    for dev in devs:

        lvmap[node_uuid].append(dev.logical_id[0] + "/" + dev.logical_id[1])

      elif dev.dev_type in constants.LDS_DRBD:

  """Annotates just DRBD disks layouts.

  """

  disk.params = objects.FillDict(drbd_params, disk.params)

  (dev_data, dev_meta) = disk.children

  """Generic disk parameter annotation routine.

  """

  disk.params = objects.FillDict(params, disk.params)

DEV_MAP = {

  }

  """Verifies if all disk parameters are set.

  """

  if missing:

    raise errors.ProgrammerError("Block device is missing disk parameters: %s" %

                                 missing)

  drbd_min = {}

  for (count, diskinfo) in enumerate(info["Disks"]):

    (dtype, _) = diskinfo["disk/%s" % count].split(",", 1)

      for child in diskinfo["child devices"]:

        vols.append(child["logical_id"])

      for key in ["nodeA", "nodeB"]:

        minor = int(m.group(2))

        minorlist = drbd_min.setdefault(node, [])

        minorlist.append(minor)

      vols.append(diskinfo["logical_id"])

  assert nodes

  , FileDriver(..)

  , BlockDriver(..)

  , DiskMode(..)

  , DiskLogicalId(..)

  , Disk(..)

  , includesLogicalId

  ])

$(makeJSONInstance ''DiskMode)

-- | The persistent block driver type. Currently only one type is allowed.

$(declareSADT "BlockDriver"

  [ ("BlockDrvManual", 'C.blockdevDriverManual)

  | LIDDrbd8 String String Int Int Int String

  -- ^ NodeA, NodeB, Port, MinorA, MinorB, Secret

  | LIDFile FileDriver String -- ^ Driver, path

  | LIDBlockDev BlockDriver String -- ^ Driver, path (must be under /dev)

  | LIDRados String String -- ^ Unused, path

  | LIDExt String String -- ^ ExtProvider, unique name

    deriving (Show, Eq)

-- | Mapping from a logical id to a disk type.

-- | Builds the extra disk_type field for a given logical id.

lidEncodeType :: DiskLogicalId -> [(String, JSValue)]

          , showJSON minorA, showJSON minorB, showJSON key ]

encodeDLId (LIDRados pool name) = JSArray [showJSON pool, showJSON name]

encodeDLId (LIDFile driver name) = JSArray [showJSON driver, showJSON name]

encodeDLId (LIDBlockDev driver name) = JSArray [showJSON driver, showJSON name]

encodeDLId (LIDExt extprovider name) =

  JSArray [showJSON extprovider, showJSON name]

decodeDLId obj lid = do

  dtype <- fromObj obj devType

  case dtype of

      case lid of

        JSArray [nA, nB, p, mA, mB, k] -> do

          nA' <- readJSON nA

          k'  <- readJSON k

          return $ LIDDrbd8 nA' nB' p' mA' mB' k'

        _ -> fail "Can't read logical_id for DRBD8 type"

      case lid of

        JSArray [vg, lv] -> do

          vg' <- readJSON vg

          lv' <- readJSON lv

          return $ LIDPlain vg' lv'

        _ -> fail "Can't read logical_id for plain type"

      case lid of

        JSArray [driver, path] -> do

          driver' <- readJSON driver

          path'   <- readJSON path

          return $ LIDFile driver' path'

        _ -> fail "Can't read logical_id for file type"

      case lid of

        JSArray [driver, path] -> do

          driver' <- readJSON driver

          path'   <- readJSON path

          return $ LIDBlockDev driver' path'

        _ -> fail "Can't read logical_id for blockdev type"

      case lid of

        JSArray [driver, path] -> do

          driver' <- readJSON driver

          path'   <- readJSON path

          return $ LIDRados driver' path'

        _ -> fail "Can't read logical_id for rdb type"

      case lid of

        JSArray [extprovider, name] -> do

          extprovider' <- readJSON extprovider

          name'   <- readJSON name

          return $ LIDExt extprovider' name'

        _ -> fail "Can't read logical_id for extstorage type"

-- | Disk data structure.

--

        disks = []

        disk_template = constants.DT_DISKLESS

      else:

                              logical_id=[pnode, snode, 1, 17, 17])]

        disk_template = constants.DT_DRBD8

  def testWithoutOldData(self):

    new = {

        "xenvg": {

          constants.DS_DISK_RESERVED: 1024,

          },

      }]

    result = self._TestTrivialDisk(constants.DT_PLAIN, disk_info, 3,

    self.assertEqual(map(operator.attrgetter("logical_id"), result), [

      ("testvg", "ec0-uq0.disk3"),

      self._SetUpLUWithTemplates([disk_template])

      result = self._TestTrivialDisk(disk_template, disk_info, 2,

        file_driver=constants.FD_BLKTAP)

      self.assertEqual(map(operator.attrgetter("logical_id"), result), [

      }]

    result = self._TestTrivialDisk(constants.DT_BLOCK, disk_info, 10,

    self.assertEqual(map(operator.attrgetter("logical_id"), result), [

      (constants.BLOCKDEV_DRIVER_MANUAL, "/tmp/some/block/dev"),

      }]

    result = self._TestTrivialDisk(constants.DT_RBD, disk_info, 0,

    self.assertEqual(map(operator.attrgetter("logical_id"), result), [

      ("rbd", "ec0-uq0.rbd.disk0"),

  def testDrbd8(self):

    gdt = instance.GenerateDiskTemplate

    drbd8_default_metavg = drbd8_defaults[constants.LDP_DEFAULT_METAVG]

    disk_info = [{

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

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

      self.assertEqual(disk.size, disk_info[idx][constants.IDISK_SIZE])

      self.assertEqual(disk.mode, disk_info[idx][constants.IDISK_MODE])

      for child in disk.children:

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

        self.assertTrue(child.children is None)

      self.assertEqual(map(operator.attrgetter("logical_id"), disk.children),

                 cfg=_ConfigForDiskWipe(node_name))

    disks = [

      ]

    inst = objects.Instance(name="inst21201",

                 cfg=_ConfigForDiskWipe(node_uuid))

    disks = [

                   size=100 * 1024),

                   size=500 * 1024),

      ]

    inst = objects.Instance(name="inst562",

  def testNormalWipe(self):

    disks = [

                   size=500 * 1024),

                   size=constants.MAX_WIPE_CHUNK),

      ]

  def testWipeWithStartOffset(self):

    for start_offset in [0, 280, 8895, 1563204]:

      disks = [

                     size=128),

                     size=start_offset + (100 * 1024)),

        ]

    self.failUnless(constants.OP_PRIO_HIGH > constants.OP_PRIO_HIGHEST)

  def testDiskDefaults(self):

    self.failUnless(set(constants.DISK_DT_DEFAULTS.keys()) ==

                    constants.DISK_TEMPLATES)

  def testManyDisks(self):

    for offset in [0, 1, 10]:

               for idx in range(len(hv_xen._DISK_LETTERS) + offset)]

      if offset == 0:

  def testTwoLvDisksWithMode(self):

    disks = [

       "/tmp/diskFirst"),

       "/tmp/diskLast"),

      ]

  def testFileDisks(self):

    disks = [

                    physical_id=[constants.FD_LOOP]),

       "/tmp/diskFirst"),

                    physical_id=[constants.FD_BLKTAP]),

       "/tmp/diskTwo"),

                    physical_id=[constants.FD_LOOP]),

       "/tmp/diskThree"),

                    physical_id=[constants.FD_BLKTAP]),

       "/tmp/diskLast"),

      ]

  def testInvalidFileDisk(self):

    disks = [

                    physical_id=["#unknown#"]),

       "/tmp/diskinvalid"),

      ]

      hvp[constants.HV_VNC_PASSWORD_FILE] = self.vncpw_path

    disks = [

       utils.PathJoin(self.tmpdir, "disk0")),

       utils.PathJoin(self.tmpdir, "disk1")),

      ]

    inst = objects.Instance(name="fakeinstplain.example.com",

      primary_node="node3.example.com",

      disks=[

                     logical_id=("myxenvg", "disk25494")),

                     logical_id=("myxenvg", "disk29071")),

        ])

    inst = objects.Instance(name="fakeinstdrbd.example.com",

      primary_node="node10.example.com",

      disks=[

          logical_id=("node10.example.com", "node15.example.com",

                      12300, 0, 0, "secret"),

          children=[

                         logical_id=("myxenvg", "disk0")),

                         logical_id=("myxenvg", "meta0"))

          ],

          iv_name="disk/0")

  def testDiskState(self):

    node = objects.Node(name="node32087.example.com", disk_state={

        "lv32352": objects.NodeDiskState(total=128),

        "lv2082": objects.NodeDiskState(total=512),

        },

    self.assertEqual(node2.name, "node32087.example.com")

    self.assertEqual(frozenset(node2.disk_state), frozenset([

      ]))

  def testFilterEsNdp(self):

    node1 = objects.Node(name="node11673.example.com", ndparams={

        ],

      disk_template=constants.DT_PLAIN,

      disks=[

                     logical_id=("vg", "disk6120")),

                     logical_id=("vg", "disk8508")),

        ])

    inst.UpgradeConfig()

      constants.HV_BOOT_ORDER: "xyz",

      })

    self.assertEqual(result["disks"], [{

      "size": 4096,

      "logical_id": ("vg", "disk6120"),

      "params": constants.DISK_DT_DEFAULTS[inst.disk_template],

      }, {

      "size": 1024,

      "logical_id": ("vg", "disk8508"),

      "params": constants.DISK_DT_DEFAULTS[inst.disk_template],

  """

  if "mode" not in disk:

    disk["mode"] = constants.DISK_RDWR

    old_lid = disk["logical_id"]

    for node in old_lid[:2]:

      if node not in drbd_minors:

      for child in disk["children"]:

        helper(child)

      if "physical_id" in disk:

        del disk["physical_id"]

      disk["logical_id"][1] = _Get(disk["logical_id"][1])

      disk["physical_id"][1] = disk["logical_id"][1]

      RandomizeDiskSecrets(child)

  # only disk type to contain secrets is the drbd one

    disk["logical_id"][5] = utils.GenerateSecret()

      RenameDiskNodes(child, node_map)

  # only disk type to contain nodes is the drbd one

    lid = disk["logical_id"]

    lid[0] = node_map[lid[0]]

    lid[1] = node_map[lid[1]]