← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-06 22:44:57 UTC
  • mfrom: (6436 +trunk)
  • mto: (6437.3.11 2.5)
  • mto: This revision was merged to the branch mainline in revision 6444.
  • Revision ID: jelmer@samba.org-20120106224457-re0pcy0fz31xob77
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2012 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#            and others
4
4
#
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
    @deprecated_method(deprecated_in((2, 5, 0)))
 
446
    def get_user_option_as_int_from_SI(self, option_name, default=None):
422
447
        """Get a generic option from a human readable size in SI units, e.g 10MB
423
 
        
 
448
 
424
449
        Accepted suffixes are K,M,G. It is case-insensitive and may be followed
425
450
        by a trailing b (i.e. Kb, MB). This is intended to be practical and not
426
451
        pedantic.
427
 
        
 
452
 
428
453
        :return Integer, expanded to its base-10 value if a proper SI unit is 
429
454
            found. If the option doesn't exist, or isn't a value in 
430
455
            SI units, return default (which defaults to None)
455
480
            except TypeError:
456
481
                val = default
457
482
        return val
458
 
        
459
483
 
 
484
    @deprecated_method(deprecated_in((2, 5, 0)))
460
485
    def gpg_signing_command(self):
461
486
        """What program should be used to sign signatures?"""
462
487
        result = self._gpg_signing_command()
468
493
        """See gpg_signing_command()."""
469
494
        return None
470
495
 
 
496
    @deprecated_method(deprecated_in((2, 5, 0)))
471
497
    def log_format(self):
472
498
        """What log format should be used"""
473
499
        result = self._log_format()
492
518
        """See validate_signatures_in_log()."""
493
519
        return None
494
520
 
 
521
    @deprecated_method(deprecated_in((2, 5, 0)))
495
522
    def acceptable_keys(self):
496
523
        """Comma separated list of key patterns acceptable to 
497
524
        verify-signatures command"""
502
529
        """See acceptable_keys()."""
503
530
        return None
504
531
 
 
532
    @deprecated_method(deprecated_in((2, 5, 0)))
505
533
    def post_commit(self):
506
534
        """An ordered list of python functions to call.
507
535
 
533
561
        v = self._get_user_id()
534
562
        if v:
535
563
            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()
 
564
        return default_email()
545
565
 
546
566
    def ensure_username(self):
547
567
        """Raise errors.NoWhoami if username is not set.
550
570
        """
551
571
        self.username()
552
572
 
 
573
    @deprecated_method(deprecated_in((2, 5, 0)))
553
574
    def signature_checking(self):
554
575
        """What is the current policy for signature checking?."""
555
576
        policy = self._get_signature_checking()
557
578
            return policy
558
579
        return CHECK_IF_POSSIBLE
559
580
 
 
581
    @deprecated_method(deprecated_in((2, 5, 0)))
560
582
    def signing_policy(self):
561
583
        """What is the current policy for signature checking?."""
562
584
        policy = self._get_signing_policy()
564
586
            return policy
565
587
        return SIGN_WHEN_REQUIRED
566
588
 
 
589
    @deprecated_method(deprecated_in((2, 5, 0)))
567
590
    def signature_needed(self):
568
591
        """Is a signature needed when committing ?."""
569
592
        policy = self._get_signing_policy()
578
601
            return True
579
602
        return False
580
603
 
 
604
    @deprecated_method(deprecated_in((2, 5, 0)))
581
605
    def gpg_signing_key(self):
582
606
        """GPG user-id to sign commits"""
583
607
        key = self.get_user_option('gpg_signing_key')
868
892
        """See Config._get_signature_checking."""
869
893
        policy = self._get_user_option('check_signatures')
870
894
        if policy:
871
 
            return self._string_to_signature_policy(policy)
 
895
            return signature_policy_from_unicode(policy)
872
896
 
873
897
    def _get_signing_policy(self):
874
898
        """See Config._get_signing_policy"""
875
899
        policy = self._get_user_option('create_signatures')
876
900
        if policy:
877
 
            return self._string_to_signing_policy(policy)
 
901
            return signing_policy_from_unicode(policy)
878
902
 
879
903
    def _get_user_id(self):
880
904
        """Get the user id from the 'email' key in the current section."""
925
949
        """See Config.post_commit."""
926
950
        return self._get_user_option('post_commit')
927
951
 
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
952
    def _get_alias(self, value):
951
953
        try:
