Statistics
| Branch: | Tag: | Revision:

root / kamaki / cli / argument / __init__.py @ ca5528f1

History | View | Annotate | Download (14.7 kB)

1
# Copyright 2012-2013 GRNET S.A. All rights reserved.
2
#
3
# Redistribution and use in source and binary forms, with or
4
# without modification, are permitted provided that the following
5
# conditions are met:
6
#
7
#   1. Redistributions of source code must retain the above
8
#     copyright notice, this list of conditions and the following
9
#     disclaimer.
10
#
11
#   2. Redistributions in binary form must reproduce the above
12
#     copyright notice, this list of conditions and the following
13
#     disclaimer in the documentation and/or other materials
14
#     provided with the distribution.
15
#
16
# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
17
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
20
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
26
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27
# POSSIBILITY OF SUCH DAMAGE.
28
#
29
# The views and conclusions contained in the software and
30
# documentation are those of the authors and should not be
31
# interpreted as representing official policies, either expressed
32
# or implied, of GRNET S.A.
33

    
34
from kamaki.cli.config import Config
35
from kamaki.cli.errors import CLISyntaxError, raiseCLIError
36
from kamaki.cli.utils import split_input
37

    
38
from datetime import datetime as dtm
39
from time import mktime
40

    
41
from logging import getLogger
42
from argparse import ArgumentParser, ArgumentError
43
from argparse import RawDescriptionHelpFormatter
44
from progress.bar import ShadyBar as KamakiProgressBar
45

    
46
log = getLogger(__name__)
47

    
48

    
49
class Argument(object):
50
    """An argument that can be parsed from command line or otherwise.
51
    This is the top-level Argument class. It is suggested to extent this
52
    class into more specific argument types.
53
    """
54

    
55
    def __init__(self, arity, help=None, parsed_name=None, default=None):
56
        self.arity = int(arity)
57
        self.help = '%s' % help or ''
58

    
59
        assert parsed_name, 'No parsed name for argument %s' % self
60
        self.parsed_name = list(parsed_name) if isinstance(
61
            parsed_name, list) or isinstance(parsed_name, tuple) else (
62
                '%s' % parsed_name).split()
63
        for name in self.parsed_name:
64
            assert name.count(' ') == 0, '%s: Invalid parse name "%s"' % (
65
                self, name)
66
            msg = '%s: Invalid parse name "%s" should start with a "-"' % (
67
                    self, name)
68
            assert name.startswith('-'), msg
69

    
70
        self.default = default if (default or self.arity) else False
71

    
72
    @property
73
    def value(self):
74
        return getattr(self, '_value', self.default)
75

    
76
    @value.setter
77
    def value(self, newvalue):
78
        self._value = newvalue
79

    
80
    def update_parser(self, parser, name):
81
        """Update argument parser with self info"""
82
        action = 'append' if self.arity < 0 else (
83
            'store' if self.arity else 'store_true')
84
        parser.add_argument(
85
            *self.parsed_name,
86
            dest=name, action=action, default=self.default, help=self.help)
87

    
88

    
89
class ConfigArgument(Argument):
90
    """Manage a kamaki configuration (file)"""
91

    
92
    def __init__(self, help, parsed_name=('-c', '--config')):
93
        super(ConfigArgument, self).__init__(1, help, parsed_name, None)
94
        self.file_path = None
95

    
96
    @property
97
    def value(self):
98
        return super(ConfigArgument, self).value
99

    
100
    @value.setter
101
    def value(self, config_file):
102
        if config_file:
103
            self._value = Config(config_file)
104
            self.file_path = config_file
105
        elif self.file_path:
106
            self._value = Config(self.file_path)
107
        else:
108
            self._value = Config()
109

    
110
    def get(self, group, term):
111
        """Get a configuration setting from the Config object"""
112
        return self.value.get(group, term)
113

    
114
    @property
115
    def groups(self):
116
        suffix = '_cli'
117
        slen = len(suffix)
