/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: Robert Collins
  • Date: 2010-05-11 08:44:59 UTC
  • mfrom: (5221 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100511084459-pb0uinna9zs3wu59
Merge trunk - resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#            and others
3
4
#
4
5
# This program is free software; you can redistribute it and/or modify
5
6
# it under the terms of the GNU General Public License as published by
13
14
#
14
15
# You should have received a copy of the GNU General Public License
15
16
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
18
 
18
19
"""Configuration that affects the behaviour of Bazaar.
19
20
 
36
37
[/home/robertc/source]
37
38
recurse=False|True(default)
38
39
email= as above
39
 
check_signatures= as above 
 
40
check_signatures= as above
40
41
create_signatures= as above.
41
42
 
42
43
explanation of options
44
45
editor - this option sets the pop up editor to use during commits.
45
46
email - this option sets the user id bzr will use when committing.
46
47
check_signatures - this option controls whether bzr will require good gpg
47
 
                   signatures, ignore them, or check them if they are 
 
48
                   signatures, ignore them, or check them if they are
48
49
                   present.
49
 
create_signatures - this option controls whether bzr will always create 
 
50
create_signatures - this option controls whether bzr will always create
50
51
                    gpg signatures, never create them, or create them if the
51
52
                    branch is configured to require them.
52
53
log_format - this option sets the default log format.  Possible values are
61
62
up=pull
62
63
"""
63
64
 
 
65
import os
 
66
import sys
64
67
 
 
68
from bzrlib.lazy_import import lazy_import
 
69
lazy_import(globals(), """
65
70
import errno
66
71
from fnmatch import fnmatch
67
 
import os
68
72
import re
69
 
import sys
70
 
from StringIO import StringIO
 
73
from cStringIO import StringIO
71
74
 
72
75
import bzrlib
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
 
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
""")
77
90
 
78
91
 
79
92
CHECK_IF_POSSIBLE=0
86
99
SIGN_NEVER=2
87
100
 
88
101
 
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]
 
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)
102
144
 
103
145
 
104
146
class Config(object):
105
147
    """A configuration policy - what username, editor, gpg needs etc."""
106
148
 
 
149
    def __init__(self):
 
150
        super(Config, self).__init__()
 
151
 
107
152
    def get_editor(self):
108
153
        """Get the users pop up editor."""
109
154
        raise NotImplementedError
110
155
 
 
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
 
111
175
    def _get_signature_checking(self):
112
176
        """Template method to override signature checking policy."""
113
177
 
122
186
        """Get a generic option - no special process, no default."""
123
187
        return self._get_user_option(option_name)
124
188
 
 
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
 
125
218
    def gpg_signing_command(self):
126
219
        """What program should be used to sign signatures?"""
127
220
        result = self._gpg_signing_command()
144
237
        """See log_format()."""
145
238
        return None
146
239
 
147
 
    def __init__(self):
148
 
        super(Config, self).__init__()
149
 
 
150
240
    def post_commit(self):
151
241
        """An ordered list of python functions to call.
152
242
 
164
254
 
165
255
    def username(self):
166
256
        """Return email-style username.
167
 
    
 
257
 
168
258
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
169
 
        
170
 
        $BZR_EMAIL can be set to override this (as well as the
171
 
        deprecated $BZREMAIL), then
 
259
 
 
260
        $BZR_EMAIL can be set to override this, then
172
261
        the concrete policy type is checked, and finally
173
262
        $EMAIL is examined.
174
 
        If none is found, a reasonable default is (hopefully)
175
 
        created.
176
 
    
 
263
        If no username can be found, errors.NoWhoami exception is raised.
 
264
 
177
265
        TODO: Check it's reasonably well-formed.
