← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

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, 2007, 2008 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#            and others
3
4
#
4
5
# This program is free software; you can redistribute it and/or modify
5
6
# it under the terms of the GNU General Public License as published by
13
14
#
14
15
# You should have received a copy of the GNU General Public License
15
16
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
18
 
18
19
"""Configuration that affects the behaviour of Bazaar.
19
20
 
36
37
[/home/robertc/source]
37
38
recurse=False|True(default)
38
39
email= as above
39
 
check_signatures= as above 
 
40
check_signatures= as above
40
41
create_signatures= as above.
41
42
 
42
43
explanation of options
44
45
editor - this option sets the pop up editor to use during commits.
45
46
email - this option sets the user id bzr will use when committing.
46
47
check_signatures - this option controls whether bzr will require good gpg
47
 
                   signatures, ignore them, or check them if they are 
 
48
                   signatures, ignore them, or check them if they are
48
49
                   present.
49
 
create_signatures - this option controls whether bzr will always create 
 
50
create_signatures - this option controls whether bzr will always create
50
51
                    gpg signatures, never create them, or create them if the
51
52
                    branch is configured to require them.
52
53
log_format - this option sets the default log format.  Possible values are
61
62
up=pull
62
63
"""
63
64
 
 
65
import os
 
66
import sys
64
67
 
 
68
from bzrlib.lazy_import import lazy_import
 
69
lazy_import(globals(), """
65
70
import errno
66
71
from fnmatch import fnmatch
67
 
import os
68
72
import re
69
 
import sys
70
 
from StringIO import StringIO
 
73
from cStringIO import StringIO
71
74
 
72
75
import bzrlib
73
 
from bzrlib import errors, urlutils
74
 
from bzrlib.osutils import pathjoin
75
 
from bzrlib.trace import mutter, warning
76
 
import bzrlib.util.configobj.configobj as configobj
 
76
from bzrlib import (
 
77
    debug,
 
78
    errors,
 
79
    mail_client,
 
80
    osutils,
 
81
    registry,
 
82
    symbol_versioning,
 
83
    trace,
 
84
    ui,
 
85
    urlutils,
 
86
    win32utils,
 
87
    )
 
88
from bzrlib.util.configobj import configobj
 
89
""")
77
90
 
78
91
 
79
92
CHECK_IF_POSSIBLE=0
86
99
SIGN_NEVER=2
87
100
 
88
101
 
89
 
class ConfigObj(configobj.ConfigObj):
90
 
 
91
 
    def get_bool(self, section, key):
92
 
        return self[section].as_bool(key)
93
 
 
94
 
    def get_value(self, section, name):
95
 
        # Try [] for the old DEFAULT section.
96
 
        if section == "DEFAULT":
97
 
            try:
98
 
                return self[name]
99
 
            except KeyError:
100
 
                pass
101
 
        return self[section][name]
 
102
POLICY_NONE = 0
 
103
POLICY_NORECURSE = 1
 
104
POLICY_APPENDPATH = 2
 
105
 
 
106
_policy_name = {
 
107
    POLICY_NONE: None,
 
108
    POLICY_NORECURSE: 'norecurse',
 
109
    POLICY_APPENDPATH: 'appendpath',
 
110
    }
 
111
_policy_value = {
 
112
    None: POLICY_NONE,
 
113
    'none': POLICY_NONE,
 
114
    'norecurse': POLICY_NORECURSE,
 
115
    'appendpath': POLICY_APPENDPATH,
 
116
    }
 
117
 
 
118
 
 
119
STORE_LOCATION = POLICY_NONE
 
120
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
 
121
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
 
122
STORE_BRANCH = 3
 
123
STORE_GLOBAL = 4
 
124
 
 
125
_ConfigObj = None
 
126
def ConfigObj(*args, **kwargs):
 
127
    global _ConfigObj
 
128
    if _ConfigObj is None:
 
129
        class ConfigObj(configobj.ConfigObj):
 
130
 
 
131
            def get_bool(self, section, key):
 
132
                return self[section].as_bool(key)
 
133
 
 
134
            def get_value(self, section, name):
 
135
                # Try [] for the old DEFAULT section.
 
136
                if section == "DEFAULT":
 
137
                    try:
 
138
                        return self[name]
 
139
                    except KeyError:
 
140
                        pass
 
141
                return self[section][name]
 
142
        _ConfigObj = ConfigObj
 
143
    return _ConfigObj(*args, **kwargs)
102
144
 
103
145
 
104
146
class Config(object):
105
147
    """A configuration policy - what username, editor, gpg needs etc."""
