← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Martin Pool
  • Date: 2010-06-02 05:03:31 UTC
  • mto: This revision was merged to the branch mainline in revision 5279.
  • Revision ID: mbp@canonical.com-20100602050331-n2p1qt8hfsahspnv
Correct more sloppy use of the term 'Linux'

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
 
log_format - This options set the default log format.  Options are long, 
53
 
             short, line, or a plugin can register new formats
 
53
log_format - this option sets the default log format.  Possible values are
 
54
             long, short, line, or a plugin can register new formats.
54
55
 
55
56
In bazaar.conf you can also define aliases in the ALIASES sections, example
56
57
 
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
 
import bzrlib.errors as errors
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
 
        $BZREMAIL can be set to override this, then
 
259
 
 
260
        $BZR_EMAIL can be set to override this, then
171
261
        the concrete policy type is checked, and finally
172
262
        $EMAIL is examined.
173
 
        If none is found, a reasonable default is (hopefully)
174
 
        created.
175
 
    
 
263
        If no username can be found, errors.NoWhoami exception is raised.
 
264
 
176
265
        TODO: Check it's reasonably well-formed.
177
266
        """
178
 
        v = os.environ.get('BZREMAIL')
 
267
        v = os.environ.get('BZR_EMAIL')
179
268
        if v:
180
 
            return v.decode(bzrlib.user_encoding)
181
 
    
 
269
            return v.decode(osutils.get_user_encoding())
 
270
 
182
271
        v = self._get_user_id()
183
272
        if v:
184
273
            return v
185
 
        
 
274
 
186
275
        v = os.environ.get('EMAIL')
187
276
        if v:
188
 
            return v.decode(bzrlib.user_encoding)
189
 
 
190
 
        name, email = _auto_user_id()
191
 
        if name:
192
 
            return '%s <%s>' % (name, email)
193
 
        else:
194
 
            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()
195
287
 
196
288
    def signature_checking(self):
197
289
        """What is the current policy for signature checking?."""
213
305
        if policy is None:
214
306
            policy = self._get_signature_checking()
215
307
            if policy is not None:
216
 
                warning("Please use create_signatures, not check_signatures "
217
 
                        "to set signing policy.")
 
308
                trace.warning("Please use create_signatures,"
 
309
                              " not check_signatures to set signing policy.")
218
310
            if policy == CHECK_ALWAYS:
219
311
                return True
220
312
        elif policy == SIGN_ALWAYS:
233
325
    def _get_nickname(self):
234
326
        return None
235
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
 
236
350
 
237
351
class IniBasedConfig(Config):
238
352
    """A configuration policy that draws from ini files."""
239
353
 
 
354
    def __init__(self, get_filename):
 
355
        super(IniBasedConfig, self).__init__()
 
356
        self._get_filename = get_filename
 
357
        self._parser = None
 
358
 
240
359
    def _get_parser(self, file=None):
241
360
        if self._parser is not None:
242
361
            return self._parser
250
369
            raise errors.ParseConfigError(e.errors, e.config.filename)
251
370
        return self._parser
252
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
 
253
384
    def _get_section(self):
254
385
        """Override this to define the section used by the config."""
255
386
        return "DEFAULT"
256
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
 
257
395
    def _get_signature_checking(self):
258
396
        """See Config._get_signature_checking."""
259
397
        policy = self._get_user_option('check_signatures')
272
410
 
273
411
    def _get_user_option(self, option_name):
274
412
        """See Config._get_user_option."""
275
 
        try:
276
 
            return self._get_parser().get_value(self._get_section(),
277
 
                                                option_name)
278
 
        except KeyError:
279
 
            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
280
435
 
281
436
    def _gpg_signing_command(self):
282
437
        """See Config.gpg_signing_command."""
286
441
        """See Config.log_format."""
287
442
        return self._get_user_option('log_format')
288
443
 
289
 
    def __init__(self, get_filename):
290
 
        super(IniBasedConfig, self).__init__()
291
 
        self._get_filename = get_filename
292
 
        self._parser = None
293
 
        
294
444
    def _post_commit(self):
295
445
        """See Config.post_commit."""
296
446
        return self._get_user_option('post_commit')
319
469
 
320
470
    def _get_alias(self, value):
321
471
        try:
322
 
            return self._get_parser().get_value("ALIASES", 
 
472
            return self._get_parser().get_value("ALIASES",
323
473
                                                value)
324
474
        except KeyError:
325
475
            pass
327
477
    def _get_nickname(self):
328
478
        return self.get_user_option('nickname')
329
479
 
 
480
    def _write_config_file(self):
 
481
        f = file(self._get_filename(), "wb")
 
482
        try:
 
483
            osutils.copy_ownership_from_path(f.name)
 
484
            self._get_parser().write(f)
 
485
        finally:
 
486
            f.close()
 
487
 
330
488
 
331
489
class GlobalConfig(IniBasedConfig):
332
490
    """The configuration that should be used for a specific location."""
339
497
 
340
498
    def set_user_option(self, option, value):
341
499
        """Save option and its value in the configuration."""
 
500
        self._set_option(option, value, 'DEFAULT')
 
501
 
 
502
    def get_aliases(self):
 
503
        """Return the aliases section."""
 
504
        if 'ALIASES' in self._get_parser():
 
505
            return self._get_parser()['ALIASES']
 
506
        else:
 
507
            return {}
 
508
 
 
509
    def set_alias(self, alias_name, alias_command):
 
510
        """Save the alias in the configuration."""
 
511
        self._set_option(alias_name, alias_command, 'ALIASES')
 
512
 
 
513
    def unset_alias(self, alias_name):
 
514
        """Unset an existing alias."""
 
515
        aliases = self._get_parser().get('ALIASES')
 
516
        if not aliases or alias_name not in aliases:
 
517
            raise errors.NoSuchAlias(alias_name)
 
518
        del aliases[alias_name]
 
519
        self._write_config_file()
 
520
 
 
521
    def _set_option(self, option, value, section):
342
522
        # FIXME: RBC 20051029 This should refresh the parser and also take a
343
523
        # file lock on bazaar.conf.
344
524
        conf_dir = os.path.dirname(self._get_filename())
345
525
        ensure_config_dir_exists(conf_dir)
346
 
        if 'DEFAULT' not in self._get_parser():
347
 
            self._get_parser()['DEFAULT'] = {}
348
 
        self._get_parser()['DEFAULT'][option] = value
349
 
        f = open(self._get_filename(), 'wb')
350
 
        self._get_parser().write(f)
351
 
        f.close()
 
526
        self._get_parser().setdefault(section, {})[option] = value
 
527
        self._write_config_file()
352
528
 
353
529
 
354
530
class LocationConfig(IniBasedConfig):
356
532
 
357
533
    def __init__(self, location):
358
534
        name_generator = locations_config_filename
359
 
        if (not os.path.exists(name_generator()) and 
 
535
        if (not os.path.exists(name_generator()) and
360
536
                os.path.exists(branches_config_filename())):
361
537
            if sys.platform == 'win32':
362
 
                warning('Please rename %s to %s' 
363
 
                         % (branches_config_filename(),
364
 
                            locations_config_filename()))
 
538
                trace.warning('Please rename %s to %s'
 
539
                              % (branches_config_filename(),
 
540
                                 locations_config_filename()))
365
541
            else:
366
 
                warning('Please rename ~/.bazaar/branches.conf'
367
 
                        ' to ~/.bazaar/locations.conf')
 
542
                trace.warning('Please rename ~/.bazaar/branches.conf'
 
543
                              ' to ~/.bazaar/locations.conf')
368
544
            name_generator = branches_config_filename
369
545
        super(LocationConfig, self).__init__(name_generator)
 
546
        # local file locations are looked up by local path, rather than
 
547
        # by file url. This is because the config file is a user
 
548
        # file, and we would rather not expose the user to file urls.
 
549
        if location.startswith('file://'):
 
550
            location = urlutils.local_path_from_url(location)
370
551
        self.location = location
371
552
 
372
 
    def _get_section(self):
373
 
        """Get the section we should look in for config items.
