~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: John Arbash Meinel
  • Date: 2006-07-13 00:05:14 UTC
  • mfrom: (1861 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1871.
  • Revision ID: john@arbash-meinel.com-20060713000514-aa62627aa0d4deb6
[merge] bzr.dev 1861

Show diffs side-by-side

added added

removed removed

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