/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: John Arbash Meinel
  • Date: 2006-09-20 14:51:03 UTC
  • mfrom: (0.8.23 version_info)
  • mto: This revision was merged to the branch mainline in revision 2028.
  • Revision ID: john@arbash-meinel.com-20060920145103-02725c6d6c886040
[merge] version-info plugin, and cleanup for layout in bzr

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005 by Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
4
3
#
5
4
# This program is free software; you can redistribute it and/or modify
6
5
# it under the terms of the GNU General Public License as published by
14
13
#
15
14
# You should have received a copy of the GNU General Public License
16
15
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
17
 
19
18
"""Configuration that affects the behaviour of Bazaar.
20
19
 
37
36
[/home/robertc/source]
38
37
recurse=False|True(default)
39
38
email= as above
40
 
check_signatures= as above
 
39
check_signatures= as above 
41
40
create_signatures= as above.
42
41
 
43
42
explanation of options
45
44
editor - this option sets the pop up editor to use during commits.
46
45
email - this option sets the user id bzr will use when committing.
47
46
check_signatures - this option controls whether bzr will require good gpg
48
 
                   signatures, ignore them, or check them if they are
 
47
                   signatures, ignore them, or check them if they are 
49
48
                   present.
50
 
create_signatures - this option controls whether bzr will always create
 
49
create_signatures - this option controls whether bzr will always create 
51
50
                    gpg signatures, never create them, or create them if the
52
51
                    branch is configured to require them.
53
52
log_format - this option sets the default log format.  Possible values are
62
61
up=pull
63
62
"""
64
63
 
65
 
import os
66
 
import sys
67
64
 
68
 
from bzrlib.lazy_import import lazy_import
69
 
lazy_import(globals(), """
70
65
import errno
71
66
from fnmatch import fnmatch
 
67
import os
72
68
import re
73
 
from cStringIO import StringIO
 
69
import sys
 
70
from StringIO import StringIO
74
71
 
75
72
import bzrlib
76
 
from bzrlib import (
77
 
    debug,
78
 
    errors,
79
 
    mail_client,
80
 
    osutils,
81
 
    registry,
82
 
    symbol_versioning,
83
 
    trace,
84
 
    ui,
85
 
    urlutils,
86
 
    win32utils,
87
 
    )
88
 
from bzrlib.util.configobj import configobj
89
 
""")
 
73
from bzrlib import errors, urlutils
 
74
from bzrlib.osutils import pathjoin
 
75
from bzrlib.trace import mutter, warning
 
76
import bzrlib.util.configobj.configobj as configobj
90
77
 
91
78
 
92
79
CHECK_IF_POSSIBLE=0
99
86
SIGN_NEVER=2
100
87
 
101
88
 
102
 
POLICY_NONE = 0
103
 
POLICY_NORECURSE = 1
104
 
POLICY_APPENDPATH = 2
105
 
 
106
 
_policy_name = {
107
 
    POLICY_NONE: None,
108
 
    POLICY_NORECURSE: 'norecurse',
109
 
    POLICY_APPENDPATH: 'appendpath',
110
 
    }
111
 
_policy_value = {
112
 
    None: POLICY_NONE,
113
 
    'none': POLICY_NONE,
114
 
    'norecurse': POLICY_NORECURSE,
115
 
    'appendpath': POLICY_APPENDPATH,
116
 
    }
117
 
 
118
 
 
119
 
STORE_LOCATION = POLICY_NONE
120
 
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
121
 
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
122
 
STORE_BRANCH = 3
123
 
STORE_GLOBAL = 4
124
 
 
125
 
_ConfigObj = None
126
 
def ConfigObj(*args, **kwargs):
127
 
    global _ConfigObj
128
 
    if _ConfigObj is None:
129
 
        class ConfigObj(configobj.ConfigObj):
130
 
 
131
 
            def get_bool(self, section, key):
132
 
                return self[section].as_bool(key)
133
 
 
134
 
            def get_value(self, section, name):
135
 
                # Try [] for the old DEFAULT section.
136
 
                if section == "DEFAULT":
137
 
                    try:
138
 
                        return self[name]
139
 
                    except KeyError:
140
 
                        pass
141
 
                return self[section][name]
142
 
        _ConfigObj = ConfigObj
143
 
    return _ConfigObj(*args, **kwargs)
 
89
class ConfigObj(configobj.ConfigObj):
 
90
 
 
91
    def get_bool(self, section, key):
 
92
        return self[section].as_bool(key)
 
93
 
 
94
    def get_value(self, section, name):
 
95
        # Try [] for the old DEFAULT section.
 
96
        if section == "DEFAULT":
 
97
            try:
 
98
                return self[name]
 
99
            except KeyError:
 
100
                pass
 
101
        return self[section][name]
144
102
 
145
103
 
146
104
class Config(object):
147
105
    """A configuration policy - what username, editor, gpg needs etc."""
148
106
 
149
 
    def __init__(self):
150
 
        super(Config, self).__init__()
151
 
 
152
107
    def get_editor(self):
153
108
        """Get the users pop up editor."""
154
109
        raise NotImplementedError
155
110
 
156
 
    def get_change_editor(self, old_tree, new_tree):
157
 
        from bzrlib import diff
158
 
        cmd = self._get_change_editor()
159
 
        if cmd is None:
160
 
            return None
161
 
        return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
162
 
                                             sys.stdout)
163
 
 
164
 
 
165
 
    def get_mail_client(self):
166
 
        """Get a mail client to use"""
167
 
        selected_client = self.get_user_option('mail_client')
168
 
        _registry = mail_client.mail_client_registry
169
 
        try:
170
 
            mail_client_class = _registry.get(selected_client)
171
 
        except KeyError:
172
 
            raise errors.UnknownMailClient(selected_client)
173
 
        return mail_client_class(self)
174
 
 
175
111
    def _get_signature_checking(self):
176
112
        """Template method to override signature checking policy."""
177
113
 
186
122
        """Get a generic option - no special process, no default."""
187
123
        return self._get_user_option(option_name)
188
124
 
189
 
    def get_user_option_as_bool(self, option_name):
190
 
        """Get a generic option as a boolean - no special process, no default.
191
 
 
192
 
        :return None if the option doesn't exist or its value can't be
193
 
            interpreted as a boolean. Returns True or False otherwise.
194
 
        """
195
 
        s = self._get_user_option(option_name)
196
 
        if s is None:
197
 
            # The option doesn't exist
198
 
            return None
199
 
        val = ui.bool_from_string(s)
200
 
        if val is None:
201
 
            # The value can't be interpreted as a boolean
202
 
            trace.warning('Value "%s" is not a boolean for "%s"',
203
 
                          s, option_name)
204
 
        return val
205
 
 
206
 
    def get_user_option_as_list(self, option_name):
207
 
        """Get a generic option as a list - no special process, no default.
208
 
 
209
 
        :return None if the option doesn't exist. Returns the value as a list
210
 
            otherwise.
211
 
        """