952
954
            return self._get_parser().get_value("ALIASES",
1635
1637
        f.close()
1636
1638
 
1637
1639
 
 
1640
def default_email():
 
1641
    v = os.environ.get('BZR_EMAIL')
 
1642
    if v:
 
1643
        return v.decode(osutils.get_user_encoding())
 
1644
    v = os.environ.get('EMAIL')
 
1645
    if v:
 
1646
        return v.decode(osutils.get_user_encoding())
 
1647
    name, email = _auto_user_id()
 
1648
    if name and email:
 
1649
        return u'%s <%s>' % (name, email)
 
1650
    elif email:
 
1651
        return email
 
1652
    raise errors.NoWhoami()
 
1653
 
 
1654
 
1638
1655
def _auto_user_id():
1639
1656
    """Calculate automatic user identification.
1640
1657
 
1829
1846
        :param user: login (optional)
1830
1847
 
1831
1848
        :param path: the absolute path on the server (optional)
1832
 
        
 
1849
 
1833
1850
        :param realm: the http authentication realm (optional)
1834
1851
 
1835
1852
        :return: A dict containing the matching credentials or None.
2315
2332
    encoutered, in which config files it can be stored.
2316
2333
    """
2317
2334
 
2318
 
    def __init__(self, name, default=None, default_from_env=None,
2319
 
                 help=None,
2320
 
                 from_unicode=None, invalid=None):
 
2335
    def __init__(self, name, override_from_env=None,
 
2336
                 default=None, default_from_env=None,
 
2337
                 help=None, from_unicode=None, invalid=None, unquote=True):
2321
2338
        """Build an option definition.
2322
2339
 
2323
2340
        :param name: the name used to refer to the option.
2324
2341
 
 
2342
        :param override_from_env: A list of environment variables which can
 
2343
           provide override any configuration setting.
 
2344
 
2325
2345
        :param default: the default value to use when none exist in the config
2326
2346
            stores. This is either a string that ``from_unicode`` will convert
2327
2347
            into the proper type, a callable returning a unicode string so that
2345
2365
            TypeError. Accepted values are: None (ignore invalid values),
2346
2366
            'warning' (emit a warning), 'error' (emit an error message and
2347
2367
            terminates).
 
2368
 
 
2369
        :param unquote: should the unicode value be unquoted before conversion.
 
2370
           This should be used only when the store providing the values cannot
 
2371
           safely unquote them (see http://pad.lv/906897). It is provided so
 
2372
           daughter classes can handle the quoting themselves.
2348
2373
        """
 
2374
        if override_from_env is None:
 
2375
            override_from_env = []
2349
2376
        if default_from_env is None:
2350
2377
            default_from_env = []
2351
2378
        self.name = name
 
2379
        self.override_from_env = override_from_env
2352
2380
        # Convert the default value to a unicode string so all values are
2353
2381
        # strings internally before conversion (via from_unicode) is attempted.
2354
2382
        if default is None:
2371
2399
        self.default_from_env = default_from_env
2372
2400
        self.help = help
2373
2401
        self.from_unicode = from_unicode
 
2402
        self.unquote = unquote
2374
2403
        if invalid and invalid not in ('warning', 'error'):
2375
2404
            raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2376
2405
        self.invalid = invalid
2377
2406
 
2378
 
    def convert_from_unicode(self, unicode_value):
 
2407
    def convert_from_unicode(self, store, unicode_value):
 
2408
        if self.unquote and store is not None and unicode_value is not None:
 
2409
            unicode_value = store.unquote(unicode_value)
2379
2410
        if self.from_unicode is None or unicode_value is None:
2380
2411
            # Don't convert or nothing to convert
2381
2412
            return unicode_value
2393
2424
                raise errors.ConfigOptionValueError(self.name, unicode_value)
2394
2425
        return converted
2395
2426
 
 
2427
    def get_override(self):
 
2428
        value = None
 
2429
        for var in self.override_from_env:
 
2430
            try:
 
2431
                # If the env variable is defined, its value takes precedence
 
2432
                value = os.environ[var].decode(osutils.get_user_encoding())
 
2433
                break
 
2434
            except KeyError:
 
2435
                continue
 
2436
        return value
 
2437
 
2396
2438
    def get_default(self):
2397
2439
        value = None
2398
2440
        for var in self.default_from_env:
2399
2441
            try:
2400
2442
                # If the env variable is defined, its value is the default one
2401
 
                value = os.environ[var]
 
2443
                value = os.environ[var].decode(osutils.get_user_encoding())
2402
2444
                break
2403
2445
            except KeyError:
2404
2446
                continue
2432
2474
    return int(unicode_str)
2433
2475
 
2434
2476
 
 
2477
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
 
2478
 
 
2479
def int_SI_from_store(unicode_str):
 
2480
    """Convert a human readable size in SI units, e.g 10MB into an integer.
 
2481
 
 
2482
    Accepted suffixes are K,M,G. It is case-insensitive and may be followed
 
2483
    by a trailing b (i.e. Kb, MB). This is intended to be practical and not
 
2484
    pedantic.
 
2485
 
 
2486
    :return Integer, expanded to its base-10 value if a proper SI unit is 
 
2487
        found, None otherwise.
 
2488
    """
 
2489
    regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
 
2490
    p = re.compile(regexp, re.IGNORECASE)
 
2491
    m = p.match(unicode_str)
 
2492
    val = None
 
2493
    if m is not None:
 
2494
        val, _, unit = m.groups()
 
2495
        val = int(val)
 
2496
        if unit:
 
2497
            try:
 
2498
                coeff = _unit_suffixes[unit.upper()]
 
2499
            except KeyError:
 
2500
                raise ValueError(gettext('{0} is not an SI unit.').format(unit))
 
2501
            val *= coeff
 
2502
    return val
 
2503
 
 
2504
 
2435
2505
def float_from_store(unicode_str):
2436
2506
    return float(unicode_str)
2437
2507
 
2438
2508
 
2439
 
 
2440
2509
# Use a an empty dict to initialize an empty configobj avoiding all
2441
2510
# parsing and encoding checks
2442
2511
_list_converter_config = configobj.ConfigObj(
2443
2512
    {}, encoding='utf-8', list_values=True, interpolation=False)
2444
2513
 
2445
2514
 
2446
 
def list_from_store(unicode_str):
2447
 
    if not isinstance(unicode_str, basestring):
2448
 
        raise TypeError
2449
 
    # Now inject our string directly as unicode. All callers got their value
2450
 
    # from configobj, so values that need to be quoted are already properly
2451
 
    # quoted.
2452
 
    _list_converter_config.reset()
2453
 
    _list_converter_config._parse([u"list=%s" % (unicode_str,)])
2454
 
    maybe_list = _list_converter_config['list']
2455
 
    # ConfigObj return '' instead of u''. Use 'str' below to catch all cases.
2456
 
    if isinstance(maybe_list, basestring):
2457
 
        if maybe_list:
2458
 
            # A single value, most probably the user forgot (or didn't care to
2459
 
            # add) the final ','
2460
 
            l = [maybe_list]
 
2515
class ListOption(Option):
 
2516
 
 
2517
    def __init__(self, name, default=None, default_from_env=None,
 
2518
                 help=None, invalid=None):
 
2519
        """A list Option definition.
 
2520
 
 
2521
        This overrides the base class so the conversion from a unicode string
 
2522
        can take quoting into account.
 
2523
        """
 
2524
        super(ListOption, self).__init__(
 
2525
            name, default=default, default_from_env=default_from_env,
 
2526
            from_unicode=self.from_unicode, help=help,
 
2527
            invalid=invalid, unquote=False)
 
2528
 
 
2529
    def from_unicode(self, unicode_str):
 
2530
        if not isinstance(unicode_str, basestring):
 
2531
            raise TypeError
 
2532
        # Now inject our string directly as unicode. All callers got their
 
2533
        # value from configobj, so values that need to be quoted are already
 
2534
        # properly quoted.
 
2535
        _list_converter_config.reset()
 
2536
        _list_converter_config._parse([u"list=%s" % (unicode_str,)])
 
2537
        maybe_list = _list_converter_config['list']
 
2538
        if isinstance(maybe_list, basestring):
 
2539
            if maybe_list:
 
2540
                # A single value, most probably the user forgot (or didn't care
 
2541
                # to add) the final ','
 
2542
                l = [maybe_list]
 
2543
            else:
 
2544
                # The empty string, convert to empty list
 
2545
                l = []
2461
2546
        else:
2462
 
            # The empty string, convert to empty list
2463
 
            l = []
2464
 
    else:
2465
 
        # We rely on ConfigObj providing us with a list already
2466
 
        l = maybe_list
2467
 
    return l
 
2547
            # We rely on ConfigObj providing us with a list already
 
2548
            l = maybe_list
 
2549
        return l
2468
2550
 
2469
2551
 
2470
2552
class OptionRegistry(registry.Registry):
2511
2593
# Registered options in lexicographical order
2512
2594
 
2513
2595
option_registry.register(
 
2596
    Option('append_revisions_only',
 
2597
           default=None, from_unicode=bool_from_store, invalid='warning',
 
2598
           help='''\
 
2599
Whether to only append revisions to the mainline.
 
2600
 
 
2601
If this is set to true, then it is not possible to change the
 
2602
existing mainline of the branch.
 
2603
'''))
 
2604
option_registry.register(
 
2605
    ListOption('acceptable_keys',
 
2606
           default=None,
 
2607
           help="""\
 
2608
List of GPG key patterns which are acceptable for verification.
 
2609
"""))
 
2610
option_registry.register(
 
2611
    Option('add.maximum_file_size',
 
2612
           default=u'20MB', from_unicode=int_SI_from_store,
 
2613
           help="""\
 
2614
Size above which files should be added manually.
 
2615
 
 
2616
Files below this size are added automatically when using ``bzr add`` without
 
2617
arguments.
 
2618
 
 
2619
A negative value means disable the size check.
 
2620
"""))
 
2621
option_registry.register(
 
2622
    Option('bound',
 
2623
           default=None, from_unicode=bool_from_store,
 
2624
           help="""\
 
2625
Is the branch bound to ``bound_location``.
 
2626
 
 
2627
If set to "True", the branch should act as a checkout, and push each commit to
 
2628
the bound_location.  This option is normally set by ``bind``/``unbind``.
 
2629
 
 
2630
See also: bound_location.
 
2631
"""))
 
2632
option_registry.register(
 
2633
    Option('bound_location',
 
2634
           default=None,
 
2635
           help="""\
 
2636
The location that commits should go to when acting as a checkout.
 
2637
 
 
2638
This option is normally set by ``bind``.
 
2639
 
 
2640
See also: bound.
 
2641
"""))
 
2642
option_registry.register(
 
2643
    Option('branch.fetch_tags', default=False,  from_unicode=bool_from_store,
 
2644
           help="""\
 
2645
Whether revisions associated with tags should be fetched.
 
2646
"""))
 
2647
option_registry.register(
2514
2648
    Option('bzr.workingtree.worth_saving_limit', default=10,
2515
2649
           from_unicode=int_from_store,  invalid='warning',
2516
2650
           help='''\
2523
2657
a file has been touched.
2524
2658
'''))
2525
2659
option_registry.register(
 
2660
    Option('check_signatures', default=CHECK_IF_POSSIBLE,
 
2661
           from_unicode=signature_policy_from_unicode,
 
2662
           help='''\
 
2663
GPG checking policy.
 
2664
 
 
2665
Possible values: require, ignore, check-available (default)
 
2666
 
 
2667
this option will control whether bzr will require good gpg
 
2668
signatures, ignore them, or check them if they are
 
2669
present.
 
2670
'''))
 
2671
option_registry.register(
 
2672
    Option('child_submit_format',
 
2673
           help='''The preferred format of submissions to this branch.'''))
 
2674
option_registry.register(
 
2675
    Option('child_submit_to',
 
2676
           help='''Where submissions to this branch are mailed to.'''))
 
2677
option_registry.register(
 
2678
    Option('create_signatures', default=SIGN_WHEN_REQUIRED,
 
2679
           from_unicode=signing_policy_from_unicode,
 
2680
           help='''\
 
2681
GPG Signing policy.
 
2682
 
 
2683
Possible values: always, never, when-required (default)
 
2684
 
 
2685
This option controls whether bzr will always create
 
2686
gpg signatures or not on commits.
 
2687
'''))
 
2688
option_registry.register(
2526
2689
    Option('dirstate.fdatasync', default=True,
2527
2690
           from_unicode=bool_from_store,
2528
2691
           help='''\
2533
2696
should not be lost if the machine crashes.  See also repository.fdatasync.
2534
2697
'''))
2535
2698
option_registry.register(
2536
 
    Option('debug_flags', default=[], from_unicode=list_from_store,
 
2699
    ListOption('debug_flags', default=[],
2537
2700
           help='Debug flags to activate.'))
2538
2701
option_registry.register(
2539
2702
    Option('default_format', default='2a',
2552
2715
    Option('editor',
2553
2716
           help='The command called to launch an editor to enter a message.'))
2554
2717
option_registry.register(
 
2718
    Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
 
2719
           help='The users identity'))
 
2720
option_registry.register(
 
2721
    Option('gpg_signing_command',
 
2722
           default='gpg',
 
2723
           help="""\
 
2724
Program to use use for creating signatures.
 
2725
 
 
2726
This should support at least the -u and --clearsign options.
 
2727
"""))
 
2728
option_registry.register(
 
2729
    Option('gpg_signing_key',
 
2730
           default=None,
 
2731
           help="""\
 
2732
GPG key to use for signing.
 
2733
 
 
2734
This defaults to the first key associated with the users email.
 
2735
"""))
 
2736
option_registry.register(
2555
2737
    Option('ignore_missing_extensions', default=False,
2556
2738
           from_unicode=bool_from_store,
2557
2739
           help='''\
2587
2769
           help= 'Unicode encoding for output'
2588
2770
           ' (terminal encoding if not specified).'))
2589
2771
option_registry.register(
 
2772
    Option('parent_location',
 
2773
           default=None,
 
2774
           help="""\
 
2775
The location of the default branch for pull or merge.
 
2776
 
 
2777
This option is normally set when creating a branch, the first ``pull`` or by
 
2778
``pull --remember``.
 
2779
"""))
 
2780
option_registry.register(
 
2781
    Option('post_commit', default=None,
 
2782
           help='''\
 
2783
Post commit functions.
 
2784
 
 
2785
An ordered list of python functions to call, separated by spaces.
 
2786
 
 
2787
Each function takes branch, rev_id as parameters.
 
2788
'''))
 
2789
option_registry.register(
 
2790
    Option('public_branch',
 
2791
           default=None,
 
2792
           help="""\
 
2793
A publically-accessible version of this branch.
 
2794
 
 
2795
This implies that the branch setting this option is not publically-accessible.
 
2796
Used and set by ``bzr send``.
 
2797
"""))
 
2798
option_registry.register(
 
2799
    Option('push_location',
 
2800
           default=None,
 
2801
           help="""\
 
2802
The location of the default branch for push.
 
2803
 
 
2804
This option is normally set by the first ``push`` or ``push --remember``.
 
2805
"""))
 
2806
option_registry.register(
2590
2807
    Option('push_strict', default=None,
2591
2808
           from_unicode=bool_from_store,
2592
2809
           help='''\
2605
2822
to physical disk.  This is somewhat slower, but means data should not be
2606
2823
lost if the machine crashes.  See also dirstate.fdatasync.
2607
2824
'''))
2608
 
 
 
2825
option_registry.register_lazy('smtp_server',
 
2826
    'bzrlib.smtp_connection', 'smtp_server')
 
2827
option_registry.register_lazy('smtp_password',
 
2828
    'bzrlib.smtp_connection', 'smtp_password')
 
2829
option_registry.register_lazy('smtp_username',
 
2830
    'bzrlib.smtp_connection', 'smtp_username')
2609
2831
option_registry.register(
2610
2832
    Option('selftest.timeout',
2611
2833
        default='600',
2620
2842
The default value for ``send --strict``.
2621
2843
 
2622
2844
If present, defines the ``--strict`` option default value for checking
2623
 
uncommitted changes before pushing.
 
2845
uncommitted changes before sending a bundle.
2624
2846
'''))
2625
2847
 
2626
2848
option_registry.register(
2628
2850
           default=300.0, from_unicode=float_from_store,
2629
2851
           help="If we wait for a new request from a client for more than"
2630
2852
                " X seconds, consider the client idle, and hangup."))
 
2853
option_registry.register(
 
2854
    Option('stacked_on_location',
 
2855
           default=None,
 
2856
           help="""The location where this branch is stacked on."""))
 
2857
option_registry.register(
 
2858
    Option('submit_branch',
 
2859
           default=None,
 
2860
           help="""\
 
2861
The branch you intend to submit your current work to.
 
2862
 
 
2863
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
 
2864
by the ``submit:`` revision spec.
 
2865
"""))
 
2866
option_registry.register(
 
2867
    Option('submit_to',
 
2868
           help='''Where submissions from this branch are mailed to.'''))
2631
2869
 
2632
2870
 
2633
2871
class Section(object):
2657
2895
 
2658
2896
_NewlyCreatedOption = object()
2659
2897
"""Was the option created during the MutableSection lifetime"""
 
2898
_DeletedOption = object()
 
2899
"""Was the option deleted during the MutableSection lifetime"""
2660
2900
 
2661
2901
 
2662
2902
class MutableSection(Section):
2664
2904
 
2665
2905
    def __init__(self, section_id, options):
2666
2906
        super(MutableSection, self).__init__(section_id, options)
2667
 
        self.orig = {}
 
2907
        self.reset_changes()
2668
2908
 
2669
2909
    def set(self, name, value):
2670
2910
        if name not in self.options:
2679
2919
            self.orig[name] = self.get(name, None)
2680
2920
        del self.options[name]
2681
2921
 
 
2922
    def reset_changes(self):
 
2923
        self.orig = {}
 
2924
 
 
2925
    def apply_changes(self, dirty, store):
 
2926
        """Apply option value changes.
 
2927
 
 
2928
        ``self`` has been reloaded from the persistent storage. ``dirty``
 
2929
        contains the changes made since the previous loading.
 
2930
 
 
2931
        :param dirty: the mutable section containing the changes.
 
2932
 
 
2933
        :param store: the store containing the section
 
2934
        """
 
2935
        for k, expected in dirty.orig.iteritems():
 
2936
            actual = dirty.get(k, _DeletedOption)
 
2937
            reloaded = self.get(k, _NewlyCreatedOption)
 
2938
            if actual is _DeletedOption:
 
2939
                if k in self.options:
 
2940
                    self.remove(k)
 
2941
            else:
 
2942
                self.set(k, actual)
 
2943
            # Report concurrent updates in an ad-hoc way. This should only
 
2944
            # occurs when different processes try to update the same option
 
2945
            # which is not supported (as in: the config framework is not meant
 
2946
            # to be used a sharing mechanism).
 
2947
            if expected != reloaded:
 
2948
                if actual is _DeletedOption:
 
2949
                    actual = '<DELETED>'
 
2950
                if reloaded is _NewlyCreatedOption:
 
2951
                    reloaded = '<CREATED>'
 
2952
                if expected is _NewlyCreatedOption:
 
2953
                    expected = '<CREATED>'
 
2954
                # Someone changed the value since we get it from the persistent
 
2955
                # storage.
 
2956
                trace.warning(gettext(
 
2957
                        "Option {0} in section {1} of {2} was changed"
 
2958
                        " from {3} to {4}. The {5} value will be saved.".format(
 
2959
                            k, self.id, store.external_url(), expected,
 
2960
                            reloaded, actual)))
 
2961
        # No need to keep track of these changes
 
2962
        self.reset_changes()
 
2963
 
2682
2964
 
2683
2965
class Store(object):
2684
2966
    """Abstract interface to persistent storage for configuration options."""
2686
2968
    readonly_section_class = Section
2687
2969
    mutable_section_class = MutableSection
2688
2970
 
 
2971
    def __init__(self):
 
2972
        # Which sections need to be saved
 
2973
        self.dirty_sections = []
 
2974
 
2689
2975
    def is_loaded(self):
2690
2976
        """Returns True if the Store has been loaded.
2691
2977
 
2714
3000
        """
2715
3001
        raise NotImplementedError(self.unload)
2716
3002
 
 
3003
    def quote(self, value):
 
3004
        """Quote a configuration option value for storing purposes.
 
3005
 
 
3006
        This allows Stacks to present values as they will be stored.
 
3007
        """
 
3008
        return value
 
3009
 
 
3010
    def unquote(self, value):
 
3011
        """Unquote a configuration option value into unicode.
 
3012
 
 
3013
        The received value is quoted as stored.
 
3014
        """
 
3015
        return value
 
3016
 
2717
3017
    def save(self):
2718
3018
        """Saves the Store to persistent storage."""
2719
3019
        raise NotImplementedError(self.save)
2720
3020
 
 
3021
    def _need_saving(self):
 
3022
        for s in self.dirty_sections:
 
3023
            if s.orig:
 
3024
                # At least one dirty section contains a modification
 
3025
                return True
 
3026
        return False
 
3027
 
 
3028
    def apply_changes(self, dirty_sections):
 
3029
        """Apply changes from dirty sections while checking for coherency.
 
3030
 
 
3031
        The Store content is discarded and reloaded from persistent storage to
 
3032
        acquire up-to-date values.
 
3033
 
 
3034
        Dirty sections are MutableSection which kept track of the value they
 
3035
        are expected to update.
 
3036
        """
 
3037
        # We need an up-to-date version from the persistent storage, unload the
 
3038
        # store. The reload will occur when needed (triggered by the first
 
3039
        # get_mutable_section() call below.
 
3040
        self.unload()
 
3041
        # Apply the changes from the preserved dirty sections
 
3042
        for dirty in dirty_sections:
 
3043
            clean = self.get_mutable_section(dirty.id)
 
3044
            clean.apply_changes(dirty, self)
 
3045
        # Everything is clean now
 
3046
        self.dirty_sections = []
 
3047
 
 
3048
    def save_changes(self):
 
3049
        """Saves the Store to persistent storage if changes occurred.
 
3050
 
 
3051
        Apply the changes recorded in the mutable sections to a store content
 
3052
        refreshed from persistent storage.
 
3053
        """
 
3054
        raise NotImplementedError(self.save_changes)
 
3055
 
2721
3056
    def external_url(self):
2722
3057
        raise NotImplementedError(self.external_url)
2723
3058
 
2749
3084
        if opts is None:
2750
3085
            opts = {}
2751
3086
        self.options = {}
 
3087
        self.id = 'cmdline'
2752
3088
 
2753
3089
    def _reset(self):
2754
3090
        # The dict should be cleared but not replaced so it can be shared.
2772
3108
        return 'cmdline'
2773
3109
 
2774
3110
    def get_sections(self):
2775
 
        yield self,  self.readonly_section_class('cmdline_overrides',
2776
 
                                                 self.options)
 
3111
        yield self,  self.readonly_section_class(None, self.options)
2777
3112
 
2778
3113
 
2779
3114
class IniFileStore(Store):
2798
3133
 
2799
3134
    def unload(self):
2800
3135
        self._config_obj = None
 
3136
        self.dirty_sections = []
2801
3137
 
2802
3138
    def _load_content(self):
2803
3139
        """Load the config file bytes.
2844
3180
        except UnicodeDecodeError:
2845
3181
            raise errors.ConfigContentError(self.external_url())
2846
3182
 
 
3183
    def save_changes(self):
 
3184
        if not self.is_loaded():
 
3185
            # Nothing to save
 
3186
            return
 
3187
        if not self._need_saving():
 
3188
            return
 
3189
        # Preserve the current version
 
3190
        current = self._config_obj
 
3191
        dirty_sections = list(self.dirty_sections)
 
3192
        self.apply_changes(dirty_sections)
 
3193
        # Save to the persistent storage
 
3194
        self.save()
 
3195
 
2847
3196
    def save(self):
2848
3197
        if not self.is_loaded():
2849
3198
            # Nothing to save
2884
3233
            section = self._config_obj
2885
3234
        else:
2886
3235
            section = self._config_obj.setdefault(section_id, {})
2887
 
        return self.mutable_section_class(section_id, section)
 
3236
        mutable_section = self.mutable_section_class(section_id, section)
 
3237
        # All mutable sections can become dirty
 
3238
        self.dirty_sections.append(mutable_section)
 
3239
        return mutable_section
 
3240
 
 
3241
    def quote(self, value):
 
3242
        try:
 
3243
            # configobj conflates automagical list values and quoting
 
3244
            self._config_obj.list_values = True
 
3245
            return self._config_obj._quote(value)
 
3246
        finally:
 
3247
            self._config_obj.list_values = False
 
3248
 
 
3249
    def unquote(self, value):
 
3250
        if value and isinstance(value, basestring):
 
3251
            # _unquote doesn't handle None nor empty strings nor anything that
 
3252
            # is not a string, really.
 
3253
            value = self._config_obj._unquote(value)
 
3254
        return value
2888
3255
 
2889
3256
 
2890
3257
class TransportIniFileStore(IniFileStore):
3024
3391
        super(ControlStore, self).__init__(bzrdir.transport,
3025
3392
                                          'control.conf',
3026
3393
                                           lock_dir_name='branch_lock')
 
3394
        self.id = 'control'
3027
3395
 
3028
3396
 
3029
3397
class SectionMatcher(object):
3216
3584
        if expand is None:
3217
3585
            expand = _get_expand_default_value()
3218
3586
        value = None
3219
 
        # Ensuring lazy loading is achieved by delaying section matching (which
3220
 
        # implies querying the persistent storage) until it can't be avoided
3221
 
        # anymore by using callables to describe (possibly empty) section
3222
 
        # lists.
3223
 
        for sections in self.sections_def:
3224
 
            for store, section in sections():
3225
 
                value = section.get(name)
3226
 
                if value is not None:
3227
 
                    break
3228
 
            if value is not None:
3229
 
                break
 
3587
        found_store = None # Where the option value has been found
3230
3588
        # If the option is registered, it may provide additional info about
3231
3589
        # value handling
3232
3590
        try:
3234
3592
        except KeyError:
3235
3593
            # Not registered
3236
3594
            opt = None
 
3595
 
3237
3596
        def expand_and_convert(val):
3238
 
            # This may need to be called twice if the value is None or ends up
3239
 
            # being None during expansion or conversion.
 
3597
            # This may need to be called in different contexts if the value is
 
3598
            # None or ends up being None during expansion or conversion.
3240
3599
            if val is not None:
3241
3600
                if expand:
3242
3601
                    if isinstance(val, basestring):
3245
3604
                        trace.warning('Cannot expand "%s":'
3246
3605
                                      ' %s does not support option expansion'
3247
3606
                                      % (name, type(val)))
3248
 
                if opt is not None:
3249
 
                    val = opt.convert_from_unicode(val)
 
3607
                if opt is None:
 
3608
                    val = found_store.unquote(val)
 
3609
                else:
 
3610
                    val = opt.convert_from_unicode(found_store, val)
3250
3611
            return val
3251
 
        value = expand_and_convert(value)
3252
 
        if opt is not None and value is None:
3253
 
            # If the option is registered, it may provide a default value
3254
 
            value = opt.get_default()
3255
 
            value = expand_and_convert(value)
 
3612
 
 
3613
        # First of all, check if the environment can override the configuration
 
3614
        # value
 
3615
        if opt is not None and opt.override_from_env:
 
3616
            value = opt.get_override()
 
3617
            value = expand_and_convert(value)
 
3618
        if value is None:
 
3619
            # Ensuring lazy loading is achieved by delaying section matching
 
3620
            # (which implies querying the persistent storage) until it can't be
 
3621
            # avoided anymore by using callables to describe (possibly empty)
 
3622
            # section lists.
 
3623
            for sections in self.sections_def:
 
3624
                for store, section in sections():
 
3625
                    value = section.get(name)
 
3626
                    if value is not None:
 
3627
                        found_store = store
 
3628
                        break
 
3629
                if value is not None:
 
3630
                    break
 
3631
            value = expand_and_convert(value)
 
3632
            if opt is not None and value is None:
 
3633
                # If the option is registered, it may provide a default value
 
3634
                value = opt.get_default()
 
3635
                value = expand_and_convert(value)
3256
3636
        for hook in ConfigHooks['get']:
3257
3637
            hook(self, name, value)
3258
3638
        return value
3330
3710
        or deleting an option. In practice the store will often be loaded but
3331
3711
        this helps catching some programming errors.
3332
3712
        """
3333
 
        section = self.store.get_mutable_section(self.mutable_section_id)
3334
 
        return section
 
3713
        store = self.store
 
3714
        section = store.get_mutable_section(self.mutable_section_id)
 
3715
        return store, section
3335
3716
 
3336
3717
    def set(self, name, value):
3337
3718
        """Set a new value for the option."""
3338
 
        section = self._get_mutable_section()
3339
 
        section.set(name, value)
 
3719
        store, section = self._get_mutable_section()
 
3720
        section.set(name, store.quote(value))
3340
3721
        for hook in ConfigHooks['set']:
3341
3722
            hook(self, name, value)
3342
3723
 
3343
3724
    def remove(self, name):
3344
3725
        """Remove an existing option."""
3345
 
        section = self._get_mutable_section()
 
3726
        _, section = self._get_mutable_section()
3346
3727
        section.remove(name)
3347
3728
        for hook in ConfigHooks['remove']:
3348
3729
            hook(self, name)
3358
3739
        return []
3359
3740
 
3360
3741
 
 
3742
class MemoryStack(Stack):
 
3743
    """A configuration stack defined from a string.
 
3744
 
 
3745
    This is mainly intended for tests and requires no disk resources.
 
3746
    """
 
3747
 
 
3748
    def __init__(self, content=None):
 
3749
        """Create an in-memory stack from a given content.
 
3750
 
 
3751
        It uses a single store based on configobj and support reading and
 
3752
        writing options.
 
3753
 
 
3754
        :param content: The initial content of the store. If None, the store is
 
3755
            not loaded and ``_load_from_string`` can and should be used if
 
3756
            needed.
 
3757
        """
 
3758
        store = IniFileStore()
 
3759
        if content is not None:
 
3760
            store._load_from_string(content)
 
3761
        super(MemoryStack, self).__init__(
 
3762
            [store.get_sections], store)
 
3763
 
 
3764
 
3361
3765
class _CompatibleStack(Stack):
3362
3766
    """Place holder for compatibility with previous design.
3363
3767
 
3390
3794
 
3391
3795
 
3392
3796
class GlobalStack(_CompatibleStack):
3393
 
    """Global options only stack."""
 
3797
    """Global options only stack.
 
3798
 
 
3799
    The following sections are queried:
 
3800
 
 
3801
    * command-line overrides,
 
3802
 
 
3803
    * the 'DEFAULT' section in bazaar.conf
 
3804
 
 
3805
    This stack will use the ``DEFAULT`` section in bazaar.conf as its
 
3806
    MutableSection.
 
3807
    """
3394
3808
 
3395
3809
    def __init__(self):
3396
 
        # Get a GlobalStore
3397
3810
        gstore = GlobalStore()
3398
3811
        super(GlobalStack, self).__init__(
3399
 
            [self._get_overrides, NameMatcher(gstore, 'DEFAULT').get_sections],
 
3812
            [self._get_overrides,
 
3813
             NameMatcher(gstore, 'DEFAULT').get_sections],
3400
3814
            gstore, mutable_section_id='DEFAULT')
3401
3815
 
3402
3816
 
3403
3817
class LocationStack(_CompatibleStack):
3404
 
    """Per-location options falling back to global options stack."""
 
3818
    """Per-location options falling back to global options stack.
 
3819
 
 
3820
 
 
3821
    The following sections are queried:
 
3822
 
 
3823
    * command-line overrides,
 
3824
 
 
3825
    * the sections matching ``location`` in ``locations.conf``, the order being
 
3826
      defined by the number of path components in the section glob, higher
 
3827
      numbers first (from most specific section to most generic).
 
3828
 
 
3829
    * the 'DEFAULT' section in bazaar.conf
 
3830
 
 
3831
    This stack will use the ``location`` section in locations.conf as its
 
3832
    MutableSection.
 
3833
    """
3405
3834
 
3406
3835
    def __init__(self, location):
3407
3836
        """Make a new stack for a location and global configuration.
3408
 
        
 
3837
 
3409
3838
        :param location: A URL prefix to """
3410
3839
        lstore = LocationStore()
3411
3840
        if location.startswith('file://'):
3412
3841
            location = urlutils.local_path_from_url(location)
3413
 
        matcher = LocationMatcher(lstore, location)
3414
3842
        gstore = GlobalStore()
3415
3843
        super(LocationStack, self).__init__(
3416
3844
            [self._get_overrides,
3417
 
             matcher.get_sections, NameMatcher(gstore, 'DEFAULT').get_sections],
 
3845
             LocationMatcher(lstore, location).get_sections,
 
3846
             NameMatcher(gstore, 'DEFAULT').get_sections],
3418
3847
            lstore, mutable_section_id=location)
3419
3848
 
3420
3849
 
3421
3850
class BranchStack(_CompatibleStack):
3422
 
    """Per-location options falling back to branch then global options stack."""
 
3851
    """Per-location options falling back to branch then global options stack.
 
3852
 
 
3853
    The following sections are queried:
 
3854
 
 
3855
    * command-line overrides,
 
3856
 
 
3857
    * the sections matching ``location`` in ``locations.conf``, the order being
 
3858
      defined by the number of path components in the section glob, higher
 
3859
      numbers first (from most specific section to most generic),
 
3860
 
 
3861
    * the no-name section in branch.conf,
 
3862
 
 
3863
    * the ``DEFAULT`` section in ``bazaar.conf``.
 
3864
 
 
3865
    This stack will use the no-name section in ``branch.conf`` as its
 
3866
    MutableSection.
 
3867
    """
3423
3868
 
3424
3869
    def __init__(self, branch):
 
3870
        lstore = LocationStore()
3425
3871
        bstore = branch._get_config_store()
3426
 
        lstore = LocationStore()
3427
 
        matcher = LocationMatcher(lstore, branch.base)
3428
3872
        gstore = GlobalStore()
3429
3873
        super(BranchStack, self).__init__(
3430
3874
            [self._get_overrides,
3431
 
             matcher.get_sections, bstore.get_sections,
 
3875
             LocationMatcher(lstore, branch.base).get_sections,
 
3876
             NameMatcher(bstore, None).get_sections,
3432
3877
             NameMatcher(gstore, 'DEFAULT').get_sections],
3433
3878
            bstore)
3434
3879
        self.branch = branch
3444
3889
    def __init__(self, bzrdir):
3445
3890
        cstore = bzrdir._get_config_store()
3446
3891
        super(RemoteControlStack, self).__init__(
3447
 
            [cstore.get_sections],
 
3892
            [NameMatcher(cstore, None).get_sections],
3448
3893
            cstore)
3449
3894
        self.bzrdir = bzrdir
3450
3895
 
3451
3896
 
3452
 
class RemoteBranchStack(_CompatibleStack):
3453
 
    """Remote branch-only options stack."""
 
3897
class BranchOnlyStack(_CompatibleStack):
 
3898
    """Branch-only options stack."""
3454
3899
 
3455
 
    # FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3456
 
    # with the stack used for remote branches. RemoteBranchStack only uses
3457
 
    # branch.conf and is used only for the stack options.
 
3900
    # FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
 
3901
    # stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
 
3902
    # -- vila 2011-12-16
3458
3903
 
3459
3904
    def __init__(self, branch):
3460
3905
        bstore = branch._get_config_store()
3461
 
        super(RemoteBranchStack, self).__init__(
3462
 
            [bstore.get_sections],
 
3906
        super(BranchOnlyStack, self).__init__(
 
3907
            [NameMatcher(bstore, None).get_sections],
3463
3908
            bstore)
3464
3909
        self.branch = branch
3465
3910
 
 
3911
 
3466
3912
# Use a an empty dict to initialize an empty configobj avoiding all
3467
3913
# parsing and encoding checks
3468
3914
_quoting_config = configobj.ConfigObj(
3469
 
    {}, encoding='utf-8', interpolation=False)
 
3915
    {}, encoding='utf-8', interpolation=False, list_values=True)
3470
3916
 
3471
3917
class cmd_config(commands.Command):
3472
3918
    __doc__ = """Display, set or remove a configuration option.
3592
4038
                            self.outf.write('%s:\n' % (store.id,))
3593
4039
                            cur_store_id = store.id
3594
4040
                            cur_section = None
3595
 
                        if (section.id not in (None, 'DEFAULT')
 
4041
                        if (section.id is not None
3596
4042
                            and cur_section != section.id):
3597
 
                            # Display the section if it's not the default (or
3598
 
                            # only) one.
 
4043
                            # Display the section id as it appears in the store
 
4044
                            # (None doesn't appear by definition)
3599
4045
                            self.outf.write('  [%s]\n' % (section.id,))
3600
4046
                            cur_section = section.id
3601
4047
                        value = section.get(oname, expand=False)
 
4048
                        # Since we don't use the stack, we need to restore a
 
4049
                        # proper quoting.
 
4050
                        try:
 
4051
                            opt = option_registry.get(oname)
 
4052
                            value = opt.convert_from_unicode(store, value)
 
4053
                        except KeyError:
 
4054
                            value = store.unquote(value)
3602
4055
                        value = _quoting_config._quote(value)
3603
4056
                        self.outf.write('  %s = %s\n' % (oname, value))
3604
4057