Synnefo » snf-ganeti

  def perspective_node_volumes(self, params):

    return backend.NodeVolumes()

def NodeVolumes():

  """List all volumes on this node.

  """

  result = utils.RunCmd(["lvs", "--noheadings", "--units=m", "--nosuffix",

                         "--separator=|",

                         "--options=lv_name,lv_size,devices,vg_name"])

  if result.failed:

    logger.Error("Failed to list logical volumes, lvs output: %s" %

                 result.output)

    return {}

  def parse_dev(dev):

    if '(' in dev:

      return dev.split('(')[0]

    else:

      return dev

  def map_line(line):

    return {

      'name': line[0].strip(),

      'size': line[1].strip(),

      'dev': parse_dev(line[2].strip()),

      'vg': line[3].strip(),

    }

  return [map_line(line.split('|')) for line in result.output.splitlines()]

           "USEUNITS_OPT", "FIELDS_OPT"]

FIELDS_OPT = make_option("-o", "--output", dest="output", action="store",

                         type="string", help="Select output fields",

                         metavar="FIELDS")

def _GetWantedNodes(lu, nodes):

  if nodes is not None and not isinstance(nodes, list):

    raise errors.OpPrereqError, "Invalid argument type 'nodes'"

  if nodes:

    wanted_nodes = []

    for name in nodes:

      node = lu.cfg.GetNodeInfo(lu.cfg.ExpandNodeName(name))

      if node is None:

        raise errors.OpPrereqError, ("No such node name '%s'" % name)

    wanted_nodes.append(node)

    return wanted_nodes

  else:

    return [lu.cfg.GetNodeInfo(name) for name in lu.cfg.GetNodeList()]

def _CheckOutputFields(static, dynamic, selected):

    static_fields = frozenset(static)

    dynamic_fields = frozenset(dynamic)

    all_fields = static_fields | dynamic_fields

    if not all_fields.issuperset(selected):

      raise errors.OpPrereqError, ("Unknown output fields selected: %s"

                                   % ",".join(frozenset(selected).

                                              difference(all_fields)))

    _CheckOutputFields(static=["name", "pinst", "sinst", "pip", "sip"],

                       dynamic=self.dynamic_fields,

                       selected=self.op.output_fields)

class LUQueryNodeVolumes(NoHooksLU):

  """Logical unit for getting volumes on node(s).

  """

  _OP_REQP = ["nodes", "output_fields"]

  def CheckPrereq(self):

    """Check prerequisites.

    This checks that the fields required are valid output fields.

    """

    self.nodes = _GetWantedNodes(self, self.op.nodes)

    _CheckOutputFields(static=["node"],

                       dynamic=["phys", "vg", "name", "size", "instance"],

                       selected=self.op.output_fields)

  def Exec(self, feedback_fn):

    """Computes the list of nodes and their attributes.

    """

    nodenames = utils.NiceSort([node.name for node in self.nodes])

    volumes = rpc.call_node_volumes(nodenames)

    ilist = [self.cfg.GetInstanceInfo(iname) for iname

             in self.cfg.GetInstanceList()]

    lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])

    output = []

    for node in nodenames:

      node_vols = volumes[node][:]

      node_vols.sort(key=lambda vol: vol['dev'])

      for vol in node_vols:

        node_output = []

        for field in self.op.output_fields:

          if field == "node":

            val = node

          elif field == "phys":

            val = vol['dev']

          elif field == "vg":

            val = vol['vg']

          elif field == "name":

            val = vol['name']

          elif field == "size":

            val = int(float(vol['size']))

          elif field == "instance":

            for inst in ilist:

              if node not in lv_by_node[inst]:

                continue

              if vol['name'] in lv_by_node[inst][node]:

                val = inst.name

                break

            else:

              val = '-'

          else:

            raise errors.ParameterError, field

          node_output.append(str(val))

        output.append(node_output)

    return output

    self.nodes = _GetWantedNodes(self, self.op.nodes)

    self.nodes = _GetWantedNodes(self, self.op.nodes)

      result = utils.RunCmd(["ssh", node.name, self.op.command])

      data.append((node.name, result.cmd, result.output, result.exit_code))

  _OP_REQP = ["output_fields"]

    _CheckOutputFields(static=["name", "os", "pnode", "snodes",

                               "admin_state", "admin_ram",

                               "disk_template", "ip", "mac", "bridge"],

                       dynamic=self.dynamic_fields,

                       selected=self.op.output_fields)

    self.wanted_nodes = _GetWantedNodes(self, self.op.nodes)

    self.nodes = _GetWantedNodes(self, getattr(self.op, "nodes", None))

    return rpc.call_export_list([node.name for node in self.nodes])

    opcodes.OpQueryNodeVolumes: cmdlib.LUQueryNodeVolumes,

