1 # Roundup Issue Tracker configuration support
2 #
3 # $Id: configuration.py,v 1.51 2008-09-01 02:30:06 richard Exp $
4 #
5 __docformat__ = "restructuredtext"
7 import ConfigParser
8 import getopt
9 import imp
10 import logging, logging.config
11 import os
12 import re
13 import sys
14 import time
15 import smtplib
17 import roundup.date
19 # XXX i don't think this module needs string translation, does it?
21 ### Exceptions
23 class ConfigurationError(Exception):
24 pass
26 class NoConfigError(ConfigurationError):
28 """Raised when configuration loading fails
30 Constructor parameters: path to the directory that was used as HOME
32 """
34 def __str__(self):
35 return "No valid configuration files found in directory %s" \
36 % self.args[0]
38 class InvalidOptionError(ConfigurationError, KeyError, AttributeError):
40 """Attempted access to non-existing configuration option
42 Configuration options may be accessed as configuration object
43 attributes or items. So this exception instances also are
44 instances of KeyError (invalid item access) and AttributeError
45 (invalid attribute access).
47 Constructor parameter: option name
49 """
51 def __str__(self):
52 return "Unsupported configuration option: %s" % self.args[0]
54 class OptionValueError(ConfigurationError, ValueError):
56 """Raised upon attempt to assign an invalid value to config option
58 Constructor parameters: Option instance, offending value
59 and optional info string.
61 """
63 def __str__(self):
64 _args = self.args
65 _rv = "Invalid value for %(option)s: %(value)r" % {
66 "option": _args[0].name, "value": _args[1]}
67 if len(_args) > 2:
68 _rv += "\n".join(("",) + _args[2:])
69 return _rv
71 class OptionUnsetError(ConfigurationError):
73 """Raised when no Option value is available - neither set, nor default
75 Constructor parameters: Option instance.
77 """
79 def __str__(self):
80 return "%s is not set and has no default" % self.args[0].name
82 class UnsetDefaultValue:
84 """Special object meaning that default value for Option is not specified"""
86 def __str__(self):
87 return "NO DEFAULT"
89 NODEFAULT = UnsetDefaultValue()
91 ### Option classes
93 class Option:
95 """Single configuration option.
97 Options have following attributes:
99 config
100 reference to the containing Config object
101 section
102 name of the section in the tracker .ini file
103 setting
104 option name in the tracker .ini file
105 default
106 default option value
107 description
108 option description. Makes a comment in the tracker .ini file
109 name
110 "canonical name" of the configuration option.
111 For items in the 'main' section this is uppercased
112 'setting' name. For other sections, the name is
113 composed of the section name and the setting name,
114 joined with underscore.
115 aliases
116 list of "also known as" names. Used to access the settings
117 by old names used in previous Roundup versions.
118 "Canonical name" is also included.
120 The name and aliases are forced to be uppercase.
121 The setting name is forced to lowercase.
123 """
125 class_description = None
127 def __init__(self, config, section, setting,
128 default=NODEFAULT, description=None, aliases=None
129 ):
130 self.config = config
131 self.section = section
132 self.setting = setting.lower()
133 self.default = default
134 self.description = description
135 self.name = setting.upper()
136 if section != "main":
137 self.name = "_".join((section.upper(), self.name))
138 if aliases:
139 self.aliases = [alias.upper() for alias in list(aliases)]
140 else:
141 self.aliases = []
142 self.aliases.insert(0, self.name)
143 # convert default to internal representation
144 if default is NODEFAULT:
145 _value = default
146 else:
147 _value = self.str2value(default)
148 # value is private. use get() and set() to access
149 self._value = self._default_value = _value
151 def str2value(self, value):
152 """Return 'value' argument converted to internal representation"""
153 return value
155 def _value2str(self, value):
156 """Return 'value' argument converted to external representation
158 This is actual conversion method called only when value
159 is not NODEFAULT. Heirs with different conversion rules
160 override this method, not the public .value2str().
162 """
163 return str(value)
165 def value2str(self, value=NODEFAULT, current=0):
166 """Return 'value' argument converted to external representation
168 If 'current' is True, use current option value.
170 """
171 if current:
172 value = self._value
173 if value is NODEFAULT:
174 return str(value)
175 else:
176 return self._value2str(value)
178 def get(self):
179 """Return current option value"""
180 if self._value is NODEFAULT:
181 raise OptionUnsetError(self)
182 return self._value
184 def set(self, value):
185 """Update the value"""
186 self._value = self.str2value(value)
188 def reset(self):
189 """Reset the value to default"""
190 self._value = self._default_value
192 def isdefault(self):
193 """Return True if current value is the default one"""
194 return self._value == self._default_value
196 def isset(self):
197 """Return True if the value is available (either set or default)"""
198 return self._value != NODEFAULT
200 def __str__(self):
201 return self.value2str(self._value)
203 def __repr__(self):
204 if self.isdefault():
205 _format = "<%(class)s %(name)s (default): %(value)s>"
206 else:
207 _format = "<%(class)s %(name)s (default: %(default)s): %(value)s>"
208 return _format % {
209 "class": self.__class__.__name__,
210 "name": self.name,
211 "default": self.value2str(self._default_value),
212 "value": self.value2str(self._value),
213 }
215 def format(self):
216 """Return .ini file fragment for this option"""
217 _desc_lines = []
218 for _description in (self.description, self.class_description):
219 if _description:
220 _desc_lines.extend(_description.split("\n"))
221 # comment out the setting line if there is no value
222 if self.isset():
223 _is_set = ""
224 else:
225 _is_set = "#"
226 _rv = "# %(description)s\n# Default: %(default)s\n" \
227 "%(is_set)s%(name)s = %(value)s\n" % {
228 "description": "\n# ".join(_desc_lines),
229 "default": self.value2str(self._default_value),
230 "name": self.setting,
231 "value": self.value2str(self._value),
232 "is_set": _is_set
233 }
234 return _rv
236 def load_ini(self, config):
237 """Load value from ConfigParser object"""
238 if config.has_option(self.section, self.setting):
239 self.set(config.get(self.section, self.setting))
241 def load_pyconfig(self, config):
242 """Load value from old-style config (python module)"""
243 for _name in self.aliases:
244 if hasattr(config, _name):
245 self.set(getattr(config, _name))
246 break
248 class BooleanOption(Option):
250 """Boolean option: yes or no"""
252 class_description = "Allowed values: yes, no"
254 def _value2str(self, value):
255 if value:
256 return "yes"
257 else:
258 return "no"
260 def str2value(self, value):
261 if type(value) == type(""):
262 _val = value.lower()
263 if _val in ("yes", "true", "on", "1"):
264 _val = 1
265 elif _val in ("no", "false", "off", "0"):
266 _val = 0
267 else:
268 raise OptionValueError(self, value, self.class_description)
269 else:
270 _val = value and 1 or 0
271 return _val
273 class WordListOption(Option):
275 """List of strings"""
277 class_description = "Allowed values: comma-separated list of words"
279 def _value2str(self, value):
280 return ','.join(value)
282 def str2value(self, value):
283 return value.split(',')
285 class RunDetectorOption(Option):
287 """When a detector is run: always, never or for new items only"""
289 class_description = "Allowed values: yes, no, new"
291 def str2value(self, value):
292 _val = value.lower()
293 if _val in ("yes", "no", "new"):
294 return _val
295 else:
296 raise OptionValueError(self, value, self.class_description)
298 class MailAddressOption(Option):
300 """Email address
302 Email addresses may be either fully qualified or local.
303 In the latter case MAIL_DOMAIN is automatically added.
305 """
307 def get(self):
308 _val = Option.get(self)
309 if "@" not in _val:
310 _val = "@".join((_val, self.config["MAIL_DOMAIN"]))
311 return _val
313 class FilePathOption(Option):
315 """File or directory path name
317 Paths may be either absolute or relative to the HOME.
319 """
321 class_description = "The path may be either absolute or relative\n" \
322 "to the directory containig this config file."
324 def get(self):
325 _val = Option.get(self)
326 if _val and not os.path.isabs(_val):
327 _val = os.path.join(self.config["HOME"], _val)
328 return _val
330 class FloatNumberOption(Option):
332 """Floating point numbers"""
334 def str2value(self, value):
335 try:
336 return float(value)
337 except ValueError:
338 raise OptionValueError(self, value,
339 "Floating point number required")
341 def _value2str(self, value):
342 _val = str(value)
343 # strip fraction part from integer numbers
344 if _val.endswith(".0"):
345 _val = _val[:-2]
346 return _val
348 class IntegerNumberOption(Option):
350 """Integer numbers"""
352 def str2value(self, value):
353 try:
354 return int(value)
355 except ValueError:
356 raise OptionValueError(self, value, "Integer number required")
358 class OctalNumberOption(Option):
360 """Octal Integer numbers"""
362 def str2value(self, value):
363 try:
364 return int(value, 8)
365 except ValueError:
366 raise OptionValueError(self, value, "Octal Integer number required")
368 def _value2str(self, value):
369 return oct(value)
371 class NullableOption(Option):
373 """Option that is set to None if its string value is one of NULL strings
375 Default nullable strings list contains empty string only.
376 There is constructor parameter allowing to specify different nullables.
378 Conversion to external representation returns the first of the NULL
379 strings list when the value is None.
381 """
383 NULL_STRINGS = ("",)
385 def __init__(self, config, section, setting,
386 default=NODEFAULT, description=None, aliases=None,
387 null_strings=NULL_STRINGS
388 ):
389 self.null_strings = list(null_strings)
390 Option.__init__(self, config, section, setting, default,
391 description, aliases)
393 def str2value(self, value):
394 if value in self.null_strings:
395 return None
396 else:
397 return value
399 def _value2str(self, value):
400 if value is None:
401 return self.null_strings[0]
402 else:
403 return value
405 class NullableFilePathOption(NullableOption, FilePathOption):
407 # .get() and class_description are from FilePathOption,
408 get = FilePathOption.get
409 class_description = FilePathOption.class_description
410 # everything else taken from NullableOption (inheritance order)
412 class TimezoneOption(Option):
414 class_description = \
415 "If pytz module is installed, value may be any valid\n" \
416 "timezone specification (e.g. EET or Europe/Warsaw).\n" \
417 "If pytz is not installed, value must be integer number\n" \
418 "giving local timezone offset from UTC in hours."
420 def str2value(self, value):
421 try:
422 roundup.date.get_timezone(value)
423 except KeyError:
424 raise OptionValueError(self, value,
425 "Timezone name or numeric hour offset required")
426 return value
428 class RegExpOption(Option):
430 """Regular Expression option (value is Regular Expression Object)"""
432 class_description = "Value is Python Regular Expression (UTF8-encoded)."
434 RE_TYPE = type(re.compile(""))
436 def __init__(self, config, section, setting,
437 default=NODEFAULT, description=None, aliases=None,
438 flags=0,
439 ):
440 self.flags = flags
441 Option.__init__(self, config, section, setting, default,
442 description, aliases)
444 def _value2str(self, value):
445 assert isinstance(value, self.RE_TYPE)
446 return value.pattern
448 def str2value(self, value):
449 if not isinstance(value, unicode):
450 value = str(value)
451 # if it is 7-bit ascii, use it as string,
452 # otherwise convert to unicode.
453 try:
454 value.decode("ascii")
455 except UnicodeError:
456 value = value.decode("utf-8")
457 return re.compile(value, self.flags)
459 ### Main configuration layout.
460 # Config is described as a sequence of sections,
461 # where each section name is followed by a sequence
462 # of Option definitions. Each Option definition
463 # is a sequence containing class name and constructor
464 # parameters, starting from the setting name:
465 # setting, default, [description, [aliases]]
466 # Note: aliases should only exist in historical options for backwards
467 # compatibility - new options should *not* have aliases!
468 SETTINGS = (
469 ("main", (
470 (FilePathOption, "database", "db", "Database directory path."),
471 (FilePathOption, "templates", "html",
472 "Path to the HTML templates directory."),
473 (NullableFilePathOption, "static_files", "",
474 "Path to directory holding additional static files\n"
475 "available via Web UI. This directory may contain\n"
476 "sitewide images, CSS stylesheets etc. and is searched\n"
477 "for these files prior to the TEMPLATES directory\n"
478 "specified above. If this option is not set, all static\n"
479 "files are taken from the TEMPLATES directory"),
480 (MailAddressOption, "admin_email", "roundup-admin",
481 "Email address that roundup will complain to if it runs\n"
482 "into trouble.\n"
483 "If no domain is specified then the config item\n"
484 "mail -> domain is added."),
485 (MailAddressOption, "dispatcher_email", "roundup-admin",
486 "The 'dispatcher' is a role that can get notified\n"
487 "of new items to the database.\n"
488 "It is used by the ERROR_MESSAGES_TO config setting.\n"
489 "If no domain is specified then the config item\n"
490 "mail -> domain is added."),
491 (Option, "email_from_tag", "",
492 "Additional text to include in the \"name\" part\n"
493 "of the From: address used in nosy messages.\n"
494 "If the sending user is \"Foo Bar\", the From: line\n"
495 "is usually: \"Foo Bar\" <issue_tracker@tracker.example>\n"
496 "the EMAIL_FROM_TAG goes inside the \"Foo Bar\" quotes like so:\n"
497 "\"Foo Bar EMAIL_FROM_TAG\" <issue_tracker@tracker.example>"),
498 (Option, "new_web_user_roles", "User",
499 "Roles that a user gets when they register"
500 " with Web User Interface.\n"
501 "This is a comma-separated string of role names"
502 " (e.g. 'Admin,User')."),
503 (Option, "new_email_user_roles", "User",
504 "Roles that a user gets when they register"
505 " with Email Gateway.\n"
506 "This is a comma-separated string of role names"
507 " (e.g. 'Admin,User')."),
508 (Option, "error_messages_to", "user",
509 # XXX This description needs better wording,
510 # with explicit allowed values list.
511 "Send error message emails to the dispatcher, user, or both?\n"
512 "The dispatcher is configured using the DISPATCHER_EMAIL"
513 " setting."),
514 (Option, "html_version", "html4",
515 "HTML version to generate. The templates are html4 by default.\n"
516 "If you wish to make them xhtml, then you'll need to change this\n"
517 "var to 'xhtml' too so all auto-generated HTML is compliant.\n"
518 "Allowed values: html4, xhtml"),
519 (TimezoneOption, "timezone", "UTC", "Default timezone offset,"
520 " applied when user's timezone is not set.",
521 ["DEFAULT_TIMEZONE"]),
522 (BooleanOption, "instant_registration", "no",
523 "Register new users instantly, or require confirmation via\n"
524 "email?"),
525 (BooleanOption, "email_registration_confirmation", "yes",
526 "Offer registration confirmation by email or only through the web?"),
527 (WordListOption, "indexer_stopwords", "",
528 "Additional stop-words for the full-text indexer specific to\n"
529 "your tracker. See the indexer source for the default list of\n"
530 "stop-words (eg. A,AND,ARE,AS,AT,BE,BUT,BY, ...)"),
531 (OctalNumberOption, "umask", "02",
532 "Defines the file creation mode mask."),
533 (IntegerNumberOption, 'csv_field_size', '131072',
534 "Maximum size of a csv-field during import. Roundups export\n"
535 "format is a csv (comma separated values) variant. The csv\n"
536 "reader has a limit on the size of individual fields\n"
537 "starting with python 2.5. Set this to a higher value if you\n"
538 "get the error 'Error: field larger than field limit' during\n"
539 "import."),
540 (IntegerNumberOption, 'password_pbkdf2_default_rounds', '10000',
541 "Sets the default number of rounds used when encoding passwords\n"
542 "using the PBKDF2 scheme. Set this to a higher value on faster\n"
543 "systems which want more security.\n"
544 "PBKDF2 (Password-Based Key Derivation Function) is a\n"
545 "password hashing mechanism that derives hash from the\n"
546 "password and a random salt. For authentication this process\n"
547 "is repeated with the same salt as in the stored hash.\n"
548 "If both hashes match, the authentication succeeds.\n"
549 "PBKDF2 supports a variable 'rounds' parameter which varies\n"
550 "the time-cost of calculating the hash - doubling the number\n"
551 "of rounds doubles the cpu time required to calculate it. The\n"
552 "purpose of this is to periodically adjust the rounds as CPUs\n"
553 "become faster. The currently enforced minimum number of\n"
554 "rounds is 1000.\n"
555 "See: http://en.wikipedia.org/wiki/PBKDF2 and RFC2898"),
556 )),
557 ("tracker", (
558 (Option, "name", "Roundup issue tracker",
559 "A descriptive name for your roundup instance."),
560 (Option, "web", NODEFAULT,
561 "The web address that the tracker is viewable at.\n"
562 "This will be included in information"
563 " sent to users of the tracker.\n"
564 "The URL MUST include the cgi-bin part or anything else\n"
565 "that is required to get to the home page of the tracker.\n"
566 "You MUST include a trailing '/' in the URL."),
567 (MailAddressOption, "email", "issue_tracker",
568 "Email address that mail to roundup should go to.\n"
569 "If no domain is specified then mail_domain is added."),
570 (NullableOption, "language", "",
571 "Default locale name for this tracker.\n"
572 "If this option is not set, the language is determined\n"
573 "by OS environment variable LANGUAGE, LC_ALL, LC_MESSAGES,\n"
574 "or LANG, in that order of preference."),
575 )),
576 ("web", (
577 (BooleanOption, "allow_html_file", "no",
578 "Setting this option enables Roundup to serve uploaded HTML\n"
579 "file content *as HTML*. This is a potential security risk\n"
580 "and is therefore disabled by default. Set to 'yes' if you\n"
581 "trust *all* users uploading content to your tracker."),
582 (BooleanOption, 'http_auth', "yes",
583 "Whether to use HTTP Basic Authentication, if present.\n"
584 "Roundup will use either the REMOTE_USER or HTTP_AUTHORIZATION\n"
585 "variables supplied by your web server (in that order).\n"
586 "Set this option to 'no' if you do not wish to use HTTP Basic\n"
587 "Authentication in your web interface."),
588 (BooleanOption, 'use_browser_language', "yes",
589 "Whether to use HTTP Accept-Language, if present.\n"
590 "Browsers send a language-region preference list.\n"
591 "It's usually set in the client's browser or in their\n"
592 "Operating System.\n"
593 "Set this option to 'no' if you want to ignore it."),
594 (BooleanOption, "debug", "no",
595 "Setting this option makes Roundup display error tracebacks\n"
596 "in the user's browser rather than emailing them to the\n"
597 "tracker admin."),
598 (BooleanOption, "migrate_passwords", "yes",
599 "Setting this option makes Roundup migrate passwords with\n"
600 "an insecure password-scheme to a more secure scheme\n"
601 "when the user logs in via the web-interface."),
602 )),
603 ("rdbms", (
604 (Option, 'name', 'roundup',
605 "Name of the database to use.",
606 ['MYSQL_DBNAME']),
607 (NullableOption, 'host', 'localhost',
608 "Database server host.",
609 ['MYSQL_DBHOST']),
610 (NullableOption, 'port', '',
611 "TCP port number of the database server.\n"
612 "Postgresql usually resides on port 5432 (if any),\n"
613 "for MySQL default port number is 3306.\n"
614 "Leave this option empty to use backend default"),
615 (NullableOption, 'user', 'roundup',
616 "Database user name that Roundup should use.",
617 ['MYSQL_DBUSER']),
618 (NullableOption, 'password', 'roundup',
619 "Database user password.",
620 ['MYSQL_DBPASSWORD']),
621 (NullableOption, 'read_default_file', '~/.my.cnf',
622 "Name of the MySQL defaults file.\n"
623 "Only used in MySQL connections."),
624 (NullableOption, 'read_default_group', 'roundup',
625 "Name of the group to use in the MySQL defaults file (.my.cnf).\n"
626 "Only used in MySQL connections."),
627 (IntegerNumberOption, 'sqlite_timeout', '30',
628 "Number of seconds to wait when the SQLite database is locked\n"
629 "Default: use a 30 second timeout (extraordinarily generous)\n"
630 "Only used in SQLite connections."),
631 (IntegerNumberOption, 'cache_size', '100',
632 "Size of the node cache (in elements)"),
633 (BooleanOption, "allow_create", "yes",
634 "Setting this option to 'no' protects the database against table creations."),
635 (BooleanOption, "allow_alter", "yes",
636 "Setting this option to 'no' protects the database against table alterations."),
637 (BooleanOption, "allow_drop", "yes",
638 "Setting this option to 'no' protects the database against table drops."),
639 (NullableOption, 'template', '',
640 "Name of the PostgreSQL template for database creation.\n"
641 "For database creation the template used has to match\n"
642 "the character encoding used (UTF8), there are different\n"
643 "PostgreSQL installations using different templates with\n"
644 "different encodings. If you get an error:\n"
645 " new encoding (UTF8) is incompatible with the encoding of\n"
646 " the template database (SQL_ASCII)\n"
647 " HINT: Use the same encoding as in the template database,\n"
648 " or use template0 as template.\n"
649 "then set this option to the template name given in the\n"
650 "error message."),
651 ), "Settings in this section are used"
652 " by RDBMS backends only"
653 ),
654 ("logging", (
655 (FilePathOption, "config", "",
656 "Path to configuration file for standard Python logging module.\n"
657 "If this option is set, logging configuration is loaded\n"
658 "from specified file; options 'filename' and 'level'\n"
659 "in this section are ignored."),
660 (FilePathOption, "filename", "",
661 "Log file name for minimal logging facility built into Roundup.\n"
662 "If no file name specified, log messages are written on stderr.\n"
663 "If above 'config' option is set, this option has no effect."),
664 (Option, "level", "ERROR",
665 "Minimal severity level of messages written to log file.\n"
666 "If above 'config' option is set, this option has no effect.\n"
667 "Allowed values: DEBUG, INFO, WARNING, ERROR"),
668 )),
669 ("mail", (
670 (Option, "domain", NODEFAULT,
671 "The email domain that admin_email, issue_tracker and\n"
672 "dispatcher_email belong to.\n"
673 "This domain is added to those config items if they don't\n"
674 "explicitly include a domain.\n"
675 "Do not include the '@' symbol."),
676 (Option, "host", NODEFAULT,
677 "SMTP mail host that roundup will use to send mail",
678 ["MAILHOST"],),
679 (Option, "username", "", "SMTP login name.\n"
680 "Set this if your mail host requires authenticated access.\n"
681 "If username is not empty, password (below) MUST be set!"),
682 (Option, "password", NODEFAULT, "SMTP login password.\n"
683 "Set this if your mail host requires authenticated access."),
684 (IntegerNumberOption, "port", smtplib.SMTP_PORT,
685 "Default port to send SMTP on.\n"
686 "Set this if your mail server runs on a different port."),
687 (NullableOption, "local_hostname", '',
688 "The local hostname to use during SMTP transmission.\n"
689 "Set this if your mail server requires something specific."),
690 (BooleanOption, "tls", "no",
691 "If your SMTP mail host provides or requires TLS\n"
692 "(Transport Layer Security) then set this option to 'yes'."),
693 (NullableFilePathOption, "tls_keyfile", "",
694 "If TLS is used, you may set this option to the name\n"
695 "of a PEM formatted file that contains your private key."),
696 (NullableFilePathOption, "tls_certfile", "",
697 "If TLS is used, you may set this option to the name\n"
698 "of a PEM formatted certificate chain file."),
699 (Option, "charset", "utf-8",
700 "Character set to encode email headers with.\n"
701 "We use utf-8 by default, as it's the most flexible.\n"
702 "Some mail readers (eg. Eudora) can't cope with that,\n"
703 "so you might need to specify a more limited character set\n"
704 "(eg. iso-8859-1).",
705 ["EMAIL_CHARSET"]),
706 (FilePathOption, "debug", "",
707 "Setting this option makes Roundup to write all outgoing email\n"
708 "messages to this file *instead* of sending them.\n"
709 "This option has the same effect as environment variable"
710 " SENDMAILDEBUG.\nEnvironment variable takes precedence."),
711 (BooleanOption, "add_authorinfo", "yes",
712 "Add a line with author information at top of all messages\n"
713 "sent by roundup"),
714 (BooleanOption, "add_authoremail", "yes",
715 "Add the mail address of the author to the author information at\n"
716 "the top of all messages.\n"
717 "If this is false but add_authorinfo is true, only the name\n"
718 "of the actor is added which protects the mail address of the\n"
719 "actor from being exposed at mail archives, etc."),
720 ), "Outgoing email options.\nUsed for nozy messages and approval requests"),
721 ("mailgw", (
722 (BooleanOption, "keep_quoted_text", "yes",
723 "Keep email citations when accepting messages.\n"
724 "Setting this to \"no\" strips out \"quoted\" text"
725 " from the message.\n"
726 "Signatures are also stripped.",
727 ["EMAIL_KEEP_QUOTED_TEXT"]),
728 (BooleanOption, "leave_body_unchanged", "no",
729 "Preserve the email body as is - that is,\n"
730 "keep the citations _and_ signatures.",
731 ["EMAIL_LEAVE_BODY_UNCHANGED"]),
732 (Option, "default_class", "issue",
733 "Default class to use in the mailgw\n"
734 "if one isn't supplied in email subjects.\n"
735 "To disable, leave the value blank.",
736 ["MAIL_DEFAULT_CLASS"]),
737 (NullableOption, "language", "",
738 "Default locale name for the tracker mail gateway.\n"
739 "If this option is not set, mail gateway will use\n"
740 "the language of the tracker instance."),
741 (Option, "subject_prefix_parsing", "strict",
742 "Controls the parsing of the [prefix] on subject\n"
743 "lines in incoming emails. \"strict\" will return an\n"
744 "error to the sender if the [prefix] is not recognised.\n"
745 "\"loose\" will attempt to parse the [prefix] but just\n"
746 "pass it through as part of the issue title if not\n"
747 "recognised. \"none\" will always pass any [prefix]\n"
748 "through as part of the issue title."),
749 (Option, "subject_suffix_parsing", "strict",
750 "Controls the parsing of the [suffix] on subject\n"
751 "lines in incoming emails. \"strict\" will return an\n"
752 "error to the sender if the [suffix] is not recognised.\n"
753 "\"loose\" will attempt to parse the [suffix] but just\n"
754 "pass it through as part of the issue title if not\n"
755 "recognised. \"none\" will always pass any [suffix]\n"
756 "through as part of the issue title."),
757 (Option, "subject_suffix_delimiters", "[]",
758 "Defines the brackets used for delimiting the prefix and \n"
759 'suffix in a subject line. The presence of "suffix" in\n'
760 "the config option name is a historical artifact and may\n"
761 "be ignored."),
762 (Option, "subject_content_match", "always",
763 "Controls matching of the incoming email subject line\n"
764 "against issue titles in the case where there is no\n"
765 "designator [prefix]. \"never\" turns off matching.\n"
766 "\"creation + interval\" or \"activity + interval\"\n"
767 "will match an issue for the interval after the issue's\n"
768 "creation or last activity. The interval is a standard\n"
769 "Roundup interval."),
770 (BooleanOption, "subject_updates_title", "yes",
771 "Update issue title if incoming subject of email is different.\n"
772 "Setting this to \"no\" will ignore the title part of"
773 " the subject\nof incoming email messages.\n"),
774 (RegExpOption, "refwd_re", "(\s*\W?\s*(fw|fwd|re|aw|sv|ang)\W)+",
775 "Regular expression matching a single reply or forward\n"
776 "prefix prepended by the mailer. This is explicitly\n"
777 "stripped from the subject during parsing."),
778 (RegExpOption, "origmsg_re",
779 "^[>|\s]*-----\s?Original Message\s?-----$",
780 "Regular expression matching start of an original message\n"
781 "if quoted the in body."),
782 (RegExpOption, "sign_re", "^[>|\s]*-- ?$",
783 "Regular expression matching the start of a signature\n"
784 "in the message body."),
785 (RegExpOption, "eol_re", r"[\r\n]+",
786 "Regular expression matching end of line."),
787 (RegExpOption, "blankline_re", r"[\r\n]+\s*[\r\n]+",
788 "Regular expression matching a blank line."),
789 (BooleanOption, "unpack_rfc822", "no",
790 "Unpack attached messages (encoded as message/rfc822 in MIME)\n"
791 "as multiple parts attached as files to the issue, if not\n"
792 "set we handle message/rfc822 attachments as a single file."),
793 (BooleanOption, "ignore_alternatives", "no",
794 "When parsing incoming mails, roundup uses the first\n"
795 "text/plain part it finds. If this part is inside a\n"
796 "multipart/alternative, and this option is set, all other\n"
797 "parts of the multipart/alternative are ignored. The default\n"
798 "is to keep all parts and attach them to the issue."),
799 ), "Roundup Mail Gateway options"),
800 ("pgp", (
801 (BooleanOption, "enable", "no",
802 "Enable PGP processing. Requires pyme. If you're planning\n"
803 "to send encrypted PGP mail to the tracker, you should also\n"
804 "enable the encrypt-option below, otherwise mail received\n"
805 "encrypted might be sent unencrypted to another user."),
806 (NullableOption, "roles", "",
807 "If specified, a comma-separated list of roles to perform\n"
808 "PGP processing on. If not specified, it happens for all\n"
809 "users. Note that received PGP messages (signed and/or\n"
810 "encrypted) will be processed with PGP even if the user\n"
811 "doesn't have one of the PGP roles, you can use this to make\n"
812 "PGP processing completely optional by defining a role here\n"
813 "and not assigning any users to that role."),
814 (NullableOption, "homedir", "",
815 "Location of PGP directory. Defaults to $HOME/.gnupg if\n"
816 "not specified."),
817 (BooleanOption, "encrypt", "no",
818 "Enable PGP encryption. All outgoing mails are encrypted.\n"
819 "This requires that keys for all users (with one of the gpg\n"
820 "roles above or all users if empty) are available. Note that\n"
821 "it makes sense to educate users to also send mails encrypted\n"
822 "to the tracker, to enforce this, set 'require_incoming'\n"
823 "option below (but see the note)."),
824 (Option, "require_incoming", "signed",
825 "Require that pgp messages received by roundup are either\n"
826 "'signed', 'encrypted' or 'both'. If encryption is required\n"
827 "we do not return the message (in clear) to the user but just\n"
828 "send an informational message that the message was rejected.\n"
829 "Note that this still presents known-plaintext to an attacker\n"
830 "when the users sends the mail a second time with encryption\n"
831 "turned on."),
832 ), "OpenPGP mail processing options"),
833 ("nosy", (
834 (Option, "messages_to_author", "no",
835 "Send nosy messages to the author of the message.\n"
836 "Allowed values: yes, no, new, nosy -- if yes, messages\n"
837 "are sent to the author even if not on the nosy list, same\n"
838 "for new (but only for new messages). When set to nosy,\n"
839 "the nosy list controls sending messages to the author.",
840 ["MESSAGES_TO_AUTHOR"]),
841 (Option, "signature_position", "bottom",
842 "Where to place the email signature.\n"
843 "Allowed values: top, bottom, none",
844 ["EMAIL_SIGNATURE_POSITION"]),
845 (RunDetectorOption, "add_author", "new",
846 "Does the author of a message get placed on the nosy list\n"
847 "automatically? If 'new' is used, then the author will\n"
848 "only be added when a message creates a new issue.\n"
849 "If 'yes', then the author will be added on followups too.\n"
850 "If 'no', they're never added to the nosy.\n",
851 ["ADD_AUTHOR_TO_NOSY"]),
852 (RunDetectorOption, "add_recipients", "new",
853 "Do the recipients (To:, Cc:) of a message get placed on the\n"
854 "nosy list? If 'new' is used, then the recipients will\n"
855 "only be added when a message creates a new issue.\n"
856 "If 'yes', then the recipients will be added on followups too.\n"
857 "If 'no', they're never added to the nosy.\n",
858 ["ADD_RECIPIENTS_TO_NOSY"]),
859 (Option, "email_sending", "single",
860 "Controls the email sending from the nosy reactor. If\n"
861 "\"multiple\" then a separate email is sent to each\n"
862 "recipient. If \"single\" then a single email is sent with\n"
863 "each recipient as a CC address."),
864 (IntegerNumberOption, "max_attachment_size", sys.maxint,
865 "Attachments larger than the given number of bytes\n"
866 "won't be attached to nosy mails. They will be replaced by\n"
867 "a link to the tracker's download page for the file.")
868 ), "Nosy messages sending"),
869 )
871 ### Configuration classes
873 class Config:
875 """Base class for configuration objects.
877 Configuration options may be accessed as attributes or items
878 of instances of this class. All option names are uppercased.
880 """
882 # Config file name
883 INI_FILE = "config.ini"
885 # Object attributes that should not be taken as common configuration
886 # options in __setattr__ (most of them are initialized in constructor):
887 # builtin pseudo-option - package home directory
888 HOME = "."
889 # names of .ini file sections, in order
890 sections = None
891 # section comments
892 section_descriptions = None
893 # lists of option names for each section, in order
894 section_options = None
895 # mapping from option names and aliases to Option instances
896 options = None
897 # actual name of the config file. set on load.
898 filepath = os.path.join(HOME, INI_FILE)
900 def __init__(self, config_path=None, layout=None, settings={}):
901 """Initialize confing instance
903 Parameters:
904 config_path:
905 optional directory or file name of the config file.
906 If passed, load the config after processing layout (if any).
907 If config_path is a directory name, use default base name
908 of the config file.
909 layout:
910 optional configuration layout, a sequence of
911 section definitions suitable for .add_section()
912 settings:
913 optional setting overrides (dictionary).
914 The overrides are applied after loading config file.
916 """
917 # initialize option containers:
918 self.sections = []
919 self.section_descriptions = {}
920 self.section_options = {}
921 self.options = {}
922 # add options from the layout structure
923 if layout:
924 for section in layout:
925 self.add_section(*section)
926 if config_path is not None:
927 self.load(config_path)
928 for (name, value) in settings.items():
929 self[name.upper()] = value
931 def add_section(self, section, options, description=None):
932 """Define new config section
934 Parameters:
935 section - name of the config.ini section
936 options - a sequence of Option definitions.
937 Each Option definition is a sequence
938 containing class object and constructor
939 parameters, starting from the setting name:
940 setting, default, [description, [aliases]]
941 description - optional section comment
943 Note: aliases should only exist in historical options
944 for backwards compatibility - new options should
945 *not* have aliases!
947 """
948 if description or not self.section_descriptions.has_key(section):
949 self.section_descriptions[section] = description
950 for option_def in options:
951 klass = option_def[0]
952 args = option_def[1:]
953 option = klass(self, section, *args)
954 self.add_option(option)
956 def add_option(self, option):
957 """Adopt a new Option object"""
958 _section = option.section
959 _name = option.setting
960 if _section not in self.sections:
961 self.sections.append(_section)
962 _options = self._get_section_options(_section)
963 if _name not in _options:
964 _options.append(_name)
965 # (section, name) key is used for writing .ini file
966 self.options[(_section, _name)] = option
967 # make the option known under all of its A.K.A.s
968 for _name in option.aliases:
969 self.options[_name] = option
971 def update_option(self, name, klass,
972 default=NODEFAULT, description=None
973 ):
974 """Override behaviour of early created option.
976 Parameters:
977 name:
978 option name
979 klass:
980 one of the Option classes
981 default:
982 optional default value for the option
983 description:
984 optional new description for the option
986 Conversion from current option value to new class value
987 is done via string representation.
989 This method may be used to attach some brains
990 to options autocreated by UserConfig.
992 """
993 # fetch current option
994 option = self._get_option(name)
995 # compute constructor parameters
996 if default is NODEFAULT:
997 default = option.default
998 if description is None:
999 description = option.description
1000 value = option.value2str(current=1)
1001 # resurrect the option
1002 option = klass(self, option.section, option.setting,
1003 default=default, description=description)
1004 # apply the value
1005 option.set(value)
1006 # incorporate new option
1007 del self[name]
1008 self.add_option(option)
1010 def reset(self):
1011 """Set all options to their default values"""
1012 for _option in self.items():
1013 _option.reset()
1015 # Meant for commandline tools.
1016 # Allows automatic creation of configuration files like this:
1017 # roundup-server -p 8017 -u roundup --save-config
1018 def getopt(self, args, short_options="", long_options=(),
1019 config_load_options=("C", "config"), **options
1020 ):
1021 """Apply options specified in command line arguments.
1023 Parameters:
1024 args:
1025 command line to parse (sys.argv[1:])
1026 short_options:
1027 optional string of letters for command line options
1028 that are not config options
1029 long_options:
1030 optional list of names for long options
1031 that are not config options
1032 config_load_options:
1033 two-element sequence (letter, long_option) defining
1034 the options for config file. If unset, don't load
1035 config file; otherwise config file is read prior
1036 to applying other options. Short option letter
1037 must not have a colon and long_option name must
1038 not have an equal sign or '--' prefix.
1039 options:
1040 mapping from option names to command line option specs.
1041 e.g. server_port="p:", server_user="u:"
1042 Names are forced to lower case for commandline parsing
1043 (long options) and to upper case to find config options.
1044 Command line options accepting no value are assumed
1045 to be binary and receive value 'yes'.
1047 Return value: same as for python standard getopt(), except that
1048 processed options are removed from returned option list.
1050 """
1051 # take a copy of long_options
1052 long_options = list(long_options)
1053 # build option lists
1054 cfg_names = {}
1055 booleans = []
1056 for (name, letter) in options.items():
1057 cfg_name = name.upper()
1058 short_opt = "-" + letter[0]
1059 name = name.lower().replace("_", "-")
1060 cfg_names.update({short_opt: cfg_name, "--" + name: cfg_name})
1062 short_options += letter
1063 if letter[-1] == ":":
1064 long_options.append(name + "=")
1065 else:
1066 booleans.append(short_opt)
1067 long_options.append(name)
1069 if config_load_options:
1070 short_options += config_load_options[0] + ":"
1071 long_options.append(config_load_options[1] + "=")
1072 # compute names that will be searched in getopt return value
1073 config_load_options = (
1074 "-" + config_load_options[0],
1075 "--" + config_load_options[1],
1076 )
1077 # parse command line arguments
1078 optlist, args = getopt.getopt(args, short_options, long_options)
1079 # load config file if requested
1080 if config_load_options:
1081 for option in optlist:
1082 if option[0] in config_load_options:
1083 self.load_ini(option[1])
1084 optlist.remove(option)
1085 break
1086 # apply options
1087 extra_options = []
1088 for (opt, arg) in optlist:
1089 if (opt in booleans): # and not arg
1090 arg = "yes"
1091 try:
1092 name = cfg_names[opt]
1093 except KeyError:
1094 extra_options.append((opt, arg))
1095 else:
1096 self[name] = arg
1097 return (extra_options, args)
1099 # option and section locators (used in option access methods)
1101 def _get_option(self, name):
1102 try:
1103 return self.options[name]
1104 except KeyError:
1105 raise InvalidOptionError(name)
1107 def _get_section_options(self, name):
1108 return self.section_options.setdefault(name, [])
1110 def _get_unset_options(self):
1111 """Return options that need manual adjustments
1113 Return value is a dictionary where keys are section
1114 names and values are lists of option names as they
1115 appear in the config file.
1117 """
1118 need_set = {}
1119 for option in self.items():
1120 if not option.isset():
1121 need_set.setdefault(option.section, []).append(option.setting)
1122 return need_set
1124 def _adjust_options(self, config):
1125 """Load ad-hoc option definitions from ConfigParser instance."""
1126 pass
1128 def _get_name(self):
1129 """Return the service name for config file heading"""
1130 return ""
1132 # file operations
1134 def load_ini(self, config_path, defaults=None):
1135 """Set options from config.ini file in given home_dir
1137 Parameters:
1138 config_path:
1139 directory or file name of the config file.
1140 If config_path is a directory name, use default
1141 base name of the config file
1142 defaults:
1143 optional dictionary of defaults for ConfigParser
1145 Note: if home_dir does not contain config.ini file,
1146 no error is raised. Config will be reset to defaults.
1148 """
1149 if os.path.isdir(config_path):
1150 home_dir = config_path
1151 config_path = os.path.join(config_path, self.INI_FILE)
1152 else:
1153 home_dir = os.path.dirname(config_path)
1154 # parse the file
1155 config_defaults = {"HOME": home_dir}
1156 if defaults:
1157 config_defaults.update(defaults)
1158 config = ConfigParser.ConfigParser(config_defaults)
1159 config.read([config_path])
1160 # .ini file loaded ok.
1161 self.HOME = home_dir
1162 self.filepath = config_path
1163 self._adjust_options(config)
1164 # set the options, starting from HOME
1165 self.reset()
1166 for option in self.items():
1167 option.load_ini(config)
1169 def load(self, home_dir):
1170 """Load configuration settings from home_dir"""
1171 self.load_ini(home_dir)
1173 def save(self, ini_file=None):
1174 """Write current configuration to .ini file
1176 'ini_file' argument, if passed, must be valid full path
1177 to the file to write. If omitted, default file in current
1178 HOME is created.
1180 If the file to write already exists, it is saved with '.bak'
1181 extension.
1183 """
1184 if ini_file is None:
1185 ini_file = self.filepath
1186 _tmp_file = os.path.splitext(ini_file)[0]
1187 _bak_file = _tmp_file + ".bak"
1188 _tmp_file = _tmp_file + ".tmp"
1189 _fp = file(_tmp_file, "wt")
1190 _fp.write("# %s configuration file\n" % self._get_name())
1191 _fp.write("# Autogenerated at %s\n" % time.asctime())
1192 need_set = self._get_unset_options()
1193 if need_set:
1194 _fp.write("\n# WARNING! Following options need adjustments:\n")
1195 for section, options in need_set.items():
1196 _fp.write("# [%s]: %s\n" % (section, ", ".join(options)))
1197 for section in self.sections:
1198 comment = self.section_descriptions.get(section, None)
1199 if comment:
1200 _fp.write("\n# ".join([""] + comment.split("\n")) +"\n")
1201 else:
1202 # no section comment - just leave a blank line between sections
1203 _fp.write("\n")
1204 _fp.write("[%s]\n" % section)
1205 for option in self._get_section_options(section):
1206 _fp.write("\n" + self.options[(section, option)].format())
1207 _fp.close()
1208 if os.access(ini_file, os.F_OK):
1209 if os.access(_bak_file, os.F_OK):
1210 os.remove(_bak_file)
1211 os.rename(ini_file, _bak_file)
1212 os.rename(_tmp_file, ini_file)
1214 # container emulation
1216 def __len__(self):
1217 return len(self.items())
1219 def __getitem__(self, name):
1220 if name == "HOME":
1221 return self.HOME
1222 else:
1223 return self._get_option(name).get()
1225 def __setitem__(self, name, value):
1226 if name == "HOME":
1227 self.HOME = value
1228 else:
1229 self._get_option(name).set(value)
1231 def __delitem__(self, name):
1232 _option = self._get_option(name)
1233 _section = _option.section
1234 _name = _option.setting
1235 self._get_section_options(_section).remove(_name)
1236 del self.options[(_section, _name)]
1237 for _alias in _option.aliases:
1238 del self.options[_alias]
1240 def items(self):
1241 """Return the list of Option objects, in .ini file order
1243 Note that HOME is not included in this list
1244 because it is builtin pseudo-option, not a real Option
1245 object loaded from or saved to .ini file.
1247 """
1248 return [self.options[(_section, _name)]
1249 for _section in self.sections
1250 for _name in self._get_section_options(_section)
1251 ]
1253 def keys(self):
1254 """Return the list of "canonical" names of the options
1256 Unlike .items(), this list also includes HOME
1258 """
1259 return ["HOME"] + [_option.name for _option in self.items()]
1261 # .values() is not implemented because i am not sure what should be
1262 # the values returned from this method: Option instances or config values?
1264 # attribute emulation
1266 def __setattr__(self, name, value):
1267 if self.__dict__.has_key(name) or hasattr(self.__class__, name):
1268 self.__dict__[name] = value
1269 else:
1270 self._get_option(name).set(value)
1272 # Note: __getattr__ is not symmetric to __setattr__:
1273 # self.__dict__ lookup is done before calling this method
1274 def __getattr__(self, name):
1275 return self[name]
1277 class UserConfig(Config):
1279 """Configuration for user extensions.
1281 Instances of this class have no predefined configuration layout.
1282 Options are created on the fly for each setting present in the
1283 config file.
1285 """
1287 def _adjust_options(self, config):
1288 # config defaults appear in all sections.
1289 # we'll need to filter them out.
1290 defaults = config.defaults().keys()
1291 # see what options are already defined and add missing ones
1292 preset = [(option.section, option.setting) for option in self.items()]
1293 for section in config.sections():
1294 for name in config.options(section):
1295 if ((section, name) not in preset) \
1296 and (name not in defaults):
1297 self.add_option(Option(self, section, name))
1299 class CoreConfig(Config):
1301 """Roundup instance configuration.
1303 Core config has a predefined layout (see the SETTINGS structure),
1304 supports loading of old-style pythonic configurations and holds
1305 three additional attributes:
1306 logging:
1307 instance logging engine, from standard python logging module
1308 or minimalistic logger implemented in Roundup
1309 detectors:
1310 user-defined configuration for detectors
1311 ext:
1312 user-defined configuration for extensions
1314 """
1316 # module name for old style configuration
1317 PYCONFIG = "config"
1318 # user configs
1319 ext = None
1320 detectors = None
1322 def __init__(self, home_dir=None, settings={}):
1323 Config.__init__(self, home_dir, layout=SETTINGS, settings=settings)
1324 # load the config if home_dir given
1325 if home_dir is None:
1326 self.init_logging()
1328 def copy(self):
1329 new = CoreConfig()
1330 new.sections = list(self.sections)
1331 new.section_descriptions = dict(self.section_descriptions)
1332 new.section_options = dict(self.section_options)
1333 new.options = dict(self.options)
1334 return new
1336 def _get_unset_options(self):
1337 need_set = Config._get_unset_options(self)
1338 # remove MAIL_PASSWORD if MAIL_USER is empty
1339 if "password" in need_set.get("mail", []):
1340 if not self["MAIL_USERNAME"]:
1341 settings = need_set["mail"]
1342 settings.remove("password")
1343 if not settings:
1344 del need_set["mail"]
1345 return need_set
1347 def _get_name(self):
1348 return self["TRACKER_NAME"]
1350 def reset(self):
1351 Config.reset(self)
1352 if self.ext:
1353 self.ext.reset()
1354 if self.detectors:
1355 self.detectors.reset()
1356 self.init_logging()
1358 def init_logging(self):
1359 _file = self["LOGGING_CONFIG"]
1360 if _file and os.path.isfile(_file):
1361 logging.config.fileConfig(_file)
1362 return
1364 _file = self["LOGGING_FILENAME"]
1365 # set file & level on the roundup logger
1366 logger = logging.getLogger('roundup')
1367 if _file:
1368 hdlr = logging.FileHandler(_file)
1369 else:
1370 hdlr = logging.StreamHandler(sys.stdout)
1371 formatter = logging.Formatter(
1372 '%(asctime)s %(levelname)s %(message)s')
1373 hdlr.setFormatter(formatter)
1374 # no logging API to remove all existing handlers!?!
1375 for h in logger.handlers:
1376 h.close()
1377 logger.removeHandler(hdlr)
1378 logger.handlers = [hdlr]
1379 logger.setLevel(logging._levelNames[self["LOGGING_LEVEL"] or "ERROR"])
1381 def load(self, home_dir):
1382 """Load configuration from path designated by home_dir argument"""
1383 if os.path.isfile(os.path.join(home_dir, self.INI_FILE)):
1384 self.load_ini(home_dir)
1385 else:
1386 self.load_pyconfig(home_dir)
1387 self.init_logging()
1388 self.ext = UserConfig(os.path.join(home_dir, "extensions"))
1389 self.detectors = UserConfig(os.path.join(home_dir, "detectors"))
1391 def load_ini(self, home_dir, defaults=None):
1392 """Set options from config.ini file in given home_dir directory"""
1393 config_defaults = {"TRACKER_HOME": home_dir}
1394 if defaults:
1395 config_defaults.update(defaults)
1396 Config.load_ini(self, home_dir, config_defaults)
1398 def load_pyconfig(self, home_dir):
1399 """Set options from config.py file in given home_dir directory"""
1400 # try to locate and import the module
1401 _mod_fp = None
1402 try:
1403 try:
1404 _module = imp.find_module(self.PYCONFIG, [home_dir])
1405 _mod_fp = _module[0]
1406 _config = imp.load_module(self.PYCONFIG, *_module)
1407 except ImportError:
1408 raise NoConfigError(home_dir)
1409 finally:
1410 if _mod_fp is not None:
1411 _mod_fp.close()
1412 # module loaded ok. set the options, starting from HOME
1413 self.reset()
1414 self.HOME = home_dir
1415 for _option in self.items():
1416 _option.load_pyconfig(_config)
1417 # backward compatibility:
1418 # SMTP login parameters were specified as a tuple in old style configs
1419 # convert them to new plain string options
1420 _mailuser = getattr(_config, "MAILUSER", ())
1421 if len(_mailuser) > 0:
1422 self.MAIL_USERNAME = _mailuser[0]
1423 if len(_mailuser) > 1:
1424 self.MAIL_PASSWORD = _mailuser[1]
1426 # in this config, HOME is also known as TRACKER_HOME
1427 def __getitem__(self, name):
1428 if name == "TRACKER_HOME":
1429 return self.HOME
1430 else:
1431 return Config.__getitem__(self, name)
1433 def __setitem__(self, name, value):
1434 if name == "TRACKER_HOME":
1435 self.HOME = value
1436 else:
1437 self._get_option(name).set(value)
1439 def __setattr__(self, name, value):
1440 if name == "TRACKER_HOME":
1441 self.__dict__["HOME"] = value
1442 else:
1443 Config.__setattr__(self, name, value)
1445 # vim: set et sts=4 sw=4 :