Synnefo » snf-ganeti » ganeti-local

#!/usr/bin/python

#

# Copyright (C) 2009, 2010, 2011, 2012 Google Inc.

#

# 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.

"""Script to generate bash_completion script for Ganeti.

"""

# pylint: disable=C0103

# [C0103] Invalid name build-bash-completion

import os

import os.path

import re

import itertools

import optparse

from cStringIO import StringIO

from ganeti import constants

from ganeti import cli

from ganeti import utils

from ganeti import build

from ganeti import pathutils

# _autoconf shouldn't be imported from anywhere except constants.py, but we're

# making an exception here because this script is only used at build time.

from ganeti import _autoconf

#: Regular expression describing desired format of option names. Long names can

#: contain lowercase characters, numbers and dashes only.

_OPT_NAME_RE = re.compile(r"^-[a-zA-Z0-9]|--[a-z][-a-z0-9]+$")

def WritePreamble(sw, support_debug):

  """Writes the script preamble.

  Helper functions should be written here.

  """

  sw.Write("# This script is automatically generated at build time.")

  sw.Write("# Do not modify manually.")

  if support_debug:

    sw.Write("_gnt_log() {")

    sw.IncIndent()

    try:

      sw.Write("if [[ -n \"$GANETI_COMPL_LOG\" ]]; then")

      sw.IncIndent()

      try:

        sw.Write("{")

        sw.IncIndent()

        try:

          sw.Write("echo ---")

          sw.Write("echo \"$@\"")

          sw.Write("echo")

        finally:

          sw.DecIndent()

        sw.Write("} >> $GANETI_COMPL_LOG")

      finally:

        sw.DecIndent()

      sw.Write("fi")

    finally:

      sw.DecIndent()

    sw.Write("}")

  sw.Write("_ganeti_nodes() {")

  sw.IncIndent()

  try:

    node_list_path = os.path.join(pathutils.DATA_DIR, "ssconf_node_list")

    sw.Write("cat %s 2>/dev/null || :", utils.ShellQuote(node_list_path))

  finally:

    sw.DecIndent()

  sw.Write("}")

  sw.Write("_ganeti_instances() {")

  sw.IncIndent()

  try:

    instance_list_path = os.path.join(pathutils.DATA_DIR,

                                      "ssconf_instance_list")

    sw.Write("cat %s 2>/dev/null || :", utils.ShellQuote(instance_list_path))

  finally:

    sw.DecIndent()

  sw.Write("}")

  sw.Write("_ganeti_jobs() {")

  sw.IncIndent()

  try:

    # FIXME: this is really going into the internals of the job queue

    sw.Write(("local jlist=($( shopt -s nullglob &&"

              " cd %s 2>/dev/null && echo job-* || : ))"),

             utils.ShellQuote(pathutils.QUEUE_DIR))

    sw.Write('echo "${jlist[@]/job-/}"')

  finally:

    sw.DecIndent()

  sw.Write("}")

  for (fnname, paths) in [

    ("os", pathutils.OS_SEARCH_PATH),

    ("iallocator", constants.IALLOCATOR_SEARCH_PATH),

    ]:

    sw.Write("_ganeti_%s() {", fnname)

    sw.IncIndent()

    try:

      # FIXME: Make querying the master for all OSes cheap

      for path in paths:

        sw.Write("( shopt -s nullglob && cd %s 2>/dev/null && echo * || : )",

                 utils.ShellQuote(path))

    finally:

      sw.DecIndent()

    sw.Write("}")

  sw.Write("_ganeti_nodegroup() {")

  sw.IncIndent()

  try:

    nodegroups_path = os.path.join(pathutils.DATA_DIR, "ssconf_nodegroups")

    sw.Write("cat %s 2>/dev/null || :", utils.ShellQuote(nodegroups_path))

  finally:

    sw.DecIndent()

  sw.Write("}")

  sw.Write("_ganeti_network() {")

  sw.IncIndent()

  try:

    networks_path = os.path.join(pathutils.DATA_DIR, "ssconf_networks")

    sw.Write("cat %s 2>/dev/null || :", utils.ShellQuote(networks_path))

  finally:

    sw.DecIndent()

  sw.Write("}")

  # Params: <offset> <options with values> <options without values>

  # Result variable: $first_arg_idx

  sw.Write("_ganeti_find_first_arg() {")

  sw.IncIndent()

  try:

    sw.Write("local w i")

    sw.Write("first_arg_idx=")

    sw.Write("for (( i=$1; i < COMP_CWORD; ++i )); do")

    sw.IncIndent()

    try:

      sw.Write("w=${COMP_WORDS[$i]}")

      # Skip option value

      sw.Write("""if [[ -n "$2" && "$w" == @($2) ]]; then let ++i""")

      # Skip

      sw.Write("""elif [[ -n "$3" && "$w" == @($3) ]]; then :""")

      # Ah, we found the first argument

      sw.Write("else first_arg_idx=$i; break;")

      sw.Write("fi")

    finally:

      sw.DecIndent()

    sw.Write("done")

  finally:

    sw.DecIndent()

  sw.Write("}")

  # Params: <list of options separated by space>

  # Input variable: $first_arg_idx

  # Result variables: $arg_idx, $choices

  sw.Write("_ganeti_list_options() {")

  sw.IncIndent()

  try:

    sw.Write("""if [[ -z "$first_arg_idx" ]]; then""")

    sw.IncIndent()

    try:

      sw.Write("arg_idx=0")

      # Show options only if the current word starts with a dash

      sw.Write("""if [[ "$cur" == -* ]]; then""")

      sw.IncIndent()

      try:

        sw.Write("choices=$1")

      finally:

        sw.DecIndent()

      sw.Write("fi")

      sw.Write("return")

    finally:

      sw.DecIndent()

    sw.Write("fi")

    # Calculate position of current argument

    sw.Write("arg_idx=$(( COMP_CWORD - first_arg_idx ))")

    sw.Write("choices=")

  finally:

    sw.DecIndent()

  sw.Write("}")

  # Params: <long options with equal sign> <all options>

  # Result variable: $optcur

  sw.Write("_gnt_checkopt() {")

  sw.IncIndent()

  try:

    sw.Write("""if [[ -n "$1" && "$cur" == @($1) ]]; then""")

    sw.IncIndent()

    try:

      sw.Write("optcur=\"${cur#--*=}\"")

      sw.Write("return 0")

    finally:

      sw.DecIndent()

    sw.Write("""elif [[ -n "$2" && "$prev" == @($2) ]]; then""")

    sw.IncIndent()

    try:

      sw.Write("optcur=\"$cur\"")

      sw.Write("return 0")

    finally:

      sw.DecIndent()

    sw.Write("fi")

    if support_debug:

      sw.Write("_gnt_log optcur=\"'$optcur'\"")

    sw.Write("return 1")

  finally:

    sw.DecIndent()

  sw.Write("}")

  # Params: <compgen options>

  # Result variable: $COMPREPLY

  sw.Write("_gnt_compgen() {")

  sw.IncIndent()

  try:

    sw.Write("""COMPREPLY=( $(compgen "$@") )""")

    if support_debug:

      sw.Write("_gnt_log COMPREPLY=\"${COMPREPLY[@]}\"")

  finally:

    sw.DecIndent()

  sw.Write("}")

