/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Robert Collins
  • Date: 2006-05-16 06:45:43 UTC
  • mto: (1713.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1714.
  • Revision ID: robertc@robertcollins.net-20060516064543-5cb7cc63047ba98b
Start on bench_add, an add benchtest.

Show diffs side-by-side

added added

removed removed

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