Synnefo » snf-ganeti

  _FIELDS_STATIC = utils.FieldSet(constants.SF_NODE)

    if storage_type not in constants.VALID_STORAGE_TYPES:

                       dynamic=utils.FieldSet(*constants.VALID_STORAGE_FIELDS),

    # Never ask for node or type as it's only known to the LU

    for extra in [constants.SF_NODE, constants.SF_TYPE]:

      while extra in fields:

        fields.remove(extra)

          if field == constants.SF_NODE:

          elif field == constants.SF_TYPE:

            val = self.op.storage_type

    if storage_type not in constants.VALID_STORAGE_TYPES:

# first two are valid in LU context only, not passed to backend

SF_NODE = "node"

SF_TYPE = "type"

# and the rest are valid in backend

VALID_STORAGE_FIELDS = frozenset([SF_NAME, SF_TYPE, SF_SIZE,

                                  SF_USED, SF_FREE, SF_ALLOCATABLE])

VALID_STORAGE_TYPES = frozenset([ST_FILE, ST_LVM_PV, ST_LVM_VG])

    if constants.SF_FREE in fields or constants.SF_SIZE in fields:

      fsstats = utils.GetFilesystemStats(path)

      fsstats = None

        values.append(fsstats[1])

      elif field_name == constants.SF_SIZE:

        values.append(fsstats[0])

      elif field_name == constants.SF_ALLOCATABLE:

        values.append(True)

  @cvar LIST_FIELDS: list of tuples consisting of three elements: SF_*

      constants, lvm command output fields (list), and conversion

      function or static value (for static value, the lvm output field

      can be an empty list)

      (_, lvm_names, _) = fields_def[idx]

      lvm_fields.extend(lvm_names)

        (_, lvm_names, mapper) = fields_def[field_to_idx[field_name]]

        values = [raw_data[lvm_name_to_idx[i]] for i in lvm_names]

        if callable(mapper):

          # we got a function, call it with all the declared fields

          val = mapper(*values)

        elif len(values) == 1:

          # we don't have a function, but we had a single field

          # declared, pass it unchanged

          val = values[0]

        else:

          # let's make sure there are no fields declared (cannot map >

          # 1 field without a function)

          assert not values, "LVM storage has multi-fields without a function"

          val = mapper

        row.append(val)

        logging.warning("Invalid line returned from lvm command: %s", line)

    (constants.SF_NAME, ["pv_name"], None),

    (constants.SF_SIZE, ["pv_size"], _ParseSize),

    (constants.SF_USED, ["pv_used"], _ParseSize),

    (constants.SF_FREE, ["pv_free"], _ParseSize),

    (constants.SF_ALLOCATABLE, ["pv_attr"], _GetAllocatable),

    (constants.SF_NAME, ["vg_name"], None),

    (constants.SF_SIZE, ["vg_size"], _ParseSize),

    (constants.SF_FREE, ["vg_free"], _ParseSize),

    (constants.SF_USED, ["vg_size", "vg_free"],

     lambda x, y: _ParseSize(x) - _ParseSize(y)),

    (constants.SF_ALLOCATABLE, [], True),

def GetFilesystemStats(path):

  """Returns the total and free space on a filesystem.

  @return: tuple of (Total space, Free space) in mebibytes

  fsize = BytesToMebibyte(st.f_bavail * st.f_frsize)

  tsize = BytesToMebibyte(st.f_blocks * st.f_frsize)

  return (tsize, fsize)

        <literal>lvm-vg</literal> or <literal>file</literal>.

            <term>type</term>

            <listitem>

              <simpara>the type of the storage unit (currently just

              what is passed in via

              <option>--storage-type</option>)</simpara>

            </listitem>

          </varlistentry>

          <varlistentry>

              <simpara>the path/identifier of the storage unit</simpara>

                total size of the unit; for the file type see a note below

                used space in the unit; for the file type see a note below

                whether we the unit is available for allocation

                (only <literal>lvm-pv</literal> can change this

                setting, the other types always report true)

        Note that for the <quote>file</quote> type, the total disk

        space might not equal to the sum of used and free, due to the

        method Ganeti uses to compute each of them. The total and free

        values are computed as the total and free space values for the

        filesystem to which the directory belongs, but the used space

        is computed from the used space under that directory

        <emphasis>only</emphasis>, which might not be necessarily the

        root of the filesystem, and as such there could be files

        outside the file storage directory using disk space and

        causing a mismatch in the values.

      </para>

      <para>

node1# gnt-node list-storage node2

Node  Type   Name        Size Used   Free Allocatable

node2 lvm-pv /dev/sda7 673.8G 1.5G 672.3G Y

node2 lvm-pv /dev/sdb1 698.6G   0M 698.6G Y

#: default list of field for L{ListStorage}

_LIST_STOR_DEF_FIELDS = [

  constants.SF_NODE,

  constants.SF_TYPE,

  constants.SF_NAME,

  constants.SF_SIZE,

  constants.SF_USED,

  constants.SF_FREE,

  constants.SF_ALLOCATABLE,

  ]

#: headers (and full field list for L{ListStorage}

_LIST_STOR_HEADERS = {

  constants.SF_NODE: "Node",

  constants.SF_TYPE: "Type",

  constants.SF_NAME: "Name",

  constants.SF_SIZE: "Size",

  constants.SF_USED: "Used",

  constants.SF_FREE: "Free",

  constants.SF_ALLOCATABLE: "Allocatable",

  }

    selected_fields = _LIST_STOR_DEF_FIELDS

    selected_fields = _LIST_STOR_DEF_FIELDS + opts.output[1:].split(",")

      constants.SF_NODE: "Node",

      constants.SF_TYPE: "Type",

  else:

    ToStderr("No changes to perform, exiting.")

    "[<node_name>...]", "List physical volumes on node(s). The available"

    " fields are (see the man page for details): %s." %

    (", ".join(_LIST_STOR_HEADERS))),