374
 
 
375
 
        Returns None if none exists. 
376
 
        TODO: perhaps return a NullSection that thunks through to the 
377
 
              global config.
378
 
        """
 
553
    def _get_matching_sections(self):
 
554
        """Return an ordered list of section names matching this location."""
379
555
        sections = self._get_parser()
380
556
        location_names = self.location.split('/')
381
557
        if self.location.endswith('/'):
382
558
            del location_names[-1]
383
559
        matches=[]
384
560
        for section in sections:
385
 
            section_names = section.split('/')
 
561
            # location is a local path if possible, so we need
 
562
            # to convert 'file://' urls to local paths if necessary.
 
563
            # This also avoids having file:///path be a more exact
 
564
            # match than '/path'.
 
565
            if section.startswith('file://'):
 
566
                section_path = urlutils.local_path_from_url(section)
 
567
            else:
 
568
                section_path = section
 
569
            section_names = section_path.split('/')
386
570
            if section.endswith('/'):
387
571
                del section_names[-1]
388
572
            names = zip(location_names, section_names)
397
581
            # if section is longer, no match.
398
582
            if len(section_names) > len(location_names):
399
583
                continue
400
 
            # if path is longer, and recurse is not true, no match
401
 
            if len(section_names) < len(location_names):
402
 
                try:
403
 
                    if not self._get_parser()[section].as_bool('recurse'):
404
 
                        continue
405
 
                except KeyError:
406
 
                    pass
407
 
            matches.append((len(section_names), section))
408
 
        if not len(matches):
409
 
            return None
 
584
            matches.append((len(section_names), section,
 
585
                            '/'.join(location_names[len(section_names):])))
410
586
        matches.sort(reverse=True)
411
 
        return matches[0][1]
412
 
 
413
 
    def set_user_option(self, option, value):
 
587
        sections = []
 
588
        for (length, section, extra_path) in matches:
 
589
            sections.append((section, extra_path))
 
590
            # should we stop looking for parent configs here?
 
591
            try:
 
592
                if self._get_parser()[section].as_bool('ignore_parents'):
 
593
                    break
 
594
            except KeyError:
 
595
                pass
 
596
        return sections
 
597
 
 
598
    def _get_option_policy(self, section, option_name):
 
599
        """Return the policy for the given (section, option_name) pair."""
 
600
        # check for the old 'recurse=False' flag
 
601
        try:
 
602
            recurse = self._get_parser()[section].as_bool('recurse')
 
603
        except KeyError:
 
604
            recurse = True
 
605
        if not recurse:
 
606
            return POLICY_NORECURSE
 
607
 
 
608
        policy_key = option_name + ':policy'
 
609
        try:
 
610
            policy_name = self._get_parser()[section][policy_key]
 
611
        except KeyError:
 
612
            policy_name = None
 
613
 
 
614
        return _policy_value[policy_name]
 
615
 
 
616
    def _set_option_policy(self, section, option_name, option_policy):
 
617
        """Set the policy for the given option name in the given section."""
 
618
        # The old recurse=False option affects all options in the
 
619
        # section.  To handle multiple policies in the section, we
 
620
        # need to convert it to a policy_norecurse key.
 
621
        try:
 
622
            recurse = self._get_parser()[section].as_bool('recurse')
 
623
        except KeyError:
 
624
            pass
 
625
        else:
 
626
            symbol_versioning.warn(
 
627
                'The recurse option is deprecated as of 0.14.  '
 
628
                'The section "%s" has been converted to use policies.'
 
629
                % section,
 
630
                DeprecationWarning)
 
631
            del self._get_parser()[section]['recurse']
 
632
            if not recurse:
 
633
                for key in self._get_parser()[section].keys():
 
634
                    if not key.endswith(':policy'):
 
635
                        self._get_parser()[section][key +
 
636
                                                    ':policy'] = 'norecurse'
 
637
 
 
638
        policy_key = option_name + ':policy'
 
639
        policy_name = _policy_name[option_policy]
 
640
        if policy_name is not None:
 
641
            self._get_parser()[section][policy_key] = policy_name
 
642
        else:
 
643
            if policy_key in self._get_parser()[section]:
 
644
                del self._get_parser()[section][policy_key]
 
645
 
 
646
    def set_user_option(self, option, value, store=STORE_LOCATION):
414
647
        """Save option and its value in the configuration."""
 
648
        if store not in [STORE_LOCATION,
 
649
                         STORE_LOCATION_NORECURSE,
 
650
                         STORE_LOCATION_APPENDPATH]:
 
651
            raise ValueError('bad storage policy %r for %r' %
 
652
                (store, option))
415
653
        # FIXME: RBC 20051029 This should refresh the parser and also take a
416
654
        # file lock on locations.conf.
417
655
        conf_dir = os.path.dirname(self._get_filename())
425
663
        elif location + '/' in self._get_parser():
426
664
            location = location + '/'
427
665
        self._get_parser()[location][option]=value
428
 
        self._get_parser().write(file(self._get_filename(), 'wb'))
 
666
        # the allowed values of store match the config policies
 
667
        self._set_option_policy(location, option, store)
 
668
        self._write_config_file()
429
669
 
430
670
 
431
671
class BranchConfig(Config):
460
700
 
461
701
    def _get_safe_value(self, option_name):
462
702
        """This variant of get_best_value never returns untrusted values.