def WriteCompReply(sw, args, cur="\"$cur\""):

  sw.Write("_gnt_compgen %s -- %s", args, cur)

  sw.Write("return")

class CompletionWriter:

  """Command completion writer class.

  """

  def __init__(self, arg_offset, opts, args, support_debug):

    self.arg_offset = arg_offset

    self.opts = opts

    self.args = args

    self.support_debug = support_debug

    for opt in opts:

      # While documented, these variables aren't seen as public attributes by

      # pylint. pylint: disable=W0212

      opt.all_names = sorted(opt._short_opts + opt._long_opts)

      invalid = list(itertools.ifilterfalse(_OPT_NAME_RE.match, opt.all_names))

      if invalid:

        raise Exception("Option names don't match regular expression '%s': %s" %

                        (_OPT_NAME_RE.pattern, utils.CommaJoin(invalid)))

  def _FindFirstArgument(self, sw):

    ignore = []

    skip_one = []

    for opt in self.opts:

      if opt.takes_value():

        # Ignore value

        for i in opt.all_names:

          if i.startswith("--"):

            ignore.append("%s=*" % utils.ShellQuote(i))

          skip_one.append(utils.ShellQuote(i))

      else:

        ignore.extend([utils.ShellQuote(i) for i in opt.all_names])

    ignore = sorted(utils.UniqueSequence(ignore))

    skip_one = sorted(utils.UniqueSequence(skip_one))

    if ignore or skip_one:

      # Try to locate first argument

      sw.Write("_ganeti_find_first_arg %s %s %s",

               self.arg_offset + 1,

               utils.ShellQuote("|".join(skip_one)),

               utils.ShellQuote("|".join(ignore)))

    else:

      # When there are no options the first argument is always at position

      # offset + 1

      sw.Write("first_arg_idx=%s", self.arg_offset + 1)

  def _CompleteOptionValues(self, sw):

    # Group by values

    # "values" -> [optname1, optname2, ...]

    values = {}

    for opt in self.opts:

      if not opt.takes_value():

        continue

      # Only static choices implemented so far (e.g. no node list)

      suggest = getattr(opt, "completion_suggest", None)

      # our custom option type

      if opt.type == "bool":

        suggest = ["yes", "no"]

      if not suggest:

        suggest = opt.choices

      if (isinstance(suggest, (int, long)) and

          suggest in cli.OPT_COMPL_ALL):

        key = suggest

      elif suggest:

        key = " ".join(sorted(suggest))

      else:

        key = ""

      values.setdefault(key, []).extend(opt.all_names)

    # Don't write any code if there are no option values

    if not values:

      return

    cur = "\"$optcur\""

    wrote_opt = False

    for (suggest, allnames) in values.items():

      longnames = [i for i in allnames if i.startswith("--")]

      if wrote_opt:

        condcmd = "elif"

      else:

        condcmd = "if"

      sw.Write("%s _gnt_checkopt %s %s; then", condcmd,

               utils.ShellQuote("|".join(["%s=*" % i for i in longnames])),

               utils.ShellQuote("|".join(allnames)))

      sw.IncIndent()

      try:

        if suggest == cli.OPT_COMPL_MANY_NODES:

          # TODO: Implement comma-separated values

          WriteCompReply(sw, "-W ''", cur=cur)

        elif suggest == cli.OPT_COMPL_ONE_NODE:

          WriteCompReply(sw, "-W \"$(_ganeti_nodes)\"", cur=cur)

        elif suggest == cli.OPT_COMPL_ONE_INSTANCE:

          WriteCompReply(sw, "-W \"$(_ganeti_instances)\"", cur=cur)

        elif suggest == cli.OPT_COMPL_ONE_OS:

          WriteCompReply(sw, "-W \"$(_ganeti_os)\"", cur=cur)

        elif suggest == cli.OPT_COMPL_ONE_EXTSTORAGE:

          WriteCompReply(sw, "-W \"$(_ganeti_extstorage)\"", cur=cur)

        elif suggest == cli.OPT_COMPL_ONE_IALLOCATOR:

          WriteCompReply(sw, "-W \"$(_ganeti_iallocator)\"", cur=cur)

        elif suggest == cli.OPT_COMPL_ONE_NODEGROUP:

          WriteCompReply(sw, "-W \"$(_ganeti_nodegroup)\"", cur=cur)

        elif suggest == cli.OPT_COMPL_ONE_NETWORK:

          WriteCompReply(sw, "-W \"$(_ganeti_network)\"", cur=cur)

        elif suggest == cli.OPT_COMPL_INST_ADD_NODES:

          sw.Write("local tmp= node1= pfx= curvalue=\"${optcur#*:}\"")

          sw.Write("if [[ \"$optcur\" == *:* ]]; then")

          sw.IncIndent()

          try:

            sw.Write("node1=\"${optcur%%:*}\"")

            sw.Write("if [[ \"$COMP_WORDBREAKS\" != *:* ]]; then")

            sw.IncIndent()

            try:

              sw.Write("pfx=\"$node1:\"")

            finally:

              sw.DecIndent()

            sw.Write("fi")

          finally:

            sw.DecIndent()

          sw.Write("fi")

          if self.support_debug:

            sw.Write("_gnt_log pfx=\"'$pfx'\" curvalue=\"'$curvalue'\""

                     " node1=\"'$node1'\"")

          sw.Write("for i in $(_ganeti_nodes); do")

          sw.IncIndent()

          try:

            sw.Write("if [[ -z \"$node1\" ]]; then")

            sw.IncIndent()

            try:

              sw.Write("tmp=\"$tmp $i $i:\"")

            finally:

              sw.DecIndent()

            sw.Write("elif [[ \"$i\" != \"$node1\" ]]; then")

            sw.IncIndent()

            try:

              sw.Write("tmp=\"$tmp $i\"")

            finally:

              sw.DecIndent()

            sw.Write("fi")

          finally:

            sw.DecIndent()

          sw.Write("done")

          WriteCompReply(sw, "-P \"$pfx\" -W \"$tmp\"", cur="\"$curvalue\"")

        else:

          WriteCompReply(sw, "-W %s" % utils.ShellQuote(suggest), cur=cur)

      finally:

        sw.DecIndent()

      wrote_opt = True

    if wrote_opt:

      sw.Write("fi")

    return

  def _CompleteArguments(self, sw):

    if not (self.opts or self.args):

      return

    all_option_names = []

    for opt in self.opts:

      all_option_names.extend(opt.all_names)

    all_option_names.sort()

    # List options if no argument has been specified yet

    sw.Write("_ganeti_list_options %s",

             utils.ShellQuote(" ".join(all_option_names)))

    if self.args:

      last_idx = len(self.args) - 1

      last_arg_end = 0

      varlen_arg_idx = None

      wrote_arg = False

      sw.Write("compgenargs=")

      for idx, arg in enumerate(self.args):

        assert arg.min is not None and arg.min >= 0

        assert not (idx < last_idx and arg.max is None)

        if arg.min != arg.max or arg.max is None:

          if varlen_arg_idx is not None:

            raise Exception("Only one argument can have a variable length")

          varlen_arg_idx = idx

        compgenargs = []

        if isinstance(arg, cli.ArgUnknown):

          choices = ""

        elif isinstance(arg, cli.ArgSuggest):

          choices = utils.ShellQuote(" ".join(arg.choices))

        elif isinstance(arg, cli.ArgInstance):

          choices = "$(_ganeti_instances)"

        elif isinstance(arg, cli.ArgNode):

          choices = "$(_ganeti_nodes)"

        elif isinstance(arg, cli.ArgGroup):

          choices = "$(_ganeti_nodegroup)"

        elif isinstance(arg, cli.ArgNetwork):

          choices = "$(_ganeti_network)"

        elif isinstance(arg, cli.ArgJobId):

          choices = "$(_ganeti_jobs)"

        elif isinstance(arg, cli.ArgOs):

          choices = "$(_ganeti_os)"

        elif isinstance(arg, cli.ArgExtStorage):

          choices = "$(_ganeti_extstorage)"

        elif isinstance(arg, cli.ArgFile):

          choices = ""

          compgenargs.append("-f")

        elif isinstance(arg, cli.ArgCommand):

          choices = ""

          compgenargs.append("-c")

        elif isinstance(arg, cli.ArgHost):

          choices = ""

          compgenargs.append("-A hostname")

        else:

          raise Exception("Unknown argument type %r" % arg)

        if arg.min == 1 and arg.max == 1:

          cmpcode = """"$arg_idx" == %d""" % (last_arg_end)

        elif arg.max is None:

          cmpcode = """"$arg_idx" -ge %d""" % (last_arg_end)

        elif arg.min <= arg.max:

          cmpcode = (""""$arg_idx" -ge %d && "$arg_idx" -lt %d""" %

                     (last_arg_end, last_arg_end + arg.max))

        else:

          raise Exception("Unable to generate argument position condition")

        last_arg_end += arg.min

        if choices or compgenargs:

          if wrote_arg:

            condcmd = "elif"

          else:

            condcmd = "if"

          sw.Write("""%s [[ %s ]]; then""", condcmd, cmpcode)

          sw.IncIndent()

          try:

            if choices:

              sw.Write("""choices="$choices "%s""", choices)

            if compgenargs:

              sw.Write("compgenargs=%s",

                       utils.ShellQuote(" ".join(compgenargs)))

          finally:

            sw.DecIndent()

          wrote_arg = True

      if wrote_arg:

        sw.Write("fi")

    if self.args:

      WriteCompReply(sw, """-W "$choices" $compgenargs""")

    else:

      # $compgenargs exists only if there are arguments

      WriteCompReply(sw, '-W "$choices"')

  def WriteTo(self, sw):

    self._FindFirstArgument(sw)

    self._CompleteOptionValues(sw)

    self._CompleteArguments(sw)