118
        return [term[:-slen] for term in self.value.keys('global') if (
119
            term.endswith(suffix))]
120

    
121
    @property
122
    def cli_specs(self):
123
        suffix = '_cli'
124
        slen = len(suffix)
125
        return [(k[:-slen], v) for k, v in self.value.items('global') if (
126
            k.endswith(suffix))]
127

    
128
    def get_global(self, option):
129
        return self.value.get_global(option)
130

    
131
    def get_cloud(self, cloud, option):
132
        return self.value.get_cloud(cloud, option)
133

    
134

    
135
_config_arg = ConfigArgument('Path to config file')
136

    
137

    
138
class RuntimeConfigArgument(Argument):
139
    """Set a run-time setting option (not persistent)"""
140

    
141
    def __init__(self, config_arg, help='', parsed_name=None, default=None):
142
        super(self.__class__, self).__init__(1, help, parsed_name, default)
143
        self._config_arg = config_arg
144

    
145
    @property
146
    def value(self):
147
        return super(RuntimeConfigArgument, self).value
148

    
149
    @value.setter
150
    def value(self, options):
151
        if options == self.default:
152
            return
153
        if not isinstance(options, list):
154
            options = ['%s' % options]
155
        for option in options:
156
            keypath, sep, val = option.partition('=')
157
            if not sep:
158
                raiseCLIError(
159
                    CLISyntaxError('Argument Syntax Error '),
160
                    details=[
161
                        '%s is missing a "="',
162
                        ' (usage: -o section.key=val)' % option])
163
            section, sep, key = keypath.partition('.')
164
        if not sep:
165
            key = section
166
            section = 'global'
167
        self._config_arg.value.override(
168
            section.strip(),
169
            key.strip(),
170
            val.strip())
171

    
172

    
173
class FlagArgument(Argument):
174
    """
175
    :value: true if set, false otherwise
176
    """
177

    
178
    def __init__(self, help='', parsed_name=None, default=False):
179
        super(FlagArgument, self).__init__(0, help, parsed_name, default)
180

    
181

    
182
class ValueArgument(Argument):
183
    """
184
    :value type: string
185
    :value returns: given value or default
186
    """
187

    
188
    def __init__(self, help='', parsed_name=None, default=None):
189
        super(ValueArgument, self).__init__(1, help, parsed_name, default)
190

    
191

    
192
class CommaSeparatedListArgument(ValueArgument):
193
    """
194
    :value type: string
195
    :value returns: list of the comma separated values
196
    """
197

    
198
    @property
199
    def value(self):
200
        return self._value or list()
201

    
202
    @value.setter
203
    def value(self, newvalue):
204
        self._value = newvalue.split(',') if newvalue else list()
205

    
206

    
207
class IntArgument(ValueArgument):
208

    
209
    @property
210
    def value(self):
211
        """integer (type checking)"""
212
        return getattr(self, '_value', self.default)
213

    
214
    @value.setter
215
    def value(self, newvalue):
216
        try:
217
            self._value = self.default if (
218
                newvalue == self.default) else int(newvalue)
219
        except ValueError:
220
            raiseCLIError(CLISyntaxError(
221
                'IntArgument Error',
222
                details=['Value %s not an int' % newvalue]))
223

    
224

    
225
class DateArgument(ValueArgument):
226

    
227
    DATE_FORMAT = '%a %b %d %H:%M:%S %Y'
228

    
229
    INPUT_FORMATS = [DATE_FORMAT, '%d-%m-%Y', '%H:%M:%S %d-%m-%Y']
230

    
231
    @property
232
    def timestamp(self):
233
        v = getattr(self, '_value', self.default)
234
        return mktime(v.timetuple()) if v else None
235

    
236
    @property
237
    def formated(self):
238
        v = getattr(self, '_value', self.default)
239
        return v.strftime(self.DATE_FORMAT) if v else None
240

    
241
    @property
242
    def value(self):
243
        return self.timestamp