212
 
        l = self._get_user_option(option_name)
213
 
        if isinstance(l, (str, unicode)):
214
 
            # A single value, most probably the user forgot the final ','
215
 
            l = [l]
216
 
        return l
217
 
 
218
125
    def gpg_signing_command(self):
219
126
        """What program should be used to sign signatures?"""
220
127
        result = self._gpg_signing_command()
237
144
        """See log_format()."""
238
145
        return None
239
146
 
 
147
    def __init__(self):
 
148
        super(Config, self).__init__()
 
149
 
240
150
    def post_commit(self):
241
151
        """An ordered list of python functions to call.
242
152
 
254
164
 
255
165
    def username(self):
256
166
        """Return email-style username.
257
 
 
 
167
    
258
168
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
259
 
 
260
 
        $BZR_EMAIL can be set to override this, then
 
169
        
 
170
        $BZR_EMAIL can be set to override this (as well as the
 
171
        deprecated $BZREMAIL), then
261
172
        the concrete policy type is checked, and finally
262
173
        $EMAIL is examined.
263
 
        If no username can be found, errors.NoWhoami exception is raised.
264
 
 
 
174
        If none is found, a reasonable default is (hopefully)
 
175
        created.
 
176
    
265
177
        TODO: Check it's reasonably well-formed.
266
178
        """
267
179
        v = os.environ.get('BZR_EMAIL')
268
180
        if v:
269
 
            return v.decode(osutils.get_user_encoding())
270
 
 
 
181
            return v.decode(bzrlib.user_encoding)
 
182
        v = os.environ.get('BZREMAIL')
 
183
        if v:
 
184
            warning('BZREMAIL is deprecated in favor of BZR_EMAIL. Please update your configuration.')
 
185
            return v.decode(bzrlib.user_encoding)
 
186
    
271
187
        v = self._get_user_id()
272
188
        if v:
273
189
            return v
274
 
 
 
190
        
275
191
        v = os.environ.get('EMAIL')
276
192
        if v:
277
 
            return v.decode(osutils.get_user_encoding())
278
 
 
279
 
        raise errors.NoWhoami()
280
 
 
281
 
    def ensure_username(self):
282
 
        """Raise errors.NoWhoami if username is not set.
283
 
 
284
 
        This method relies on the username() function raising the error.
285
 
        """
286
 
        self.username()
 
193
            return v.decode(bzrlib.user_encoding)
 
194
 
 
195
        name, email = _auto_user_id()
 
196
        if name:
 
197
            return '%s <%s>' % (name, email)
 
198
        else:
 
199
            return email
287
200
 
288
201
    def signature_checking(self):
289
202
        """What is the current policy for signature checking?."""
305
218
        if policy is None:
306
219
            policy = self._get_signature_checking()
307
220
            if policy is not None:
308
 
                trace.warning("Please use create_signatures,"
309
 
                              " not check_signatures to set signing policy.")
 
221
                warning("Please use create_signatures, not check_signatures "
 
222
                        "to set signing policy.")
310
223
            if policy == CHECK_ALWAYS:
311
224
                return True
312
225
        elif policy == SIGN_ALWAYS:
325
238
    def _get_nickname(self):
326
239
        return None
327
240
 
328
 
    def get_bzr_remote_path(self):
329
 
        try:
330
 
            return os.environ['BZR_REMOTE_PATH']
331
 
        except KeyError:
332
 
            path = self.get_user_option("bzr_remote_path")
333
 
            if path is None:
334
 
                path = 'bzr'
335
 
            return path
336
 
 
337
 
    def suppress_warning(self, warning):
338
 
        """Should the warning be suppressed or emitted.
339
 
 
340
 
        :param warning: The name of the warning being tested.
341
 
 
342
 
        :returns: True if the warning should be suppressed, False otherwise.
343
 
        """
344
 
        warnings = self.get_user_option_as_list('suppress_warnings')
345
 
        if warnings is None or warning not in warnings:
346
 
            return False
347
 
        else:
348
 
            return True
349
 
 
350
241
 
351
242
class IniBasedConfig(Config):
352
243
    """A configuration policy that draws from ini files."""
353
244
 
354
 
    def __init__(self, get_filename):
355
 
        super(IniBasedConfig, self).__init__()
356
 
        self._get_filename = get_filename
357
 
        self._parser = None
358
 
 
359
245
    def _get_parser(self, file=None):
360
246
        if self._parser is not None:
361
247
            return self._parser
369
255
            raise errors.ParseConfigError(e.errors, e.config.filename)
370
256
        return self._parser
371
257
 
372
 
    def _get_matching_sections(self):
373
 
        """Return an ordered list of (section_name, extra_path) pairs.
374
 
 
375
 
        If the section contains inherited configuration, extra_path is
376
 
        a string containing the additional path components.
