← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

(jelmer) Use the absolute_import feature everywhere in bzrlib,
 and add a source test to make sure it's used everywhere. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
72
72
up=pull
73
73
"""
74
74
 
 
75
from __future__ import absolute_import
 
76
 
75
77
import os
76
 
import string
77
78
import sys
78
79
 
79
 
 
80
80
import bzrlib
81
81
from bzrlib.decorators import needs_write_lock
82
82
from bzrlib.lazy_import import lazy_import
152
152
STORE_GLOBAL = 4
153
153
 
154
154
 
 
155
def signature_policy_from_unicode(signature_string):
 
156
    """Convert a string to a signing policy."""
 
157
    if signature_string.lower() == 'check-available':
 
158
        return CHECK_IF_POSSIBLE
 
159
    if signature_string.lower() == 'ignore':
 
160
        return CHECK_NEVER
 
161
    if signature_string.lower() == 'require':
 
162
        return CHECK_ALWAYS
 
163
    raise ValueError("Invalid signatures policy '%s'"
 
164
                     % signature_string)
 
165
 
 
166
 
 
167
def signing_policy_from_unicode(signature_string):
 
168
    """Convert a string to a signing policy."""
 
169
    if signature_string.lower() == 'when-required':
 
170
        return SIGN_WHEN_REQUIRED
 
171
    if signature_string.lower() == 'never':
 
172
        return SIGN_NEVER
 
173
    if signature_string.lower() == 'always':
 
174
        return SIGN_ALWAYS
 
175
    raise ValueError("Invalid signing policy '%s'"
 
176
                     % signature_string)
 
177
 
 
178
 
155
179
class ConfigObj(configobj.ConfigObj):
156
180
 
157
181
    def __init__(self, infile=None, **kwargs):
417
441
            # add) the final ','
418
442
            l = [l]
419
443
        return l
420
 
        
421
 
    def get_user_option_as_int_from_SI(self,  option_name,  default=None):
 
444
 
 
445
    def get_user_option_as_int_from_SI(self, option_name, default=None):
422
446
        """Get a generic option from a human readable size in SI units, e.g 10MB
423
 
        
 
447
 
424
448
        Accepted suffixes are K,M,G. It is case-insensitive and may be followed
425
449
        by a trailing b (i.e. Kb, MB). This is intended to be practical and not
426
450
        pedantic.
427
 
        
 
451
 
428
452
        :return Integer, expanded to its base-10 value if a proper SI unit is 
429
453
            found. If the option doesn't exist, or isn't a value in 
430
454
            SI units, return default (which defaults to None)
455
479
            except TypeError:
456
480
                val = default
457
481
        return val
458
 
        
459
482
 
 
483
    @deprecated_method(deprecated_in((2, 5, 0)))
460
484
    def gpg_signing_command(self):
461
485
        """What program should be used to sign signatures?"""
462
486
        result = self._gpg_signing_command()
492
516
        """See validate_signatures_in_log()."""
493
517
        return None
494
518
 
 
519
    @deprecated_method(deprecated_in((2, 5, 0)))
495
520
    def acceptable_keys(self):
496
521
        """Comma separated list of key patterns acceptable to 
497
522
        verify-signatures command"""
502
527
        """See acceptable_keys()."""
503
528
        return None
504
529
 
 
530
    @deprecated_method(deprecated_in((2, 5, 0)))
505
531
    def post_commit(self):
506
532
        """An ordered list of python functions to call.
507
533
 
533
559
        v = self._get_user_id()
534
560
        if v:
535
561
            return v
536
 
        v = os.environ.get('EMAIL')
537
 
        if v:
538
 
            return v.decode(osutils.get_user_encoding())
539
 
        name, email = _auto_user_id()
540
 
        if name and email:
541
 
            return '%s <%s>' % (name, email)
542
 
        elif email:
543
 
            return email
544
 
        raise errors.NoWhoami()
 
562
        return default_email()
545
563
 
546
564
    def ensure_username(self):
547
565
        """Raise errors.NoWhoami if username is not set.