244

    
245
    @value.setter
246
    def value(self, newvalue):
247
        self._value = self.format_date(newvalue) if newvalue else self.default
248

    
249
    def format_date(self, datestr):
250
        for format in self.INPUT_FORMATS:
251
            try:
252
                t = dtm.strptime(datestr, format)
253
            except ValueError:
254
                continue
255
            return t  # .strftime(self.DATE_FORMAT)
256
        raiseCLIError(None, 'Date Argument Error', details=[
257
            '%s not a valid date' % datestr,
258
            'Correct formats:\n\t%s' % self.INPUT_FORMATS])
259

    
260

    
261
class VersionArgument(FlagArgument):
262
    """A flag argument with that prints current version"""
263

    
264
    @property
265
    def value(self):
266
        """bool"""
267
        return super(self.__class__, self).value
268

    
269
    @value.setter
270
    def value(self, newvalue):
271
        self._value = newvalue
272
        if newvalue:
273
            import kamaki
274
            print('kamaki %s' % kamaki.__version__)
275

    
276

    
277
class RepeatableArgument(Argument):
278
    """A value argument that can be repeated"""
279

    
280
    def __init__(self, help='', parsed_name=None, default=[]):
281
        super(RepeatableArgument, self).__init__(
282
            -1, help, parsed_name, default)
283

    
284

    
285
class KeyValueArgument(Argument):
286
    """A Key=Value Argument that can be repeated
287

288
    :syntax: --<arg> key1=value1 --<arg> key2=value2 ...
289
    """
290

    
291
    def __init__(self, help='', parsed_name=None, default=[]):
292
        super(KeyValueArgument, self).__init__(-1, help, parsed_name, default)
293

    
294
    @property
295
    def value(self):
296
        """
297
        :returns: (dict) {key1: val1, key2: val2, ...}
298
        """
299
        return super(KeyValueArgument, self).value
300

    
301
    @value.setter
302
    def value(self, keyvalue_pairs):
303
        """
304
        :param keyvalue_pairs: (str) ['key1=val1', 'key2=val2', ...]
305
        """
306
        self._value = getattr(self, '_value', self.value) or {}
307
        try:
308
            for pair in keyvalue_pairs:
309
                key, sep, val = pair.partition('=')
310
                assert sep, ' %s misses a "=" (usage: key1=val1 )\n' % (pair)
311
                self._value[key] = val
312
        except Exception as e:
313
            raiseCLIError(e, 'KeyValueArgument Syntax Error')
314

    
315

    
316
class ProgressBarArgument(FlagArgument):
317
    """Manage a progress bar"""
318

    
319
    def __init__(self, help='', parsed_name='', default=True):
320
        self.suffix = '%(percent)d%%'
321
        super(ProgressBarArgument, self).__init__(help, parsed_name, default)
322

    
323
    def clone(self):
324
        """Get a modifiable copy of this bar"""
325
        newarg = ProgressBarArgument(
326
            self.help, self.parsed_name, self.default)
327
        newarg._value = self._value
328
        return newarg
329

    
330
    def get_generator(self, message, message_len=25):
331
        """Get a generator to handle progress of the bar (gen.next())"""
332
        if self.value:
333
            return None
334
        try:
335
            self.bar = KamakiProgressBar()
336
        except NameError:
337
            self.value = None
338
            return self.value
339
        self.bar.message = message.ljust(message_len)
340
        self.bar.suffix = '%(percent)d%% - %(eta)ds'
341
        self.bar.start()
342

    
343
        def progress_gen(n):
344
            for i in self.bar.iter(range(int(n))):
345
                yield
346
            yield
347
        return progress_gen
348

    
349
    def finish(self):
350
        """Stop progress bar, return terminal cursor to user"""
351
        if self.value:
352
            return
353
        mybar = getattr(self, 'bar', None)
354
        if mybar:
355
            mybar.finish()
