1508
2280
configobj[name] = value
1510
2282
configobj.setdefault(section, {})[name] = value
2283
for hook in OldConfigHooks['set']:
2284
hook(self, name, value)
2285
self._set_configobj(configobj)
2287
def remove_option(self, option_name, section_name=None):
2288
configobj = self._get_configobj()
2289
if section_name is None:
2290
del configobj[option_name]
2292
del configobj[section_name][option_name]
2293
for hook in OldConfigHooks['remove']:
2294
hook(self, option_name)
1511
2295
self._set_configobj(configobj)
1513
2297
def _get_config_file(self):
1515
return StringIO(self._transport.get_bytes(self._filename))
2299
f = StringIO(self._transport.get_bytes(self._filename))
2300
for hook in OldConfigHooks['load']:
1516
2303
except errors.NoSuchFile:
1517
2304
return StringIO()
2305
except errors.PermissionDenied, e:
2306
trace.warning("Permission denied while trying to open "
2307
"configuration file %s.", urlutils.unescape_for_display(
2308
urlutils.join(self._transport.base, self._filename), "utf-8"))
2311
def _external_url(self):
2312
return urlutils.join(self._transport.external_url(), self._filename)
1519
2314
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
2315
f = self._get_config_file()
2318
conf = ConfigObj(f, encoding='utf-8')
2319
except configobj.ConfigObjError, e:
2320
raise errors.ParseConfigError(e.errors, self._external_url())
2321
except UnicodeDecodeError:
2322
raise errors.ConfigContentError(self._external_url())
1522
2327
def _set_configobj(self, configobj):
1523
2328
out_file = StringIO()
1524
2329
configobj.write(out_file)
1525
2330
out_file.seek(0)
1526
2331
self._transport.put_file(self._filename, out_file)
2332
for hook in OldConfigHooks['save']:
2336
class Option(object):
2337
"""An option definition.
2339
The option *values* are stored in config files and found in sections.
2341
Here we define various properties about the option itself, its default
2342
value, how to convert it from stores, what to do when invalid values are
2343
encoutered, in which config files it can be stored.
2346
def __init__(self, name, default=None, default_from_env=None,
2347
help=None, from_unicode=None, invalid=None,
2349
"""Build an option definition.
2351
:param name: the name used to refer to the option.
2353
:param default: the default value to use when none exist in the config
2354
stores. This is either a string that ``from_unicode`` will convert
2355
into the proper type, a callable returning a unicode string so that
2356
``from_unicode`` can be used on the return value, or a python
2357
object that can be stringified (so only the empty list is supported
2360
:param default_from_env: A list of environment variables which can
2361
provide a default value. 'default' will be used only if none of the
2362
variables specified here are set in the environment.
2364
:param help: a doc string to explain the option to the user.
2366
:param from_unicode: a callable to convert the unicode string
2367
representing the option value in a store. This is not called for
2370
:param invalid: the action to be taken when an invalid value is
2371
encountered in a store. This is called only when from_unicode is
2372
invoked to convert a string and returns None or raise ValueError or
2373
TypeError. Accepted values are: None (ignore invalid values),
2374
'warning' (emit a warning), 'error' (emit an error message and
2377
:param unquote: should the unicode value be unquoted before conversion.
2378
This should be used only when the store providing the values cannot
2379
safely unquote them (see http://pad.lv/906897). It is provided so
2380
daughter classes can handle the quoting themselves.
2382
if default_from_env is None:
2383
default_from_env = []
2385
# Convert the default value to a unicode string so all values are
2386
# strings internally before conversion (via from_unicode) is attempted.
2389
elif isinstance(default, list):
2390
# Only the empty list is supported
2392
raise AssertionError(
2393
'Only empty lists are supported as default values')
2395
elif isinstance(default, (str, unicode, bool, int, float)):
2396
# Rely on python to convert strings, booleans and integers
2397
self.default = u'%s' % (default,)
2398
elif callable(default):
2399
self.default = default
2401
# other python objects are not expected
2402
raise AssertionError('%r is not supported as a default value'
2404
self.default_from_env = default_from_env
2406
self.from_unicode = from_unicode
2407
self.unquote = unquote
2408
if invalid and invalid not in ('warning', 'error'):
2409
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2410
self.invalid = invalid
2412
def convert_from_unicode(self, store, unicode_value):
2413
if self.unquote and store is not None and unicode_value is not None:
2414
unicode_value = store.unquote(unicode_value)
2415
if self.from_unicode is None or unicode_value is None:
2416
# Don't convert or nothing to convert
2417
return unicode_value
2419
converted = self.from_unicode(unicode_value)
2420
except (ValueError, TypeError):
2421
# Invalid values are ignored
2423
if converted is None and self.invalid is not None:
2424
# The conversion failed
2425
if self.invalid == 'warning':
2426
trace.warning('Value "%s" is not valid for "%s"',
2427
unicode_value, self.name)
2428
elif self.invalid == 'error':
2429
raise errors.ConfigOptionValueError(self.name, unicode_value)
2432
def get_default(self):
2434
for var in self.default_from_env:
2436
# If the env variable is defined, its value is the default one
2437
value = os.environ[var].decode(osutils.get_user_encoding())
2442
# Otherwise, fallback to the value defined at registration
2443
if callable(self.default):
2444
value = self.default()
2445
if not isinstance(value, unicode):
2446
raise AssertionError(
2447
'Callable default values should be unicode')
2449
value = self.default
2452
def get_help_text(self, additional_see_also=None, plain=True):
2454
from bzrlib import help_topics
2455
result += help_topics._format_see_also(additional_see_also)
2457
result = help_topics.help_as_plain_text(result)
2461
# Predefined converters to get proper values from store
2463
def bool_from_store(unicode_str):
2464
return ui.bool_from_string(unicode_str)
2467
def int_from_store(unicode_str):
2468
return int(unicode_str)
2471
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2473
def int_SI_from_store(unicode_str):
2474
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2476
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2477
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2480
:return Integer, expanded to its base-10 value if a proper SI unit is
2481
found, None otherwise.
2483
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2484
p = re.compile(regexp, re.IGNORECASE)
2485
m = p.match(unicode_str)
2488
val, _, unit = m.groups()
2492
coeff = _unit_suffixes[unit.upper()]
2494
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2499
def float_from_store(unicode_str):
2500
return float(unicode_str)
2503
# Use a an empty dict to initialize an empty configobj avoiding all
2504
# parsing and encoding checks
2505
_list_converter_config = configobj.ConfigObj(
2506
{}, encoding='utf-8', list_values=True, interpolation=False)
2509
class ListOption(Option):
2511
def __init__(self, name, default=None, default_from_env=None,
2512
help=None, invalid=None):
2513
"""A list Option definition.
2515
This overrides the base class so the conversion from a unicode string
2516
can take quoting into account.
2518
super(ListOption, self).__init__(
2519
name, default=default, default_from_env=default_from_env,
2520
from_unicode=self.from_unicode, help=help,
2521
invalid=invalid, unquote=False)
2523
def from_unicode(self, unicode_str):
2524
if not isinstance(unicode_str, basestring):
2526
# Now inject our string directly as unicode. All callers got their
2527
# value from configobj, so values that need to be quoted are already
2529
_list_converter_config.reset()
2530
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2531
maybe_list = _list_converter_config['list']
2532
if isinstance(maybe_list, basestring):
2534
# A single value, most probably the user forgot (or didn't care
2535
# to add) the final ','
2538
# The empty string, convert to empty list
2541
# We rely on ConfigObj providing us with a list already
2546
class OptionRegistry(registry.Registry):
2547
"""Register config options by their name.
2549
This overrides ``registry.Registry`` to simplify registration by acquiring
2550
some information from the option object itself.
2553
def register(self, option):
2554
"""Register a new option to its name.
2556
:param option: The option to register. Its name is used as the key.
2558
super(OptionRegistry, self).register(option.name, option,
2561
def register_lazy(self, key, module_name, member_name):
2562
"""Register a new option to be loaded on request.
2564
:param key: the key to request the option later. Since the registration
2565
is lazy, it should be provided and match the option name.
2567
:param module_name: the python path to the module. Such as 'os.path'.
2569
:param member_name: the member of the module to return. If empty or
2570
None, get() will return the module itself.
2572
super(OptionRegistry, self).register_lazy(key,
2573
module_name, member_name)
2575
def get_help(self, key=None):
2576
"""Get the help text associated with the given key"""
2577
option = self.get(key)
2578
the_help = option.help
2579
if callable(the_help):
2580
return the_help(self, key)
2584
option_registry = OptionRegistry()
2587
# Registered options in lexicographical order
2589
option_registry.register(
2590
Option('append_revisions_only',
2591
default=None, from_unicode=bool_from_store, invalid='warning',
2593
Whether to only append revisions to the mainline.
2595
If this is set to true, then it is not possible to change the
2596
existing mainline of the branch.
2598
option_registry.register(
2599
ListOption('acceptable_keys',
2602
List of GPG key patterns which are acceptable for verification.
2604
option_registry.register(
2605
Option('add.maximum_file_size',
2606
default=u'20MB', from_unicode=int_SI_from_store,
2608
Size above which files should be added manually.
2610
Files below this size are added automatically when using ``bzr add`` without
2613
A negative value means disable the size check.
2615
option_registry.register(
2617
default=None, from_unicode=bool_from_store,
2619
Is the branch bound to ``bound_location``.
2621
If set to "True", the branch should act as a checkout, and push each commit to
2622
the bound_location. This option is normally set by ``bind``/``unbind``.
2624
See also: bound_location.
2626
option_registry.register(
2627
Option('bound_location',
2630
The location that commits should go to when acting as a checkout.
2632
This option is normally set by ``bind``.
2636
option_registry.register(
2637
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2639
Whether revisions associated with tags should be fetched.
2641
option_registry.register(
2642
Option('bzr.workingtree.worth_saving_limit', default=10,
2643
from_unicode=int_from_store, invalid='warning',
2645
How many changes before saving the dirstate.
2647
-1 means that we will never rewrite the dirstate file for only
2648
stat-cache changes. Regardless of this setting, we will always rewrite
2649
the dirstate file if a file is added/removed/renamed/etc. This flag only
2650
affects the behavior of updating the dirstate file after we notice that
2651
a file has been touched.
2653
option_registry.register(
2654
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2655
from_unicode=signature_policy_from_unicode,
2657
GPG checking policy.
2659
Possible values: require, ignore, check-available (default)
2661
this option will control whether bzr will require good gpg
2662
signatures, ignore them, or check them if they are
2665
option_registry.register(
2666
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2667
from_unicode=signing_policy_from_unicode,
2671
Possible values: always, never, when-required (default)
2673
This option controls whether bzr will always create
2674
gpg signatures or not on commits.
2676
option_registry.register(
2677
Option('dirstate.fdatasync', default=True,
2678
from_unicode=bool_from_store,
2680
Flush dirstate changes onto physical disk?
2682
If true (default), working tree metadata changes are flushed through the
2683
OS buffers to physical disk. This is somewhat slower, but means data
2684
should not be lost if the machine crashes. See also repository.fdatasync.
2686
option_registry.register(
2687
ListOption('debug_flags', default=[],
2688
help='Debug flags to activate.'))
2689
option_registry.register(
2690
Option('default_format', default='2a',
2691
help='Format used when creating branches.'))
2692
option_registry.register(
2693
Option('dpush_strict', default=None,
2694
from_unicode=bool_from_store,
2696
The default value for ``dpush --strict``.
2698
If present, defines the ``--strict`` option default value for checking
2699
uncommitted changes before pushing into a different VCS without any
2700
custom bzr metadata.
2702
option_registry.register(
2704
help='The command called to launch an editor to enter a message.'))
2705
option_registry.register(
2706
Option('email', default=default_email,
2707
from_unicode=email_from_store,
2708
help='The users identity'))
2709
option_registry.register(
2710
Option('gpg_signing_command',
2713
Program to use use for creating signatures.
2715
This should support at least the -u and --clearsign options.
2717
option_registry.register(
2718
Option('gpg_signing_key',
2721
GPG key to use for signing.
2723
This defaults to the first key associated with the users email.
2725
option_registry.register(
2726
Option('ignore_missing_extensions', default=False,
2727
from_unicode=bool_from_store,
2729
Control the missing extensions warning display.
2731
The warning will not be emitted if set to True.
2733
option_registry.register(
2735
help='Language to translate messages into.'))
2736
option_registry.register(
2737
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2739
Steal locks that appears to be dead.
2741
If set to True, bzr will check if a lock is supposed to be held by an
2742
active process from the same user on the same machine. If the user and
2743
machine match, but no process with the given PID is active, then bzr
2744
will automatically break the stale lock, and create a new lock for
2746
Otherwise, bzr will prompt as normal to break the lock.
2748
option_registry.register(
2749
Option('log_format', default='long',
2751
Log format to use when displaying revisions.
2753
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2754
may be provided by plugins.
2756
option_registry.register(
2757
Option('output_encoding',
2758
help= 'Unicode encoding for output'
2759
' (terminal encoding if not specified).'))
2760
option_registry.register(
2761
Option('parent_location',
2764
The location of the default branch for pull or merge.
2766
This option is normally set when creating a branch, the first ``pull`` or by
2767
``pull --remember``.
2769
option_registry.register(
2770
Option('post_commit', default=None,
2772
Post commit functions.
2774
An ordered list of python functions to call, separated by spaces.
2776
Each function takes branch, rev_id as parameters.
2778
option_registry.register(
2779
Option('public_branch',
2782
A publically-accessible version of this branch.
2784
This implies that the branch setting this option is not publically-accessible.
2785
Used and set by ``bzr send``.
2787
option_registry.register(
2788
Option('push_location',
2791
The location of the default branch for push.
2793
This option is normally set by the first ``push`` or ``push --remember``.
2795
option_registry.register(
2796
Option('push_strict', default=None,
2797
from_unicode=bool_from_store,
2799
The default value for ``push --strict``.
2801
If present, defines the ``--strict`` option default value for checking
2802
uncommitted changes before sending a merge directive.
2804
option_registry.register(
2805
Option('repository.fdatasync', default=True,
2806
from_unicode=bool_from_store,
2808
Flush repository changes onto physical disk?
2810
If true (default), repository changes are flushed through the OS buffers
2811
to physical disk. This is somewhat slower, but means data should not be
2812
lost if the machine crashes. See also dirstate.fdatasync.
2814
option_registry.register_lazy('smtp_server',
2815
'bzrlib.smtp_connection', 'smtp_server')
2816
option_registry.register_lazy('smtp_password',
2817
'bzrlib.smtp_connection', 'smtp_password')
2818
option_registry.register_lazy('smtp_username',
2819
'bzrlib.smtp_connection', 'smtp_username')
2820
option_registry.register(
2821
Option('selftest.timeout',
2823
from_unicode=int_from_store,
2824
help='Abort selftest if one test takes longer than this many seconds',
2827
option_registry.register(
2828
Option('send_strict', default=None,
2829
from_unicode=bool_from_store,
2831
The default value for ``send --strict``.
2833
If present, defines the ``--strict`` option default value for checking
2834
uncommitted changes before sending a bundle.
2837
option_registry.register(
2838
Option('serve.client_timeout',
2839
default=300.0, from_unicode=float_from_store,
2840
help="If we wait for a new request from a client for more than"
2841
" X seconds, consider the client idle, and hangup."))
2842
option_registry.register(
2843
Option('stacked_on_location',
2845
help="""The location where this branch is stacked on."""))
2846
option_registry.register(
2847
Option('submit_branch',
2850
The branch you intend to submit your current work to.
2852
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2853
by the ``submit:`` revision spec.
2857
class Section(object):
2858
"""A section defines a dict of option name => value.
2860
This is merely a read-only dict which can add some knowledge about the
2861
options. It is *not* a python dict object though and doesn't try to mimic
2865
def __init__(self, section_id, options):
2866
self.id = section_id
2867
# We re-use the dict-like object received
2868
self.options = options
2870
def get(self, name, default=None, expand=True):
2871
return self.options.get(name, default)
2873
def iter_option_names(self):
2874
for k in self.options.iterkeys():
2878
# Mostly for debugging use
2879
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2882
_NewlyCreatedOption = object()
2883
"""Was the option created during the MutableSection lifetime"""
2886
class MutableSection(Section):
2887
"""A section allowing changes and keeping track of the original values."""
2889
def __init__(self, section_id, options):
2890
super(MutableSection, self).__init__(section_id, options)
2893
def set(self, name, value):
2894
if name not in self.options:
2895
# This is a new option
2896
self.orig[name] = _NewlyCreatedOption
2897
elif name not in self.orig:
2898
self.orig[name] = self.get(name, None)
2899
self.options[name] = value
2901
def remove(self, name):
2902
if name not in self.orig:
2903
self.orig[name] = self.get(name, None)
2904
del self.options[name]
2907
class Store(object):
2908
"""Abstract interface to persistent storage for configuration options."""
2910
readonly_section_class = Section
2911
mutable_section_class = MutableSection
2913
def is_loaded(self):
2914
"""Returns True if the Store has been loaded.
2916
This is used to implement lazy loading and ensure the persistent
2917
storage is queried only when needed.
2919
raise NotImplementedError(self.is_loaded)
2922
"""Loads the Store from persistent storage."""
2923
raise NotImplementedError(self.load)
2925
def _load_from_string(self, bytes):
2926
"""Create a store from a string in configobj syntax.
2928
:param bytes: A string representing the file content.
2930
raise NotImplementedError(self._load_from_string)
2933
"""Unloads the Store.
2935
This should make is_loaded() return False. This is used when the caller
2936
knows that the persistent storage has changed or may have change since
2939
raise NotImplementedError(self.unload)
2941
def quote(self, value):
2942
"""Quote a configuration option value for storing purposes.
2944
This allows Stacks to present values as they will be stored.
2948
def unquote(self, value):
2949
"""Unquote a configuration option value into unicode.
2951
The received value is quoted as stored.
2956
"""Saves the Store to persistent storage."""
2957
raise NotImplementedError(self.save)
2959
def external_url(self):
2960
raise NotImplementedError(self.external_url)
2962
def get_sections(self):
2963
"""Returns an ordered iterable of existing sections.
2965
:returns: An iterable of (store, section).
2967
raise NotImplementedError(self.get_sections)
2969
def get_mutable_section(self, section_id=None):
2970
"""Returns the specified mutable section.
2972
:param section_id: The section identifier
2974
raise NotImplementedError(self.get_mutable_section)
2977
# Mostly for debugging use
2978
return "<config.%s(%s)>" % (self.__class__.__name__,
2979
self.external_url())
2982
class CommandLineStore(Store):
2983
"A store to carry command line overrides for the config options."""
2985
def __init__(self, opts=None):
2986
super(CommandLineStore, self).__init__()
2992
# The dict should be cleared but not replaced so it can be shared.
2993
self.options.clear()
2995
def _from_cmdline(self, overrides):
2996
# Reset before accepting new definitions
2998
for over in overrides:
3000
name, value = over.split('=', 1)
3002
raise errors.BzrCommandError(
3003
gettext("Invalid '%s', should be of the form 'name=value'")
3005
self.options[name] = value
3007
def external_url(self):
3008
# Not an url but it makes debugging easier and is never needed
3012
def get_sections(self):
3013
yield self, self.readonly_section_class('cmdline_overrides',
3017
class IniFileStore(Store):
3018
"""A config Store using ConfigObj for storage.
3020
:ivar transport: The transport object where the config file is located.
3022
:ivar file_name: The config file basename in the transport directory.
3024
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3025
serialize/deserialize the config file.
3029
"""A config Store using ConfigObj for storage.
3031
super(IniFileStore, self).__init__()
3032
self._config_obj = None
3034
def is_loaded(self):
3035
return self._config_obj != None
3038
self._config_obj = None
3040
def _load_content(self):
3041
"""Load the config file bytes.
3043
This should be provided by subclasses
3045
:return: Byte string
3047
raise NotImplementedError(self._load_content)
3049
def _save_content(self, content):
3050
"""Save the config file bytes.
3052
This should be provided by subclasses
3054
:param content: Config file bytes to write
3056
raise NotImplementedError(self._save_content)
3059
"""Load the store from the associated file."""
3060
if self.is_loaded():
3062
content = self._load_content()
3063
self._load_from_string(content)
3064
for hook in ConfigHooks['load']:
3067
def _load_from_string(self, bytes):
3068
"""Create a config store from a string.
3070
:param bytes: A string representing the file content.
3072
if self.is_loaded():
3073
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3074
co_input = StringIO(bytes)
3076
# The config files are always stored utf8-encoded
3077
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3079
except configobj.ConfigObjError, e:
3080
self._config_obj = None
3081
raise errors.ParseConfigError(e.errors, self.external_url())
3082
except UnicodeDecodeError:
3083
raise errors.ConfigContentError(self.external_url())
3086
if not self.is_loaded():
3090
self._config_obj.write(out)
3091
self._save_content(out.getvalue())
3092
for hook in ConfigHooks['save']:
3095
def get_sections(self):
3096
"""Get the configobj section in the file order.
3098
:returns: An iterable of (store, section).
3100
# We need a loaded store
3103
except (errors.NoSuchFile, errors.PermissionDenied):
3104
# If the file can't be read, there is no sections
3106
cobj = self._config_obj
3108
yield self, self.readonly_section_class(None, cobj)
3109
for section_name in cobj.sections:
3111
self.readonly_section_class(section_name,
3112
cobj[section_name]))
3114
def get_mutable_section(self, section_id=None):
3115
# We need a loaded store
3118
except errors.NoSuchFile:
3119
# The file doesn't exist, let's pretend it was empty
3120
self._load_from_string('')
3121
if section_id is None:
3122
section = self._config_obj
3124
section = self._config_obj.setdefault(section_id, {})
3125
return self.mutable_section_class(section_id, section)
3127
def quote(self, value):
3129
# configobj conflates automagical list values and quoting
3130
self._config_obj.list_values = True
3131
return self._config_obj._quote(value)
3133
self._config_obj.list_values = False
3135
def unquote(self, value):
3137
# _unquote doesn't handle None nor empty strings
3138
value = self._config_obj._unquote(value)
3142
class TransportIniFileStore(IniFileStore):
3143
"""IniFileStore that loads files from a transport.
3146
def __init__(self, transport, file_name):
3147
"""A Store using a ini file on a Transport
3149
:param transport: The transport object where the config file is located.
3150
:param file_name: The config file basename in the transport directory.
3152
super(TransportIniFileStore, self).__init__()
3153
self.transport = transport
3154
self.file_name = file_name
3156
def _load_content(self):
3158
return self.transport.get_bytes(self.file_name)
3159
except errors.PermissionDenied:
3160
trace.warning("Permission denied while trying to load "
3161
"configuration store %s.", self.external_url())
3164
def _save_content(self, content):
3165
self.transport.put_bytes(self.file_name, content)
3167
def external_url(self):
3168
# FIXME: external_url should really accepts an optional relpath
3169
# parameter (bug #750169) :-/ -- vila 2011-04-04
3170
# The following will do in the interim but maybe we don't want to
3171
# expose a path here but rather a config ID and its associated
3172
# object </hand wawe>.
3173
return urlutils.join(self.transport.external_url(), self.file_name)
3176
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3177
# unlockable stores for use with objects that can already ensure the locking
3178
# (think branches). If different stores (not based on ConfigObj) are created,
3179
# they may face the same issue.
3182
class LockableIniFileStore(TransportIniFileStore):
3183
"""A ConfigObjStore using locks on save to ensure store integrity."""
3185
def __init__(self, transport, file_name, lock_dir_name=None):
3186
"""A config Store using ConfigObj for storage.
3188
:param transport: The transport object where the config file is located.
3190
:param file_name: The config file basename in the transport directory.
3192
if lock_dir_name is None:
3193
lock_dir_name = 'lock'
3194
self.lock_dir_name = lock_dir_name
3195
super(LockableIniFileStore, self).__init__(transport, file_name)
3196
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3198
def lock_write(self, token=None):
3199
"""Takes a write lock in the directory containing the config file.
3201
If the directory doesn't exist it is created.
3203
# FIXME: This doesn't check the ownership of the created directories as
3204
# ensure_config_dir_exists does. It should if the transport is local
3205
# -- vila 2011-04-06
3206
self.transport.create_prefix()
3207
return self._lock.lock_write(token)
3212
def break_lock(self):
3213
self._lock.break_lock()
3217
# We need to be able to override the undecorated implementation
3218
self.save_without_locking()
3220
def save_without_locking(self):
3221
super(LockableIniFileStore, self).save()
3224
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3225
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3226
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3228
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3229
# functions or a registry will make it easier and clearer for tests, focusing
3230
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3231
# on a poolie's remark)
3232
class GlobalStore(LockableIniFileStore):
3234
def __init__(self, possible_transports=None):
3235
t = transport.get_transport_from_path(
3236
config_dir(), possible_transports=possible_transports)
3237
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3241
class LocationStore(LockableIniFileStore):
3243
def __init__(self, possible_transports=None):
3244
t = transport.get_transport_from_path(
3245
config_dir(), possible_transports=possible_transports)
3246
super(LocationStore, self).__init__(t, 'locations.conf')
3247
self.id = 'locations'
3250
class BranchStore(TransportIniFileStore):
3252
def __init__(self, branch):
3253
super(BranchStore, self).__init__(branch.control_transport,
3255
self.branch = branch
3258
def lock_write(self, token=None):
3259
return self.branch.lock_write(token)
3262
return self.branch.unlock()
3266
# We need to be able to override the undecorated implementation
3267
self.save_without_locking()
3269
def save_without_locking(self):
3270
super(BranchStore, self).save()
3273
class ControlStore(LockableIniFileStore):
3275
def __init__(self, bzrdir):
3276
super(ControlStore, self).__init__(bzrdir.transport,
3278
lock_dir_name='branch_lock')
3281
class SectionMatcher(object):
3282
"""Select sections into a given Store.
3284
This is intended to be used to postpone getting an iterable of sections
3288
def __init__(self, store):
3291
def get_sections(self):
3292
# This is where we require loading the store so we can see all defined
3294
sections = self.store.get_sections()
3295
# Walk the revisions in the order provided
3296
for store, s in sections:
3300
def match(self, section):
3301
"""Does the proposed section match.
3303
:param section: A Section object.
3305
:returns: True if the section matches, False otherwise.
3307
raise NotImplementedError(self.match)
3310
class NameMatcher(SectionMatcher):
3312
def __init__(self, store, section_id):
3313
super(NameMatcher, self).__init__(store)
3314
self.section_id = section_id
3316
def match(self, section):
3317
return section.id == self.section_id
3320
class LocationSection(Section):
3322
def __init__(self, section, length, extra_path):
3323
super(LocationSection, self).__init__(section.id, section.options)
3324
self.length = length
3325
self.extra_path = extra_path
3326
self.locals = {'relpath': extra_path,
3327
'basename': urlutils.basename(extra_path)}
3329
def get(self, name, default=None, expand=True):
3330
value = super(LocationSection, self).get(name, default)
3331
if value is not None and expand:
3332
policy_name = self.get(name + ':policy', None)
3333
policy = _policy_value.get(policy_name, POLICY_NONE)
3334
if policy == POLICY_APPENDPATH:
3335
value = urlutils.join(value, self.extra_path)
3336
# expand section local options right now (since POLICY_APPENDPATH
3337
# will never add options references, it's ok to expand after it).
3339
for is_ref, chunk in iter_option_refs(value):
3341
chunks.append(chunk)
3344
if ref in self.locals:
3345
chunks.append(self.locals[ref])
3347
chunks.append(chunk)
3348
value = ''.join(chunks)
3352
class LocationMatcher(SectionMatcher):
3354
def __init__(self, store, location):
3355
super(LocationMatcher, self).__init__(store)
3356
if location.startswith('file://'):
3357
location = urlutils.local_path_from_url(location)
3358
self.location = location
3360
def _get_matching_sections(self):
3361
"""Get all sections matching ``location``."""
3362
# We slightly diverge from LocalConfig here by allowing the no-name
3363
# section as the most generic one and the lower priority.
3364
no_name_section = None
3366
# Filter out the no_name_section so _iter_for_location_by_parts can be
3367
# used (it assumes all sections have a name).
3368
for _, section in self.store.get_sections():
3369
if section.id is None:
3370
no_name_section = section
3372
all_sections.append(section)
3373
# Unfortunately _iter_for_location_by_parts deals with section names so
3374
# we have to resync.
3375
filtered_sections = _iter_for_location_by_parts(
3376
[s.id for s in all_sections], self.location)
3377
iter_all_sections = iter(all_sections)
3378
matching_sections = []
3379
if no_name_section is not None:
3380
matching_sections.append(
3381
LocationSection(no_name_section, 0, self.location))
3382
for section_id, extra_path, length in filtered_sections:
3383
# a section id is unique for a given store so it's safe to take the
3384
# first matching section while iterating. Also, all filtered
3385
# sections are part of 'all_sections' and will always be found
3388
section = iter_all_sections.next()
3389
if section_id == section.id:
3390
matching_sections.append(
3391
LocationSection(section, length, extra_path))
3393
return matching_sections
3395
def get_sections(self):
3396
# Override the default implementation as we want to change the order
3397
matching_sections = self._get_matching_sections()
3398
# We want the longest (aka more specific) locations first
3399
sections = sorted(matching_sections,
3400
key=lambda section: (section.length, section.id),
3402
# Sections mentioning 'ignore_parents' restrict the selection
3403
for section in sections:
3404
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3405
ignore = section.get('ignore_parents', None)
3406
if ignore is not None:
3407
ignore = ui.bool_from_string(ignore)
3410
# Finally, we have a valid section
3411
yield self.store, section
3414
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3415
"""Describes an expandable option reference.
3417
We want to match the most embedded reference first.
3419
I.e. for '{{foo}}' we will get '{foo}',
3420
for '{bar{baz}}' we will get '{baz}'
3423
def iter_option_refs(string):
3424
# Split isolate refs so every other chunk is a ref
3426
for chunk in _option_ref_re.split(string):
3431
class Stack(object):
3432
"""A stack of configurations where an option can be defined"""
3434
def __init__(self, sections_def, store=None, mutable_section_id=None):
3435
"""Creates a stack of sections with an optional store for changes.
3437
:param sections_def: A list of Section or callables that returns an
3438
iterable of Section. This defines the Sections for the Stack and
3439
can be called repeatedly if needed.
3441
:param store: The optional Store where modifications will be
3442
recorded. If none is specified, no modifications can be done.
3444
:param mutable_section_id: The id of the MutableSection where changes
3445
are recorded. This requires the ``store`` parameter to be
3448
self.sections_def = sections_def
3450
self.mutable_section_id = mutable_section_id
3452
def get(self, name, expand=None):
3453
"""Return the *first* option value found in the sections.
3455
This is where we guarantee that sections coming from Store are loaded
3456
lazily: the loading is delayed until we need to either check that an
3457
option exists or get its value, which in turn may require to discover
3458
in which sections it can be defined. Both of these (section and option
3459
existence) require loading the store (even partially).
3461
:param name: The queried option.
3463
:param expand: Whether options references should be expanded.
3465
:returns: The value of the option.
3467
# FIXME: No caching of options nor sections yet -- vila 20110503
3469
expand = _get_expand_default_value()
3471
# Ensuring lazy loading is achieved by delaying section matching (which
3472
# implies querying the persistent storage) until it can't be avoided
3473
# anymore by using callables to describe (possibly empty) section
3475
found_store = None # Where the option value has been found
3476
for sections in self.sections_def:
3477
for store, section in sections():
3478
value = section.get(name)
3479
if value is not None:
3482
if value is not None:
3484
# If the option is registered, it may provide additional info about
3487
opt = option_registry.get(name)
3491
def expand_and_convert(val):
3492
# This may need to be called twice if the value is None or ends up
3493
# being None during expansion or conversion.
3496
if isinstance(val, basestring):
3497
val = self._expand_options_in_string(val)
3499
trace.warning('Cannot expand "%s":'
3500
' %s does not support option expansion'
3501
% (name, type(val)))
3503
val = found_store.unquote(val)
3505
val = opt.convert_from_unicode(found_store, val)
3507
value = expand_and_convert(value)
3508
if opt is not None and value is None:
3509
# If the option is registered, it may provide a default value
3510
value = opt.get_default()
3511
value = expand_and_convert(value)
3512
for hook in ConfigHooks['get']:
3513
hook(self, name, value)
3516
def expand_options(self, string, env=None):
3517
"""Expand option references in the string in the configuration context.
3519
:param string: The string containing option(s) to expand.
3521
:param env: An option dict defining additional configuration options or
3522
overriding existing ones.
3524
:returns: The expanded string.
3526
return self._expand_options_in_string(string, env)
3528
def _expand_options_in_string(self, string, env=None, _refs=None):
3529
"""Expand options in the string in the configuration context.
3531
:param string: The string to be expanded.
3533
:param env: An option dict defining additional configuration options or
3534
overriding existing ones.
3536
:param _refs: Private list (FIFO) containing the options being expanded
3539
:returns: The expanded string.
3542
# Not much to expand there
3545
# What references are currently resolved (to detect loops)
3548
# We need to iterate until no more refs appear ({{foo}} will need two
3549
# iterations for example).
3554
for is_ref, chunk in iter_option_refs(result):
3556
chunks.append(chunk)
3561
raise errors.OptionExpansionLoop(string, _refs)
3563
value = self._expand_option(name, env, _refs)
3565
raise errors.ExpandingUnknownOption(name, string)
3566
chunks.append(value)
3568
result = ''.join(chunks)
3571
def _expand_option(self, name, env, _refs):
3572
if env is not None and name in env:
3573
# Special case, values provided in env takes precedence over
3577
value = self.get(name, expand=False)
3578
value = self._expand_options_in_string(value, env, _refs)
3581
def _get_mutable_section(self):
3582
"""Get the MutableSection for the Stack.
3584
This is where we guarantee that the mutable section is lazily loaded:
3585
this means we won't load the corresponding store before setting a value
3586
or deleting an option. In practice the store will often be loaded but
3587
this helps catching some programming errors.
3590
section = store.get_mutable_section(self.mutable_section_id)
3591
return store, section
3593
def set(self, name, value):
3594
"""Set a new value for the option."""
3595
store, section = self._get_mutable_section()
3596
section.set(name, store.quote(value))
3597
for hook in ConfigHooks['set']:
3598
hook(self, name, value)
3600
def remove(self, name):
3601
"""Remove an existing option."""
3602
_, section = self._get_mutable_section()
3603
section.remove(name)
3604
for hook in ConfigHooks['remove']:
3608
# Mostly for debugging use
3609
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3611
def _get_overrides(self):
3612
# Hack around library_state.initialize never called
3613
if bzrlib.global_state is not None:
3614
return bzrlib.global_state.cmdline_overrides.get_sections()
3618
class MemoryStack(Stack):
3619
"""A configuration stack defined from a string.
3621
This is mainly intended for tests and requires no disk resources.
3624
def __init__(self, content=None):
3625
"""Create an in-memory stack from a given content.
3627
It uses a single store based on configobj and support reading and
3630
:param content: The initial content of the store. If None, the store is
3631
not loaded and ``_load_from_string`` can and should be used if
3634
store = IniFileStore()
3635
if content is not None:
3636
store._load_from_string(content)
3637
super(MemoryStack, self).__init__(
3638
[store.get_sections], store)
3641
class _CompatibleStack(Stack):
3642
"""Place holder for compatibility with previous design.
3644
This is intended to ease the transition from the Config-based design to the
3645
Stack-based design and should not be used nor relied upon by plugins.
3647
One assumption made here is that the daughter classes will all use Stores
3648
derived from LockableIniFileStore).
3650
It implements set() and remove () by re-loading the store before applying
3651
the modification and saving it.
3653
The long term plan being to implement a single write by store to save
3654
all modifications, this class should not be used in the interim.
3657
def set(self, name, value):
3660
super(_CompatibleStack, self).set(name, value)
3661
# Force a write to persistent storage
3664
def remove(self, name):
3667
super(_CompatibleStack, self).remove(name)
3668
# Force a write to persistent storage
3672
class GlobalStack(_CompatibleStack):
3673
"""Global options only stack.
3675
The following sections are queried:
3677
* command-line overrides,
3679
* the 'DEFAULT' section in bazaar.conf
3681
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3686
gstore = GlobalStore()
3687
super(GlobalStack, self).__init__(
3688
[self._get_overrides,
3689
NameMatcher(gstore, 'DEFAULT').get_sections],
3690
gstore, mutable_section_id='DEFAULT')
3693
class LocationStack(_CompatibleStack):
3694
"""Per-location options falling back to global options stack.
3697
The following sections are queried:
3699
* command-line overrides,
3701
* the sections matching ``location`` in ``locations.conf``, the order being
3702
defined by the number of path components in the section glob, higher
3703
numbers first (from most specific section to most generic).
3705
* the 'DEFAULT' section in bazaar.conf
3707
This stack will use the ``location`` section in locations.conf as its
3711
def __init__(self, location):
3712
"""Make a new stack for a location and global configuration.
3714
:param location: A URL prefix to """
3715
lstore = LocationStore()
3716
if location.startswith('file://'):
3717
location = urlutils.local_path_from_url(location)
3718
gstore = GlobalStore()
3719
super(LocationStack, self).__init__(
3720
[self._get_overrides,
3721
LocationMatcher(lstore, location).get_sections,
3722
NameMatcher(gstore, 'DEFAULT').get_sections],
3723
lstore, mutable_section_id=location)
3726
class BranchStack(_CompatibleStack):
3727
"""Per-location options falling back to branch then global options stack.
3729
The following sections are queried:
3731
* command-line overrides,
3733
* the sections matching ``location`` in ``locations.conf``, the order being
3734
defined by the number of path components in the section glob, higher
3735
numbers first (from most specific section to most generic),
3737
* the no-name section in branch.conf,
3739
* the ``DEFAULT`` section in ``bazaar.conf``.
3741
This stack will use the no-name section in ``branch.conf`` as its
3745
def __init__(self, branch):
3746
lstore = LocationStore()
3747
bstore = branch._get_config_store()
3748
gstore = GlobalStore()
3749
super(BranchStack, self).__init__(
3750
[self._get_overrides,
3751
LocationMatcher(lstore, branch.base).get_sections,
3752
NameMatcher(bstore, None).get_sections,
3753
NameMatcher(gstore, 'DEFAULT').get_sections],
3755
self.branch = branch
3758
class RemoteControlStack(_CompatibleStack):
3759
"""Remote control-only options stack."""
3761
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3762
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3763
# control.conf and is used only for stack options.
3765
def __init__(self, bzrdir):
3766
cstore = bzrdir._get_config_store()
3767
super(RemoteControlStack, self).__init__(
3768
[NameMatcher(cstore, None).get_sections],
3770
self.bzrdir = bzrdir
3773
class BranchOnlyStack(_CompatibleStack):
3774
"""Branch-only options stack."""
3776
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
3777
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
3778
# -- vila 2011-12-16
3780
def __init__(self, branch):
3781
bstore = branch._get_config_store()
3782
super(BranchOnlyStack, self).__init__(
3783
[NameMatcher(bstore, None).get_sections],
3785
self.branch = branch
3788
# Use a an empty dict to initialize an empty configobj avoiding all
3789
# parsing and encoding checks
3790
_quoting_config = configobj.ConfigObj(
3791
{}, encoding='utf-8', interpolation=False, list_values=True)
3793
class cmd_config(commands.Command):
3794
__doc__ = """Display, set or remove a configuration option.
3796
Display the active value for a given option.
3798
If --all is specified, NAME is interpreted as a regular expression and all
3799
matching options are displayed mentioning their scope. The active value
3800
that bzr will take into account is the first one displayed for each option.
3802
If no NAME is given, --all .* is implied.
3804
Setting a value is achieved by using name=value without spaces. The value
3805
is set in the most relevant scope and can be checked by displaying the
3809
takes_args = ['name?']
3813
# FIXME: This should be a registry option so that plugins can register
3814
# their own config files (or not) and will also address
3815
# http://pad.lv/788991 -- vila 20101115
3816
commands.Option('scope', help='Reduce the scope to the specified'
3817
' configuration file.',
3819
commands.Option('all',
3820
help='Display all the defined values for the matching options.',
3822
commands.Option('remove', help='Remove the option from'
3823
' the configuration file.'),
3826
_see_also = ['configuration']
3828
@commands.display_command
3829
def run(self, name=None, all=False, directory=None, scope=None,
3831
if directory is None:
3833
directory = urlutils.normalize_url(directory)
3835
raise errors.BzrError(
3836
'--all and --remove are mutually exclusive.')
3838
# Delete the option in the given scope
3839
self._remove_config_option(name, directory, scope)
3841
# Defaults to all options
3842
self._show_matching_options('.*', directory, scope)
3845
name, value = name.split('=', 1)
3847
# Display the option(s) value(s)
3849
self._show_matching_options(name, directory, scope)
3851
self._show_value(name, directory, scope)
3854
raise errors.BzrError(
3855
'Only one option can be set.')
3856
# Set the option value
3857
self._set_config_option(name, value, directory, scope)
3859
def _get_stack(self, directory, scope=None):
3860
"""Get the configuration stack specified by ``directory`` and ``scope``.
3862
:param directory: Where the configurations are derived from.
3864
:param scope: A specific config to start from.
3866
# FIXME: scope should allow access to plugin-specific stacks (even
3867
# reduced to the plugin-specific store), related to
3868
# http://pad.lv/788991 -- vila 2011-11-15
3869
if scope is not None:
3870
if scope == 'bazaar':
3871
return GlobalStack()
3872
elif scope == 'locations':
3873
return LocationStack(directory)
3874
elif scope == 'branch':
3876
controldir.ControlDir.open_containing_tree_or_branch(
3878
return br.get_config_stack()
3879
raise errors.NoSuchConfig(scope)
3883
controldir.ControlDir.open_containing_tree_or_branch(
3885
return br.get_config_stack()
3886
except errors.NotBranchError:
3887
return LocationStack(directory)
3889
def _show_value(self, name, directory, scope):
3890
conf = self._get_stack(directory, scope)
3891
value = conf.get(name, expand=True)
3892
if value is not None:
3893
# Quote the value appropriately
3894
value = _quoting_config._quote(value)
3895
self.outf.write('%s\n' % (value,))
3897
raise errors.NoSuchConfigOption(name)
3899
def _show_matching_options(self, name, directory, scope):
3900
name = lazy_regex.lazy_compile(name)
3901
# We want any error in the regexp to be raised *now* so we need to
3902
# avoid the delay introduced by the lazy regexp. But, we still do
3903
# want the nicer errors raised by lazy_regex.
3904
name._compile_and_collapse()
3907
conf = self._get_stack(directory, scope)
3908
for sections in conf.sections_def:
3909
for store, section in sections():
3910
for oname in section.iter_option_names():
3911
if name.search(oname):
3912
if cur_store_id != store.id:
3913
# Explain where the options are defined
3914
self.outf.write('%s:\n' % (store.id,))
3915
cur_store_id = store.id
3917
if (section.id is not None
3918
and cur_section != section.id):
3919
# Display the section id as it appears in the store
3920
# (None doesn't appear by definition)
3921
self.outf.write(' [%s]\n' % (section.id,))
3922
cur_section = section.id
3923
value = section.get(oname, expand=False)
3924
# Since we don't use the stack, we need to restore a
3927
opt = option_registry.get(oname)
3928
value = opt.convert_from_unicode(store, value)
3930
value = store.unquote(value)
3931
value = _quoting_config._quote(value)
3932
self.outf.write(' %s = %s\n' % (oname, value))
3934
def _set_config_option(self, name, value, directory, scope):
3935
conf = self._get_stack(directory, scope)
3936
conf.set(name, value)
3938
def _remove_config_option(self, name, directory, scope):
3940
raise errors.BzrCommandError(
3941
'--remove expects an option to remove.')
3942
conf = self._get_stack(directory, scope)
3946
raise errors.NoSuchConfigOption(name)
3951
# We need adapters that can build a Store or a Stack in a test context. Test
3952
# classes, based on TestCaseWithTransport, can use the registry to parametrize
3953
# themselves. The builder will receive a test instance and should return a
3954
# ready-to-use store or stack. Plugins that define new store/stacks can also
3955
# register themselves here to be tested against the tests defined in
3956
# bzrlib.tests.test_config. Note that the builder can be called multiple times
3957
# for the same test.
3959
# The registered object should be a callable receiving a test instance
3960
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
3962
test_store_builder_registry = registry.Registry()
3964
# The registered object should be a callable receiving a test instance
3965
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
3967
test_stack_builder_registry = registry.Registry()