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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
# Copyright (C) 2008-2011 by the Free Software Foundation, Inc.
#
# This file is part of GNU Mailman.
#
# GNU Mailman 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 3 of the License, or (at your option)
# any later version.
#
# GNU Mailman 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
# GNU Mailman. If not, see <http://www.gnu.org/licenses/>.
"""Common argument parsing."""
from __future__ import absolute_import, unicode_literals
__metaclass__ = type
__all__ = [
'Options',
'SingleMailingListOptions',
'MultipleMailingListOptions',
]
import os
import sys
from copy import copy
from optparse import Option, OptionParser, OptionValueError
from mailman.config import config
from mailman.core.i18n import _
from mailman.core.initialize import initialize
from mailman.version import MAILMAN_VERSION
def check_unicode(option, opt, value):
"""Check that the value is a unicode string."""
if isinstance(value, unicode):
return value
try:
return value.decode(sys.getdefaultencoding())
except UnicodeDecodeError:
raise OptionValueError(
'option {0}: Cannot decode: {1}'.format(opt, value))
def check_yesno(option, opt, value):
"""Check that the value is 'yes' or 'no'."""
value = value.lower()
if value not in ('yes', 'no', 'y', 'n'):
raise OptionValueError('option {0}: invalid: {1}'.format(opt, value))
return value[0] == 'y'
class MailmanOption(Option):
"""Extension types for unicode options."""
TYPES = Option.TYPES + ('unicode', 'yesno')
TYPE_CHECKER = copy(Option.TYPE_CHECKER)
TYPE_CHECKER['unicode'] = check_unicode
TYPE_CHECKER['yesno'] = check_yesno
class SafeOptionParser(OptionParser):
"""A unicode-compatible `OptionParser`.
Python's standard option parser does not accept unicode options. Rather
than try to fix that, this class wraps the add_option() method and saves
having to wrap the options in str() calls.
"""
def add_option(self, *args, **kwargs):
"""See `OptionParser`."""
# Check to see if the first or first two options are unicodes and turn
# them into 8-bit strings before calling the superclass's method.
if len(args) == 0:
return OptionParser.add_option(self, *args, **kwargs)
old_args = list(args)
new_args = []
arg0 = old_args.pop(0)
new_args.append(str(arg0))
if len(old_args) > 0:
arg1 = old_args.pop(0)
new_args.append(str(arg1))
new_args.extend(old_args)
return OptionParser.add_option(self, *new_args, **kwargs)
class Options:
"""Common argument parser."""
# Subclasses should override.
usage = None
def __init__(self):
self.parser = SafeOptionParser(
version=MAILMAN_VERSION,
option_class=MailmanOption,
usage=self.usage)
self.add_common_options()
self.add_options()
options, arguments = self.parser.parse_args()
self.options = options
self.arguments = arguments
# Also, for convenience, place the options in the configuration file
# because occasional global uses are necessary.
config.options = self
def add_options(self):
"""Allow the subclass to add its own specific arguments."""
pass
def sanity_check(self):
"""Allow subclasses to do sanity checking of arguments."""
pass
def add_common_options(self):
"""Add options common to all scripts."""
# Python requires str types here.
self.parser.add_option(
'-C', '--config',
help=_('Alternative configuration file to use'))
def initialize(self, propagate_logs=None):
"""Initialize the configuration system.
After initialization of the configuration system, perform sanity
checks. We do it in this order because some sanity checks require the
configuration to be initialized.
:param propagate_logs: Optional flag specifying whether log messages
in sub-loggers should be propagated to the master logger (and
hence to the root logger). If not given, propagation is taken
from the configuration files.
:type propagate_logs: bool or None.
"""
# Fall back to using the environment variable if -C is not given.
config_file = (os.getenv('MAILMAN_CONFIG_FILE')
if self.options.config is None
else self.options.config)
initialize(config_file, propagate_logs=propagate_logs)
self.sanity_check()
class SingleMailingListOptions(Options):
"""A helper for specifying the mailing list on the command line."""
def add_options(self):
"""See `Options`."""
self.parser.add_option(
'-l', '--listname',
type='unicode', help=_('The mailing list name'))
super(SingleMailingListOptions, self).add_options()
class MultipleMailingListOptions(Options):
"""A helper for specifying multiple mailing lists on the command line."""
def add_options(self):
"""See `Options`."""
self.parser.add_option(
'-l', '--listname',
default=[], action='append', dest='listnames', type='unicode',
help=_("""\
A mailing list name. It is okay to have multiple --listname options."""))
|