def WriteCompletion(sw, scriptname, funcname, support_debug,

                    commands=None,

                    opts=None, args=None):

  """Writes the completion code for one command.

  @type sw: ShellWriter

  @param sw: Script writer

  @type scriptname: string

  @param scriptname: Name of command line program

  @type funcname: string

  @param funcname: Shell function name

  @type commands: list

  @param commands: List of all subcommands in this program

  """

  sw.Write("%s() {", funcname)

  sw.IncIndent()

  try:

    sw.Write("local "

             ' cur="${COMP_WORDS[COMP_CWORD]}"'

             ' prev="${COMP_WORDS[COMP_CWORD-1]}"'

             ' i first_arg_idx choices compgenargs arg_idx optcur')

    if support_debug:

      sw.Write("_gnt_log cur=\"$cur\" prev=\"$prev\"")

      sw.Write("[[ -n \"$GANETI_COMPL_LOG\" ]] &&"

               " _gnt_log \"$(set | grep ^COMP_)\"")

    sw.Write("COMPREPLY=()")

    if opts is not None and args is not None:

      assert not commands

      CompletionWriter(0, opts, args, support_debug).WriteTo(sw)

    else:

      sw.Write("""if [[ "$COMP_CWORD" == 1 ]]; then""")

      sw.IncIndent()

      try:

        # Complete the command name

        WriteCompReply(sw,

                       ("-W %s" %

                        utils.ShellQuote(" ".join(sorted(commands.keys())))))

      finally:

        sw.DecIndent()

      sw.Write("fi")

      # Group commands by arguments and options

      grouped_cmds = {}

      for cmd, (_, argdef, optdef, _, _) in commands.items():

        if not (argdef or optdef):

          continue

        grouped_cmds.setdefault((tuple(argdef), tuple(optdef)), set()).add(cmd)

      # We're doing options and arguments to commands

      sw.Write("""case "${COMP_WORDS[1]}" in""")

      sort_grouped = sorted(grouped_cmds.items(),

                            key=lambda (_, y): sorted(y)[0])

      for ((argdef, optdef), cmds) in sort_grouped:

        assert argdef or optdef

        sw.Write("%s)", "|".join(map(utils.ShellQuote, sorted(cmds))))

        sw.IncIndent()

        try:

          CompletionWriter(1, optdef, argdef, support_debug).WriteTo(sw)

        finally:

          sw.DecIndent()

        sw.Write(";;")

      sw.Write("esac")

  finally:

    sw.DecIndent()

  sw.Write("}")

  sw.Write("complete -F %s -o filenames %s",

           utils.ShellQuote(funcname),

           utils.ShellQuote(scriptname))

