gitosis/app.py


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

import os
import sys
import logging
import optparse
import ConfigParser
 
class App(object):
    name = None
 
    @classmethod
    def run(class_):
        app = class_()
        return app.main()
 
    def main(self):
        parser = self.create_parser()
        (options, args) = parser.parse_args()
        cfg = self.read_config(options)
        self.setup_logging(cfg)
        self.handle_args(parser, cfg, options, args)
 
    def create_parser(self):
        parser = optparse.OptionParser()
        parser.set_defaults(
            config=os.path.expanduser('~/.gitosis.conf'),
            )
        parser.add_option('--config',
                          metavar='FILE',
                          help='read config from FILE',
                          )
 
        return parser
 
    def read_config(self, options):
        cfg = ConfigParser.RawConfigParser()
        try:
            conffile = file(options.config)
        except (IOError, OSError), e:
            # I trust the exception has the path. 
            print >>sys.stderr, '%s: Unable to read config file: %s' \ 
                  % (options.get_prog_name(), e)
            sys.exit(1)
        try:
            cfg.readfp(conffile)
        finally:
            conffile.close()
        return cfg
 
    def setup_logging(self, cfg):
        logging.basicConfig()
 
        try:
            loglevel = cfg.get('gitosis', 'loglevel')
        except (ConfigParser.NoSectionError,
                ConfigParser.NoOptionError):
            pass
        else:
            try:
                symbolic = logging._levelNames[loglevel]
            except KeyError:
                # need to delay error reporting until we've called 
                # basicConfig 
                log = logging.getLogger('gitosis.app')
                log.warning(
                    'Ignored invalid loglevel configuration: %r',
                    loglevel,
                    )
            else:
                logging.root.setLevel(symbolic)
 
    def handle_args(self, parser, options, args):
        if args:
            parser.error('not expecting arguments')