377
 
        """
378
 
        section = self._get_section()
379
 
        if section is not None:
380
 
            return [(section, '')]
381
 
        else:
382
 
            return []
383
 
 
384
258
    def _get_section(self):
385
259
        """Override this to define the section used by the config."""
386
260
        return "DEFAULT"
387
261
 
388
 
    def _get_option_policy(self, section, option_name):
389
 
        """Return the policy for the given (section, option_name) pair."""
390
 
        return POLICY_NONE
391
 
 
392
 
    def _get_change_editor(self):
393
 
        return self.get_user_option('change_editor')
394
 
 
395
262
    def _get_signature_checking(self):
396
263
        """See Config._get_signature_checking."""
397
264
        policy = self._get_user_option('check_signatures')
410
277
 
411
278
    def _get_user_option(self, option_name):
412
279
        """See Config._get_user_option."""
413
 
        for (section, extra_path) in self._get_matching_sections():
414
 
            try:
415
 
                value = self._get_parser().get_value(section, option_name)
416
 
            except KeyError:
417
 
                continue
418
 
            policy = self._get_option_policy(section, option_name)
419
 
            if policy == POLICY_NONE:
420
 
                return value
421
 
            elif policy == POLICY_NORECURSE:
422
 
                # norecurse items only apply to the exact path
423
 
                if extra_path:
424
 
                    continue
425
 
                else:
426
 
                    return value
427
 
            elif policy == POLICY_APPENDPATH:
428
 
                if extra_path:
429
 
                    value = urlutils.join(value, extra_path)
430
 
                return value
431
 
            else:
432
 
                raise AssertionError('Unexpected config policy %r' % policy)
433
 
        else:
434
 
            return None
 
280
        try:
 
281
            return self._get_parser().get_value(self._get_section(),
 
282
                                                option_name)
 
283
        except KeyError:
 
284
            pass
435
285
 
436
286
    def _gpg_signing_command(self):
437
287
        """See Config.gpg_signing_command."""
441
291
        """See Config.log_format."""
442
292
        return self._get_user_option('log_format')
443
293
 
 
294
    def __init__(self, get_filename):
 
295
        super(IniBasedConfig, self).__init__()
 
296
        self._get_filename = get_filename
 
297
        self._parser = None
 
298
        
444
299
    def _post_commit(self):
445
300
        """See Config.post_commit."""
446
301
        return self._get_user_option('post_commit')
469
324
 
470
325
    def _get_alias(self, value):
471
326
        try:
472
 
            return self._get_parser().get_value("ALIASES",
 
327
            return self._get_parser().get_value("ALIASES", 
473
328
                                                value)
474
329
        except KeyError:
475
330
            pass
489
344
 
490
345
    def set_user_option(self, option, value):
491
346
        """Save option and its value in the configuration."""
492
 
        self._set_option(option, value, 'DEFAULT')
493
 
 
494
 
    def get_aliases(self):
495
 
        """Return the aliases section."""
496
 
        if 'ALIASES' in self._get_parser():
497
 
            return self._get_parser()['ALIASES']
498
 
        else:
499
 
            return {}
500
 
 
501
 
    def set_alias(self, alias_name, alias_command):
502
 
        """Save the alias in the configuration."""
503
 
        self._set_option(alias_name, alias_command, 'ALIASES')
504
 
 
505
 
    def unset_alias(self, alias_name):
506
 
        """Unset an existing alias."""
507
 
        aliases = self._get_parser().get('ALIASES')
508
 
        if not aliases or alias_name not in aliases:
509
 
            raise errors.NoSuchAlias(alias_name)
510
 
        del aliases[alias_name]
511
 
        self._write_config_file()
512
 
 
513
 
    def _set_option(self, option, value, section):
514
347
        # FIXME: RBC 20051029 This should refresh the parser and also take a
515
348
        # file lock on bazaar.conf.
516
349
        conf_dir = os.path.dirname(self._get_filename())
517
350
        ensure_config_dir_exists(conf_dir)
518
 
        self._get_parser().setdefault(section, {})[option] = value
519
 
        self._write_config_file()
520
 
 
521
 
    def _write_config_file(self):
522
 
        path = self._get_filename()
523
 
        f = open(path, 'wb')
524
 
        osutils.copy_ownership_from_path(path)
 
351
        if 'DEFAULT' not in self._get_parser():
 
352
            self._get_parser()['DEFAULT'] = {}
 
353
        self._get_parser()['DEFAULT'][option] = value
 
354
        f = open(self._get_filename(), 'wb')
525
355
        self._get_parser().write(f)
526
356
        f.close()
527
357
 
531
361
 
532
362
    def __init__(self, location):
533
363
        name_generator = locations_config_filename
534
 
        if (not os.path.exists(name_generator()) and
 
364
        if (not os.path.exists(name_generator()) and 
535
365
                os.path.exists(branches_config_filename())):
536
366
            if sys.platform == 'win32':
537
 
                trace.warning('Please rename %s to %s'
538
 
                              % (branches_config_filename(),
539
 
                                 locations_config_filename()))
 
367
                warning('Please rename %s to %s' 
 
368
                         % (branches_config_filename(),
 
369
                            locations_config_filename()))
540
370
            else:
541
 
                trace.warning('Please rename ~/.bazaar/branches.conf'
542
 
                              ' to ~/.bazaar/locations.conf')
 
371
                warning('Please rename ~/.bazaar/branches.conf'
 
372
                        ' to ~/.bazaar/locations.conf')
543
373
            name_generator = branches_config_filename
544
374
        super(LocationConfig, self).__init__(name_generator)
545
375
        # local file locations are looked up by local path, rather than
549
379
            location = urlutils.local_path_from_url(location)
550
380
        self.location = location
551
381
 
552
 
    def _get_matching_sections(self):
553
 
        """Return an ordered list of section names matching this location."""
 
382
    def _get_section(self):
 
383
        """Get the section we should look in for config items.
 
384
 
 
385
        Returns None if none exists. 
 
386
        TODO: perhaps return a NullSection that thunks through to the 
 
387
              global config.
 
388
        """
554
389
        sections = self._get_parser()
555
390
        location_names = self.location.split('/')
556
391
        if self.location.endswith('/'):
580
415
            # if section is longer, no match.
581
416
            if len(section_names) > len(location_names):
582
417
                continue
583
 
            matches.append((len(section_names), section,
584
 
                            '/'.join(location_names[len(section_names):])))
 
418
            # if path is longer, and recurse is not true, no match
 
419
            if len(section_names) < len(location_names):
 
420
                try:
 
421
                    if not self._get_parser()[section].as_bool('recurse'):
 
422
                        continue
 
423
                except KeyError:
 
424
                    pass
 
425
            matches.append((len(section_names), section))
 
426
        if not len(matches):
 
427
            return None
585
428
        matches.sort(reverse=True)
586
 
        sections = []
587
 
        for (length, section, extra_path) in matches:
588
 
            sections.append((section, extra_path))
589
 
            # should we stop looking for parent configs here?
590
 
            try:
591
 
                if self._get_parser()[section].as_bool('ignore_parents'):
592
 
                    break
593
 
            except KeyError:
594
 
                pass
595
 
        return sections
596
 
 
597
 
    def _get_option_policy(self, section, option_name):
598
 
        """Return the policy for the given (section, option_name) pair."""
599
 
        # check for the old 'recurse=False' flag
600
 
        try:
601
 
            recurse = self._get_parser()[section].as_bool('recurse')
602
 
        except KeyError:
603
 
            recurse = True
604
 
        if not recurse:
605
 
            return POLICY_NORECURSE
606
 
 
607
 
        policy_key = option_name + ':policy'
608
 
        try:
609
 
            policy_name = self._get_parser()[section][policy_key]
610
 
        except KeyError:
611
 
            policy_name = None
612
 
 
613
 
        return _policy_value[policy_name]
614
 
 
615
 
    def _set_option_policy(self, section, option_name, option_policy):
616
 
        """Set the policy for the given option name in the given section."""
617
 
        # The old recurse=False option affects all options in the
618
 
        # section.  To handle multiple policies in the section, we
619
 
        # need to convert it to a policy_norecurse key.
620
 
        try:
621
 
            recurse = self._get_parser()[section].as_bool('recurse')
622
 
        except KeyError:
623
 
            pass
624
 
        else:
625
 
            symbol_versioning.warn(
626
 
                'The recurse option is deprecated as of 0.14.  '
627
 
                'The section "%s" has been converted to use policies.'
628
 
                % section,
629
 
                DeprecationWarning)
630
 
            del self._get_parser()[section]['recurse']
631
 
            if not recurse:
632
 
                for key in self._get_parser()[section].keys():
633
 
                    if not key.endswith(':policy'):
634
 
                        self._get_parser()[section][key +
635
 
                                                    ':policy'] = 'norecurse'
636
 
 
637
 
        policy_key = option_name + ':policy'
638
 
        policy_name = _policy_name[option_policy]
639
 
        if policy_name is not None:
640
 
            self._get_parser()[section][policy_key] = policy_name
641
 
        else:
642
 
            if policy_key in self._get_parser()[section]:
643
 
                del self._get_parser()[section][policy_key]
644
 
 
645
 
    def set_user_option(self, option, value, store=STORE_LOCATION):
 
429
        return matches[0][1]
 
430
 
 
431
    def set_user_option(self, option, value):
646
432
        """Save option and its value in the configuration."""
647
 
        if store not in [STORE_LOCATION,
648
 
                         STORE_LOCATION_NORECURSE,
649
 
                         STORE_LOCATION_APPENDPATH]:
650
 
            raise ValueError('bad storage policy %r for %r' %
651
 
                (store, option))
652
433
        # FIXME: RBC 20051029 This should refresh the parser and also take a
653
434
        # file lock on locations.conf.
654
435
        conf_dir = os.path.dirname(self._get_filename())
662
443
        elif location + '/' in self._get_parser():
663
444
            location = location + '/'
664
445
        self._get_parser()[location][option]=value
665
 
        # the allowed values of store match the config policies
666
 
        self._set_option_policy(location, option, store)
667
446
        self._get_parser().write(file(self._get_filename(), 'wb'))
668
447
 
669
448
 
699
478
 
700
479
    def _get_safe_value(self, option_name):
701
480
        """This variant of get_best_value never returns untrusted values.
