1508
2252
configobj[name] = value
1510
2254
configobj.setdefault(section, {})[name] = value
2255
for hook in OldConfigHooks['set']:
2256
hook(self, name, value)
2257
self._set_configobj(configobj)
2259
def remove_option(self, option_name, section_name=None):
2260
configobj = self._get_configobj()
2261
if section_name is None:
2262
del configobj[option_name]
2264
del configobj[section_name][option_name]
2265
for hook in OldConfigHooks['remove']:
2266
hook(self, option_name)
1511
2267
self._set_configobj(configobj)
1513
2269
def _get_config_file(self):
1515
return StringIO(self._transport.get_bytes(self._filename))
2271
f = BytesIO(self._transport.get_bytes(self._filename))
2272
for hook in OldConfigHooks['load']:
1516
2275
except errors.NoSuchFile:
2277
except errors.PermissionDenied:
2279
"Permission denied while trying to open "
2280
"configuration file %s.",
2281
urlutils.unescape_for_display(
2282
urlutils.join(self._transport.base, self._filename),
2286
def _external_url(self):
2287
return urlutils.join(self._transport.external_url(), self._filename)
1519
2289
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
2290
f = self._get_config_file()
2293
conf = ConfigObj(f, encoding='utf-8')
2294
except configobj.ConfigObjError as e:
2295
raise ParseConfigError(e.errors, self._external_url())
2296
except UnicodeDecodeError:
2297
raise ConfigContentError(self._external_url())
1522
2302
def _set_configobj(self, configobj):
1523
out_file = StringIO()
2303
out_file = BytesIO()
1524
2304
configobj.write(out_file)
1525
2305
out_file.seek(0)
1526
2306
self._transport.put_file(self._filename, out_file)
2307
for hook in OldConfigHooks['save']:
2311
class Option(object):
2312
"""An option definition.
2314
The option *values* are stored in config files and found in sections.
2316
Here we define various properties about the option itself, its default
2317
value, how to convert it from stores, what to do when invalid values are
2318
encoutered, in which config files it can be stored.
2321
def __init__(self, name, override_from_env=None,
2322
default=None, default_from_env=None,
2323
help=None, from_unicode=None, invalid=None, unquote=True):
2324
"""Build an option definition.
2326
:param name: the name used to refer to the option.
2328
:param override_from_env: A list of environment variables which can
2329
provide override any configuration setting.
2331
:param default: the default value to use when none exist in the config
2332
stores. This is either a string that ``from_unicode`` will convert
2333
into the proper type, a callable returning a unicode string so that
2334
``from_unicode`` can be used on the return value, or a python
2335
object that can be stringified (so only the empty list is supported
2338
:param default_from_env: A list of environment variables which can
2339
provide a default value. 'default' will be used only if none of the
2340
variables specified here are set in the environment.
2342
:param help: a doc string to explain the option to the user.
2344
:param from_unicode: a callable to convert the unicode string
2345
representing the option value in a store or its default value.
2347
:param invalid: the action to be taken when an invalid value is
2348
encountered in a store. This is called only when from_unicode is
2349
invoked to convert a string and returns None or raise ValueError or
2350
TypeError. Accepted values are: None (ignore invalid values),
2351
'warning' (emit a warning), 'error' (emit an error message and
2354
:param unquote: should the unicode value be unquoted before conversion.
2355
This should be used only when the store providing the values cannot
2356
safely unquote them (see http://pad.lv/906897). It is provided so
2357
daughter classes can handle the quoting themselves.
2359
if override_from_env is None:
2360
override_from_env = []
2361
if default_from_env is None:
2362
default_from_env = []
2364
self.override_from_env = override_from_env
2365
# Convert the default value to a unicode string so all values are
2366
# strings internally before conversion (via from_unicode) is attempted.
2369
elif isinstance(default, list):
2370
# Only the empty list is supported
2372
raise AssertionError(
2373
'Only empty lists are supported as default values')
2375
elif isinstance(default, (binary_type, text_type, bool, int, float)):
2376
# Rely on python to convert strings, booleans and integers
2377
self.default = u'%s' % (default,)
2378
elif callable(default):
2379
self.default = default
2381
# other python objects are not expected
2382
raise AssertionError('%r is not supported as a default value'
2384
self.default_from_env = default_from_env
2386
self.from_unicode = from_unicode
2387
self.unquote = unquote
2388
if invalid and invalid not in ('warning', 'error'):
2389
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2390
self.invalid = invalid
2396
def convert_from_unicode(self, store, unicode_value):
2397
if self.unquote and store is not None and unicode_value is not None:
2398
unicode_value = store.unquote(unicode_value)
2399
if self.from_unicode is None or unicode_value is None:
2400
# Don't convert or nothing to convert
2401
return unicode_value
2403
converted = self.from_unicode(unicode_value)
2404
except (ValueError, TypeError):
2405
# Invalid values are ignored
2407
if converted is None and self.invalid is not None:
2408
# The conversion failed
2409
if self.invalid == 'warning':
2410
trace.warning('Value "%s" is not valid for "%s"',
2411
unicode_value, self.name)
2412
elif self.invalid == 'error':
2413
raise ConfigOptionValueError(self.name, unicode_value)
2416
def get_override(self):
2418
for var in self.override_from_env:
2420
# If the env variable is defined, its value takes precedence
2421
value = os.environ[var]
2423
value = value.decode(osutils.get_user_encoding())
2429
def get_default(self):
2431
for var in self.default_from_env:
2433
# If the env variable is defined, its value is the default one
2434
value = os.environ[var]
2436
value = value.decode(osutils.get_user_encoding())
2441
# Otherwise, fallback to the value defined at registration
2442
if callable(self.default):
2443
value = self.default()
2444
if not isinstance(value, text_type):
2445
raise AssertionError(
2446
"Callable default value for '%s' should be unicode"
2449
value = self.default
2452
def get_help_topic(self):
2455
def get_help_text(self, additional_see_also=None, plain=True):
2457
from breezy import help_topics
2458
result += help_topics._format_see_also(additional_see_also)
2460
result = help_topics.help_as_plain_text(result)
2464
# Predefined converters to get proper values from store
2466
def bool_from_store(unicode_str):
2467
return ui.bool_from_string(unicode_str)
2470
def int_from_store(unicode_str):
2471
return int(unicode_str)
2474
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2477
def int_SI_from_store(unicode_str):
2478
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2480
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2481
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2484
:return Integer, expanded to its base-10 value if a proper SI unit is
2485
found, None otherwise.
2487
regexp = "^(\\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2488
p = re.compile(regexp, re.IGNORECASE)
2489
m = p.match(unicode_str)
2492
val, _, unit = m.groups()
2496
coeff = _unit_suffixes[unit.upper()]
2499
gettext('{0} is not an SI unit.').format(unit))
2504
def float_from_store(unicode_str):
2505
return float(unicode_str)
2508
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2510
_list_converter_config = configobj.ConfigObj(
2511
{}, encoding='utf-8', list_values=True, interpolation=False)
2514
class ListOption(Option):
2516
def __init__(self, name, default=None, default_from_env=None,
2517
help=None, invalid=None):
2518
"""A list Option definition.
2520
This overrides the base class so the conversion from a unicode string
2521
can take quoting into account.
2523
super(ListOption, self).__init__(
2524
name, default=default, default_from_env=default_from_env,
2525
from_unicode=self.from_unicode, help=help,
2526
invalid=invalid, unquote=False)
2528
def from_unicode(self, unicode_str):
2529
if not isinstance(unicode_str, string_types):
2531
# Now inject our string directly as unicode. All callers got their
2532
# value from configobj, so values that need to be quoted are already
2534
_list_converter_config.reset()
2535
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2536
maybe_list = _list_converter_config['list']
2537
if isinstance(maybe_list, string_types):
2539
# A single value, most probably the user forgot (or didn't care
2540
# to add) the final ','
2543
# The empty string, convert to empty list
2546
# We rely on ConfigObj providing us with a list already
2551
class RegistryOption(Option):
2552
"""Option for a choice from a registry."""
2554
def __init__(self, name, registry, default_from_env=None,
2555
help=None, invalid=None):
2556
"""A registry based Option definition.
2558
This overrides the base class so the conversion from a unicode string
2559
can take quoting into account.
2561
super(RegistryOption, self).__init__(
2562
name, default=lambda: registry.default_key,
2563
default_from_env=default_from_env,
2564
from_unicode=self.from_unicode, help=help,
2565
invalid=invalid, unquote=False)
2566
self.registry = registry
2568
def from_unicode(self, unicode_str):
2569
if not isinstance(unicode_str, string_types):
2572
return self.registry.get(unicode_str)
2575
"Invalid value %s for %s."
2576
"See help for a list of possible values." % (unicode_str,
2581
ret = [self._help, "\n\nThe following values are supported:\n"]
2582
for key in self.registry.keys():
2583
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2587
_option_ref_re = lazy_regex.lazy_compile('({[^\\d\\W](?:\\.\\w|-\\w|\\w)*})')
2588
"""Describes an expandable option reference.
2590
We want to match the most embedded reference first.
2592
I.e. for '{{foo}}' we will get '{foo}',
2593
for '{bar{baz}}' we will get '{baz}'
2597
def iter_option_refs(string):
2598
# Split isolate refs so every other chunk is a ref
2600
for chunk in _option_ref_re.split(string):
2605
class OptionRegistry(registry.Registry):
2606
"""Register config options by their name.
2608
This overrides ``registry.Registry`` to simplify registration by acquiring
2609
some information from the option object itself.
2612
def _check_option_name(self, option_name):
2613
"""Ensures an option name is valid.
2615
:param option_name: The name to validate.
2617
if _option_ref_re.match('{%s}' % option_name) is None:
2618
raise IllegalOptionName(option_name)
2620
def register(self, option):
2621
"""Register a new option to its name.
2623
:param option: The option to register. Its name is used as the key.
2625
self._check_option_name(option.name)
2626
super(OptionRegistry, self).register(option.name, option,
2629
def register_lazy(self, key, module_name, member_name):
2630
"""Register a new option to be loaded on request.
2632
:param key: the key to request the option later. Since the registration
2633
is lazy, it should be provided and match the option name.
2635
:param module_name: the python path to the module. Such as 'os.path'.
2637
:param member_name: the member of the module to return. If empty or
2638
None, get() will return the module itself.
2640
self._check_option_name(key)
2641
super(OptionRegistry, self).register_lazy(key,
2642
module_name, member_name)
2644
def get_help(self, key=None):
2645
"""Get the help text associated with the given key"""
2646
option = self.get(key)
2647
the_help = option.help
2648
if callable(the_help):
2649
return the_help(self, key)
2653
option_registry = OptionRegistry()
2656
# Registered options in lexicographical order
2658
option_registry.register(
2659
Option('append_revisions_only',
2660
default=None, from_unicode=bool_from_store, invalid='warning',
2662
Whether to only append revisions to the mainline.
2664
If this is set to true, then it is not possible to change the
2665
existing mainline of the branch.
2667
option_registry.register(
2668
ListOption('acceptable_keys',
2671
List of GPG key patterns which are acceptable for verification.
2673
option_registry.register(
2674
Option('add.maximum_file_size',
2675
default=u'20MB', from_unicode=int_SI_from_store,
2677
Size above which files should be added manually.
2679
Files below this size are added automatically when using ``bzr add`` without
2682
A negative value means disable the size check.
2684
option_registry.register(
2686
default=None, from_unicode=bool_from_store,
2688
Is the branch bound to ``bound_location``.
2690
If set to "True", the branch should act as a checkout, and push each commit to
2691
the bound_location. This option is normally set by ``bind``/``unbind``.
2693
See also: bound_location.
2695
option_registry.register(
2696
Option('bound_location',
2699
The location that commits should go to when acting as a checkout.
2701
This option is normally set by ``bind``.
2705
option_registry.register(
2706
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2708
Whether revisions associated with tags should be fetched.
2710
option_registry.register_lazy(
2711
'transform.orphan_policy', 'breezy.transform', 'opt_transform_orphan')
2712
option_registry.register(
2713
Option('bzr.workingtree.worth_saving_limit', default=10,
2714
from_unicode=int_from_store, invalid='warning',
2716
How many changes before saving the dirstate.
2718
-1 means that we will never rewrite the dirstate file for only
2719
stat-cache changes. Regardless of this setting, we will always rewrite
2720
the dirstate file if a file is added/removed/renamed/etc. This flag only
2721
affects the behavior of updating the dirstate file after we notice that
2722
a file has been touched.
2724
option_registry.register(
2725
Option('bugtracker', default=None,
2727
Default bug tracker to use.
2729
This bug tracker will be used for example when marking bugs
2730
as fixed using ``bzr commit --fixes``, if no explicit
2731
bug tracker was specified.
2733
option_registry.register(
2734
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2735
from_unicode=signature_policy_from_unicode,
2737
GPG checking policy.
2739
Possible values: require, ignore, check-available (default)
2741
this option will control whether bzr will require good gpg
2742
signatures, ignore them, or check them if they are
2745
option_registry.register(
2746
Option('child_submit_format',
2747
help='''The preferred format of submissions to this branch.'''))
2748
option_registry.register(
2749
Option('child_submit_to',
2750
help='''Where submissions to this branch are mailed to.'''))
2751
option_registry.register(
2752
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2753
from_unicode=signing_policy_from_unicode,
2757
Possible values: always, never, when-required (default)
2759
This option controls whether bzr will always create
2760
gpg signatures or not on commits.
2762
option_registry.register(
2763
Option('dirstate.fdatasync', default=True,
2764
from_unicode=bool_from_store,
2766
Flush dirstate changes onto physical disk?
2768
If true (default), working tree metadata changes are flushed through the
2769
OS buffers to physical disk. This is somewhat slower, but means data
2770
should not be lost if the machine crashes. See also repository.fdatasync.
2772
option_registry.register(
2773
ListOption('debug_flags', default=[],
2774
help='Debug flags to activate.'))
2775
option_registry.register(
2776
Option('default_format', default='2a',
2777
help='Format used when creating branches.'))
2778
option_registry.register(
2780
help='The command called to launch an editor to enter a message.'))
2781
option_registry.register(
2782
Option('email', override_from_env=['BRZ_EMAIL'], default=default_email,
2783
help='The users identity'))
2784
option_registry.register(
2785
Option('gpg_signing_key',
2788
GPG key to use for signing.
2790
This defaults to the first key associated with the users email.
2792
option_registry.register(
2794
help='Language to translate messages into.'))
2795
option_registry.register(
2796
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2798
Steal locks that appears to be dead.
2800
If set to True, bzr will check if a lock is supposed to be held by an
2801
active process from the same user on the same machine. If the user and
2802
machine match, but no process with the given PID is active, then bzr
2803
will automatically break the stale lock, and create a new lock for
2805
Otherwise, bzr will prompt as normal to break the lock.
2807
option_registry.register(
2808
Option('log_format', default='long',
2810
Log format to use when displaying revisions.
2812
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2813
may be provided by plugins.
2815
option_registry.register_lazy('mail_client', 'breezy.mail_client',
2817
option_registry.register(
2818
Option('output_encoding',
2819
help='Unicode encoding for output'
2820
' (terminal encoding if not specified).'))
2821
option_registry.register(
2822
Option('parent_location',
2825
The location of the default branch for pull or merge.
2827
This option is normally set when creating a branch, the first ``pull`` or by
2828
``pull --remember``.
2830
option_registry.register(
2831
Option('post_commit', default=None,
2833
Post commit functions.
2835
An ordered list of python functions to call, separated by spaces.
2837
Each function takes branch, rev_id as parameters.
2839
option_registry.register_lazy('progress_bar', 'breezy.ui.text',
2841
option_registry.register(
2842
Option('public_branch',
2845
A publically-accessible version of this branch.
2847
This implies that the branch setting this option is not publically-accessible.
2848
Used and set by ``bzr send``.
2850
option_registry.register(
2851
Option('push_location',
2854
The location of the default branch for push.
2856
This option is normally set by the first ``push`` or ``push --remember``.
2858
option_registry.register(
2859
Option('push_strict', default=None,
2860
from_unicode=bool_from_store,
2862
The default value for ``push --strict``.
2864
If present, defines the ``--strict`` option default value for checking
2865
uncommitted changes before sending a merge directive.
2867
option_registry.register(
2868
Option('repository.fdatasync', default=True,
2869
from_unicode=bool_from_store,
2871
Flush repository changes onto physical disk?
2873
If true (default), repository changes are flushed through the OS buffers
2874
to physical disk. This is somewhat slower, but means data should not be
2875
lost if the machine crashes. See also dirstate.fdatasync.
2877
option_registry.register_lazy('smtp_server',
2878
'breezy.smtp_connection', 'smtp_server')
2879
option_registry.register_lazy('smtp_password',
2880
'breezy.smtp_connection', 'smtp_password')
2881
option_registry.register_lazy('smtp_username',
2882
'breezy.smtp_connection', 'smtp_username')
2883
option_registry.register(
2884
Option('selftest.timeout',
2886
from_unicode=int_from_store,
2887
help='Abort selftest if one test takes longer than this many seconds',
2890
option_registry.register(
2891
Option('send_strict', default=None,
2892
from_unicode=bool_from_store,
2894
The default value for ``send --strict``.
2896
If present, defines the ``--strict`` option default value for checking
2897
uncommitted changes before sending a bundle.
2900
option_registry.register(
2901
Option('serve.client_timeout',
2902
default=300.0, from_unicode=float_from_store,
2903
help="If we wait for a new request from a client for more than"
2904
" X seconds, consider the client idle, and hangup."))
2905
option_registry.register(
2906
Option('stacked_on_location',
2908
help="""The location where this branch is stacked on."""))
2909
option_registry.register(
2910
Option('submit_branch',
2913
The branch you intend to submit your current work to.
2915
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2916
by the ``submit:`` revision spec.
2918
option_registry.register(
2920
help='''Where submissions from this branch are mailed to.'''))
2921
option_registry.register(
2922
ListOption('suppress_warnings',
2924
help="List of warning classes to suppress."))
2925
option_registry.register(
2926
Option('validate_signatures_in_log', default=False,
2927
from_unicode=bool_from_store, invalid='warning',
2928
help='''Whether to validate signatures in brz log.'''))
2929
option_registry.register_lazy('ssl.ca_certs',
2930
'breezy.transport.http', 'opt_ssl_ca_certs')
2932
option_registry.register_lazy('ssl.cert_reqs',
2933
'breezy.transport.http', 'opt_ssl_cert_reqs')
2936
class Section(object):
2937
"""A section defines a dict of option name => value.
2939
This is merely a read-only dict which can add some knowledge about the
2940
options. It is *not* a python dict object though and doesn't try to mimic
2944
def __init__(self, section_id, options):
2945
self.id = section_id
2946
# We re-use the dict-like object received
2947
self.options = options
2949
def get(self, name, default=None, expand=True):
2950
return self.options.get(name, default)
2952
def iter_option_names(self):
2953
for k in self.options.keys():
2957
# Mostly for debugging use
2958
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2961
_NewlyCreatedOption = object()
2962
"""Was the option created during the MutableSection lifetime"""
2963
_DeletedOption = object()
2964
"""Was the option deleted during the MutableSection lifetime"""
2967
class MutableSection(Section):
2968
"""A section allowing changes and keeping track of the original values."""
2970
def __init__(self, section_id, options):
2971
super(MutableSection, self).__init__(section_id, options)
2972
self.reset_changes()
2974
def set(self, name, value):
2975
if name not in self.options:
2976
# This is a new option
2977
self.orig[name] = _NewlyCreatedOption
2978
elif name not in self.orig:
2979
self.orig[name] = self.get(name, None)
2980
self.options[name] = value
2982
def remove(self, name):
2983
if name not in self.orig and name in self.options:
2984
self.orig[name] = self.get(name, None)
2985
del self.options[name]
2987
def reset_changes(self):
2990
def apply_changes(self, dirty, store):
2991
"""Apply option value changes.
2993
``self`` has been reloaded from the persistent storage. ``dirty``
2994
contains the changes made since the previous loading.
2996
:param dirty: the mutable section containing the changes.
2998
:param store: the store containing the section
3000
for k, expected in dirty.orig.items():
3001
actual = dirty.get(k, _DeletedOption)
3002
reloaded = self.get(k, _NewlyCreatedOption)
3003
if actual is _DeletedOption:
3004
if k in self.options:
3008
# Report concurrent updates in an ad-hoc way. This should only
3009
# occurs when different processes try to update the same option
3010
# which is not supported (as in: the config framework is not meant
3011
# to be used as a sharing mechanism).
3012
if expected != reloaded:
3013
if actual is _DeletedOption:
3014
actual = '<DELETED>'
3015
if reloaded is _NewlyCreatedOption:
3016
reloaded = '<CREATED>'
3017
if expected is _NewlyCreatedOption:
3018
expected = '<CREATED>'
3019
# Someone changed the value since we get it from the persistent
3021
trace.warning(gettext(
3022
"Option {0} in section {1} of {2} was changed"
3023
" from {3} to {4}. The {5} value will be saved.".format(
3024
k, self.id, store.external_url(), expected,
3026
# No need to keep track of these changes
3027
self.reset_changes()
3030
class Store(object):
3031
"""Abstract interface to persistent storage for configuration options."""
3033
readonly_section_class = Section
3034
mutable_section_class = MutableSection
3037
# Which sections need to be saved (by section id). We use a dict here
3038
# so the dirty sections can be shared by multiple callers.
3039
self.dirty_sections = {}
3041
def is_loaded(self):
3042
"""Returns True if the Store has been loaded.
3044
This is used to implement lazy loading and ensure the persistent
3045
storage is queried only when needed.
3047
raise NotImplementedError(self.is_loaded)
3050
"""Loads the Store from persistent storage."""
3051
raise NotImplementedError(self.load)
3053
def _load_from_string(self, bytes):
3054
"""Create a store from a string in configobj syntax.
3056
:param bytes: A string representing the file content.
3058
raise NotImplementedError(self._load_from_string)
3061
"""Unloads the Store.
3063
This should make is_loaded() return False. This is used when the caller
3064
knows that the persistent storage has changed or may have change since
3067
raise NotImplementedError(self.unload)
3069
def quote(self, value):
3070
"""Quote a configuration option value for storing purposes.
3072
This allows Stacks to present values as they will be stored.
3076
def unquote(self, value):
3077
"""Unquote a configuration option value into unicode.
3079
The received value is quoted as stored.
3084
"""Saves the Store to persistent storage."""
3085
raise NotImplementedError(self.save)
3087
def _need_saving(self):
3088
for s in self.dirty_sections.values():
3090
# At least one dirty section contains a modification
3094
def apply_changes(self, dirty_sections):
3095
"""Apply changes from dirty sections while checking for coherency.
3097
The Store content is discarded and reloaded from persistent storage to
3098
acquire up-to-date values.
3100
Dirty sections are MutableSection which kept track of the value they
3101
are expected to update.
3103
# We need an up-to-date version from the persistent storage, unload the
3104
# store. The reload will occur when needed (triggered by the first
3105
# get_mutable_section() call below.
3107
# Apply the changes from the preserved dirty sections
3108
for section_id, dirty in dirty_sections.items():
3109
clean = self.get_mutable_section(section_id)
3110
clean.apply_changes(dirty, self)
3111
# Everything is clean now
3112
self.dirty_sections = {}
3114
def save_changes(self):
3115
"""Saves the Store to persistent storage if changes occurred.
3117
Apply the changes recorded in the mutable sections to a store content
3118
refreshed from persistent storage.
3120
raise NotImplementedError(self.save_changes)
3122
def external_url(self):
3123
raise NotImplementedError(self.external_url)
3125
def get_sections(self):
3126
"""Returns an ordered iterable of existing sections.
3128
:returns: An iterable of (store, section).
3130
raise NotImplementedError(self.get_sections)
3132
def get_mutable_section(self, section_id=None):
3133
"""Returns the specified mutable section.
3135
:param section_id: The section identifier
3137
raise NotImplementedError(self.get_mutable_section)
3140
# Mostly for debugging use
3141
return "<config.%s(%s)>" % (self.__class__.__name__,
3142
self.external_url())
3145
class CommandLineStore(Store):
3146
"A store to carry command line overrides for the config options."""
3148
def __init__(self, opts=None):
3149
super(CommandLineStore, self).__init__()
3156
# The dict should be cleared but not replaced so it can be shared.
3157
self.options.clear()
3159
def _from_cmdline(self, overrides):
3160
# Reset before accepting new definitions
3162
for over in overrides:
3164
name, value = over.split('=', 1)
3166
raise errors.BzrCommandError(
3167
gettext("Invalid '%s', should be of the form 'name=value'")
3169
self.options[name] = value
3171
def external_url(self):
3172
# Not an url but it makes debugging easier and is never needed
3176
def get_sections(self):
3177
yield self, self.readonly_section_class(None, self.options)
3180
class IniFileStore(Store):
3181
"""A config Store using ConfigObj for storage.
3183
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3184
serialize/deserialize the config file.
3188
"""A config Store using ConfigObj for storage.
3190
super(IniFileStore, self).__init__()
3191
self._config_obj = None
3193
def is_loaded(self):
3194
return self._config_obj is not None
3197
self._config_obj = None
3198
self.dirty_sections = {}
3200
def _load_content(self):
3201
"""Load the config file bytes.
3203
This should be provided by subclasses
3205
:return: Byte string
3207
raise NotImplementedError(self._load_content)
3209
def _save_content(self, content):
3210
"""Save the config file bytes.
3212
This should be provided by subclasses
3214
:param content: Config file bytes to write
3216
raise NotImplementedError(self._save_content)
3219
"""Load the store from the associated file."""
3220
if self.is_loaded():
3222
content = self._load_content()
3223
self._load_from_string(content)
3224
for hook in ConfigHooks['load']:
3227
def _load_from_string(self, bytes):
3228
"""Create a config store from a string.
3230
:param bytes: A string representing the file content.
3232
if self.is_loaded():
3233
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3234
co_input = BytesIO(bytes)
3236
# The config files are always stored utf8-encoded
3237
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3239
except configobj.ConfigObjError as e:
3240
self._config_obj = None
3241
raise ParseConfigError(e.errors, self.external_url())
3242
except UnicodeDecodeError:
3243
raise ConfigContentError(self.external_url())
3245
def save_changes(self):
3246
if not self.is_loaded():
3249
if not self._need_saving():
3251
# Preserve the current version
3252
dirty_sections = self.dirty_sections.copy()
3253
self.apply_changes(dirty_sections)
3254
# Save to the persistent storage
3258
if not self.is_loaded():
3262
self._config_obj.write(out)
3263
self._save_content(out.getvalue())
3264
for hook in ConfigHooks['save']:
3267
def get_sections(self):
3268
"""Get the configobj section in the file order.
3270
:returns: An iterable of (store, section).
3272
# We need a loaded store
3275
except (errors.NoSuchFile, errors.PermissionDenied):
3276
# If the file can't be read, there is no sections
3278
cobj = self._config_obj
3280
yield self, self.readonly_section_class(None, cobj)
3281
for section_name in cobj.sections:
3283
self.readonly_section_class(section_name,
3284
cobj[section_name]))
3286
def get_mutable_section(self, section_id=None):
3287
# We need a loaded store
3290
except errors.NoSuchFile:
3291
# The file doesn't exist, let's pretend it was empty
3292
self._load_from_string(b'')
3293
if section_id in self.dirty_sections:
3294
# We already created a mutable section for this id
3295
return self.dirty_sections[section_id]
3296
if section_id is None:
3297
section = self._config_obj
3299
section = self._config_obj.setdefault(section_id, {})
3300
mutable_section = self.mutable_section_class(section_id, section)
3301
# All mutable sections can become dirty
3302
self.dirty_sections[section_id] = mutable_section
3303
return mutable_section
3305
def quote(self, value):
3307
# configobj conflates automagical list values and quoting
3308
self._config_obj.list_values = True
3309
return self._config_obj._quote(value)
3311
self._config_obj.list_values = False
3313
def unquote(self, value):
3314
if value and isinstance(value, string_types):
3315
# _unquote doesn't handle None nor empty strings nor anything that
3316
# is not a string, really.
3317
value = self._config_obj._unquote(value)
3320
def external_url(self):
3321
# Since an IniFileStore can be used without a file (at least in tests),
3322
# it's better to provide something than raising a NotImplementedError.
3323
# All daughter classes are supposed to provide an implementation
3325
return 'In-Process Store, no URL'
3328
class TransportIniFileStore(IniFileStore):
3329
"""IniFileStore that loads files from a transport.
3331
:ivar transport: The transport object where the config file is located.
3333
:ivar file_name: The config file basename in the transport directory.
3336
def __init__(self, transport, file_name):
3337
"""A Store using a ini file on a Transport
3339
:param transport: The transport object where the config file is located.
3340
:param file_name: The config file basename in the transport directory.
3342
super(TransportIniFileStore, self).__init__()
3343
self.transport = transport
3344
self.file_name = file_name
3346
def _load_content(self):
3348
return self.transport.get_bytes(self.file_name)
3349
except errors.PermissionDenied:
3350
trace.warning("Permission denied while trying to load "
3351
"configuration store %s.", self.external_url())
3354
def _save_content(self, content):
3355
self.transport.put_bytes(self.file_name, content)
3357
def external_url(self):
3358
# FIXME: external_url should really accepts an optional relpath
3359
# parameter (bug #750169) :-/ -- vila 2011-04-04
3360
# The following will do in the interim but maybe we don't want to
3361
# expose a path here but rather a config ID and its associated
3362
# object </hand wawe>.
3363
return urlutils.join(
3364
self.transport.external_url(), urlutils.escape(self.file_name))
3367
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3368
# unlockable stores for use with objects that can already ensure the locking
3369
# (think branches). If different stores (not based on ConfigObj) are created,
3370
# they may face the same issue.
3373
class LockableIniFileStore(TransportIniFileStore):
3374
"""A ConfigObjStore using locks on save to ensure store integrity."""
3376
def __init__(self, transport, file_name, lock_dir_name=None):
3377
"""A config Store using ConfigObj for storage.
3379
:param transport: The transport object where the config file is located.
3381
:param file_name: The config file basename in the transport directory.
3383
if lock_dir_name is None:
3384
lock_dir_name = 'lock'
3385
self.lock_dir_name = lock_dir_name
3386
super(LockableIniFileStore, self).__init__(transport, file_name)
3387
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3389
def lock_write(self, token=None):
3390
"""Takes a write lock in the directory containing the config file.
3392
If the directory doesn't exist it is created.
3394
# FIXME: This doesn't check the ownership of the created directories as
3395
# ensure_config_dir_exists does. It should if the transport is local
3396
# -- vila 2011-04-06
3397
self.transport.create_prefix()
3398
token = self._lock.lock_write(token)
3399
return lock.LogicalLockResult(self.unlock, token)
3404
def break_lock(self):
3405
self._lock.break_lock()
3408
with self.lock_write():
3409
# We need to be able to override the undecorated implementation
3410
self.save_without_locking()
3412
def save_without_locking(self):
3413
super(LockableIniFileStore, self).save()
3416
# FIXME: global, breezy, shouldn't that be 'user' instead or even
3417
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3418
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3420
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3421
# functions or a registry will make it easier and clearer for tests, focusing
3422
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3423
# on a poolie's remark)
3424
class GlobalStore(LockableIniFileStore):
3425
"""A config store for global options.
3427
There is a single GlobalStore for a given process.
3430
def __init__(self, possible_transports=None):
3431
(path, kind) = _config_dir()
3432
t = transport.get_transport_from_path(
3433
path, possible_transports=possible_transports)
3434
filename = {'bazaar': 'bazaar.conf', 'breezy': 'breezy.conf'}[kind]
3435
super(GlobalStore, self).__init__(t, filename)
3439
class LocationStore(LockableIniFileStore):
3440
"""A config store for options specific to a location.
3442
There is a single LocationStore for a given process.
3445
def __init__(self, possible_transports=None):
3446
t = transport.get_transport_from_path(
3447
config_dir(), possible_transports=possible_transports)
3448
super(LocationStore, self).__init__(t, 'locations.conf')
3449
self.id = 'locations'
3452
class BranchStore(TransportIniFileStore):
3453
"""A config store for branch options.
3455
There is a single BranchStore for a given branch.
3458
def __init__(self, branch):
3459
super(BranchStore, self).__init__(branch.control_transport,
3461
self.branch = branch
3465
class ControlStore(LockableIniFileStore):
3467
def __init__(self, bzrdir):
3468
super(ControlStore, self).__init__(bzrdir.transport,
3470
lock_dir_name='branch_lock')
3474
class SectionMatcher(object):
3475
"""Select sections into a given Store.
3477
This is intended to be used to postpone getting an iterable of sections
3481
def __init__(self, store):
3484
def get_sections(self):
3485
# This is where we require loading the store so we can see all defined
3487
sections = self.store.get_sections()
3488
# Walk the revisions in the order provided
3489
for store, s in sections:
3493
def match(self, section):
3494
"""Does the proposed section match.
3496
:param section: A Section object.
3498
:returns: True if the section matches, False otherwise.
3500
raise NotImplementedError(self.match)
3503
class NameMatcher(SectionMatcher):
3505
def __init__(self, store, section_id):
3506
super(NameMatcher, self).__init__(store)
3507
self.section_id = section_id
3509
def match(self, section):
3510
return section.id == self.section_id
3513
class LocationSection(Section):
3515
def __init__(self, section, extra_path, branch_name=None):
3516
super(LocationSection, self).__init__(section.id, section.options)
3517
self.extra_path = extra_path
3518
if branch_name is None:
3520
self.locals = {'relpath': extra_path,
3521
'basename': urlutils.basename(extra_path),
3522
'branchname': branch_name}
3524
def get(self, name, default=None, expand=True):
3525
value = super(LocationSection, self).get(name, default)
3526
if value is not None and expand:
3527
policy_name = self.get(name + ':policy', None)
3528
policy = _policy_value.get(policy_name, POLICY_NONE)
3529
if policy == POLICY_APPENDPATH:
3530
value = urlutils.join(value, self.extra_path)
3531
# expand section local options right now (since POLICY_APPENDPATH
3532
# will never add options references, it's ok to expand after it).
3534
for is_ref, chunk in iter_option_refs(value):
3536
chunks.append(chunk)
3539
if ref in self.locals:
3540
chunks.append(self.locals[ref])
3542
chunks.append(chunk)
3543
value = ''.join(chunks)
3547
class StartingPathMatcher(SectionMatcher):
3548
"""Select sections for a given location respecting the Store order."""
3550
# FIXME: Both local paths and urls can be used for section names as well as
3551
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3552
# inherited the fuzziness from the previous ``LocationConfig``
3553
# implementation. We probably need to revisit which encoding is allowed for
3554
# both ``location`` and section names and how we normalize
3555
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3556
# related too. -- vila 2012-01-04
3558
def __init__(self, store, location):
3559
super(StartingPathMatcher, self).__init__(store)
3560
if location.startswith('file://'):
3561
location = urlutils.local_path_from_url(location)
3562
self.location = location
3564
def get_sections(self):
3565
"""Get all sections matching ``location`` in the store.
3567
The most generic sections are described first in the store, then more
3568
specific ones can be provided for reduced scopes.
3570
The returned section are therefore returned in the reversed order so
3571
the most specific ones can be found first.
3573
location_parts = self.location.rstrip('/').split('/')
3575
# Later sections are more specific, they should be returned first
3576
for _, section in reversed(list(store.get_sections())):
3577
if section.id is None:
3578
# The no-name section is always included if present
3579
yield store, LocationSection(section, self.location)
3581
section_path = section.id
3582
if section_path.startswith('file://'):
3583
# the location is already a local path or URL, convert the
3584
# section id to the same format
3585
section_path = urlutils.local_path_from_url(section_path)
3586
if (self.location.startswith(section_path) or
3587
fnmatch.fnmatch(self.location, section_path)):
3588
section_parts = section_path.rstrip('/').split('/')
3589
extra_path = '/'.join(location_parts[len(section_parts):])
3590
yield store, LocationSection(section, extra_path)
3593
class LocationMatcher(SectionMatcher):
3595
def __init__(self, store, location):
3596
super(LocationMatcher, self).__init__(store)
3597
url, params = urlutils.split_segment_parameters(location)
3598
if location.startswith('file://'):
3599
location = urlutils.local_path_from_url(location)
3600
self.location = location
3601
branch_name = params.get('branch')
3602
if branch_name is None:
3603
self.branch_name = urlutils.basename(self.location)
3605
self.branch_name = urlutils.unescape(branch_name)
3607
def _get_matching_sections(self):
3608
"""Get all sections matching ``location``."""
3609
# We slightly diverge from LocalConfig here by allowing the no-name
3610
# section as the most generic one and the lower priority.
3611
no_name_section = None
3613
# Filter out the no_name_section so _iter_for_location_by_parts can be
3614
# used (it assumes all sections have a name).
3615
for _, section in self.store.get_sections():
3616
if section.id is None:
3617
no_name_section = section
3619
all_sections.append(section)
3620
# Unfortunately _iter_for_location_by_parts deals with section names so
3621
# we have to resync.
3622
filtered_sections = _iter_for_location_by_parts(
3623
[s.id for s in all_sections], self.location)
3624
iter_all_sections = iter(all_sections)
3625
matching_sections = []
3626
if no_name_section is not None:
3627
matching_sections.append(
3628
(0, LocationSection(no_name_section, self.location)))
3629
for section_id, extra_path, length in filtered_sections:
3630
# a section id is unique for a given store so it's safe to take the
3631
# first matching section while iterating. Also, all filtered
3632
# sections are part of 'all_sections' and will always be found
3635
section = next(iter_all_sections)
3636
if section_id == section.id:
3637
section = LocationSection(section, extra_path,
3639
matching_sections.append((length, section))
3641
return matching_sections
3643
def get_sections(self):
3644
# Override the default implementation as we want to change the order
3645
# We want the longest (aka more specific) locations first
3646
sections = sorted(self._get_matching_sections(),
3647
key=lambda match: (match[0], match[1].id),
3649
# Sections mentioning 'ignore_parents' restrict the selection
3650
for _, section in sections:
3651
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3652
ignore = section.get('ignore_parents', None)
3653
if ignore is not None:
3654
ignore = ui.bool_from_string(ignore)
3657
# Finally, we have a valid section
3658
yield self.store, section
3661
# FIXME: _shared_stores should be an attribute of a library state once a
3662
# library_state object is always available.
3664
_shared_stores_at_exit_installed = False
3667
class Stack(object):
3668
"""A stack of configurations where an option can be defined"""
3670
def __init__(self, sections_def, store=None, mutable_section_id=None):
3671
"""Creates a stack of sections with an optional store for changes.
3673
:param sections_def: A list of Section or callables that returns an
3674
iterable of Section. This defines the Sections for the Stack and
3675
can be called repeatedly if needed.
3677
:param store: The optional Store where modifications will be
3678
recorded. If none is specified, no modifications can be done.
3680
:param mutable_section_id: The id of the MutableSection where changes
3681
are recorded. This requires the ``store`` parameter to be
3684
self.sections_def = sections_def
3686
self.mutable_section_id = mutable_section_id
3688
def iter_sections(self):
3689
"""Iterate all the defined sections."""
3690
# Ensuring lazy loading is achieved by delaying section matching (which
3691
# implies querying the persistent storage) until it can't be avoided
3692
# anymore by using callables to describe (possibly empty) section
3694
for sections in self.sections_def:
3695
for store, section in sections():
3696
yield store, section
3698
def get(self, name, expand=True, convert=True):
3699
"""Return the *first* option value found in the sections.
3701
This is where we guarantee that sections coming from Store are loaded
3702
lazily: the loading is delayed until we need to either check that an
3703
option exists or get its value, which in turn may require to discover
3704
in which sections it can be defined. Both of these (section and option
3705
existence) require loading the store (even partially).
3707
:param name: The queried option.
3709
:param expand: Whether options references should be expanded.
3711
:param convert: Whether the option value should be converted from
3712
unicode (do nothing for non-registered options).
3714
:returns: The value of the option.
3716
# FIXME: No caching of options nor sections yet -- vila 20110503
3718
found_store = None # Where the option value has been found
3719
# If the option is registered, it may provide additional info about
3722
opt = option_registry.get(name)
3727
def expand_and_convert(val):
3728
# This may need to be called in different contexts if the value is
3729
# None or ends up being None during expansion or conversion.
3732
if isinstance(val, string_types):
3733
val = self._expand_options_in_string(val)
3735
trace.warning('Cannot expand "%s":'
3736
' %s does not support option expansion'
3737
% (name, type(val)))
3739
val = found_store.unquote(val)
3741
val = opt.convert_from_unicode(found_store, val)
3744
# First of all, check if the environment can override the configuration
3746
if opt is not None and opt.override_from_env:
3747
value = opt.get_override()
3748
value = expand_and_convert(value)
3750
for store, section in self.iter_sections():
3751
value = section.get(name)
3752
if value is not None:
3755
value = expand_and_convert(value)
3756
if opt is not None and value is None:
3757
# If the option is registered, it may provide a default value
3758
value = opt.get_default()
3759
value = expand_and_convert(value)
3760
for hook in ConfigHooks['get']:
3761
hook(self, name, value)
3764
def expand_options(self, string, env=None):
3765
"""Expand option references in the string in the configuration context.
3767
:param string: The string containing option(s) to expand.
3769
:param env: An option dict defining additional configuration options or
3770
overriding existing ones.
3772
:returns: The expanded string.
3774
return self._expand_options_in_string(string, env)
3776
def _expand_options_in_string(self, string, env=None, _refs=None):
3777
"""Expand options in the string in the configuration context.
3779
:param string: The string to be expanded.
3781
:param env: An option dict defining additional configuration options or
3782
overriding existing ones.
3784
:param _refs: Private list (FIFO) containing the options being expanded
3787
:returns: The expanded string.
3790
# Not much to expand there
3793
# What references are currently resolved (to detect loops)
3796
# We need to iterate until no more refs appear ({{foo}} will need two
3797
# iterations for example).
3802
for is_ref, chunk in iter_option_refs(result):
3804
chunks.append(chunk)
3809
raise OptionExpansionLoop(string, _refs)
3811
value = self._expand_option(name, env, _refs)
3813
raise ExpandingUnknownOption(name, string)
3814
chunks.append(value)
3816
result = ''.join(chunks)
3819
def _expand_option(self, name, env, _refs):
3820
if env is not None and name in env:
3821
# Special case, values provided in env takes precedence over
3825
value = self.get(name, expand=False, convert=False)
3826
value = self._expand_options_in_string(value, env, _refs)
3829
def _get_mutable_section(self):
3830
"""Get the MutableSection for the Stack.
3832
This is where we guarantee that the mutable section is lazily loaded:
3833
this means we won't load the corresponding store before setting a value
3834
or deleting an option. In practice the store will often be loaded but
3835
this helps catching some programming errors.
3838
section = store.get_mutable_section(self.mutable_section_id)
3839
return store, section
3841
def set(self, name, value):
3842
"""Set a new value for the option."""
3843
store, section = self._get_mutable_section()
3844
section.set(name, store.quote(value))
3845
for hook in ConfigHooks['set']:
3846
hook(self, name, value)
3848
def remove(self, name):
3849
"""Remove an existing option."""
3850
_, section = self._get_mutable_section()
3851
section.remove(name)
3852
for hook in ConfigHooks['remove']:
3856
# Mostly for debugging use
3857
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3859
def _get_overrides(self):
3860
if breezy._global_state is not None:
3861
# TODO(jelmer): Urgh, this is circular so we can't call breezy.get_global_state()
3862
return breezy._global_state.cmdline_overrides.get_sections()
3865
def get_shared_store(self, store, state=None):
3866
"""Get a known shared store.
3868
Store urls uniquely identify them and are used to ensure a single copy
3869
is shared across all users.
3871
:param store: The store known to the caller.
3873
:param state: The library state where the known stores are kept.
3875
:returns: The store received if it's not a known one, an already known
3879
# TODO(jelmer): Urgh, this is circular so we can't call breezy.get_global_state()
3880
state = breezy._global_state
3882
global _shared_stores_at_exit_installed
3883
stores = _shared_stores
3885
def save_config_changes():
3886
for k, store in stores.items():
3887
store.save_changes()
3888
if not _shared_stores_at_exit_installed:
3889
# FIXME: Ugly hack waiting for library_state to always be
3890
# available. -- vila 20120731
3892
atexit.register(save_config_changes)
3893
_shared_stores_at_exit_installed = True
3895
stores = state.config_stores
3896
url = store.external_url()
3904
class MemoryStack(Stack):
3905
"""A configuration stack defined from a string.
3907
This is mainly intended for tests and requires no disk resources.
3910
def __init__(self, content=None):
3911
"""Create an in-memory stack from a given content.
3913
It uses a single store based on configobj and support reading and
3916
:param content: The initial content of the store. If None, the store is
3917
not loaded and ``_load_from_string`` can and should be used if
3920
store = IniFileStore()
3921
if content is not None:
3922
store._load_from_string(content)
3923
super(MemoryStack, self).__init__(
3924
[store.get_sections], store)
3927
class _CompatibleStack(Stack):
3928
"""Place holder for compatibility with previous design.
3930
This is intended to ease the transition from the Config-based design to the
3931
Stack-based design and should not be used nor relied upon by plugins.
3933
One assumption made here is that the daughter classes will all use Stores
3934
derived from LockableIniFileStore).
3936
It implements set() and remove () by re-loading the store before applying
3937
the modification and saving it.
3939
The long term plan being to implement a single write by store to save
3940
all modifications, this class should not be used in the interim.
3943
def set(self, name, value):
3946
super(_CompatibleStack, self).set(name, value)
3947
# Force a write to persistent storage
3950
def remove(self, name):
3953
super(_CompatibleStack, self).remove(name)
3954
# Force a write to persistent storage
3958
class GlobalStack(Stack):
3959
"""Global options only stack.
3961
The following sections are queried:
3963
* command-line overrides,
3965
* the 'DEFAULT' section in bazaar.conf
3967
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3972
gstore = self.get_shared_store(GlobalStore())
3973
super(GlobalStack, self).__init__(
3974
[self._get_overrides,
3975
NameMatcher(gstore, 'DEFAULT').get_sections],
3976
gstore, mutable_section_id='DEFAULT')
3979
class LocationStack(Stack):
3980
"""Per-location options falling back to global options stack.
3983
The following sections are queried:
3985
* command-line overrides,
3987
* the sections matching ``location`` in ``locations.conf``, the order being
3988
defined by the number of path components in the section glob, higher
3989
numbers first (from most specific section to most generic).
3991
* the 'DEFAULT' section in bazaar.conf
3993
This stack will use the ``location`` section in locations.conf as its
3997
def __init__(self, location):
3998
"""Make a new stack for a location and global configuration.
4000
:param location: A URL prefix to """
4001
lstore = self.get_shared_store(LocationStore())
4002
if location.startswith('file://'):
4003
location = urlutils.local_path_from_url(location)
4004
gstore = self.get_shared_store(GlobalStore())
4005
super(LocationStack, self).__init__(
4006
[self._get_overrides,
4007
LocationMatcher(lstore, location).get_sections,
4008
NameMatcher(gstore, 'DEFAULT').get_sections],
4009
lstore, mutable_section_id=location)
4012
class BranchStack(Stack):
4013
"""Per-location options falling back to branch then global options stack.
4015
The following sections are queried:
4017
* command-line overrides,
4019
* the sections matching ``location`` in ``locations.conf``, the order being
4020
defined by the number of path components in the section glob, higher
4021
numbers first (from most specific section to most generic),
4023
* the no-name section in branch.conf,
4025
* the ``DEFAULT`` section in ``bazaar.conf``.
4027
This stack will use the no-name section in ``branch.conf`` as its
4031
def __init__(self, branch):
4032
lstore = self.get_shared_store(LocationStore())
4033
bstore = branch._get_config_store()
4034
gstore = self.get_shared_store(GlobalStore())
4035
super(BranchStack, self).__init__(
4036
[self._get_overrides,
4037
LocationMatcher(lstore, branch.base).get_sections,
4038
NameMatcher(bstore, None).get_sections,
4039
NameMatcher(gstore, 'DEFAULT').get_sections],
4041
self.branch = branch
4043
def lock_write(self, token=None):
4044
return self.branch.lock_write(token)
4047
return self.branch.unlock()
4049
def set(self, name, value):
4050
with self.lock_write():
4051
super(BranchStack, self).set(name, value)
4052
# Unlocking the branch will trigger a store.save_changes() so the
4053
# last unlock saves all the changes.
4055
def remove(self, name):
4056
with self.lock_write():
4057
super(BranchStack, self).remove(name)
4058
# Unlocking the branch will trigger a store.save_changes() so the
4059
# last unlock saves all the changes.
4062
class RemoteControlStack(Stack):
4063
"""Remote control-only options stack."""
4065
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4066
# with the stack used for remote bzr dirs. RemoteControlStack only uses
4067
# control.conf and is used only for stack options.
4069
def __init__(self, bzrdir):
4070
cstore = bzrdir._get_config_store()
4071
super(RemoteControlStack, self).__init__(
4072
[NameMatcher(cstore, None).get_sections],
4074
self.controldir = bzrdir
4077
class BranchOnlyStack(Stack):
4078
"""Branch-only options stack."""
4080
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4081
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4082
# -- vila 2011-12-16
4084
def __init__(self, branch):
4085
bstore = branch._get_config_store()
4086
super(BranchOnlyStack, self).__init__(
4087
[NameMatcher(bstore, None).get_sections],
4089
self.branch = branch
4091
def lock_write(self, token=None):
4092
return self.branch.lock_write(token)
4095
return self.branch.unlock()
4097
def set(self, name, value):
4098
with self.lock_write():
4099
super(BranchOnlyStack, self).set(name, value)
4100
# Force a write to persistent storage
4101
self.store.save_changes()
4103
def remove(self, name):
4104
with self.lock_write():
4105
super(BranchOnlyStack, self).remove(name)
4106
# Force a write to persistent storage
4107
self.store.save_changes()
4110
class cmd_config(commands.Command):
4111
__doc__ = """Display, set or remove a configuration option.
4113
Display the active value for option NAME.
4115
If --all is specified, NAME is interpreted as a regular expression and all
4116
matching options are displayed mentioning their scope and without resolving
4117
option references in the value). The active value that bzr will take into
4118
account is the first one displayed for each option.
4120
If NAME is not given, --all .* is implied (all options are displayed for the
4123
Setting a value is achieved by using NAME=value without spaces. The value
4124
is set in the most relevant scope and can be checked by displaying the
4127
Removing a value is achieved by using --remove NAME.
4130
takes_args = ['name?']
4134
# FIXME: This should be a registry option so that plugins can register
4135
# their own config files (or not) and will also address
4136
# http://pad.lv/788991 -- vila 20101115
4137
commands.Option('scope', help='Reduce the scope to the specified'
4138
' configuration file.',
4140
commands.Option('all',
4141
help='Display all the defined values for the matching options.',
4143
commands.Option('remove', help='Remove the option from'
4144
' the configuration file.'),
4147
_see_also = ['configuration']
4149
@commands.display_command
4150
def run(self, name=None, all=False, directory=None, scope=None,
4152
if directory is None:
4154
directory = directory_service.directories.dereference(directory)
4155
directory = urlutils.normalize_url(directory)
4157
raise errors.BzrError(
4158
'--all and --remove are mutually exclusive.')
4160
# Delete the option in the given scope
4161
self._remove_config_option(name, directory, scope)
4163
# Defaults to all options
4164
self._show_matching_options('.*', directory, scope)
4167
name, value = name.split('=', 1)
4169
# Display the option(s) value(s)
4171
self._show_matching_options(name, directory, scope)
4173
self._show_value(name, directory, scope)
4176
raise errors.BzrError(
4177
'Only one option can be set.')
4178
# Set the option value
4179
self._set_config_option(name, value, directory, scope)
4181
def _get_stack(self, directory, scope=None, write_access=False):
4182
"""Get the configuration stack specified by ``directory`` and ``scope``.
4184
:param directory: Where the configurations are derived from.
4186
:param scope: A specific config to start from.
4188
:param write_access: Whether a write access to the stack will be
4191
# FIXME: scope should allow access to plugin-specific stacks (even
4192
# reduced to the plugin-specific store), related to
4193
# http://pad.lv/788991 -- vila 2011-11-15
4194
if scope is not None:
4195
if scope == 'breezy':
4196
return GlobalStack()
4197
elif scope == 'locations':
4198
return LocationStack(directory)
4199
elif scope == 'branch':
4201
controldir.ControlDir.open_containing_tree_or_branch(
4204
self.add_cleanup(br.lock_write().unlock)
4205
return br.get_config_stack()
4206
raise NoSuchConfig(scope)
4210
controldir.ControlDir.open_containing_tree_or_branch(
4213
self.add_cleanup(br.lock_write().unlock)
4214
return br.get_config_stack()
4215
except errors.NotBranchError:
4216
return LocationStack(directory)
4218
def _quote_multiline(self, value):
4220
value = '"""' + value + '"""'
4223
def _show_value(self, name, directory, scope):
4224
conf = self._get_stack(directory, scope)
4225
value = conf.get(name, expand=True, convert=False)
4226
if value is not None:
4227
# Quote the value appropriately
4228
value = self._quote_multiline(value)
4229
self.outf.write('%s\n' % (value,))
4231
raise NoSuchConfigOption(name)
4233
def _show_matching_options(self, name, directory, scope):
4234
name = lazy_regex.lazy_compile(name)
4235
# We want any error in the regexp to be raised *now* so we need to
4236
# avoid the delay introduced by the lazy regexp. But, we still do
4237
# want the nicer errors raised by lazy_regex.
4238
name._compile_and_collapse()
4241
conf = self._get_stack(directory, scope)
4242
for store, section in conf.iter_sections():
4243
for oname in section.iter_option_names():
4244
if name.search(oname):
4245
if cur_store_id != store.id:
4246
# Explain where the options are defined
4247
self.outf.write('%s:\n' % (store.id,))
4248
cur_store_id = store.id
4250
if (section.id is not None and cur_section != section.id):
4251
# Display the section id as it appears in the store
4252
# (None doesn't appear by definition)
4253
self.outf.write(' [%s]\n' % (section.id,))
4254
cur_section = section.id
4255
value = section.get(oname, expand=False)
4256
# Quote the value appropriately
4257
value = self._quote_multiline(value)
4258
self.outf.write(' %s = %s\n' % (oname, value))
4260
def _set_config_option(self, name, value, directory, scope):
4261
conf = self._get_stack(directory, scope, write_access=True)
4262
conf.set(name, value)
4263
# Explicitly save the changes
4264
conf.store.save_changes()
4266
def _remove_config_option(self, name, directory, scope):
4268
raise errors.BzrCommandError(
4269
'--remove expects an option to remove.')
4270
conf = self._get_stack(directory, scope, write_access=True)
4273
# Explicitly save the changes
4274
conf.store.save_changes()
4276
raise NoSuchConfigOption(name)
4281
# We need adapters that can build a Store or a Stack in a test context. Test
4282
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4283
# themselves. The builder will receive a test instance and should return a
4284
# ready-to-use store or stack. Plugins that define new store/stacks can also
4285
# register themselves here to be tested against the tests defined in
4286
# breezy.tests.test_config. Note that the builder can be called multiple times
4287
# for the same test.
4289
# The registered object should be a callable receiving a test instance
4290
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4292
test_store_builder_registry = registry.Registry()
4294
# The registered object should be a callable receiving a test instance
4295
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4297
test_stack_builder_registry = registry.Registry()