def GetFunctionName(name):

  return "_" + re.sub(r"[^a-z0-9]+", "_", name.lower())

def GetCommands(filename, module):

  """Returns the commands defined in a module.

  Aliases are also added as commands.

  """

  try:

    commands = getattr(module, "commands")

  except AttributeError:

    raise Exception("Script %s doesn't have 'commands' attribute" %

                    filename)

  # Add the implicit "--help" option

  help_option = cli.cli_option("-h", "--help", default=False,

                               action="store_true")

  for name, (_, _, optdef, _, _) in commands.items():

    if help_option not in optdef:

      optdef.append(help_option)

    for opt in cli.COMMON_OPTS:

      if opt in optdef:

        raise Exception("Common option '%s' listed for command '%s' in %s" %

                        (opt, name, filename))

      optdef.append(opt)

  # Use aliases

  aliases = getattr(module, "aliases", {})

  if aliases:

    commands = commands.copy()

    for name, target in aliases.items():

      commands[name] = commands[target]

  return commands

def HaskellOptToOptParse(opts, kind):

  """Converts a Haskell options to Python cli_options.

  @type opts: string

  @param opts: comma-separated string with short and long options

  @type kind: string

  @param kind: type generated by Common.hs/complToText; needs to be

      kept in sync

  """

  # pylint: disable=W0142

  # since we pass *opts in a number of places

  opts = opts.split(",")

  if kind == "none":

    return cli.cli_option(*opts, action="store_true")

  elif kind in ["file", "string", "host", "dir", "inetaddr"]:

    return cli.cli_option(*opts, type="string")

  elif kind == "integer":

    return cli.cli_option(*opts, type="int")

  elif kind == "float":

    return cli.cli_option(*opts, type="float")

  elif kind == "onegroup":

    return cli.cli_option(*opts, type="string",

                           completion_suggest=cli.OPT_COMPL_ONE_NODEGROUP)

  elif kind == "onenode":

    return cli.cli_option(*opts, type="string",

                          completion_suggest=cli.OPT_COMPL_ONE_NODE)

  elif kind == "manyinstances":

    # FIXME: no support for many instances

    return cli.cli_option(*opts, type="string")

  elif kind.startswith("choices="):

    choices = kind[len("choices="):].split(",")

    return cli.cli_option(*opts, type="choice", choices=choices)

  else:

    # FIXME: there are many other currently unused completion types,

    # should be added on an as-needed basis

    raise Exception("Unhandled option kind '%s'" % kind)