106
148
 
 
149
    def __init__(self):
 
150
        super(Config, self).__init__()
 
151
 
107
152
    def get_editor(self):
108
153
        """Get the users pop up editor."""
109
154
        raise NotImplementedError
110
155
 
 
156
    def get_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
 
111
166
    def _get_signature_checking(self):
112
167
        """Template method to override signature checking policy."""
113
168
 
122
177
        """Get a generic option - no special process, no default."""
123
178
        return self._get_user_option(option_name)
124
179
 
 
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
 
125
189
    def gpg_signing_command(self):
126
190
        """What program should be used to sign signatures?"""
127
191
        result = self._gpg_signing_command()
144
208
        """See log_format()."""
145
209
        return None
146
210
 
147
 
    def __init__(self):
148
 
        super(Config, self).__init__()
149
 
 
150
211
    def post_commit(self):
151
212
        """An ordered list of python functions to call.
152
213
 
164
225
 
165
226
    def username(self):
166
227
        """Return email-style username.
167
 
    
 
228
 
168
229
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
169
 
        
 
230
 
170
231
        $BZR_EMAIL can be set to override this (as well as the
171
232
        deprecated $BZREMAIL), then
172
233
        the concrete policy type is checked, and finally
173
234
        $EMAIL is examined.
174
235
        If none is found, a reasonable default is (hopefully)
175
236
        created.
176
 
    
 
237
 
177
238
        TODO: Check it's reasonably well-formed.
178
239
        """
179
240
        v = os.environ.get('BZR_EMAIL')
180
241
        if v:
181
 
            return v.decode(bzrlib.user_encoding)
182
 
        v = os.environ.get('BZREMAIL')
183
 
        if v:
184
 
            warning('BZREMAIL is deprecated in favor of BZR_EMAIL. Please update your configuration.')
185
 
            return v.decode(bzrlib.user_encoding)
186
 
    
 
242
            return v.decode(osutils.get_user_encoding())
 
243
 
187
244
        v = self._get_user_id()
188
245
        if v:
189
246
            return v
190
 
        
 
247
 
191
248
        v = os.environ.get('EMAIL')
192
249
        if v:
193
 
            return v.decode(bzrlib.user_encoding)
 
250
            return v.decode(osutils.get_user_encoding())
194
251
 
195
252
        name, email = _auto_user_id()
196
253
        if name:
218
275
        if policy is None:
219
276
            policy = self._get_signature_checking()
220
277
            if policy is not None:
221
 
                warning("Please use create_signatures, not check_signatures "
222
 
                        "to set signing policy.")
 
278
                trace.warning("Please use create_signatures,"
 
279
                              " not check_signatures to set signing policy.")
223
280
            if policy == CHECK_ALWAYS:
224
281
                return True
225
282
        elif policy == SIGN_ALWAYS:
238
295
    def _get_nickname(self):
239
296
        return None
240
297
 
 
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
 
241
307
 
242
308
class IniBasedConfig(Config):
243
309
    """A configuration policy that draws from ini files."""
244
310
 
 
311
    def __init__(self, get_filename):
 
312
        super(IniBasedConfig, self).__init__()
 
313
        self._get_filename = get_filename
 
314
        self._parser = None
 
315
 
245
316
    def _get_parser(self, file=None):
246
317
        if self._parser is not None:
247
318
            return self._parser
255
326
            raise errors.ParseConfigError(e.errors, e.config.filename)
256
327
        return self._parser
257
328
 
 
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
 
258
341
    def _get_section(self):
259
342
        """Override this to define the section used by the config."""
260
343
        return "DEFAULT"
261
344
 
 
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
 
262
349
    def _get_signature_checking(self):
263
350
        """See Config._get_signature_checking."""
264
351
        policy = self._get_user_option('check_signatures')
277
364
 
278
365
    def _get_user_option(self, option_name):
279
366
        """See Config._get_user_option."""
280
 
        try:
281
 
            return self._get_parser().get_value(self._get_section(),
282
 
                                                option_name)
283
 
        except KeyError:
284
 
            pass
 
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
285
389
 
286
390
    def _gpg_signing_command(self):
287
391
        """See Config.gpg_signing_command."""
291
395
        """See Config.log_format."""
292
396
        return self._get_user_option('log_format')
293
397
 
294
 
    def __init__(self, get_filename):
295
 
        super(IniBasedConfig, self).__init__()
296
 
        self._get_filename = get_filename
297
 
        self._parser = None
298
 
        
299
398
    def _post_commit(self):
300
399
        """See Config.post_commit."""
301
400
        return self._get_user_option('post_commit')
324
423
 
325
424
    def _get_alias(self, value):
326
425
        try:
327
 
            return self._get_parser().get_value("ALIASES", 
 
426
            return self._get_parser().get_value("ALIASES",
328
427
                                                value)
329
428
        except KeyError:
330
429
            pass
344
443
 
345
444
    def set_user_option(self, option, value):
346
445
        """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):