702
 
 
 
481
        
703
482
        It does not return values from the branch data, because the branch may
704
483
        not be controlled by the user.
705
484
 
714
493
 
715
494
    def _get_user_id(self):
716
495
        """Return the full user id for the branch.
717
 
 
718
 
        e.g. "John Hacker <jhacker@example.com>"
 
496
    
 
497
        e.g. "John Hacker <jhacker@foo.org>"
719
498
        This is looked up in the email controlfile for the branch.
720
499
        """
721
500
        try:
722
 
            return (self.branch._transport.get_bytes("email")
723
 
                    .decode(osutils.get_user_encoding())
 
501
            return (self.branch.control_files.get_utf8("email") 
 
502
                    .read()
 
503
                    .decode(bzrlib.user_encoding)
724
504
                    .rstrip("\r\n"))
725
505
        except errors.NoSuchFile, e:
726
506
            pass
727
 
 
 
507
        
728
508
        return self._get_best_value('_get_user_id')
729
509
 
730
 
    def _get_change_editor(self):
731
 
        return self._get_best_value('_get_change_editor')
732
 
 
733
510
    def _get_signature_checking(self):
734
511
        """See Config._get_signature_checking."""
735
512
        return self._get_best_value('_get_signature_checking')
746
523
                return value
747
524
        return None
748
525
 
749
 
    def set_user_option(self, name, value, store=STORE_BRANCH,
750
 
        warn_masked=False):
751
 
        if store == STORE_BRANCH:
 
526
    def set_user_option(self, name, value, local=False):
 
527
        if local is True:
 
528
            self._get_location_config().set_user_option(name, value)
 
529
        else:
752
530
            self._get_branch_data_config().set_option(value, name)
753
 
        elif store == STORE_GLOBAL:
754
 
            self._get_global_config().set_user_option(name, value)
755
 
        else:
756
 
            self._get_location_config().set_user_option(name, value, store)
757
 
        if not warn_masked:
758
 
            return
759
 
        if store in (STORE_GLOBAL, STORE_BRANCH):
760
 
            mask_value = self._get_location_config().get_user_option(name)
761
 
            if mask_value is not None:
762
 
                trace.warning('Value "%s" is masked by "%s" from'
763
 
                              ' locations.conf', value, mask_value)
764
 
            else:
765
 
                if store == STORE_GLOBAL:
766
 
                    branch_config = self._get_branch_data_config()
767
 
                    mask_value = branch_config.get_user_option(name)
768
 
                    if mask_value is not None:
769
 
                        trace.warning('Value "%s" is masked by "%s" from'
770
 
                                      ' branch.conf', value, mask_value)
 
531
 
771
532
 
772
533
    def _gpg_signing_command(self):
773
534
        """See Config.gpg_signing_command."""
774
535
        return self._get_safe_value('_gpg_signing_command')
775
 
 
 
536
        
776
537
    def __init__(self, branch):
777
538
        super(BranchConfig, self).__init__()
778
539
        self._location_config = None
779
540
        self._branch_data_config = None
780
541
        self._global_config = None
781
542
        self.branch = branch
782
 
        self.option_sources = (self._get_location_config,
 
543
        self.option_sources = (self._get_location_config, 
783
544
                               self._get_branch_data_config,
784
545
                               self._get_global_config)
785
546
 
791
552
        value = self._get_explicit_nickname()
792
553
        if value is not None:
793
554
            return value
794
 
        return urlutils.unescape(self.branch.base.split('/')[-2])
 
555
        return self.branch.base.split('/')[-2]
795
556
 
796
557
    def has_explicit_nickname(self):
797
558
        """Return true if a nickname has been explicitly assigned."""
817
578
        if sys.platform == 'win32':
818
579
            parent_dir = os.path.dirname(path)
819
580
            if not os.path.isdir(parent_dir):
820
 
                trace.mutter('creating config parent directory: %r', parent_dir)
 
581
                mutter('creating config parent directory: %r', parent_dir)
821
582
            os.mkdir(parent_dir)
822
 
        trace.mutter('creating config directory: %r', path)
 
583
        mutter('creating config directory: %r', path)
823
584
        os.mkdir(path)
824
 
        osutils.copy_ownership_from_path(path)
825
585
 
826
586
 
827
587
def config_dir():
828
588
    """Return per-user configuration directory.
829
589
 
830
590
    By default this is ~/.bazaar/
831
 
 
 
591
    
832
592
    TODO: Global option --config-dir to override this.
833
593
    """
834
594
    base = os.environ.get('BZR_HOME', None)
835
595
    if sys.platform == 'win32':
836
596
        if base is None:
837
 
            base = win32utils.get_appdata_location_unicode()
 
597
            base = os.environ.get('APPDATA', None)
838
598
        if base is None:
839
599
            base = os.environ.get('HOME', None)
840
600
        if base is None:
841
 
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
842
 
                                  ' or HOME set')
843
 
        return osutils.pathjoin(base, 'bazaar', '2.0')
 
601
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
 
602
        return pathjoin(base, 'bazaar', '2.0')
844
603
    else:
845
604
        # cygwin, linux, and darwin all have a $HOME directory
846
605
        if base is None:
847
606
            base = os.path.expanduser("~")
848
 
        return osutils.pathjoin(base, ".bazaar")
 
607
        return pathjoin(base, ".bazaar")
849
608
 
850
609
 
851
610
def config_filename():
852
611
    """Return per-user configuration ini file filename."""
853
 
    return osutils.pathjoin(config_dir(), 'bazaar.conf')
 
612
    return pathjoin(config_dir(), 'bazaar.conf')
854
613
 
855
614
 
856
615
def branches_config_filename():
857
616
    """Return per-user configuration ini file filename."""
858
 
    return osutils.pathjoin(config_dir(), 'branches.conf')
 
617
    return pathjoin(config_dir(), 'branches.conf')
859
618
 
860
619
 
861
620
def locations_config_filename():
862
621
    """Return per-user configuration ini file filename."""
863
 
    return osutils.pathjoin(config_dir(), 'locations.conf')
864
 
 
865
 
 
866
 
def authentication_config_filename():
867
 
    """Return per-user authentication ini file filename."""
868
 
    return osutils.pathjoin(config_dir(), 'authentication.conf')
 
622
    return pathjoin(config_dir(), 'locations.conf')
869
623
 
870
624
 
871
625
def user_ignore_config_filename():
872
626
    """Return the user default ignore filename"""
873
 
    return osutils.pathjoin(config_dir(), 'ignore')
874
 
 
875
 
 
876
 
def crash_dir():
877
 
    """Return the directory name to store crash files.
878
 
 
879
 
    This doesn't implicitly create it.
880
 
 
881
 
    On Windows it's in the config directory; elsewhere it's /var/crash
882
 
    which may be monitored by apport.  It can be overridden by
883
 
    $APPORT_CRASH_DIR.
 
627
    return pathjoin(config_dir(), 'ignore')
 
628
 
 
629
 
 
630
def _auto_user_id():
 
631
    """Calculate automatic user identification.
 
632
 
 
633
    Returns (realname, email).
 
634
 
 
635
    Only used when none is set in the environment or the id file.
 
636
 
 
637
    This previously used the FQDN as the default domain, but that can
 
638
    be very slow on machines where DNS is broken.  So now we simply
 
639
    use the hostname.
884
640
    """
885
 
    if sys.platform == 'win32':
886
 
        return osutils.pathjoin(config_dir(), 'Crash')
887
 
    else:
888
 
        # XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
889
 
        # 2010-01-31
890
 
        return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
891
 
 
892
 
 
893
 
def xdg_cache_dir():
894
 
    # See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
895
 
    # Possibly this should be different on Windows?
896
 
    e = os.environ.get('XDG_CACHE_DIR', None)
897
 
    if e:
898
 
        return e
899
 
    else:
900
 
        return os.path.expanduser('~/.cache')
901
 
 
902
 
 
903
 
def parse_username(username):
904
 
    """Parse e-mail username and return a (name, address) tuple."""
905
 
    match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
906
 
    if match is None:
907
 
        return (username, '')
908
 
    else:
909
 
        return (match.group(1), match.group(2))
 
641
    import socket
 
642
 
 
643
    # XXX: Any good way to get real user name on win32?
 
644
 
 
645
    try:
 
646
        import pwd
 
647
        uid = os.getuid()
 
648
        w = pwd.getpwuid(uid)
 
649
 
 
650
        # we try utf-8 first, because on many variants (like Linux),
 
651
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
 
652
        # false positives.  (many users will have their user encoding set to
 
653
        # latin-1, which cannot raise UnicodeError.)
 
654
        try:
 
655
            gecos = w.pw_gecos.decode('utf-8')
 
656
            encoding = 'utf-8'
 
657
        except UnicodeError:
 
658
            try:
 
659
                gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
660
                encoding = bzrlib.user_encoding
 
661
            except UnicodeError:
 
662
                raise errors.BzrCommandError('Unable to determine your name.  '
 
663
                   'Use "bzr whoami" to set it.')
 
664
        try:
 
665
            username = w.pw_name.decode(encoding)
 
666
        except UnicodeError:
 
667
            raise errors.BzrCommandError('Unable to determine your name.  '
 
668
                'Use "bzr whoami" to set it.')
 
669
 
 
670
        comma = gecos.find(',')
 
671
        if comma == -1:
 
672
            realname = gecos
 
673
        else:
 
674
            realname = gecos[:comma]
 
675
        if not realname:
 
676
            realname = username
 
677
 
 
678
    except ImportError:
 
679
        import getpass
 
680
        try:
 
681
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
682
        except UnicodeDecodeError:
 
683
            raise errors.BzrError("Can't decode username as %s." % \
 
684
                    bzrlib.user_encoding)
 
685
 
 
686
    return realname, (username + '@' + socket.gethostname())
910
687
 
911
688
 
912
689
def extract_email_address(e):
913
690
    """Return just the address part of an email string.
914
 
 
915
 
    That is just the user@domain part, nothing else.
 
691
    
 
692
    That is just the user@domain part, nothing else. 
916
693
    This part is required to contain only ascii characters.
917
694
    If it can't be extracted, raises an error.
918
 
 
 
695
    
919
696
    >>> extract_email_address('Jane Tester <jane@test.com>')
920
697
    "jane@test.com"
921
698
    """
922
 
    name, email = parse_username(e)
923
 
    if not email:
924
 
        raise errors.NoEmailInUsername(e)
925
 
    return email
 
699
    m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
700
    if not m:
 
701
        raise errors.BzrError("%r doesn't seem to contain "
 
702
                              "a reasonable email address" % e)
 
703
    return m.group(0)
926
704
 
927
705
 
928
706
class TreeConfig(IniBasedConfig):
929
707
    """Branch configuration data associated with its contents, not location"""
930
 
 
931
 
    # XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
932
 
 
933
708
    def __init__(self, branch):
934
 
        self._config = branch._get_config()
935
709
        self.branch = branch
936
710
 
937
711
    def _get_parser(self, file=None):
938
712
        if file is not None:
939
713
            return IniBasedConfig._get_parser(file)
940
 
        return self._config._get_configobj()
 
714
        return self._get_config()
 
715
 
 
716
    def _get_config(self):
 
717
        try:
 
718
            obj = ConfigObj(self.branch.control_files.get('branch.conf'), 
 
719
                            encoding='utf-8')
 
720
        except errors.NoSuchFile:
 
721
            obj = ConfigObj(encoding='utf=8')
 
722
        return obj
941
723
 
942
724
    def get_option(self, name, section=None, default=None):
943
725
        self.branch.lock_read()
944
726
        try:
945
 
            return self._config.get_option(name, section, default)
 
727
            obj = self._get_config()
 
728
            try:
 
729
                if section is not None:
 
730
                    obj[section]
 
731
                result = obj[name]
 
732
            except KeyError:
 
733
                result = default
946
734
        finally:
947
735
            self.branch.unlock()
 
736
        return result
948
737
 
949
738
    def set_option(self, value, name, section=None):
950
739
        """Set a per-branch configuration option"""
951
740
        self.branch.lock_write()
952
741
        try:
953
 
            self._config.set_option(value, name, section)
 
742
            cfg_obj = self._get_config()
 
743
            if section is None:
 
744
                obj = cfg_obj
 
745
            else:
 
746
                try:
 
747
                    obj = cfg_obj[section]
 
748
                except KeyError:
 
749
                    cfg_obj[section] = {}
 
750
                    obj = cfg_obj[section]
 
751
            obj[name] = value
 
752
            out_file = StringIO()
 
753
            cfg_obj.write(out_file)
 
754
            out_file.seek(0)
 
755
            self.branch.control_files.put('branch.conf', out_file)
954
756
        finally:
955
757
            self.branch.unlock()
956
 
 
957
 
 
958
 
class AuthenticationConfig(object):
959
 
    """The authentication configuration file based on a ini file.
960
 
 
961
 
    Implements the authentication.conf file described in
962
 
    doc/developers/authentication-ring.txt.
963
 
    """
964
 
 
965
 
    def __init__(self, _file=None):
966
 
        self._config = None # The ConfigObj
967
 
        if _file is None:
968
 
            self._filename = authentication_config_filename()
969
 
            self._input = self._filename = authentication_config_filename()
970
 
        else:
971
 
            # Tests can provide a string as _file
972
 
            self._filename = None
973
 
            self._input = _file
974
 
 
975
 
    def _get_config(self):
976
 
        if self._config is not None:
977
 
            return self._config
978
 
        try:
979
 
            # FIXME: Should we validate something here ? Includes: empty
980
 
            # sections are useless, at least one of
981
 
            # user/password/password_encoding should be defined, etc.
982
 
 
983
 
            # Note: the encoding below declares that the file itself is utf-8
984
 
            # encoded, but the values in the ConfigObj are always Unicode.
985
 
            self._config = ConfigObj(self._input, encoding='utf-8')
986
 
        except configobj.ConfigObjError, e:
987
 
            raise errors.ParseConfigError(e.errors, e.config.filename)
988
 
        return self._config
989
 
 
990
 
    def _save(self):
991
 
        """Save the config file, only tests should use it for now."""
992
 
        conf_dir = os.path.dirname(self._filename)
993
 
        ensure_config_dir_exists(conf_dir)
994
 
        self._get_config().write(file(self._filename, 'wb'))
995
 
 
996
 
    def _set_option(self, section_name, option_name, value):
997
 
        """Set an authentication configuration option"""
998
 
        conf = self._get_config()
999
 
        section = conf.get(section_name)
1000
 
        if section is None:
1001
 
            conf[section] = {}
1002
 
            section = conf[section]
1003
 
        section[option_name] = value
1004
 
        self._save()
1005
 
 
1006
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None, 
1007
 
                        realm=None):
1008
 
        """Returns the matching credentials from authentication.conf file.
1009
 
 
1010
 
        :param scheme: protocol
1011
 
 
1012
 
        :param host: the server address
1013
 
 
1014
 
        :param port: the associated port (optional)
1015
 
 
1016
 
        :param user: login (optional)
1017
 
 
1018
 
        :param path: the absolute path on the server (optional)
1019
 
        
1020
 
        :param realm: the http authentication realm (optional)
1021
 
 
1022
 
        :return: A dict containing the matching credentials or None.
1023
 
           This includes:
1024
 
           - name: the section name of the credentials in the
1025
 
             authentication.conf file,
1026
 
           - user: can't be different from the provided user if any,
1027
 
           - scheme: the server protocol,
1028
 
           - host: the server address,
1029
 
           - port: the server port (can be None),
1030
 
           - path: the absolute server path (can be None),
1031
 
           - realm: the http specific authentication realm (can be None),
1032
 
           - password: the decoded password, could be None if the credential
1033
 
             defines only the user
1034
 
           - verify_certificates: https specific, True if the server
1035
 
             certificate should be verified, False otherwise.
1036
 
        """
1037
 
        credentials = None
1038
 
        for auth_def_name, auth_def in self._get_config().items():
1039
 
            if type(auth_def) is not configobj.Section:
1040
 
                raise ValueError("%s defined outside a section" % auth_def_name)
1041
 
 
1042
 
            a_scheme, a_host, a_user, a_path = map(
1043
 
                auth_def.get, ['scheme', 'host', 'user', 'path'])
1044
 
 
1045
 
            try:
1046
 
                a_port = auth_def.as_int('port')
1047
 
            except KeyError:
1048
 
                a_port = None
1049
 
            except ValueError:
1050
 
                raise ValueError("'port' not numeric in %s" % auth_def_name)
1051
 
            try:
1052
 
                a_verify_certificates = auth_def.as_bool('verify_certificates')
1053
 
            except KeyError:
1054
 
                a_verify_certificates = True
1055
 
            except ValueError:
1056
 
                raise ValueError(
1057
 
                    "'verify_certificates' not boolean in %s" % auth_def_name)
1058
 
 
1059
 
            # Attempt matching
1060
 
            if a_scheme is not None and scheme != a_scheme:
1061
 
                continue
1062
 
            if a_host is not None:
1063
 
                if not (host == a_host
1064
 
                        or (a_host.startswith('.') and host.endswith(a_host))):
1065
 
                    continue
1066
 
            if a_port is not None and port != a_port:
1067
 
                continue
1068
 
            if (a_path is not None and path is not None
1069
 
                and not path.startswith(a_path)):
1070
 
                continue
1071
 
            if (a_user is not None and user is not None
1072
 
                and a_user != user):
1073
 
                # Never contradict the caller about the user to be used
1074
 
                continue
1075
 
            if a_user is None:
1076
 
                # Can't find a user
1077
 
                continue
1078
 
            # Prepare a credentials dictionary with additional keys
1079
 
            # for the credential providers
1080
 
            credentials = dict(name=auth_def_name,
1081
 
                               user=a_user,
1082
 
                               scheme=a_scheme,
1083
 
                               host=host,
1084
 
                               port=port,
1085
 
                               path=path,
1086
 
                               realm=realm,
1087
 
                               password=auth_def.get('password', None),
1088
 
                               verify_certificates=a_verify_certificates)
1089
 
            # Decode the password in the credentials (or get one)
1090
 
            self.decode_password(credentials,
1091
 
                                 auth_def.get('password_encoding', None))
1092
 
            if 'auth' in debug.debug_flags:
1093
 
                trace.mutter("Using authentication section: %r", auth_def_name)
1094
 
            break
1095
 
 
1096
 
        if credentials is None:
1097
 
            # No credentials were found in authentication.conf, try the fallback
1098
 
            # credentials stores.
1099
 
            credentials = credential_store_registry.get_fallback_credentials(
1100
 
                scheme, host, port, user, path, realm)
1101
 
 
1102
 
        return credentials
1103
 
 
1104
 
    def set_credentials(self, name, host, user, scheme=None, password=None,
1105
 
                        port=None, path=None, verify_certificates=None,
1106
 
                        realm=None):
1107
 
        """Set authentication credentials for a host.
1108
 
 
1109
 
        Any existing credentials with matching scheme, host, port and path
1110
 
        will be deleted, regardless of name.
1111
 
 
1112
 
        :param name: An arbitrary name to describe this set of credentials.
1113
 
        :param host: Name of the host that accepts these credentials.
1114
 
        :param user: The username portion of these credentials.
1115
 
        :param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1116
 
            to.
1117
 
        :param password: Password portion of these credentials.
1118
 
        :param port: The IP port on the host that these credentials apply to.
1119
 
        :param path: A filesystem path on the host that these credentials
1120
 
            apply to.
1121
 
        :param verify_certificates: On https, verify server certificates if
1122
 
            True.
1123
 
        :param realm: The http authentication realm (optional).
1124
 
        """
1125
 
        values = {'host': host, 'user': user}
1126
 
        if password is not None:
1127
 
            values['password'] = password
1128
 
        if scheme is not None:
1129
 
            values['scheme'] = scheme
1130
 
        if port is not None:
1131
 
            values['port'] = '%d' % port
1132
 
        if path is not None:
1133
 
            values['path'] = path
1134
 
        if verify_certificates is not None:
1135
 
            values['verify_certificates'] = str(verify_certificates)
1136
 
        if realm is not None:
1137
 
            values['realm'] = realm
1138
 
        config = self._get_config()
1139
 
        for_deletion = []
1140
 
        for section, existing_values in config.items():
1141
 
            for key in ('scheme', 'host', 'port', 'path', 'realm'):
1142
 
                if existing_values.get(key) != values.get(key):
1143
 
                    break
1144
 
            else:
1145
 
                del config[section]
1146
 
        config.update({name: values})
1147
 
        self._save()
1148
 
 
1149
 
    def get_user(self, scheme, host, port=None, realm=None, path=None,
1150
 
                 prompt=None, ask=False, default=None):
1151
 
        """Get a user from authentication file.
1152
 
 
1153
 
        :param scheme: protocol
1154
 
 
1155
 
        :param host: the server address
1156
 
 
1157
 
        :param port: the associated port (optional)
1158
 
 
1159
 
        :param realm: the realm sent by the server (optional)
1160
 
 
1161
 
        :param path: the absolute path on the server (optional)
1162
 
 
1163
 
        :param ask: Ask the user if there is no explicitly configured username 
1164
 
                    (optional)
1165
 
 
1166
 
        :param default: The username returned if none is defined (optional).
1167
 
 
1168
 
        :return: The found user.
1169
 
        """
1170
 
        credentials = self.get_credentials(scheme, host, port, user=None,
1171
 
                                           path=path, realm=realm)
1172
 
        if credentials is not None:
1173
 
            user = credentials['user']
1174
 
        else:
1175
 
            user = None
1176
 
        if user is None:
1177
 
            if ask:
1178
 
                if prompt is None:
1179
 
                    # Create a default prompt suitable for most cases
1180
 
                    prompt = scheme.upper() + ' %(host)s username'
1181
 
                # Special handling for optional fields in the prompt
1182
 
                if port is not None:
1183
 
                    prompt_host = '%s:%d' % (host, port)
1184
 
                else:
1185
 
                    prompt_host = host
1186
 
                user = ui.ui_factory.get_username(prompt, host=prompt_host)
1187
 
            else:
1188
 
                user = default
1189
 
        return user
1190
 
 
1191
 
    def get_password(self, scheme, host, user, port=None,
1192
 
                     realm=None, path=None, prompt=None):
1193
 
        """Get a password from authentication file or prompt the user for one.
1194
 
 
1195
 
        :param scheme: protocol
1196
 
 
1197
 
        :param host: the server address
1198
 
 
1199
 
        :param port: the associated port (optional)
1200
 
 
1201
 
        :param user: login
1202
 
 
1203
 
        :param realm: the realm sent by the server (optional)
1204
 
 
1205
 
        :param path: the absolute path on the server (optional)
1206
 
 
1207
 
        :return: The found password or the one entered by the user.
1208
 
        """
1209
 
        credentials = self.get_credentials(scheme, host, port, user, path,
1210
 
                                           realm)
1211
 
        if credentials is not None:
1212
 
            password = credentials['password']
1213
 
            if password is not None and scheme is 'ssh':
1214
 
                trace.warning('password ignored in section [%s],'
1215
 
                              ' use an ssh agent instead'
1216
 
                              % credentials['name'])
1217
 
                password = None
1218
 
        else:
1219
 
            password = None
1220
 
        # Prompt user only if we could't find a password
1221
 
        if password is None:
1222
 
            if prompt is None:
1223
 
                # Create a default prompt suitable for most cases
1224
 
                prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
1225
 
            # Special handling for optional fields in the prompt
1226
 
            if port is not None:
1227
 
                prompt_host = '%s:%d' % (host, port)
1228
 
            else:
1229
 
                prompt_host = host
1230
 
            password = ui.ui_factory.get_password(prompt,
1231
 
                                                  host=prompt_host, user=user)
1232
 
        return password
1233
 
 
1234
 
    def decode_password(self, credentials, encoding):
1235
 
        try:
1236
 
            cs = credential_store_registry.get_credential_store(encoding)
1237
 
        except KeyError:
1238
 
            raise ValueError('%r is not a known password_encoding' % encoding)
1239
 
        credentials['password'] = cs.decode_password(credentials)
1240
 
        return credentials
1241
 
 
1242
 
 
1243
 
class CredentialStoreRegistry(registry.Registry):
1244
 
    """A class that registers credential stores.
1245
 
 
1246
 
    A credential store provides access to credentials via the password_encoding
1247
 
    field in authentication.conf sections.
1248
 
 
1249
 
    Except for stores provided by bzr itself, most stores are expected to be
1250
 
    provided by plugins that will therefore use
1251
 
    register_lazy(password_encoding, module_name, member_name, help=help,
1252
 
    fallback=fallback) to install themselves.
1253
 
 
1254
 
    A fallback credential store is one that is queried if no credentials can be
1255
 
    found via authentication.conf.
1256
 
    """
1257
 
 
1258
 
    def get_credential_store(self, encoding=None):
1259
 
        cs = self.get(encoding)
1260
 
        if callable(cs):
1261
 
            cs = cs()
1262
 
        return cs
1263
 
 
1264
 
    def is_fallback(self, name):
1265
 
        """Check if the named credentials store should be used as fallback."""
1266
 
        return self.get_info(name)
1267
 
 
1268
 
    def get_fallback_credentials(self, scheme, host, port=None, user=None,
1269
 
                                 path=None, realm=None):
1270
 
        """Request credentials from all fallback credentials stores.
1271
 
 
1272
 
        The first credentials store that can provide credentials wins.
1273
 
        """
1274
 
        credentials = None
1275
 
        for name in self.keys():
1276
 
            if not self.is_fallback(name):
1277
 
                continue
1278
 
            cs = self.get_credential_store(name)
1279
 
            credentials = cs.get_credentials(scheme, host, port, user,
1280
 
                                             path, realm)
1281
 
            if credentials is not None:
1282
 
                # We found some credentials
1283
 
                break
1284
 
        return credentials
1285
 
 
1286
 
    def register(self, key, obj, help=None, override_existing=False,
1287
 
                 fallback=False):
1288
 
        """Register a new object to a name.
1289
 
 
1290
 
        :param key: This is the key to use to request the object later.
1291
 
        :param obj: The object to register.
1292
 
        :param help: Help text for this entry. This may be a string or
1293
 
                a callable. If it is a callable, it should take two
1294
 
                parameters (registry, key): this registry and the key that
1295
 
                the help was registered under.
1296
 
        :param override_existing: Raise KeyErorr if False and something has
1297
 
                already been registered for that key. If True, ignore if there
1298
 
                is an existing key (always register the new value).
1299
 
        :param fallback: Whether this credential store should be 
1300
 
                used as fallback.
1301
 
        """
1302
 
        return super(CredentialStoreRegistry,
1303
 
                     self).register(key, obj, help, info=fallback,
1304
 
                                    override_existing=override_existing)
1305
 
 
1306
 
    def register_lazy(self, key, module_name, member_name,
1307
 
                      help=None, override_existing=False,
1308
 
                      fallback=False):
1309
 
        """Register a new credential store to be loaded on request.
1310
 
 
1311
 
        :param module_name: The python path to the module. Such as 'os.path'.
1312
 
        :param member_name: The member of the module to return.  If empty or
1313
 
                None, get() will return the module itself.
1314
 
        :param help: Help text for this entry. This may be a string or
1315
 
                a callable.
1316
 
        :param override_existing: If True, replace the existing object
1317
 
                with the new one. If False, if there is already something
1318
 
                registered with the same key, raise a KeyError
1319
 
        :param fallback: Whether this credential store should be 
1320
 
                used as fallback.
1321
 
        """
1322
 
        return super(CredentialStoreRegistry, self).register_lazy(
1323
 
            key, module_name, member_name, help,
1324
 
            info=fallback, override_existing=override_existing)
1325
 
 
1326
 
 
1327
 
credential_store_registry = CredentialStoreRegistry()
1328
 
 
1329
 
 
1330
 
class CredentialStore(object):
1331
 
    """An abstract class to implement storage for credentials"""
1332
 
 
1333
 
    def decode_password(self, credentials):
1334
 
        """Returns a clear text password for the provided credentials."""
1335
 
        raise NotImplementedError(self.decode_password)
1336
 
 
1337
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None,
1338
 
                        realm=None):
1339
 
        """Return the matching credentials from this credential store.
1340
 
 
1341
 
        This method is only called on fallback credential stores.
1342
 
        """
1343
 
        raise NotImplementedError(self.get_credentials)
1344
 
 
1345
 
 
1346
 
 
1347
 
class PlainTextCredentialStore(CredentialStore):
1348
 
    __doc__ = """Plain text credential store for the authentication.conf file"""
1349
 
 
1350
 
    def decode_password(self, credentials):
1351
 
        """See CredentialStore.decode_password."""
1352
 
        return credentials['password']
1353
 
 
1354
 
 
1355
 
credential_store_registry.register('plain', PlainTextCredentialStore,
1356
 
                                   help=PlainTextCredentialStore.__doc__)
1357
 
credential_store_registry.default_key = 'plain'
1358
 
 
1359
 
 
1360
 
class BzrDirConfig(object):
1361
 
 
1362
 
    def __init__(self, bzrdir):
1363
 
        self._bzrdir = bzrdir
1364
 
        self._config = bzrdir._get_config()
1365
 
 
1366
 
    def set_default_stack_on(self, value):
1367
 
        """Set the default stacking location.
1368
 
 
1369
 
        It may be set to a location, or None.
1370
 
 
1371
 
        This policy affects all branches contained by this bzrdir, except for
1372
 
        those under repositories.
1373
 
        """
1374
 
        if self._config is None:
1375
 
            raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
1376
 
        if value is None:
1377
 
            self._config.set_option('', 'default_stack_on')
1378
 
        else:
1379
 
            self._config.set_option(value, 'default_stack_on')
1380
 
 
1381
 
    def get_default_stack_on(self):
1382
 
        """Return the default stacking location.
1383
 
 
1384
 
        This will either be a location, or None.
1385
 
 
1386
 
        This policy affects all branches contained by this bzrdir, except for
1387
 
        those under repositories.
1388
 
        """
1389
 
        if self._config is None:
1390
 
            return None
1391
 
        value = self._config.get_option('default_stack_on')
1392
 
        if value == '':
1393
 
            value = None
1394
 
        return value
1395
 
 
1396
 
 
1397
 
class TransportConfig(object):
1398
 
    """A Config that reads/writes a config file on a Transport.
1399
 
 
1400
 
    It is a low-level object that considers config data to be name/value pairs
1401
 
    that may be associated with a section.  Assigning meaning to the these
1402
 
    values is done at higher levels like TreeConfig.
1403
 
    """
1404
 
 
1405
 
    def __init__(self, transport, filename):
1406
 
        self._transport = transport
1407
 
        self._filename = filename
1408
 
 
1409
 
    def get_option(self, name, section=None, default=None):
1410
 
        """Return the value associated with a named option.
1411
 
 
1412
 
        :param name: The name of the value
1413
 
        :param section: The section the option is in (if any)
1414
 
        :param default: The value to return if the value is not set
1415
 
        :return: The value or default value
1416
 
        """
1417
 
        configobj = self._get_configobj()
1418
 
        if section is None:
1419
 
            section_obj = configobj
1420
 
        else:
1421
 
            try:
1422
 
                section_obj = configobj[section]
1423
 
            except KeyError:
1424
 
                return default
1425
 
        return section_obj.get(name, default)
1426
 
 
1427
 
    def set_option(self, value, name, section=None):
1428
 
        """Set the value associated with a named option.
1429
 
 
1430
 
        :param value: The value to set
1431
 
        :param name: The name of the value to set
1432
 
        :param section: The section the option is in (if any)
1433
 
        """
1434
 
        configobj = self._get_configobj()
1435
 
        if section is None:
1436
 
            configobj[name] = value
1437
 
        else:
1438
 
            configobj.setdefault(section, {})[name] = value
1439
 
        self._set_configobj(configobj)
1440
 
 
1441
 
    def _get_config_file(self):
1442
 
        try:
1443
 
            return StringIO(self._transport.get_bytes(self._filename))
1444
 
        except errors.NoSuchFile:
1445
 
            return StringIO()
1446
 
 
1447
 
    def _get_configobj(self):
1448
 
        return ConfigObj(self._get_config_file(), encoding='utf-8')
1449
 
 
1450
 
    def _set_configobj(self, configobj):
1451
 
        out_file = StringIO()
1452
 
        configobj.write(out_file)
1453
 
        out_file.seek(0)
1454
 
        self._transport.put_file(self._filename, out_file)