#: serialised kind to arg type

_ARG_MAP = {

  "choices": cli.ArgChoice,

  "command": cli.ArgCommand,

  "file": cli.ArgFile,

  "host": cli.ArgHost,

  "jobid": cli.ArgJobId,

  "onegroup": cli.ArgGroup,

  "oneinstance": cli.ArgInstance,

  "onenode": cli.ArgNode,

  "oneos": cli.ArgOs,

  "string": cli.ArgUnknown,

  "suggests": cli.ArgSuggest,

  }

def HaskellArgToCliArg(kind, min_cnt, max_cnt):

  """Converts a Haskell options to Python _Argument.

  @type kind: string

  @param kind: type generated by Common.hs/argComplToText; needs to be

      kept in sync

  """

  min_cnt = int(min_cnt)

  if max_cnt == "none":

    max_cnt = None

  else:

    max_cnt = int(max_cnt)

  # pylint: disable=W0142

  # since we pass **kwargs

  kwargs = {"min": min_cnt, "max": max_cnt}

  if kind.startswith("choices=") or kind.startswith("suggest="):

    (kind, choices) = kind.split("=", 1)

    kwargs["choices"] = choices.split(",")

  if kind not in _ARG_MAP:

    raise Exception("Unhandled argument kind '%s'" % kind)

  else:

    return _ARG_MAP[kind](**kwargs)

