~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Aaron Bentley
  • Date: 2008-10-11 17:52:14 UTC
  • mto: This revision was merged to the branch mainline in revision 3823.
  • Revision ID: aaron@aaronbentley.com-20081011175214-85vfxt61753sp404
Make status nicer by not shelving lines for files not being changed

Show diffs side-by-side

added added

removed removed

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