class OpQueryNodeVolumes(OpCode):

  """Get list of volumes on node."""

  OP_ID = "OP_NODE_QUERYVOLS"

  __slots__ = ["nodes", "output_fields"]

def call_node_volumes(node_list):

  """Gets all volumes on node(s).

  This is a multi-node call.

  """

  c = Client("node_volumes", [])

  c.connect_list(node_list)

  c.run()

  return c.getresult()

    <refsect2>

      <title>VOLUMES</title>

      <cmdsynopsis>

        <command>volumes</command>

        <arg rep="repeat"><replaceable>node</replaceable></arg>

      </cmdsynopsis>

      <para>

        Lists all logical volumes and their physical disks from the node(s)

        provided.

      </para>

      <para>

        Example:

        <screen>

# gnt-node volumes node5.example.com

Node              PhysDev   VG    Name                                 Size Instance

node1.example.com /dev/hdc1 xenvg instance1.example.com-sda_11000.meta 128  instance1.example.com

node1.example.com /dev/hdc1 xenvg instance1.example.com-sda_11001.data 256  instance1.example.com

        </screen>

      </para>

    </refsect2>

           [DEBUG_OPT, NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT],

def ListVolumes(opts, args):

  """List logical volumes on node(s).

  """

  if opts.output is None:

    selected_fields = ["node", "phys", "vg",

                       "name", "size", "instance"]

  else:

    selected_fields = opts.output.split(",")

  op = opcodes.OpQueryNodeVolumes(nodes=args, output_fields=selected_fields)

  output = SubmitOpCode(op)

  mlens = [0 for name in selected_fields]

  format_fields = []

  unitformat_fields = ("size",)

  for field in selected_fields:

    if field in unitformat_fields:

      format_fields.append("%*s")

    else:

      format_fields.append("%-*s")

  separator = opts.separator

  if "%" in separator:

    separator = separator.replace("%", "%%")

  format = separator.join(format_fields)

  for row in output:

    for idx, val in enumerate(row):

      if opts.human_readable and selected_fields[idx] in unitformat_fields:

        try:

          val = int(val)

        except ValueError:

          pass

        else:

          val = row[idx] = utils.FormatUnit(val)

      mlens[idx] = max(mlens[idx], len(val))

  if not opts.no_headers:

    header_list = {"node": "Node", "phys": "PhysDev",

                   "vg": "VG", "name": "Name",

                   "size": "Size", "instance": "Instance"}

    args = []

    for idx, name in enumerate(selected_fields):

      hdr = header_list[name]

      mlens[idx] = max(mlens[idx], len(hdr))

      args.append(mlens[idx])

      args.append(hdr)

    logger.ToStdout(format % tuple(args))

  for row in output:

    args = []

    for idx, val in enumerate(row):

      args.append(mlens[idx])

      args.append(val)

    logger.ToStdout(format % tuple(args))

  return 0

           [DEBUG_OPT, NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT],

  'volumes': (ListVolumes, ARGS_ANY,

              [DEBUG_OPT, NOHDR_OPT, SEP_OPT, USEUNITS_OPT, FIELDS_OPT],

              "[<node_name>...]", "List logical volumes on node(s)"),