Synnefo » snf-ganeti

      lvm_enabled = utils.storage.IsLvmEnabled(

          lu.cfg.GetClusterInfo().enabled_disk_templates)

      # FIXME: this per default asks for storage space information for all

      # enabled disk templates. Fix this by making it possible to specify

      # space report fields for specific disk templates.

      raw_storage_units = utils.storage.GetStorageUnitsOfCluster(

          lu.cfg, include_spindles=lvm_enabled)

          (uuid, rpc.MakeLegacyNodeInfo(nresult.payload,

                                        require_spindles=lvm_enabled))

    if disk_templates:

      storage_units_raw = utils.storage.GetStorageUnits(self.cfg,

                                                        disk_templates)

    else:

      # FIXME: eliminate this case

      storage_units_raw = utils.storage.GetStorageUnitsOfCluster(

         self.cfg, include_spindles=True)

        if not lvm_pv_info:

          raise errors.OpExecError("Node '%s' didn't return LVM pv space info."

                                   % (node_name))

        total_spindles = lvm_pv_info["storage_size"]

        free_spindles = lvm_pv_info["storage_free"]

      else:

        total_spindles = 0

        free_spindles = 0

    raise errors.OpExecError("No spindle storage information available.")

def _AddDefaultStorageInfoToLegacyNodeInfo(result, space_info):

  """Extracts the storage space information of the default storage type from

  # Check if there is at least one row for non-spindle storage info.

  no_defaults = (len(space_info) < 1) or \

      (space_info[0]["type"] == constants.ST_LVM_PV and len(space_info) == 1)

  default_space_info = None

  if no_defaults:

    logging.warning("No storage info provided for default storage type.")

    default_space_info = space_info[0]

  if default_space_info:

    result["name"] = default_space_info["name"]

    result["storage_free"] = default_space_info["storage_free"]

    result["storage_size"] = default_space_info["storage_size"]

def MakeLegacyNodeInfo(data, require_spindles=False):

  @param require_spindles: add spindle storage information to the legacy node

      info

  if require_spindles:

    _AddSpindlesToLegacyNodeInfo(ret, space_info)

  _AddDefaultStorageInfoToLegacyNodeInfo(ret, space_info)

def _GetDefaultStorageUnitForSpindles(cfg):

  """Creates a 'spindle' storage unit, by retrieving the volume group

  name and associating it to the lvm-pv storage type.

  @rtype: (string, string)

  @return: tuple (storage_type, storage_key), where storage type is

    'lvm-pv' and storage_key the name of the default volume group

  """

  return (constants.ST_LVM_PV, cfg.GetVGName())

def GetStorageUnitsOfCluster(cfg, include_spindles=False):

  """Examines the cluster's configuration and returns a list of storage

  units and their storage keys, ordered by the order in which they

  are enabled.

  @type cfg: L{config.ConfigWriter}

  @param cfg: Cluster configuration

  @type include_spindles: boolean

  @param include_spindles: flag to include an extra storage unit for physical

    volumes

  @rtype: list of tuples (string, string)

  @return: list of storage units, each storage unit being a tuple of

    (storage_type, storage_key); storage_type is in

    C{constants.STORAGE_TYPES} and the storage_key a string to

    identify an entity of that storage type, for example a volume group

    name for LVM storage or a file for file storage.

  """

  cluster_config = cfg.GetClusterInfo()

  storage_units = []

  for disk_template in cluster_config.enabled_disk_templates:

    if constants.MAP_DISK_TEMPLATE_STORAGE_TYPE[disk_template]\

        in constants.STS_REPORT:

      storage_units.append(

          _GetDefaultStorageUnitForDiskTemplate(cfg, disk_template))

  if include_spindles:

    included_storage_types = set([st for (st, _) in storage_units])

    if not constants.ST_LVM_PV in included_storage_types:

      storage_units.append(

          _GetDefaultStorageUnitForSpindles(cfg))

  return storage_units

    if constants.MAP_DISK_TEMPLATE_STORAGE_TYPE[disk_template]\

        in constants.STS_REPORT:

  if len(set(disk_templates) & constants.DTS_LVM) > 0:

    storage_units.append(

        _GetDefaultStorageUnitForSpindles(cfg))

  def testStandard(self):

    result = rpc.MakeLegacyNodeInfo(self.STD_LST)

  def testSpindlesRequired(self):

    my_lst = [self.VAL_BOOT, [], [self.DICT_HV]]

    self.assertRaises(errors.OpExecError, rpc.MakeLegacyNodeInfo, my_lst,

        require_spindles=True)

  def testNoSpindlesRequired(self):

    my_lst = [self.VAL_BOOT, [], [self.DICT_HV]]

    result = rpc.MakeLegacyNodeInfo(my_lst, require_spindles = False)

    self.assertEqual(result, {self.KEY_BOOT: self.VAL_BOOT,

                              self.KEY_CPU_COUNT: self.VAL_CPU_COUNT})

    result = rpc.MakeLegacyNodeInfo(self.STD_LST, require_spindles = False)

    self.assertEqual(result, self.STD_DICT)

class TestAddDefaultStorageInfoToLegacyNodeInfo(unittest.TestCase):

  def setUp(self):

    self.free_storage_file = 23

    self.total_storage_file = 42

    self.free_storage_lvm = 69

    self.total_storage_lvm = 666

    self.node_info = [{"name": "myfile",

                       "type": constants.ST_FILE,

                       "storage_free": self.free_storage_file,

                       "storage_size": self.total_storage_file},

                      {"name": "myvg",

                       "type": constants.ST_LVM_VG,

                       "storage_free": self.free_storage_lvm,

                       "storage_size": self.total_storage_lvm},

                      {"name": "myspindle",

                       "type": constants.ST_LVM_PV,

                       "storage_free": 33,

                       "storage_size": 44}]

  def testAddDefaultStorageInfoToLegacyNodeInfo(self):

    result = {}

    rpc._AddDefaultStorageInfoToLegacyNodeInfo(result, self.node_info)

    self.assertEqual(self.free_storage_file, result["storage_free"])

    self.assertEqual(self.total_storage_file, result["storage_size"])

  def testAddDefaultStorageInfoToLegacyNodeInfoNoDefaults(self):

    result = {}

    rpc._AddDefaultStorageInfoToLegacyNodeInfo(result, self.node_info[-1:])

    self.assertFalse("storage_free" in result)

    self.assertFalse("storage_size" in result)

from ganeti import objects

  def testGetDefaultStorageUnitForSpindles(self):

    (storage_type, storage_key) = \

        storage._GetDefaultStorageUnitForSpindles(self._cfg)

    self.assertEqual(storage_type, constants.ST_LVM_PV)

    self.assertEqual(storage_key, self._default_vg_name)

class TestGetStorageUnitsOfCluster(unittest.TestCase):

  def setUp(self):

    storage._GetDefaultStorageUnitForDiskTemplate = \

        mock.Mock(return_value=("foo", "bar"))

    self._cluster_cfg = objects.Cluster()

    self._enabled_disk_templates = \

        [constants.DT_DRBD8, constants.DT_PLAIN, constants.DT_FILE,

         constants.DT_SHARED_FILE]

    self._cluster_cfg.enabled_disk_templates = \

        self._enabled_disk_templates

    self._cfg = mock.Mock()

    self._cfg.GetClusterInfo = mock.Mock(return_value=self._cluster_cfg)

    self._cfg.GetVGName = mock.Mock(return_value="some_vg_name")

  def testGetStorageUnitsOfCluster(self):

    storage_units = storage.GetStorageUnitsOfCluster(self._cfg)

    self.assertEqual(len(storage_units), len(self._enabled_disk_templates))

  def testGetStorageUnitsOfClusterWithSpindles(self):

    storage_units = storage.GetStorageUnitsOfCluster(

        self._cfg, include_spindles=True)

    self.assertEqual(len(storage_units), len(self._enabled_disk_templates) + 1)

    self.assertTrue(constants.ST_LVM_PV in [st for (st, sk) in storage_units])

    self.assertEqual(len(storage_units), len(disk_templates) + 1)