178
266
        """
179
267
        v = os.environ.get('BZR_EMAIL')
180
268
        if v:
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
 
    
 
269
            return v.decode(osutils.get_user_encoding())
 
270
 
187
271
        v = self._get_user_id()
188
272
        if v:
189
273
            return v
190
 
        
 
274
 
191
275
        v = os.environ.get('EMAIL')
192
276
        if v:
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
 
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()
200
287
 
201
288
    def signature_checking(self):
202
289
        """What is the current policy for signature checking?."""
218
305
        if policy is None:
219
306
            policy = self._get_signature_checking()
220
307
            if policy is not None:
221
 
                warning("Please use create_signatures, not check_signatures "
222
 
                        "to set signing policy.")
 
308
                trace.warning("Please use create_signatures,"
 
309
                              " not check_signatures to set signing policy.")
223
310
            if policy == CHECK_ALWAYS:
224
311
                return True
225
312
        elif policy == SIGN_ALWAYS:
238
325
    def _get_nickname(self):
239
326
        return None
240
327
 
 
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
 
241
350
 
242
351
class IniBasedConfig(Config):
243
352
    """A configuration policy that draws from ini files."""
244
353
 
 
354
    def __init__(self, get_filename):
 
355
        super(IniBasedConfig, self).__init__()
 
356
        self._get_filename = get_filename
 
357
        self._parser = None
 
358
 
245
359
    def _get_parser(self, file=None):
246
360
        if self._parser is not None:
247
361
            return self._parser
255
369
            raise errors.ParseConfigError(e.errors, e.config.filename)
256
370
        return self._parser
257
371
 
 
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
 
258
384
    def _get_section(self):
259
385
        """Override this to define the section used by the config."""
260
386
        return "DEFAULT"
261
387
 
 
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
 
262
395
    def _get_signature_checking(self):
263
396
        """See Config._get_signature_checking."""
264
397
        policy = self._get_user_option('check_signatures')
277
410
 
278
411
    def _get_user_option(self, option_name):
279
412
        """See Config._get_user_option."""
280
 
        try:
281
 
            return self._get_parser().get_value(self._get_section(),
282
 
                                                option_name)
283
 
        except KeyError:
284
 
            pass
 
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
285
435
 
286
436
    def _gpg_signing_command(self):
287
437
        """See Config.gpg_signing_command."""
291
441
        """See Config.log_format."""
292
442
        return self._get_user_option('log_format')
293
443
 
294
 
    def __init__(self, get_filename):
295
 
        super(IniBasedConfig, self).__init__()
296
 
        self._get_filename = get_filename
297
 
        self._parser = None
298
 
        
299
444
    def _post_commit(self):
300
445
        """See Config.post_commit."""
301
446
        return self._get_user_option('post_commit')
324
469
 
325
470
    def _get_alias(self, value):
326
471
        try:
327
 
            return self._get_parser().get_value("ALIASES", 
 
472
            return self._get_parser().get_value("ALIASES",
328
473
                                                value)
329
474
        except KeyError:
330
475
            pass
344
489
 
345
490
    def set_user_option(self, option, value):
346
491
        """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):
347
514
        # FIXME: RBC 20051029 This should refresh the parser and also take a
348
515
        # file lock on bazaar.conf.
349
516
        conf_dir = os.path.dirname(self._get_filename())
350
517
        ensure_config_dir_exists(conf_dir)
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')
 
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)
355
525
        self._get_parser().write(f)
356
526
        f.close()
357
527
 
361
531
 
362
532
    def __init__(self, location):
363
533
        name_generator = locations_config_filename
364
 
        if (not os.path.exists(name_generator()) and 
 
534
        if (not os.path.exists(name_generator()) and
365
535
                os.path.exists(branches_config_filename())):
366
536
            if sys.platform == 'win32':
367
 
                warning('Please rename %s to %s' 
368
 
                         % (branches_config_filename(),
369
 
                            locations_config_filename()))
 
537
                trace.warning('Please rename %s to %s'
 
538
                              % (branches_config_filename(),
 
539
                                 locations_config_filename()))
370
540
            else:
371
 
                warning('Please rename ~/.bazaar/branches.conf'
372
 
                        ' to ~/.bazaar/locations.conf')
 
541
                trace.warning('Please rename ~/.bazaar/branches.conf'
 
542
                              ' to ~/.bazaar/locations.conf')
373
543
            name_generator = branches_config_filename
374
544
        super(LocationConfig, self).__init__(name_generator)
375
545
        # local file locations are looked up by local path, rather than
379
549
            location = urlutils.local_path_from_url(location)
380
550
        self.location = location
381
551
 
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
 
        """
 
552
    def _get_matching_sections(self):
 
553
        """Return an ordered list of section names matching this location."""
389
554
        sections = self._get_parser()
390
555
        location_names = self.location.split('/')
391
556
        if self.location.endswith('/'):
415
580
            # if section is longer, no match.
416
581
            if len(section_names) > len(location_names):
417
582
                continue
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
 
583
            matches.append((len(section_names), section,
 
584
                            '/'.join(location_names[len(section_names):])))
428
585
        matches.sort(reverse=True)
429
 
        return matches[0][1]
430
 
 
431
 
    def set_user_option(self, option, value):
 
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):
432
646
        """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))
