2237
2072
del configobj[option_name]
2239
2074
del configobj[section_name][option_name]
2240
for hook in OldConfigHooks['remove']:
2241
hook(self, option_name)
2242
2075
self._set_configobj(configobj)
2244
2077
def _get_config_file(self):
2246
f = StringIO(self._transport.get_bytes(self._filename))
2247
for hook in OldConfigHooks['load']:
2079
return StringIO(self._transport.get_bytes(self._filename))
2250
2080
except errors.NoSuchFile:
2251
2081
return StringIO()
2252
except errors.PermissionDenied, e:
2253
trace.warning("Permission denied while trying to open "
2254
"configuration file %s.", urlutils.unescape_for_display(
2255
urlutils.join(self._transport.base, self._filename), "utf-8"))
2258
def _external_url(self):
2259
return urlutils.join(self._transport.external_url(), self._filename)
2261
2083
def _get_configobj(self):
2262
2084
f = self._get_config_file()
2265
conf = ConfigObj(f, encoding='utf-8')
2266
except configobj.ConfigObjError, e:
2267
raise errors.ParseConfigError(e.errors, self._external_url())
2268
except UnicodeDecodeError:
2269
raise errors.ConfigContentError(self._external_url())
2086
return ConfigObj(f, encoding='utf-8')
2274
2090
def _set_configobj(self, configobj):
2275
2091
out_file = StringIO()
2276
2092
configobj.write(out_file)
2277
2093
out_file.seek(0)
2278
2094
self._transport.put_file(self._filename, out_file)
2279
for hook in OldConfigHooks['save']:
2283
class Option(object):
2284
"""An option definition.
2286
The option *values* are stored in config files and found in sections.
2288
Here we define various properties about the option itself, its default
2289
value, how to convert it from stores, what to do when invalid values are
2290
encoutered, in which config files it can be stored.
2293
def __init__(self, name, override_from_env=None,
2294
default=None, default_from_env=None,
2295
help=None, from_unicode=None, invalid=None, unquote=True):
2296
"""Build an option definition.
2298
:param name: the name used to refer to the option.
2300
:param override_from_env: A list of environment variables which can
2301
provide override any configuration setting.
2303
:param default: the default value to use when none exist in the config
2304
stores. This is either a string that ``from_unicode`` will convert
2305
into the proper type, a callable returning a unicode string so that
2306
``from_unicode`` can be used on the return value, or a python
2307
object that can be stringified (so only the empty list is supported
2310
:param default_from_env: A list of environment variables which can
2311
provide a default value. 'default' will be used only if none of the
2312
variables specified here are set in the environment.
2314
:param help: a doc string to explain the option to the user.
2316
:param from_unicode: a callable to convert the unicode string
2317
representing the option value in a store or its default value.
2319
:param invalid: the action to be taken when an invalid value is
2320
encountered in a store. This is called only when from_unicode is
2321
invoked to convert a string and returns None or raise ValueError or
2322
TypeError. Accepted values are: None (ignore invalid values),
2323
'warning' (emit a warning), 'error' (emit an error message and
2326
:param unquote: should the unicode value be unquoted before conversion.
2327
This should be used only when the store providing the values cannot
2328
safely unquote them (see http://pad.lv/906897). It is provided so
2329
daughter classes can handle the quoting themselves.
2331
if override_from_env is None:
2332
override_from_env = []
2333
if default_from_env is None:
2334
default_from_env = []
2336
self.override_from_env = override_from_env
2337
# Convert the default value to a unicode string so all values are
2338
# strings internally before conversion (via from_unicode) is attempted.
2341
elif isinstance(default, list):
2342
# Only the empty list is supported
2344
raise AssertionError(
2345
'Only empty lists are supported as default values')
2347
elif isinstance(default, (str, unicode, bool, int, float)):
2348
# Rely on python to convert strings, booleans and integers
2349
self.default = u'%s' % (default,)
2350
elif callable(default):
2351
self.default = default
2353
# other python objects are not expected
2354
raise AssertionError('%r is not supported as a default value'
2356
self.default_from_env = default_from_env
2358
self.from_unicode = from_unicode
2359
self.unquote = unquote
2360
if invalid and invalid not in ('warning', 'error'):
2361
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2362
self.invalid = invalid
2368
def convert_from_unicode(self, store, unicode_value):
2369
if self.unquote and store is not None and unicode_value is not None:
2370
unicode_value = store.unquote(unicode_value)
2371
if self.from_unicode is None or unicode_value is None:
2372
# Don't convert or nothing to convert
2373
return unicode_value
2375
converted = self.from_unicode(unicode_value)
2376
except (ValueError, TypeError):
2377
# Invalid values are ignored
2379
if converted is None and self.invalid is not None:
2380
# The conversion failed
2381
if self.invalid == 'warning':
2382
trace.warning('Value "%s" is not valid for "%s"',
2383
unicode_value, self.name)
2384
elif self.invalid == 'error':
2385
raise errors.ConfigOptionValueError(self.name, unicode_value)
2388
def get_override(self):
2390
for var in self.override_from_env:
2392
# If the env variable is defined, its value takes precedence
2393
value = os.environ[var].decode(osutils.get_user_encoding())
2399
def get_default(self):
2401
for var in self.default_from_env:
2403
# If the env variable is defined, its value is the default one
2404
value = os.environ[var].decode(osutils.get_user_encoding())
2409
# Otherwise, fallback to the value defined at registration
2410
if callable(self.default):
2411
value = self.default()
2412
if not isinstance(value, unicode):
2413
raise AssertionError(
2414
"Callable default value for '%s' should be unicode"
2417
value = self.default
2420
def get_help_topic(self):
2423
def get_help_text(self, additional_see_also=None, plain=True):
2425
from bzrlib import help_topics
2426
result += help_topics._format_see_also(additional_see_also)
2428
result = help_topics.help_as_plain_text(result)
2432
# Predefined converters to get proper values from store
2434
def bool_from_store(unicode_str):
2435
return ui.bool_from_string(unicode_str)
2438
def int_from_store(unicode_str):
2439
return int(unicode_str)
2442
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2444
def int_SI_from_store(unicode_str):
2445
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2447
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2448
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2451
:return Integer, expanded to its base-10 value if a proper SI unit is
2452
found, None otherwise.
2454
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2455
p = re.compile(regexp, re.IGNORECASE)
2456
m = p.match(unicode_str)
2459
val, _, unit = m.groups()
2463
coeff = _unit_suffixes[unit.upper()]
2465
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2470
def float_from_store(unicode_str):
2471
return float(unicode_str)
2474
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2476
_list_converter_config = configobj.ConfigObj(
2477
{}, encoding='utf-8', list_values=True, interpolation=False)
2480
class ListOption(Option):
2482
def __init__(self, name, default=None, default_from_env=None,
2483
help=None, invalid=None):
2484
"""A list Option definition.
2486
This overrides the base class so the conversion from a unicode string
2487
can take quoting into account.
2489
super(ListOption, self).__init__(
2490
name, default=default, default_from_env=default_from_env,
2491
from_unicode=self.from_unicode, help=help,
2492
invalid=invalid, unquote=False)
2494
def from_unicode(self, unicode_str):
2495
if not isinstance(unicode_str, basestring):
2497
# Now inject our string directly as unicode. All callers got their
2498
# value from configobj, so values that need to be quoted are already
2500
_list_converter_config.reset()
2501
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2502
maybe_list = _list_converter_config['list']
2503
if isinstance(maybe_list, basestring):
2505
# A single value, most probably the user forgot (or didn't care
2506
# to add) the final ','
2509
# The empty string, convert to empty list
2512
# We rely on ConfigObj providing us with a list already
2517
class RegistryOption(Option):
2518
"""Option for a choice from a registry."""
2520
def __init__(self, name, registry, default_from_env=None,
2521
help=None, invalid=None):
2522
"""A registry based Option definition.
2524
This overrides the base class so the conversion from a unicode string
2525
can take quoting into account.
2527
super(RegistryOption, self).__init__(
2528
name, default=lambda: unicode(registry.default_key),
2529
default_from_env=default_from_env,
2530
from_unicode=self.from_unicode, help=help,
2531
invalid=invalid, unquote=False)
2532
self.registry = registry
2534
def from_unicode(self, unicode_str):
2535
if not isinstance(unicode_str, basestring):
2538
return self.registry.get(unicode_str)
2541
"Invalid value %s for %s."
2542
"See help for a list of possible values." % (unicode_str,
2547
ret = [self._help, "\n\nThe following values are supported:\n"]
2548
for key in self.registry.keys():
2549
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2553
_option_ref_re = lazy_regex.lazy_compile('({[^\d\W](?:\.\w|-\w|\w)*})')
2554
"""Describes an expandable option reference.
2556
We want to match the most embedded reference first.
2558
I.e. for '{{foo}}' we will get '{foo}',
2559
for '{bar{baz}}' we will get '{baz}'
2562
def iter_option_refs(string):
2563
# Split isolate refs so every other chunk is a ref
2565
for chunk in _option_ref_re.split(string):
2570
class OptionRegistry(registry.Registry):
2571
"""Register config options by their name.
2573
This overrides ``registry.Registry`` to simplify registration by acquiring
2574
some information from the option object itself.
2577
def _check_option_name(self, option_name):
2578
"""Ensures an option name is valid.
2580
:param option_name: The name to validate.
2582
if _option_ref_re.match('{%s}' % option_name) is None:
2583
raise errors.IllegalOptionName(option_name)
2585
def register(self, option):
2586
"""Register a new option to its name.
2588
:param option: The option to register. Its name is used as the key.
2590
self._check_option_name(option.name)
2591
super(OptionRegistry, self).register(option.name, option,
2594
def register_lazy(self, key, module_name, member_name):
2595
"""Register a new option to be loaded on request.
2597
:param key: the key to request the option later. Since the registration
2598
is lazy, it should be provided and match the option name.
2600
:param module_name: the python path to the module. Such as 'os.path'.
2602
:param member_name: the member of the module to return. If empty or
2603
None, get() will return the module itself.
2605
self._check_option_name(key)
2606
super(OptionRegistry, self).register_lazy(key,
2607
module_name, member_name)
2609
def get_help(self, key=None):
2610
"""Get the help text associated with the given key"""
2611
option = self.get(key)
2612
the_help = option.help
2613
if callable(the_help):
2614
return the_help(self, key)
2618
option_registry = OptionRegistry()
2621
# Registered options in lexicographical order
2623
option_registry.register(
2624
Option('append_revisions_only',
2625
default=None, from_unicode=bool_from_store, invalid='warning',
2627
Whether to only append revisions to the mainline.
2629
If this is set to true, then it is not possible to change the
2630
existing mainline of the branch.
2632
option_registry.register(
2633
ListOption('acceptable_keys',
2636
List of GPG key patterns which are acceptable for verification.
2638
option_registry.register(
2639
Option('add.maximum_file_size',
2640
default=u'20MB', from_unicode=int_SI_from_store,
2642
Size above which files should be added manually.
2644
Files below this size are added automatically when using ``bzr add`` without
2647
A negative value means disable the size check.
2649
option_registry.register(
2651
default=None, from_unicode=bool_from_store,
2653
Is the branch bound to ``bound_location``.
2655
If set to "True", the branch should act as a checkout, and push each commit to
2656
the bound_location. This option is normally set by ``bind``/``unbind``.
2658
See also: bound_location.
2660
option_registry.register(
2661
Option('bound_location',
2664
The location that commits should go to when acting as a checkout.
2666
This option is normally set by ``bind``.
2670
option_registry.register(
2671
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2673
Whether revisions associated with tags should be fetched.
2675
option_registry.register_lazy(
2676
'bzr.transform.orphan_policy', 'bzrlib.transform', 'opt_transform_orphan')
2677
option_registry.register(
2678
Option('bzr.workingtree.worth_saving_limit', default=10,
2679
from_unicode=int_from_store, invalid='warning',
2681
How many changes before saving the dirstate.
2683
-1 means that we will never rewrite the dirstate file for only
2684
stat-cache changes. Regardless of this setting, we will always rewrite
2685
the dirstate file if a file is added/removed/renamed/etc. This flag only
2686
affects the behavior of updating the dirstate file after we notice that
2687
a file has been touched.
2689
option_registry.register(
2690
Option('bugtracker', default=None,
2692
Default bug tracker to use.
2694
This bug tracker will be used for example when marking bugs
2695
as fixed using ``bzr commit --fixes``, if no explicit
2696
bug tracker was specified.
2698
option_registry.register(
2699
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2700
from_unicode=signature_policy_from_unicode,
2702
GPG checking policy.
2704
Possible values: require, ignore, check-available (default)
2706
this option will control whether bzr will require good gpg
2707
signatures, ignore them, or check them if they are
2710
option_registry.register(
2711
Option('child_submit_format',
2712
help='''The preferred format of submissions to this branch.'''))
2713
option_registry.register(
2714
Option('child_submit_to',
2715
help='''Where submissions to this branch are mailed to.'''))
2716
option_registry.register(
2717
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2718
from_unicode=signing_policy_from_unicode,
2722
Possible values: always, never, when-required (default)
2724
This option controls whether bzr will always create
2725
gpg signatures or not on commits.
2727
option_registry.register(
2728
Option('dirstate.fdatasync', default=True,
2729
from_unicode=bool_from_store,
2731
Flush dirstate changes onto physical disk?
2733
If true (default), working tree metadata changes are flushed through the
2734
OS buffers to physical disk. This is somewhat slower, but means data
2735
should not be lost if the machine crashes. See also repository.fdatasync.
2737
option_registry.register(
2738
ListOption('debug_flags', default=[],
2739
help='Debug flags to activate.'))
2740
option_registry.register(
2741
Option('default_format', default='2a',
2742
help='Format used when creating branches.'))
2743
option_registry.register(
2744
Option('dpush_strict', default=None,
2745
from_unicode=bool_from_store,
2747
The default value for ``dpush --strict``.
2749
If present, defines the ``--strict`` option default value for checking
2750
uncommitted changes before pushing into a different VCS without any
2751
custom bzr metadata.
2753
option_registry.register(
2755
help='The command called to launch an editor to enter a message.'))
2756
option_registry.register(
2757
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2758
help='The users identity'))
2759
option_registry.register(
2760
Option('gpg_signing_command',
2763
Program to use use for creating signatures.
2765
This should support at least the -u and --clearsign options.
2767
option_registry.register(
2768
Option('gpg_signing_key',
2771
GPG key to use for signing.
2773
This defaults to the first key associated with the users email.
2775
option_registry.register(
2776
Option('ignore_missing_extensions', default=False,
2777
from_unicode=bool_from_store,
2779
Control the missing extensions warning display.
2781
The warning will not be emitted if set to True.
2783
option_registry.register(
2785
help='Language to translate messages into.'))
2786
option_registry.register(
2787
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2789
Steal locks that appears to be dead.
2791
If set to True, bzr will check if a lock is supposed to be held by an
2792
active process from the same user on the same machine. If the user and
2793
machine match, but no process with the given PID is active, then bzr
2794
will automatically break the stale lock, and create a new lock for
2796
Otherwise, bzr will prompt as normal to break the lock.
2798
option_registry.register(
2799
Option('log_format', default='long',
2801
Log format to use when displaying revisions.
2803
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2804
may be provided by plugins.
2806
option_registry.register_lazy('mail_client', 'bzrlib.mail_client',
2808
option_registry.register(
2809
Option('output_encoding',
2810
help= 'Unicode encoding for output'
2811
' (terminal encoding if not specified).'))
2812
option_registry.register(
2813
Option('parent_location',
2816
The location of the default branch for pull or merge.
2818
This option is normally set when creating a branch, the first ``pull`` or by
2819
``pull --remember``.
2821
option_registry.register(
2822
Option('post_commit', default=None,
2824
Post commit functions.
2826
An ordered list of python functions to call, separated by spaces.
2828
Each function takes branch, rev_id as parameters.
2830
option_registry.register_lazy('progress_bar', 'bzrlib.ui.text',
2832
option_registry.register(
2833
Option('public_branch',
2836
A publically-accessible version of this branch.
2838
This implies that the branch setting this option is not publically-accessible.
2839
Used and set by ``bzr send``.
2841
option_registry.register(
2842
Option('push_location',
2845
The location of the default branch for push.
2847
This option is normally set by the first ``push`` or ``push --remember``.
2849
option_registry.register(
2850
Option('push_strict', default=None,
2851
from_unicode=bool_from_store,
2853
The default value for ``push --strict``.
2855
If present, defines the ``--strict`` option default value for checking
2856
uncommitted changes before sending a merge directive.
2858
option_registry.register(
2859
Option('repository.fdatasync', default=True,
2860
from_unicode=bool_from_store,
2862
Flush repository changes onto physical disk?
2864
If true (default), repository changes are flushed through the OS buffers
2865
to physical disk. This is somewhat slower, but means data should not be
2866
lost if the machine crashes. See also dirstate.fdatasync.
2868
option_registry.register_lazy('smtp_server',
2869
'bzrlib.smtp_connection', 'smtp_server')
2870
option_registry.register_lazy('smtp_password',
2871
'bzrlib.smtp_connection', 'smtp_password')
2872
option_registry.register_lazy('smtp_username',
2873
'bzrlib.smtp_connection', 'smtp_username')
2874
option_registry.register(
2875
Option('selftest.timeout',
2877
from_unicode=int_from_store,
2878
help='Abort selftest if one test takes longer than this many seconds',
2881
option_registry.register(
2882
Option('send_strict', default=None,
2883
from_unicode=bool_from_store,
2885
The default value for ``send --strict``.
2887
If present, defines the ``--strict`` option default value for checking
2888
uncommitted changes before sending a bundle.
2891
option_registry.register(
2892
Option('serve.client_timeout',
2893
default=300.0, from_unicode=float_from_store,
2894
help="If we wait for a new request from a client for more than"
2895
" X seconds, consider the client idle, and hangup."))
2896
option_registry.register(
2897
Option('stacked_on_location',
2899
help="""The location where this branch is stacked on."""))
2900
option_registry.register(
2901
Option('submit_branch',
2904
The branch you intend to submit your current work to.
2906
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2907
by the ``submit:`` revision spec.
2909
option_registry.register(
2911
help='''Where submissions from this branch are mailed to.'''))
2912
option_registry.register(
2913
ListOption('suppress_warnings',
2915
help="List of warning classes to suppress."))
2916
option_registry.register(
2917
Option('validate_signatures_in_log', default=False,
2918
from_unicode=bool_from_store, invalid='warning',
2919
help='''Whether to validate signatures in bzr log.'''))
2920
option_registry.register_lazy('ssl.ca_certs',
2921
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2923
option_registry.register_lazy('ssl.cert_reqs',
2924
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2927
class Section(object):
2928
"""A section defines a dict of option name => value.
2930
This is merely a read-only dict which can add some knowledge about the
2931
options. It is *not* a python dict object though and doesn't try to mimic
2935
def __init__(self, section_id, options):
2936
self.id = section_id
2937
# We re-use the dict-like object received
2938
self.options = options
2940
def get(self, name, default=None, expand=True):
2941
return self.options.get(name, default)
2943
def iter_option_names(self):
2944
for k in self.options.iterkeys():
2948
# Mostly for debugging use
2949
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2952
_NewlyCreatedOption = object()
2953
"""Was the option created during the MutableSection lifetime"""
2954
_DeletedOption = object()
2955
"""Was the option deleted during the MutableSection lifetime"""
2958
class MutableSection(Section):
2959
"""A section allowing changes and keeping track of the original values."""
2961
def __init__(self, section_id, options):
2962
super(MutableSection, self).__init__(section_id, options)
2963
self.reset_changes()
2965
def set(self, name, value):
2966
if name not in self.options:
2967
# This is a new option
2968
self.orig[name] = _NewlyCreatedOption
2969
elif name not in self.orig:
2970
self.orig[name] = self.get(name, None)
2971
self.options[name] = value
2973
def remove(self, name):
2974
if name not in self.orig and name in self.options:
2975
self.orig[name] = self.get(name, None)
2976
del self.options[name]
2978
def reset_changes(self):
2981
def apply_changes(self, dirty, store):
2982
"""Apply option value changes.
2984
``self`` has been reloaded from the persistent storage. ``dirty``
2985
contains the changes made since the previous loading.
2987
:param dirty: the mutable section containing the changes.
2989
:param store: the store containing the section
2991
for k, expected in dirty.orig.iteritems():
2992
actual = dirty.get(k, _DeletedOption)
2993
reloaded = self.get(k, _NewlyCreatedOption)
2994
if actual is _DeletedOption:
2995
if k in self.options:
2999
# Report concurrent updates in an ad-hoc way. This should only
3000
# occurs when different processes try to update the same option
3001
# which is not supported (as in: the config framework is not meant
3002
# to be used as a sharing mechanism).
3003
if expected != reloaded:
3004
if actual is _DeletedOption:
3005
actual = '<DELETED>'
3006
if reloaded is _NewlyCreatedOption:
3007
reloaded = '<CREATED>'
3008
if expected is _NewlyCreatedOption:
3009
expected = '<CREATED>'
3010
# Someone changed the value since we get it from the persistent
3012
trace.warning(gettext(
3013
"Option {0} in section {1} of {2} was changed"
3014
" from {3} to {4}. The {5} value will be saved.".format(
3015
k, self.id, store.external_url(), expected,
3017
# No need to keep track of these changes
3018
self.reset_changes()
3021
class Store(object):
3022
"""Abstract interface to persistent storage for configuration options."""
3024
readonly_section_class = Section
3025
mutable_section_class = MutableSection
3028
# Which sections need to be saved (by section id). We use a dict here
3029
# so the dirty sections can be shared by multiple callers.
3030
self.dirty_sections = {}
3032
def is_loaded(self):
3033
"""Returns True if the Store has been loaded.
3035
This is used to implement lazy loading and ensure the persistent
3036
storage is queried only when needed.
3038
raise NotImplementedError(self.is_loaded)
3041
"""Loads the Store from persistent storage."""
3042
raise NotImplementedError(self.load)
3044
def _load_from_string(self, bytes):
3045
"""Create a store from a string in configobj syntax.
3047
:param bytes: A string representing the file content.
3049
raise NotImplementedError(self._load_from_string)
3052
"""Unloads the Store.
3054
This should make is_loaded() return False. This is used when the caller
3055
knows that the persistent storage has changed or may have change since
3058
raise NotImplementedError(self.unload)
3060
def quote(self, value):
3061
"""Quote a configuration option value for storing purposes.
3063
This allows Stacks to present values as they will be stored.
3067
def unquote(self, value):
3068
"""Unquote a configuration option value into unicode.
3070
The received value is quoted as stored.
3075
"""Saves the Store to persistent storage."""
3076
raise NotImplementedError(self.save)
3078
def _need_saving(self):
3079
for s in self.dirty_sections.values():
3081
# At least one dirty section contains a modification
3085
def apply_changes(self, dirty_sections):
3086
"""Apply changes from dirty sections while checking for coherency.
3088
The Store content is discarded and reloaded from persistent storage to
3089
acquire up-to-date values.
3091
Dirty sections are MutableSection which kept track of the value they
3092
are expected to update.
3094
# We need an up-to-date version from the persistent storage, unload the
3095
# store. The reload will occur when needed (triggered by the first
3096
# get_mutable_section() call below.
3098
# Apply the changes from the preserved dirty sections
3099
for section_id, dirty in dirty_sections.iteritems():
3100
clean = self.get_mutable_section(section_id)
3101
clean.apply_changes(dirty, self)
3102
# Everything is clean now
3103
self.dirty_sections = {}
3105
def save_changes(self):
3106
"""Saves the Store to persistent storage if changes occurred.
3108
Apply the changes recorded in the mutable sections to a store content
3109
refreshed from persistent storage.
3111
raise NotImplementedError(self.save_changes)
3113
def external_url(self):
3114
raise NotImplementedError(self.external_url)
3116
def get_sections(self):
3117
"""Returns an ordered iterable of existing sections.
3119
:returns: An iterable of (store, section).
3121
raise NotImplementedError(self.get_sections)
3123
def get_mutable_section(self, section_id=None):
3124
"""Returns the specified mutable section.
3126
:param section_id: The section identifier
3128
raise NotImplementedError(self.get_mutable_section)
3131
# Mostly for debugging use
3132
return "<config.%s(%s)>" % (self.__class__.__name__,
3133
self.external_url())
3136
class CommandLineStore(Store):
3137
"A store to carry command line overrides for the config options."""
3139
def __init__(self, opts=None):
3140
super(CommandLineStore, self).__init__()
3147
# The dict should be cleared but not replaced so it can be shared.
3148
self.options.clear()
3150
def _from_cmdline(self, overrides):
3151
# Reset before accepting new definitions
3153
for over in overrides:
3155
name, value = over.split('=', 1)
3157
raise errors.BzrCommandError(
3158
gettext("Invalid '%s', should be of the form 'name=value'")
3160
self.options[name] = value
3162
def external_url(self):
3163
# Not an url but it makes debugging easier and is never needed
3167
def get_sections(self):
3168
yield self, self.readonly_section_class(None, self.options)
3171
class IniFileStore(Store):
3172
"""A config Store using ConfigObj for storage.
3174
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3175
serialize/deserialize the config file.
3179
"""A config Store using ConfigObj for storage.
3181
super(IniFileStore, self).__init__()
3182
self._config_obj = None
3184
def is_loaded(self):
3185
return self._config_obj != None
3188
self._config_obj = None
3189
self.dirty_sections = {}
3191
def _load_content(self):
3192
"""Load the config file bytes.
3194
This should be provided by subclasses
3196
:return: Byte string
3198
raise NotImplementedError(self._load_content)
3200
def _save_content(self, content):
3201
"""Save the config file bytes.
3203
This should be provided by subclasses
3205
:param content: Config file bytes to write
3207
raise NotImplementedError(self._save_content)
3210
"""Load the store from the associated file."""
3211
if self.is_loaded():
3213
content = self._load_content()
3214
self._load_from_string(content)
3215
for hook in ConfigHooks['load']:
3218
def _load_from_string(self, bytes):
3219
"""Create a config store from a string.
3221
:param bytes: A string representing the file content.
3223
if self.is_loaded():
3224
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3225
co_input = StringIO(bytes)
3227
# The config files are always stored utf8-encoded
3228
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3230
except configobj.ConfigObjError, e:
3231
self._config_obj = None
3232
raise errors.ParseConfigError(e.errors, self.external_url())
3233
except UnicodeDecodeError:
3234
raise errors.ConfigContentError(self.external_url())
3236
def save_changes(self):
3237
if not self.is_loaded():
3240
if not self._need_saving():
3242
# Preserve the current version
3243
dirty_sections = dict(self.dirty_sections.items())
3244
self.apply_changes(dirty_sections)
3245
# Save to the persistent storage
3249
if not self.is_loaded():
3253
self._config_obj.write(out)
3254
self._save_content(out.getvalue())
3255
for hook in ConfigHooks['save']:
3258
def get_sections(self):
3259
"""Get the configobj section in the file order.
3261
:returns: An iterable of (store, section).
3263
# We need a loaded store
3266
except (errors.NoSuchFile, errors.PermissionDenied):
3267
# If the file can't be read, there is no sections
3269
cobj = self._config_obj
3271
yield self, self.readonly_section_class(None, cobj)
3272
for section_name in cobj.sections:
3274
self.readonly_section_class(section_name,
3275
cobj[section_name]))
3277
def get_mutable_section(self, section_id=None):
3278
# We need a loaded store
3281
except errors.NoSuchFile:
3282
# The file doesn't exist, let's pretend it was empty
3283
self._load_from_string('')
3284
if section_id in self.dirty_sections:
3285
# We already created a mutable section for this id
3286
return self.dirty_sections[section_id]
3287
if section_id is None:
3288
section = self._config_obj
3290
section = self._config_obj.setdefault(section_id, {})
3291
mutable_section = self.mutable_section_class(section_id, section)
3292
# All mutable sections can become dirty
3293
self.dirty_sections[section_id] = mutable_section
3294
return mutable_section
3296
def quote(self, value):
3298
# configobj conflates automagical list values and quoting
3299
self._config_obj.list_values = True
3300
return self._config_obj._quote(value)
3302
self._config_obj.list_values = False
3304
def unquote(self, value):
3305
if value and isinstance(value, basestring):
3306
# _unquote doesn't handle None nor empty strings nor anything that
3307
# is not a string, really.
3308
value = self._config_obj._unquote(value)
3311
def external_url(self):
3312
# Since an IniFileStore can be used without a file (at least in tests),
3313
# it's better to provide something than raising a NotImplementedError.
3314
# All daughter classes are supposed to provide an implementation
3316
return 'In-Process Store, no URL'
3319
class TransportIniFileStore(IniFileStore):
3320
"""IniFileStore that loads files from a transport.
3322
:ivar transport: The transport object where the config file is located.
3324
:ivar file_name: The config file basename in the transport directory.
3327
def __init__(self, transport, file_name):
3328
"""A Store using a ini file on a Transport
3330
:param transport: The transport object where the config file is located.
3331
:param file_name: The config file basename in the transport directory.
3333
super(TransportIniFileStore, self).__init__()
3334
self.transport = transport
3335
self.file_name = file_name
3337
def _load_content(self):
3339
return self.transport.get_bytes(self.file_name)
3340
except errors.PermissionDenied:
3341
trace.warning("Permission denied while trying to load "
3342
"configuration store %s.", self.external_url())
3345
def _save_content(self, content):
3346
self.transport.put_bytes(self.file_name, content)
3348
def external_url(self):
3349
# FIXME: external_url should really accepts an optional relpath
3350
# parameter (bug #750169) :-/ -- vila 2011-04-04
3351
# The following will do in the interim but maybe we don't want to
3352
# expose a path here but rather a config ID and its associated
3353
# object </hand wawe>.
3354
return urlutils.join(self.transport.external_url(), self.file_name)
3357
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3358
# unlockable stores for use with objects that can already ensure the locking
3359
# (think branches). If different stores (not based on ConfigObj) are created,
3360
# they may face the same issue.
3363
class LockableIniFileStore(TransportIniFileStore):
3364
"""A ConfigObjStore using locks on save to ensure store integrity."""
3366
def __init__(self, transport, file_name, lock_dir_name=None):
3367
"""A config Store using ConfigObj for storage.
3369
:param transport: The transport object where the config file is located.
3371
:param file_name: The config file basename in the transport directory.
3373
if lock_dir_name is None:
3374
lock_dir_name = 'lock'
3375
self.lock_dir_name = lock_dir_name
3376
super(LockableIniFileStore, self).__init__(transport, file_name)
3377
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3379
def lock_write(self, token=None):
3380
"""Takes a write lock in the directory containing the config file.
3382
If the directory doesn't exist it is created.
3384
# FIXME: This doesn't check the ownership of the created directories as
3385
# ensure_config_dir_exists does. It should if the transport is local
3386
# -- vila 2011-04-06
3387
self.transport.create_prefix()
3388
return self._lock.lock_write(token)
3393
def break_lock(self):
3394
self._lock.break_lock()
3398
# We need to be able to override the undecorated implementation
3399
self.save_without_locking()
3401
def save_without_locking(self):
3402
super(LockableIniFileStore, self).save()
3405
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3406
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3407
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3409
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3410
# functions or a registry will make it easier and clearer for tests, focusing
3411
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3412
# on a poolie's remark)
3413
class GlobalStore(LockableIniFileStore):
3414
"""A config store for global options.
3416
There is a single GlobalStore for a given process.
3419
def __init__(self, possible_transports=None):
3420
t = transport.get_transport_from_path(
3421
config_dir(), possible_transports=possible_transports)
3422
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3426
class LocationStore(LockableIniFileStore):
3427
"""A config store for options specific to a location.
3429
There is a single LocationStore for a given process.
3432
def __init__(self, possible_transports=None):
3433
t = transport.get_transport_from_path(
3434
config_dir(), possible_transports=possible_transports)
3435
super(LocationStore, self).__init__(t, 'locations.conf')
3436
self.id = 'locations'
3439
class BranchStore(TransportIniFileStore):
3440
"""A config store for branch options.
3442
There is a single BranchStore for a given branch.
3445
def __init__(self, branch):
3446
super(BranchStore, self).__init__(branch.control_transport,
3448
self.branch = branch
3452
class ControlStore(LockableIniFileStore):
3454
def __init__(self, bzrdir):
3455
super(ControlStore, self).__init__(bzrdir.transport,
3457
lock_dir_name='branch_lock')
3461
class SectionMatcher(object):
3462
"""Select sections into a given Store.
3464
This is intended to be used to postpone getting an iterable of sections
3468
def __init__(self, store):
3471
def get_sections(self):
3472
# This is where we require loading the store so we can see all defined
3474
sections = self.store.get_sections()
3475
# Walk the revisions in the order provided
3476
for store, s in sections:
3480
def match(self, section):
3481
"""Does the proposed section match.
3483
:param section: A Section object.
3485
:returns: True if the section matches, False otherwise.
3487
raise NotImplementedError(self.match)
3490
class NameMatcher(SectionMatcher):
3492
def __init__(self, store, section_id):
3493
super(NameMatcher, self).__init__(store)
3494
self.section_id = section_id
3496
def match(self, section):
3497
return section.id == self.section_id
3500
class LocationSection(Section):
3502
def __init__(self, section, extra_path, branch_name=None):
3503
super(LocationSection, self).__init__(section.id, section.options)
3504
self.extra_path = extra_path
3505
if branch_name is None:
3507
self.locals = {'relpath': extra_path,
3508
'basename': urlutils.basename(extra_path),
3509
'branchname': branch_name}
3511
def get(self, name, default=None, expand=True):
3512
value = super(LocationSection, self).get(name, default)
3513
if value is not None and expand:
3514
policy_name = self.get(name + ':policy', None)
3515
policy = _policy_value.get(policy_name, POLICY_NONE)
3516
if policy == POLICY_APPENDPATH:
3517
value = urlutils.join(value, self.extra_path)
3518
# expand section local options right now (since POLICY_APPENDPATH
3519
# will never add options references, it's ok to expand after it).
3521
for is_ref, chunk in iter_option_refs(value):
3523
chunks.append(chunk)
3526
if ref in self.locals:
3527
chunks.append(self.locals[ref])
3529
chunks.append(chunk)
3530
value = ''.join(chunks)
3534
class StartingPathMatcher(SectionMatcher):
3535
"""Select sections for a given location respecting the Store order."""
3537
# FIXME: Both local paths and urls can be used for section names as well as
3538
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3539
# inherited the fuzziness from the previous ``LocationConfig``
3540
# implementation. We probably need to revisit which encoding is allowed for
3541
# both ``location`` and section names and how we normalize
3542
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3543
# related too. -- vila 2012-01-04
3545
def __init__(self, store, location):
3546
super(StartingPathMatcher, self).__init__(store)
3547
if location.startswith('file://'):
3548
location = urlutils.local_path_from_url(location)
3549
self.location = location
3551
def get_sections(self):
3552
"""Get all sections matching ``location`` in the store.
3554
The most generic sections are described first in the store, then more
3555
specific ones can be provided for reduced scopes.
3557
The returned section are therefore returned in the reversed order so
3558
the most specific ones can be found first.
3560
location_parts = self.location.rstrip('/').split('/')
3562
# Later sections are more specific, they should be returned first
3563
for _, section in reversed(list(store.get_sections())):
3564
if section.id is None:
3565
# The no-name section is always included if present
3566
yield store, LocationSection(section, self.location)
3568
section_path = section.id
3569
if section_path.startswith('file://'):
3570
# the location is already a local path or URL, convert the
3571
# section id to the same format
3572
section_path = urlutils.local_path_from_url(section_path)
3573
if (self.location.startswith(section_path)
3574
or fnmatch.fnmatch(self.location, section_path)):
3575
section_parts = section_path.rstrip('/').split('/')
3576
extra_path = '/'.join(location_parts[len(section_parts):])
3577
yield store, LocationSection(section, extra_path)
3580
class LocationMatcher(SectionMatcher):
3582
def __init__(self, store, location):
3583
super(LocationMatcher, self).__init__(store)
3584
url, params = urlutils.split_segment_parameters(location)
3585
if location.startswith('file://'):
3586
location = urlutils.local_path_from_url(location)
3587
self.location = location
3588
branch_name = params.get('branch')
3589
if branch_name is None:
3590
self.branch_name = urlutils.basename(self.location)
3592
self.branch_name = urlutils.unescape(branch_name)
3594
def _get_matching_sections(self):
3595
"""Get all sections matching ``location``."""
3596
# We slightly diverge from LocalConfig here by allowing the no-name
3597
# section as the most generic one and the lower priority.
3598
no_name_section = None
3600
# Filter out the no_name_section so _iter_for_location_by_parts can be
3601
# used (it assumes all sections have a name).
3602
for _, section in self.store.get_sections():
3603
if section.id is None:
3604
no_name_section = section
3606
all_sections.append(section)
3607
# Unfortunately _iter_for_location_by_parts deals with section names so
3608
# we have to resync.
3609
filtered_sections = _iter_for_location_by_parts(
3610
[s.id for s in all_sections], self.location)
3611
iter_all_sections = iter(all_sections)
3612
matching_sections = []
3613
if no_name_section is not None:
3614
matching_sections.append(
3615
(0, LocationSection(no_name_section, self.location)))
3616
for section_id, extra_path, length in filtered_sections:
3617
# a section id is unique for a given store so it's safe to take the
3618
# first matching section while iterating. Also, all filtered
3619
# sections are part of 'all_sections' and will always be found
3622
section = iter_all_sections.next()
3623
if section_id == section.id:
3624
section = LocationSection(section, extra_path,
3626
matching_sections.append((length, section))
3628
return matching_sections
3630
def get_sections(self):
3631
# Override the default implementation as we want to change the order
3632
matching_sections = self._get_matching_sections()
3633
# We want the longest (aka more specific) locations first
3634
sections = sorted(matching_sections,
3635
key=lambda (length, section): (length, section.id),
3637
# Sections mentioning 'ignore_parents' restrict the selection
3638
for _, section in sections:
3639
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3640
ignore = section.get('ignore_parents', None)
3641
if ignore is not None:
3642
ignore = ui.bool_from_string(ignore)
3645
# Finally, we have a valid section
3646
yield self.store, section
3649
# FIXME: _shared_stores should be an attribute of a library state once a
3650
# library_state object is always available.
3652
_shared_stores_at_exit_installed = False
3654
class Stack(object):
3655
"""A stack of configurations where an option can be defined"""
3657
def __init__(self, sections_def, store=None, mutable_section_id=None):
3658
"""Creates a stack of sections with an optional store for changes.
3660
:param sections_def: A list of Section or callables that returns an
3661
iterable of Section. This defines the Sections for the Stack and
3662
can be called repeatedly if needed.
3664
:param store: The optional Store where modifications will be
3665
recorded. If none is specified, no modifications can be done.
3667
:param mutable_section_id: The id of the MutableSection where changes
3668
are recorded. This requires the ``store`` parameter to be
3671
self.sections_def = sections_def
3673
self.mutable_section_id = mutable_section_id
3675
def iter_sections(self):
3676
"""Iterate all the defined sections."""
3677
# Ensuring lazy loading is achieved by delaying section matching (which
3678
# implies querying the persistent storage) until it can't be avoided
3679
# anymore by using callables to describe (possibly empty) section
3681
for sections in self.sections_def:
3682
for store, section in sections():
3683
yield store, section
3685
def get(self, name, expand=True, convert=True):
3686
"""Return the *first* option value found in the sections.
3688
This is where we guarantee that sections coming from Store are loaded
3689
lazily: the loading is delayed until we need to either check that an
3690
option exists or get its value, which in turn may require to discover
3691
in which sections it can be defined. Both of these (section and option
3692
existence) require loading the store (even partially).
3694
:param name: The queried option.
3696
:param expand: Whether options references should be expanded.
3698
:param convert: Whether the option value should be converted from
3699
unicode (do nothing for non-registered options).
3701
:returns: The value of the option.
3703
# FIXME: No caching of options nor sections yet -- vila 20110503
3705
found_store = None # Where the option value has been found
3706
# If the option is registered, it may provide additional info about
3709
opt = option_registry.get(name)
3714
def expand_and_convert(val):
3715
# This may need to be called in different contexts if the value is
3716
# None or ends up being None during expansion or conversion.
3719
if isinstance(val, basestring):
3720
val = self._expand_options_in_string(val)
3722
trace.warning('Cannot expand "%s":'
3723
' %s does not support option expansion'
3724
% (name, type(val)))
3726
val = found_store.unquote(val)
3728
val = opt.convert_from_unicode(found_store, val)
3731
# First of all, check if the environment can override the configuration
3733
if opt is not None and opt.override_from_env:
3734
value = opt.get_override()
3735
value = expand_and_convert(value)
3737
for store, section in self.iter_sections():
3738
value = section.get(name)
3739
if value is not None:
3742
value = expand_and_convert(value)
3743
if opt is not None and value is None:
3744
# If the option is registered, it may provide a default value
3745
value = opt.get_default()
3746
value = expand_and_convert(value)
3747
for hook in ConfigHooks['get']:
3748
hook(self, name, value)
3751
def expand_options(self, string, env=None):
3752
"""Expand option references in the string in the configuration context.
3754
:param string: The string containing option(s) to expand.
3756
:param env: An option dict defining additional configuration options or
3757
overriding existing ones.
3759
:returns: The expanded string.
3761
return self._expand_options_in_string(string, env)
3763
def _expand_options_in_string(self, string, env=None, _refs=None):
3764
"""Expand options in the string in the configuration context.
3766
:param string: The string to be expanded.
3768
:param env: An option dict defining additional configuration options or
3769
overriding existing ones.
3771
:param _refs: Private list (FIFO) containing the options being expanded
3774
:returns: The expanded string.
3777
# Not much to expand there
3780
# What references are currently resolved (to detect loops)
3783
# We need to iterate until no more refs appear ({{foo}} will need two
3784
# iterations for example).
3789
for is_ref, chunk in iter_option_refs(result):
3791
chunks.append(chunk)
3796
raise errors.OptionExpansionLoop(string, _refs)
3798
value = self._expand_option(name, env, _refs)
3800
raise errors.ExpandingUnknownOption(name, string)
3801
chunks.append(value)
3803
result = ''.join(chunks)
3806
def _expand_option(self, name, env, _refs):
3807
if env is not None and name in env:
3808
# Special case, values provided in env takes precedence over
3812
value = self.get(name, expand=False, convert=False)
3813
value = self._expand_options_in_string(value, env, _refs)
3816
def _get_mutable_section(self):
3817
"""Get the MutableSection for the Stack.
3819
This is where we guarantee that the mutable section is lazily loaded:
3820
this means we won't load the corresponding store before setting a value
3821
or deleting an option. In practice the store will often be loaded but
3822
this helps catching some programming errors.
3825
section = store.get_mutable_section(self.mutable_section_id)
3826
return store, section
3828
def set(self, name, value):
3829
"""Set a new value for the option."""
3830
store, section = self._get_mutable_section()
3831
section.set(name, store.quote(value))
3832
for hook in ConfigHooks['set']:
3833
hook(self, name, value)
3835
def remove(self, name):
3836
"""Remove an existing option."""
3837
_, section = self._get_mutable_section()
3838
section.remove(name)
3839
for hook in ConfigHooks['remove']:
3843
# Mostly for debugging use
3844
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3846
def _get_overrides(self):
3847
# FIXME: Hack around library_state.initialize never called
3848
if bzrlib.global_state is not None:
3849
return bzrlib.global_state.cmdline_overrides.get_sections()
3852
def get_shared_store(self, store, state=None):
3853
"""Get a known shared store.
3855
Store urls uniquely identify them and are used to ensure a single copy
3856
is shared across all users.
3858
:param store: The store known to the caller.
3860
:param state: The library state where the known stores are kept.
3862
:returns: The store received if it's not a known one, an already known
3866
state = bzrlib.global_state
3868
global _shared_stores_at_exit_installed
3869
stores = _shared_stores
3870
def save_config_changes():
3871
for k, store in stores.iteritems():
3872
store.save_changes()
3873
if not _shared_stores_at_exit_installed:
3874
# FIXME: Ugly hack waiting for library_state to always be
3875
# available. -- vila 20120731
3877
atexit.register(save_config_changes)
3878
_shared_stores_at_exit_installed = True
3880
stores = state.config_stores
3881
url = store.external_url()
3889
class MemoryStack(Stack):
3890
"""A configuration stack defined from a string.
3892
This is mainly intended for tests and requires no disk resources.
3895
def __init__(self, content=None):
3896
"""Create an in-memory stack from a given content.
3898
It uses a single store based on configobj and support reading and
3901
:param content: The initial content of the store. If None, the store is
3902
not loaded and ``_load_from_string`` can and should be used if
3905
store = IniFileStore()
3906
if content is not None:
3907
store._load_from_string(content)
3908
super(MemoryStack, self).__init__(
3909
[store.get_sections], store)
3912
class _CompatibleStack(Stack):
3913
"""Place holder for compatibility with previous design.
3915
This is intended to ease the transition from the Config-based design to the
3916
Stack-based design and should not be used nor relied upon by plugins.
3918
One assumption made here is that the daughter classes will all use Stores
3919
derived from LockableIniFileStore).
3921
It implements set() and remove () by re-loading the store before applying
3922
the modification and saving it.
3924
The long term plan being to implement a single write by store to save
3925
all modifications, this class should not be used in the interim.
3928
def set(self, name, value):
3931
super(_CompatibleStack, self).set(name, value)
3932
# Force a write to persistent storage
3935
def remove(self, name):
3938
super(_CompatibleStack, self).remove(name)
3939
# Force a write to persistent storage
3943
class GlobalStack(Stack):
3944
"""Global options only stack.
3946
The following sections are queried:
3948
* command-line overrides,
3950
* the 'DEFAULT' section in bazaar.conf
3952
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3957
gstore = self.get_shared_store(GlobalStore())
3958
super(GlobalStack, self).__init__(
3959
[self._get_overrides,
3960
NameMatcher(gstore, 'DEFAULT').get_sections],
3961
gstore, mutable_section_id='DEFAULT')
3964
class LocationStack(Stack):
3965
"""Per-location options falling back to global options stack.
3968
The following sections are queried:
3970
* command-line overrides,
3972
* the sections matching ``location`` in ``locations.conf``, the order being
3973
defined by the number of path components in the section glob, higher
3974
numbers first (from most specific section to most generic).
3976
* the 'DEFAULT' section in bazaar.conf
3978
This stack will use the ``location`` section in locations.conf as its
3982
def __init__(self, location):
3983
"""Make a new stack for a location and global configuration.
3985
:param location: A URL prefix to """
3986
lstore = self.get_shared_store(LocationStore())
3987
if location.startswith('file://'):
3988
location = urlutils.local_path_from_url(location)
3989
gstore = self.get_shared_store(GlobalStore())
3990
super(LocationStack, self).__init__(
3991
[self._get_overrides,
3992
LocationMatcher(lstore, location).get_sections,
3993
NameMatcher(gstore, 'DEFAULT').get_sections],
3994
lstore, mutable_section_id=location)
3997
class BranchStack(Stack):
3998
"""Per-location options falling back to branch then global options stack.
4000
The following sections are queried:
4002
* command-line overrides,
4004
* the sections matching ``location`` in ``locations.conf``, the order being
4005
defined by the number of path components in the section glob, higher
4006
numbers first (from most specific section to most generic),
4008
* the no-name section in branch.conf,
4010
* the ``DEFAULT`` section in ``bazaar.conf``.
4012
This stack will use the no-name section in ``branch.conf`` as its
4016
def __init__(self, branch):
4017
lstore = self.get_shared_store(LocationStore())
4018
bstore = branch._get_config_store()
4019
gstore = self.get_shared_store(GlobalStore())
4020
super(BranchStack, self).__init__(
4021
[self._get_overrides,
4022
LocationMatcher(lstore, branch.base).get_sections,
4023
NameMatcher(bstore, None).get_sections,
4024
NameMatcher(gstore, 'DEFAULT').get_sections],
4026
self.branch = branch
4028
def lock_write(self, token=None):
4029
return self.branch.lock_write(token)
4032
return self.branch.unlock()
4035
def set(self, name, value):
4036
super(BranchStack, self).set(name, value)
4037
# Unlocking the branch will trigger a store.save_changes() so the last
4038
# unlock saves all the changes.
4041
def remove(self, name):
4042
super(BranchStack, self).remove(name)
4043
# Unlocking the branch will trigger a store.save_changes() so the last
4044
# unlock saves all the changes.
4047
class RemoteControlStack(Stack):
4048
"""Remote control-only options stack."""
4050
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4051
# with the stack used for remote bzr dirs. RemoteControlStack only uses
4052
# control.conf and is used only for stack options.
4054
def __init__(self, bzrdir):
4055
cstore = bzrdir._get_config_store()
4056
super(RemoteControlStack, self).__init__(
4057
[NameMatcher(cstore, None).get_sections],
4059
self.bzrdir = bzrdir
4062
class BranchOnlyStack(Stack):
4063
"""Branch-only options stack."""
4065
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4066
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4067
# -- vila 2011-12-16
4069
def __init__(self, branch):
4070
bstore = branch._get_config_store()
4071
super(BranchOnlyStack, self).__init__(
4072
[NameMatcher(bstore, None).get_sections],
4074
self.branch = branch
4076
def lock_write(self, token=None):
4077
return self.branch.lock_write(token)
4080
return self.branch.unlock()
4083
def set(self, name, value):
4084
super(BranchOnlyStack, self).set(name, value)
4085
# Force a write to persistent storage
4086
self.store.save_changes()
4089
def remove(self, name):
4090
super(BranchOnlyStack, self).remove(name)
4091
# Force a write to persistent storage
4092
self.store.save_changes()
4095
2097
class cmd_config(commands.Command):
4096
2098
__doc__ = """Display, set or remove a configuration option.
4098
Display the active value for option NAME.
2100
Display the active value for a given option.
4100
2102
If --all is specified, NAME is interpreted as a regular expression and all
4101
matching options are displayed mentioning their scope and without resolving
4102
option references in the value). The active value that bzr will take into
4103
account is the first one displayed for each option.
4105
If NAME is not given, --all .* is implied (all options are displayed for the
4108
Setting a value is achieved by using NAME=value without spaces. The value
2103
matching options are displayed mentioning their scope. The active value
2104
that bzr will take into account is the first one displayed for each option.
2106
If no NAME is given, --all .* is implied.
2108
Setting a value is achieved by using name=value without spaces. The value
4109
2109
is set in the most relevant scope and can be checked by displaying the
4112
Removing a value is achieved by using --remove NAME.
4115
2113
takes_args = ['name?']
added
removed
bzrlib/config.py