347
468
        # FIXME: RBC 20051029 This should refresh the parser and also take a
348
469
        # file lock on bazaar.conf.
349
470
        conf_dir = os.path.dirname(self._get_filename())
350
471
        ensure_config_dir_exists(conf_dir)
351
 
        if 'DEFAULT' not in self._get_parser():
352
 
            self._get_parser()['DEFAULT'] = {}
353
 
        self._get_parser()['DEFAULT'][option] = value
 
472
        self._get_parser().setdefault(section, {})[option] = value
 
473
        self._write_config_file()
 
474
 
 
475
    def _write_config_file(self):
354
476
        f = open(self._get_filename(), 'wb')
355
477
        self._get_parser().write(f)
356
478
        f.close()
361
483
 
362
484
    def __init__(self, location):
363
485
        name_generator = locations_config_filename
364
 
        if (not os.path.exists(name_generator()) and 
 
486
        if (not os.path.exists(name_generator()) and
365
487
                os.path.exists(branches_config_filename())):
366
488
            if sys.platform == 'win32':
367
 
                warning('Please rename %s to %s' 
368
 
                         % (branches_config_filename(),
369
 
                            locations_config_filename()))
 
489
                trace.warning('Please rename %s to %s'
 
490
                              % (branches_config_filename(),
 
491
                                 locations_config_filename()))
370
492
            else:
371
 
                warning('Please rename ~/.bazaar/branches.conf'
372
 
                        ' to ~/.bazaar/locations.conf')
 
493
                trace.warning('Please rename ~/.bazaar/branches.conf'
 
494
                              ' to ~/.bazaar/locations.conf')
373
495
            name_generator = branches_config_filename
374
496
        super(LocationConfig, self).__init__(name_generator)
375
497
        # local file locations are looked up by local path, rather than
379
501
            location = urlutils.local_path_from_url(location)
380
502
        self.location = location
381
503
 
382
 
    def _get_section(self):
383
 
        """Get the section we should look in for config items.
384
 
 
385
 
        Returns None if none exists. 
386
 
        TODO: perhaps return a NullSection that thunks through to the 
387
 
              global config.
388
 
        """
 
504
    def _get_matching_sections(self):
 
505
        """Return an ordered list of section names matching this location."""
389
506
        sections = self._get_parser()
390
507
        location_names = self.location.split('/')
391
508
        if self.location.endswith('/'):
415
532
            # if section is longer, no match.
416
533
            if len(section_names) > len(location_names):
417
534
                continue
418
 
            # if path is longer, and recurse is not true, no match
419
 
            if len(section_names) < len(location_names):
420
 
                try:
421
 
                    if not self._get_parser()[section].as_bool('recurse'):
422
 
                        continue
423
 
                except KeyError:
424
 
                    pass
425
 
            matches.append((len(section_names), section))
426
 
        if not len(matches):
427
 
            return None
 
535
            matches.append((len(section_names), section,
 
536
                            '/'.join(location_names[len(section_names):])))
428
537
        matches.sort(reverse=True)
429
 
        return matches[0][1]
430
 
 
431
 
    def set_user_option(self, option, value):
 
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):
432
598
        """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))
433
604
        # FIXME: RBC 20051029 This should refresh the parser and also take a
434
605
        # file lock on locations.conf.
435
606
        conf_dir = os.path.dirname(self._get_filename())
443
614
        elif location + '/' in self._get_parser():
444
615
            location = location + '/'
445
616
        self._get_parser()[location][option]=value
 
617
        # the allowed values of store match the config policies
 
618
        self._set_option_policy(location, option, store)
446
619
        self._get_parser().write(file(self._get_filename(), 'wb'))
447
620
 
448
621
 
478
651
 
479
652
    def _get_safe_value(self, option_name):
480
653
        """This variant of get_best_value never returns untrusted values.
481
 
        
 
654
 
482
655
        It does not return values from the branch data, because the branch may
483
656
        not be controlled by the user.
484
657
 
493
666
 
494
667
    def _get_user_id(self):
495
668
        """Return the full user id for the branch.
496
 
    
497
 
        e.g. "John Hacker <jhacker@foo.org>"
 
669
 
 
670
        e.g. "John Hacker <jhacker@example.com>"
498
671
        This is looked up in the email controlfile for the branch.
499
672
        """