433
652
        # FIXME: RBC 20051029 This should refresh the parser and also take a
434
653
        # file lock on locations.conf.
435
654
        conf_dir = os.path.dirname(self._get_filename())
443
662
        elif location + '/' in self._get_parser():
444
663
            location = location + '/'
445
664
        self._get_parser()[location][option]=value
 
665
        # the allowed values of store match the config policies
 
666
        self._set_option_policy(location, option, store)
446
667
        self._get_parser().write(file(self._get_filename(), 'wb'))
447
668
 
448
669
 
478
699
 
479
700
    def _get_safe_value(self, option_name):
480
701
        """This variant of get_best_value never returns untrusted values.
481
 
        
 
702
 
482
703
        It does not return values from the branch data, because the branch may
483
704
        not be controlled by the user.
484
705
 
493
714
 
494
715
    def _get_user_id(self):
495
716
        """Return the full user id for the branch.
496
 
    
497
 
        e.g. "John Hacker <jhacker@foo.org>"
 
717
 
 
718
        e.g. "John Hacker <jhacker@example.com>"
498
719
        This is looked up in the email controlfile for the branch.
499
720
        """
500
721
        try:
501
 
            return (self.branch.control_files.get_utf8("email") 
502
 
                    .read()
503
 
                    .decode(bzrlib.user_encoding)
 
722
            return (self.branch._transport.get_bytes("email")
 
723
                    .decode(osutils.get_user_encoding())
504
724
                    .rstrip("\r\n"))
505
725
        except errors.NoSuchFile, e:
506
726
            pass
507
 
        
 
727
 
508
728
        return self._get_best_value('_get_user_id')
509
729
 
 
730
    def _get_change_editor(self):
 
731
        return self._get_best_value('_get_change_editor')
 
732
 
510
733
    def _get_signature_checking(self):
511
734
        """See Config._get_signature_checking."""
512
735
        return self._get_best_value('_get_signature_checking')
523
746
                return value
524
747
        return None
525
748
 
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:
 
749
    def set_user_option(self, name, value, store=STORE_BRANCH,
 
750
        warn_masked=False):
 
751
        if store == STORE_BRANCH:
530
752
            self._get_branch_data_config().set_option(value, name)
531
 
 
 
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)
532
771
 
533
772
    def _gpg_signing_command(self):
534
773
        """See Config.gpg_signing_command."""
535
774
        return self._get_safe_value('_gpg_signing_command')
536
 
        
 
775
 
537
776
    def __init__(self, branch):
538
777
        super(BranchConfig, self).__init__()
539
778
        self._location_config = None
540
779
        self._branch_data_config = None
541
780
        self._global_config = None
542
781
        self.branch = branch
543
 
        self.option_sources = (self._get_location_config, 
 
782
        self.option_sources = (self._get_location_config,
544
783
                               self._get_branch_data_config,
545
784
                               self._get_global_config)
546
785
 
552
791
        value = self._get_explicit_nickname()
553
792
        if value is not None:
554
793
            return value
555
 
        return self.branch.base.split('/')[-2]
 
794
        return urlutils.unescape(self.branch.base.split('/')[-2])
556
795
 
557
796
    def has_explicit_nickname(self):
558
797
        """Return true if a nickname has been explicitly assigned."""
578
817
        if sys.platform == 'win32':
579
818
            parent_dir = os.path.dirname(path)
580
819
            if not os.path.isdir(parent_dir):
581
 
                mutter('creating config parent directory: %r', parent_dir)
 
820
                trace.mutter('creating config parent directory: %r', parent_dir)
582
821
            os.mkdir(parent_dir)
583
 
        mutter('creating config directory: %r', path)
 
822
        trace.mutter('creating config directory: %r', path)
584
823
        os.mkdir(path)
 
824
        osutils.copy_ownership_from_path(path)
585
825
 
586
826
 
587
827
def config_dir():
588
828
    """Return per-user configuration directory.
