155
def signature_policy_from_unicode(signature_string):
156
"""Convert a string to a signing policy."""
157
if signature_string.lower() == 'check-available':
158
return CHECK_IF_POSSIBLE
159
if signature_string.lower() == 'ignore':
161
if signature_string.lower() == 'require':
163
raise ValueError("Invalid signatures policy '%s'"
167
def signing_policy_from_unicode(signature_string):
168
"""Convert a string to a signing policy."""
169
if signature_string.lower() == 'when-required':
170
return SIGN_WHEN_REQUIRED
171
if signature_string.lower() == 'never':
173
if signature_string.lower() == 'always':
175
raise ValueError("Invalid signing policy '%s'"
179
152
class ConfigObj(configobj.ConfigObj):
181
154
def __init__(self, infile=None, **kwargs):
441
414
# add) the final ','
445
@deprecated_method(deprecated_in((2, 5, 0)))
446
def get_user_option_as_int_from_SI(self, option_name, default=None):
418
def get_user_option_as_int_from_SI(self, option_name, default=None):
447
419
"""Get a generic option from a human readable size in SI units, e.g 10MB
449
421
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
450
422
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
453
425
:return Integer, expanded to its base-10 value if a proper SI unit is
454
426
found. If the option doesn't exist, or isn't a value in
455
427
SI units, return default (which defaults to None)
949
922
"""See Config.post_commit."""
950
923
return self._get_user_option('post_commit')
925
def _string_to_signature_policy(self, signature_string):
926
"""Convert a string to a signing policy."""
927
if signature_string.lower() == 'check-available':
928
return CHECK_IF_POSSIBLE
929
if signature_string.lower() == 'ignore':
931
if signature_string.lower() == 'require':
933
raise errors.BzrError("Invalid signatures policy '%s'"
936
def _string_to_signing_policy(self, signature_string):
937
"""Convert a string to a signing policy."""
938
if signature_string.lower() == 'when-required':
939
return SIGN_WHEN_REQUIRED
940
if signature_string.lower() == 'never':
942
if signature_string.lower() == 'always':
944
raise errors.BzrError("Invalid signing policy '%s'"
952
947
def _get_alias(self, value):
954
949
return self._get_parser().get_value("ALIASES",
2332
2319
encoutered, in which config files it can be stored.
2335
def __init__(self, name, override_from_env=None,
2336
default=None, default_from_env=None,
2337
help=None, from_unicode=None, invalid=None, unquote=True):
2322
def __init__(self, name, default=None, default_from_env=None,
2324
from_unicode=None, invalid=None):
2338
2325
"""Build an option definition.
2340
2327
:param name: the name used to refer to the option.
2342
:param override_from_env: A list of environment variables which can
2343
provide override any configuration setting.
2345
2329
:param default: the default value to use when none exist in the config
2346
2330
stores. This is either a string that ``from_unicode`` will convert
2347
into the proper type, a callable returning a unicode string so that
2348
``from_unicode`` can be used on the return value, or a python
2349
object that can be stringified (so only the empty list is supported
2331
into the proper type or a python object that can be stringified (so
2332
only the empty list is supported for example).
2352
2334
:param default_from_env: A list of environment variables which can
2353
2335
provide a default value. 'default' will be used only if none of the
2365
2347
TypeError. Accepted values are: None (ignore invalid values),
2366
2348
'warning' (emit a warning), 'error' (emit an error message and
2369
:param unquote: should the unicode value be unquoted before conversion.
2370
This should be used only when the store providing the values cannot
2371
safely unquote them (see http://pad.lv/906897). It is provided so
2372
daughter classes can handle the quoting themselves.
2374
if override_from_env is None:
2375
override_from_env = []
2376
2351
if default_from_env is None:
2377
2352
default_from_env = []
2378
2353
self.name = name
2379
self.override_from_env = override_from_env
2380
2354
# Convert the default value to a unicode string so all values are
2381
2355
# strings internally before conversion (via from_unicode) is attempted.
2382
2356
if default is None:
2387
2361
raise AssertionError(
2388
2362
'Only empty lists are supported as default values')
2389
2363
self.default = u','
2390
elif isinstance(default, (str, unicode, bool, int, float)):
2364
elif isinstance(default, (str, unicode, bool, int)):
2391
2365
# Rely on python to convert strings, booleans and integers
2392
2366
self.default = u'%s' % (default,)
2393
elif callable(default):
2394
self.default = default
2396
2368
# other python objects are not expected
2397
2369
raise AssertionError('%r is not supported as a default value'
2399
2371
self.default_from_env = default_from_env
2400
2372
self.help = help
2401
2373
self.from_unicode = from_unicode
2402
self.unquote = unquote
2403
2374
if invalid and invalid not in ('warning', 'error'):
2404
2375
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2405
2376
self.invalid = invalid
2407
def convert_from_unicode(self, store, unicode_value):
2408
if self.unquote and store is not None and unicode_value is not None:
2409
unicode_value = store.unquote(unicode_value)
2378
def convert_from_unicode(self, unicode_value):
2410
2379
if self.from_unicode is None or unicode_value is None:
2411
2380
# Don't convert or nothing to convert
2412
2381
return unicode_value
2424
2393
raise errors.ConfigOptionValueError(self.name, unicode_value)
2425
2394
return converted
2427
def get_override(self):
2429
for var in self.override_from_env:
2431
# If the env variable is defined, its value takes precedence
2432
value = os.environ[var].decode(osutils.get_user_encoding())
2438
2396
def get_default(self):
2440
2398
for var in self.default_from_env:
2442
2400
# If the env variable is defined, its value is the default one
2443
value = os.environ[var].decode(osutils.get_user_encoding())
2401
value = os.environ[var]
2445
2403
except KeyError:
2447
2405
if value is None:
2448
2406
# Otherwise, fallback to the value defined at registration
2449
if callable(self.default):
2450
value = self.default()
2451
if not isinstance(value, unicode):
2452
raise AssertionError(
2453
'Callable default values should be unicode')
2455
value = self.default
2407
value = self.default
2458
2410
def get_help_text(self, additional_see_also=None, plain=True):
2474
2426
return int(unicode_str)
2477
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2479
def int_SI_from_store(unicode_str):
2480
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2482
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2483
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2486
:return Integer, expanded to its base-10 value if a proper SI unit is
2487
found, None otherwise.
2489
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2490
p = re.compile(regexp, re.IGNORECASE)
2491
m = p.match(unicode_str)
2494
val, _, unit = m.groups()
2498
coeff = _unit_suffixes[unit.upper()]
2500
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2505
def float_from_store(unicode_str):
2506
return float(unicode_str)
2509
2429
# Use a an empty dict to initialize an empty configobj avoiding all
2510
2430
# parsing and encoding checks
2511
2431
_list_converter_config = configobj.ConfigObj(
2512
2432
{}, encoding='utf-8', list_values=True, interpolation=False)
2515
class ListOption(Option):
2517
def __init__(self, name, default=None, default_from_env=None,
2518
help=None, invalid=None):
2519
"""A list Option definition.
2521
This overrides the base class so the conversion from a unicode string
2522
can take quoting into account.
2524
super(ListOption, self).__init__(
2525
name, default=default, default_from_env=default_from_env,
2526
from_unicode=self.from_unicode, help=help,
2527
invalid=invalid, unquote=False)
2529
def from_unicode(self, unicode_str):
2530
if not isinstance(unicode_str, basestring):
2532
# Now inject our string directly as unicode. All callers got their
2533
# value from configobj, so values that need to be quoted are already
2535
_list_converter_config.reset()
2536
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2537
maybe_list = _list_converter_config['list']
2538
if isinstance(maybe_list, basestring):
2540
# A single value, most probably the user forgot (or didn't care
2541
# to add) the final ','
2544
# The empty string, convert to empty list
2435
def list_from_store(unicode_str):
2436
if not isinstance(unicode_str, basestring):
2438
# Now inject our string directly as unicode. All callers got their value
2439
# from configobj, so values that need to be quoted are already properly
2441
_list_converter_config.reset()
2442
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2443
maybe_list = _list_converter_config['list']
2444
# ConfigObj return '' instead of u''. Use 'str' below to catch all cases.
2445
if isinstance(maybe_list, basestring):
2447
# A single value, most probably the user forgot (or didn't care to
2448
# add) the final ','
2547
# We rely on ConfigObj providing us with a list already
2451
# The empty string, convert to empty list
2454
# We rely on ConfigObj providing us with a list already
2552
2459
class OptionRegistry(registry.Registry):
2593
2500
# Registered options in lexicographical order
2595
2502
option_registry.register(
2596
Option('append_revisions_only',
2597
default=None, from_unicode=bool_from_store, invalid='warning',
2599
Whether to only append revisions to the mainline.
2601
If this is set to true, then it is not possible to change the
2602
existing mainline of the branch.
2604
option_registry.register(
2605
ListOption('acceptable_keys',
2608
List of GPG key patterns which are acceptable for verification.
2610
option_registry.register(
2611
Option('add.maximum_file_size',
2612
default=u'20MB', from_unicode=int_SI_from_store,
2614
Size above which files should be added manually.
2616
Files below this size are added automatically when using ``bzr add`` without
2619
A negative value means disable the size check.
2621
option_registry.register(
2623
default=None, from_unicode=bool_from_store,
2625
Is the branch bound to ``bound_location``.
2627
If set to "True", the branch should act as a checkout, and push each commit to
2628
the bound_location. This option is normally set by ``bind``/``unbind``.
2630
See also: bound_location.
2632
option_registry.register(
2633
Option('bound_location',
2636
The location that commits should go to when acting as a checkout.
2638
This option is normally set by ``bind``.
2642
option_registry.register(
2643
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2645
Whether revisions associated with tags should be fetched.
2647
option_registry.register(
2648
2503
Option('bzr.workingtree.worth_saving_limit', default=10,
2649
2504
from_unicode=int_from_store, invalid='warning',
2657
2512
a file has been touched.
2659
2514
option_registry.register(
2660
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2661
from_unicode=signature_policy_from_unicode,
2663
GPG checking policy.
2665
Possible values: require, ignore, check-available (default)
2667
this option will control whether bzr will require good gpg
2668
signatures, ignore them, or check them if they are
2671
option_registry.register(
2672
Option('child_submit_format',
2673
help='''The preferred format of submissions to this branch.'''))
2674
option_registry.register(
2675
Option('child_submit_to',
2676
help='''Where submissions to this branch are mailed to.'''))
2677
option_registry.register(
2678
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2679
from_unicode=signing_policy_from_unicode,
2683
Possible values: always, never, when-required (default)
2685
This option controls whether bzr will always create
2686
gpg signatures or not on commits.
2688
option_registry.register(
2689
2515
Option('dirstate.fdatasync', default=True,
2690
2516
from_unicode=bool_from_store,
2696
2522
should not be lost if the machine crashes. See also repository.fdatasync.
2698
2524
option_registry.register(
2699
ListOption('debug_flags', default=[],
2525
Option('debug_flags', default=[], from_unicode=list_from_store,
2700
2526
help='Debug flags to activate.'))
2701
2527
option_registry.register(
2702
2528
Option('default_format', default='2a',
2703
2529
help='Format used when creating branches.'))
2704
2530
option_registry.register(
2705
Option('dpush_strict', default=None,
2706
from_unicode=bool_from_store,
2708
The default value for ``dpush --strict``.
2710
If present, defines the ``--strict`` option default value for checking
2711
uncommitted changes before pushing into a different VCS without any
2712
custom bzr metadata.
2714
option_registry.register(
2715
2531
Option('editor',
2716
2532
help='The command called to launch an editor to enter a message.'))
2717
2533
option_registry.register(
2718
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2719
help='The users identity'))
2720
option_registry.register(
2721
Option('gpg_signing_command',
2724
Program to use use for creating signatures.
2726
This should support at least the -u and --clearsign options.
2728
option_registry.register(
2729
Option('gpg_signing_key',
2732
GPG key to use for signing.
2734
This defaults to the first key associated with the users email.
2736
option_registry.register(
2737
2534
Option('ignore_missing_extensions', default=False,
2738
2535
from_unicode=bool_from_store,
2757
2554
Otherwise, bzr will prompt as normal to break the lock.
2759
2556
option_registry.register(
2760
Option('log_format', default='long',
2762
Log format to use when displaying revisions.
2764
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2765
may be provided by plugins.
2767
option_registry.register(
2768
2557
Option('output_encoding',
2769
2558
help= 'Unicode encoding for output'
2770
2559
' (terminal encoding if not specified).'))
2771
2560
option_registry.register(
2772
Option('parent_location',
2775
The location of the default branch for pull or merge.
2777
This option is normally set when creating a branch, the first ``pull`` or by
2778
``pull --remember``.
2780
option_registry.register(
2781
Option('post_commit', default=None,
2783
Post commit functions.
2785
An ordered list of python functions to call, separated by spaces.
2787
Each function takes branch, rev_id as parameters.
2789
option_registry.register(
2790
Option('public_branch',
2793
A publically-accessible version of this branch.
2795
This implies that the branch setting this option is not publically-accessible.
2796
Used and set by ``bzr send``.
2798
option_registry.register(
2799
Option('push_location',
2802
The location of the default branch for push.
2804
This option is normally set by the first ``push`` or ``push --remember``.
2806
option_registry.register(
2807
Option('push_strict', default=None,
2808
from_unicode=bool_from_store,
2810
The default value for ``push --strict``.
2812
If present, defines the ``--strict`` option default value for checking
2813
uncommitted changes before sending a merge directive.
2815
option_registry.register(
2816
2561
Option('repository.fdatasync', default=True,
2817
2562
from_unicode=bool_from_store,
2822
2567
to physical disk. This is somewhat slower, but means data should not be
2823
2568
lost if the machine crashes. See also dirstate.fdatasync.
2825
option_registry.register_lazy('smtp_server',
2826
'bzrlib.smtp_connection', 'smtp_server')
2827
option_registry.register_lazy('smtp_password',
2828
'bzrlib.smtp_connection', 'smtp_password')
2829
option_registry.register_lazy('smtp_username',
2830
'bzrlib.smtp_connection', 'smtp_username')
2831
option_registry.register(
2832
Option('selftest.timeout',
2834
from_unicode=int_from_store,
2835
help='Abort selftest if one test takes longer than this many seconds',
2838
option_registry.register(
2839
Option('send_strict', default=None,
2840
from_unicode=bool_from_store,
2842
The default value for ``send --strict``.
2844
If present, defines the ``--strict`` option default value for checking
2845
uncommitted changes before sending a bundle.
2848
option_registry.register(
2849
Option('serve.client_timeout',
2850
default=300.0, from_unicode=float_from_store,
2851
help="If we wait for a new request from a client for more than"
2852
" X seconds, consider the client idle, and hangup."))
2853
option_registry.register(
2854
Option('stacked_on_location',
2856
help="""The location where this branch is stacked on."""))
2857
option_registry.register(
2858
Option('submit_branch',
2861
The branch you intend to submit your current work to.
2863
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2864
by the ``submit:`` revision spec.
2866
option_registry.register(
2868
help='''Where submissions from this branch are mailed to.'''))
2871
2572
class Section(object):
2919
2614
self.orig[name] = self.get(name, None)
2920
2615
del self.options[name]
2922
def reset_changes(self):
2925
def apply_changes(self, dirty, store):
2926
"""Apply option value changes.
2928
``self`` has been reloaded from the persistent storage. ``dirty``
2929
contains the changes made since the previous loading.
2931
:param dirty: the mutable section containing the changes.
2933
:param store: the store containing the section
2935
for k, expected in dirty.orig.iteritems():
2936
actual = dirty.get(k, _DeletedOption)
2937
reloaded = self.get(k, _NewlyCreatedOption)
2938
if actual is _DeletedOption:
2939
if k in self.options:
2943
# Report concurrent updates in an ad-hoc way. This should only
2944
# occurs when different processes try to update the same option
2945
# which is not supported (as in: the config framework is not meant
2946
# to be used a sharing mechanism).
2947
if expected != reloaded:
2948
if actual is _DeletedOption:
2949
actual = '<DELETED>'
2950
if reloaded is _NewlyCreatedOption:
2951
reloaded = '<CREATED>'
2952
if expected is _NewlyCreatedOption:
2953
expected = '<CREATED>'
2954
# Someone changed the value since we get it from the persistent
2956
trace.warning(gettext(
2957
"Option {0} in section {1} of {2} was changed"
2958
" from {3} to {4}. The {5} value will be saved.".format(
2959
k, self.id, store.external_url(), expected,
2961
# No need to keep track of these changes
2962
self.reset_changes()
2965
2618
class Store(object):
2966
2619
"""Abstract interface to persistent storage for configuration options."""
3001
2650
raise NotImplementedError(self.unload)
3003
def quote(self, value):
3004
"""Quote a configuration option value for storing purposes.
3006
This allows Stacks to present values as they will be stored.
3010
def unquote(self, value):
3011
"""Unquote a configuration option value into unicode.
3013
The received value is quoted as stored.
3017
2652
def save(self):
3018
2653
"""Saves the Store to persistent storage."""
3019
2654
raise NotImplementedError(self.save)
3021
def _need_saving(self):
3022
for s in self.dirty_sections:
3024
# At least one dirty section contains a modification
3028
def apply_changes(self, dirty_sections):
3029
"""Apply changes from dirty sections while checking for coherency.
3031
The Store content is discarded and reloaded from persistent storage to
3032
acquire up-to-date values.
3034
Dirty sections are MutableSection which kept track of the value they
3035
are expected to update.
3037
# We need an up-to-date version from the persistent storage, unload the
3038
# store. The reload will occur when needed (triggered by the first
3039
# get_mutable_section() call below.
3041
# Apply the changes from the preserved dirty sections
3042
for dirty in dirty_sections:
3043
clean = self.get_mutable_section(dirty.id)
3044
clean.apply_changes(dirty, self)
3045
# Everything is clean now
3046
self.dirty_sections = []
3048
def save_changes(self):
3049
"""Saves the Store to persistent storage if changes occurred.
3051
Apply the changes recorded in the mutable sections to a store content
3052
refreshed from persistent storage.
3054
raise NotImplementedError(self.save_changes)
3056
2656
def external_url(self):
3057
2657
raise NotImplementedError(self.external_url)
3059
2659
def get_sections(self):
3060
2660
"""Returns an ordered iterable of existing sections.
3062
:returns: An iterable of (store, section).
2662
:returns: An iterable of (name, dict).
3064
2664
raise NotImplementedError(self.get_sections)
3066
def get_mutable_section(self, section_id=None):
2666
def get_mutable_section(self, section_name=None):
3067
2667
"""Returns the specified mutable section.
3069
:param section_id: The section identifier
2669
:param section_name: The section identifier
3071
2671
raise NotImplementedError(self.get_mutable_section)
3076
2676
self.external_url())
3079
class CommandLineStore(Store):
3080
"A store to carry command line overrides for the config options."""
3082
def __init__(self, opts=None):
3083
super(CommandLineStore, self).__init__()
3090
# The dict should be cleared but not replaced so it can be shared.
3091
self.options.clear()
3093
def _from_cmdline(self, overrides):
3094
# Reset before accepting new definitions
3096
for over in overrides:
3098
name, value = over.split('=', 1)
3100
raise errors.BzrCommandError(
3101
gettext("Invalid '%s', should be of the form 'name=value'")
3103
self.options[name] = value
3105
def external_url(self):
3106
# Not an url but it makes debugging easier and is never needed
3110
def get_sections(self):
3111
yield self, self.readonly_section_class(None, self.options)
3114
2679
class IniFileStore(Store):
3115
2680
"""A config Store using ConfigObj for storage.
2682
:ivar transport: The transport object where the config file is located.
2684
:ivar file_name: The config file basename in the transport directory.
3117
2686
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3118
2687
serialize/deserialize the config file.
2690
def __init__(self, transport, file_name):
3122
2691
"""A config Store using ConfigObj for storage.
2693
:param transport: The transport object where the config file is located.
2695
:param file_name: The config file basename in the transport directory.
3124
2697
super(IniFileStore, self).__init__()
2698
self.transport = transport
2699
self.file_name = file_name
3125
2700
self._config_obj = None
3127
2702
def is_loaded(self):
3130
2705
def unload(self):
3131
2706
self._config_obj = None
3132
self.dirty_sections = []
3134
def _load_content(self):
3135
"""Load the config file bytes.
3137
This should be provided by subclasses
3139
:return: Byte string
3141
raise NotImplementedError(self._load_content)
3143
def _save_content(self, content):
3144
"""Save the config file bytes.
3146
This should be provided by subclasses
3148
:param content: Config file bytes to write
3150
raise NotImplementedError(self._save_content)
3152
2708
def load(self):
3153
2709
"""Load the store from the associated file."""
3154
2710
if self.is_loaded():
3156
content = self._load_content()
2713
content = self.transport.get_bytes(self.file_name)
2714
except errors.PermissionDenied:
2715
trace.warning("Permission denied while trying to load "
2716
"configuration store %s.", self.external_url())
3157
2718
self._load_from_string(content)
3158
2719
for hook in ConfigHooks['load']:
3176
2737
except UnicodeDecodeError:
3177
2738
raise errors.ConfigContentError(self.external_url())
3179
def save_changes(self):
3180
if not self.is_loaded():
3183
if not self._need_saving():
3185
# Preserve the current version
3186
current = self._config_obj
3187
dirty_sections = list(self.dirty_sections)
3188
self.apply_changes(dirty_sections)
3189
# Save to the persistent storage
3192
2740
def save(self):
3193
2741
if not self.is_loaded():
3194
2742
# Nothing to save
3196
2744
out = StringIO()
3197
2745
self._config_obj.write(out)
3198
self._save_content(out.getvalue())
2746
self.transport.put_bytes(self.file_name, out.getvalue())
3199
2747
for hook in ConfigHooks['save']:
2750
def external_url(self):
2751
# FIXME: external_url should really accepts an optional relpath
2752
# parameter (bug #750169) :-/ -- vila 2011-04-04
2753
# The following will do in the interim but maybe we don't want to
2754
# expose a path here but rather a config ID and its associated
2755
# object </hand wawe>.
2756
return urlutils.join(self.transport.external_url(), self.file_name)
3202
2758
def get_sections(self):
3203
2759
"""Get the configobj section in the file order.
3205
:returns: An iterable of (store, section).
2761
:returns: An iterable of (name, dict).
3207
2763
# We need a loaded store
3213
2769
cobj = self._config_obj
3214
2770
if cobj.scalars:
3215
yield self, self.readonly_section_class(None, cobj)
2771
yield self.readonly_section_class(None, cobj)
3216
2772
for section_name in cobj.sections:
3218
self.readonly_section_class(section_name,
3219
cobj[section_name]))
2773
yield self.readonly_section_class(section_name, cobj[section_name])
3221
def get_mutable_section(self, section_id=None):
2775
def get_mutable_section(self, section_name=None):
3222
2776
# We need a loaded store
3225
2779
except errors.NoSuchFile:
3226
2780
# The file doesn't exist, let's pretend it was empty
3227
2781
self._load_from_string('')
3228
if section_id is None:
2782
if section_name is None:
3229
2783
section = self._config_obj
3231
section = self._config_obj.setdefault(section_id, {})
3232
mutable_section = self.mutable_section_class(section_id, section)
3233
# All mutable sections can become dirty
3234
self.dirty_sections.append(mutable_section)
3235
return mutable_section
3237
def quote(self, value):
3239
# configobj conflates automagical list values and quoting
3240
self._config_obj.list_values = True
3241
return self._config_obj._quote(value)
3243
self._config_obj.list_values = False
3245
def unquote(self, value):
3246
if value and isinstance(value, basestring):
3247
# _unquote doesn't handle None nor empty strings nor anything that
3248
# is not a string, really.
3249
value = self._config_obj._unquote(value)
3252
def external_url(self):
3253
# Since an IniFileStore can be used without a file (at least in tests),
3254
# it's better to provide something than raising a NotImplementedError.
3255
# All daughter classes are supposed to provide an implementation
3257
return 'In-Process Store, no URL'
3259
class TransportIniFileStore(IniFileStore):
3260
"""IniFileStore that loads files from a transport.
3262
:ivar transport: The transport object where the config file is located.
3264
:ivar file_name: The config file basename in the transport directory.
3267
def __init__(self, transport, file_name):
3268
"""A Store using a ini file on a Transport
3270
:param transport: The transport object where the config file is located.
3271
:param file_name: The config file basename in the transport directory.
3273
super(TransportIniFileStore, self).__init__()
3274
self.transport = transport
3275
self.file_name = file_name
3277
def _load_content(self):
3279
return self.transport.get_bytes(self.file_name)
3280
except errors.PermissionDenied:
3281
trace.warning("Permission denied while trying to load "
3282
"configuration store %s.", self.external_url())
3285
def _save_content(self, content):
3286
self.transport.put_bytes(self.file_name, content)
3288
def external_url(self):
3289
# FIXME: external_url should really accepts an optional relpath
3290
# parameter (bug #750169) :-/ -- vila 2011-04-04
3291
# The following will do in the interim but maybe we don't want to
3292
# expose a path here but rather a config ID and its associated
3293
# object </hand wawe>.
3294
return urlutils.join(self.transport.external_url(), self.file_name)
2785
section = self._config_obj.setdefault(section_name, {})
2786
return self.mutable_section_class(section_name, section)
3297
2789
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3365
2856
t = transport.get_transport_from_path(
3366
2857
config_dir(), possible_transports=possible_transports)
3367
2858
super(LocationStore, self).__init__(t, 'locations.conf')
3368
self.id = 'locations'
3371
class BranchStore(TransportIniFileStore):
2861
class BranchStore(IniFileStore):
3373
2863
def __init__(self, branch):
3374
2864
super(BranchStore, self).__init__(branch.control_transport,
3376
2866
self.branch = branch
3379
2868
def lock_write(self, token=None):
3380
2869
return self.branch.lock_write(token)
3442
2930
class LocationSection(Section):
3444
def __init__(self, section, extra_path):
2932
def __init__(self, section, length, extra_path):
3445
2933
super(LocationSection, self).__init__(section.id, section.options)
2934
self.length = length
3446
2935
self.extra_path = extra_path
3447
self.locals = {'relpath': extra_path,
3448
'basename': urlutils.basename(extra_path)}
3450
def get(self, name, default=None, expand=True):
2937
def get(self, name, default=None):
3451
2938
value = super(LocationSection, self).get(name, default)
3452
if value is not None and expand:
2939
if value is not None:
3453
2940
policy_name = self.get(name + ':policy', None)
3454
2941
policy = _policy_value.get(policy_name, POLICY_NONE)
3455
2942
if policy == POLICY_APPENDPATH:
3456
2943
value = urlutils.join(value, self.extra_path)
3457
# expand section local options right now (since POLICY_APPENDPATH
3458
# will never add options references, it's ok to expand after it).
3460
for is_ref, chunk in iter_option_refs(value):
3462
chunks.append(chunk)
3465
if ref in self.locals:
3466
chunks.append(self.locals[ref])
3468
chunks.append(chunk)
3469
value = ''.join(chunks)
3473
class StartingPathMatcher(SectionMatcher):
3474
"""Select sections for a given location respecting the Store order."""
3476
# FIXME: Both local paths and urls can be used for section names as well as
3477
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3478
# inherited the fuzziness from the previous ``LocationConfig``
3479
# implementation. We probably need to revisit which encoding is allowed for
3480
# both ``location`` and section names and how we normalize
3481
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3482
# related too. -- vila 2012-01-04
3484
def __init__(self, store, location):
3485
super(StartingPathMatcher, self).__init__(store)
3486
if location.startswith('file://'):
3487
location = urlutils.local_path_from_url(location)
3488
self.location = location
3490
def get_sections(self):
3491
"""Get all sections matching ``location`` in the store.
3493
The most generic sections are described first in the store, then more
3494
specific ones can be provided for reduced scopes.
3496
The returned section are therefore returned in the reversed order so
3497
the most specific ones can be found first.
3499
location_parts = self.location.rstrip('/').split('/')
3502
# Later sections are more specific, they should be returned first
3503
for _, section in reversed(list(store.get_sections())):
3504
if section.id is None:
3505
# The no-name section is always included if present
3506
yield store, LocationSection(section, self.location)
3508
section_path = section.id
3509
if section_path.startswith('file://'):
3510
# the location is already a local path or URL, convert the
3511
# section id to the same format
3512
section_path = urlutils.local_path_from_url(section_path)
3513
if (self.location.startswith(section_path)
3514
or fnmatch.fnmatch(self.location, section_path)):
3515
section_parts = section_path.rstrip('/').split('/')
3516
extra_path = '/'.join(location_parts[len(section_parts):])
3517
yield store, LocationSection(section, extra_path)
3520
2947
class LocationMatcher(SectionMatcher):
3522
2949
def __init__(self, store, location):
3565
2992
matching_sections = self._get_matching_sections()
3566
2993
# We want the longest (aka more specific) locations first
3567
2994
sections = sorted(matching_sections,
3568
key=lambda (length, section): (length, section.id),
2995
key=lambda section: (section.length, section.id),
3570
2997
# Sections mentioning 'ignore_parents' restrict the selection
3571
for _, section in sections:
2998
for section in sections:
3572
2999
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3573
3000
ignore = section.get('ignore_parents', None)
3574
3001
if ignore is not None:
3578
3005
# Finally, we have a valid section
3579
yield self.store, section
3582
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3583
"""Describes an expandable option reference.
3585
We want to match the most embedded reference first.
3587
I.e. for '{{foo}}' we will get '{foo}',
3588
for '{bar{baz}}' we will get '{baz}'
3591
def iter_option_refs(string):
3592
# Split isolate refs so every other chunk is a ref
3594
for chunk in _option_ref_re.split(string):
3599
3009
class Stack(object):
3600
3010
"""A stack of configurations where an option can be defined"""
3602
def __init__(self, sections_def, store=None, mutable_section_id=None):
3012
_option_ref_re = lazy_regex.lazy_compile('({[^{}]+})')
3013
"""Describes an exandable option reference.
3015
We want to match the most embedded reference first.
3017
I.e. for '{{foo}}' we will get '{foo}',
3018
for '{bar{baz}}' we will get '{baz}'
3021
def __init__(self, sections_def, store=None, mutable_section_name=None):
3603
3022
"""Creates a stack of sections with an optional store for changes.
3605
3024
:param sections_def: A list of Section or callables that returns an
3609
3028
:param store: The optional Store where modifications will be
3610
3029
recorded. If none is specified, no modifications can be done.
3612
:param mutable_section_id: The id of the MutableSection where changes
3613
are recorded. This requires the ``store`` parameter to be
3031
:param mutable_section_name: The name of the MutableSection where
3032
changes are recorded. This requires the ``store`` parameter to be
3616
3035
self.sections_def = sections_def
3617
3036
self.store = store
3618
self.mutable_section_id = mutable_section_id
3037
self.mutable_section_name = mutable_section_name
3620
3039
def get(self, name, expand=None):
3621
3040
"""Return the *first* option value found in the sections.
3636
3055
if expand is None:
3637
3056
expand = _get_expand_default_value()
3639
found_store = None # Where the option value has been found
3058
# Ensuring lazy loading is achieved by delaying section matching (which
3059
# implies querying the persistent storage) until it can't be avoided
3060
# anymore by using callables to describe (possibly empty) section
3062
for section_or_callable in self.sections_def:
3063
# Each section can expand to multiple ones when a callable is used
3064
if callable(section_or_callable):
3065
sections = section_or_callable()
3067
sections = [section_or_callable]
3068
for section in sections:
3069
value = section.get(name)
3070
if value is not None:
3072
if value is not None:
3640
3074
# If the option is registered, it may provide additional info about
3641
3075
# value handling
3656
3089
trace.warning('Cannot expand "%s":'
3657
3090
' %s does not support option expansion'
3658
3091
% (name, type(val)))
3660
val = found_store.unquote(val)
3662
val = opt.convert_from_unicode(found_store, val)
3093
val = opt.convert_from_unicode(val)
3665
# First of all, check if the environment can override the configuration
3667
if opt is not None and opt.override_from_env:
3668
value = opt.get_override()
3669
value = expand_and_convert(value)
3671
# Ensuring lazy loading is achieved by delaying section matching
3672
# (which implies querying the persistent storage) until it can't be
3673
# avoided anymore by using callables to describe (possibly empty)
3675
for sections in self.sections_def:
3676
for store, section in sections():
3677
value = section.get(name)
3678
if value is not None:
3681
if value is not None:
3683
value = expand_and_convert(value)
3684
if opt is not None and value is None:
3685
# If the option is registered, it may provide a default value
3686
value = opt.get_default()
3687
value = expand_and_convert(value)
3095
value = expand_and_convert(value)
3096
if opt is not None and value is None:
3097
# If the option is registered, it may provide a default value
3098
value = opt.get_default()
3099
value = expand_and_convert(value)
3688
3100
for hook in ConfigHooks['get']:
3689
3101
hook(self, name, value)
3760
3182
This is where we guarantee that the mutable section is lazily loaded:
3761
3183
this means we won't load the corresponding store before setting a value
3762
3184
or deleting an option. In practice the store will often be loaded but
3763
this helps catching some programming errors.
3185
this allows helps catching some programming errors.
3766
section = store.get_mutable_section(self.mutable_section_id)
3767
return store, section
3187
section = self.store.get_mutable_section(self.mutable_section_name)
3769
3190
def set(self, name, value):
3770
3191
"""Set a new value for the option."""
3771
store, section = self._get_mutable_section()
3772
section.set(name, store.quote(value))
3192
section = self._get_mutable_section()
3193
section.set(name, value)
3773
3194
for hook in ConfigHooks['set']:
3774
3195
hook(self, name, value)
3776
3197
def remove(self, name):
3777
3198
"""Remove an existing option."""
3778
_, section = self._get_mutable_section()
3199
section = self._get_mutable_section()
3779
3200
section.remove(name)
3780
3201
for hook in ConfigHooks['remove']:
3781
3202
hook(self, name)
3784
3205
# Mostly for debugging use
3785
3206
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3787
def _get_overrides(self):
3788
# Hack around library_state.initialize never called
3789
if bzrlib.global_state is not None:
3790
return bzrlib.global_state.cmdline_overrides.get_sections()
3794
class MemoryStack(Stack):
3795
"""A configuration stack defined from a string.
3797
This is mainly intended for tests and requires no disk resources.
3800
def __init__(self, content=None):
3801
"""Create an in-memory stack from a given content.
3803
It uses a single store based on configobj and support reading and
3806
:param content: The initial content of the store. If None, the store is
3807
not loaded and ``_load_from_string`` can and should be used if
3810
store = IniFileStore()
3811
if content is not None:
3812
store._load_from_string(content)
3813
super(MemoryStack, self).__init__(
3814
[store.get_sections], store)
3817
3209
class _CompatibleStack(Stack):
3818
3210
"""Place holder for compatibility with previous design.
3837
3229
# Force a write to persistent storage
3838
3230
self.store.save()
3840
def remove(self, name):
3843
super(_CompatibleStack, self).remove(name)
3844
# Force a write to persistent storage
3848
3233
class GlobalStack(_CompatibleStack):
3849
"""Global options only stack.
3851
The following sections are queried:
3853
* command-line overrides,
3855
* the 'DEFAULT' section in bazaar.conf
3857
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3234
"""Global options only stack."""
3861
3236
def __init__(self):
3862
3238
gstore = GlobalStore()
3863
super(GlobalStack, self).__init__(
3864
[self._get_overrides,
3865
NameMatcher(gstore, 'DEFAULT').get_sections],
3866
gstore, mutable_section_id='DEFAULT')
3239
super(GlobalStack, self).__init__([gstore.get_sections], gstore)
3869
3242
class LocationStack(_CompatibleStack):
3870
"""Per-location options falling back to global options stack.
3873
The following sections are queried:
3875
* command-line overrides,
3877
* the sections matching ``location`` in ``locations.conf``, the order being
3878
defined by the number of path components in the section glob, higher
3879
numbers first (from most specific section to most generic).
3881
* the 'DEFAULT' section in bazaar.conf
3883
This stack will use the ``location`` section in locations.conf as its
3243
"""Per-location options falling back to global options stack."""
3887
3245
def __init__(self, location):
3888
3246
"""Make a new stack for a location and global configuration.
3890
3248
:param location: A URL prefix to """
3891
3249
lstore = LocationStore()
3892
if location.startswith('file://'):
3893
location = urlutils.local_path_from_url(location)
3250
matcher = LocationMatcher(lstore, location)
3894
3251
gstore = GlobalStore()
3895
3252
super(LocationStack, self).__init__(
3896
[self._get_overrides,
3897
LocationMatcher(lstore, location).get_sections,
3898
NameMatcher(gstore, 'DEFAULT').get_sections],
3899
lstore, mutable_section_id=location)
3253
[matcher.get_sections, gstore.get_sections], lstore)
3902
3256
class BranchStack(_CompatibleStack):
3903
"""Per-location options falling back to branch then global options stack.
3905
The following sections are queried:
3907
* command-line overrides,
3909
* the sections matching ``location`` in ``locations.conf``, the order being
3910
defined by the number of path components in the section glob, higher
3911
numbers first (from most specific section to most generic),
3913
* the no-name section in branch.conf,
3915
* the ``DEFAULT`` section in ``bazaar.conf``.
3917
This stack will use the no-name section in ``branch.conf`` as its
3257
"""Per-location options falling back to branch then global options stack."""
3921
3259
def __init__(self, branch):
3260
bstore = BranchStore(branch)
3922
3261
lstore = LocationStore()
3923
bstore = branch._get_config_store()
3262
matcher = LocationMatcher(lstore, branch.base)
3924
3263
gstore = GlobalStore()
3925
3264
super(BranchStack, self).__init__(
3926
[self._get_overrides,
3927
LocationMatcher(lstore, branch.base).get_sections,
3928
NameMatcher(bstore, None).get_sections,
3929
NameMatcher(gstore, 'DEFAULT').get_sections],
3265
[matcher.get_sections, bstore.get_sections, gstore.get_sections],
3931
3267
self.branch = branch
3934
3270
class RemoteControlStack(_CompatibleStack):
3935
3271
"""Remote control-only options stack."""
3937
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3938
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3939
# control.conf and is used only for stack options.
3941
3273
def __init__(self, bzrdir):
3942
cstore = bzrdir._get_config_store()
3274
cstore = ControlStore(bzrdir)
3943
3275
super(RemoteControlStack, self).__init__(
3944
[NameMatcher(cstore, None).get_sections],
3276
[cstore.get_sections],
3946
3278
self.bzrdir = bzrdir
3949
class BranchOnlyStack(_CompatibleStack):
3950
"""Branch-only options stack."""
3952
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
3953
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
3954
# -- vila 2011-12-16
3281
class RemoteBranchStack(_CompatibleStack):
3282
"""Remote branch-only options stack."""
3956
3284
def __init__(self, branch):
3957
bstore = branch._get_config_store()
3958
super(BranchOnlyStack, self).__init__(
3959
[NameMatcher(bstore, None).get_sections],
3285
bstore = BranchStore(branch)
3286
super(RemoteBranchStack, self).__init__(
3287
[bstore.get_sections],
3961
3289
self.branch = branch
3964
# Use a an empty dict to initialize an empty configobj avoiding all
3965
# parsing and encoding checks
3966
_quoting_config = configobj.ConfigObj(
3967
{}, encoding='utf-8', interpolation=False, list_values=True)
3969
3292
class cmd_config(commands.Command):
3970
3293
__doc__ = """Display, set or remove a configuration option.
3987
3310
takes_options = [
3989
3312
# FIXME: This should be a registry option so that plugins can register
3990
# their own config files (or not) and will also address
3991
# http://pad.lv/788991 -- vila 20101115
3313
# their own config files (or not) -- vila 20101002
3992
3314
commands.Option('scope', help='Reduce the scope to the specified'
3993
' configuration file.',
3315
' configuration file',
3995
3317
commands.Option('all',
3996
3318
help='Display all the defined values for the matching options.',
3998
3320
commands.Option('remove', help='Remove the option from'
3999
' the configuration file.'),
3321
' the configuration file'),
4002
3324
_see_also = ['configuration']
4032
3354
# Set the option value
4033
3355
self._set_config_option(name, value, directory, scope)
4035
def _get_stack(self, directory, scope=None):
4036
"""Get the configuration stack specified by ``directory`` and ``scope``.
3357
def _get_configs(self, directory, scope=None):
3358
"""Iterate the configurations specified by ``directory`` and ``scope``.
4038
3360
:param directory: Where the configurations are derived from.
4040
3362
:param scope: A specific config to start from.
4042
# FIXME: scope should allow access to plugin-specific stacks (even
4043
# reduced to the plugin-specific store), related to
4044
# http://pad.lv/788991 -- vila 2011-11-15
4045
3364
if scope is not None:
4046
3365
if scope == 'bazaar':
4047
return GlobalStack()
3366
yield GlobalConfig()
4048
3367
elif scope == 'locations':
4049
return LocationStack(directory)
3368
yield LocationConfig(directory)
4050
3369
elif scope == 'branch':
4052
controldir.ControlDir.open_containing_tree_or_branch(
4054
return br.get_config_stack()
4055
raise errors.NoSuchConfig(scope)
3370
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
3372
yield br.get_config()
4059
controldir.ControlDir.open_containing_tree_or_branch(
4061
return br.get_config_stack()
3375
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
3377
yield br.get_config()
4062
3378
except errors.NotBranchError:
4063
return LocationStack(directory)
3379
yield LocationConfig(directory)
3380
yield GlobalConfig()
4065
3382
def _show_value(self, name, directory, scope):
4066
conf = self._get_stack(directory, scope)
4067
value = conf.get(name, expand=True)
4068
if value is not None:
4069
# Quote the value appropriately
4070
value = _quoting_config._quote(value)
4071
self.outf.write('%s\n' % (value,))
3384
for c in self._get_configs(directory, scope):
3387
for (oname, value, section, conf_id, parser) in c._get_options():
3389
# Display only the first value and exit
3391
# FIXME: We need to use get_user_option to take policies
3392
# into account and we need to make sure the option exists
3393
# too (hence the two for loops), this needs a better API
3395
value = c.get_user_option(name)
3396
# Quote the value appropriately
3397
value = parser._quote(value)
3398
self.outf.write('%s\n' % (value,))
4073
3402
raise errors.NoSuchConfigOption(name)
4075
3404
def _show_matching_options(self, name, directory, scope):
4078
3407
# avoid the delay introduced by the lazy regexp. But, we still do
4079
3408
# want the nicer errors raised by lazy_regex.
4080
3409
name._compile_and_collapse()
4082
3411
cur_section = None
4083
conf = self._get_stack(directory, scope)
4084
for sections in conf.sections_def:
4085
for store, section in sections():
4086
for oname in section.iter_option_names():
4087
if name.search(oname):
4088
if cur_store_id != store.id:
4089
# Explain where the options are defined
4090
self.outf.write('%s:\n' % (store.id,))
4091
cur_store_id = store.id
4093
if (section.id is not None
4094
and cur_section != section.id):
4095
# Display the section id as it appears in the store
4096
# (None doesn't appear by definition)
4097
self.outf.write(' [%s]\n' % (section.id,))
4098
cur_section = section.id
4099
value = section.get(oname, expand=False)
4100
# Since we don't use the stack, we need to restore a
4103
opt = option_registry.get(oname)
4104
value = opt.convert_from_unicode(store, value)
4106
value = store.unquote(value)
4107
value = _quoting_config._quote(value)
4108
self.outf.write(' %s = %s\n' % (oname, value))
3412
for c in self._get_configs(directory, scope):
3413
for (oname, value, section, conf_id, parser) in c._get_options():
3414
if name.search(oname):
3415
if cur_conf_id != conf_id:
3416
# Explain where the options are defined
3417
self.outf.write('%s:\n' % (conf_id,))
3418
cur_conf_id = conf_id
3420
if (section not in (None, 'DEFAULT')
3421
and cur_section != section):
3422
# Display the section if it's not the default (or only)
3424
self.outf.write(' [%s]\n' % (section,))
3425
cur_section = section
3426
self.outf.write(' %s = %s\n' % (oname, value))
4110
3428
def _set_config_option(self, name, value, directory, scope):
4111
conf = self._get_stack(directory, scope)
4112
conf.set(name, value)
3429
for conf in self._get_configs(directory, scope):
3430
conf.set_user_option(name, value)
3433
raise errors.NoSuchConfig(scope)
4114
3435
def _remove_config_option(self, name, directory, scope):
4115
3436
if name is None:
4116
3437
raise errors.BzrCommandError(
4117
3438
'--remove expects an option to remove.')
4118
conf = self._get_stack(directory, scope)
3440
for conf in self._get_configs(directory, scope):
3441
for (section_name, section, conf_id) in conf._get_sections():
3442
if scope is not None and conf_id != scope:
3443
# Not the right configuration file
3446
if conf_id != conf.config_id():
3447
conf = self._get_configs(directory, conf_id).next()
3448
# We use the first section in the first config where the
3449
# option is defined to remove it
3450
conf.remove_user_option(name, section_name)
3455
raise errors.NoSuchConfig(scope)
4122
3457
raise errors.NoSuchConfigOption(name)
4125
3459
# Test registries
4127
3461
# We need adapters that can build a Store or a Stack in a test context. Test
added
removed
bzrlib/config.py