500
673
        try:
501
 
            return (self.branch.control_files.get_utf8("email") 
502
 
                    .read()
503
 
                    .decode(bzrlib.user_encoding)
 
674
            return (self.branch._transport.get_bytes("email")
 
675
                    .decode(osutils.get_user_encoding())
504
676
                    .rstrip("\r\n"))
505
677
        except errors.NoSuchFile, e:
506
678
            pass
507
 
        
 
679
 
508
680
        return self._get_best_value('_get_user_id')
509
681
 
510
682
    def _get_signature_checking(self):
523
695
                return value
524
696
        return None
525
697
 
526
 
    def set_user_option(self, name, value, local=False):
527
 
        if local is True:
528
 
            self._get_location_config().set_user_option(name, value)
529
 
        else:
 
698
    def set_user_option(self, name, value, store=STORE_BRANCH,
 
699
        warn_masked=False):
 
700
        if store == STORE_BRANCH:
530
701
            self._get_branch_data_config().set_option(value, name)
531
 
 
 
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)
532
720
 
533
721
    def _gpg_signing_command(self):
534
722
        """See Config.gpg_signing_command."""
535
723
        return self._get_safe_value('_gpg_signing_command')
536
 
        
 
724
 
537
725
    def __init__(self, branch):
538
726
        super(BranchConfig, self).__init__()
539
727
        self._location_config = None
540
728
        self._branch_data_config = None
541
729
        self._global_config = None
542
730
        self.branch = branch
543
 
        self.option_sources = (self._get_location_config, 
 
731
        self.option_sources = (self._get_location_config,
544
732
                               self._get_branch_data_config,
545
733
                               self._get_global_config)
546
734
 
552
740
        value = self._get_explicit_nickname()
553
741
        if value is not None:
554
742
            return value
555
 
        return self.branch.base.split('/')[-2]
 
743
        return urlutils.unescape(self.branch.base.split('/')[-2])
556
744
 
557
745
    def has_explicit_nickname(self):
558
746
        """Return true if a nickname has been explicitly assigned."""
578
766
        if sys.platform == 'win32':
579
767
            parent_dir = os.path.dirname(path)
580
768
            if not os.path.isdir(parent_dir):
581
 
                mutter('creating config parent directory: %r', parent_dir)
 
769
                trace.mutter('creating config parent directory: %r', parent_dir)
582
770
            os.mkdir(parent_dir)
583
 
        mutter('creating config directory: %r', path)
 
771
        trace.mutter('creating config directory: %r', path)
584
772
        os.mkdir(path)
585
773
 
586
774
 
588
776
    """Return per-user configuration directory.
589
777
 
590
778
    By default this is ~/.bazaar/
591
 
    
 
779
 
592
780
    TODO: Global option --config-dir to override this.
593
781
    """
594
782
    base = os.environ.get('BZR_HOME', None)
595
783
    if sys.platform == 'win32':
596
784
        if base is None:
597
 
            base = os.environ.get('APPDATA', None)
 
785
            base = win32utils.get_appdata_location_unicode()
598
786
        if base is None:
599
787
            base = os.environ.get('HOME', None)
600
788
        if base is None:
601
 
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
602
 
        return pathjoin(base, 'bazaar', '2.0')
 
789
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
 
790
                                  ' or HOME set')
 
791
        return osutils.pathjoin(base, 'bazaar', '2.0')
603
792
    else:
604
793
        # cygwin, linux, and darwin all have a $HOME directory
605
794
        if base is None:
606
795
            base = os.path.expanduser("~")
607
 
        return pathjoin(base, ".bazaar")
 
796
        return osutils.pathjoin(base, ".bazaar")
608
797
 
609
798
 
610
799
def config_filename():
611
800
    """Return per-user configuration ini file filename."""
612
 
    return pathjoin(config_dir(), 'bazaar.conf')
 
801
    return osutils.pathjoin(config_dir(), 'bazaar.conf')
613
802
 
614
803
 
615
804
def branches_config_filename():
616
805
    """Return per-user configuration ini file filename."""
617
 
    return pathjoin(config_dir(), 'branches.conf')
 
806
    return osutils.pathjoin(config_dir(), 'branches.conf')
618
807
 
619
808
 
620
809
def locations_config_filename():
621
810
    """Return per-user configuration ini file filename."""
622
 
    return pathjoin(config_dir(), 'locations.conf')
 
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')
623
817
 
624
818
 
625
819
def user_ignore_config_filename():
626
820
    """Return the user default ignore filename"""