589
829
 
590
830
    By default this is ~/.bazaar/
591
 
    
 
831
 
592
832
    TODO: Global option --config-dir to override this.
593
833
    """
594
834
    base = os.environ.get('BZR_HOME', None)
595
835
    if sys.platform == 'win32':
596
836
        if base is None:
597
 
            base = os.environ.get('APPDATA', None)
 
837
            base = win32utils.get_appdata_location_unicode()
598
838
        if base is None:
599
839
            base = os.environ.get('HOME', None)
600
840
        if base is None:
601
 
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
602
 
        return pathjoin(base, 'bazaar', '2.0')
 
841
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
 
842
                                  ' or HOME set')
 
843
        return osutils.pathjoin(base, 'bazaar', '2.0')
603
844
    else:
604
845
        # cygwin, linux, and darwin all have a $HOME directory
605
846
        if base is None:
606
847
            base = os.path.expanduser("~")
607
 
        return pathjoin(base, ".bazaar")
 
848
        return osutils.pathjoin(base, ".bazaar")
608
849
 
609
850
 
610
851
def config_filename():
611
852
    """Return per-user configuration ini file filename."""
612
 
    return pathjoin(config_dir(), 'bazaar.conf')
 
853
    return osutils.pathjoin(config_dir(), 'bazaar.conf')
613
854
 
614
855
 
615
856
def branches_config_filename():
616
857
    """Return per-user configuration ini file filename."""
617
 
    return pathjoin(config_dir(), 'branches.conf')
 
858
    return osutils.pathjoin(config_dir(), 'branches.conf')
618
859
 
619
860
 
620
861
def locations_config_filename():
621
862
    """Return per-user configuration ini file filename."""
622
 
    return pathjoin(config_dir(), 'locations.conf')
 
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')
623
869
 
624
870
 
625
871
def user_ignore_config_filename():
626
872
    """Return the user default ignore filename"""
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.
 
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.
640
884
    """
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())
 
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))
687
910
 
688
911
 
689
912
def extract_email_address(e):
690
913
    """Return just the address part of an email string.
691
 
    
692
 
    That is just the user@domain part, nothing else. 
 
914
 
 
915
    That is just the user@domain part, nothing else.
693
916
    This part is required to contain only ascii characters.
694
917
    If it can't be extracted, raises an error.
695
 
    
 
918
 
696
919
    >>> extract_email_address('Jane Tester <jane@test.com>')
697
920
    "jane@test.com"
698
921
    """
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)
 
922
    name, email = parse_username(e)
 
923
    if not email:
 
924
        raise errors.NoEmailInUsername(e)
 
925
    return email
704
926
 
705
927
 
706
928
class TreeConfig(IniBasedConfig):
707
929
    """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
 
708
933
    def __init__(self, branch):
 
934
        self._config = branch._get_config()
709
935
        self.branch = branch
710
936
 
711
937
    def _get_parser(self, file=None):
712
938
        if file is not None:
713
939
            return IniBasedConfig._get_parser(file)
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
 
940
        return self._config._get_configobj()
723
941
 
724
942
    def get_option(self, name, section=None, default=None):
725
943
        self.branch.lock_read()
726
944
        try:
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
 
945
            return self._config.get_option(name, section, default)
734
946
        finally:
735
947
            self.branch.unlock()
736
 
        return result
737
948
 
738
949
    def set_option(self, value, name, section=None):
739
950
        """Set a per-branch configuration option"""
740
951
        self.branch.lock_write()
741
952
        try:
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)
 
953
            self._config.set_option(value, name, section)
756
954
        finally:
757
955
            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)