1
# Copyright (C) 2005-2012 Canonical Ltd
2
# Authors: Robert Collins <robert.collins@canonical.com>
5
# This program is free software; you can redistribute it and/or modify
6
# it under the terms of the GNU General Public License as published by
7
# the Free Software Foundation; either version 2 of the License, or
8
# (at your option) any later version.
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
# GNU General Public License for more details.
15
# You should have received a copy of the GNU General Public License
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
"""Configuration that affects the behaviour of Bazaar.
21
Currently this configuration resides in ~/.bazaar/bazaar.conf
22
and ~/.bazaar/locations.conf, which is written to by bzr.
24
In bazaar.conf the following options may be set:
26
editor=name-of-program
27
email=Your Name <your@email.address>
28
check_signatures=require|ignore|check-available(default)
29
create_signatures=always|never|when-required(default)
30
gpg_signing_command=name-of-program
31
log_format=name-of-format
32
validate_signatures_in_log=true|false(default)
33
acceptable_keys=pattern1,pattern2
34
gpg_signing_key=amy@example.com
36
in locations.conf, you specify the url of a branch and options for it.
37
Wildcards may be used - * and ? as normal in shell completion. Options
38
set in both bazaar.conf and locations.conf are overridden by the locations.conf
40
[/home/robertc/source]
41
recurse=False|True(default)
43
check_signatures= as above
44
create_signatures= as above.
45
validate_signatures_in_log=as above
46
acceptable_keys=as above
48
explanation of options
49
----------------------
50
editor - this option sets the pop up editor to use during commits.
51
email - this option sets the user id bzr will use when committing.
52
check_signatures - this option will control whether bzr will require good gpg
53
signatures, ignore them, or check them if they are
54
present. Currently it is unused except that check_signatures
55
turns on create_signatures.
56
create_signatures - this option controls whether bzr will always create
57
gpg signatures or not on commits. There is an unused
58
option which in future is expected to work if
59
branch settings require signatures.
60
log_format - this option sets the default log format. Possible values are
61
long, short, line, or a plugin can register new formats.
62
validate_signatures_in_log - show GPG signature validity in log output
63
acceptable_keys - comma separated list of key patterns acceptable for
64
verify-signatures command
66
In bazaar.conf you can also define aliases in the ALIASES sections, example
69
lastlog=log --line -r-10..-1
70
ll=log --line -r-10..-1
75
from __future__ import absolute_import
76
from cStringIO import StringIO
81
from bzrlib.decorators import needs_write_lock
82
from bzrlib.lazy_import import lazy_import
83
lazy_import(globals(), """
104
from bzrlib.i18n import gettext
105
from bzrlib.util.configobj import configobj
113
from bzrlib.symbol_versioning import (
131
POLICY_APPENDPATH = 2
135
POLICY_NORECURSE: 'norecurse',
136
POLICY_APPENDPATH: 'appendpath',
141
'norecurse': POLICY_NORECURSE,
142
'appendpath': POLICY_APPENDPATH,
146
STORE_LOCATION = POLICY_NONE
147
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
148
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
153
def signature_policy_from_unicode(signature_string):
154
"""Convert a string to a signing policy."""
155
if signature_string.lower() == 'check-available':
156
return CHECK_IF_POSSIBLE
157
if signature_string.lower() == 'ignore':
159
if signature_string.lower() == 'require':
161
raise ValueError("Invalid signatures policy '%s'"
165
def signing_policy_from_unicode(signature_string):
166
"""Convert a string to a signing policy."""
167
if signature_string.lower() == 'when-required':
168
return SIGN_WHEN_REQUIRED
169
if signature_string.lower() == 'never':
171
if signature_string.lower() == 'always':
173
raise ValueError("Invalid signing policy '%s'"
177
class ConfigObj(configobj.ConfigObj):
179
def __init__(self, infile=None, **kwargs):
180
# We define our own interpolation mechanism calling it option expansion
181
super(ConfigObj, self).__init__(infile=infile,
185
def get_bool(self, section, key):
186
return self[section].as_bool(key)
188
def get_value(self, section, name):
189
# Try [] for the old DEFAULT section.
190
if section == "DEFAULT":
195
return self[section][name]
198
class Config(object):
199
"""A configuration policy - what username, editor, gpg needs etc."""
202
super(Config, self).__init__()
205
"""Returns a unique ID for the config."""
206
raise NotImplementedError(self.config_id)
208
def get_change_editor(self, old_tree, new_tree):
209
from bzrlib import diff
210
cmd = self._get_change_editor()
213
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
216
def _get_signature_checking(self):
217
"""Template method to override signature checking policy."""
219
def _get_signing_policy(self):
220
"""Template method to override signature creation policy."""
224
def expand_options(self, string, env=None):
225
"""Expand option references in the string in the configuration context.
227
:param string: The string containing option to expand.
229
:param env: An option dict defining additional configuration options or
230
overriding existing ones.
232
:returns: The expanded string.
234
return self._expand_options_in_string(string, env)
236
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
237
"""Expand options in a list of strings in the configuration context.
239
:param slist: A list of strings.
241
:param env: An option dict defining additional configuration options or
242
overriding existing ones.
244
:param _ref_stack: Private list containing the options being
245
expanded to detect loops.
247
:returns: The flatten list of expanded strings.
249
# expand options in each value separately flattening lists
252
value = self._expand_options_in_string(s, env, _ref_stack)
253
if isinstance(value, list):
259
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
260
"""Expand options in the string in the configuration context.
262
:param string: The string to be expanded.
264
:param env: An option dict defining additional configuration options or
265
overriding existing ones.
267
:param _ref_stack: Private list containing the options being
268
expanded to detect loops.
270
:returns: The expanded string.
273
# Not much to expand there
275
if _ref_stack is None:
276
# What references are currently resolved (to detect loops)
278
if self.option_ref_re is None:
279
# We want to match the most embedded reference first (i.e. for
280
# '{{foo}}' we will get '{foo}',
281
# for '{bar{baz}}' we will get '{baz}'
282
self.option_ref_re = re.compile('({[^{}]+})')
284
# We need to iterate until no more refs appear ({{foo}} will need two
285
# iterations for example).
287
raw_chunks = self.option_ref_re.split(result)
288
if len(raw_chunks) == 1:
289
# Shorcut the trivial case: no refs
293
# Split will isolate refs so that every other chunk is a ref
295
for chunk in raw_chunks:
298
# Keep only non-empty strings (or we get bogus empty
299
# slots when a list value is involved).
304
if name in _ref_stack:
305
raise errors.OptionExpansionLoop(string, _ref_stack)
306
_ref_stack.append(name)
307
value = self._expand_option(name, env, _ref_stack)
309
raise errors.ExpandingUnknownOption(name, string)
310
if isinstance(value, list):
318
# Once a list appears as the result of an expansion, all
319
# callers will get a list result. This allows a consistent
320
# behavior even when some options in the expansion chain
321
# defined as strings (no comma in their value) but their
322
# expanded value is a list.
323
return self._expand_options_in_list(chunks, env, _ref_stack)
325
result = ''.join(chunks)
328
def _expand_option(self, name, env, _ref_stack):
329
if env is not None and name in env:
330
# Special case, values provided in env takes precedence over
334
# FIXME: This is a limited implementation, what we really need is a
335
# way to query the bzr config for the value of an option,
336
# respecting the scope rules (That is, once we implement fallback
337
# configs, getting the option value should restart from the top
338
# config, not the current one) -- vila 20101222
339
value = self.get_user_option(name, expand=False)
340
if isinstance(value, list):
341
value = self._expand_options_in_list(value, env, _ref_stack)
343
value = self._expand_options_in_string(value, env, _ref_stack)
346
def _get_user_option(self, option_name):
347
"""Template method to provide a user option."""
350
def get_user_option(self, option_name, expand=True):
351
"""Get a generic option - no special process, no default.
353
:param option_name: The queried option.
355
:param expand: Whether options references should be expanded.
357
:returns: The value of the option.
359
value = self._get_user_option(option_name)
361
if isinstance(value, list):
362
value = self._expand_options_in_list(value)
363
elif isinstance(value, dict):
364
trace.warning('Cannot expand "%s":'
365
' Dicts do not support option expansion'
368
value = self._expand_options_in_string(value)
369
for hook in OldConfigHooks['get']:
370
hook(self, option_name, value)
373
def get_user_option_as_bool(self, option_name, expand=None, default=None):
374
"""Get a generic option as a boolean.
376
:param expand: Allow expanding references to other config values.
377
:param default: Default value if nothing is configured
378
:return None if the option doesn't exist or its value can't be
379
interpreted as a boolean. Returns True or False otherwise.
381
s = self.get_user_option(option_name, expand=expand)
383
# The option doesn't exist
385
val = ui.bool_from_string(s)
387
# The value can't be interpreted as a boolean
388
trace.warning('Value "%s" is not a boolean for "%s"',
392
def get_user_option_as_list(self, option_name, expand=None):
393
"""Get a generic option as a list - no special process, no default.
395
:return None if the option doesn't exist. Returns the value as a list
398
l = self.get_user_option(option_name, expand=expand)
399
if isinstance(l, (str, unicode)):
400
# A single value, most probably the user forgot (or didn't care to
405
@deprecated_method(deprecated_in((2, 5, 0)))
406
def get_user_option_as_int_from_SI(self, option_name, default=None):
407
"""Get a generic option from a human readable size in SI units, e.g 10MB
409
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
410
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
413
:return Integer, expanded to its base-10 value if a proper SI unit is
414
found. If the option doesn't exist, or isn't a value in
415
SI units, return default (which defaults to None)
417
val = self.get_user_option(option_name)
418
if isinstance(val, list):
423
p = re.compile("^(\d+)([kmg])*b*$", re.IGNORECASE)
427
val = int(m.group(1))
428
if m.group(2) is not None:
429
if m.group(2).lower() == 'k':
431
elif m.group(2).lower() == 'm':
433
elif m.group(2).lower() == 'g':
436
ui.ui_factory.show_warning(gettext('Invalid config value for "{0}" '
437
' value {1!r} is not an SI unit.').format(
444
@deprecated_method(deprecated_in((2, 5, 0)))
445
def gpg_signing_command(self):
446
"""What program should be used to sign signatures?"""
447
result = self._gpg_signing_command()
452
def _gpg_signing_command(self):
453
"""See gpg_signing_command()."""
456
@deprecated_method(deprecated_in((2, 5, 0)))
457
def log_format(self):
458
"""What log format should be used"""
459
result = self._log_format()
464
def _log_format(self):
465
"""See log_format()."""
468
def validate_signatures_in_log(self):
469
"""Show GPG signature validity in log"""
470
result = self._validate_signatures_in_log()
477
def _validate_signatures_in_log(self):
478
"""See validate_signatures_in_log()."""
481
@deprecated_method(deprecated_in((2, 5, 0)))
482
def acceptable_keys(self):
483
"""Comma separated list of key patterns acceptable to
484
verify-signatures command"""
485
result = self._acceptable_keys()
488
def _acceptable_keys(self):
489
"""See acceptable_keys()."""
492
@deprecated_method(deprecated_in((2, 5, 0)))
493
def post_commit(self):
494
"""An ordered list of python functions to call.
496
Each function takes branch, rev_id as parameters.
498
return self._post_commit()
500
def _post_commit(self):
501
"""See Config.post_commit."""
504
def user_email(self):
505
"""Return just the email component of a username."""
506
return extract_email_address(self.username())
509
"""Return email-style username.
511
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
513
$BZR_EMAIL can be set to override this, then
514
the concrete policy type is checked, and finally
516
If no username can be found, errors.NoWhoami exception is raised.
518
v = os.environ.get('BZR_EMAIL')
520
return v.decode(osutils.get_user_encoding())
521
v = self._get_user_id()
524
return default_email()
526
def ensure_username(self):
527
"""Raise errors.NoWhoami if username is not set.
529
This method relies on the username() function raising the error.
533
@deprecated_method(deprecated_in((2, 5, 0)))
534
def signature_checking(self):
535
"""What is the current policy for signature checking?."""
536
policy = self._get_signature_checking()
537
if policy is not None:
539
return CHECK_IF_POSSIBLE
541
@deprecated_method(deprecated_in((2, 5, 0)))
542
def signing_policy(self):
543
"""What is the current policy for signature checking?."""
544
policy = self._get_signing_policy()
545
if policy is not None:
547
return SIGN_WHEN_REQUIRED
549
@deprecated_method(deprecated_in((2, 5, 0)))
550
def signature_needed(self):
551
"""Is a signature needed when committing ?."""
552
policy = self._get_signing_policy()
554
policy = self._get_signature_checking()
555
if policy is not None:
556
#this warning should go away once check_signatures is
557
#implemented (if not before)
558
trace.warning("Please use create_signatures,"
559
" not check_signatures to set signing policy.")
560
elif policy == SIGN_ALWAYS:
564
@deprecated_method(deprecated_in((2, 5, 0)))
565
def gpg_signing_key(self):
566
"""GPG user-id to sign commits"""
567
key = self.get_user_option('gpg_signing_key')
568
if key == "default" or key == None:
569
return self.user_email()
573
def get_alias(self, value):
574
return self._get_alias(value)
576
def _get_alias(self, value):
579
def get_nickname(self):
580
return self._get_nickname()
582
def _get_nickname(self):
585
def get_bzr_remote_path(self):
587
return os.environ['BZR_REMOTE_PATH']
589
path = self.get_user_option("bzr_remote_path")
594
def suppress_warning(self, warning):
595
"""Should the warning be suppressed or emitted.
597
:param warning: The name of the warning being tested.
599
:returns: True if the warning should be suppressed, False otherwise.
601
warnings = self.get_user_option_as_list('suppress_warnings')
602
if warnings is None or warning not in warnings:
607
def get_merge_tools(self):
609
for (oname, value, section, conf_id, parser) in self._get_options():
610
if oname.startswith('bzr.mergetool.'):
611
tool_name = oname[len('bzr.mergetool.'):]
612
tools[tool_name] = self.get_user_option(oname, False)
613
trace.mutter('loaded merge tools: %r' % tools)
616
def find_merge_tool(self, name):
617
# We fake a defaults mechanism here by checking if the given name can
618
# be found in the known_merge_tools if it's not found in the config.
619
# This should be done through the proposed config defaults mechanism
620
# when it becomes available in the future.
621
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
623
or mergetools.known_merge_tools.get(name, None))
627
class _ConfigHooks(hooks.Hooks):
628
"""A dict mapping hook names and a list of callables for configs.
632
"""Create the default hooks.
634
These are all empty initially, because by default nothing should get
637
super(_ConfigHooks, self).__init__('bzrlib.config', 'ConfigHooks')
638
self.add_hook('load',
639
'Invoked when a config store is loaded.'
640
' The signature is (store).',
642
self.add_hook('save',
643
'Invoked when a config store is saved.'
644
' The signature is (store).',
646
# The hooks for config options
648
'Invoked when a config option is read.'
649
' The signature is (stack, name, value).',
652
'Invoked when a config option is set.'
653
' The signature is (stack, name, value).',
655
self.add_hook('remove',
656
'Invoked when a config option is removed.'
657
' The signature is (stack, name).',
659
ConfigHooks = _ConfigHooks()
662
class _OldConfigHooks(hooks.Hooks):
663
"""A dict mapping hook names and a list of callables for configs.
667
"""Create the default hooks.
669
These are all empty initially, because by default nothing should get
672
super(_OldConfigHooks, self).__init__('bzrlib.config', 'OldConfigHooks')
673
self.add_hook('load',
674
'Invoked when a config store is loaded.'
675
' The signature is (config).',
677
self.add_hook('save',
678
'Invoked when a config store is saved.'
679
' The signature is (config).',
681
# The hooks for config options
683
'Invoked when a config option is read.'
684
' The signature is (config, name, value).',
687
'Invoked when a config option is set.'
688
' The signature is (config, name, value).',
690
self.add_hook('remove',
691
'Invoked when a config option is removed.'
692
' The signature is (config, name).',
694
OldConfigHooks = _OldConfigHooks()
697
class IniBasedConfig(Config):
698
"""A configuration policy that draws from ini files."""
700
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
702
"""Base class for configuration files using an ini-like syntax.
704
:param file_name: The configuration file path.
706
super(IniBasedConfig, self).__init__()
707
self.file_name = file_name
708
if symbol_versioning.deprecated_passed(get_filename):
709
symbol_versioning.warn(
710
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
711
' Use file_name instead.',
714
if get_filename is not None:
715
self.file_name = get_filename()
717
self.file_name = file_name
722
def from_string(cls, str_or_unicode, file_name=None, save=False):
723
"""Create a config object from a string.
725
:param str_or_unicode: A string representing the file content. This will
728
:param file_name: The configuration file path.
730
:param _save: Whether the file should be saved upon creation.
732
conf = cls(file_name=file_name)
733
conf._create_from_string(str_or_unicode, save)
736
def _create_from_string(self, str_or_unicode, save):
737
self._content = StringIO(str_or_unicode.encode('utf-8'))
738
# Some tests use in-memory configs, some other always need the config
739
# file to exist on disk.
741
self._write_config_file()
743
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
744
if self._parser is not None:
746
if symbol_versioning.deprecated_passed(file):
747
symbol_versioning.warn(
748
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
749
' Use IniBasedConfig(_content=xxx) instead.',
752
if self._content is not None:
753
co_input = self._content
754
elif self.file_name is None:
755
raise AssertionError('We have no content to create the config')
757
co_input = self.file_name
759
self._parser = ConfigObj(co_input, encoding='utf-8')
760
except configobj.ConfigObjError, e:
761
raise errors.ParseConfigError(e.errors, e.config.filename)
762
except UnicodeDecodeError:
763
raise errors.ConfigContentError(self.file_name)
764
# Make sure self.reload() will use the right file name
765
self._parser.filename = self.file_name
766
for hook in OldConfigHooks['load']:
771
"""Reload the config file from disk."""
772
if self.file_name is None:
773
raise AssertionError('We need a file name to reload the config')
774
if self._parser is not None:
775
self._parser.reload()
776
for hook in ConfigHooks['load']:
779
def _get_matching_sections(self):
780
"""Return an ordered list of (section_name, extra_path) pairs.
782
If the section contains inherited configuration, extra_path is
783
a string containing the additional path components.
785
section = self._get_section()
786
if section is not None:
787
return [(section, '')]
791
def _get_section(self):
792
"""Override this to define the section used by the config."""
795
def _get_sections(self, name=None):
796
"""Returns an iterator of the sections specified by ``name``.
798
:param name: The section name. If None is supplied, the default
799
configurations are yielded.
801
:return: A tuple (name, section, config_id) for all sections that will
802
be walked by user_get_option() in the 'right' order. The first one
803
is where set_user_option() will update the value.
805
parser = self._get_parser()
807
yield (name, parser[name], self.config_id())
809
# No section name has been given so we fallback to the configobj
810
# itself which holds the variables defined outside of any section.
811
yield (None, parser, self.config_id())
813
def _get_options(self, sections=None):
814
"""Return an ordered list of (name, value, section, config_id) tuples.
816
All options are returned with their associated value and the section
817
they appeared in. ``config_id`` is a unique identifier for the
818
configuration file the option is defined in.
820
:param sections: Default to ``_get_matching_sections`` if not
821
specified. This gives a better control to daughter classes about
822
which sections should be searched. This is a list of (name,
827
parser = self._get_parser()
829
for (section_name, _) in self._get_matching_sections():
831
section = parser[section_name]
833
# This could happen for an empty file for which we define a
834
# DEFAULT section. FIXME: Force callers to provide sections
835
# instead ? -- vila 20100930
837
sections.append((section_name, section))
838
config_id = self.config_id()
839
for (section_name, section) in sections:
840
for (name, value) in section.iteritems():
841
yield (name, parser._quote(value), section_name,
844
def _get_option_policy(self, section, option_name):
845
"""Return the policy for the given (section, option_name) pair."""
848
def _get_change_editor(self):
849
return self.get_user_option('change_editor')
851
def _get_signature_checking(self):
852
"""See Config._get_signature_checking."""
853
policy = self._get_user_option('check_signatures')
855
return signature_policy_from_unicode(policy)
857
def _get_signing_policy(self):
858
"""See Config._get_signing_policy"""
859
policy = self._get_user_option('create_signatures')
861
return signing_policy_from_unicode(policy)
863
def _get_user_id(self):
864
"""Get the user id from the 'email' key in the current section."""
865
return self._get_user_option('email')
867
def _get_user_option(self, option_name):
868
"""See Config._get_user_option."""
869
for (section, extra_path) in self._get_matching_sections():
871
value = self._get_parser().get_value(section, option_name)
874
policy = self._get_option_policy(section, option_name)
875
if policy == POLICY_NONE:
877
elif policy == POLICY_NORECURSE:
878
# norecurse items only apply to the exact path
883
elif policy == POLICY_APPENDPATH:
885
value = urlutils.join(value, extra_path)
888
raise AssertionError('Unexpected config policy %r' % policy)
892
def _gpg_signing_command(self):
893
"""See Config.gpg_signing_command."""
894
return self._get_user_option('gpg_signing_command')
896
def _log_format(self):
897
"""See Config.log_format."""
898
return self._get_user_option('log_format')
900
def _validate_signatures_in_log(self):
901
"""See Config.validate_signatures_in_log."""
902
return self._get_user_option('validate_signatures_in_log')
904
def _acceptable_keys(self):
905
"""See Config.acceptable_keys."""
906
return self._get_user_option('acceptable_keys')
908
def _post_commit(self):
909
"""See Config.post_commit."""
910
return self._get_user_option('post_commit')
912
def _get_alias(self, value):
914
return self._get_parser().get_value("ALIASES",
919
def _get_nickname(self):
920
return self.get_user_option('nickname')
922
def remove_user_option(self, option_name, section_name=None):
923
"""Remove a user option and save the configuration file.
925
:param option_name: The option to be removed.
927
:param section_name: The section the option is defined in, default to
931
parser = self._get_parser()
932
if section_name is None:
935
section = parser[section_name]
937
del section[option_name]
939
raise errors.NoSuchConfigOption(option_name)
940
self._write_config_file()
941
for hook in OldConfigHooks['remove']:
942
hook(self, option_name)
944
def _write_config_file(self):
945
if self.file_name is None:
946
raise AssertionError('We cannot save, self.file_name is None')
947
conf_dir = os.path.dirname(self.file_name)
948
ensure_config_dir_exists(conf_dir)
949
atomic_file = atomicfile.AtomicFile(self.file_name)
950
self._get_parser().write(atomic_file)
953
osutils.copy_ownership_from_path(self.file_name)
954
for hook in OldConfigHooks['save']:
958
class LockableConfig(IniBasedConfig):
959
"""A configuration needing explicit locking for access.
961
If several processes try to write the config file, the accesses need to be
964
Daughter classes should decorate all methods that update a config with the
965
``@needs_write_lock`` decorator (they call, directly or indirectly, the
966
``_write_config_file()`` method. These methods (typically ``set_option()``
967
and variants must reload the config file from disk before calling
968
``_write_config_file()``), this can be achieved by calling the
969
``self.reload()`` method. Note that the lock scope should cover both the
970
reading and the writing of the config file which is why the decorator can't
971
be applied to ``_write_config_file()`` only.
973
This should be enough to implement the following logic:
974
- lock for exclusive write access,
975
- reload the config file from disk,
979
This logic guarantees that a writer can update a value without erasing an
980
update made by another writer.
985
def __init__(self, file_name):
986
super(LockableConfig, self).__init__(file_name=file_name)
987
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
988
# FIXME: It doesn't matter that we don't provide possible_transports
989
# below since this is currently used only for local config files ;
990
# local transports are not shared. But if/when we start using
991
# LockableConfig for other kind of transports, we will need to reuse
992
# whatever connection is already established -- vila 20100929
993
self.transport = transport.get_transport_from_path(self.dir)
994
self._lock = lockdir.LockDir(self.transport, self.lock_name)
996
def _create_from_string(self, unicode_bytes, save):
997
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
999
# We need to handle the saving here (as opposed to IniBasedConfig)
1000
# to be able to lock
1002
self._write_config_file()
1005
def lock_write(self, token=None):
1006
"""Takes a write lock in the directory containing the config file.
1008
If the directory doesn't exist it is created.
1010
ensure_config_dir_exists(self.dir)
1011
return self._lock.lock_write(token)
1016
def break_lock(self):
1017
self._lock.break_lock()
1020
def remove_user_option(self, option_name, section_name=None):
1021
super(LockableConfig, self).remove_user_option(option_name,
1024
def _write_config_file(self):
1025
if self._lock is None or not self._lock.is_held:
1026
# NB: if the following exception is raised it probably means a
1027
# missing @needs_write_lock decorator on one of the callers.
1028
raise errors.ObjectNotLocked(self)
1029
super(LockableConfig, self)._write_config_file()
1032
class GlobalConfig(LockableConfig):
1033
"""The configuration that should be used for a specific location."""
1036
super(GlobalConfig, self).__init__(file_name=config_filename())
1038
def config_id(self):
1042
def from_string(cls, str_or_unicode, save=False):
1043
"""Create a config object from a string.
1045
:param str_or_unicode: A string representing the file content. This
1046
will be utf-8 encoded.
1048
:param save: Whether the file should be saved upon creation.
1051
conf._create_from_string(str_or_unicode, save)
1055
def set_user_option(self, option, value):
1056
"""Save option and its value in the configuration."""
1057
self._set_option(option, value, 'DEFAULT')
1059
def get_aliases(self):
1060
"""Return the aliases section."""
1061
if 'ALIASES' in self._get_parser():
1062
return self._get_parser()['ALIASES']
1067
def set_alias(self, alias_name, alias_command):
1068
"""Save the alias in the configuration."""
1069
self._set_option(alias_name, alias_command, 'ALIASES')
1072
def unset_alias(self, alias_name):
1073
"""Unset an existing alias."""
1075
aliases = self._get_parser().get('ALIASES')
1076
if not aliases or alias_name not in aliases:
1077
raise errors.NoSuchAlias(alias_name)
1078
del aliases[alias_name]
1079
self._write_config_file()
1081
def _set_option(self, option, value, section):
1083
self._get_parser().setdefault(section, {})[option] = value
1084
self._write_config_file()
1085
for hook in OldConfigHooks['set']:
1086
hook(self, option, value)
1088
def _get_sections(self, name=None):
1089
"""See IniBasedConfig._get_sections()."""
1090
parser = self._get_parser()
1091
# We don't give access to options defined outside of any section, we
1092
# used the DEFAULT section by... default.
1093
if name in (None, 'DEFAULT'):
1094
# This could happen for an empty file where the DEFAULT section
1095
# doesn't exist yet. So we force DEFAULT when yielding
1097
if 'DEFAULT' not in parser:
1098
parser['DEFAULT']= {}
1099
yield (name, parser[name], self.config_id())
1102
def remove_user_option(self, option_name, section_name=None):
1103
if section_name is None:
1104
# We need to force the default section.
1105
section_name = 'DEFAULT'
1106
# We need to avoid the LockableConfig implementation or we'll lock
1108
super(LockableConfig, self).remove_user_option(option_name,
1111
def _iter_for_location_by_parts(sections, location):
1112
"""Keep only the sessions matching the specified location.
1114
:param sections: An iterable of section names.
1116
:param location: An url or a local path to match against.
1118
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1119
number of path components in the section name, section is the section
1120
name and extra_path is the difference between location and the section
1123
``location`` will always be a local path and never a 'file://' url but the
1124
section names themselves can be in either form.
1126
location_parts = location.rstrip('/').split('/')
1128
for section in sections:
1129
# location is a local path if possible, so we need to convert 'file://'
1130
# urls in section names to local paths if necessary.
1132
# This also avoids having file:///path be a more exact
1133
# match than '/path'.
1135
# FIXME: This still raises an issue if a user defines both file:///path
1136
# *and* /path. Should we raise an error in this case -- vila 20110505
1138
if section.startswith('file://'):
1139
section_path = urlutils.local_path_from_url(section)
1141
section_path = section
1142
section_parts = section_path.rstrip('/').split('/')
1145
if len(section_parts) > len(location_parts):
1146
# More path components in the section, they can't match
1149
# Rely on zip truncating in length to the length of the shortest
1150
# argument sequence.
1151
names = zip(location_parts, section_parts)
1153
if not fnmatch.fnmatch(name[0], name[1]):
1158
# build the path difference between the section and the location
1159
extra_path = '/'.join(location_parts[len(section_parts):])
1160
yield section, extra_path, len(section_parts)
1163
class LocationConfig(LockableConfig):
1164
"""A configuration object that gives the policy for a location."""
1166
def __init__(self, location):
1167
super(LocationConfig, self).__init__(
1168
file_name=locations_config_filename())
1169
# local file locations are looked up by local path, rather than
1170
# by file url. This is because the config file is a user
1171
# file, and we would rather not expose the user to file urls.
1172
if location.startswith('file://'):
1173
location = urlutils.local_path_from_url(location)
1174
self.location = location
1176
def config_id(self):
1180
def from_string(cls, str_or_unicode, location, save=False):
1181
"""Create a config object from a string.
1183
:param str_or_unicode: A string representing the file content. This will
1186
:param location: The location url to filter the configuration.
1188
:param save: Whether the file should be saved upon creation.
1190
conf = cls(location)
1191
conf._create_from_string(str_or_unicode, save)
1194
def _get_matching_sections(self):
1195
"""Return an ordered list of section names matching this location."""
1196
matches = list(_iter_for_location_by_parts(self._get_parser(),
1198
# put the longest (aka more specific) locations first
1200
key=lambda (section, extra_path, length): (length, section),
1202
for (section, extra_path, length) in matches:
1203
yield section, extra_path
1204
# should we stop looking for parent configs here?
1206
if self._get_parser()[section].as_bool('ignore_parents'):
1211
def _get_sections(self, name=None):
1212
"""See IniBasedConfig._get_sections()."""
1213
# We ignore the name here as the only sections handled are named with
1214
# the location path and we don't expose embedded sections either.
1215
parser = self._get_parser()
1216
for name, extra_path in self._get_matching_sections():
1217
yield (name, parser[name], self.config_id())
1219
def _get_option_policy(self, section, option_name):
1220
"""Return the policy for the given (section, option_name) pair."""
1221
# check for the old 'recurse=False' flag
1223
recurse = self._get_parser()[section].as_bool('recurse')
1227
return POLICY_NORECURSE
1229
policy_key = option_name + ':policy'
1231
policy_name = self._get_parser()[section][policy_key]
1235
return _policy_value[policy_name]
1237
def _set_option_policy(self, section, option_name, option_policy):
1238
"""Set the policy for the given option name in the given section."""
1239
# The old recurse=False option affects all options in the
1240
# section. To handle multiple policies in the section, we
1241
# need to convert it to a policy_norecurse key.
1243
recurse = self._get_parser()[section].as_bool('recurse')
1247
symbol_versioning.warn(
1248
'The recurse option is deprecated as of 0.14. '
1249
'The section "%s" has been converted to use policies.'
1252
del self._get_parser()[section]['recurse']
1254
for key in self._get_parser()[section].keys():
1255
if not key.endswith(':policy'):
1256
self._get_parser()[section][key +
1257
':policy'] = 'norecurse'
1259
policy_key = option_name + ':policy'
1260
policy_name = _policy_name[option_policy]
1261
if policy_name is not None:
1262
self._get_parser()[section][policy_key] = policy_name
1264
if policy_key in self._get_parser()[section]:
1265
del self._get_parser()[section][policy_key]
1268
def set_user_option(self, option, value, store=STORE_LOCATION):
1269
"""Save option and its value in the configuration."""
1270
if store not in [STORE_LOCATION,
1271
STORE_LOCATION_NORECURSE,
1272
STORE_LOCATION_APPENDPATH]:
1273
raise ValueError('bad storage policy %r for %r' %
1276
location = self.location
1277
if location.endswith('/'):
1278
location = location[:-1]
1279
parser = self._get_parser()
1280
if not location in parser and not location + '/' in parser:
1281
parser[location] = {}
1282
elif location + '/' in parser:
1283
location = location + '/'
1284
parser[location][option]=value
1285
# the allowed values of store match the config policies
1286
self._set_option_policy(location, option, store)
1287
self._write_config_file()
1288
for hook in OldConfigHooks['set']:
1289
hook(self, option, value)
1292
class BranchConfig(Config):
1293
"""A configuration object giving the policy for a branch."""
1295
def __init__(self, branch):
1296
super(BranchConfig, self).__init__()
1297
self._location_config = None
1298
self._branch_data_config = None
1299
self._global_config = None
1300
self.branch = branch
1301
self.option_sources = (self._get_location_config,
1302
self._get_branch_data_config,
1303
self._get_global_config)
1305
def config_id(self):
1308
def _get_branch_data_config(self):
1309
if self._branch_data_config is None:
1310
self._branch_data_config = TreeConfig(self.branch)
1311
self._branch_data_config.config_id = self.config_id
1312
return self._branch_data_config
1314
def _get_location_config(self):
1315
if self._location_config is None:
1316
self._location_config = LocationConfig(self.branch.base)
1317
return self._location_config
1319
def _get_global_config(self):
1320
if self._global_config is None:
1321
self._global_config = GlobalConfig()
1322
return self._global_config
1324
def _get_best_value(self, option_name):
1325
"""This returns a user option from local, tree or global config.
1327
They are tried in that order. Use get_safe_value if trusted values
1330
for source in self.option_sources:
1331
value = getattr(source(), option_name)()
1332
if value is not None:
1336
def _get_safe_value(self, option_name):
1337
"""This variant of get_best_value never returns untrusted values.
1339
It does not return values from the branch data, because the branch may
1340
not be controlled by the user.
1342
We may wish to allow locations.conf to control whether branches are
1343
trusted in the future.
1345
for source in (self._get_location_config, self._get_global_config):
1346
value = getattr(source(), option_name)()
1347
if value is not None:
1351
def _get_user_id(self):
1352
"""Return the full user id for the branch.
1354
e.g. "John Hacker <jhacker@example.com>"
1355
This is looked up in the email controlfile for the branch.
1357
return self._get_best_value('_get_user_id')
1359
def _get_change_editor(self):
1360
return self._get_best_value('_get_change_editor')
1362
def _get_signature_checking(self):
1363
"""See Config._get_signature_checking."""
1364
return self._get_best_value('_get_signature_checking')
1366
def _get_signing_policy(self):
1367
"""See Config._get_signing_policy."""
1368
return self._get_best_value('_get_signing_policy')
1370
def _get_user_option(self, option_name):
1371
"""See Config._get_user_option."""
1372
for source in self.option_sources:
1373
value = source()._get_user_option(option_name)
1374
if value is not None:
1378
def _get_sections(self, name=None):
1379
"""See IniBasedConfig.get_sections()."""
1380
for source in self.option_sources:
1381
for section in source()._get_sections(name):
1384
def _get_options(self, sections=None):
1386
# First the locations options
1387
for option in self._get_location_config()._get_options():
1389
# Then the branch options
1390
branch_config = self._get_branch_data_config()
1391
if sections is None:
1392
sections = [('DEFAULT', branch_config._get_parser())]
1393
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1394
# Config itself has no notion of sections :( -- vila 20101001
1395
config_id = self.config_id()
1396
for (section_name, section) in sections:
1397
for (name, value) in section.iteritems():
1398
yield (name, value, section_name,
1399
config_id, branch_config._get_parser())
1400
# Then the global options
1401
for option in self._get_global_config()._get_options():
1404
def set_user_option(self, name, value, store=STORE_BRANCH,
1406
if store == STORE_BRANCH:
1407
self._get_branch_data_config().set_option(value, name)
1408
elif store == STORE_GLOBAL:
1409
self._get_global_config().set_user_option(name, value)
1411
self._get_location_config().set_user_option(name, value, store)
1414
if store in (STORE_GLOBAL, STORE_BRANCH):
1415
mask_value = self._get_location_config().get_user_option(name)
1416
if mask_value is not None:
1417
trace.warning('Value "%s" is masked by "%s" from'
1418
' locations.conf', value, mask_value)
1420
if store == STORE_GLOBAL:
1421
branch_config = self._get_branch_data_config()
1422
mask_value = branch_config.get_user_option(name)
1423
if mask_value is not None:
1424
trace.warning('Value "%s" is masked by "%s" from'
1425
' branch.conf', value, mask_value)
1427
def remove_user_option(self, option_name, section_name=None):
1428
self._get_branch_data_config().remove_option(option_name, section_name)
1430
def _gpg_signing_command(self):
1431
"""See Config.gpg_signing_command."""
1432
return self._get_safe_value('_gpg_signing_command')
1434
def _post_commit(self):
1435
"""See Config.post_commit."""
1436
return self._get_safe_value('_post_commit')
1438
def _get_nickname(self):
1439
value = self._get_explicit_nickname()
1440
if value is not None:
1442
if self.branch.name:
1443
return self.branch.name
1444
return urlutils.unescape(self.branch.base.split('/')[-2])
1446
def has_explicit_nickname(self):
1447
"""Return true if a nickname has been explicitly assigned."""
1448
return self._get_explicit_nickname() is not None
1450
def _get_explicit_nickname(self):
1451
return self._get_best_value('_get_nickname')
1453
def _log_format(self):
1454
"""See Config.log_format."""
1455
return self._get_best_value('_log_format')
1457
def _validate_signatures_in_log(self):
1458
"""See Config.validate_signatures_in_log."""
1459
return self._get_best_value('_validate_signatures_in_log')
1461
def _acceptable_keys(self):
1462
"""See Config.acceptable_keys."""
1463
return self._get_best_value('_acceptable_keys')
1466
def ensure_config_dir_exists(path=None):
1467
"""Make sure a configuration directory exists.
1468
This makes sure that the directory exists.
1469
On windows, since configuration directories are 2 levels deep,
1470
it makes sure both the directory and the parent directory exists.
1474
if not os.path.isdir(path):
1475
if sys.platform == 'win32':
1476
parent_dir = os.path.dirname(path)
1477
if not os.path.isdir(parent_dir):
1478
trace.mutter('creating config parent directory: %r', parent_dir)
1479
os.mkdir(parent_dir)
1480
trace.mutter('creating config directory: %r', path)
1482
osutils.copy_ownership_from_path(path)
1486
"""Return per-user configuration directory as unicode string
1488
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1489
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1490
that will be used instead.
1492
TODO: Global option --config-dir to override this.
1494
base = osutils.path_from_environ('BZR_HOME')
1495
if sys.platform == 'win32':
1497
base = win32utils.get_appdata_location()
1499
base = win32utils.get_home_location()
1500
# GZ 2012-02-01: Really the two level subdirs only make sense inside
1501
# APPDATA, but hard to move. See bug 348640 for more.
1502
return osutils.pathjoin(base, 'bazaar', '2.0')
1504
# GZ 2012-02-01: What should OSX use instead of XDG if anything?
1505
if sys.platform != 'darwin':
1506
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1508
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1509
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1510
if osutils.isdir(xdg_dir):
1512
"Using configuration in XDG directory %s." % xdg_dir)
1514
base = osutils._get_home_dir()
1515
return osutils.pathjoin(base, ".bazaar")
1518
def config_filename():
1519
"""Return per-user configuration ini file filename."""
1520
return osutils.pathjoin(config_dir(), 'bazaar.conf')
1523
def locations_config_filename():
1524
"""Return per-user configuration ini file filename."""
1525
return osutils.pathjoin(config_dir(), 'locations.conf')
1528
def authentication_config_filename():
1529
"""Return per-user authentication ini file filename."""
1530
return osutils.pathjoin(config_dir(), 'authentication.conf')
1533
def user_ignore_config_filename():
1534
"""Return the user default ignore filename"""
1535
return osutils.pathjoin(config_dir(), 'ignore')
1539
"""Return the directory name to store crash files.
1541
This doesn't implicitly create it.
1543
On Windows it's in the config directory; elsewhere it's /var/crash
1544
which may be monitored by apport. It can be overridden by
1547
if sys.platform == 'win32':
1548
return osutils.pathjoin(config_dir(), 'Crash')
1550
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1552
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1555
def xdg_cache_dir():
1556
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1557
# Possibly this should be different on Windows?
1558
e = os.environ.get('XDG_CACHE_DIR', None)
1562
return os.path.expanduser('~/.cache')
1565
def _get_default_mail_domain():
1566
"""If possible, return the assumed default email domain.
1568
:returns: string mail domain, or None.
1570
if sys.platform == 'win32':
1571
# No implementation yet; patches welcome
1574
f = open('/etc/mailname')
1575
except (IOError, OSError), e:
1578
domain = f.read().strip()
1584
def default_email():
1585
v = os.environ.get('BZR_EMAIL')
1587
return v.decode(osutils.get_user_encoding())
1588
v = os.environ.get('EMAIL')
1590
return v.decode(osutils.get_user_encoding())
1591
name, email = _auto_user_id()
1593
return u'%s <%s>' % (name, email)
1596
raise errors.NoWhoami()
1599
def _auto_user_id():
1600
"""Calculate automatic user identification.
1602
:returns: (realname, email), either of which may be None if they can't be
1605
Only used when none is set in the environment or the id file.
1607
This only returns an email address if we can be fairly sure the
1608
address is reasonable, ie if /etc/mailname is set on unix.
1610
This doesn't use the FQDN as the default domain because that may be
1611
slow, and it doesn't use the hostname alone because that's not normally
1612
a reasonable address.
1614
if sys.platform == 'win32':
1615
# No implementation to reliably determine Windows default mail
1616
# address; please add one.
1619
default_mail_domain = _get_default_mail_domain()
1620
if not default_mail_domain:
1626
w = pwd.getpwuid(uid)
1628
trace.mutter('no passwd entry for uid %d?' % uid)
1631
# we try utf-8 first, because on many variants (like Linux),
1632
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1633
# false positives. (many users will have their user encoding set to
1634
# latin-1, which cannot raise UnicodeError.)
1636
gecos = w.pw_gecos.decode('utf-8')
1638
except UnicodeError:
1640
encoding = osutils.get_user_encoding()
1641
gecos = w.pw_gecos.decode(encoding)
1642
except UnicodeError, e:
1643
trace.mutter("cannot decode passwd entry %s" % w)
1646
username = w.pw_name.decode(encoding)
1647
except UnicodeError, e:
1648
trace.mutter("cannot decode passwd entry %s" % w)
1651
comma = gecos.find(',')
1655
realname = gecos[:comma]
1657
return realname, (username + '@' + default_mail_domain)
1660
def parse_username(username):
1661
"""Parse e-mail username and return a (name, address) tuple."""
1662
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1664
return (username, '')
1666
return (match.group(1), match.group(2))
1669
def extract_email_address(e):
1670
"""Return just the address part of an email string.
1672
That is just the user@domain part, nothing else.
1673
This part is required to contain only ascii characters.
1674
If it can't be extracted, raises an error.
1676
>>> extract_email_address('Jane Tester <jane@test.com>')
1679
name, email = parse_username(e)
1681
raise errors.NoEmailInUsername(e)
1685
class TreeConfig(IniBasedConfig):
1686
"""Branch configuration data associated with its contents, not location"""
1688
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1690
def __init__(self, branch):
1691
self._config = branch._get_config()
1692
self.branch = branch
1694
def _get_parser(self, file=None):
1695
if file is not None:
1696
return IniBasedConfig._get_parser(file)
1697
return self._config._get_configobj()
1699
def get_option(self, name, section=None, default=None):
1700
self.branch.lock_read()
1702
return self._config.get_option(name, section, default)
1704
self.branch.unlock()
1706
def set_option(self, value, name, section=None):
1707
"""Set a per-branch configuration option"""
1708
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1709
# higher levels providing the right lock -- vila 20101004
1710
self.branch.lock_write()
1712
self._config.set_option(value, name, section)
1714
self.branch.unlock()
1716
def remove_option(self, option_name, section_name=None):
1717
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1718
# higher levels providing the right lock -- vila 20101004
1719
self.branch.lock_write()
1721
self._config.remove_option(option_name, section_name)
1723
self.branch.unlock()
1726
class AuthenticationConfig(object):
1727
"""The authentication configuration file based on a ini file.
1729
Implements the authentication.conf file described in
1730
doc/developers/authentication-ring.txt.
1733
def __init__(self, _file=None):
1734
self._config = None # The ConfigObj
1736
self._filename = authentication_config_filename()
1737
self._input = self._filename = authentication_config_filename()
1739
# Tests can provide a string as _file
1740
self._filename = None
1743
def _get_config(self):
1744
if self._config is not None:
1747
# FIXME: Should we validate something here ? Includes: empty
1748
# sections are useless, at least one of
1749
# user/password/password_encoding should be defined, etc.
1751
# Note: the encoding below declares that the file itself is utf-8
1752
# encoded, but the values in the ConfigObj are always Unicode.
1753
self._config = ConfigObj(self._input, encoding='utf-8')
1754
except configobj.ConfigObjError, e:
1755
raise errors.ParseConfigError(e.errors, e.config.filename)
1756
except UnicodeError:
1757
raise errors.ConfigContentError(self._filename)
1761
"""Save the config file, only tests should use it for now."""
1762
conf_dir = os.path.dirname(self._filename)
1763
ensure_config_dir_exists(conf_dir)
1764
f = file(self._filename, 'wb')
1766
self._get_config().write(f)
1770
def _set_option(self, section_name, option_name, value):
1771
"""Set an authentication configuration option"""
1772
conf = self._get_config()
1773
section = conf.get(section_name)
1776
section = conf[section]
1777
section[option_name] = value
1780
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1782
"""Returns the matching credentials from authentication.conf file.
1784
:param scheme: protocol
1786
:param host: the server address
1788
:param port: the associated port (optional)
1790
:param user: login (optional)
1792
:param path: the absolute path on the server (optional)
1794
:param realm: the http authentication realm (optional)
1796
:return: A dict containing the matching credentials or None.
1798
- name: the section name of the credentials in the
1799
authentication.conf file,
1800
- user: can't be different from the provided user if any,
1801
- scheme: the server protocol,
1802
- host: the server address,
1803
- port: the server port (can be None),
1804
- path: the absolute server path (can be None),
1805
- realm: the http specific authentication realm (can be None),
1806
- password: the decoded password, could be None if the credential
1807
defines only the user
1808
- verify_certificates: https specific, True if the server
1809
certificate should be verified, False otherwise.
1812
for auth_def_name, auth_def in self._get_config().items():
1813
if type(auth_def) is not configobj.Section:
1814
raise ValueError("%s defined outside a section" % auth_def_name)
1816
a_scheme, a_host, a_user, a_path = map(
1817
auth_def.get, ['scheme', 'host', 'user', 'path'])
1820
a_port = auth_def.as_int('port')
1824
raise ValueError("'port' not numeric in %s" % auth_def_name)
1826
a_verify_certificates = auth_def.as_bool('verify_certificates')
1828
a_verify_certificates = True
1831
"'verify_certificates' not boolean in %s" % auth_def_name)
1834
if a_scheme is not None and scheme != a_scheme:
1836
if a_host is not None:
1837
if not (host == a_host
1838
or (a_host.startswith('.') and host.endswith(a_host))):
1840
if a_port is not None and port != a_port:
1842
if (a_path is not None and path is not None
1843
and not path.startswith(a_path)):
1845
if (a_user is not None and user is not None
1846
and a_user != user):
1847
# Never contradict the caller about the user to be used
1852
# Prepare a credentials dictionary with additional keys
1853
# for the credential providers
1854
credentials = dict(name=auth_def_name,
1861
password=auth_def.get('password', None),
1862
verify_certificates=a_verify_certificates)
1863
# Decode the password in the credentials (or get one)
1864
self.decode_password(credentials,
1865
auth_def.get('password_encoding', None))
1866
if 'auth' in debug.debug_flags:
1867
trace.mutter("Using authentication section: %r", auth_def_name)
1870
if credentials is None:
1871
# No credentials were found in authentication.conf, try the fallback
1872
# credentials stores.
1873
credentials = credential_store_registry.get_fallback_credentials(
1874
scheme, host, port, user, path, realm)
1878
def set_credentials(self, name, host, user, scheme=None, password=None,
1879
port=None, path=None, verify_certificates=None,
1881
"""Set authentication credentials for a host.
1883
Any existing credentials with matching scheme, host, port and path
1884
will be deleted, regardless of name.
1886
:param name: An arbitrary name to describe this set of credentials.
1887
:param host: Name of the host that accepts these credentials.
1888
:param user: The username portion of these credentials.
1889
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1891
:param password: Password portion of these credentials.
1892
:param port: The IP port on the host that these credentials apply to.
1893
:param path: A filesystem path on the host that these credentials
1895
:param verify_certificates: On https, verify server certificates if
1897
:param realm: The http authentication realm (optional).
1899
values = {'host': host, 'user': user}
1900
if password is not None:
1901
values['password'] = password
1902
if scheme is not None:
1903
values['scheme'] = scheme
1904
if port is not None:
1905
values['port'] = '%d' % port
1906
if path is not None:
1907
values['path'] = path
1908
if verify_certificates is not None:
1909
values['verify_certificates'] = str(verify_certificates)
1910
if realm is not None:
1911
values['realm'] = realm
1912
config = self._get_config()
1914
for section, existing_values in config.items():
1915
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1916
if existing_values.get(key) != values.get(key):
1920
config.update({name: values})
1923
def get_user(self, scheme, host, port=None, realm=None, path=None,
1924
prompt=None, ask=False, default=None):
1925
"""Get a user from authentication file.
1927
:param scheme: protocol
1929
:param host: the server address
1931
:param port: the associated port (optional)
1933
:param realm: the realm sent by the server (optional)
1935
:param path: the absolute path on the server (optional)
1937
:param ask: Ask the user if there is no explicitly configured username
1940
:param default: The username returned if none is defined (optional).
1942
:return: The found user.
1944
credentials = self.get_credentials(scheme, host, port, user=None,
1945
path=path, realm=realm)
1946
if credentials is not None:
1947
user = credentials['user']
1953
# Create a default prompt suitable for most cases
1954
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1955
# Special handling for optional fields in the prompt
1956
if port is not None:
1957
prompt_host = '%s:%d' % (host, port)
1960
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1965
def get_password(self, scheme, host, user, port=None,
1966
realm=None, path=None, prompt=None):
1967
"""Get a password from authentication file or prompt the user for one.
1969
:param scheme: protocol
1971
:param host: the server address
1973
:param port: the associated port (optional)
1977
:param realm: the realm sent by the server (optional)
1979
:param path: the absolute path on the server (optional)
1981
:return: The found password or the one entered by the user.
1983
credentials = self.get_credentials(scheme, host, port, user, path,
1985
if credentials is not None:
1986
password = credentials['password']
1987
if password is not None and scheme is 'ssh':
1988
trace.warning('password ignored in section [%s],'
1989
' use an ssh agent instead'
1990
% credentials['name'])
1994
# Prompt user only if we could't find a password
1995
if password is None:
1997
# Create a default prompt suitable for most cases
1998
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
1999
# Special handling for optional fields in the prompt
2000
if port is not None:
2001
prompt_host = '%s:%d' % (host, port)
2004
password = ui.ui_factory.get_password(prompt,
2005
host=prompt_host, user=user)
2008
def decode_password(self, credentials, encoding):
2010
cs = credential_store_registry.get_credential_store(encoding)
2012
raise ValueError('%r is not a known password_encoding' % encoding)
2013
credentials['password'] = cs.decode_password(credentials)
2017
class CredentialStoreRegistry(registry.Registry):
2018
"""A class that registers credential stores.
2020
A credential store provides access to credentials via the password_encoding
2021
field in authentication.conf sections.
2023
Except for stores provided by bzr itself, most stores are expected to be
2024
provided by plugins that will therefore use
2025
register_lazy(password_encoding, module_name, member_name, help=help,
2026
fallback=fallback) to install themselves.
2028
A fallback credential store is one that is queried if no credentials can be
2029
found via authentication.conf.
2032
def get_credential_store(self, encoding=None):
2033
cs = self.get(encoding)
2038
def is_fallback(self, name):
2039
"""Check if the named credentials store should be used as fallback."""
2040
return self.get_info(name)
2042
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2043
path=None, realm=None):
2044
"""Request credentials from all fallback credentials stores.
2046
The first credentials store that can provide credentials wins.
2049
for name in self.keys():
2050
if not self.is_fallback(name):
2052
cs = self.get_credential_store(name)
2053
credentials = cs.get_credentials(scheme, host, port, user,
2055
if credentials is not None:
2056
# We found some credentials
2060
def register(self, key, obj, help=None, override_existing=False,
2062
"""Register a new object to a name.
2064
:param key: This is the key to use to request the object later.
2065
:param obj: The object to register.
2066
:param help: Help text for this entry. This may be a string or
2067
a callable. If it is a callable, it should take two
2068
parameters (registry, key): this registry and the key that
2069
the help was registered under.
2070
:param override_existing: Raise KeyErorr if False and something has
2071
already been registered for that key. If True, ignore if there
2072
is an existing key (always register the new value).
2073
:param fallback: Whether this credential store should be
2076
return super(CredentialStoreRegistry,
2077
self).register(key, obj, help, info=fallback,
2078
override_existing=override_existing)
2080
def register_lazy(self, key, module_name, member_name,
2081
help=None, override_existing=False,
2083
"""Register a new credential store to be loaded on request.
2085
:param module_name: The python path to the module. Such as 'os.path'.
2086
:param member_name: The member of the module to return. If empty or
2087
None, get() will return the module itself.
2088
:param help: Help text for this entry. This may be a string or
2090
:param override_existing: If True, replace the existing object
2091
with the new one. If False, if there is already something
2092
registered with the same key, raise a KeyError
2093
:param fallback: Whether this credential store should be
2096
return super(CredentialStoreRegistry, self).register_lazy(
2097
key, module_name, member_name, help,
2098
info=fallback, override_existing=override_existing)
2101
credential_store_registry = CredentialStoreRegistry()
2104
class CredentialStore(object):
2105
"""An abstract class to implement storage for credentials"""
2107
def decode_password(self, credentials):
2108
"""Returns a clear text password for the provided credentials."""
2109
raise NotImplementedError(self.decode_password)
2111
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2113
"""Return the matching credentials from this credential store.
2115
This method is only called on fallback credential stores.
2117
raise NotImplementedError(self.get_credentials)
2121
class PlainTextCredentialStore(CredentialStore):
2122
__doc__ = """Plain text credential store for the authentication.conf file"""
2124
def decode_password(self, credentials):
2125
"""See CredentialStore.decode_password."""
2126
return credentials['password']
2129
credential_store_registry.register('plain', PlainTextCredentialStore,
2130
help=PlainTextCredentialStore.__doc__)
2131
credential_store_registry.default_key = 'plain'
2134
class BzrDirConfig(object):
2136
def __init__(self, bzrdir):
2137
self._bzrdir = bzrdir
2138
self._config = bzrdir._get_config()
2140
def set_default_stack_on(self, value):
2141
"""Set the default stacking location.
2143
It may be set to a location, or None.
2145
This policy affects all branches contained by this control dir, except
2146
for those under repositories.
2148
if self._config is None:
2149
raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
2151
self._config.set_option('', 'default_stack_on')
2153
self._config.set_option(value, 'default_stack_on')
2155
def get_default_stack_on(self):
2156
"""Return the default stacking location.
2158
This will either be a location, or None.
2160
This policy affects all branches contained by this control dir, except
2161
for those under repositories.
2163
if self._config is None:
2165
value = self._config.get_option('default_stack_on')
2171
class TransportConfig(object):
2172
"""A Config that reads/writes a config file on a Transport.
2174
It is a low-level object that considers config data to be name/value pairs
2175
that may be associated with a section. Assigning meaning to these values
2176
is done at higher levels like TreeConfig.
2179
def __init__(self, transport, filename):
2180
self._transport = transport
2181
self._filename = filename
2183
def get_option(self, name, section=None, default=None):
2184
"""Return the value associated with a named option.
2186
:param name: The name of the value
2187
:param section: The section the option is in (if any)
2188
:param default: The value to return if the value is not set
2189
:return: The value or default value
2191
configobj = self._get_configobj()
2193
section_obj = configobj
2196
section_obj = configobj[section]
2199
value = section_obj.get(name, default)
2200
for hook in OldConfigHooks['get']:
2201
hook(self, name, value)
2204
def set_option(self, value, name, section=None):
2205
"""Set the value associated with a named option.
2207
:param value: The value to set
2208
:param name: The name of the value to set
2209
:param section: The section the option is in (if any)
2211
configobj = self._get_configobj()
2213
configobj[name] = value
2215
configobj.setdefault(section, {})[name] = value
2216
for hook in OldConfigHooks['set']:
2217
hook(self, name, value)
2218
self._set_configobj(configobj)
2220
def remove_option(self, option_name, section_name=None):
2221
configobj = self._get_configobj()
2222
if section_name is None:
2223
del configobj[option_name]
2225
del configobj[section_name][option_name]
2226
for hook in OldConfigHooks['remove']:
2227
hook(self, option_name)
2228
self._set_configobj(configobj)
2230
def _get_config_file(self):
2232
f = StringIO(self._transport.get_bytes(self._filename))
2233
for hook in OldConfigHooks['load']:
2236
except errors.NoSuchFile:
2238
except errors.PermissionDenied, e:
2239
trace.warning("Permission denied while trying to open "
2240
"configuration file %s.", urlutils.unescape_for_display(
2241
urlutils.join(self._transport.base, self._filename), "utf-8"))
2244
def _external_url(self):
2245
return urlutils.join(self._transport.external_url(), self._filename)
2247
def _get_configobj(self):
2248
f = self._get_config_file()
2251
conf = ConfigObj(f, encoding='utf-8')
2252
except configobj.ConfigObjError, e:
2253
raise errors.ParseConfigError(e.errors, self._external_url())
2254
except UnicodeDecodeError:
2255
raise errors.ConfigContentError(self._external_url())
2260
def _set_configobj(self, configobj):
2261
out_file = StringIO()
2262
configobj.write(out_file)
2264
self._transport.put_file(self._filename, out_file)
2265
for hook in OldConfigHooks['save']:
2269
class Option(object):
2270
"""An option definition.
2272
The option *values* are stored in config files and found in sections.
2274
Here we define various properties about the option itself, its default
2275
value, how to convert it from stores, what to do when invalid values are
2276
encoutered, in which config files it can be stored.
2279
def __init__(self, name, override_from_env=None,
2280
default=None, default_from_env=None,
2281
help=None, from_unicode=None, invalid=None, unquote=True):
2282
"""Build an option definition.
2284
:param name: the name used to refer to the option.
2286
:param override_from_env: A list of environment variables which can
2287
provide override any configuration setting.
2289
:param default: the default value to use when none exist in the config
2290
stores. This is either a string that ``from_unicode`` will convert
2291
into the proper type, a callable returning a unicode string so that
2292
``from_unicode`` can be used on the return value, or a python
2293
object that can be stringified (so only the empty list is supported
2296
:param default_from_env: A list of environment variables which can
2297
provide a default value. 'default' will be used only if none of the
2298
variables specified here are set in the environment.
2300
:param help: a doc string to explain the option to the user.
2302
:param from_unicode: a callable to convert the unicode string
2303
representing the option value in a store. This is not called for
2306
:param invalid: the action to be taken when an invalid value is
2307
encountered in a store. This is called only when from_unicode is
2308
invoked to convert a string and returns None or raise ValueError or
2309
TypeError. Accepted values are: None (ignore invalid values),
2310
'warning' (emit a warning), 'error' (emit an error message and
2313
:param unquote: should the unicode value be unquoted before conversion.
2314
This should be used only when the store providing the values cannot
2315
safely unquote them (see http://pad.lv/906897). It is provided so
2316
daughter classes can handle the quoting themselves.
2318
if override_from_env is None:
2319
override_from_env = []
2320
if default_from_env is None:
2321
default_from_env = []
2323
self.override_from_env = override_from_env
2324
# Convert the default value to a unicode string so all values are
2325
# strings internally before conversion (via from_unicode) is attempted.
2328
elif isinstance(default, list):
2329
# Only the empty list is supported
2331
raise AssertionError(
2332
'Only empty lists are supported as default values')
2334
elif isinstance(default, (str, unicode, bool, int, float)):
2335
# Rely on python to convert strings, booleans and integers
2336
self.default = u'%s' % (default,)
2337
elif callable(default):
2338
self.default = default
2340
# other python objects are not expected
2341
raise AssertionError('%r is not supported as a default value'
2343
self.default_from_env = default_from_env
2345
self.from_unicode = from_unicode
2346
self.unquote = unquote
2347
if invalid and invalid not in ('warning', 'error'):
2348
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2349
self.invalid = invalid
2355
def convert_from_unicode(self, store, unicode_value):
2356
if self.unquote and store is not None and unicode_value is not None:
2357
unicode_value = store.unquote(unicode_value)
2358
if self.from_unicode is None or unicode_value is None:
2359
# Don't convert or nothing to convert
2360
return unicode_value
2362
converted = self.from_unicode(unicode_value)
2363
except (ValueError, TypeError):
2364
# Invalid values are ignored
2366
if converted is None and self.invalid is not None:
2367
# The conversion failed
2368
if self.invalid == 'warning':
2369
trace.warning('Value "%s" is not valid for "%s"',
2370
unicode_value, self.name)
2371
elif self.invalid == 'error':
2372
raise errors.ConfigOptionValueError(self.name, unicode_value)
2375
def get_override(self):
2377
for var in self.override_from_env:
2379
# If the env variable is defined, its value takes precedence
2380
value = os.environ[var].decode(osutils.get_user_encoding())
2386
def get_default(self):
2388
for var in self.default_from_env:
2390
# If the env variable is defined, its value is the default one
2391
value = os.environ[var].decode(osutils.get_user_encoding())
2396
# Otherwise, fallback to the value defined at registration
2397
if callable(self.default):
2398
value = self.default()
2399
if not isinstance(value, unicode):
2400
raise AssertionError(
2401
"Callable default value for '%s' should be unicode"
2404
value = self.default
2407
def get_help_topic(self):
2410
def get_help_text(self, additional_see_also=None, plain=True):
2412
from bzrlib import help_topics
2413
result += help_topics._format_see_also(additional_see_also)
2415
result = help_topics.help_as_plain_text(result)
2419
# Predefined converters to get proper values from store
2421
def bool_from_store(unicode_str):
2422
return ui.bool_from_string(unicode_str)
2425
def int_from_store(unicode_str):
2426
return int(unicode_str)
2429
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2431
def int_SI_from_store(unicode_str):
2432
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2434
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2435
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2438
:return Integer, expanded to its base-10 value if a proper SI unit is
2439
found, None otherwise.
2441
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2442
p = re.compile(regexp, re.IGNORECASE)
2443
m = p.match(unicode_str)
2446
val, _, unit = m.groups()
2450
coeff = _unit_suffixes[unit.upper()]
2452
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2457
def float_from_store(unicode_str):
2458
return float(unicode_str)
2461
# Use a an empty dict to initialize an empty configobj avoiding all
2462
# parsing and encoding checks
2463
_list_converter_config = configobj.ConfigObj(
2464
{}, encoding='utf-8', list_values=True, interpolation=False)
2467
class ListOption(Option):
2469
def __init__(self, name, default=None, default_from_env=None,
2470
help=None, invalid=None):
2471
"""A list Option definition.
2473
This overrides the base class so the conversion from a unicode string
2474
can take quoting into account.
2476
super(ListOption, self).__init__(
2477
name, default=default, default_from_env=default_from_env,
2478
from_unicode=self.from_unicode, help=help,
2479
invalid=invalid, unquote=False)
2481
def from_unicode(self, unicode_str):
2482
if not isinstance(unicode_str, basestring):
2484
# Now inject our string directly as unicode. All callers got their
2485
# value from configobj, so values that need to be quoted are already
2487
_list_converter_config.reset()
2488
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2489
maybe_list = _list_converter_config['list']
2490
if isinstance(maybe_list, basestring):
2492
# A single value, most probably the user forgot (or didn't care
2493
# to add) the final ','
2496
# The empty string, convert to empty list
2499
# We rely on ConfigObj providing us with a list already
2504
class RegistryOption(Option):
2505
"""Option for a choice from a registry."""
2507
def __init__(self, name, registry, default_from_env=None,
2508
help=None, invalid=None):
2509
"""A registry based Option definition.
2511
This overrides the base class so the conversion from a unicode string
2512
can take quoting into account.
2514
super(RegistryOption, self).__init__(
2515
name, default=lambda: unicode(registry.default_key),
2516
default_from_env=default_from_env,
2517
from_unicode=self.from_unicode, help=help,
2518
invalid=invalid, unquote=False)
2519
self.registry = registry
2521
def from_unicode(self, unicode_str):
2522
if not isinstance(unicode_str, basestring):
2525
return self.registry.get(unicode_str)
2528
"Invalid value %s for %s."
2529
"See help for a list of possible values." % (unicode_str,
2534
ret = [self._help, "\n\nThe following values are supported:\n"]
2535
for key in self.registry.keys():
2536
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2540
class OptionRegistry(registry.Registry):
2541
"""Register config options by their name.
2543
This overrides ``registry.Registry`` to simplify registration by acquiring
2544
some information from the option object itself.
2547
def register(self, option):
2548
"""Register a new option to its name.
2550
:param option: The option to register. Its name is used as the key.
2552
super(OptionRegistry, self).register(option.name, option,
2555
def register_lazy(self, key, module_name, member_name):
2556
"""Register a new option to be loaded on request.
2558
:param key: the key to request the option later. Since the registration
2559
is lazy, it should be provided and match the option name.
2561
:param module_name: the python path to the module. Such as 'os.path'.
2563
:param member_name: the member of the module to return. If empty or
2564
None, get() will return the module itself.
2566
super(OptionRegistry, self).register_lazy(key,
2567
module_name, member_name)
2569
def get_help(self, key=None):
2570
"""Get the help text associated with the given key"""
2571
option = self.get(key)
2572
the_help = option.help
2573
if callable(the_help):
2574
return the_help(self, key)
2578
option_registry = OptionRegistry()
2581
# Registered options in lexicographical order
2583
option_registry.register(
2584
Option('append_revisions_only',
2585
default=None, from_unicode=bool_from_store, invalid='warning',
2587
Whether to only append revisions to the mainline.
2589
If this is set to true, then it is not possible to change the
2590
existing mainline of the branch.
2592
option_registry.register(
2593
ListOption('acceptable_keys',
2596
List of GPG key patterns which are acceptable for verification.
2598
option_registry.register(
2599
Option('add.maximum_file_size',
2600
default=u'20MB', from_unicode=int_SI_from_store,
2602
Size above which files should be added manually.
2604
Files below this size are added automatically when using ``bzr add`` without
2607
A negative value means disable the size check.
2609
option_registry.register(
2611
default=None, from_unicode=bool_from_store,
2613
Is the branch bound to ``bound_location``.
2615
If set to "True", the branch should act as a checkout, and push each commit to
2616
the bound_location. This option is normally set by ``bind``/``unbind``.
2618
See also: bound_location.
2620
option_registry.register(
2621
Option('bound_location',
2624
The location that commits should go to when acting as a checkout.
2626
This option is normally set by ``bind``.
2630
option_registry.register(
2631
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2633
Whether revisions associated with tags should be fetched.
2635
option_registry.register_lazy(
2636
'bzr.transform.orphan_policy', 'bzrlib.transform', 'opt_transform_orphan')
2637
option_registry.register(
2638
Option('bzr.workingtree.worth_saving_limit', default=10,
2639
from_unicode=int_from_store, invalid='warning',
2641
How many changes before saving the dirstate.
2643
-1 means that we will never rewrite the dirstate file for only
2644
stat-cache changes. Regardless of this setting, we will always rewrite
2645
the dirstate file if a file is added/removed/renamed/etc. This flag only
2646
affects the behavior of updating the dirstate file after we notice that
2647
a file has been touched.
2649
option_registry.register(
2650
Option('bugtracker', default=None,
2652
Default bug tracker to use.
2654
This bug tracker will be used for example when marking bugs
2655
as fixed using ``bzr commit --fixes``, if no explicit
2656
bug tracker was specified.
2658
option_registry.register(
2659
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2660
from_unicode=signature_policy_from_unicode,
2662
GPG checking policy.
2664
Possible values: require, ignore, check-available (default)
2666
this option will control whether bzr will require good gpg
2667
signatures, ignore them, or check them if they are
2670
option_registry.register(
2671
Option('child_submit_format',
2672
help='''The preferred format of submissions to this branch.'''))
2673
option_registry.register(
2674
Option('child_submit_to',
2675
help='''Where submissions to this branch are mailed to.'''))
2676
option_registry.register(
2677
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2678
from_unicode=signing_policy_from_unicode,
2682
Possible values: always, never, when-required (default)
2684
This option controls whether bzr will always create
2685
gpg signatures or not on commits.
2687
option_registry.register(
2688
Option('dirstate.fdatasync', default=True,
2689
from_unicode=bool_from_store,
2691
Flush dirstate changes onto physical disk?
2693
If true (default), working tree metadata changes are flushed through the
2694
OS buffers to physical disk. This is somewhat slower, but means data
2695
should not be lost if the machine crashes. See also repository.fdatasync.
2697
option_registry.register(
2698
ListOption('debug_flags', default=[],
2699
help='Debug flags to activate.'))
2700
option_registry.register(
2701
Option('default_format', default='2a',
2702
help='Format used when creating branches.'))
2703
option_registry.register(
2704
Option('dpush_strict', default=None,
2705
from_unicode=bool_from_store,
2707
The default value for ``dpush --strict``.
2709
If present, defines the ``--strict`` option default value for checking
2710
uncommitted changes before pushing into a different VCS without any
2711
custom bzr metadata.
2713
option_registry.register(
2715
help='The command called to launch an editor to enter a message.'))
2716
option_registry.register(
2717
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2718
help='The users identity'))
2719
option_registry.register(
2720
Option('gpg_signing_command',
2723
Program to use use for creating signatures.
2725
This should support at least the -u and --clearsign options.
2727
option_registry.register(
2728
Option('gpg_signing_key',
2731
GPG key to use for signing.
2733
This defaults to the first key associated with the users email.
2735
option_registry.register(
2736
Option('ignore_missing_extensions', default=False,
2737
from_unicode=bool_from_store,
2739
Control the missing extensions warning display.
2741
The warning will not be emitted if set to True.
2743
option_registry.register(
2745
help='Language to translate messages into.'))
2746
option_registry.register(
2747
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2749
Steal locks that appears to be dead.
2751
If set to True, bzr will check if a lock is supposed to be held by an
2752
active process from the same user on the same machine. If the user and
2753
machine match, but no process with the given PID is active, then bzr
2754
will automatically break the stale lock, and create a new lock for
2756
Otherwise, bzr will prompt as normal to break the lock.
2758
option_registry.register(
2759
Option('log_format', default='long',
2761
Log format to use when displaying revisions.
2763
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2764
may be provided by plugins.
2766
option_registry.register_lazy('mail_client', 'bzrlib.mail_client',
2768
option_registry.register(
2769
Option('output_encoding',
2770
help= 'Unicode encoding for output'
2771
' (terminal encoding if not specified).'))
2772
option_registry.register(
2773
Option('parent_location',
2776
The location of the default branch for pull or merge.
2778
This option is normally set when creating a branch, the first ``pull`` or by
2779
``pull --remember``.
2781
option_registry.register(
2782
Option('post_commit', default=None,
2784
Post commit functions.
2786
An ordered list of python functions to call, separated by spaces.
2788
Each function takes branch, rev_id as parameters.
2790
option_registry.register(
2791
Option('public_branch',
2794
A publically-accessible version of this branch.
2796
This implies that the branch setting this option is not publically-accessible.
2797
Used and set by ``bzr send``.
2799
option_registry.register(
2800
Option('push_location',
2803
The location of the default branch for push.
2805
This option is normally set by the first ``push`` or ``push --remember``.
2807
option_registry.register(
2808
Option('push_strict', default=None,
2809
from_unicode=bool_from_store,
2811
The default value for ``push --strict``.
2813
If present, defines the ``--strict`` option default value for checking
2814
uncommitted changes before sending a merge directive.
2816
option_registry.register(
2817
Option('repository.fdatasync', default=True,
2818
from_unicode=bool_from_store,
2820
Flush repository changes onto physical disk?
2822
If true (default), repository changes are flushed through the OS buffers
2823
to physical disk. This is somewhat slower, but means data should not be
2824
lost if the machine crashes. See also dirstate.fdatasync.
2826
option_registry.register_lazy('smtp_server',
2827
'bzrlib.smtp_connection', 'smtp_server')
2828
option_registry.register_lazy('smtp_password',
2829
'bzrlib.smtp_connection', 'smtp_password')
2830
option_registry.register_lazy('smtp_username',
2831
'bzrlib.smtp_connection', 'smtp_username')
2832
option_registry.register(
2833
Option('selftest.timeout',
2835
from_unicode=int_from_store,
2836
help='Abort selftest if one test takes longer than this many seconds',
2839
option_registry.register(
2840
Option('send_strict', default=None,
2841
from_unicode=bool_from_store,
2843
The default value for ``send --strict``.
2845
If present, defines the ``--strict`` option default value for checking
2846
uncommitted changes before sending a bundle.
2849
option_registry.register(
2850
Option('serve.client_timeout',
2851
default=300.0, from_unicode=float_from_store,
2852
help="If we wait for a new request from a client for more than"
2853
" X seconds, consider the client idle, and hangup."))
2854
option_registry.register(
2855
Option('stacked_on_location',
2857
help="""The location where this branch is stacked on."""))
2858
option_registry.register(
2859
Option('submit_branch',
2862
The branch you intend to submit your current work to.
2864
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2865
by the ``submit:`` revision spec.
2867
option_registry.register(
2869
help='''Where submissions from this branch are mailed to.'''))
2870
option_registry.register(
2871
ListOption('suppress_warnings',
2873
help="List of warning classes to suppress."))
2874
option_registry.register(
2875
Option('validate_signatures_in_log', default=False,
2876
from_unicode=bool_from_store, invalid='warning',
2877
help='''Whether to validate signatures in bzr log.'''))
2878
option_registry.register_lazy('ssl.ca_certs',
2879
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2881
option_registry.register_lazy('ssl.cert_reqs',
2882
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2885
class Section(object):
2886
"""A section defines a dict of option name => value.
2888
This is merely a read-only dict which can add some knowledge about the
2889
options. It is *not* a python dict object though and doesn't try to mimic
2893
def __init__(self, section_id, options):
2894
self.id = section_id
2895
# We re-use the dict-like object received
2896
self.options = options
2898
def get(self, name, default=None, expand=True):
2899
return self.options.get(name, default)
2901
def iter_option_names(self):
2902
for k in self.options.iterkeys():
2906
# Mostly for debugging use
2907
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2910
_NewlyCreatedOption = object()
2911
"""Was the option created during the MutableSection lifetime"""
2912
_DeletedOption = object()
2913
"""Was the option deleted during the MutableSection lifetime"""
2916
class MutableSection(Section):
2917
"""A section allowing changes and keeping track of the original values."""
2919
def __init__(self, section_id, options):
2920
super(MutableSection, self).__init__(section_id, options)
2921
self.reset_changes()
2923
def set(self, name, value):
2924
if name not in self.options:
2925
# This is a new option
2926
self.orig[name] = _NewlyCreatedOption
2927
elif name not in self.orig:
2928
self.orig[name] = self.get(name, None)
2929
self.options[name] = value
2931
def remove(self, name):
2932
if name not in self.orig:
2933
self.orig[name] = self.get(name, None)
2934
del self.options[name]
2936
def reset_changes(self):
2939
def apply_changes(self, dirty, store):
2940
"""Apply option value changes.
2942
``self`` has been reloaded from the persistent storage. ``dirty``
2943
contains the changes made since the previous loading.
2945
:param dirty: the mutable section containing the changes.
2947
:param store: the store containing the section
2949
for k, expected in dirty.orig.iteritems():
2950
actual = dirty.get(k, _DeletedOption)
2951
reloaded = self.get(k, _NewlyCreatedOption)
2952
if actual is _DeletedOption:
2953
if k in self.options:
2957
# Report concurrent updates in an ad-hoc way. This should only
2958
# occurs when different processes try to update the same option
2959
# which is not supported (as in: the config framework is not meant
2960
# to be used as a sharing mechanism).
2961
if expected != reloaded:
2962
if actual is _DeletedOption:
2963
actual = '<DELETED>'
2964
if reloaded is _NewlyCreatedOption:
2965
reloaded = '<CREATED>'
2966
if expected is _NewlyCreatedOption:
2967
expected = '<CREATED>'
2968
# Someone changed the value since we get it from the persistent
2970
trace.warning(gettext(
2971
"Option {0} in section {1} of {2} was changed"
2972
" from {3} to {4}. The {5} value will be saved.".format(
2973
k, self.id, store.external_url(), expected,
2975
# No need to keep track of these changes
2976
self.reset_changes()
2979
class Store(object):
2980
"""Abstract interface to persistent storage for configuration options."""
2982
readonly_section_class = Section
2983
mutable_section_class = MutableSection
2986
# Which sections need to be saved (by section id). We use a dict here
2987
# so the dirty sections can be shared by multiple callers.
2988
self.dirty_sections = {}
2990
def is_loaded(self):
2991
"""Returns True if the Store has been loaded.
2993
This is used to implement lazy loading and ensure the persistent
2994
storage is queried only when needed.
2996
raise NotImplementedError(self.is_loaded)
2999
"""Loads the Store from persistent storage."""
3000
raise NotImplementedError(self.load)
3002
def _load_from_string(self, bytes):
3003
"""Create a store from a string in configobj syntax.
3005
:param bytes: A string representing the file content.
3007
raise NotImplementedError(self._load_from_string)
3010
"""Unloads the Store.
3012
This should make is_loaded() return False. This is used when the caller
3013
knows that the persistent storage has changed or may have change since
3016
raise NotImplementedError(self.unload)
3018
def quote(self, value):
3019
"""Quote a configuration option value for storing purposes.
3021
This allows Stacks to present values as they will be stored.
3025
def unquote(self, value):
3026
"""Unquote a configuration option value into unicode.
3028
The received value is quoted as stored.
3033
"""Saves the Store to persistent storage."""
3034
raise NotImplementedError(self.save)
3036
def _need_saving(self):
3037
for s in self.dirty_sections.values():
3039
# At least one dirty section contains a modification
3043
def apply_changes(self, dirty_sections):
3044
"""Apply changes from dirty sections while checking for coherency.
3046
The Store content is discarded and reloaded from persistent storage to
3047
acquire up-to-date values.
3049
Dirty sections are MutableSection which kept track of the value they
3050
are expected to update.
3052
# We need an up-to-date version from the persistent storage, unload the
3053
# store. The reload will occur when needed (triggered by the first
3054
# get_mutable_section() call below.
3056
# Apply the changes from the preserved dirty sections
3057
for section_id, dirty in dirty_sections.iteritems():
3058
clean = self.get_mutable_section(section_id)
3059
clean.apply_changes(dirty, self)
3060
# Everything is clean now
3061
self.dirty_sections = {}
3063
def save_changes(self):
3064
"""Saves the Store to persistent storage if changes occurred.
3066
Apply the changes recorded in the mutable sections to a store content
3067
refreshed from persistent storage.
3069
raise NotImplementedError(self.save_changes)
3071
def external_url(self):
3072
raise NotImplementedError(self.external_url)
3074
def get_sections(self):
3075
"""Returns an ordered iterable of existing sections.
3077
:returns: An iterable of (store, section).
3079
raise NotImplementedError(self.get_sections)
3081
def get_mutable_section(self, section_id=None):
3082
"""Returns the specified mutable section.
3084
:param section_id: The section identifier
3086
raise NotImplementedError(self.get_mutable_section)
3089
# Mostly for debugging use
3090
return "<config.%s(%s)>" % (self.__class__.__name__,
3091
self.external_url())
3094
class CommandLineStore(Store):
3095
"A store to carry command line overrides for the config options."""
3097
def __init__(self, opts=None):
3098
super(CommandLineStore, self).__init__()
3105
# The dict should be cleared but not replaced so it can be shared.
3106
self.options.clear()
3108
def _from_cmdline(self, overrides):
3109
# Reset before accepting new definitions
3111
for over in overrides:
3113
name, value = over.split('=', 1)
3115
raise errors.BzrCommandError(
3116
gettext("Invalid '%s', should be of the form 'name=value'")
3118
self.options[name] = value
3120
def external_url(self):
3121
# Not an url but it makes debugging easier and is never needed
3125
def get_sections(self):
3126
yield self, self.readonly_section_class(None, self.options)
3129
class IniFileStore(Store):
3130
"""A config Store using ConfigObj for storage.
3132
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3133
serialize/deserialize the config file.
3137
"""A config Store using ConfigObj for storage.
3139
super(IniFileStore, self).__init__()
3140
self._config_obj = None
3142
def is_loaded(self):
3143
return self._config_obj != None
3146
self._config_obj = None
3147
self.dirty_sections = {}
3149
def _load_content(self):
3150
"""Load the config file bytes.
3152
This should be provided by subclasses
3154
:return: Byte string
3156
raise NotImplementedError(self._load_content)
3158
def _save_content(self, content):
3159
"""Save the config file bytes.
3161
This should be provided by subclasses
3163
:param content: Config file bytes to write
3165
raise NotImplementedError(self._save_content)
3168
"""Load the store from the associated file."""
3169
if self.is_loaded():
3171
content = self._load_content()
3172
self._load_from_string(content)
3173
for hook in ConfigHooks['load']:
3176
def _load_from_string(self, bytes):
3177
"""Create a config store from a string.
3179
:param bytes: A string representing the file content.
3181
if self.is_loaded():
3182
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3183
co_input = StringIO(bytes)
3185
# The config files are always stored utf8-encoded
3186
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3188
except configobj.ConfigObjError, e:
3189
self._config_obj = None
3190
raise errors.ParseConfigError(e.errors, self.external_url())
3191
except UnicodeDecodeError:
3192
raise errors.ConfigContentError(self.external_url())
3194
def save_changes(self):
3195
if not self.is_loaded():
3198
if not self._need_saving():
3200
# Preserve the current version
3201
dirty_sections = dict(self.dirty_sections.items())
3202
self.apply_changes(dirty_sections)
3203
# Save to the persistent storage
3207
if not self.is_loaded():
3211
self._config_obj.write(out)
3212
self._save_content(out.getvalue())
3213
for hook in ConfigHooks['save']:
3216
def get_sections(self):
3217
"""Get the configobj section in the file order.
3219
:returns: An iterable of (store, section).
3221
# We need a loaded store
3224
except (errors.NoSuchFile, errors.PermissionDenied):
3225
# If the file can't be read, there is no sections
3227
cobj = self._config_obj
3229
yield self, self.readonly_section_class(None, cobj)
3230
for section_name in cobj.sections:
3232
self.readonly_section_class(section_name,
3233
cobj[section_name]))
3235
def get_mutable_section(self, section_id=None):
3236
# We need a loaded store
3239
except errors.NoSuchFile:
3240
# The file doesn't exist, let's pretend it was empty
3241
self._load_from_string('')
3242
if section_id in self.dirty_sections:
3243
# We already created a mutable section for this id
3244
return self.dirty_sections[section_id]
3245
if section_id is None:
3246
section = self._config_obj
3248
section = self._config_obj.setdefault(section_id, {})
3249
mutable_section = self.mutable_section_class(section_id, section)
3250
# All mutable sections can become dirty
3251
self.dirty_sections[section_id] = mutable_section
3252
return mutable_section
3254
def quote(self, value):
3256
# configobj conflates automagical list values and quoting
3257
self._config_obj.list_values = True
3258
return self._config_obj._quote(value)
3260
self._config_obj.list_values = False
3262
def unquote(self, value):
3263
if value and isinstance(value, basestring):
3264
# _unquote doesn't handle None nor empty strings nor anything that
3265
# is not a string, really.
3266
value = self._config_obj._unquote(value)
3269
def external_url(self):
3270
# Since an IniFileStore can be used without a file (at least in tests),
3271
# it's better to provide something than raising a NotImplementedError.
3272
# All daughter classes are supposed to provide an implementation
3274
return 'In-Process Store, no URL'
3276
class TransportIniFileStore(IniFileStore):
3277
"""IniFileStore that loads files from a transport.
3279
:ivar transport: The transport object where the config file is located.
3281
:ivar file_name: The config file basename in the transport directory.
3284
def __init__(self, transport, file_name):
3285
"""A Store using a ini file on a Transport
3287
:param transport: The transport object where the config file is located.
3288
:param file_name: The config file basename in the transport directory.
3290
super(TransportIniFileStore, self).__init__()
3291
self.transport = transport
3292
self.file_name = file_name
3294
def _load_content(self):
3296
return self.transport.get_bytes(self.file_name)
3297
except errors.PermissionDenied:
3298
trace.warning("Permission denied while trying to load "
3299
"configuration store %s.", self.external_url())
3302
def _save_content(self, content):
3303
self.transport.put_bytes(self.file_name, content)
3305
def external_url(self):
3306
# FIXME: external_url should really accepts an optional relpath
3307
# parameter (bug #750169) :-/ -- vila 2011-04-04
3308
# The following will do in the interim but maybe we don't want to
3309
# expose a path here but rather a config ID and its associated
3310
# object </hand wawe>.
3311
return urlutils.join(self.transport.external_url(), self.file_name)
3314
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3315
# unlockable stores for use with objects that can already ensure the locking
3316
# (think branches). If different stores (not based on ConfigObj) are created,
3317
# they may face the same issue.
3320
class LockableIniFileStore(TransportIniFileStore):
3321
"""A ConfigObjStore using locks on save to ensure store integrity."""
3323
def __init__(self, transport, file_name, lock_dir_name=None):
3324
"""A config Store using ConfigObj for storage.
3326
:param transport: The transport object where the config file is located.
3328
:param file_name: The config file basename in the transport directory.
3330
if lock_dir_name is None:
3331
lock_dir_name = 'lock'
3332
self.lock_dir_name = lock_dir_name
3333
super(LockableIniFileStore, self).__init__(transport, file_name)
3334
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3336
def lock_write(self, token=None):
3337
"""Takes a write lock in the directory containing the config file.
3339
If the directory doesn't exist it is created.
3341
# FIXME: This doesn't check the ownership of the created directories as
3342
# ensure_config_dir_exists does. It should if the transport is local
3343
# -- vila 2011-04-06
3344
self.transport.create_prefix()
3345
return self._lock.lock_write(token)
3350
def break_lock(self):
3351
self._lock.break_lock()
3355
# We need to be able to override the undecorated implementation
3356
self.save_without_locking()
3358
def save_without_locking(self):
3359
super(LockableIniFileStore, self).save()
3362
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3363
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3364
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3366
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3367
# functions or a registry will make it easier and clearer for tests, focusing
3368
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3369
# on a poolie's remark)
3370
class GlobalStore(LockableIniFileStore):
3372
def __init__(self, possible_transports=None):
3373
t = transport.get_transport_from_path(
3374
config_dir(), possible_transports=possible_transports)
3375
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3379
class LocationStore(LockableIniFileStore):
3381
def __init__(self, possible_transports=None):
3382
t = transport.get_transport_from_path(
3383
config_dir(), possible_transports=possible_transports)
3384
super(LocationStore, self).__init__(t, 'locations.conf')
3385
self.id = 'locations'
3388
class BranchStore(TransportIniFileStore):
3390
def __init__(self, branch):
3391
super(BranchStore, self).__init__(branch.control_transport,
3393
self.branch = branch
3397
class ControlStore(LockableIniFileStore):
3399
def __init__(self, bzrdir):
3400
super(ControlStore, self).__init__(bzrdir.transport,
3402
lock_dir_name='branch_lock')
3406
class SectionMatcher(object):
3407
"""Select sections into a given Store.
3409
This is intended to be used to postpone getting an iterable of sections
3413
def __init__(self, store):
3416
def get_sections(self):
3417
# This is where we require loading the store so we can see all defined
3419
sections = self.store.get_sections()
3420
# Walk the revisions in the order provided
3421
for store, s in sections:
3425
def match(self, section):
3426
"""Does the proposed section match.
3428
:param section: A Section object.
3430
:returns: True if the section matches, False otherwise.
3432
raise NotImplementedError(self.match)
3435
class NameMatcher(SectionMatcher):
3437
def __init__(self, store, section_id):
3438
super(NameMatcher, self).__init__(store)
3439
self.section_id = section_id
3441
def match(self, section):
3442
return section.id == self.section_id
3445
class LocationSection(Section):
3447
def __init__(self, section, extra_path, branch_name=None):
3448
super(LocationSection, self).__init__(section.id, section.options)
3449
self.extra_path = extra_path
3450
if branch_name is None:
3452
self.locals = {'relpath': extra_path,
3453
'basename': urlutils.basename(extra_path),
3454
'branchname': branch_name}
3456
def get(self, name, default=None, expand=True):
3457
value = super(LocationSection, self).get(name, default)
3458
if value is not None and expand:
3459
policy_name = self.get(name + ':policy', None)
3460
policy = _policy_value.get(policy_name, POLICY_NONE)
3461
if policy == POLICY_APPENDPATH:
3462
value = urlutils.join(value, self.extra_path)
3463
# expand section local options right now (since POLICY_APPENDPATH
3464
# will never add options references, it's ok to expand after it).
3466
for is_ref, chunk in iter_option_refs(value):
3468
chunks.append(chunk)
3471
if ref in self.locals:
3472
chunks.append(self.locals[ref])
3474
chunks.append(chunk)
3475
value = ''.join(chunks)
3479
class StartingPathMatcher(SectionMatcher):
3480
"""Select sections for a given location respecting the Store order."""
3482
# FIXME: Both local paths and urls can be used for section names as well as
3483
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3484
# inherited the fuzziness from the previous ``LocationConfig``
3485
# implementation. We probably need to revisit which encoding is allowed for
3486
# both ``location`` and section names and how we normalize
3487
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3488
# related too. -- vila 2012-01-04
3490
def __init__(self, store, location):
3491
super(StartingPathMatcher, self).__init__(store)
3492
if location.startswith('file://'):
3493
location = urlutils.local_path_from_url(location)
3494
self.location = location
3496
def get_sections(self):
3497
"""Get all sections matching ``location`` in the store.
3499
The most generic sections are described first in the store, then more
3500
specific ones can be provided for reduced scopes.
3502
The returned section are therefore returned in the reversed order so
3503
the most specific ones can be found first.
3505
location_parts = self.location.rstrip('/').split('/')
3508
# Later sections are more specific, they should be returned first
3509
for _, section in reversed(list(store.get_sections())):
3510
if section.id is None:
3511
# The no-name section is always included if present
3512
yield store, LocationSection(section, self.location)
3514
section_path = section.id
3515
if section_path.startswith('file://'):
3516
# the location is already a local path or URL, convert the
3517
# section id to the same format
3518
section_path = urlutils.local_path_from_url(section_path)
3519
if (self.location.startswith(section_path)
3520
or fnmatch.fnmatch(self.location, section_path)):
3521
section_parts = section_path.rstrip('/').split('/')
3522
extra_path = '/'.join(location_parts[len(section_parts):])
3523
yield store, LocationSection(section, extra_path)
3526
class LocationMatcher(SectionMatcher):
3528
def __init__(self, store, location):
3529
super(LocationMatcher, self).__init__(store)
3530
url, params = urlutils.split_segment_parameters(location)
3531
if location.startswith('file://'):
3532
location = urlutils.local_path_from_url(location)
3533
self.location = location
3534
branch_name = params.get('branch')
3535
if branch_name is None:
3536
self.branch_name = urlutils.basename(self.location)
3538
self.branch_name = urlutils.unescape(branch_name)
3540
def _get_matching_sections(self):
3541
"""Get all sections matching ``location``."""
3542
# We slightly diverge from LocalConfig here by allowing the no-name
3543
# section as the most generic one and the lower priority.
3544
no_name_section = None
3546
# Filter out the no_name_section so _iter_for_location_by_parts can be
3547
# used (it assumes all sections have a name).
3548
for _, section in self.store.get_sections():
3549
if section.id is None:
3550
no_name_section = section
3552
all_sections.append(section)
3553
# Unfortunately _iter_for_location_by_parts deals with section names so
3554
# we have to resync.
3555
filtered_sections = _iter_for_location_by_parts(
3556
[s.id for s in all_sections], self.location)
3557
iter_all_sections = iter(all_sections)
3558
matching_sections = []
3559
if no_name_section is not None:
3560
matching_sections.append(
3561
(0, LocationSection(no_name_section, self.location)))
3562
for section_id, extra_path, length in filtered_sections:
3563
# a section id is unique for a given store so it's safe to take the
3564
# first matching section while iterating. Also, all filtered
3565
# sections are part of 'all_sections' and will always be found
3568
section = iter_all_sections.next()
3569
if section_id == section.id:
3570
section = LocationSection(section, extra_path,
3572
matching_sections.append((length, section))
3574
return matching_sections
3576
def get_sections(self):
3577
# Override the default implementation as we want to change the order
3578
matching_sections = self._get_matching_sections()
3579
# We want the longest (aka more specific) locations first
3580
sections = sorted(matching_sections,
3581
key=lambda (length, section): (length, section.id),
3583
# Sections mentioning 'ignore_parents' restrict the selection
3584
for _, section in sections:
3585
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3586
ignore = section.get('ignore_parents', None)
3587
if ignore is not None:
3588
ignore = ui.bool_from_string(ignore)
3591
# Finally, we have a valid section
3592
yield self.store, section
3595
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3596
"""Describes an expandable option reference.
3598
We want to match the most embedded reference first.
3600
I.e. for '{{foo}}' we will get '{foo}',
3601
for '{bar{baz}}' we will get '{baz}'
3604
def iter_option_refs(string):
3605
# Split isolate refs so every other chunk is a ref
3607
for chunk in _option_ref_re.split(string):
3612
class Stack(object):
3613
"""A stack of configurations where an option can be defined"""
3615
def __init__(self, sections_def, store=None, mutable_section_id=None):
3616
"""Creates a stack of sections with an optional store for changes.
3618
:param sections_def: A list of Section or callables that returns an
3619
iterable of Section. This defines the Sections for the Stack and
3620
can be called repeatedly if needed.
3622
:param store: The optional Store where modifications will be
3623
recorded. If none is specified, no modifications can be done.
3625
:param mutable_section_id: The id of the MutableSection where changes
3626
are recorded. This requires the ``store`` parameter to be
3629
self.sections_def = sections_def
3631
self.mutable_section_id = mutable_section_id
3633
def iter_sections(self):
3634
"""Iterate all the defined sections."""
3635
# Ensuring lazy loading is achieved by delaying section matching (which
3636
# implies querying the persistent storage) until it can't be avoided
3637
# anymore by using callables to describe (possibly empty) section
3639
for sections in self.sections_def:
3640
for store, section in sections():
3641
yield store, section
3643
def get(self, name, expand=True, convert=True):
3644
"""Return the *first* option value found in the sections.
3646
This is where we guarantee that sections coming from Store are loaded
3647
lazily: the loading is delayed until we need to either check that an
3648
option exists or get its value, which in turn may require to discover
3649
in which sections it can be defined. Both of these (section and option
3650
existence) require loading the store (even partially).
3652
:param name: The queried option.
3654
:param expand: Whether options references should be expanded.
3656
:param convert: Whether the option value should be converted from
3657
unicode (do nothing for non-registered options).
3659
:returns: The value of the option.
3661
# FIXME: No caching of options nor sections yet -- vila 20110503
3663
found_store = None # Where the option value has been found
3664
# If the option is registered, it may provide additional info about
3667
opt = option_registry.get(name)
3672
def expand_and_convert(val):
3673
# This may need to be called in different contexts if the value is
3674
# None or ends up being None during expansion or conversion.
3677
if isinstance(val, basestring):
3678
val = self._expand_options_in_string(val)
3680
trace.warning('Cannot expand "%s":'
3681
' %s does not support option expansion'
3682
% (name, type(val)))
3684
val = found_store.unquote(val)
3686
val = opt.convert_from_unicode(found_store, val)
3689
# First of all, check if the environment can override the configuration
3691
if opt is not None and opt.override_from_env:
3692
value = opt.get_override()
3693
value = expand_and_convert(value)
3695
for store, section in self.iter_sections():
3696
value = section.get(name)
3697
if value is not None:
3700
value = expand_and_convert(value)
3701
if opt is not None and value is None:
3702
# If the option is registered, it may provide a default value
3703
value = opt.get_default()
3704
value = expand_and_convert(value)
3705
for hook in ConfigHooks['get']:
3706
hook(self, name, value)
3709
def expand_options(self, string, env=None):
3710
"""Expand option references in the string in the configuration context.
3712
:param string: The string containing option(s) to expand.
3714
:param env: An option dict defining additional configuration options or
3715
overriding existing ones.
3717
:returns: The expanded string.
3719
return self._expand_options_in_string(string, env)
3721
def _expand_options_in_string(self, string, env=None, _refs=None):
3722
"""Expand options in the string in the configuration context.
3724
:param string: The string to be expanded.
3726
:param env: An option dict defining additional configuration options or
3727
overriding existing ones.
3729
:param _refs: Private list (FIFO) containing the options being expanded
3732
:returns: The expanded string.
3735
# Not much to expand there
3738
# What references are currently resolved (to detect loops)
3741
# We need to iterate until no more refs appear ({{foo}} will need two
3742
# iterations for example).
3747
for is_ref, chunk in iter_option_refs(result):
3749
chunks.append(chunk)
3754
raise errors.OptionExpansionLoop(string, _refs)
3756
value = self._expand_option(name, env, _refs)
3758
raise errors.ExpandingUnknownOption(name, string)
3759
chunks.append(value)
3761
result = ''.join(chunks)
3764
def _expand_option(self, name, env, _refs):
3765
if env is not None and name in env:
3766
# Special case, values provided in env takes precedence over
3770
value = self.get(name, expand=False, convert=False)
3771
value = self._expand_options_in_string(value, env, _refs)
3774
def _get_mutable_section(self):
3775
"""Get the MutableSection for the Stack.
3777
This is where we guarantee that the mutable section is lazily loaded:
3778
this means we won't load the corresponding store before setting a value
3779
or deleting an option. In practice the store will often be loaded but
3780
this helps catching some programming errors.
3783
section = store.get_mutable_section(self.mutable_section_id)
3784
return store, section
3786
def set(self, name, value):
3787
"""Set a new value for the option."""
3788
store, section = self._get_mutable_section()
3789
section.set(name, store.quote(value))
3790
for hook in ConfigHooks['set']:
3791
hook(self, name, value)
3793
def remove(self, name):
3794
"""Remove an existing option."""
3795
_, section = self._get_mutable_section()
3796
section.remove(name)
3797
for hook in ConfigHooks['remove']:
3801
# Mostly for debugging use
3802
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3804
def _get_overrides(self):
3805
# Hack around library_state.initialize never called
3806
if bzrlib.global_state is not None:
3807
return bzrlib.global_state.cmdline_overrides.get_sections()
3811
class MemoryStack(Stack):
3812
"""A configuration stack defined from a string.
3814
This is mainly intended for tests and requires no disk resources.
3817
def __init__(self, content=None):
3818
"""Create an in-memory stack from a given content.
3820
It uses a single store based on configobj and support reading and
3823
:param content: The initial content of the store. If None, the store is
3824
not loaded and ``_load_from_string`` can and should be used if
3827
store = IniFileStore()
3828
if content is not None:
3829
store._load_from_string(content)
3830
super(MemoryStack, self).__init__(
3831
[store.get_sections], store)
3834
class _CompatibleStack(Stack):
3835
"""Place holder for compatibility with previous design.
3837
This is intended to ease the transition from the Config-based design to the
3838
Stack-based design and should not be used nor relied upon by plugins.
3840
One assumption made here is that the daughter classes will all use Stores
3841
derived from LockableIniFileStore).
3843
It implements set() and remove () by re-loading the store before applying
3844
the modification and saving it.
3846
The long term plan being to implement a single write by store to save
3847
all modifications, this class should not be used in the interim.
3850
def set(self, name, value):
3853
super(_CompatibleStack, self).set(name, value)
3854
# Force a write to persistent storage
3857
def remove(self, name):
3860
super(_CompatibleStack, self).remove(name)
3861
# Force a write to persistent storage
3865
class GlobalStack(_CompatibleStack):
3866
"""Global options only stack.
3868
The following sections are queried:
3870
* command-line overrides,
3872
* the 'DEFAULT' section in bazaar.conf
3874
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3879
gstore = GlobalStore()
3880
super(GlobalStack, self).__init__(
3881
[self._get_overrides,
3882
NameMatcher(gstore, 'DEFAULT').get_sections],
3883
gstore, mutable_section_id='DEFAULT')
3886
class LocationStack(_CompatibleStack):
3887
"""Per-location options falling back to global options stack.
3890
The following sections are queried:
3892
* command-line overrides,
3894
* the sections matching ``location`` in ``locations.conf``, the order being
3895
defined by the number of path components in the section glob, higher
3896
numbers first (from most specific section to most generic).
3898
* the 'DEFAULT' section in bazaar.conf
3900
This stack will use the ``location`` section in locations.conf as its
3904
def __init__(self, location):
3905
"""Make a new stack for a location and global configuration.
3907
:param location: A URL prefix to """
3908
lstore = LocationStore()
3909
if location.startswith('file://'):
3910
location = urlutils.local_path_from_url(location)
3911
gstore = GlobalStore()
3912
super(LocationStack, self).__init__(
3913
[self._get_overrides,
3914
LocationMatcher(lstore, location).get_sections,
3915
NameMatcher(gstore, 'DEFAULT').get_sections],
3916
lstore, mutable_section_id=location)
3919
class BranchStack(Stack):
3920
"""Per-location options falling back to branch then global options stack.
3922
The following sections are queried:
3924
* command-line overrides,
3926
* the sections matching ``location`` in ``locations.conf``, the order being
3927
defined by the number of path components in the section glob, higher
3928
numbers first (from most specific section to most generic),
3930
* the no-name section in branch.conf,
3932
* the ``DEFAULT`` section in ``bazaar.conf``.
3934
This stack will use the no-name section in ``branch.conf`` as its
3938
def __init__(self, branch):
3939
lstore = LocationStore()
3940
bstore = branch._get_config_store()
3941
gstore = GlobalStore()
3942
super(BranchStack, self).__init__(
3943
[self._get_overrides,
3944
LocationMatcher(lstore, branch.base).get_sections,
3945
NameMatcher(bstore, None).get_sections,
3946
NameMatcher(gstore, 'DEFAULT').get_sections],
3948
self.branch = branch
3950
def lock_write(self, token=None):
3951
return self.branch.lock_write(token)
3954
return self.branch.unlock()
3957
def set(self, name, value):
3958
super(BranchStack, self).set(name, value)
3959
# Unlocking the branch will trigger a store.save_changes() so the last
3960
# unlock saves all the changes.
3963
def remove(self, name):
3964
super(BranchStack, self).remove(name)
3965
# Unlocking the branch will trigger a store.save_changes() so the last
3966
# unlock saves all the changes.
3969
class RemoteControlStack(_CompatibleStack):
3970
"""Remote control-only options stack."""
3972
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3973
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3974
# control.conf and is used only for stack options.
3976
def __init__(self, bzrdir):
3977
cstore = bzrdir._get_config_store()
3978
super(RemoteControlStack, self).__init__(
3979
[NameMatcher(cstore, None).get_sections],
3981
self.bzrdir = bzrdir
3984
class BranchOnlyStack(Stack):
3985
"""Branch-only options stack."""
3987
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
3988
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
3989
# -- vila 2011-12-16
3991
def __init__(self, branch):
3992
bstore = branch._get_config_store()
3993
super(BranchOnlyStack, self).__init__(
3994
[NameMatcher(bstore, None).get_sections],
3996
self.branch = branch
3998
def lock_write(self, token=None):
3999
return self.branch.lock_write(token)
4002
return self.branch.unlock()
4005
def set(self, name, value):
4006
super(BranchOnlyStack, self).set(name, value)
4007
# Force a write to persistent storage
4008
self.store.save_changes()
4011
def remove(self, name):
4012
super(BranchOnlyStack, self).remove(name)
4013
# Force a write to persistent storage
4014
self.store.save_changes()
4017
class cmd_config(commands.Command):
4018
__doc__ = """Display, set or remove a configuration option.
4020
Display the active value for a given option.
4022
If --all is specified, NAME is interpreted as a regular expression and all
4023
matching options are displayed mentioning their scope. The active value
4024
that bzr will take into account is the first one displayed for each option.
4026
If no NAME is given, --all .* is implied.
4028
Setting a value is achieved by using name=value without spaces. The value
4029
is set in the most relevant scope and can be checked by displaying the
4033
takes_args = ['name?']
4037
# FIXME: This should be a registry option so that plugins can register
4038
# their own config files (or not) and will also address
4039
# http://pad.lv/788991 -- vila 20101115
4040
commands.Option('scope', help='Reduce the scope to the specified'
4041
' configuration file.',
4043
commands.Option('all',
4044
help='Display all the defined values for the matching options.',
4046
commands.Option('remove', help='Remove the option from'
4047
' the configuration file.'),
4050
_see_also = ['configuration']
4052
@commands.display_command
4053
def run(self, name=None, all=False, directory=None, scope=None,
4055
if directory is None:
4057
directory = urlutils.normalize_url(directory)
4059
raise errors.BzrError(
4060
'--all and --remove are mutually exclusive.')
4062
# Delete the option in the given scope
4063
self._remove_config_option(name, directory, scope)
4065
# Defaults to all options
4066
self._show_matching_options('.*', directory, scope)
4069
name, value = name.split('=', 1)
4071
# Display the option(s) value(s)
4073
self._show_matching_options(name, directory, scope)
4075
self._show_value(name, directory, scope)
4078
raise errors.BzrError(
4079
'Only one option can be set.')
4080
# Set the option value
4081
self._set_config_option(name, value, directory, scope)
4083
def _get_stack(self, directory, scope=None, write_access=False):
4084
"""Get the configuration stack specified by ``directory`` and ``scope``.
4086
:param directory: Where the configurations are derived from.
4088
:param scope: A specific config to start from.
4090
:param write_access: Whether a write access to the stack will be
4093
# FIXME: scope should allow access to plugin-specific stacks (even
4094
# reduced to the plugin-specific store), related to
4095
# http://pad.lv/788991 -- vila 2011-11-15
4096
if scope is not None:
4097
if scope == 'bazaar':
4098
return GlobalStack()
4099
elif scope == 'locations':
4100
return LocationStack(directory)
4101
elif scope == 'branch':
4103
controldir.ControlDir.open_containing_tree_or_branch(
4106
self.add_cleanup(br.lock_write().unlock)
4107
return br.get_config_stack()
4108
raise errors.NoSuchConfig(scope)
4112
controldir.ControlDir.open_containing_tree_or_branch(
4115
self.add_cleanup(br.lock_write().unlock)
4116
return br.get_config_stack()
4117
except errors.NotBranchError:
4118
return LocationStack(directory)
4120
def _quote_multiline(self, value):
4122
value = '"""' + value + '"""'
4125
def _show_value(self, name, directory, scope):
4126
conf = self._get_stack(directory, scope)
4127
value = conf.get(name, expand=True, convert=False)
4128
if value is not None:
4129
# Quote the value appropriately
4130
value = self._quote_multiline(value)
4131
self.outf.write('%s\n' % (value,))
4133
raise errors.NoSuchConfigOption(name)
4135
def _show_matching_options(self, name, directory, scope):
4136
name = lazy_regex.lazy_compile(name)
4137
# We want any error in the regexp to be raised *now* so we need to
4138
# avoid the delay introduced by the lazy regexp. But, we still do
4139
# want the nicer errors raised by lazy_regex.
4140
name._compile_and_collapse()
4143
conf = self._get_stack(directory, scope)
4144
for store, section in conf.iter_sections():
4145
for oname in section.iter_option_names():
4146
if name.search(oname):
4147
if cur_store_id != store.id:
4148
# Explain where the options are defined
4149
self.outf.write('%s:\n' % (store.id,))
4150
cur_store_id = store.id
4152
if (section.id is not None and cur_section != section.id):
4153
# Display the section id as it appears in the store
4154
# (None doesn't appear by definition)
4155
self.outf.write(' [%s]\n' % (section.id,))
4156
cur_section = section.id
4157
value = section.get(oname, expand=False)
4158
# Quote the value appropriately
4159
value = self._quote_multiline(value)
4160
self.outf.write(' %s = %s\n' % (oname, value))
4162
def _set_config_option(self, name, value, directory, scope):
4163
conf = self._get_stack(directory, scope, write_access=True)
4164
conf.set(name, value)
4166
def _remove_config_option(self, name, directory, scope):
4168
raise errors.BzrCommandError(
4169
'--remove expects an option to remove.')
4170
conf = self._get_stack(directory, scope, write_access=True)
4174
raise errors.NoSuchConfigOption(name)
4179
# We need adapters that can build a Store or a Stack in a test context. Test
4180
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4181
# themselves. The builder will receive a test instance and should return a
4182
# ready-to-use store or stack. Plugins that define new store/stacks can also
4183
# register themselves here to be tested against the tests defined in
4184
# bzrlib.tests.test_config. Note that the builder can be called multiple times
4185
# for the same test.
4187
# The registered object should be a callable receiving a test instance
4188
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4190
test_store_builder_registry = registry.Registry()
4192
# The registered object should be a callable receiving a test instance
4193
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4195
test_stack_builder_registry = registry.Registry()
added
removed
bzrlib/config.py
