#! /usr/libexec/platform-python

#
# Copyright Red Hat
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA. 
#

"""
  vdoStats - Report statistics from an Albireo VDO.

  $Id: //eng/vdo-releases/aluminum/src/python/vdo/vdoStats#6 $
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import argparse
import errno
import gettext
import locale
import os
import sys

from vdo.statistics import *
from vdo.utils import Command, CommandError, runCommand

gettext.install('vdo')

parser = argparse.ArgumentParser(
  description="Get configuration and statistics from a running VDO volume")

parser.add_argument("--all", "-a", action="store_true", dest="all",
                    help=_("Equivalent to --verbose"))
parser.add_argument("--human-readable", action="store_true",
                    dest="humanReadable",
                    help=_("Display stats in human-readable form"))
parser.add_argument("--si", action="store_true", dest="si",
                    help=_("Use SI units, implies --human-readable"))
parser.add_argument("--verbose", "-v", action="store_true", dest="verbose",
                    help=_("Include verbose statistics"))
parser.add_argument("--version", "-V", action="store_true", dest="version",
                    help=_("Print the vdostats version number and exit"))
parser.add_argument("devices", metavar="DEVICE", help="a VDO device", nargs="*")
                    

UNITS = [ 'B', 'K', 'M', 'G', 'T' ]

########################################################################
def makeDedupeFormatter(options):
  """
  Make the formatter for dedupe stats if needed.

  :param options:  The command line options

  :return: A formatter if needed or None
  """
  if not options.verbose:
    return None

  return StatFormatter([{ 'namer' : '+'  },
                        { 'indent': '  ', 'namer' : True }],
                       hierarchical=False)

########################################################################
def enumerateDevices():
  """
  Enumerate the list of VDO devices on this host.

  :return: A list of VDO device names
  """
  names = []
  try:
    names = [name.split(":")[0] for name in
             runCommand(["dmsetup", "status", "--target", "vdo"]).splitlines()
             if len(name) > 0]
    paths = [os.path.sep.join(["", "dev", "mapper", name]) for name in names]
    names = list(filter(os.path.exists, paths))
  except CommandError as e:
    print(_("Error enumerating VDO devices: {0}".format(e)), file = sys.stderr)
  return names

########################################################################
def transformDevices(devices):
  """
  Iterates over the list of provided devices transforming any standalone device
  name or absolute path that represents a resolved vdo device to the name/path
  of the vdo device using the vdo name specified at its creation.

  Returns a list of sampling dictionaries.

  :param devices: A list of devices to sample.

  :return:  The dictionary list of devices to sample.
  """
  paths = enumerateDevices()
  names = [os.path.basename(x) for x in paths]
  resolvedPaths = [os.path.realpath(x) for x in paths]
  resolvedNames = [os.path.basename(x) for x in resolvedPaths]
  resolvedToVdoName = dict(list(zip(resolvedNames, names)))
  resolvedToVdoPath = dict(list(zip(resolvedPaths, paths)))

  transformedDevices = []
  for (original, (head, tail)) in [(x, os.path.split(x)) for x in devices]:
    if tail in names:
      transformedDevices.append(Samples.samplingDevice(original, original))
      continue
    if tail in resolvedNames:
      if head == '':
        transformedDevices.append(
          Samples.samplingDevice(original, resolvedToVdoName[tail]))
        continue
      if os.path.isabs(original) and (original in resolvedPaths):
        transformedDevices.append(
          Samples.samplingDevice(original, resolvedToVdoPath[original]))
        continue
    transformedDevices.append(Samples.samplingDevice(original, original))

  return transformedDevices

########################################################################
def getDeviceStats(devices, assays):
  """
  Get the statistics for a given device.

  :param devices:  A list of devices to sample. If empty, all VDOs will
                   be sampled.
  :param assays:   The types of samples to take for each device

  :return:  A tuple whose first entry is the Samples and whose second entry
            is the exit status to use if no subsequent error occurs.
  """
  exitStatus = 0
  if not devices:
    mustBeVDO = False
    devices = [Samples.samplingDevice(x, x) for x in enumerateDevices()]
  else:
    mustBeVDO = True

    # Get the device dictionary containing transformations of references to a
    # vdo device's resolved name/path to references to its symbolic name/path.
    devices = transformDevices(devices)

    # Filter out any specified devices that do not exist.
    #
    # Any specified device that passes os.path.exists is passed through.
    # If it fails os.path.exists and is not a full path it is checked
    # against being an entry in either /dev/mapper or /proc/vdo.
    # If either of those exists the original device is passed through
    # unchanged.
    existingDevices = []
    for device in devices:
      user = device["user"]
      sample = device["sample"]
      if os.path.exists(sample):
        existingDevices.append(device)
      else:
        exists = False
        if (not os.path.isabs(sample)):
          exists = os.path.exists(os.path.sep.join(["", "dev", "mapper",
                                                    sample]))
          if (not exists):
            sample = os.path.sep.join(["", "proc", "vdo", sample])

        if ((not exists) and (not os.path.exists(sample))):
          print("'{0}': {1}".format(user, os.strerror(errno.ENOENT)),
                file = sys.stderr)
          exitStatus = 1
        else:
          existingDevices.append(device)
    devices = existingDevices

  if len(devices) > 0:
    return (Samples.assayDevices(assays, devices, mustBeVDO), exitStatus)
  return (None, exitStatus)

########################################################################
def formatSize(size, options):
  """
  Format a size (in KB) for printing.

  :param size:    The size in bytes.
  :param options: The command line options

  :return: The size formatted for printing based on the options
  """
  if isinstance(size, NotAvailable):
    return size

  if not options.humanReadable:
    return size

  size    *= 1024
  divisor  = 1000.0 if options.si else 1024.0
  unit     = 0
  while ((size >= divisor) and (unit < (len(UNITS) - 1))):
    size /= divisor
    unit += 1

  return "{0:>.1f}{1}".format(size, UNITS[unit])

########################################################################
def formatPercent(value):
  """
  Format a percentage for printing.

  :param value: The value to format

  :return: The formatted value
  """
  return value if isinstance(value, NotAvailable) else "{0}%".format(value)

########################################################################
def dfStats(sample, options):
  """
  Extract the values needed for df-style output from a sample.

  :param sample:  The sample from which to extract df values
  :param options: The command line options
  """
  return ([formatSize(sample.getStat(statName), options)
           for statName in
           ["oneKBlocks", "oneKBlocksUsed", "oneKBlocksAvailable"]]
          + [formatPercent(sample.getStat(statName))
             for statName in ["usedPercent", "savingPercent"]])

########################################################################
def printDF(stats, options):
  """
  Print stats in df-style.

  :param stats:   A list of samples, one for each device sampled
  :param options: The command line options
  """
  dfFormat = "{0:<20} {1:>9} {2:>9} {3:>9} {4:>4} {5:>13}"
  print(dfFormat.format("Device",
                        "Size" if options.humanReadable else "1K-blocks",
                        "Used", "Available", "Use%", "Space saving%"))
  for stat in stats:
    lst = [stat.getDevice()] + dfStats(stat.getSamples()[0], options)
    print(dfFormat.format(*lst))

########################################################################
def printYAML(stats, dedupeFormatter):
  """
  Print stats as (pseudo) YAML.

  :param stats:           A list of Samples, one for each device sampled
  :param dedupeFormatter: The formatter for dedupe stats (may be None)
  """
  for stat in stats:
    samples = stat.getSamples()
    if dedupeFormatter:
      dedupeFormatter.output(LabeledValue.make(stat.getDevice(),
                                               [s.labeled() for s in samples]))

########################################################################
def main():
  try:
    locale.setlocale(locale.LC_ALL, '')
  except locale.Error:
    pass

  options = parser.parse_args()
  if options.version:
    print("{0}.{1}".format(CURRENT_RELEASE_VERSION_NUMBER,
                           VDOStatistics.statisticsVersion))
    sys.exit(0)

  if options.all:
    options.verbose = True
  if options.si:
    options.humanReadable = True

  dedupeFormatter = makeDedupeFormatter(options)

  if options.verbose:
    statsTypes = [VDOStatistics(), KernelStatistics()]
  else:
    statsTypes = [VDOStatistics()]

  exitStatus = 0
  try:
    (stats, exitStatus) = getDeviceStats(options.devices, statsTypes)
    if not stats:
      return exitStatus
  except Exception as e:
    print(e, file = sys.stderr)
    return 1

  if options.verbose:
    printYAML(stats, dedupeFormatter)
  else:
    printDF(stats, options)

  return exitStatus

########################################################################
if __name__ == "__main__":
  sys.exit(main())