356

    
357

    
358
_arguments = dict(
359
    config=_config_arg,
360
    cloud=ValueArgument('Chose a cloud to connect to', ('--cloud')),
361
    help=Argument(0, 'Show help message', ('-h', '--help')),
362
    debug=FlagArgument('Include debug output', ('-d', '--debug')),
363
    include=FlagArgument(
364
        'Include raw connection data in the output', ('-i', '--include')),
365
    silent=FlagArgument('Do not output anything', ('-s', '--silent')),
366
    verbose=FlagArgument('More info at response', ('-v', '--verbose')),
367
    version=VersionArgument('Print current version', ('-V', '--version')),
368
    options=RuntimeConfigArgument(
369
        _config_arg, 'Override a config value', ('-o', '--options'))
370
)
371

    
372

    
373
#  Initial command line interface arguments
374

    
375

    
376
class ArgumentParseManager(object):
377
    """Manage (initialize and update) an ArgumentParser object"""
378

    
379
    def __init__(self, exe, arguments=None):
380
        """
381
        :param exe: (str) the basic command (e.g. 'kamaki')
382

383
        :param arguments: (dict) if given, overrides the global _argument as
384
            the parsers arguments specification
385
        """
386
        self.parser = ArgumentParser(
387
            add_help=False, formatter_class=RawDescriptionHelpFormatter)
388
        self.syntax = '%s <cmd_group> [<cmd_subbroup> ...] <cmd>' % exe
389
        if arguments:
390
            self.arguments = arguments
391
        else:
392
            global _arguments
393
            self.arguments = _arguments
394
        self._parser_modified, self._parsed, self._unparsed = False, None, None
395
        self.parse()
396

    
397
    @property
398
    def syntax(self):
399
        """The command syntax (useful for help messages, descriptions, etc)"""
400
        return self.parser.prog
401

    
402
    @syntax.setter
403
    def syntax(self, new_syntax):
404
        self.parser.prog = new_syntax
405

    
406
    @property
407
    def arguments(self):
408
        """:returns: (dict) arguments the parser should be aware of"""
409
        return self._arguments
410

    
411
    @arguments.setter
412
    def arguments(self, new_arguments):
413
        assert isinstance(new_arguments, dict), 'Arguments must be in a dict'
414
        self._arguments = new_arguments
415
        self.update_parser()
416

    
417
    @property
418
    def parsed(self):
419
        """(Namespace) parser-matched terms"""
420
        if self._parser_modified:
421
            self.parse()
422
        return self._parsed
423

    
424
    @property
425
    def unparsed(self):
426
        """(list) parser-unmatched terms"""
427
        if self._parser_modified:
428
            self.parse()
429
        return self._unparsed
430

    
431
    def update_parser(self, arguments=None):
432
        """Load argument specifications to parser
433

434
        :param arguments: if not given, update self.arguments instead
435
        """
436
        arguments = arguments or self._arguments
437

    
438
        for name, arg in arguments.items():
439
            try:
440
                arg.update_parser(self.parser, name)
441
                self._parser_modified = True
442
            except ArgumentError:
443
                pass
444

    
445
    def update_arguments(self, new_arguments):
446
        """Add to / update existing arguments
447

448
        :param new_arguments: (dict)
449
        """
450
        if new_arguments:
451
            assert isinstance(new_arguments, dict)
452
            self._arguments.update(new_arguments)
453
            self.update_parser()
454

    
455
    def parse(self, new_args=None):
456
        """Parse user input"""
457
        try:
458
            pkargs = (new_args,) if new_args else ()
459
            self._parsed, unparsed = self.parser.parse_known_args(*pkargs)
460
        except SystemExit:
461
            raiseCLIError(CLISyntaxError('Argument Syntax Error'))
462
        for name, arg in self.arguments.items():
463
            arg.value = getattr(self._parsed, name, arg.default)
464
        self._unparsed = []
465
        for term in unparsed:
466
            self._unparsed += split_input(' \'%s\' ' % term)
467
        self._parser_modified = False