9037d033190fcc364b67803ec33ba22b7050c96b
[kai/samba-autobuild/.git] / python / samba / netcmd / __init__.py
1 # Unix SMB/CIFS implementation.
2 # Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2009-2012
3 # Copyright (C) Theresa Halloran <theresahalloran@gmail.com> 2011
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 #
18
19 import optparse, samba
20 from samba import getopt as options
21 from ldb import LdbError
22 import sys, traceback
23 import textwrap
24
25 class Option(optparse.Option):
26     pass
27
28 # This help formatter does text wrapping and preserves newlines
29 class PlainHelpFormatter(optparse.IndentedHelpFormatter):
30     def format_description(self,description=""):
31             desc_width = self.width - self.current_indent
32             indent = " "*self.current_indent
33             paragraphs = description.split('\n')
34             wrapped_paragraphs = [
35                 textwrap.fill(p,
36                         desc_width,
37                         initial_indent=indent,
38                         subsequent_indent=indent)
39                 for p in paragraphs]
40             result = "\n".join(wrapped_paragraphs) + "\n"
41             return result
42
43     def format_epilog(self, epilog):
44         if epilog:
45             return "\n" + epilog + "\n"
46         else:
47             return ""
48
49 class Command(object):
50     """A samba-tool command."""
51
52     def _get_short_description(self):
53         return self.__doc__.splitlines()[0].rstrip("\n")
54
55     short_description = property(_get_short_description)
56
57     def _get_full_description(self):
58         lines = self.__doc__.split("\n")
59         return lines[0] + "\n" + textwrap.dedent("\n".join(lines[1:]))
60
61     full_description = property(_get_full_description)
62
63     def _get_name(self):
64         name = self.__class__.__name__
65         if name.startswith("cmd_"):
66             return name[4:]
67         return name
68
69     name = property(_get_name)
70
71     # synopsis must be defined in all subclasses in order to provide the
72     # command usage
73     synopsis = None
74     takes_args = []
75     takes_options = []
76     takes_optiongroups = {}
77
78     hidden = False
79
80     raw_argv = None
81     raw_args = None
82     raw_kwargs = None
83
84     def __init__(self, outf=sys.stdout, errf=sys.stderr):
85         self.outf = outf
86         self.errf = errf
87
88     def usage(self, prog, *args):
89         parser, _ = self._create_parser(prog)
90         parser.print_usage()
91
92     def show_command_error(self, e):
93         '''display a command error'''
94         if isinstance(e, CommandError):
95             (etype, evalue, etraceback) = e.exception_info
96             inner_exception = e.inner_exception
97             message = e.message
98             force_traceback = False
99         else:
100             (etype, evalue, etraceback) = sys.exc_info()
101             inner_exception = e
102             message = "uncaught exception"
103             force_traceback = True
104
105         if isinstance(inner_exception, LdbError):
106             (ldb_ecode, ldb_emsg) = inner_exception
107             self.errf.write("ERROR(ldb): %s - %s\n" % (message, ldb_emsg))
108         elif isinstance(inner_exception, AssertionError):
109             self.errf.write("ERROR(assert): %s\n" % message)
110             force_traceback = True
111         elif isinstance(inner_exception, RuntimeError):
112             self.errf.write("ERROR(runtime): %s - %s\n" % (message, evalue))
113         elif type(inner_exception) is Exception:
114             self.errf.write("ERROR(exception): %s - %s\n" % (message, evalue))
115             force_traceback = True
116         elif inner_exception is None:
117             self.errf.write("ERROR: %s\n" % (message))
118         else:
119             self.errf.write("ERROR(%s): %s - %s\n" % (str(etype), message, evalue))
120             force_traceback = True
121
122         if force_traceback or samba.get_debug_level() >= 3:
123             traceback.print_tb(etraceback, file=self.errf)
124
125     def _create_parser(self, prog, epilog=None):
126         parser = optparse.OptionParser(
127             usage=self.synopsis,
128             description=self.full_description,
129             formatter=PlainHelpFormatter(),
130             prog=prog,epilog=epilog)
131         parser.add_options(self.takes_options)
132         optiongroups = {}
133         for name, optiongroup in self.takes_optiongroups.iteritems():
134             optiongroups[name] = optiongroup(parser)
135             parser.add_option_group(optiongroups[name])
136         return parser, optiongroups
137
138     def message(self, text):
139         self.outf.write(text+"\n")
140
141     def _run(self, *argv):
142         parser, optiongroups = self._create_parser(argv[0])
143         opts, args = parser.parse_args(list(argv))
144         # Filter out options from option groups
145         args = args[1:]
146         kwargs = dict(opts.__dict__)
147         for option_group in parser.option_groups:
148             for option in option_group.option_list:
149                 if option.dest is not None:
150                     del kwargs[option.dest]
151         kwargs.update(optiongroups)
152
153         # Check for a min a max number of allowed arguments, whenever possible
154         # The suffix "?" means zero or one occurence
155         # The suffix "+" means at least one occurence
156         # The suffix "*" means zero or more occurences
157         min_args = 0
158         max_args = 0
159         undetermined_max_args = False
160         for i, arg in enumerate(self.takes_args):
161             if arg[-1] != "?" and arg[-1] != "*":
162                min_args += 1
163             if arg[-1] == "+" or arg[-1] == "*":
164                undetermined_max_args = True
165             else:
166                max_args += 1
167         if (len(args) < min_args) or (not undetermined_max_args and len(args) > max_args):
168             parser.print_usage()
169             return -1
170
171         self.raw_argv = list(argv)
172         self.raw_args = args
173         self.raw_kwargs = kwargs
174
175         try:
176             return self.run(*args, **kwargs)
177         except Exception as e:
178             self.show_command_error(e)
179             return -1
180
181     def run(self):
182         """Run the command. This should be overridden by all subclasses."""
183         raise NotImplementedError(self.run)
184
185     def get_logger(self, name="netcmd"):
186         """Get a logger object."""
187         import logging
188         logger = logging.getLogger(name)
189         logger.addHandler(logging.StreamHandler(self.errf))
190         return logger
191
192
193 class SuperCommand(Command):
194     """A samba-tool command with subcommands."""
195
196     synopsis = "%prog <subcommand>"
197
198     subcommands = {}
199
200     def _run(self, myname, subcommand=None, *args):
201         if subcommand in self.subcommands:
202             return self.subcommands[subcommand]._run(
203                 "%s %s" % (myname, subcommand), *args)
204
205         if subcommand == 'help':
206             # pass the request down
207             if len(args) > 0:
208                 sub = self.subcommands.get(args[0])
209                 if isinstance(sub, SuperCommand):
210                     return sub._run("%s %s" % (myname, args[0]), 'help',
211                                     *args[1:])
212                 elif sub is not None:
213                     return sub._run("%s %s" % (myname, args[0]), '--help',
214                                     *args[1:])
215
216             subcommand = '--help'
217
218         epilog = "\nAvailable subcommands:\n"
219         subcmds = self.subcommands.keys()
220         subcmds.sort()
221         max_length = max([len(c) for c in subcmds])
222         for cmd_name in subcmds:
223             cmd = self.subcommands[cmd_name]
224             if not cmd.hidden:
225                 epilog += "  %*s  - %s\n" % (
226                     -max_length, cmd_name, cmd.short_description)
227         epilog += "For more help on a specific subcommand, please type: %s <subcommand> (-h|--help)\n" % myname
228
229         parser, optiongroups = self._create_parser(myname, epilog=epilog)
230         args_list = list(args)
231         if subcommand:
232             args_list.insert(0, subcommand)
233         opts, args = parser.parse_args(args_list)
234
235         parser.print_help()
236         return -1
237
238
239 class CommandError(Exception):
240     """An exception class for samba-tool Command errors."""
241
242     def __init__(self, message, inner_exception=None):
243         self.message = message
244         self.inner_exception = inner_exception
245         self.exception_info = sys.exc_info()
246
247     def __repr__(self):
248         return "CommandError(%s)" % self.message