def ParseHaskellOptsArgs(script, output):

  """Computes list of options/arguments from help-completion output.

  """

  cli_opts = []

  cli_args = []

  for line in output.splitlines():

    v = line.split(None)

    exc = lambda msg: Exception("Invalid %s output from %s: %s" %

                                (msg, script, v))

    if len(v) < 2:

      raise exc("help completion")

    if v[0].startswith("-"):

      if len(v) != 2:

        raise exc("option format")

      (opts, kind) = v

      cli_opts.append(HaskellOptToOptParse(opts, kind))

    else:

      if len(v) != 3:

        raise exc("argument format")

      (kind, min_cnt, max_cnt) = v

      cli_args.append(HaskellArgToCliArg(kind, min_cnt, max_cnt))

  return (cli_opts, cli_args)

def WriteHaskellCompletion(sw, script, htools=True, debug=True):

  """Generates completion information for a Haskell program.

  This converts completion info from a Haskell program into 'fake'

  cli_opts and then builds completion for them.

  """

  if htools:

    cmd = "./htools/htools"

    env = {"HTOOLS": script}

    script_name = script

    func_name = "htools_%s" % script

  else:

    cmd = "./" + script

    env = {}

    script_name = os.path.basename(script)

    func_name = script_name

  func_name = GetFunctionName(func_name)

  output = utils.RunCmd([cmd, "--help-completion"], env=env, cwd=".").output

  (opts, args) = ParseHaskellOptsArgs(script_name, output)

  WriteCompletion(sw, script_name, func_name, debug, opts=opts, args=args)

