roundup/configuration.py

   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"
   6
   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
  16
  17 import roundup.date
  18
  19 # XXX i don't think this module needs string translation, does it?
  20
  21 ### Exceptions
  22
  23 class ConfigurationError(Exception):
  24     pass
  25
  26 class NoConfigError(ConfigurationError):
  27
  28     """Raised when configuration loading fails
  29
  30     Constructor parameters: path to the directory that was used as HOME
  31
  32     """
  33
  34     def __str__(self):
  35         return "No valid configuration files found in directory %s" \
  36             % self.args[0]
  37
  38 class InvalidOptionError(ConfigurationError, KeyError, AttributeError):
  39
  40     """Attempted access to non-existing configuration option
  41
  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).
  46
  47     Constructor parameter: option name
  48
  49     """
  50
  51     def __str__(self):
  52         return "Unsupported configuration option: %s" % self.args[0]
  53
  54 class OptionValueError(ConfigurationError, ValueError):
  55
  56     """Raised upon attempt to assign an invalid value to config option
  57
  58     Constructor parameters: Option instance, offending value
  59     and optional info string.
  60
  61     """
  62
  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
  70
  71 class OptionUnsetError(ConfigurationError):
  72
  73     """Raised when no Option value is available - neither set, nor default
  74
  75     Constructor parameters: Option instance.
  76
  77     """
  78
  79     def __str__(self):
  80         return "%s is not set and has no default" % self.args[0].name
  81
  82 class UnsetDefaultValue:
  83
  84     """Special object meaning that default value for Option is not specified"""
  85
  86     def __str__(self):
  87         return "NO DEFAULT"
  88
  89 NODEFAULT = UnsetDefaultValue()
  90
  91 ### Option classes
  92
  93 class Option:
  94
  95     """Single configuration option.
  96
  97     Options have following attributes:
  98
  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.
 119
 120     The name and aliases are forced to be uppercase.
 121     The setting name is forced to lowercase.
 122
 123     """
 124
 125     class_description = None
 126
 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
 150
 151     def str2value(self, value):
 152         """Return 'value' argument converted to internal representation"""
 153         return value
 154
 155     def _value2str(self, value):
 156         """Return 'value' argument converted to external representation
 157
 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().
 161
 162         """
 163         return str(value)
 164
 165     def value2str(self, value=NODEFAULT, current=0):
 166         """Return 'value' argument converted to external representation
 167
 168         If 'current' is True, use current option value.
 169
 170         """
 171         if current:
 172             value = self._value
 173         if value is NODEFAULT:
 174             return str(value)
 175         else:
 176             return self._value2str(value)
 177
 178     def get(self):
 179         """Return current option value"""
 180         if self._value is NODEFAULT:
 181             raise OptionUnsetError(self)
 182         return self._value
 183
 184     def set(self, value):
 185         """Update the value"""
 186         self._value = self.str2value(value)
 187
 188     def reset(self):
 189         """Reset the value to default"""
 190         self._value = self._default_value
 191
 192     def isdefault(self):
 193         """Return True if current value is the default one"""
 194         return self._value == self._default_value
 195
 196     def isset(self):
 197         """Return True if the value is available (either set or default)"""
 198         return self._value != NODEFAULT
 199
 200     def __str__(self):
 201         return self.value2str(self._value)
 202
 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         }
 214
 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
 235
 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))
 240
 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
 247
 248 class BooleanOption(Option):
 249
 250     """Boolean option: yes or no"""
 251
 252     class_description = "Allowed values: yes, no"
 253
 254     def _value2str(self, value):
 255         if value:
 256             return "yes"
 257         else:
 258             return "no"
 259
 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
 272
 273 class WordListOption(Option):
 274
 275     """List of strings"""
 276
 277     class_description = "Allowed values: comma-separated list of words"
 278
 279     def _value2str(self, value):
 280         return ','.join(value)
 281
 282     def str2value(self, value):
 283         return value.split(',')
 284
 285 class RunDetectorOption(Option):
 286
 287     """When a detector is run: always, never or for new items only"""
 288
 289     class_description = "Allowed values: yes, no, new"
 290
 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)
 297
 298 class MailAddressOption(Option):
 299
 300     """Email address
 301
 302     Email addresses may be either fully qualified or local.
 303     In the latter case MAIL_DOMAIN is automatically added.
 304
 305     """
 306
 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
 312
 313 class FilePathOption(Option):
 314
 315     """File or directory path name
 316
 317     Paths may be either absolute or relative to the HOME.
 318
 319     """
 320
 321     class_description = "The path may be either absolute or relative\n" \
 322         "to the directory containig this config file."
 323
 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
 329
 330 class FloatNumberOption(Option):
 331
 332     """Floating point numbers"""
 333
 334     def str2value(self, value):
 335         try:
 336             return float(value)
 337         except ValueError:
 338             raise OptionValueError(self, value,
 339                 "Floating point number required")
 340
 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
 347
 348 class IntegerNumberOption(Option):
 349
 350     """Integer numbers"""
 351
 352     def str2value(self, value):
 353         try:
 354             return int(value)
 355         except ValueError:
 356             raise OptionValueError(self, value, "Integer number required")
 357
 358 class OctalNumberOption(Option):
 359
 360     """Octal Integer numbers"""
 361
 362     def str2value(self, value):
 363         try:
 364             return int(value, 8)
 365         except ValueError:
 366             raise OptionValueError(self, value, "Octal Integer number required")
 367
 368     def _value2str(self, value):
 369         return oct(value)
 370
 371 class NullableOption(Option):
 372
 373     """Option that is set to None if its string value is one of NULL strings
 374
 375     Default nullable strings list contains empty string only.
 376     There is constructor parameter allowing to specify different nullables.
 377
 378     Conversion to external representation returns the first of the NULL
 379     strings list when the value is None.
 380
 381     """
 382
 383     NULL_STRINGS = ("",)
 384
 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)
 392
 393     def str2value(self, value):
 394         if value in self.null_strings:
 395             return None
 396         else:
 397             return value
 398
 399     def _value2str(self, value):
 400         if value is None:
 401             return self.null_strings[0]
 402         else:
 403             return value
 404
 405 class NullableFilePathOption(NullableOption, FilePathOption):
 406
 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)
 411
 412 class TimezoneOption(Option):
 413
 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."
 419
 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
 427
 428 class RegExpOption(Option):
 429
 430     """Regular Expression option (value is Regular Expression Object)"""
 431
 432     class_description = "Value is Python Regular Expression (UTF8-encoded)."
 433
 434     RE_TYPE = type(re.compile(""))
 435
 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)
 443
 444     def _value2str(self, value):
 445         assert isinstance(value, self.RE_TYPE)
 446         return value.pattern
 447
 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)
 458
 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 )
 870
 871 ### Configuration classes
 872
 873 class Config:
 874
 875     """Base class for configuration objects.
 876
 877     Configuration options may be accessed as attributes or items
 878     of instances of this class.  All option names are uppercased.
 879
 880     """
 881
 882     # Config file name
 883     INI_FILE = "config.ini"
 884
 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)
 899
 900     def __init__(self, config_path=None, layout=None, settings={}):
 901         """Initialize confing instance
 902
 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.
 915
 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
 930
 931     def add_section(self, section, options, description=None):
 932         """Define new config section
 933
 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
 942
 943         Note: aliases should only exist in historical options
 944         for backwards compatibility - new options should
 945         *not* have aliases!
 946
 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)
 955
 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
 970
 971     def update_option(self, name, klass,
 972         default=NODEFAULT, description=None
 973     ):
 974         """Override behaviour of early created option.
 975
 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
 985
 986         Conversion from current option value to new class value
 987         is done via string representation.
 988
 989         This method may be used to attach some brains
 990         to options autocreated by UserConfig.
 991
 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)
1009
1010     def reset(self):
1011         """Set all options to their default values"""
1012         for _option in self.items():
1013             _option.reset()
1014
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.
1022
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'.
1046
1047         Return value: same as for python standard getopt(), except that
1048         processed options are removed from returned option list.
1049
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})
1061
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)
1068
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)
1098
1099     # option and section locators (used in option access methods)
1100
1101     def _get_option(self, name):
1102         try:
1103             return self.options[name]
1104         except KeyError:
1105             raise InvalidOptionError(name)
1106
1107     def _get_section_options(self, name):
1108         return self.section_options.setdefault(name, [])
1109
1110     def _get_unset_options(self):
1111         """Return options that need manual adjustments
1112
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.
1116
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
1123
1124     def _adjust_options(self, config):
1125         """Load ad-hoc option definitions from ConfigParser instance."""
1126         pass
1127
1128     def _get_name(self):
1129         """Return the service name for config file heading"""
1130         return ""
1131
1132     # file operations
1133
1134     def load_ini(self, config_path, defaults=None):
1135         """Set options from config.ini file in given home_dir
1136
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
1144
1145         Note: if home_dir does not contain config.ini file,
1146         no error is raised.  Config will be reset to defaults.
1147
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)
1168
1169     def load(self, home_dir):
1170         """Load configuration settings from home_dir"""
1171         self.load_ini(home_dir)
1172
1173     def save(self, ini_file=None):
1174         """Write current configuration to .ini file
1175
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.
1179
1180         If the file to write already exists, it is saved with '.bak'
1181         extension.
1182
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)
1213
1214     # container emulation
1215
1216     def __len__(self):
1217         return len(self.items())
1218
1219     def __getitem__(self, name):
1220         if name == "HOME":
1221             return self.HOME
1222         else:
1223             return self._get_option(name).get()
1224
1225     def __setitem__(self, name, value):
1226         if name == "HOME":
1227             self.HOME = value
1228         else:
1229             self._get_option(name).set(value)
1230
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]
1239
1240     def items(self):
1241         """Return the list of Option objects, in .ini file order
1242
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.
1246
1247         """
1248         return [self.options[(_section, _name)]
1249             for _section in self.sections
1250             for _name in self._get_section_options(_section)
1251         ]
1252
1253     def keys(self):
1254         """Return the list of "canonical" names of the options
1255
1256         Unlike .items(), this list also includes HOME
1257
1258         """
1259         return ["HOME"] + [_option.name for _option in self.items()]
1260
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?
1263
1264     # attribute emulation
1265
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)
1271
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]
1276
1277 class UserConfig(Config):
1278
1279     """Configuration for user extensions.
1280
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.
1284
1285     """
1286
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))
1298
1299 class CoreConfig(Config):
1300
1301     """Roundup instance configuration.
1302
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
1313
1314     """
1315
1316     # module name for old style configuration
1317     PYCONFIG = "config"
1318     # user configs
1319     ext = None
1320     detectors = None
1321
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()
1327
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
1335
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
1346
1347     def _get_name(self):
1348         return self["TRACKER_NAME"]
1349
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()
1357
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
1363
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"])
1380
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"))
1390
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)
1397
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]
1425
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)
1432
1433     def __setitem__(self, name, value):
1434         if name == "TRACKER_HOME":
1435             self.HOME = value
1436         else:
1437             self._get_option(name).set(value)
1438
1439     def __setattr__(self, name, value):
1440         if name == "TRACKER_HOME":
1441             self.__dict__["HOME"] = value
1442         else:
1443             Config.__setattr__(self, name, value)
1444
1445 # vim: set et sts=4 sw=4 :