550
568
        """
551
569
        self.username()
552
570
 
 
571
    @deprecated_method(deprecated_in((2, 5, 0)))
553
572
    def signature_checking(self):
554
573
        """What is the current policy for signature checking?."""
555
574
        policy = self._get_signature_checking()
557
576
            return policy
558
577
        return CHECK_IF_POSSIBLE
559
578
 
 
579
    @deprecated_method(deprecated_in((2, 5, 0)))
560
580
    def signing_policy(self):
561
581
        """What is the current policy for signature checking?."""
562
582
        policy = self._get_signing_policy()
564
584
            return policy
565
585
        return SIGN_WHEN_REQUIRED
566
586
 
 
587
    @deprecated_method(deprecated_in((2, 5, 0)))
567
588
    def signature_needed(self):
568
589
        """Is a signature needed when committing ?."""
569
590
        policy = self._get_signing_policy()
578
599
            return True
579
600
        return False
580
601
 
 
602
    @deprecated_method(deprecated_in((2, 5, 0)))
581
603
    def gpg_signing_key(self):
582
604
        """GPG user-id to sign commits"""
583
605
        key = self.get_user_option('gpg_signing_key')
868
890
        """See Config._get_signature_checking."""
869
891
        policy = self._get_user_option('check_signatures')
870
892
        if policy:
871
 
            return self._string_to_signature_policy(policy)
 
893
            return signature_policy_from_unicode(policy)
872
894
 
873
895
    def _get_signing_policy(self):
874
896
        """See Config._get_signing_policy"""
875
897
        policy = self._get_user_option('create_signatures')
876
898
        if policy:
877
 
            return self._string_to_signing_policy(policy)
 
899
            return signing_policy_from_unicode(policy)
878
900
 
879
901
    def _get_user_id(self):
880
902
        """Get the user id from the 'email' key in the current section."""
925
947
        """See Config.post_commit."""
926
948
        return self._get_user_option('post_commit')
927
949
 
928
 
    def _string_to_signature_policy(self, signature_string):
929
 
        """Convert a string to a signing policy."""
930
 
        if signature_string.lower() == 'check-available':
931
 
            return CHECK_IF_POSSIBLE
932
 
        if signature_string.lower() == 'ignore':
933
 
            return CHECK_NEVER
934
 
        if signature_string.lower() == 'require':
935
 
            return CHECK_ALWAYS
936
 
        raise errors.BzrError("Invalid signatures policy '%s'"
937
 
                              % signature_string)
938
 
 
939
 
    def _string_to_signing_policy(self, signature_string):
940
 
        """Convert a string to a signing policy."""
941
 
        if signature_string.lower() == 'when-required':
942
 
            return SIGN_WHEN_REQUIRED
943
 
        if signature_string.lower() == 'never':
944
 
            return SIGN_NEVER
945
 
        if signature_string.lower() == 'always':
946
 
            return SIGN_ALWAYS
947
 
        raise errors.BzrError("Invalid signing policy '%s'"
948
 
                              % signature_string)
949
 
 
950
950
    def _get_alias(self, value):
951
951
        try:
952
952
            return self._get_parser().get_value("ALIASES",
1396
1396
        e.g. "John Hacker <jhacker@example.com>"
1397
1397
        This is looked up in the email controlfile for the branch.
1398
1398
        """
1399
 
        try:
1400
 
            return (self.branch._transport.get_bytes("email")
1401
 
                    .decode(osutils.get_user_encoding())
1402
 
                    .rstrip("\r\n"))
1403
 
        except (errors.NoSuchFile, errors.PermissionDenied), e:
1404
 
            pass
1405
 
 
1406
1399
        return self._get_best_value('_get_user_id')
1407
1400
 
1408
1401
    def _get_change_editor(self):
1642
1635
        f.close()
1643
1636
 
1644
1637
 
 
1638
def default_email():
 
1639
    v = os.environ.get('BZR_EMAIL')
 
1640
    if v:
 
1641
        return v.decode(osutils.get_user_encoding())
 
1642
    v = os.environ.get('EMAIL')
 
1643
    if v:
 
1644
        return v.decode(osutils.get_user_encoding())
 
1645
    name, email = _auto_user_id()
 
1646
    if name and email:
 
1647
        return u'%s <%s>' % (name, email)
 
1648
    elif email:
 
1649
        return email
 
1650
    raise errors.NoWhoami()
 
1651
 
 
1652
 
 
1653
def email_from_store(unicode_str):
 
1654
    """Unlike other env vars, BZR_EMAIL takes precedence over config settings.
 
1655
 
 
1656
    Whatever comes from a config file is then overridden.
 
1657
    """
 
1658
    value = os.environ.get('BZR_EMAIL')
 
1659
    if value:
 
1660
        return value.decode(osutils.get_user_encoding())
 
1661
    return unicode_str
 
1662
 
 
1663
 