463
 
        
 
703
 
464
704
        It does not return values from the branch data, because the branch may
465
705
        not be controlled by the user.
466
706
 
475
715
 
476
716
    def _get_user_id(self):
477
717
        """Return the full user id for the branch.
478
 
    
479
 
        e.g. "John Hacker <jhacker@foo.org>"
 
718
 
 
719
        e.g. "John Hacker <jhacker@example.com>"
480
720
        This is looked up in the email controlfile for the branch.
481
721
        """
482
722
        try:
483
 
            return (self.branch.control_files.get_utf8("email") 
484
 
                    .read()
485
 
                    .decode(bzrlib.user_encoding)
 
723
            return (self.branch._transport.get_bytes("email")
 
724
                    .decode(osutils.get_user_encoding())
486
725
                    .rstrip("\r\n"))
487
726
        except errors.NoSuchFile, e:
488
727
            pass
489
 
        
 
728
 
490
729
        return self._get_best_value('_get_user_id')
491
730
 
 
731
    def _get_change_editor(self):
 
732
        return self._get_best_value('_get_change_editor')
 
733
 
492
734
    def _get_signature_checking(self):
493
735
        """See Config._get_signature_checking."""
494
736
        return self._get_best_value('_get_signature_checking')
505
747
                return value
506
748
        return None
507
749
 
508
 
    def set_user_option(self, name, value, local=False):
509
 
        if local is True:
510
 
            self._get_location_config().set_user_option(name, value)
511
 
        else:
 
750
    def set_user_option(self, name, value, store=STORE_BRANCH,
 
751
        warn_masked=False):
 
752
        if store == STORE_BRANCH:
512
753
            self._get_branch_data_config().set_option(value, name)
513
 
 
 
754
        elif store == STORE_GLOBAL:
 
755
            self._get_global_config().set_user_option(name, value)
 
756
        else:
 
757
            self._get_location_config().set_user_option(name, value, store)
 
758
        if not warn_masked:
 
759
            return
 
760
        if store in (STORE_GLOBAL, STORE_BRANCH):
 
761
            mask_value = self._get_location_config().get_user_option(name)
 
762
            if mask_value is not None:
 
763
                trace.warning('Value "%s" is masked by "%s" from'
 
764
                              ' locations.conf', value, mask_value)
 
765
            else:
 
766
                if store == STORE_GLOBAL:
 
767
                    branch_config = self._get_branch_data_config()
 
768
                    mask_value = branch_config.get_user_option(name)
 
769
                    if mask_value is not None:
 
770
                        trace.warning('Value "%s" is masked by "%s" from'
 
771
                                      ' branch.conf', value, mask_value)
514
772
 
515
773
    def _gpg_signing_command(self):
516
774
        """See Config.gpg_signing_command."""
517
775
        return self._get_safe_value('_gpg_signing_command')
518
 
        
 
776
 
519
777
    def __init__(self, branch):
520
778
        super(BranchConfig, self).__init__()
521
779
        self._location_config = None
522
780
        self._branch_data_config = None
523
781
        self._global_config = None
524
782
        self.branch = branch
525
 
        self.option_sources = (self._get_location_config, 
 
783
        self.option_sources = (self._get_location_config,
526
784
                               self._get_branch_data_config,
527
785
                               self._get_global_config)
528
786
 
534
792
        value = self._get_explicit_nickname()
535
793
        if value is not None:
536
794
            return value
537
 
        return self.branch.base.split('/')[-2]
 
795
        return urlutils.unescape(self.branch.base.split('/')[-2])
538
796
 
539
797
    def has_explicit_nickname(self):
540
798
        """Return true if a nickname has been explicitly assigned."""
560
818
        if sys.platform == 'win32':
561
819
            parent_dir = os.path.dirname(path)
562
820
            if not os.path.isdir(parent_dir):
563
 
                mutter('creating config parent directory: %r', parent_dir)
 
821
                trace.mutter('creating config parent directory: %r', parent_dir)
564
822
            os.mkdir(parent_dir)
565
 
        mutter('creating config directory: %r', path)
 
823
        trace.mutter('creating config directory: %r', path)
566
824
        os.mkdir(path)
 
825
        osutils.copy_ownership_from_path(path)
567
826
 
568
827
 
569
828
def config_dir():
570
829
    """Return per-user configuration directory.
571
830
 
572
831
    By default this is ~/.bazaar/
573
 
    
 
832
 
574
833
    TODO: Global option --config-dir to override this.
575
834
    """
576
835
    base = os.environ.get('BZR_HOME', None)
577
836
    if sys.platform == 'win32':
578
837
        if base is None:
579
 
            base = os.environ.get('APPDATA', None)
 
838
            base = win32utils.get_appdata_location_unicode()
580
839
        if base is None:
581
840
            base = os.environ.get('HOME', None)
582
841
        if base is None:
583
 
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
584
 
        return pathjoin(base, 'bazaar', '2.0')
 
842
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
 
843
                                  ' or HOME set')
 
844
        return osutils.pathjoin(base, 'bazaar', '2.0')
585
845
    else:
586
 
        # cygwin, linux, and darwin all have a $HOME directory
587
846
        if base is None:
588
847
            base = os.path.expanduser("~")
589
 
        return pathjoin(base, ".bazaar")
 
848
        return osutils.pathjoin(base, ".bazaar")
590
849
 
591
850
 
592
851
def config_filename():
593
852
    """Return per-user configuration ini file filename."""
594
 
    return pathjoin(config_dir(), 'bazaar.conf')
 
853
    return osutils.pathjoin(config_dir(), 'bazaar.conf')
595
854
 
596
855
 
597
856
def branches_config_filename():
598
857
    """Return per-user configuration ini file filename."""
599
 
    return pathjoin(config_dir(), 'branches.conf')
 
858
    return osutils.pathjoin(config_dir(), 'branches.conf')
600
859
 
601
860
 
602
861
def locations_config_filename():
603
862
    """Return per-user configuration ini file filename."""
604
 
    return pathjoin(config_dir(), 'locations.conf')
605
 
 
606
 
 
607
 
def _auto_user_id():
608
 
    """Calculate automatic user identification.
609
 
 
610
 
    Returns (realname, email).
611
 
 
612
 
    Only used when none is set in the environment or the id file.
613
 
 
614
 
    This previously used the FQDN as the default domain, but that can
615
 
    be very slow on machines where DNS is broken.  So now we simply
616
 
    use the hostname.
 
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')
 
869
 
 
870
 
 
871
def user_ignore_config_filename():
 
872
    """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.
617
884
    """
618
 
    import socket
619
 
 
620
 
    # XXX: Any good way to get real user name on win32?
621
 
 
622
 
    try:
623
 
        import pwd
624
 
        uid = os.getuid()
625
 
        w = pwd.getpwuid(uid)
626
 
 
627
 
        # we try utf-8 first, because on many variants (like Linux),
628
 
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
629
 
        # false positives.  (many users will have their user encoding set to
630
 
        # latin-1, which cannot raise UnicodeError.)
631
 
        try:
632
 
            gecos = w.pw_gecos.decode('utf-8')
633
 
            encoding = 'utf-8'
634
 
        except UnicodeError:
635
 
            try:
636
 
                gecos = w.pw_gecos.decode(bzrlib.user_encoding)
637
 
                encoding = bzrlib.user_encoding
638
 
            except UnicodeError:
639
 
                raise errors.BzrCommandError('Unable to determine your name.  '
640
 
                   'Use "bzr whoami" to set it.')
641
 
        try:
642
 
            username = w.pw_name.decode(encoding)
643
 
        except UnicodeError:
644
 
            raise errors.BzrCommandError('Unable to determine your name.  '
645
 
                'Use "bzr whoami" to set it.')
646
 
 
647
 
        comma = gecos.find(',')
648
 
        if comma == -1:
649
 
            realname = gecos
650
 
        else:
651
 
            realname = gecos[:comma]
652
 
        if not realname:
653
 
            realname = username
654
 
 
655
 
    except ImportError:
656
 
        import getpass
657
 
        try:
658
 
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
659
 
        except UnicodeDecodeError:
660
 
            raise errors.BzrError("Can't decode username as %s." % \
661
 
                    bzrlib.user_encoding)
662
 
 
663
 
    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))
664
910
 
665
911
 
666
912
def extract_email_address(e):
667
913
    """Return just the address part of an email string.
668
 
    
669
 
    That is just the user@domain part, nothing else. 
 
914
 
 
915
    That is just the user@domain part, nothing else.
670
916
    This part is required to contain only ascii characters.
671
917
    If it can't be extracted, raises an error.
672
 
    
 
918
 
673
919
    >>> extract_email_address('Jane Tester <jane@test.com>')
674
920
    "jane@test.com"
675
921
    """
676
 
    m = re.search(r'[\w+.-]+@[\w+.-]+', e)
677
 
    if not m:
678
 
        raise errors.BzrError("%r doesn't seem to contain "
679
 
                              "a reasonable email address" % e)
680
 
    return m.group(0)
 
922
    name, email = parse_username(e)
 
923
    if not email:
 
924
        raise errors.NoEmailInUsername(e)
 
925
    return email
681
926
 
682
927
 
683
928
class TreeConfig(IniBasedConfig):
684
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
 
685
933
    def __init__(self, branch):
 
934
        self._config = branch._get_config()
686
935
        self.branch = branch
687
936
 
688
937
    def _get_parser(self, file=None):
689
938
        if file is not None:
690
939
            return IniBasedConfig._get_parser(file)
691
 
        return self._get_config()
692
 
 
693
 
    def _get_config(self):
694
 
        try:
695
 
            obj = ConfigObj(self.branch.control_files.get('branch.conf'), 
696
 
                            encoding='utf-8')
697
 
        except errors.NoSuchFile:
698
 
            obj = ConfigObj(encoding='utf=8')
699
 
        return obj
 
940
        return self._config._get_configobj()
700
941
 
701
942
    def get_option(self, name, section=None, default=None):
702
943
        self.branch.lock_read()
703
944
        try:
704
 
            obj = self._get_config()
705
 
            try:
706
 
                if section is not None:
707
 
                    obj[section]
708
 
                result = obj[name]
709
 
            except KeyError:
710
 
                result = default
 
945
            return self._config.get_option(name, section, default)
711
946
        finally:
712
947
            self.branch.unlock()
713
 
        return result
714
948
 
715
949
    def set_option(self, value, name, section=None):
716
950
        """Set a per-branch configuration option"""
717
951
        self.branch.lock_write()
718
952
        try:
719
 
            cfg_obj = self._get_config()
720
 
            if section is None:
721
 
                obj = cfg_obj
722
 
            else:
723
 
                try:
724
 
                    obj = cfg_obj[section]
725
 
                except KeyError:
726
 
                    cfg_obj[section] = {}
727
 
                    obj = cfg_obj[section]
728
 
            obj[name] = value
729
 
            out_file = StringIO()
730
 
            cfg_obj.write(out_file)
731
 
            out_file.seek(0)
732
 
            self.branch.control_files.put('branch.conf', out_file)
 
953
            self._config.set_option(value, name, section)
733
954
        finally:
734
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
        f = file(self._filename, 'wb')
 
995
        try:
 
996
            self._get_config().write(f)
 
997
        finally:
 
998
            f.close()
 
999
 
 
1000
    def _set_option(self, section_name, option_name, value):
 
1001
        """Set an authentication configuration option"""
 
1002
        conf = self._get_config()
 
1003
        section = conf.get(section_name)
 
1004
        if section is None:
 
1005
            conf[section] = {}
 
1006
            section = conf[section]
 
1007
        section[option_name] = value
 
1008
        self._save()
 
1009
 
 
1010
    def get_credentials(self, scheme, host, port=None, user=None, path=None, 
 
1011
                        realm=None):
 
1012
        """Returns the matching credentials from authentication.conf file.
 
1013
 
 
1014
        :param scheme: protocol
 
1015
 
 
1016
        :param host: the server address
 
1017
 
 
1018
        :param port: the associated port (optional)
 
1019
 
 
1020
        :param user: login (optional)
 
1021
 
 
1022
        :param path: the absolute path on the server (optional)
 
1023
        
 
1024
        :param realm: the http authentication realm (optional)
 
1025
 
 
1026
        :return: A dict containing the matching credentials or None.
 
1027
           This includes:
 
1028
           - name: the section name of the credentials in the
 
1029
             authentication.conf file,
 
1030
           - user: can't be different from the provided user if any,
 
1031
           - scheme: the server protocol,
 
1032
           - host: the server address,
 
1033
           - port: the server port (can be None),
 
1034
           - path: the absolute server path (can be None),
 
1035
           - realm: the http specific authentication realm (can be None),
 
1036
           - password: the decoded password, could be None if the credential
 
1037
             defines only the user
 
1038
           - verify_certificates: https specific, True if the server
 
1039
             certificate should be verified, False otherwise.
 
1040
        """
 
1041
        credentials = None
 
1042
        for auth_def_name, auth_def in self._get_config().items():
 
1043
            if type(auth_def) is not configobj.Section:
 
1044
                raise ValueError("%s defined outside a section" % auth_def_name)
 
1045
 
 
1046
            a_scheme, a_host, a_user, a_path = map(
 
1047
                auth_def.get, ['scheme', 'host', 'user', 'path'])
 
1048
 
 
1049
            try:
 
1050
                a_port = auth_def.as_int('port')
 
1051
            except KeyError:
 
1052
                a_port = None
 
1053
            except ValueError:
 
1054
                raise ValueError("'port' not numeric in %s" % auth_def_name)
 
1055
            try:
 
1056
                a_verify_certificates = auth_def.as_bool('verify_certificates')
 
1057
            except KeyError:
 
1058
                a_verify_certificates = True
 
1059
            except ValueError:
 
1060
                raise ValueError(
 
1061
                    "'verify_certificates' not boolean in %s" % auth_def_name)
 
1062
 
 
1063
            # Attempt matching
 
1064
            if a_scheme is not None and scheme != a_scheme:
 
1065
                continue
 
1066
            if a_host is not None:
 
1067
                if not (host == a_host
 
1068
                        or (a_host.startswith('.') and host.endswith(a_host))):
 
1069
                    continue
 
1070
            if a_port is not None and port != a_port:
 
1071
                continue
 
1072
            if (a_path is not None and path is not None
 
1073
                and not path.startswith(a_path)):
 
1074
                continue
 
1075
            if (a_user is not None and user is not None
 
1076
                and a_user != user):
 
1077
                # Never contradict the caller about the user to be used
 
1078
                continue
 
1079
            if a_user is None:
 
1080
                # Can't find a user
 
1081
                continue
 
1082
            # Prepare a credentials dictionary with additional keys
 
1083
            # for the credential providers
 
1084
            credentials = dict(name=auth_def_name,
 
1085
                               user=a_user,
 
1086
                               scheme=a_scheme,
 
1087
                               host=host,
 
1088
                               port=port,
 
1089
                               path=path,
 
1090
                               realm=realm,
 
1091
                               password=auth_def.get('password', None),
 
1092
                               verify_certificates=a_verify_certificates)
 
1093
            # Decode the password in the credentials (or get one)
 
1094
            self.decode_password(credentials,
 
1095
                                 auth_def.get('password_encoding', None))
 
1096
            if 'auth' in debug.debug_flags:
 
1097
                trace.mutter("Using authentication section: %r", auth_def_name)
 
1098
            break
 
1099
 
 
1100
        if credentials is None:
 
1101
            # No credentials were found in authentication.conf, try the fallback
 
1102
            # credentials stores.
 
1103
            credentials = credential_store_registry.get_fallback_credentials(
 
1104
                scheme, host, port, user, path, realm)
 
1105
 
 
1106
        return credentials
 
1107
 
 
1108
    def set_credentials(self, name, host, user, scheme=None, password=None,
 
1109
                        port=None, path=None, verify_certificates=None,
 
1110
                        realm=None):
 
1111
        """Set authentication credentials for a host.
 
1112
 
 
1113
        Any existing credentials with matching scheme, host, port and path
 
1114
        will be deleted, regardless of name.
 
1115
 
 
1116
        :param name: An arbitrary name to describe this set of credentials.
 
1117
        :param host: Name of the host that accepts these credentials.
 
1118
        :param user: The username portion of these credentials.
 
1119
        :param scheme: The URL scheme (e.g. ssh, http) the credentials apply
 
1120
            to.
 
1121
        :param password: Password portion of these credentials.
 
1122
        :param port: The IP port on the host that these credentials apply to.
 
1123
        :param path: A filesystem path on the host that these credentials
 
1124
            apply to.
 
1125
        :param verify_certificates: On https, verify server certificates if
 
1126
            True.
 
1127
        :param realm: The http authentication realm (optional).
 
1128
        """
 
1129
        values = {'host': host, 'user': user}
 
1130
        if password is not None:
 
1131
            values['password'] = password
 
1132
        if scheme is not None:
 
1133
            values['scheme'] = scheme
 
1134
        if port is not None:
 
1135
            values['port'] = '%d' % port
 
1136
        if path is not None:
 
1137
            values['path'] = path
 
1138
        if verify_certificates is not None:
 
1139
            values['verify_certificates'] = str(verify_certificates)
 
1140
        if realm is not None:
 
1141
            values['realm'] = realm
 
1142
        config = self._get_config()
 
1143
        for_deletion = []
 
1144
        for section, existing_values in config.items():
 
1145
            for key in ('scheme', 'host', 'port', 'path', 'realm'):
 
1146
                if existing_values.get(key) != values.get(key):
 
1147
                    break
 
1148
            else:
 
1149
                del config[section]
 
1150
        config.update({name: values})
 
1151
        self._save()
 
1152
 
 
1153
    def get_user(self, scheme, host, port=None, realm=None, path=None,
 
1154
                 prompt=None, ask=False, default=None):
 
1155
        """Get a user from authentication file.
 
1156
 
 
1157
        :param scheme: protocol
 
1158
 
 
1159
        :param host: the server address
 
1160
 
 
1161
        :param port: the associated port (optional)
 
1162
 
 
1163
        :param realm: the realm sent by the server (optional)
 
1164
 
 
1165
        :param path: the absolute path on the server (optional)
 
1166
 
 
1167
        :param ask: Ask the user if there is no explicitly configured username 
 
1168
                    (optional)
 
1169
 
 
1170
        :param default: The username returned if none is defined (optional).
 
1171
 
 
1172
        :return: The found user.
 
1173
        """
 
1174
        credentials = self.get_credentials(scheme, host, port, user=None,
 
1175
                                           path=path, realm=realm)
 
1176
        if credentials is not None:
 
1177
            user = credentials['user']
 
1178
        else:
 
1179
            user = None
 
1180
        if user is None:
 
1181
            if ask:
 
1182
                if prompt is None:
 
1183
                    # Create a default prompt suitable for most cases
 
1184
                    prompt = scheme.upper() + ' %(host)s username'
 
1185
                # Special handling for optional fields in the prompt
 
1186
                if port is not None:
 
1187
                    prompt_host = '%s:%d' % (host, port)
 
1188
                else:
 
1189
                    prompt_host = host
 
1190
                user = ui.ui_factory.get_username(prompt, host=prompt_host)
 
1191
            else:
 
1192
                user = default
 
1193
        return user
 
1194
 
 
1195
    def get_password(self, scheme, host, user, port=None,
 
1196
                     realm=None, path=None, prompt=None):
 
1197
        """Get a password from authentication file or prompt the user for one.
 
1198
 
 
1199
        :param scheme: protocol
 
1200
 
 
1201
        :param host: the server address
 
1202
 
 
1203
        :param port: the associated port (optional)
 
1204
 
 
1205
        :param user: login
 
1206
 
 
1207
        :param realm: the realm sent by the server (optional)
 
1208
 
 
1209
        :param path: the absolute path on the server (optional)
 
1210
 
 
1211
        :return: The found password or the one entered by the user.
 
1212
        """
 
1213
        credentials = self.get_credentials(scheme, host, port, user, path,
 
1214
                                           realm)
 
1215
        if credentials is not None:
 
1216
            password = credentials['password']
 
1217
            if password is not None and scheme is 'ssh':
 
1218
                trace.warning('password ignored in section [%s],'
 
1219
                              ' use an ssh agent instead'
 
1220
                              % credentials['name'])
 
1221
                password = None
 
1222
        else:
 
1223
            password = None
 
1224
        # Prompt user only if we could't find a password
 
1225
        if password is None:
 
1226
            if prompt is None:
 
1227
                # Create a default prompt suitable for most cases
 
1228
                prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
 
1229
            # Special handling for optional fields in the prompt
 
1230
            if port is not None:
 
1231
                prompt_host = '%s:%d' % (host, port)
 
1232
            else:
 
1233
                prompt_host = host
 
1234
            password = ui.ui_factory.get_password(prompt,
 
1235
                                                  host=prompt_host, user=user)
 
1236
        return password
 
1237
 
 
1238
    def decode_password(self, credentials, encoding):
 
1239
        try:
 
1240
            cs = credential_store_registry.get_credential_store(encoding)
 
1241
        except KeyError:
 
1242
            raise ValueError('%r is not a known password_encoding' % encoding)
 
1243
        credentials['password'] = cs.decode_password(credentials)
 
1244
        return credentials
 
1245
 
 
1246
 
 
1247
class CredentialStoreRegistry(registry.Registry):
 
1248
    """A class that registers credential stores.
 
1249
 
 
1250
    A credential store provides access to credentials via the password_encoding
 
1251
    field in authentication.conf sections.
 
1252
 
 
1253
    Except for stores provided by bzr itself, most stores are expected to be
 
1254
    provided by plugins that will therefore use
 
1255
    register_lazy(password_encoding, module_name, member_name, help=help,
 
1256
    fallback=fallback) to install themselves.
 
1257
 
 
1258
    A fallback credential store is one that is queried if no credentials can be
 
1259
    found via authentication.conf.
 
1260
    """
 
1261
 
 
1262
    def get_credential_store(self, encoding=None):
 
1263
        cs = self.get(encoding)
 
1264
        if callable(cs):
 
1265
            cs = cs()
 
1266
        return cs
 
1267
 
 
1268
    def is_fallback(self, name):
 
1269
        """Check if the named credentials store should be used as fallback."""
 
1270
        return self.get_info(name)
 
1271
 
 
1272
    def get_fallback_credentials(self, scheme, host, port=None, user=None,
 
1273
                                 path=None, realm=None):
 
1274
        """Request credentials from all fallback credentials stores.
 
1275
 
 
1276
        The first credentials store that can provide credentials wins.
 
1277
        """
 
1278
        credentials = None
 
1279
        for name in self.keys():
 
1280
            if not self.is_fallback(name):
 
1281
                continue
 
1282
            cs = self.get_credential_store(name)
 
1283
            credentials = cs.get_credentials(scheme, host, port, user,
 
1284
                                             path, realm)
 
1285
            if credentials is not None:
 
1286
                # We found some credentials
 
1287
                break
 
1288
        return credentials
 
1289
 
 
1290
    def register(self, key, obj, help=None, override_existing=False,
 
1291
                 fallback=False):
 
1292
        """Register a new object to a name.
 
1293
 
 
1294
        :param key: This is the key to use to request the object later.
 
1295
        :param obj: The object to register.
 
1296
        :param help: Help text for this entry. This may be a string or
 
1297
                a callable. If it is a callable, it should take two
 
1298
                parameters (registry, key): this registry and the key that
 
1299
                the help was registered under.
 
1300
        :param override_existing: Raise KeyErorr if False and something has
 
1301
                already been registered for that key. If True, ignore if there
 
1302
                is an existing key (always register the new value).
 
1303
        :param fallback: Whether this credential store should be 
 
1304
                used as fallback.
 
1305
        """
 
1306
        return super(CredentialStoreRegistry,
 
1307
                     self).register(key, obj, help, info=fallback,
 
1308
                                    override_existing=override_existing)
 
1309
 
 
1310
    def register_lazy(self, key, module_name, member_name,
 
1311
                      help=None, override_existing=False,
 
1312
                      fallback=False):
 
1313
        """Register a new credential store to be loaded on request.
 
1314
 
 
1315
        :param module_name: The python path to the module. Such as 'os.path'.
 
1316
        :param member_name: The member of the module to return.  If empty or
 
1317
                None, get() will return the module itself.
 
1318
        :param help: Help text for this entry. This may be a string or
 
1319
                a callable.
 
1320
        :param override_existing: If True, replace the existing object
 
1321
                with the new one. If False, if there is already something
 
1322
                registered with the same key, raise a KeyError
 
1323
        :param fallback: Whether this credential store should be 
 
1324
                used as fallback.
 
1325
        """
 
1326
        return super(CredentialStoreRegistry, self).register_lazy(
 
1327
            key, module_name, member_name, help,
 
1328
            info=fallback, override_existing=override_existing)
 
1329
 
 
1330
 
 
1331
credential_store_registry = CredentialStoreRegistry()
 
1332
 
 
1333
 
 
1334
class CredentialStore(object):
 
1335
    """An abstract class to implement storage for credentials"""
 
1336
 
 
1337
    def decode_password(self, credentials):
 
1338
        """Returns a clear text password for the provided credentials."""
 
1339
        raise NotImplementedError(self.decode_password)
 
1340
 
 
1341
    def get_credentials(self, scheme, host, port=None, user=None, path=None,
 
1342
                        realm=None):
 
1343
        """Return the matching credentials from this credential store.
 
1344
 
 
1345
        This method is only called on fallback credential stores.
 
1346
        """
 
1347
        raise NotImplementedError(self.get_credentials)
 
1348
 
 
1349
 
 
1350
 
 
1351
class PlainTextCredentialStore(CredentialStore):
 
1352
    __doc__ = """Plain text credential store for the authentication.conf file"""
 
1353
 
 
1354
    def decode_password(self, credentials):
 
1355
        """See CredentialStore.decode_password."""
 
1356
        return credentials['password']
 
1357
 
 
1358
 
 
1359
credential_store_registry.register('plain', PlainTextCredentialStore,
 
1360
                                   help=PlainTextCredentialStore.__doc__)
 
1361
credential_store_registry.default_key = 'plain'
 
1362
 
 
1363
 
 
1364
class BzrDirConfig(object):
 
1365
 
 
1366
    def __init__(self, bzrdir):
 
1367
        self._bzrdir = bzrdir
 
1368
        self._config = bzrdir._get_config()
 
1369
 
 
1370
    def set_default_stack_on(self, value):
 
1371
        """Set the default stacking location.
 
1372
 
 
1373
        It may be set to a location, or None.
 
1374
 
 
1375
        This policy affects all branches contained by this bzrdir, except for
 
1376
        those under repositories.
 
1377
        """
 
1378
        if self._config is None:
 
1379
            raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
 
1380
        if value is None:
 
1381
            self._config.set_option('', 'default_stack_on')
 
1382
        else:
 
1383
            self._config.set_option(value, 'default_stack_on')
 
1384
 
 
1385
    def get_default_stack_on(self):
 
1386
        """Return the default stacking location.
 
1387
 
 
1388
        This will either be a location, or None.
 
1389
 
 
1390
        This policy affects all branches contained by this bzrdir, except for
 
1391
        those under repositories.
 
1392
        """
 
1393
        if self._config is None:
 
1394
            return None
 
1395
        value = self._config.get_option('default_stack_on')
 
1396
        if value == '':
 
1397
            value = None
 
1398
        return value
 
1399
 
 
1400
 
 
1401
class TransportConfig(object):
 
1402
    """A Config that reads/writes a config file on a Transport.
 
1403
 
 
1404
    It is a low-level object that considers config data to be name/value pairs
 
1405
    that may be associated with a section.  Assigning meaning to the these
 
1406
    values is done at higher levels like TreeConfig.
 
1407
    """
 
1408
 
 
1409
    def __init__(self, transport, filename):
 
1410
        self._transport = transport
 
1411
        self._filename = filename
 
1412
 
 
1413
    def get_option(self, name, section=None, default=None):
 
1414
        """Return the value associated with a named option.
 
1415
 
 
1416
        :param name: The name of the value
 
1417
        :param section: The section the option is in (if any)
 
1418
        :param default: The value to return if the value is not set
 
1419
        :return: The value or default value
 
1420
        """
 
1421
        configobj = self._get_configobj()
 
1422
        if section is None:
 
1423
            section_obj = configobj
 
1424
        else:
 
1425
            try:
 
1426
                section_obj = configobj[section]
 
1427
            except KeyError:
 
1428
                return default
 
1429
        return section_obj.get(name, default)
 
1430
 
 
1431
    def set_option(self, value, name, section=None):
 
1432
        """Set the value associated with a named option.
 
1433
 
 
1434
        :param value: The value to set
 
1435
        :param name: The name of the value to set
 
1436
        :param section: The section the option is in (if any)
 
1437
        """
 
1438
        configobj = self._get_configobj()
 
1439
        if section is None:
 
1440
            configobj[name] = value
 
1441
        else:
 
1442
            configobj.setdefault(section, {})[name] = value
 
1443
        self._set_configobj(configobj)
 
1444
 
 
1445
    def _get_config_file(self):
 
1446
        try:
 
1447
            return StringIO(self._transport.get_bytes(self._filename))
 
1448
        except errors.NoSuchFile:
 
1449
            return StringIO()
 
1450
 
 
1451
    def _get_configobj(self):
 
1452
        f = self._get_config_file()
 
1453
        try:
 
1454
            return ConfigObj(f, encoding='utf-8')
 
1455
        finally:
 
1456
            f.close()
 
1457
 
 
1458
    def _set_configobj(self, configobj):
 
1459
        out_file = StringIO()
 
1460
        configobj.write(out_file)
 
1461
        out_file.seek(0)
 
1462
        self._transport.put_file(self._filename, out_file)