154
def signature_policy_from_unicode(signature_string):
155
"""Convert a string to a signing policy."""
156
if signature_string.lower() == 'check-available':
157
return CHECK_IF_POSSIBLE
158
if signature_string.lower() == 'ignore':
160
if signature_string.lower() == 'require':
162
raise ValueError("Invalid signatures policy '%s'"
166
def signing_policy_from_unicode(signature_string):
167
"""Convert a string to a signing policy."""
168
if signature_string.lower() == 'when-required':
169
return SIGN_WHEN_REQUIRED
170
if signature_string.lower() == 'never':
172
if signature_string.lower() == 'always':
174
raise ValueError("Invalid signing policy '%s'"
178
155
class ConfigObj(configobj.ConfigObj):
180
157
def __init__(self, infile=None, **kwargs):
440
417
# add) the final ','
444
@deprecated_method(deprecated_in((2, 5, 0)))
445
def get_user_option_as_int_from_SI(self, option_name, default=None):
421
def get_user_option_as_int_from_SI(self, option_name, default=None):
446
422
"""Get a generic option from a human readable size in SI units, e.g 10MB
448
424
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
449
425
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
452
428
:return Integer, expanded to its base-10 value if a proper SI unit is
453
429
found. If the option doesn't exist, or isn't a value in
454
430
SI units, return default (which defaults to None)
948
925
"""See Config.post_commit."""
949
926
return self._get_user_option('post_commit')
928
def _string_to_signature_policy(self, signature_string):
929
"""Convert a string to a signing policy."""
930
if signature_string.lower() == 'check-available':
931
return CHECK_IF_POSSIBLE
932
if signature_string.lower() == 'ignore':
934
if signature_string.lower() == 'require':
936
raise errors.BzrError("Invalid signatures policy '%s'"
939
def _string_to_signing_policy(self, signature_string):
940
"""Convert a string to a signing policy."""
941
if signature_string.lower() == 'when-required':
942
return SIGN_WHEN_REQUIRED
943
if signature_string.lower() == 'never':
945
if signature_string.lower() == 'always':
947
raise errors.BzrError("Invalid signing policy '%s'"
951
950
def _get_alias(self, value):
953
952
return self._get_parser().get_value("ALIASES",
1535
1539
TODO: Global option --config-dir to override this.
1537
base = osutils.path_from_environ('BZR_HOME')
1541
base = os.environ.get('BZR_HOME', None)
1538
1542
if sys.platform == 'win32':
1540
base = win32utils.get_appdata_location()
1542
base = win32utils.get_home_location()
1543
# GZ 2012-02-01: Really the two level subdirs only make sense inside
1544
# APPDATA, but hard to move. See bug 348640 for more.
1543
# environ variables on Windows are in user encoding/mbcs. So decode
1545
if base is not None:
1546
base = base.decode('mbcs')
1548
base = win32utils.get_appdata_location_unicode()
1550
base = os.environ.get('HOME', None)
1551
if base is not None:
1552
base = base.decode('mbcs')
1554
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1545
1556
return osutils.pathjoin(base, 'bazaar', '2.0')
1547
# GZ 2012-02-01: What should OSX use instead of XDG if anything?
1548
if sys.platform != 'darwin':
1549
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1558
if base is not None:
1559
base = base.decode(osutils._fs_enc)
1560
if sys.platform == 'darwin':
1562
# this takes into account $HOME
1563
base = os.path.expanduser("~")
1564
return osutils.pathjoin(base, '.bazaar')
1567
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1550
1568
if xdg_dir is None:
1551
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1569
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1552
1570
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1553
1571
if osutils.isdir(xdg_dir):
1555
1573
"Using configuration in XDG directory %s." % xdg_dir)
1557
base = osutils._get_home_dir()
1558
return osutils.pathjoin(base, ".bazaar")
1575
base = os.path.expanduser("~")
1576
return osutils.pathjoin(base, ".bazaar")
1561
1579
def config_filename():
2319
2322
encoutered, in which config files it can be stored.
2322
def __init__(self, name, override_from_env=None,
2323
default=None, default_from_env=None,
2324
help=None, from_unicode=None, invalid=None, unquote=True):
2325
def __init__(self, name, default=None, default_from_env=None,
2327
from_unicode=None, invalid=None):
2325
2328
"""Build an option definition.
2327
2330
:param name: the name used to refer to the option.
2329
:param override_from_env: A list of environment variables which can
2330
provide override any configuration setting.
2332
2332
:param default: the default value to use when none exist in the config
2333
2333
stores. This is either a string that ``from_unicode`` will convert
2334
into the proper type, a callable returning a unicode string so that
2335
``from_unicode`` can be used on the return value, or a python
2336
object that can be stringified (so only the empty list is supported
2334
into the proper type or a python object that can be stringified (so
2335
only the empty list is supported for example).
2339
2337
:param default_from_env: A list of environment variables which can
2340
2338
provide a default value. 'default' will be used only if none of the
2352
2350
TypeError. Accepted values are: None (ignore invalid values),
2353
2351
'warning' (emit a warning), 'error' (emit an error message and
2356
:param unquote: should the unicode value be unquoted before conversion.
2357
This should be used only when the store providing the values cannot
2358
safely unquote them (see http://pad.lv/906897). It is provided so
2359
daughter classes can handle the quoting themselves.
2361
if override_from_env is None:
2362
override_from_env = []
2363
2354
if default_from_env is None:
2364
2355
default_from_env = []
2365
2356
self.name = name
2366
self.override_from_env = override_from_env
2367
2357
# Convert the default value to a unicode string so all values are
2368
2358
# strings internally before conversion (via from_unicode) is attempted.
2369
2359
if default is None:
2386
2374
self.default_from_env = default_from_env
2387
2375
self.help = help
2388
2376
self.from_unicode = from_unicode
2389
self.unquote = unquote
2390
2377
if invalid and invalid not in ('warning', 'error'):
2391
2378
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2392
2379
self.invalid = invalid
2394
def convert_from_unicode(self, store, unicode_value):
2395
if self.unquote and store is not None and unicode_value is not None:
2396
unicode_value = store.unquote(unicode_value)
2381
def convert_from_unicode(self, unicode_value):
2397
2382
if self.from_unicode is None or unicode_value is None:
2398
2383
# Don't convert or nothing to convert
2399
2384
return unicode_value
2411
2396
raise errors.ConfigOptionValueError(self.name, unicode_value)
2412
2397
return converted
2414
def get_override(self):
2416
for var in self.override_from_env:
2418
# If the env variable is defined, its value takes precedence
2419
value = os.environ[var].decode(osutils.get_user_encoding())
2425
2399
def get_default(self):
2427
2401
for var in self.default_from_env:
2429
2403
# If the env variable is defined, its value is the default one
2430
value = os.environ[var].decode(osutils.get_user_encoding())
2404
value = os.environ[var]
2432
2406
except KeyError:
2434
2408
if value is None:
2435
2409
# Otherwise, fallback to the value defined at registration
2436
if callable(self.default):
2437
value = self.default()
2438
if not isinstance(value, unicode):
2439
raise AssertionError(
2440
'Callable default values should be unicode')
2442
value = self.default
2410
value = self.default
2445
2413
def get_help_text(self, additional_see_also=None, plain=True):
2461
2429
return int(unicode_str)
2464
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2466
def int_SI_from_store(unicode_str):
2467
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2469
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2470
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2473
:return Integer, expanded to its base-10 value if a proper SI unit is
2474
found, None otherwise.
2476
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2477
p = re.compile(regexp, re.IGNORECASE)
2478
m = p.match(unicode_str)
2481
val, _, unit = m.groups()
2485
coeff = _unit_suffixes[unit.upper()]
2487
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2492
2432
def float_from_store(unicode_str):
2493
2433
return float(unicode_str)
2496
2437
# Use a an empty dict to initialize an empty configobj avoiding all
2497
2438
# parsing and encoding checks
2498
2439
_list_converter_config = configobj.ConfigObj(
2499
2440
{}, encoding='utf-8', list_values=True, interpolation=False)
2502
class ListOption(Option):
2504
def __init__(self, name, default=None, default_from_env=None,
2505
help=None, invalid=None):
2506
"""A list Option definition.
2508
This overrides the base class so the conversion from a unicode string
2509
can take quoting into account.
2511
super(ListOption, self).__init__(
2512
name, default=default, default_from_env=default_from_env,
2513
from_unicode=self.from_unicode, help=help,
2514
invalid=invalid, unquote=False)
2516
def from_unicode(self, unicode_str):
2517
if not isinstance(unicode_str, basestring):
2519
# Now inject our string directly as unicode. All callers got their
2520
# value from configobj, so values that need to be quoted are already
2522
_list_converter_config.reset()
2523
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2524
maybe_list = _list_converter_config['list']
2525
if isinstance(maybe_list, basestring):
2527
# A single value, most probably the user forgot (or didn't care
2528
# to add) the final ','
2531
# The empty string, convert to empty list
2443
def list_from_store(unicode_str):
2444
if not isinstance(unicode_str, basestring):
2446
# Now inject our string directly as unicode. All callers got their value
2447
# from configobj, so values that need to be quoted are already properly
2449
_list_converter_config.reset()
2450
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2451
maybe_list = _list_converter_config['list']
2452
# ConfigObj return '' instead of u''. Use 'str' below to catch all cases.
2453
if isinstance(maybe_list, basestring):
2455
# A single value, most probably the user forgot (or didn't care to
2456
# add) the final ','
2534
# We rely on ConfigObj providing us with a list already
2459
# The empty string, convert to empty list
2462
# We rely on ConfigObj providing us with a list already
2539
2467
class OptionRegistry(registry.Registry):
2580
2508
# Registered options in lexicographical order
2582
2510
option_registry.register(
2583
Option('append_revisions_only',
2584
default=None, from_unicode=bool_from_store, invalid='warning',
2586
Whether to only append revisions to the mainline.
2588
If this is set to true, then it is not possible to change the
2589
existing mainline of the branch.
2591
option_registry.register(
2592
ListOption('acceptable_keys',
2595
List of GPG key patterns which are acceptable for verification.
2597
option_registry.register(
2598
Option('add.maximum_file_size',
2599
default=u'20MB', from_unicode=int_SI_from_store,
2601
Size above which files should be added manually.
2603
Files below this size are added automatically when using ``bzr add`` without
2606
A negative value means disable the size check.
2608
option_registry.register(
2610
default=None, from_unicode=bool_from_store,
2612
Is the branch bound to ``bound_location``.
2614
If set to "True", the branch should act as a checkout, and push each commit to
2615
the bound_location. This option is normally set by ``bind``/``unbind``.
2617
See also: bound_location.
2619
option_registry.register(
2620
Option('bound_location',
2623
The location that commits should go to when acting as a checkout.
2625
This option is normally set by ``bind``.
2629
option_registry.register(
2630
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2632
Whether revisions associated with tags should be fetched.
2634
option_registry.register(
2635
2511
Option('bzr.workingtree.worth_saving_limit', default=10,
2636
2512
from_unicode=int_from_store, invalid='warning',
2644
2520
a file has been touched.
2646
2522
option_registry.register(
2647
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2648
from_unicode=signature_policy_from_unicode,
2650
GPG checking policy.
2652
Possible values: require, ignore, check-available (default)
2654
this option will control whether bzr will require good gpg
2655
signatures, ignore them, or check them if they are
2658
option_registry.register(
2659
Option('child_submit_format',
2660
help='''The preferred format of submissions to this branch.'''))
2661
option_registry.register(
2662
Option('child_submit_to',
2663
help='''Where submissions to this branch are mailed to.'''))
2664
option_registry.register(
2665
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2666
from_unicode=signing_policy_from_unicode,
2670
Possible values: always, never, when-required (default)
2672
This option controls whether bzr will always create
2673
gpg signatures or not on commits.
2675
option_registry.register(
2676
2523
Option('dirstate.fdatasync', default=True,
2677
2524
from_unicode=bool_from_store,
2702
2549
Option('editor',
2703
2550
help='The command called to launch an editor to enter a message.'))
2704
2551
option_registry.register(
2705
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2706
help='The users identity'))
2707
option_registry.register(
2708
Option('gpg_signing_command',
2711
Program to use use for creating signatures.
2713
This should support at least the -u and --clearsign options.
2715
option_registry.register(
2716
Option('gpg_signing_key',
2719
GPG key to use for signing.
2721
This defaults to the first key associated with the users email.
2723
option_registry.register(
2724
2552
Option('ignore_missing_extensions', default=False,
2725
2553
from_unicode=bool_from_store,
2756
2584
help= 'Unicode encoding for output'
2757
2585
' (terminal encoding if not specified).'))
2758
2586
option_registry.register(
2759
Option('parent_location',
2762
The location of the default branch for pull or merge.
2764
This option is normally set when creating a branch, the first ``pull`` or by
2765
``pull --remember``.
2767
option_registry.register(
2768
Option('post_commit', default=None,
2770
Post commit functions.
2772
An ordered list of python functions to call, separated by spaces.
2774
Each function takes branch, rev_id as parameters.
2776
option_registry.register(
2777
Option('public_branch',
2780
A publically-accessible version of this branch.
2782
This implies that the branch setting this option is not publically-accessible.
2783
Used and set by ``bzr send``.
2785
option_registry.register(
2786
Option('push_location',
2789
The location of the default branch for push.
2791
This option is normally set by the first ``push`` or ``push --remember``.
2793
option_registry.register(
2794
2587
Option('push_strict', default=None,
2795
2588
from_unicode=bool_from_store,
2809
2602
to physical disk. This is somewhat slower, but means data should not be
2810
2603
lost if the machine crashes. See also dirstate.fdatasync.
2812
option_registry.register_lazy('smtp_server',
2813
'bzrlib.smtp_connection', 'smtp_server')
2814
option_registry.register_lazy('smtp_password',
2815
'bzrlib.smtp_connection', 'smtp_password')
2816
option_registry.register_lazy('smtp_username',
2817
'bzrlib.smtp_connection', 'smtp_username')
2818
option_registry.register(
2819
Option('selftest.timeout',
2821
from_unicode=int_from_store,
2822
help='Abort selftest if one test takes longer than this many seconds',
2825
2605
option_registry.register(
2826
2606
Option('send_strict', default=None,
2827
2607
from_unicode=bool_from_store,
2837
2617
default=300.0, from_unicode=float_from_store,
2838
2618
help="If we wait for a new request from a client for more than"
2839
2619
" X seconds, consider the client idle, and hangup."))
2840
option_registry.register(
2841
Option('stacked_on_location',
2843
help="""The location where this branch is stacked on."""))
2844
option_registry.register(
2845
Option('submit_branch',
2848
The branch you intend to submit your current work to.
2850
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2851
by the ``submit:`` revision spec.
2853
option_registry.register(
2855
help='''Where submissions from this branch are mailed to.'''))
2857
option_registry.register_lazy('ssl.ca_certs',
2858
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2860
option_registry.register_lazy('ssl.cert_reqs',
2861
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2865
2622
class Section(object):
2913
2664
self.orig[name] = self.get(name, None)
2914
2665
del self.options[name]
2916
def reset_changes(self):
2919
def apply_changes(self, dirty, store):
2920
"""Apply option value changes.
2922
``self`` has been reloaded from the persistent storage. ``dirty``
2923
contains the changes made since the previous loading.
2925
:param dirty: the mutable section containing the changes.
2927
:param store: the store containing the section
2929
for k, expected in dirty.orig.iteritems():
2930
actual = dirty.get(k, _DeletedOption)
2931
reloaded = self.get(k, _NewlyCreatedOption)
2932
if actual is _DeletedOption:
2933
if k in self.options:
2937
# Report concurrent updates in an ad-hoc way. This should only
2938
# occurs when different processes try to update the same option
2939
# which is not supported (as in: the config framework is not meant
2940
# to be used a sharing mechanism).
2941
if expected != reloaded:
2942
if actual is _DeletedOption:
2943
actual = '<DELETED>'
2944
if reloaded is _NewlyCreatedOption:
2945
reloaded = '<CREATED>'
2946
if expected is _NewlyCreatedOption:
2947
expected = '<CREATED>'
2948
# Someone changed the value since we get it from the persistent
2950
trace.warning(gettext(
2951
"Option {0} in section {1} of {2} was changed"
2952
" from {3} to {4}. The {5} value will be saved.".format(
2953
k, self.id, store.external_url(), expected,
2955
# No need to keep track of these changes
2956
self.reset_changes()
2668
class CommandLineSection(MutableSection):
2669
"""A section used to carry command line overrides for the config options."""
2671
def __init__(self, opts=None):
2674
super(CommandLineSection, self).__init__('cmdline-overrides', opts)
2677
# The dict should be cleared but not replaced so it can be shared.
2678
self.options.clear()
2680
def _from_cmdline(self, overrides):
2681
# Reset before accepting new definitions
2683
for over in overrides:
2685
name, value = over.split('=', 1)
2687
raise errors.BzrCommandError(
2688
gettext("Invalid '%s', should be of the form 'name=value'")
2690
self.set(name, value)
2959
2693
class Store(object):
2995
2725
raise NotImplementedError(self.unload)
2997
def quote(self, value):
2998
"""Quote a configuration option value for storing purposes.
3000
This allows Stacks to present values as they will be stored.
3004
def unquote(self, value):
3005
"""Unquote a configuration option value into unicode.
3007
The received value is quoted as stored.
3011
2727
def save(self):
3012
2728
"""Saves the Store to persistent storage."""
3013
2729
raise NotImplementedError(self.save)
3015
def _need_saving(self):
3016
for s in self.dirty_sections:
3018
# At least one dirty section contains a modification
3022
def apply_changes(self, dirty_sections):
3023
"""Apply changes from dirty sections while checking for coherency.
3025
The Store content is discarded and reloaded from persistent storage to
3026
acquire up-to-date values.
3028
Dirty sections are MutableSection which kept track of the value they
3029
are expected to update.
3031
# We need an up-to-date version from the persistent storage, unload the
3032
# store. The reload will occur when needed (triggered by the first
3033
# get_mutable_section() call below.
3035
# Apply the changes from the preserved dirty sections
3036
for dirty in dirty_sections:
3037
clean = self.get_mutable_section(dirty.id)
3038
clean.apply_changes(dirty, self)
3039
# Everything is clean now
3040
self.dirty_sections = []
3042
def save_changes(self):
3043
"""Saves the Store to persistent storage if changes occurred.
3045
Apply the changes recorded in the mutable sections to a store content
3046
refreshed from persistent storage.
3048
raise NotImplementedError(self.save_changes)
3050
2731
def external_url(self):
3051
2732
raise NotImplementedError(self.external_url)
3053
2734
def get_sections(self):
3054
2735
"""Returns an ordered iterable of existing sections.
3056
:returns: An iterable of (store, section).
2737
:returns: An iterable of (name, dict).
3058
2739
raise NotImplementedError(self.get_sections)
3060
def get_mutable_section(self, section_id=None):
2741
def get_mutable_section(self, section_name=None):
3061
2742
"""Returns the specified mutable section.
3063
:param section_id: The section identifier
2744
:param section_name: The section identifier
3065
2746
raise NotImplementedError(self.get_mutable_section)
3070
2751
self.external_url())
3073
class CommandLineStore(Store):
3074
"A store to carry command line overrides for the config options."""
3076
def __init__(self, opts=None):
3077
super(CommandLineStore, self).__init__()
3084
# The dict should be cleared but not replaced so it can be shared.
3085
self.options.clear()
3087
def _from_cmdline(self, overrides):
3088
# Reset before accepting new definitions
3090
for over in overrides:
3092
name, value = over.split('=', 1)
3094
raise errors.BzrCommandError(
3095
gettext("Invalid '%s', should be of the form 'name=value'")
3097
self.options[name] = value
3099
def external_url(self):
3100
# Not an url but it makes debugging easier and is never needed
3104
def get_sections(self):
3105
yield self, self.readonly_section_class(None, self.options)
3108
2754
class IniFileStore(Store):
3109
2755
"""A config Store using ConfigObj for storage.
2757
:ivar transport: The transport object where the config file is located.
2759
:ivar file_name: The config file basename in the transport directory.
3111
2761
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3112
2762
serialize/deserialize the config file.
2765
def __init__(self, transport, file_name):
3116
2766
"""A config Store using ConfigObj for storage.
2768
:param transport: The transport object where the config file is located.
2770
:param file_name: The config file basename in the transport directory.
3118
2772
super(IniFileStore, self).__init__()
2773
self.transport = transport
2774
self.file_name = file_name
3119
2775
self._config_obj = None
3121
2777
def is_loaded(self):
3124
2780
def unload(self):
3125
2781
self._config_obj = None
3126
self.dirty_sections = []
3128
def _load_content(self):
3129
"""Load the config file bytes.
3131
This should be provided by subclasses
3133
:return: Byte string
3135
raise NotImplementedError(self._load_content)
3137
def _save_content(self, content):
3138
"""Save the config file bytes.
3140
This should be provided by subclasses
3142
:param content: Config file bytes to write
3144
raise NotImplementedError(self._save_content)
3146
2783
def load(self):
3147
2784
"""Load the store from the associated file."""
3148
2785
if self.is_loaded():
3150
content = self._load_content()
2788
content = self.transport.get_bytes(self.file_name)
2789
except errors.PermissionDenied:
2790
trace.warning("Permission denied while trying to load "
2791
"configuration store %s.", self.external_url())
3151
2793
self._load_from_string(content)
3152
2794
for hook in ConfigHooks['load']:
3170
2812
except UnicodeDecodeError:
3171
2813
raise errors.ConfigContentError(self.external_url())
3173
def save_changes(self):
3174
if not self.is_loaded():
3177
if not self._need_saving():
3179
# Preserve the current version
3180
current = self._config_obj
3181
dirty_sections = list(self.dirty_sections)
3182
self.apply_changes(dirty_sections)
3183
# Save to the persistent storage
3186
2815
def save(self):
3187
2816
if not self.is_loaded():
3188
2817
# Nothing to save
3190
2819
out = StringIO()
3191
2820
self._config_obj.write(out)
3192
self._save_content(out.getvalue())
2821
self.transport.put_bytes(self.file_name, out.getvalue())
3193
2822
for hook in ConfigHooks['save']:
2825
def external_url(self):
2826
# FIXME: external_url should really accepts an optional relpath
2827
# parameter (bug #750169) :-/ -- vila 2011-04-04
2828
# The following will do in the interim but maybe we don't want to
2829
# expose a path here but rather a config ID and its associated
2830
# object </hand wawe>.
2831
return urlutils.join(self.transport.external_url(), self.file_name)
3196
2833
def get_sections(self):
3197
2834
"""Get the configobj section in the file order.
3199
:returns: An iterable of (store, section).
2836
:returns: An iterable of (name, dict).
3201
2838
# We need a loaded store
3207
2844
cobj = self._config_obj
3208
2845
if cobj.scalars:
3209
yield self, self.readonly_section_class(None, cobj)
2846
yield self.readonly_section_class(None, cobj)
3210
2847
for section_name in cobj.sections:
3212
self.readonly_section_class(section_name,
3213
cobj[section_name]))
2848
yield self.readonly_section_class(section_name, cobj[section_name])
3215
def get_mutable_section(self, section_id=None):
2850
def get_mutable_section(self, section_name=None):
3216
2851
# We need a loaded store
3219
2854
except errors.NoSuchFile:
3220
2855
# The file doesn't exist, let's pretend it was empty
3221
2856
self._load_from_string('')
3222
if section_id is None:
2857
if section_name is None:
3223
2858
section = self._config_obj
3225
section = self._config_obj.setdefault(section_id, {})
3226
mutable_section = self.mutable_section_class(section_id, section)
3227
# All mutable sections can become dirty
3228
self.dirty_sections.append(mutable_section)
3229
return mutable_section
3231
def quote(self, value):
3233
# configobj conflates automagical list values and quoting
3234
self._config_obj.list_values = True
3235
return self._config_obj._quote(value)
3237
self._config_obj.list_values = False
3239
def unquote(self, value):
3240
if value and isinstance(value, basestring):
3241
# _unquote doesn't handle None nor empty strings nor anything that
3242
# is not a string, really.
3243
value = self._config_obj._unquote(value)
3246
def external_url(self):
3247
# Since an IniFileStore can be used without a file (at least in tests),
3248
# it's better to provide something than raising a NotImplementedError.
3249
# All daughter classes are supposed to provide an implementation
3251
return 'In-Process Store, no URL'
3253
class TransportIniFileStore(IniFileStore):
3254
"""IniFileStore that loads files from a transport.
3256
:ivar transport: The transport object where the config file is located.
3258
:ivar file_name: The config file basename in the transport directory.
3261
def __init__(self, transport, file_name):
3262
"""A Store using a ini file on a Transport
3264
:param transport: The transport object where the config file is located.
3265
:param file_name: The config file basename in the transport directory.
3267
super(TransportIniFileStore, self).__init__()
3268
self.transport = transport
3269
self.file_name = file_name
3271
def _load_content(self):
3273
return self.transport.get_bytes(self.file_name)
3274
except errors.PermissionDenied:
3275
trace.warning("Permission denied while trying to load "
3276
"configuration store %s.", self.external_url())
3279
def _save_content(self, content):
3280
self.transport.put_bytes(self.file_name, content)
3282
def external_url(self):
3283
# FIXME: external_url should really accepts an optional relpath
3284
# parameter (bug #750169) :-/ -- vila 2011-04-04
3285
# The following will do in the interim but maybe we don't want to
3286
# expose a path here but rather a config ID and its associated
3287
# object </hand wawe>.
3288
return urlutils.join(self.transport.external_url(), self.file_name)
2860
section = self._config_obj.setdefault(section_name, {})
2861
return self.mutable_section_class(section_name, section)
3291
2864
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3359
2931
t = transport.get_transport_from_path(
3360
2932
config_dir(), possible_transports=possible_transports)
3361
2933
super(LocationStore, self).__init__(t, 'locations.conf')
3362
self.id = 'locations'
3365
class BranchStore(TransportIniFileStore):
2936
class BranchStore(IniFileStore):
3367
2938
def __init__(self, branch):
3368
2939
super(BranchStore, self).__init__(branch.control_transport,
3370
2941
self.branch = branch
3373
2943
def lock_write(self, token=None):
3374
2944
return self.branch.lock_write(token)
3436
3005
class LocationSection(Section):
3438
def __init__(self, section, extra_path):
3007
def __init__(self, section, length, extra_path):
3439
3008
super(LocationSection, self).__init__(section.id, section.options)
3009
self.length = length
3440
3010
self.extra_path = extra_path
3441
self.locals = {'relpath': extra_path,
3442
'basename': urlutils.basename(extra_path)}
3444
def get(self, name, default=None, expand=True):
3012
def get(self, name, default=None):
3445
3013
value = super(LocationSection, self).get(name, default)
3446
if value is not None and expand:
3014
if value is not None:
3447
3015
policy_name = self.get(name + ':policy', None)
3448
3016
policy = _policy_value.get(policy_name, POLICY_NONE)
3449
3017
if policy == POLICY_APPENDPATH:
3450
3018
value = urlutils.join(value, self.extra_path)
3451
# expand section local options right now (since POLICY_APPENDPATH
3452
# will never add options references, it's ok to expand after it).
3454
for is_ref, chunk in iter_option_refs(value):
3456
chunks.append(chunk)
3459
if ref in self.locals:
3460
chunks.append(self.locals[ref])
3462
chunks.append(chunk)
3463
value = ''.join(chunks)
3467
class StartingPathMatcher(SectionMatcher):
3468
"""Select sections for a given location respecting the Store order."""
3470
# FIXME: Both local paths and urls can be used for section names as well as
3471
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3472
# inherited the fuzziness from the previous ``LocationConfig``
3473
# implementation. We probably need to revisit which encoding is allowed for
3474
# both ``location`` and section names and how we normalize
3475
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3476
# related too. -- vila 2012-01-04
3478
def __init__(self, store, location):
3479
super(StartingPathMatcher, self).__init__(store)
3480
if location.startswith('file://'):
3481
location = urlutils.local_path_from_url(location)
3482
self.location = location
3484
def get_sections(self):
3485
"""Get all sections matching ``location`` in the store.
3487
The most generic sections are described first in the store, then more
3488
specific ones can be provided for reduced scopes.
3490
The returned section are therefore returned in the reversed order so
3491
the most specific ones can be found first.
3493
location_parts = self.location.rstrip('/').split('/')
3496
# Later sections are more specific, they should be returned first
3497
for _, section in reversed(list(store.get_sections())):
3498
if section.id is None:
3499
# The no-name section is always included if present
3500
yield store, LocationSection(section, self.location)
3502
section_path = section.id
3503
if section_path.startswith('file://'):
3504
# the location is already a local path or URL, convert the
3505
# section id to the same format
3506
section_path = urlutils.local_path_from_url(section_path)
3507
if (self.location.startswith(section_path)
3508
or fnmatch.fnmatch(self.location, section_path)):
3509
section_parts = section_path.rstrip('/').split('/')
3510
extra_path = '/'.join(location_parts[len(section_parts):])
3511
yield store, LocationSection(section, extra_path)
3514
3022
class LocationMatcher(SectionMatcher):
3516
3024
def __init__(self, store, location):
3559
3067
matching_sections = self._get_matching_sections()
3560
3068
# We want the longest (aka more specific) locations first
3561
3069
sections = sorted(matching_sections,
3562
key=lambda (length, section): (length, section.id),
3070
key=lambda section: (section.length, section.id),
3564
3072
# Sections mentioning 'ignore_parents' restrict the selection
3565
for _, section in sections:
3073
for section in sections:
3566
3074
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3567
3075
ignore = section.get('ignore_parents', None)
3568
3076
if ignore is not None:
3572
3080
# Finally, we have a valid section
3573
yield self.store, section
3576
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3577
"""Describes an expandable option reference.
3579
We want to match the most embedded reference first.
3581
I.e. for '{{foo}}' we will get '{foo}',
3582
for '{bar{baz}}' we will get '{baz}'
3585
def iter_option_refs(string):
3586
# Split isolate refs so every other chunk is a ref
3588
for chunk in _option_ref_re.split(string):
3593
3084
class Stack(object):
3594
3085
"""A stack of configurations where an option can be defined"""
3596
def __init__(self, sections_def, store=None, mutable_section_id=None):
3087
_option_ref_re = lazy_regex.lazy_compile('({[^{}]+})')
3088
"""Describes an exandable option reference.
3090
We want to match the most embedded reference first.
3092
I.e. for '{{foo}}' we will get '{foo}',
3093
for '{bar{baz}}' we will get '{baz}'
3096
def __init__(self, sections_def, store=None, mutable_section_name=None):
3597
3097
"""Creates a stack of sections with an optional store for changes.
3599
3099
:param sections_def: A list of Section or callables that returns an
3603
3103
:param store: The optional Store where modifications will be
3604
3104
recorded. If none is specified, no modifications can be done.
3606
:param mutable_section_id: The id of the MutableSection where changes
3607
are recorded. This requires the ``store`` parameter to be
3106
:param mutable_section_name: The name of the MutableSection where
3107
changes are recorded. This requires the ``store`` parameter to be
3610
3110
self.sections_def = sections_def
3611
3111
self.store = store
3612
self.mutable_section_id = mutable_section_id
3112
self.mutable_section_name = mutable_section_name
3614
3114
def get(self, name, expand=None):
3615
3115
"""Return the *first* option value found in the sections.
3630
3130
if expand is None:
3631
3131
expand = _get_expand_default_value()
3633
found_store = None # Where the option value has been found
3133
# Ensuring lazy loading is achieved by delaying section matching (which
3134
# implies querying the persistent storage) until it can't be avoided
3135
# anymore by using callables to describe (possibly empty) section
3137
for section_or_callable in self.sections_def:
3138
# Each section can expand to multiple ones when a callable is used
3139
if callable(section_or_callable):
3140
sections = section_or_callable()
3142
sections = [section_or_callable]
3143
for section in sections:
3144
value = section.get(name)
3145
if value is not None:
3147
if value is not None:
3634
3149
# If the option is registered, it may provide additional info about
3635
3150
# value handling
3650
3164
trace.warning('Cannot expand "%s":'
3651
3165
' %s does not support option expansion'
3652
3166
% (name, type(val)))
3654
val = found_store.unquote(val)
3656
val = opt.convert_from_unicode(found_store, val)
3168
val = opt.convert_from_unicode(val)
3659
# First of all, check if the environment can override the configuration
3661
if opt is not None and opt.override_from_env:
3662
value = opt.get_override()
3663
value = expand_and_convert(value)
3665
# Ensuring lazy loading is achieved by delaying section matching
3666
# (which implies querying the persistent storage) until it can't be
3667
# avoided anymore by using callables to describe (possibly empty)
3669
for sections in self.sections_def:
3670
for store, section in sections():
3671
value = section.get(name)
3672
if value is not None:
3675
if value is not None:
3677
value = expand_and_convert(value)
3678
if opt is not None and value is None:
3679
# If the option is registered, it may provide a default value
3680
value = opt.get_default()
3681
value = expand_and_convert(value)
3170
value = expand_and_convert(value)
3171
if opt is not None and value is None:
3172
# If the option is registered, it may provide a default value
3173
value = opt.get_default()
3174
value = expand_and_convert(value)
3682
3175
for hook in ConfigHooks['get']:
3683
3176
hook(self, name, value)
3754
3257
This is where we guarantee that the mutable section is lazily loaded:
3755
3258
this means we won't load the corresponding store before setting a value
3756
3259
or deleting an option. In practice the store will often be loaded but
3757
this helps catching some programming errors.
3260
this allows helps catching some programming errors.
3760
section = store.get_mutable_section(self.mutable_section_id)
3761
return store, section
3262
section = self.store.get_mutable_section(self.mutable_section_name)
3763
3265
def set(self, name, value):
3764
3266
"""Set a new value for the option."""
3765
store, section = self._get_mutable_section()
3766
section.set(name, store.quote(value))
3267
section = self._get_mutable_section()
3268
section.set(name, value)
3767
3269
for hook in ConfigHooks['set']:
3768
3270
hook(self, name, value)
3770
3272
def remove(self, name):
3771
3273
"""Remove an existing option."""
3772
_, section = self._get_mutable_section()
3274
section = self._get_mutable_section()
3773
3275
section.remove(name)
3774
3276
for hook in ConfigHooks['remove']:
3775
3277
hook(self, name)
3781
3283
def _get_overrides(self):
3782
3284
# Hack around library_state.initialize never called
3783
3285
if bzrlib.global_state is not None:
3784
return bzrlib.global_state.cmdline_overrides.get_sections()
3286
return [bzrlib.global_state.cmdline_overrides]
3788
class MemoryStack(Stack):
3789
"""A configuration stack defined from a string.
3791
This is mainly intended for tests and requires no disk resources.
3794
def __init__(self, content=None):
3795
"""Create an in-memory stack from a given content.
3797
It uses a single store based on configobj and support reading and
3800
:param content: The initial content of the store. If None, the store is
3801
not loaded and ``_load_from_string`` can and should be used if
3804
store = IniFileStore()
3805
if content is not None:
3806
store._load_from_string(content)
3807
super(MemoryStack, self).__init__(
3808
[store.get_sections], store)
3811
3290
class _CompatibleStack(Stack):
3812
3291
"""Place holder for compatibility with previous design.
3831
3310
# Force a write to persistent storage
3832
3311
self.store.save()
3834
def remove(self, name):
3837
super(_CompatibleStack, self).remove(name)
3838
# Force a write to persistent storage
3842
3314
class GlobalStack(_CompatibleStack):
3843
"""Global options only stack.
3845
The following sections are queried:
3847
* command-line overrides,
3849
* the 'DEFAULT' section in bazaar.conf
3851
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3315
"""Global options only stack."""
3855
3317
def __init__(self):
3856
3319
gstore = GlobalStore()
3857
3320
super(GlobalStack, self).__init__(
3858
[self._get_overrides,
3859
NameMatcher(gstore, 'DEFAULT').get_sections],
3860
gstore, mutable_section_id='DEFAULT')
3321
[self._get_overrides, gstore.get_sections],
3863
3325
class LocationStack(_CompatibleStack):
3864
"""Per-location options falling back to global options stack.
3867
The following sections are queried:
3869
* command-line overrides,
3871
* the sections matching ``location`` in ``locations.conf``, the order being
3872
defined by the number of path components in the section glob, higher
3873
numbers first (from most specific section to most generic).
3875
* the 'DEFAULT' section in bazaar.conf
3877
This stack will use the ``location`` section in locations.conf as its
3326
"""Per-location options falling back to global options stack."""
3881
3328
def __init__(self, location):
3882
3329
"""Make a new stack for a location and global configuration.
3884
3331
:param location: A URL prefix to """
3885
3332
lstore = LocationStore()
3886
if location.startswith('file://'):
3887
location = urlutils.local_path_from_url(location)
3333
matcher = LocationMatcher(lstore, location)
3888
3334
gstore = GlobalStore()
3889
3335
super(LocationStack, self).__init__(
3890
3336
[self._get_overrides,
3891
LocationMatcher(lstore, location).get_sections,
3892
NameMatcher(gstore, 'DEFAULT').get_sections],
3893
lstore, mutable_section_id=location)
3337
matcher.get_sections, gstore.get_sections],
3896
3341
class BranchStack(_CompatibleStack):
3897
"""Per-location options falling back to branch then global options stack.
3899
The following sections are queried:
3901
* command-line overrides,
3903
* the sections matching ``location`` in ``locations.conf``, the order being
3904
defined by the number of path components in the section glob, higher
3905
numbers first (from most specific section to most generic),
3907
* the no-name section in branch.conf,
3909
* the ``DEFAULT`` section in ``bazaar.conf``.
3911
This stack will use the no-name section in ``branch.conf`` as its
3342
"""Per-location options falling back to branch then global options stack."""
3915
3344
def __init__(self, branch):
3345
bstore = BranchStore(branch)
3916
3346
lstore = LocationStore()
3917
bstore = branch._get_config_store()
3347
matcher = LocationMatcher(lstore, branch.base)
3918
3348
gstore = GlobalStore()
3919
3349
super(BranchStack, self).__init__(
3920
3350
[self._get_overrides,
3921
LocationMatcher(lstore, branch.base).get_sections,
3922
NameMatcher(bstore, None).get_sections,
3923
NameMatcher(gstore, 'DEFAULT').get_sections],
3351
matcher.get_sections, bstore.get_sections, gstore.get_sections],
3925
3353
self.branch = branch
3928
3356
class RemoteControlStack(_CompatibleStack):
3929
3357
"""Remote control-only options stack."""
3931
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3932
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3933
# control.conf and is used only for stack options.
3935
3359
def __init__(self, bzrdir):
3936
cstore = bzrdir._get_config_store()
3360
cstore = ControlStore(bzrdir)
3937
3361
super(RemoteControlStack, self).__init__(
3938
[NameMatcher(cstore, None).get_sections],
3362
[cstore.get_sections],
3940
3364
self.bzrdir = bzrdir
3943
class BranchOnlyStack(_CompatibleStack):
3944
"""Branch-only options stack."""
3946
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
3947
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
3948
# -- vila 2011-12-16
3367
class RemoteBranchStack(_CompatibleStack):
3368
"""Remote branch-only options stack."""
3950
3370
def __init__(self, branch):
3951
bstore = branch._get_config_store()
3952
super(BranchOnlyStack, self).__init__(
3953
[NameMatcher(bstore, None).get_sections],
3371
bstore = BranchStore(branch)
3372
super(RemoteBranchStack, self).__init__(
3373
[bstore.get_sections],
3955
3375
self.branch = branch
3958
# Use a an empty dict to initialize an empty configobj avoiding all
3959
# parsing and encoding checks
3960
_quoting_config = configobj.ConfigObj(
3961
{}, encoding='utf-8', interpolation=False, list_values=True)
3963
3378
class cmd_config(commands.Command):
3964
3379
__doc__ = """Display, set or remove a configuration option.
3981
3396
takes_options = [
3983
3398
# FIXME: This should be a registry option so that plugins can register
3984
# their own config files (or not) and will also address
3985
# http://pad.lv/788991 -- vila 20101115
3399
# their own config files (or not) -- vila 20101002
3986
3400
commands.Option('scope', help='Reduce the scope to the specified'
3987
' configuration file.',
3401
' configuration file',
3989
3403
commands.Option('all',
3990
3404
help='Display all the defined values for the matching options.',
3992
3406
commands.Option('remove', help='Remove the option from'
3993
' the configuration file.'),
3407
' the configuration file'),
3996
3410
_see_also = ['configuration']
4026
3440
# Set the option value
4027
3441
self._set_config_option(name, value, directory, scope)
4029
def _get_stack(self, directory, scope=None):
4030
"""Get the configuration stack specified by ``directory`` and ``scope``.
3443
def _get_configs(self, directory, scope=None):
3444
"""Iterate the configurations specified by ``directory`` and ``scope``.
4032
3446
:param directory: Where the configurations are derived from.
4034
3448
:param scope: A specific config to start from.
4036
# FIXME: scope should allow access to plugin-specific stacks (even
4037
# reduced to the plugin-specific store), related to
4038
# http://pad.lv/788991 -- vila 2011-11-15
4039
3450
if scope is not None:
4040
3451
if scope == 'bazaar':
4041
return GlobalStack()
3452
yield GlobalConfig()
4042
3453
elif scope == 'locations':
4043
return LocationStack(directory)
3454
yield LocationConfig(directory)
4044
3455
elif scope == 'branch':
4046
3457
controldir.ControlDir.open_containing_tree_or_branch(
4048
return br.get_config_stack()
4049
raise errors.NoSuchConfig(scope)
3459
yield br.get_config()
4053
3463
controldir.ControlDir.open_containing_tree_or_branch(
4055
return br.get_config_stack()
3465
yield br.get_config()
4056
3466
except errors.NotBranchError:
4057
return LocationStack(directory)
3467
yield LocationConfig(directory)
3468
yield GlobalConfig()
4059
3470
def _show_value(self, name, directory, scope):
4060
conf = self._get_stack(directory, scope)
4061
value = conf.get(name, expand=True)
4062
if value is not None:
4063
# Quote the value appropriately
4064
value = _quoting_config._quote(value)
4065
self.outf.write('%s\n' % (value,))
3472
for c in self._get_configs(directory, scope):
3475
for (oname, value, section, conf_id, parser) in c._get_options():
3477
# Display only the first value and exit
3479
# FIXME: We need to use get_user_option to take policies
3480
# into account and we need to make sure the option exists
3481
# too (hence the two for loops), this needs a better API
3483
value = c.get_user_option(name)
3484
# Quote the value appropriately
3485
value = parser._quote(value)
3486
self.outf.write('%s\n' % (value,))
4067
3490
raise errors.NoSuchConfigOption(name)
4069
3492
def _show_matching_options(self, name, directory, scope):
4072
3495
# avoid the delay introduced by the lazy regexp. But, we still do
4073
3496
# want the nicer errors raised by lazy_regex.
4074
3497
name._compile_and_collapse()
4076
3499
cur_section = None
4077
conf = self._get_stack(directory, scope)
4078
for sections in conf.sections_def:
4079
for store, section in sections():
4080
for oname in section.iter_option_names():
4081
if name.search(oname):
4082
if cur_store_id != store.id:
4083
# Explain where the options are defined
4084
self.outf.write('%s:\n' % (store.id,))
4085
cur_store_id = store.id
4087
if (section.id is not None
4088
and cur_section != section.id):
4089
# Display the section id as it appears in the store
4090
# (None doesn't appear by definition)
4091
self.outf.write(' [%s]\n' % (section.id,))
4092
cur_section = section.id
4093
value = section.get(oname, expand=False)
4094
# Since we don't use the stack, we need to restore a
4097
opt = option_registry.get(oname)
4098
value = opt.convert_from_unicode(store, value)
4100
value = store.unquote(value)
4101
value = _quoting_config._quote(value)
4102
self.outf.write(' %s = %s\n' % (oname, value))
3500
for c in self._get_configs(directory, scope):
3501
for (oname, value, section, conf_id, parser) in c._get_options():
3502
if name.search(oname):
3503
if cur_conf_id != conf_id:
3504
# Explain where the options are defined
3505
self.outf.write('%s:\n' % (conf_id,))
3506
cur_conf_id = conf_id
3508
if (section not in (None, 'DEFAULT')
3509
and cur_section != section):
3510
# Display the section if it's not the default (or only)
3512
self.outf.write(' [%s]\n' % (section,))
3513
cur_section = section
3514
self.outf.write(' %s = %s\n' % (oname, value))
4104
3516
def _set_config_option(self, name, value, directory, scope):
4105
conf = self._get_stack(directory, scope)
4106
conf.set(name, value)
3517
for conf in self._get_configs(directory, scope):
3518
conf.set_user_option(name, value)
3521
raise errors.NoSuchConfig(scope)
4108
3523
def _remove_config_option(self, name, directory, scope):
4109
3524
if name is None:
4110
3525
raise errors.BzrCommandError(
4111
3526
'--remove expects an option to remove.')
4112
conf = self._get_stack(directory, scope)
3528
for conf in self._get_configs(directory, scope):
3529
for (section_name, section, conf_id) in conf._get_sections():
3530
if scope is not None and conf_id != scope:
3531
# Not the right configuration file
3534
if conf_id != conf.config_id():
3535
conf = self._get_configs(directory, conf_id).next()
3536
# We use the first section in the first config where the
3537
# option is defined to remove it
3538
conf.remove_user_option(name, section_name)
3543
raise errors.NoSuchConfig(scope)
4116
3545
raise errors.NoSuchConfigOption(name)
4119
3547
# Test registries
4121
3549
# We need adapters that can build a Store or a Stack in a test context. Test
added
removed
bzrlib/config.py