1645
1664
def _auto_user_id():
1646
1665
    """Calculate automatic user identification.
1647
1666
 
1836
1855
        :param user: login (optional)
1837
1856
 
1838
1857
        :param path: the absolute path on the server (optional)
1839
 
        
 
1858
 
1840
1859
        :param realm: the http authentication realm (optional)
1841
1860
 
1842
1861
        :return: A dict containing the matching credentials or None.
2323
2342
    """
2324
2343
 
2325
2344
    def __init__(self, name, default=None, default_from_env=None,
2326
 
                 help=None,
2327
 
                 from_unicode=None, invalid=None):
 
2345
                 help=None, from_unicode=None, invalid=None):
2328
2346
        """Build an option definition.
2329
2347
 
2330
2348
        :param name: the name used to refer to the option.
2331
2349
 
2332
2350
        :param default: the default value to use when none exist in the config
2333
2351
            stores. This is either a string that ``from_unicode`` will convert
2334
 
            into the proper type or a python object that can be stringified (so
2335
 
            only the empty list is supported for example).
 
2352
            into the proper type, a callable returning a unicode string so that
 
2353
            ``from_unicode`` can be used on the return value, or a python
 
2354
            object that can be stringified (so only the empty list is supported
 
2355
            for example).
2336
2356
 
2337
2357
        :param default_from_env: A list of environment variables which can
2338
2358
           provide a default value. 'default' will be used only if none of the
2367
2387
        elif isinstance(default, (str, unicode, bool, int, float)):
2368
2388
            # Rely on python to convert strings, booleans and integers
2369
2389
            self.default = u'%s' % (default,)
 
2390
        elif callable(default):
 
2391
            self.default = default
2370
2392
        else:
2371
2393
            # other python objects are not expected
2372
2394
            raise AssertionError('%r is not supported as a default value'
2401
2423
        for var in self.default_from_env:
2402
2424
            try:
2403
2425
                # If the env variable is defined, its value is the default one
2404
 
                value = os.environ[var]
 
2426
                value = os.environ[var].decode(osutils.get_user_encoding())
2405
2427
                break
2406
2428
            except KeyError:
2407
2429
                continue
2408
2430
        if value is None:
2409
2431
            # Otherwise, fallback to the value defined at registration
2410
 
            value = self.default
 
2432
            if callable(self.default):
 
2433
                value = self.default()
 
2434
                if not isinstance(value, unicode):
 
2435
                    raise AssertionError(
 
2436
                    'Callable default values should be unicode')
 
2437
            else:
 
2438
                value = self.default
2411
2439
        return value
2412
2440
 
2413
2441
    def get_help_text(self, additional_see_also=None, plain=True):
2433
2461
    return float(unicode_str)
2434
2462
 
2435
2463
 
2436
 
 
2437
2464
# Use a an empty dict to initialize an empty configobj avoiding all
2438
2465
# parsing and encoding checks
2439
2466
_list_converter_config = configobj.ConfigObj(
2508
2535
# Registered options in lexicographical order
2509
2536
 
2510
2537
option_registry.register(
 
2538
    Option('append_revisions_only',
 
2539
           default=None, from_unicode=bool_from_store, invalid='warning',
 
2540
           help='''\
 
2541
Whether to only append revisions to the mainline.
 
2542
 
 
2543
If this is set to true, then it is not possible to change the
 
2544
existing mainline of the branch.
 
2545
'''))
 
2546
option_registry.register(
 
2547
    Option('acceptable_keys',
 
2548
           default=None, from_unicode=list_from_store,
 
2549
           help="""\
 
2550
List of GPG key patterns which are acceptable for verification.
 