627
 
    return pathjoin(config_dir(), 'ignore')
 
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')
628
845
 
629
846
 
630
847
def _auto_user_id():
640
857
    """
641
858
    import socket
642
859
 
643
 
    # XXX: Any good way to get real user name on win32?
 
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)
644
870
 
645
871
    try:
646
872
        import pwd
647
873
        uid = os.getuid()
648
 
        w = pwd.getpwuid(uid)
 
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.')
649
879
 
650
880
        # we try utf-8 first, because on many variants (like Linux),
651
881
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
656
886
            encoding = 'utf-8'
657
887
        except UnicodeError:
658
888
            try:
659
 
                gecos = w.pw_gecos.decode(bzrlib.user_encoding)
660
 
                encoding = bzrlib.user_encoding
 
889
                encoding = osutils.get_user_encoding()
 
890
                gecos = w.pw_gecos.decode(encoding)
661
891
            except UnicodeError:
662
892
                raise errors.BzrCommandError('Unable to determine your name.  '
663
893
                   'Use "bzr whoami" to set it.')
678
908
    except ImportError:
679
909
        import getpass
680
910
        try:
681
 
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
911
            user_encoding = osutils.get_user_encoding()
 
912
            realname = username = getpass.getuser().decode(user_encoding)
682
913
        except UnicodeDecodeError:
683
914
            raise errors.BzrError("Can't decode username as %s." % \
684
 
                    bzrlib.user_encoding)
 
915
                    user_encoding)
685
916
 
686
917
    return realname, (username + '@' + socket.gethostname())
687
918
 
688
919
 
 
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
 
689
929
def extract_email_address(e):
690
930
    """Return just the address part of an email string.
691
 
    
692
 
    That is just the user@domain part, nothing else. 
 
931
 
 
932
    That is just the user@domain part, nothing else.
693
933
    This part is required to contain only ascii characters.
694
934
    If it can't be extracted, raises an error.
695
 
    
 
935
 
696
936
    >>> extract_email_address('Jane Tester <jane@test.com>')
697
937
    "jane@test.com"
698
938
    """
699
 
    m = re.search(r'[\w+.-]+@[\w+.-]+', e)
700
 
    if not m:
701
 
        raise errors.BzrError("%r doesn't seem to contain "
702
 
                              "a reasonable email address" % e)
703
 
    return m.group(0)
 
939
    name, email = parse_username(e)
 
940
    if not email:
 
941
        raise errors.NoEmailInUsername(e)
 
942
    return email
704
943
 
705
944
 
706
945
class TreeConfig(IniBasedConfig):
707
946
    """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
 
708
950
    def __init__(self, branch):
 
951
        self._config = branch._get_config()
709
952
        self.branch = branch
710
953
 
711
954
    def _get_parser(self, file=None):
712
955
        if file is not None:
713
956
            return IniBasedConfig._get_parser(file)
714
 
        return self._get_config()
715
 
 
716
 
    def _get_config(self):
717
 
        try:
718
 
            obj = ConfigObj(self.branch.control_files.get('branch.conf'), 
719
 
                            encoding='utf-8')
720
 
        except errors.NoSuchFile:
721
 
            obj = ConfigObj(encoding='utf=8')
722
 
        return obj
 
957
        return self._config._get_configobj()
723
958
 
724
959
    def get_option(self, name, section=None, default=None):
725
960
        self.branch.lock_read()
726
961
        try:
727
 
            obj = self._get_config()
728
 
            try:
729
 
                if section is not None:
730
 
                    obj[section]
731
 
                result = obj[name]
732
 
            except KeyError:
733
 
                result = default
 
962
            return self._config.get_option(name, section, default)
734
963
        finally:
735
964
            self.branch.unlock()
736
 
        return result
737
965
 
738
966
    def set_option(self, value, name, section=None):
739
967
        """Set a per-branch configuration option"""
740
968
        self.branch.lock_write()
741
969
        try:
742
 
            cfg_obj = self._get_config()
743
 
            if section is None:
744
 
                obj = cfg_obj
745
 
            else:
746
 
                try:
747
 
                    obj = cfg_obj[section]
748
 
                except KeyError:
749
 
                    cfg_obj[section] = {}
750
 
                    obj = cfg_obj[section]
751
 
            obj[name] = value
752
 
            out_file = StringIO()
753
 
            cfg_obj.write(out_file)
754
 
            out_file.seek(0)
755
 
            self.branch.control_files.put('branch.conf', out_file)
 
970
            self._config.set_option(value, name, section)
756
971
        finally:
757
972
            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)