def WriteHaskellCmdCompletion(sw, script, debug=True):

  """Generates completion information for a Haskell multi-command program.

  This gathers the list of commands from a Haskell program and

  computes the list of commands available, then builds the sub-command

  list of options/arguments for each command, using that for building

  a unified help output.

  """

  cmd = "./" + script

  script_name = os.path.basename(script)

  func_name = script_name

  func_name = GetFunctionName(func_name)

  output = utils.RunCmd([cmd, "--help-completion"], cwd=".").output

  commands = {}

  lines = output.splitlines()

  if len(lines) != 1:

    raise Exception("Invalid lines in multi-command mode: %s" % str(lines))

  v = lines[0].split(None)

  exc = lambda msg: Exception("Invalid %s output from %s: %s" %

                              (msg, script, v))

  if len(v) != 3:

    raise exc("help completion in multi-command mode")

  if not v[0].startswith("choices="):

    raise exc("invalid format in multi-command mode '%s'" % v[0])

  for subcmd in v[0][len("choices="):].split(","):

    output = utils.RunCmd([cmd, subcmd, "--help-completion"], cwd=".").output

    (opts, args) = ParseHaskellOptsArgs(script, output)

    commands[subcmd] = (None, args, opts, None, None)

  WriteCompletion(sw, script_name, func_name, debug, commands=commands)

def main():

  parser = optparse.OptionParser(usage="%prog [--compact]")

  parser.add_option("--compact", action="store_true",

                    help=("Don't indent output and don't include debugging"

                          " facilities"))

  options, args = parser.parse_args()

  if args:

    parser.error("Wrong number of arguments")

  # Whether to build debug version of completion script

  debug = not options.compact

  buf = StringIO()

  sw = utils.ShellWriter(buf, indent=debug)

  # Remember original state of extglob and enable it (required for pattern

  # matching; must be enabled while parsing script)

  sw.Write("gnt_shopt_extglob=$(shopt -p extglob || :)")

  sw.Write("shopt -s extglob")

  WritePreamble(sw, debug)

  # gnt-* scripts

  for scriptname in _autoconf.GNT_SCRIPTS:

    filename = "scripts/%s" % scriptname

    WriteCompletion(sw, scriptname, GetFunctionName(scriptname), debug,

                    commands=GetCommands(filename,

                                         build.LoadModule(filename)))

  # Burnin script

  burnin = build.LoadModule("tools/burnin")

  WriteCompletion(sw, "%s/burnin" % pathutils.TOOLSDIR, "_ganeti_burnin",

                  debug,

                  opts=burnin.OPTIONS, args=burnin.ARGUMENTS)

  # ganeti-cleaner

  WriteHaskellCompletion(sw, "daemons/ganeti-cleaner", htools=False,

                         debug=not options.compact)

  # htools, if enabled

  if _autoconf.HTOOLS:

    for script in _autoconf.HTOOLS_PROGS:

      WriteHaskellCompletion(sw, script, htools=True, debug=debug)

  # ganeti-confd, if enabled

  if _autoconf.ENABLE_CONFD:

    WriteHaskellCompletion(sw, "htools/ganeti-confd", htools=False,

                           debug=debug)

  # mon-collector, if monitoring is enabled

  if _autoconf.ENABLE_MONITORING:

    WriteHaskellCmdCompletion(sw, "htools/mon-collector", debug=debug)

  # Reset extglob to original value

  sw.Write("[[ -n \"$gnt_shopt_extglob\" ]] && $gnt_shopt_extglob")

  sw.Write("unset gnt_shopt_extglob")

  print buf.getvalue()

if __name__ == "__main__":

  main()