2551
"""))
 
2552
option_registry.register(
2511
2553
    Option('bzr.workingtree.worth_saving_limit', default=10,
2512
2554
           from_unicode=int_from_store,  invalid='warning',
2513
2555
           help='''\
2520
2562
a file has been touched.
2521
2563
'''))
2522
2564
option_registry.register(
 
2565
    Option('check_signatures', default=CHECK_IF_POSSIBLE,
 
2566
           from_unicode=signature_policy_from_unicode,
 
2567
           help='''\
 
2568
GPG checking policy.
 
2569
 
 
2570
Possible values: require, ignore, check-available (default)
 
2571
 
 
2572
this option will control whether bzr will require good gpg
 
2573
signatures, ignore them, or check them if they are
 
2574
present.
 
2575
'''))
 
2576
option_registry.register(
 
2577
    Option('create_signatures', default=SIGN_WHEN_REQUIRED,
 
2578
           from_unicode=signing_policy_from_unicode,
 
2579
           help='''\
 
2580
GPG Signing policy.
 
2581
 
 
2582
Possible values: always, never, when-required (default)
 
2583
 
 
2584
This option controls whether bzr will always create
 
2585
gpg signatures or not on commits.
 
2586
'''))
 
2587
option_registry.register(
2523
2588
    Option('dirstate.fdatasync', default=True,
2524
2589
           from_unicode=bool_from_store,
2525
2590
           help='''\
2549
2614
    Option('editor',
2550
2615
           help='The command called to launch an editor to enter a message.'))
2551
2616
option_registry.register(
 
2617
    Option('email', default=default_email,
 
2618
           from_unicode=email_from_store,
 
2619
           help='The users identity'))
 
2620
option_registry.register(
 
2621
    Option('gpg_signing_command',
 
2622
           default='gpg',
 
2623
           help="""\
 
2624
Program to use use for creating signatures.
 
2625
 
 
2626
This should support at least the -u and --clearsign options.
 
2627
"""))
 
2628
option_registry.register(
 
2629
    Option('gpg_signing_key',
 
2630
           default=None,
 
2631
           help="""\
 
2632
GPG key to use for signing.
 
2633
 
 
2634
This defaults to the first key associated with the users email.
 
2635
"""))
 
2636
option_registry.register(
2552
2637
    Option('ignore_missing_extensions', default=False,
2553
2638
           from_unicode=bool_from_store,
2554
2639
           help='''\
2584
2669
           help= 'Unicode encoding for output'
2585
2670
           ' (terminal encoding if not specified).'))
2586
2671
option_registry.register(
 
2672
    Option('post_commit', default=None,
 
2673
           help='''\
 
2674
Post commit functions.
 
2675
 
 
2676
An ordered list of python functions to call, separated by spaces.
 
2677
 
 
2678
Each function takes branch, rev_id as parameters.
 
2679
'''))
 
2680
option_registry.register(
2587
2681
    Option('push_strict', default=None,
2588
2682
           from_unicode=bool_from_store,
2589
2683
           help='''\
2602
2696
to physical disk.  This is somewhat slower, but means data should not be
2603
2697
lost if the machine crashes.  See also dirstate.fdatasync.
2604
2698
'''))
 
2699
 
 
2700
option_registry.register(
 
2701
    Option('selftest.timeout',
 
2702
        default='600',
 
2703
        from_unicode=int_from_store,
 
2704
        help='Abort selftest if one test takes longer than this many seconds',
 
2705
        ))
 
2706
 
2605
2707
option_registry.register(
2606
2708
    Option('send_strict', default=None,
2607
2709
           from_unicode=bool_from_store,
2756
2858
            self.options[name] = value
2757
2859
 
2758
2860
    def external_url(self):
2759
 
        # Not an url but it makes debugging easier and it never needed
 
2861
        # Not an url but it makes debugging easier and is never needed
2760
2862
        # otherwise
2761
2863
        return 'cmdline'
2762
2864
 
3148
3250
            yield self.store, section
3149
3251
 
3150
3252
 
3151
 
_option_ref_re = lazy_regex.lazy_compile('({[^{}]+})')
 
3253
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3152
3254
"""Describes an expandable option reference.
3153
3255
 
3154
3256
We want to match the most embedded reference first.
3379
3481
 
3380
3482
 
3381
3483
class GlobalStack(_CompatibleStack):
3382
 
    """Global options only stack."""
 
3484
    """Global options only stack.
 
3485
 
 
3486
    The following sections are queried:
 
3487
 
 
3488
    * command-line overrides,
 
3489
 
 
3490
    * the 'DEFAULT' section in bazaar.conf
 
3491
 
 
3492
    This stack will use the ``DEFAULT`` section in bazaar.conf as its
 
3493
    MutableSection.
 
3494
    """
3383
3495
 
3384
3496
    def __init__(self):
3385
 
        # Get a GlobalStore
3386
3497
        gstore = GlobalStore()
3387
3498
        super(GlobalStack, self).__init__(
3388
 
            [self._get_overrides, NameMatcher(gstore, 'DEFAULT').get_sections],
 
3499
            [self._get_overrides,
 
3500
             NameMatcher(gstore, 'DEFAULT').get_sections],
3389
3501
            gstore, mutable_section_id='DEFAULT')
3390
3502
 
3391
3503
 
3392
3504
class LocationStack(_CompatibleStack):
3393
 
    """Per-location options falling back to global options stack."""
 
3505
    """Per-location options falling back to global options stack.
 
3506
 
 
3507
 
 
3508
    The following sections are queried:
 
3509
 
 
3510
    * command-line overrides,
 
3511
 
 
3512
    * the sections matching ``location`` in ``locations.conf``, the order being
 
3513
      defined by the number of path components in the section glob, higher
 
3514
      numbers first (from most specific section to most generic).
 
3515
 
 
3516
    * the 'DEFAULT' section in bazaar.conf
 
3517
 
 
3518
    This stack will use the ``location`` section in locations.conf as its
 
3519
    MutableSection.
 
3520
    """
3394
3521
 
3395
3522
    def __init__(self, location):
3396
3523
        """Make a new stack for a location and global configuration.
3397
 
        
 
3524
 
3398
3525
        :param location: A URL prefix to """
3399
3526
        lstore = LocationStore()
3400
3527
        if location.startswith('file://'):
3401
3528
            location = urlutils.local_path_from_url(location)
3402
 
        matcher = LocationMatcher(lstore, location)
3403
3529
        gstore = GlobalStore()
3404
3530
        super(LocationStack, self).__init__(
3405
3531
            [self._get_overrides,
3406
 
             matcher.get_sections, NameMatcher(gstore, 'DEFAULT').get_sections],
 
3532
             LocationMatcher(lstore, location).get_sections,
 
3533
             NameMatcher(gstore, 'DEFAULT').get_sections],
3407
3534
            lstore, mutable_section_id=location)
3408
3535
 
3409
3536
 
3410
3537
class BranchStack(_CompatibleStack):
3411
 
    """Per-location options falling back to branch then global options stack."""
 
3538
    """Per-location options falling back to branch then global options stack.
 
3539
 
 
3540
    The following sections are queried:
 
3541
 
 
3542
    * command-line overrides,
 
3543
 
 
3544
    * the sections matching ``location`` in ``locations.conf``, the order being
 
3545
      defined by the number of path components in the section glob, higher
 
3546
      numbers first (from most specific section to most generic),
 
3547
 
 
3548
    * the no-name section in branch.conf,
 
3549
 
 
3550
    * the ``DEFAULT`` section in ``bazaar.conf``.
 
3551
 
 
3552
    This stack will use the no-name section in ``branch.conf`` as its
 
3553
    MutableSection.
 
3554
    """
3412
3555
 
3413
3556
    def __init__(self, branch):
 
3557
        lstore = LocationStore()
3414
3558
        bstore = branch._get_config_store()
3415
 
        lstore = LocationStore()
3416
 
        matcher = LocationMatcher(lstore, branch.base)
3417
3559
        gstore = GlobalStore()
3418
3560
        super(BranchStack, self).__init__(
3419
3561
            [self._get_overrides,
3420
 
             matcher.get_sections, bstore.get_sections,
 
3562
             LocationMatcher(lstore, branch.base).get_sections,
 
3563
             NameMatcher(bstore, None).get_sections,
3421
3564
             NameMatcher(gstore, 'DEFAULT').get_sections],
3422
3565
            bstore)
3423
3566
        self.branch = branch
3433
3576
    def __init__(self, bzrdir):
3434
3577
        cstore = bzrdir._get_config_store()
3435
3578
        super(RemoteControlStack, self).__init__(
3436
 
            [cstore.get_sections],
 
3579
            [NameMatcher(cstore, None).get_sections],
3437
3580
            cstore)
3438
3581
        self.bzrdir = bzrdir
3439
3582
 
3448
3591
    def __init__(self, branch):
3449
3592
        bstore = branch._get_config_store()
3450
3593
        super(RemoteBranchStack, self).__init__(
3451
 
            [bstore.get_sections],
 
3594
            [NameMatcher(bstore, None).get_sections],
3452
3595
            bstore)
3453
3596
        self.branch = branch
3454
3597
 
3614
3757
# ready-to-use store or stack.  Plugins that define new store/stacks can also
3615
3758
# register themselves here to be tested against the tests defined in
3616
3759
# bzrlib.tests.test_config. Note that the builder can be called multiple times
3617
 
# for the same tests.
 
3760
# for the same test.
3618
3761
 
3619
3762
# The registered object should be a callable receiving a test instance
3620
3763
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store