1
# Copyright (C) 2005-2014, 2016 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 Breezy.
21
Currently this configuration resides in ~/.config/breezy/breezy.conf
22
and ~/.config/breezy/locations.conf, which is written to by brz.
24
If the first location doesn't exist, then brz falls back to reading
25
Bazaar configuration files in ~/.bazaar or ~/.config/bazaar.
27
In breezy.conf the following options may be set:
29
editor=name-of-program
30
email=Your Name <your@email.address>
31
check_signatures=require|ignore|check-available(default)
32
create_signatures=always|never|when-required(default)
33
log_format=name-of-format
34
validate_signatures_in_log=true|false(default)
35
acceptable_keys=pattern1,pattern2
36
gpg_signing_key=amy@example.com
38
in locations.conf, you specify the url of a branch and options for it.
39
Wildcards may be used - * and ? as normal in shell completion. Options
40
set in both breezy.conf and locations.conf are overridden by the locations.conf
42
[/home/robertc/source]
43
recurse=False|True(default)
45
check_signatures= as above
46
create_signatures= as above.
47
validate_signatures_in_log=as above
48
acceptable_keys=as above
50
explanation of options
51
----------------------
52
editor - this option sets the pop up editor to use during commits.
53
email - this option sets the user id brz will use when committing.
54
check_signatures - this option will control whether brz will require good gpg
55
signatures, ignore them, or check them if they are
56
present. Currently it is unused except that check_signatures
57
turns on create_signatures.
58
create_signatures - this option controls whether brz will always create
59
gpg signatures or not on commits. There is an unused
60
option which in future is expected to work if
61
branch settings require signatures.
62
log_format - this option sets the default log format. Possible values are
63
long, short, line, or a plugin can register new formats.
64
validate_signatures_in_log - show GPG signature validity in log output
65
acceptable_keys - comma separated list of key patterns acceptable for
66
verify-signatures command
68
In breezy.conf you can also define aliases in the ALIASES sections, example
71
lastlog=log --line -r-10..-1
72
ll=log --line -r-10..-1
77
from __future__ import absolute_import
84
from .lazy_import import lazy_import
85
lazy_import(globals(), """
109
from breezy.i18n import gettext
118
from .sixish import (
139
POLICY_APPENDPATH = 2
143
POLICY_NORECURSE: 'norecurse',
144
POLICY_APPENDPATH: 'appendpath',
149
'norecurse': POLICY_NORECURSE,
150
'appendpath': POLICY_APPENDPATH,
154
STORE_LOCATION = POLICY_NONE
155
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
156
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
161
class OptionExpansionLoop(errors.BzrError):
163
_fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
165
def __init__(self, string, refs):
167
self.refs = '->'.join(refs)
170
class ExpandingUnknownOption(errors.BzrError):
172
_fmt = 'Option "%(name)s" is not defined while expanding "%(string)s".'
174
def __init__(self, name, string):
179
class IllegalOptionName(errors.BzrError):
181
_fmt = 'Option "%(name)s" is not allowed.'
183
def __init__(self, name):
187
class ConfigContentError(errors.BzrError):
189
_fmt = "Config file %(filename)s is not UTF-8 encoded\n"
191
def __init__(self, filename):
192
self.filename = filename
195
class ParseConfigError(errors.BzrError):
197
_fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
199
def __init__(self, errors, filename):
200
self.filename = filename
201
self.errors = '\n'.join(e.msg for e in errors)
204
class ConfigOptionValueError(errors.BzrError):
206
_fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
207
'See ``brz help %(name)s``')
209
def __init__(self, name, value):
210
errors.BzrError.__init__(self, name=name, value=value)
213
class NoEmailInUsername(errors.BzrError):
215
_fmt = "%(username)r does not seem to contain a reasonable email address"
217
def __init__(self, username):
218
self.username = username
221
class NoSuchConfig(errors.BzrError):
223
_fmt = ('The "%(config_id)s" configuration does not exist.')
225
def __init__(self, config_id):
226
errors.BzrError.__init__(self, config_id=config_id)
229
class NoSuchConfigOption(errors.BzrError):
231
_fmt = ('The "%(option_name)s" configuration option does not exist.')
233
def __init__(self, option_name):
234
errors.BzrError.__init__(self, option_name=option_name)
237
class NoWhoami(errors.BzrError):
239
_fmt = ('Unable to determine your name.\n'
240
"Please, set your name with the 'whoami' command.\n"
241
'E.g. brz whoami "Your Name <name@example.com>"')
244
def signature_policy_from_unicode(signature_string):
245
"""Convert a string to a signing policy."""
246
if signature_string.lower() == 'check-available':
247
return CHECK_IF_POSSIBLE
248
if signature_string.lower() == 'ignore':
250
if signature_string.lower() == 'require':
252
raise ValueError("Invalid signatures policy '%s'"
256
def signing_policy_from_unicode(signature_string):
257
"""Convert a string to a signing policy."""
258
if signature_string.lower() == 'when-required':
259
return SIGN_WHEN_REQUIRED
260
if signature_string.lower() == 'never':
262
if signature_string.lower() == 'always':
264
raise ValueError("Invalid signing policy '%s'"
268
def _has_decode_bug():
269
"""True if configobj will fail to decode to unicode on Python 2."""
270
if sys.version_info > (3,):
272
conf = configobj.ConfigObj()
273
decode = getattr(conf, "_decode", None)
275
result = decode(b"\xc2\xa7", "utf-8")
276
if isinstance(result[0], str):
281
def _has_triplequote_bug():
282
"""True if triple quote logic is reversed, see lp:710410."""
283
conf = configobj.ConfigObj()
284
quote = getattr(conf, "_get_triple_quote", None)
285
if quote and quote('"""') != "'''":
290
class ConfigObj(configobj.ConfigObj):
292
def __init__(self, infile=None, **kwargs):
293
# We define our own interpolation mechanism calling it option expansion
294
super(ConfigObj, self).__init__(infile=infile,
298
if _has_decode_bug():
299
def _decode(self, infile, encoding):
300
if isinstance(infile, str) and encoding:
301
return infile.decode(encoding).splitlines(True)
302
return super(ConfigObj, self)._decode(infile, encoding)
304
if _has_triplequote_bug():
305
def _get_triple_quote(self, value):
306
quot = super(ConfigObj, self)._get_triple_quote(value)
307
if quot == configobj.tdquot:
308
return configobj.tsquot
309
return configobj.tdquot
311
def get_bool(self, section, key):
312
return self[section].as_bool(key)
314
def get_value(self, section, name):
315
# Try [] for the old DEFAULT section.
316
if section == "DEFAULT":
321
return self[section][name]
324
class Config(object):
325
"""A configuration policy - what username, editor, gpg needs etc."""
328
super(Config, self).__init__()
331
"""Returns a unique ID for the config."""
332
raise NotImplementedError(self.config_id)
334
def get_change_editor(self, old_tree, new_tree):
335
from breezy import diff
336
cmd = self._get_change_editor()
339
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
342
def _get_signature_checking(self):
343
"""Template method to override signature checking policy."""
345
def _get_signing_policy(self):
346
"""Template method to override signature creation policy."""
350
def expand_options(self, string, env=None):
351
"""Expand option references in the string in the configuration context.
353
:param string: The string containing option to expand.
355
:param env: An option dict defining additional configuration options or
356
overriding existing ones.
358
:returns: The expanded string.
360
return self._expand_options_in_string(string, env)
362
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
363
"""Expand options in a list of strings in the configuration context.
365
:param slist: A list of strings.
367
:param env: An option dict defining additional configuration options or
368
overriding existing ones.
370
:param _ref_stack: Private list containing the options being
371
expanded to detect loops.
373
:returns: The flatten list of expanded strings.
375
# expand options in each value separately flattening lists
378
value = self._expand_options_in_string(s, env, _ref_stack)
379
if isinstance(value, list):
385
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
386
"""Expand options in the string in the configuration context.
388
:param string: The string to be expanded.
390
:param env: An option dict defining additional configuration options or
391
overriding existing ones.
393
:param _ref_stack: Private list containing the options being
394
expanded to detect loops.
396
:returns: The expanded string.
399
# Not much to expand there
401
if _ref_stack is None:
402
# What references are currently resolved (to detect loops)
404
if self.option_ref_re is None:
405
# We want to match the most embedded reference first (i.e. for
406
# '{{foo}}' we will get '{foo}',
407
# for '{bar{baz}}' we will get '{baz}'
408
self.option_ref_re = re.compile('({[^{}]+})')
410
# We need to iterate until no more refs appear ({{foo}} will need two
411
# iterations for example).
413
raw_chunks = self.option_ref_re.split(result)
414
if len(raw_chunks) == 1:
415
# Shorcut the trivial case: no refs
419
# Split will isolate refs so that every other chunk is a ref
421
for chunk in raw_chunks:
424
# Keep only non-empty strings (or we get bogus empty
425
# slots when a list value is involved).
430
if name in _ref_stack:
431
raise OptionExpansionLoop(string, _ref_stack)
432
_ref_stack.append(name)
433
value = self._expand_option(name, env, _ref_stack)
435
raise ExpandingUnknownOption(name, string)
436
if isinstance(value, list):
444
# Once a list appears as the result of an expansion, all
445
# callers will get a list result. This allows a consistent
446
# behavior even when some options in the expansion chain
447
# defined as strings (no comma in their value) but their
448
# expanded value is a list.
449
return self._expand_options_in_list(chunks, env, _ref_stack)
451
result = ''.join(chunks)
454
def _expand_option(self, name, env, _ref_stack):
455
if env is not None and name in env:
456
# Special case, values provided in env takes precedence over
460
# FIXME: This is a limited implementation, what we really need is a
461
# way to query the brz config for the value of an option,
462
# respecting the scope rules (That is, once we implement fallback
463
# configs, getting the option value should restart from the top
464
# config, not the current one) -- vila 20101222
465
value = self.get_user_option(name, expand=False)
466
if isinstance(value, list):
467
value = self._expand_options_in_list(value, env, _ref_stack)
469
value = self._expand_options_in_string(value, env, _ref_stack)
472
def _get_user_option(self, option_name):
473
"""Template method to provide a user option."""
476
def get_user_option(self, option_name, expand=True):
477
"""Get a generic option - no special process, no default.
479
:param option_name: The queried option.
481
:param expand: Whether options references should be expanded.
483
:returns: The value of the option.
485
value = self._get_user_option(option_name)
487
if isinstance(value, list):
488
value = self._expand_options_in_list(value)
489
elif isinstance(value, dict):
490
trace.warning('Cannot expand "%s":'
491
' Dicts do not support option expansion'
494
value = self._expand_options_in_string(value)
495
for hook in OldConfigHooks['get']:
496
hook(self, option_name, value)
499
def get_user_option_as_bool(self, option_name, expand=None, default=None):
500
"""Get a generic option as a boolean.
502
:param expand: Allow expanding references to other config values.
503
:param default: Default value if nothing is configured
504
:return None if the option doesn't exist or its value can't be
505
interpreted as a boolean. Returns True or False otherwise.
507
s = self.get_user_option(option_name, expand=expand)
509
# The option doesn't exist
511
val = ui.bool_from_string(s)
513
# The value can't be interpreted as a boolean
514
trace.warning('Value "%s" is not a boolean for "%s"',
518
def get_user_option_as_list(self, option_name, expand=None):
519
"""Get a generic option as a list - no special process, no default.
521
:return None if the option doesn't exist. Returns the value as a list
524
l = self.get_user_option(option_name, expand=expand)
525
if isinstance(l, string_types):
526
# A single value, most probably the user forgot (or didn't care to
531
def _log_format(self):
532
"""See log_format()."""
535
def validate_signatures_in_log(self):
536
"""Show GPG signature validity in log"""
537
result = self._validate_signatures_in_log()
544
def _validate_signatures_in_log(self):
545
"""See validate_signatures_in_log()."""
548
def _post_commit(self):
549
"""See Config.post_commit."""
552
def user_email(self):
553
"""Return just the email component of a username."""
554
return extract_email_address(self.username())
557
"""Return email-style username.
559
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
561
$BRZ_EMAIL can be set to override this, then
562
the concrete policy type is checked, and finally
564
If no username can be found, NoWhoami exception is raised.
566
v = os.environ.get('BRZ_EMAIL')
569
v = v.decode(osutils.get_user_encoding())
571
v = self._get_user_id()
574
return default_email()
576
def ensure_username(self):
577
"""Raise NoWhoami if username is not set.
579
This method relies on the username() function raising the error.
583
def get_alias(self, value):
584
return self._get_alias(value)
586
def _get_alias(self, value):
589
def get_nickname(self):
590
return self._get_nickname()
592
def _get_nickname(self):
595
def get_bzr_remote_path(self):
597
return os.environ['BZR_REMOTE_PATH']
599
path = self.get_user_option("bzr_remote_path")
604
def suppress_warning(self, warning):
605
"""Should the warning be suppressed or emitted.
607
:param warning: The name of the warning being tested.
609
:returns: True if the warning should be suppressed, False otherwise.
611
warnings = self.get_user_option_as_list('suppress_warnings')
612
if warnings is None or warning not in warnings:
617
def get_merge_tools(self):
619
for (oname, value, section, conf_id, parser) in self._get_options():
620
if oname.startswith('bzr.mergetool.'):
621
tool_name = oname[len('bzr.mergetool.'):]
622
tools[tool_name] = self.get_user_option(oname, False)
623
trace.mutter('loaded merge tools: %r' % tools)
626
def find_merge_tool(self, name):
627
# We fake a defaults mechanism here by checking if the given name can
628
# be found in the known_merge_tools if it's not found in the config.
629
# This should be done through the proposed config defaults mechanism
630
# when it becomes available in the future.
631
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
633
or mergetools.known_merge_tools.get(name, None))
637
class _ConfigHooks(hooks.Hooks):
638
"""A dict mapping hook names and a list of callables for configs.
642
"""Create the default hooks.
644
These are all empty initially, because by default nothing should get
647
super(_ConfigHooks, self).__init__('breezy.config', 'ConfigHooks')
648
self.add_hook('load',
649
'Invoked when a config store is loaded.'
650
' The signature is (store).',
652
self.add_hook('save',
653
'Invoked when a config store is saved.'
654
' The signature is (store).',
656
# The hooks for config options
658
'Invoked when a config option is read.'
659
' The signature is (stack, name, value).',
662
'Invoked when a config option is set.'
663
' The signature is (stack, name, value).',
665
self.add_hook('remove',
666
'Invoked when a config option is removed.'
667
' The signature is (stack, name).',
669
ConfigHooks = _ConfigHooks()
672
class _OldConfigHooks(hooks.Hooks):
673
"""A dict mapping hook names and a list of callables for configs.
677
"""Create the default hooks.
679
These are all empty initially, because by default nothing should get
682
super(_OldConfigHooks, self).__init__('breezy.config', 'OldConfigHooks')
683
self.add_hook('load',
684
'Invoked when a config store is loaded.'
685
' The signature is (config).',
687
self.add_hook('save',
688
'Invoked when a config store is saved.'
689
' The signature is (config).',
691
# The hooks for config options
693
'Invoked when a config option is read.'
694
' The signature is (config, name, value).',
697
'Invoked when a config option is set.'
698
' The signature is (config, name, value).',
700
self.add_hook('remove',
701
'Invoked when a config option is removed.'
702
' The signature is (config, name).',
704
OldConfigHooks = _OldConfigHooks()
707
class IniBasedConfig(Config):
708
"""A configuration policy that draws from ini files."""
710
def __init__(self, file_name=None):
711
"""Base class for configuration files using an ini-like syntax.
713
:param file_name: The configuration file path.
715
super(IniBasedConfig, self).__init__()
716
self.file_name = file_name
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 = BytesIO(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):
744
if self._parser is not None:
746
if self._content is not None:
747
co_input = self._content
748
elif self.file_name is None:
749
raise AssertionError('We have no content to create the config')
751
co_input = self.file_name
753
self._parser = ConfigObj(co_input, encoding='utf-8')
754
except configobj.ConfigObjError as e:
755
raise ParseConfigError(e.errors, e.config.filename)
756
except UnicodeDecodeError:
757
raise ConfigContentError(self.file_name)
758
# Make sure self.reload() will use the right file name
759
self._parser.filename = self.file_name
760
for hook in OldConfigHooks['load']:
765
"""Reload the config file from disk."""
766
if self.file_name is None:
767
raise AssertionError('We need a file name to reload the config')
768
if self._parser is not None:
769
self._parser.reload()
770
for hook in ConfigHooks['load']:
773
def _get_matching_sections(self):
774
"""Return an ordered list of (section_name, extra_path) pairs.
776
If the section contains inherited configuration, extra_path is
777
a string containing the additional path components.
779
section = self._get_section()
780
if section is not None:
781
return [(section, '')]
785
def _get_section(self):
786
"""Override this to define the section used by the config."""
789
def _get_sections(self, name=None):
790
"""Returns an iterator of the sections specified by ``name``.
792
:param name: The section name. If None is supplied, the default
793
configurations are yielded.
795
:return: A tuple (name, section, config_id) for all sections that will
796
be walked by user_get_option() in the 'right' order. The first one
797
is where set_user_option() will update the value.
799
parser = self._get_parser()
801
yield (name, parser[name], self.config_id())
803
# No section name has been given so we fallback to the configobj
804
# itself which holds the variables defined outside of any section.
805
yield (None, parser, self.config_id())
807
def _get_options(self, sections=None):
808
"""Return an ordered list of (name, value, section, config_id) tuples.
810
All options are returned with their associated value and the section
811
they appeared in. ``config_id`` is a unique identifier for the
812
configuration file the option is defined in.
814
:param sections: Default to ``_get_matching_sections`` if not
815
specified. This gives a better control to daughter classes about
816
which sections should be searched. This is a list of (name,
821
parser = self._get_parser()
823
for (section_name, _) in self._get_matching_sections():
825
section = parser[section_name]
827
# This could happen for an empty file for which we define a
828
# DEFAULT section. FIXME: Force callers to provide sections
829
# instead ? -- vila 20100930
831
sections.append((section_name, section))
832
config_id = self.config_id()
833
for (section_name, section) in sections:
834
for (name, value) in section.iteritems():
835
yield (name, parser._quote(value), section_name,
838
def _get_option_policy(self, section, option_name):
839
"""Return the policy for the given (section, option_name) pair."""
842
def _get_change_editor(self):
843
return self.get_user_option('change_editor')
845
def _get_signature_checking(self):
846
"""See Config._get_signature_checking."""
847
policy = self._get_user_option('check_signatures')
849
return signature_policy_from_unicode(policy)
851
def _get_signing_policy(self):
852
"""See Config._get_signing_policy"""
853
policy = self._get_user_option('create_signatures')
855
return signing_policy_from_unicode(policy)
857
def _get_user_id(self):
858
"""Get the user id from the 'email' key in the current section."""
859
return self._get_user_option('email')
861
def _get_user_option(self, option_name):
862
"""See Config._get_user_option."""
863
for (section, extra_path) in self._get_matching_sections():
865
value = self._get_parser().get_value(section, option_name)
868
policy = self._get_option_policy(section, option_name)
869
if policy == POLICY_NONE:
871
elif policy == POLICY_NORECURSE:
872
# norecurse items only apply to the exact path
877
elif policy == POLICY_APPENDPATH:
879
value = urlutils.join(value, extra_path)
882
raise AssertionError('Unexpected config policy %r' % policy)
886
def _log_format(self):
887
"""See Config.log_format."""
888
return self._get_user_option('log_format')
890
def _validate_signatures_in_log(self):
891
"""See Config.validate_signatures_in_log."""
892
return self._get_user_option('validate_signatures_in_log')
894
def _acceptable_keys(self):
895
"""See Config.acceptable_keys."""
896
return self._get_user_option('acceptable_keys')
898
def _post_commit(self):
899
"""See Config.post_commit."""
900
return self._get_user_option('post_commit')
902
def _get_alias(self, value):
904
return self._get_parser().get_value("ALIASES",
909
def _get_nickname(self):
910
return self.get_user_option('nickname')
912
def remove_user_option(self, option_name, section_name=None):
913
"""Remove a user option and save the configuration file.
915
:param option_name: The option to be removed.
917
:param section_name: The section the option is defined in, default to
921
parser = self._get_parser()
922
if section_name is None:
925
section = parser[section_name]
927
del section[option_name]
929
raise NoSuchConfigOption(option_name)
930
self._write_config_file()
931
for hook in OldConfigHooks['remove']:
932
hook(self, option_name)
934
def _write_config_file(self):
935
if self.file_name is None:
936
raise AssertionError('We cannot save, self.file_name is None')
937
conf_dir = os.path.dirname(self.file_name)
938
ensure_config_dir_exists(conf_dir)
939
atomic_file = atomicfile.AtomicFile(self.file_name)
940
self._get_parser().write(atomic_file)
943
osutils.copy_ownership_from_path(self.file_name)
944
for hook in OldConfigHooks['save']:
948
class LockableConfig(IniBasedConfig):
949
"""A configuration needing explicit locking for access.
951
If several processes try to write the config file, the accesses need to be
954
Daughter classes should use the self.lock_write() decorator method when they
955
upate a config (they call, directly or indirectly, the
956
``_write_config_file()`` method. These methods (typically ``set_option()``
957
and variants must reload the config file from disk before calling
958
``_write_config_file()``), this can be achieved by calling the
959
``self.reload()`` method. Note that the lock scope should cover both the
960
reading and the writing of the config file which is why the decorator can't
961
be applied to ``_write_config_file()`` only.
963
This should be enough to implement the following logic:
964
- lock for exclusive write access,
965
- reload the config file from disk,
969
This logic guarantees that a writer can update a value without erasing an
970
update made by another writer.
975
def __init__(self, file_name):
976
super(LockableConfig, self).__init__(file_name=file_name)
977
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
978
# FIXME: It doesn't matter that we don't provide possible_transports
979
# below since this is currently used only for local config files ;
980
# local transports are not shared. But if/when we start using
981
# LockableConfig for other kind of transports, we will need to reuse
982
# whatever connection is already established -- vila 20100929
983
self.transport = transport.get_transport_from_path(self.dir)
984
self._lock = lockdir.LockDir(self.transport, self.lock_name)
986
def _create_from_string(self, unicode_bytes, save):
987
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
989
# We need to handle the saving here (as opposed to IniBasedConfig)
992
self._write_config_file()
995
def lock_write(self, token=None):
996
"""Takes a write lock in the directory containing the config file.
998
If the directory doesn't exist it is created.
1000
ensure_config_dir_exists(self.dir)
1001
token = self._lock.lock_write(token)
1002
return lock.LogicalLockResult(self.unlock, token)
1007
def break_lock(self):
1008
self._lock.break_lock()
1010
def remove_user_option(self, option_name, section_name=None):
1011
with self.lock_write():
1012
super(LockableConfig, self).remove_user_option(
1013
option_name, section_name)
1015
def _write_config_file(self):
1016
if self._lock is None or not self._lock.is_held:
1017
# NB: if the following exception is raised it probably means a
1018
# missing call to lock_write() by one of the callers.
1019
raise errors.ObjectNotLocked(self)
1020
super(LockableConfig, self)._write_config_file()
1023
class GlobalConfig(LockableConfig):
1024
"""The configuration that should be used for a specific location."""
1027
super(GlobalConfig, self).__init__(file_name=config_filename())
1029
def config_id(self):
1033
def from_string(cls, str_or_unicode, save=False):
1034
"""Create a config object from a string.
1036
:param str_or_unicode: A string representing the file content. This
1037
will be utf-8 encoded.
1039
:param save: Whether the file should be saved upon creation.
1042
conf._create_from_string(str_or_unicode, save)
1045
def set_user_option(self, option, value):
1046
"""Save option and its value in the configuration."""
1047
with self.lock_write():
1048
self._set_option(option, value, 'DEFAULT')
1050
def get_aliases(self):
1051
"""Return the aliases section."""
1052
if 'ALIASES' in self._get_parser():
1053
return self._get_parser()['ALIASES']
1057
def set_alias(self, alias_name, alias_command):
1058
"""Save the alias in the configuration."""
1059
with self.lock_write():
1060
self._set_option(alias_name, alias_command, 'ALIASES')
1062
def unset_alias(self, alias_name):
1063
"""Unset an existing alias."""
1064
with self.lock_write():
1066
aliases = self._get_parser().get('ALIASES')
1067
if not aliases or alias_name not in aliases:
1068
raise errors.NoSuchAlias(alias_name)
1069
del aliases[alias_name]
1070
self._write_config_file()
1072
def _set_option(self, option, value, section):
1074
self._get_parser().setdefault(section, {})[option] = value
1075
self._write_config_file()
1076
for hook in OldConfigHooks['set']:
1077
hook(self, option, value)
1079
def _get_sections(self, name=None):
1080
"""See IniBasedConfig._get_sections()."""
1081
parser = self._get_parser()
1082
# We don't give access to options defined outside of any section, we
1083
# used the DEFAULT section by... default.
1084
if name in (None, 'DEFAULT'):
1085
# This could happen for an empty file where the DEFAULT section
1086
# doesn't exist yet. So we force DEFAULT when yielding
1088
if 'DEFAULT' not in parser:
1089
parser['DEFAULT'] = {}
1090
yield (name, parser[name], self.config_id())
1092
def remove_user_option(self, option_name, section_name=None):
1093
if section_name is None:
1094
# We need to force the default section.
1095
section_name = 'DEFAULT'
1096
with self.lock_write():
1097
# We need to avoid the LockableConfig implementation or we'll lock
1099
super(LockableConfig, self).remove_user_option(
1100
option_name, section_name)
1103
def _iter_for_location_by_parts(sections, location):
1104
"""Keep only the sessions matching the specified location.
1106
:param sections: An iterable of section names.
1108
:param location: An url or a local path to match against.
1110
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1111
number of path components in the section name, section is the section
1112
name and extra_path is the difference between location and the section
1115
``location`` will always be a local path and never a 'file://' url but the
1116
section names themselves can be in either form.
1118
location_parts = location.rstrip('/').split('/')
1120
for section in sections:
1121
# location is a local path if possible, so we need to convert 'file://'
1122
# urls in section names to local paths if necessary.
1124
# This also avoids having file:///path be a more exact
1125
# match than '/path'.
1127
# FIXME: This still raises an issue if a user defines both file:///path
1128
# *and* /path. Should we raise an error in this case -- vila 20110505
1130
if section.startswith('file://'):
1131
section_path = urlutils.local_path_from_url(section)
1133
section_path = section
1134
section_parts = section_path.rstrip('/').split('/')
1137
if len(section_parts) > len(location_parts):
1138
# More path components in the section, they can't match
1141
# Rely on zip truncating in length to the length of the shortest
1142
# argument sequence.
1143
for name in zip(location_parts, section_parts):
1144
if not fnmatch.fnmatch(name[0], name[1]):
1149
# build the path difference between the section and the location
1150
extra_path = '/'.join(location_parts[len(section_parts):])
1151
yield section, extra_path, len(section_parts)
1154
class LocationConfig(LockableConfig):
1155
"""A configuration object that gives the policy for a location."""
1157
def __init__(self, location):
1158
super(LocationConfig, self).__init__(
1159
file_name=locations_config_filename())
1160
# local file locations are looked up by local path, rather than
1161
# by file url. This is because the config file is a user
1162
# file, and we would rather not expose the user to file urls.
1163
if location.startswith('file://'):
1164
location = urlutils.local_path_from_url(location)
1165
self.location = location
1167
def config_id(self):
1171
def from_string(cls, str_or_unicode, location, save=False):
1172
"""Create a config object from a string.
1174
:param str_or_unicode: A string representing the file content. This will
1177
:param location: The location url to filter the configuration.
1179
:param save: Whether the file should be saved upon creation.
1181
conf = cls(location)
1182
conf._create_from_string(str_or_unicode, save)
1185
def _get_matching_sections(self):
1186
"""Return an ordered list of section names matching this location."""
1187
# put the longest (aka more specific) locations first
1189
_iter_for_location_by_parts(self._get_parser(), self.location),
1190
key=lambda match: (match[2], match[0]),
1192
for (section, extra_path, length) in matches:
1193
yield section, extra_path
1194
# should we stop looking for parent configs here?
1196
if self._get_parser()[section].as_bool('ignore_parents'):
1201
def _get_sections(self, name=None):
1202
"""See IniBasedConfig._get_sections()."""
1203
# We ignore the name here as the only sections handled are named with
1204
# the location path and we don't expose embedded sections either.
1205
parser = self._get_parser()
1206
for name, extra_path in self._get_matching_sections():
1207
yield (name, parser[name], self.config_id())
1209
def _get_option_policy(self, section, option_name):
1210
"""Return the policy for the given (section, option_name) pair."""
1211
# check for the old 'recurse=False' flag
1213
recurse = self._get_parser()[section].as_bool('recurse')
1217
return POLICY_NORECURSE
1219
policy_key = option_name + ':policy'
1221
policy_name = self._get_parser()[section][policy_key]
1225
return _policy_value[policy_name]
1227
def _set_option_policy(self, section, option_name, option_policy):
1228
"""Set the policy for the given option name in the given section."""
1229
policy_key = option_name + ':policy'
1230
policy_name = _policy_name[option_policy]
1231
if policy_name is not None:
1232
self._get_parser()[section][policy_key] = policy_name
1234
if policy_key in self._get_parser()[section]:
1235
del self._get_parser()[section][policy_key]
1237
def set_user_option(self, option, value, store=STORE_LOCATION):
1238
"""Save option and its value in the configuration."""
1239
if store not in [STORE_LOCATION,
1240
STORE_LOCATION_NORECURSE,
1241
STORE_LOCATION_APPENDPATH]:
1242
raise ValueError('bad storage policy %r for %r' %
1244
with self.lock_write():
1246
location = self.location
1247
if location.endswith('/'):
1248
location = location[:-1]
1249
parser = self._get_parser()
1250
if location not in parser and not location + '/' in parser:
1251
parser[location] = {}
1252
elif location + '/' in parser:
1253
location = location + '/'
1254
parser[location][option] = value
1255
# the allowed values of store match the config policies
1256
self._set_option_policy(location, option, store)
1257
self._write_config_file()
1258
for hook in OldConfigHooks['set']:
1259
hook(self, option, value)
1262
class BranchConfig(Config):
1263
"""A configuration object giving the policy for a branch."""
1265
def __init__(self, branch):
1266
super(BranchConfig, self).__init__()
1267
self._location_config = None
1268
self._branch_data_config = None
1269
self._global_config = None
1270
self.branch = branch
1271
self.option_sources = (self._get_location_config,
1272
self._get_branch_data_config,
1273
self._get_global_config)
1275
def config_id(self):
1278
def _get_branch_data_config(self):
1279
if self._branch_data_config is None:
1280
self._branch_data_config = TreeConfig(self.branch)
1281
self._branch_data_config.config_id = self.config_id
1282
return self._branch_data_config
1284
def _get_location_config(self):
1285
if self._location_config is None:
1286
self._location_config = LocationConfig(self.branch.base)
1287
return self._location_config
1289
def _get_global_config(self):
1290
if self._global_config is None:
1291
self._global_config = GlobalConfig()
1292
return self._global_config
1294
def _get_best_value(self, option_name):
1295
"""This returns a user option from local, tree or global config.
1297
They are tried in that order. Use get_safe_value if trusted values
1300
for source in self.option_sources:
1301
value = getattr(source(), option_name)()
1302
if value is not None:
1306
def _get_safe_value(self, option_name):
1307
"""This variant of get_best_value never returns untrusted values.
1309
It does not return values from the branch data, because the branch may
1310
not be controlled by the user.
1312
We may wish to allow locations.conf to control whether branches are
1313
trusted in the future.
1315
for source in (self._get_location_config, self._get_global_config):
1316
value = getattr(source(), option_name)()
1317
if value is not None:
1321
def _get_user_id(self):
1322
"""Return the full user id for the branch.
1324
e.g. "John Hacker <jhacker@example.com>"
1325
This is looked up in the email controlfile for the branch.
1327
return self._get_best_value('_get_user_id')
1329
def _get_change_editor(self):
1330
return self._get_best_value('_get_change_editor')
1332
def _get_signature_checking(self):
1333
"""See Config._get_signature_checking."""
1334
return self._get_best_value('_get_signature_checking')
1336
def _get_signing_policy(self):
1337
"""See Config._get_signing_policy."""
1338
return self._get_best_value('_get_signing_policy')
1340
def _get_user_option(self, option_name):
1341
"""See Config._get_user_option."""
1342
for source in self.option_sources:
1343
value = source()._get_user_option(option_name)
1344
if value is not None:
1348
def _get_sections(self, name=None):
1349
"""See IniBasedConfig.get_sections()."""
1350
for source in self.option_sources:
1351
for section in source()._get_sections(name):
1354
def _get_options(self, sections=None):
1356
# First the locations options
1357
for option in self._get_location_config()._get_options():
1359
# Then the branch options
1360
branch_config = self._get_branch_data_config()
1361
if sections is None:
1362
sections = [('DEFAULT', branch_config._get_parser())]
1363
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1364
# Config itself has no notion of sections :( -- vila 20101001
1365
config_id = self.config_id()
1366
for (section_name, section) in sections:
1367
for (name, value) in section.iteritems():
1368
yield (name, value, section_name,
1369
config_id, branch_config._get_parser())
1370
# Then the global options
1371
for option in self._get_global_config()._get_options():
1374
def set_user_option(self, name, value, store=STORE_BRANCH,
1376
if store == STORE_BRANCH:
1377
self._get_branch_data_config().set_option(value, name)
1378
elif store == STORE_GLOBAL:
1379
self._get_global_config().set_user_option(name, value)
1381
self._get_location_config().set_user_option(name, value, store)
1384
if store in (STORE_GLOBAL, STORE_BRANCH):
1385
mask_value = self._get_location_config().get_user_option(name)
1386
if mask_value is not None:
1387
trace.warning('Value "%s" is masked by "%s" from'
1388
' locations.conf', value, mask_value)
1390
if store == STORE_GLOBAL:
1391
branch_config = self._get_branch_data_config()
1392
mask_value = branch_config.get_user_option(name)
1393
if mask_value is not None:
1394
trace.warning('Value "%s" is masked by "%s" from'
1395
' branch.conf', value, mask_value)
1397
def remove_user_option(self, option_name, section_name=None):
1398
self._get_branch_data_config().remove_option(option_name, section_name)
1400
def _post_commit(self):
1401
"""See Config.post_commit."""
1402
return self._get_safe_value('_post_commit')
1404
def _get_nickname(self):
1405
value = self._get_explicit_nickname()
1406
if value is not None:
1408
if self.branch.name:
1409
return self.branch.name
1410
return urlutils.unescape(self.branch.base.split('/')[-2])
1412
def has_explicit_nickname(self):
1413
"""Return true if a nickname has been explicitly assigned."""
1414
return self._get_explicit_nickname() is not None
1416
def _get_explicit_nickname(self):
1417
return self._get_best_value('_get_nickname')
1419
def _log_format(self):
1420
"""See Config.log_format."""
1421
return self._get_best_value('_log_format')
1423
def _validate_signatures_in_log(self):
1424
"""See Config.validate_signatures_in_log."""
1425
return self._get_best_value('_validate_signatures_in_log')
1427
def _acceptable_keys(self):
1428
"""See Config.acceptable_keys."""
1429
return self._get_best_value('_acceptable_keys')
1432
def ensure_config_dir_exists(path=None):
1433
"""Make sure a configuration directory exists.
1434
This makes sure that the directory exists.
1435
On windows, since configuration directories are 2 levels deep,
1436
it makes sure both the directory and the parent directory exists.
1440
if not os.path.isdir(path):
1441
if sys.platform == 'win32':
1442
parent_dir = os.path.dirname(path)
1443
if not os.path.isdir(parent_dir):
1444
trace.mutter('creating config parent directory: %r', parent_dir)
1445
os.mkdir(parent_dir)
1446
trace.mutter('creating config directory: %r', path)
1448
osutils.copy_ownership_from_path(path)
1451
def bazaar_config_dir():
1452
"""Return per-user configuration directory as unicode string
1454
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1455
and Linux. On Mac OS X and Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1456
that will be used instead.
1458
TODO: Global option --config-dir to override this.
1460
base = osutils.path_from_environ('BZR_HOME')
1461
if sys.platform == 'win32':
1463
base = win32utils.get_appdata_location()
1465
base = win32utils.get_home_location()
1466
return osutils.pathjoin(base, 'bazaar', '2.0')
1468
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1470
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1471
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1472
if osutils.isdir(xdg_dir):
1474
"Using configuration in XDG directory %s." % xdg_dir)
1476
base = osutils._get_home_dir()
1477
return osutils.pathjoin(base, ".bazaar")
1481
"""Return per-user configuration directory as unicode string
1483
By default this is %APPDATA%/breezy on Windows, $XDG_CONFIG_HOME/breezy on
1484
Mac OS X and Linux. If the breezy config directory doesn't exist but
1485
the bazaar one (see bazaar_config_dir()) does, use that instead.
1487
# TODO: Global option --config-dir to override this.
1488
base = osutils.path_from_environ('BRZ_HOME')
1489
if sys.platform == 'win32':
1491
base = win32utils.get_appdata_location()
1493
base = win32utils.get_home_location()
1495
base = osutils.path_from_environ('XDG_CONFIG_HOME')
1497
base = osutils.pathjoin(osutils._get_home_dir(), ".config")
1498
breezy_dir = osutils.pathjoin(base, 'breezy')
1499
if osutils.isdir(breezy_dir):
1500
return (breezy_dir, 'breezy')
1501
# If the breezy directory doesn't exist, but the bazaar one does, use that:
1502
bazaar_dir = bazaar_config_dir()
1503
if osutils.isdir(bazaar_dir):
1505
"Using Bazaar configuration directory (%s)", bazaar_dir)
1506
return (bazaar_dir, 'bazaar')
1507
return (breezy_dir, 'breezy')
1511
"""Return per-user configuration directory as unicode string
1513
By default this is %APPDATA%/breezy on Windows, $XDG_CONFIG_HOME/breezy on
1514
Mac OS X and Linux. If the breezy config directory doesn't exist but
1515
the bazaar one (see bazaar_config_dir()) does, use that instead.
1517
return _config_dir()[0]
1520
def config_filename():
1521
"""Return per-user configuration ini file filename."""
1522
path, kind = _config_dir()
1523
if kind == 'bazaar':
1524
return osutils.pathjoin(path, 'bazaar.conf')
1526
return osutils.pathjoin(path, 'breezy.conf')
1529
def locations_config_filename():
1530
"""Return per-user configuration ini file filename."""
1531
return osutils.pathjoin(config_dir(), 'locations.conf')
1534
def authentication_config_filename():
1535
"""Return per-user authentication ini file filename."""
1536
return osutils.pathjoin(config_dir(), 'authentication.conf')
1539
def user_ignore_config_filename():
1540
"""Return the user default ignore filename"""
1541
return osutils.pathjoin(config_dir(), 'ignore')
1545
"""Return the directory name to store crash files.
1547
This doesn't implicitly create it.
1549
On Windows it's in the config directory; elsewhere it's /var/crash
1550
which may be monitored by apport. It can be overridden by
1553
if sys.platform == 'win32':
1554
return osutils.pathjoin(config_dir(), 'Crash')
1556
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1558
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1561
def xdg_cache_dir():
1562
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1563
# Possibly this should be different on Windows?
1564
e = os.environ.get('XDG_CACHE_HOME', None)
1568
return os.path.expanduser('~/.cache')
1571
def _get_default_mail_domain(mailname_file='/etc/mailname'):
1572
"""If possible, return the assumed default email domain.
1574
:returns: string mail domain, or None.
1576
if sys.platform == 'win32':
1577
# No implementation yet; patches welcome
1580
f = open(mailname_file)
1581
except (IOError, OSError) as e:
1584
domain = f.readline().strip()
1590
def default_email():
1591
v = os.environ.get('BRZ_EMAIL')
1594
v = v.decode(osutils.get_user_encoding())
1596
v = os.environ.get('EMAIL')
1599
v = v.decode(osutils.get_user_encoding())
1601
name, email = _auto_user_id()
1603
return u'%s <%s>' % (name, email)
1609
def _auto_user_id():
1610
"""Calculate automatic user identification.
1612
:returns: (realname, email), either of which may be None if they can't be
1615
Only used when none is set in the environment or the id file.
1617
This only returns an email address if we can be fairly sure the
1618
address is reasonable, ie if /etc/mailname is set on unix.
1620
This doesn't use the FQDN as the default domain because that may be
1621
slow, and it doesn't use the hostname alone because that's not normally
1622
a reasonable address.
1624
if sys.platform == 'win32':
1625
# No implementation to reliably determine Windows default mail
1626
# address; please add one.
1629
default_mail_domain = _get_default_mail_domain()
1630
if not default_mail_domain:
1636
w = pwd.getpwuid(uid)
1638
trace.mutter('no passwd entry for uid %d?' % uid)
1641
# we try utf-8 first, because on many variants (like Linux),
1642
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1643
# false positives. (many users will have their user encoding set to
1644
# latin-1, which cannot raise UnicodeError.)
1646
if isinstance(gecos, bytes):
1648
gecos = gecos.decode('utf-8')
1650
except UnicodeError:
1652
encoding = osutils.get_user_encoding()
1653
gecos = gecos.decode(encoding)
1654
except UnicodeError as e:
1655
trace.mutter("cannot decode passwd entry %s" % w)
1658
username = w.pw_name
1659
if isinstance(username, bytes):
1661
username = username.decode(encoding)
1662
except UnicodeError as e:
1663
trace.mutter("cannot decode passwd entry %s" % w)
1666
comma = gecos.find(',')
1670
realname = gecos[:comma]
1672
return realname, (username + '@' + default_mail_domain)
1675
def parse_username(username):
1676
"""Parse e-mail username and return a (name, address) tuple."""
1677
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1679
return (username, '')
1681
return (match.group(1), match.group(2))
1684
def extract_email_address(e):
1685
"""Return just the address part of an email string.
1687
That is just the user@domain part, nothing else.
1688
This part is required to contain only ascii characters.
1689
If it can't be extracted, raises an error.
1691
>>> extract_email_address('Jane Tester <jane@test.com>')
1694
name, email = parse_username(e)
1696
raise NoEmailInUsername(e)
1700
class TreeConfig(IniBasedConfig):
1701
"""Branch configuration data associated with its contents, not location"""
1703
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1705
def __init__(self, branch):
1706
self._config = branch._get_config()
1707
self.branch = branch
1709
def _get_parser(self, file=None):
1710
if file is not None:
1711
return IniBasedConfig._get_parser(file)
1712
return self._config._get_configobj()
1714
def get_option(self, name, section=None, default=None):
1715
with self.branch.lock_read():
1716
return self._config.get_option(name, section, default)
1718
def set_option(self, value, name, section=None):
1719
"""Set a per-branch configuration option"""
1720
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1721
# higher levels providing the right lock -- vila 20101004
1722
with self.branch.lock_write():
1723
self._config.set_option(value, name, section)
1725
def remove_option(self, option_name, section_name=None):
1726
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1727
# higher levels providing the right lock -- vila 20101004
1728
with self.branch.lock_write():
1729
self._config.remove_option(option_name, section_name)
1732
_authentication_config_permission_errors = set()
1735
class AuthenticationConfig(object):
1736
"""The authentication configuration file based on a ini file.
1738
Implements the authentication.conf file described in
1739
doc/developers/authentication-ring.txt.
1742
def __init__(self, _file=None):
1743
self._config = None # The ConfigObj
1745
self._filename = authentication_config_filename()
1746
self._input = self._filename = authentication_config_filename()
1747
self._check_permissions()
1749
# Tests can provide a string as _file
1750
self._filename = None
1753
def _get_config(self):
1754
if self._config is not None:
1757
# FIXME: Should we validate something here ? Includes: empty
1758
# sections are useless, at least one of
1759
# user/password/password_encoding should be defined, etc.
1761
# Note: the encoding below declares that the file itself is utf-8
1762
# encoded, but the values in the ConfigObj are always Unicode.
1763
self._config = ConfigObj(self._input, encoding='utf-8')
1764
except configobj.ConfigObjError as e:
1765
raise ParseConfigError(e.errors, e.config.filename)
1766
except UnicodeError:
1767
raise ConfigContentError(self._filename)
1770
def _check_permissions(self):
1771
"""Check permission of auth file are user read/write able only."""
1773
st = os.stat(self._filename)
1774
except OSError as e:
1775
if e.errno != errno.ENOENT:
1776
trace.mutter('Unable to stat %r: %r', self._filename, e)
1778
mode = stat.S_IMODE(st.st_mode)
1779
if ((stat.S_IXOTH | stat.S_IWOTH | stat.S_IROTH | stat.S_IXGRP |
1780
stat.S_IWGRP | stat.S_IRGRP ) & mode):
1782
if (not self._filename in _authentication_config_permission_errors
1783
and not GlobalConfig().suppress_warning(
1784
'insecure_permissions')):
1785
trace.warning("The file '%s' has insecure "
1786
"file permissions. Saved passwords may be accessible "
1787
"by other users.", self._filename)
1788
_authentication_config_permission_errors.add(self._filename)
1791
"""Save the config file, only tests should use it for now."""
1792
conf_dir = os.path.dirname(self._filename)
1793
ensure_config_dir_exists(conf_dir)
1794
fd = os.open(self._filename, os.O_RDWR|os.O_CREAT, 0o600)
1796
f = os.fdopen(fd, 'wb')
1797
self._get_config().write(f)
1801
def _set_option(self, section_name, option_name, value):
1802
"""Set an authentication configuration option"""
1803
conf = self._get_config()
1804
section = conf.get(section_name)
1807
section = conf[section]
1808
section[option_name] = value
1811
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1813
"""Returns the matching credentials from authentication.conf file.
1815
:param scheme: protocol
1817
:param host: the server address
1819
:param port: the associated port (optional)
1821
:param user: login (optional)
1823
:param path: the absolute path on the server (optional)
1825
:param realm: the http authentication realm (optional)
1827
:return: A dict containing the matching credentials or None.
1829
- name: the section name of the credentials in the
1830
authentication.conf file,
1831
- user: can't be different from the provided user if any,
1832
- scheme: the server protocol,
1833
- host: the server address,
1834
- port: the server port (can be None),
1835
- path: the absolute server path (can be None),
1836
- realm: the http specific authentication realm (can be None),
1837
- password: the decoded password, could be None if the credential
1838
defines only the user
1839
- verify_certificates: https specific, True if the server
1840
certificate should be verified, False otherwise.
1843
for auth_def_name, auth_def in self._get_config().iteritems():
1844
if not isinstance(auth_def, configobj.Section):
1845
raise ValueError("%s defined outside a section" % auth_def_name)
1847
a_scheme, a_host, a_user, a_path = map(
1848
auth_def.get, ['scheme', 'host', 'user', 'path'])
1851
a_port = auth_def.as_int('port')
1855
raise ValueError("'port' not numeric in %s" % auth_def_name)
1857
a_verify_certificates = auth_def.as_bool('verify_certificates')
1859
a_verify_certificates = True
1862
"'verify_certificates' not boolean in %s" % auth_def_name)
1865
if a_scheme is not None and scheme != a_scheme:
1867
if a_host is not None:
1868
if not (host == a_host
1869
or (a_host.startswith('.') and host.endswith(a_host))):
1871
if a_port is not None and port != a_port:
1873
if (a_path is not None and path is not None
1874
and not path.startswith(a_path)):
1876
if (a_user is not None and user is not None
1877
and a_user != user):
1878
# Never contradict the caller about the user to be used
1883
# Prepare a credentials dictionary with additional keys
1884
# for the credential providers
1885
credentials = dict(name=auth_def_name,
1892
password=auth_def.get('password', None),
1893
verify_certificates=a_verify_certificates)
1894
# Decode the password in the credentials (or get one)
1895
self.decode_password(credentials,
1896
auth_def.get('password_encoding', None))
1897
if 'auth' in debug.debug_flags:
1898
trace.mutter("Using authentication section: %r", auth_def_name)
1901
if credentials is None:
1902
# No credentials were found in authentication.conf, try the fallback
1903
# credentials stores.
1904
credentials = credential_store_registry.get_fallback_credentials(
1905
scheme, host, port, user, path, realm)
1909
def set_credentials(self, name, host, user, scheme=None, password=None,
1910
port=None, path=None, verify_certificates=None,
1912
"""Set authentication credentials for a host.
1914
Any existing credentials with matching scheme, host, port and path
1915
will be deleted, regardless of name.
1917
:param name: An arbitrary name to describe this set of credentials.
1918
:param host: Name of the host that accepts these credentials.
1919
:param user: The username portion of these credentials.
1920
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1922
:param password: Password portion of these credentials.
1923
:param port: The IP port on the host that these credentials apply to.
1924
:param path: A filesystem path on the host that these credentials
1926
:param verify_certificates: On https, verify server certificates if
1928
:param realm: The http authentication realm (optional).
1930
values = {'host': host, 'user': user}
1931
if password is not None:
1932
values['password'] = password
1933
if scheme is not None:
1934
values['scheme'] = scheme
1935
if port is not None:
1936
values['port'] = '%d' % port
1937
if path is not None:
1938
values['path'] = path
1939
if verify_certificates is not None:
1940
values['verify_certificates'] = str(verify_certificates)
1941
if realm is not None:
1942
values['realm'] = realm
1943
config = self._get_config()
1945
for section, existing_values in config.iteritems():
1946
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1947
if existing_values.get(key) != values.get(key):
1951
config.update({name: values})
1954
def get_user(self, scheme, host, port=None, realm=None, path=None,
1955
prompt=None, ask=False, default=None):
1956
"""Get a user from authentication file.
1958
:param scheme: protocol
1960
:param host: the server address
1962
:param port: the associated port (optional)
1964
:param realm: the realm sent by the server (optional)
1966
:param path: the absolute path on the server (optional)
1968
:param ask: Ask the user if there is no explicitly configured username
1971
:param default: The username returned if none is defined (optional).
1973
:return: The found user.
1975
credentials = self.get_credentials(scheme, host, port, user=None,
1976
path=path, realm=realm)
1977
if credentials is not None:
1978
user = credentials['user']
1984
# Create a default prompt suitable for most cases
1985
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1986
# Special handling for optional fields in the prompt
1987
if port is not None:
1988
prompt_host = '%s:%d' % (host, port)
1991
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1996
def get_password(self, scheme, host, user, port=None,
1997
realm=None, path=None, prompt=None):
1998
"""Get a password from authentication file or prompt the user for one.
2000
:param scheme: protocol
2002
:param host: the server address
2004
:param port: the associated port (optional)
2008
:param realm: the realm sent by the server (optional)
2010
:param path: the absolute path on the server (optional)
2012
:return: The found password or the one entered by the user.
2014
credentials = self.get_credentials(scheme, host, port, user, path,
2016
if credentials is not None:
2017
password = credentials['password']
2018
if password is not None and scheme is 'ssh':
2019
trace.warning('password ignored in section [%s],'
2020
' use an ssh agent instead'
2021
% credentials['name'])
2025
# Prompt user only if we could't find a password
2026
if password is None:
2028
# Create a default prompt suitable for most cases
2029
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
2030
# Special handling for optional fields in the prompt
2031
if port is not None:
2032
prompt_host = '%s:%d' % (host, port)
2035
password = ui.ui_factory.get_password(prompt,
2036
host=prompt_host, user=user)
2039
def decode_password(self, credentials, encoding):
2041
cs = credential_store_registry.get_credential_store(encoding)
2043
raise ValueError('%r is not a known password_encoding' % encoding)
2044
credentials['password'] = cs.decode_password(credentials)
2048
class CredentialStoreRegistry(registry.Registry):
2049
"""A class that registers credential stores.
2051
A credential store provides access to credentials via the password_encoding
2052
field in authentication.conf sections.
2054
Except for stores provided by brz itself, most stores are expected to be
2055
provided by plugins that will therefore use
2056
register_lazy(password_encoding, module_name, member_name, help=help,
2057
fallback=fallback) to install themselves.
2059
A fallback credential store is one that is queried if no credentials can be
2060
found via authentication.conf.
2063
def get_credential_store(self, encoding=None):
2064
cs = self.get(encoding)
2069
def is_fallback(self, name):
2070
"""Check if the named credentials store should be used as fallback."""
2071
return self.get_info(name)
2073
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2074
path=None, realm=None):
2075
"""Request credentials from all fallback credentials stores.
2077
The first credentials store that can provide credentials wins.
2080
for name in self.keys():
2081
if not self.is_fallback(name):
2083
cs = self.get_credential_store(name)
2084
credentials = cs.get_credentials(scheme, host, port, user,
2086
if credentials is not None:
2087
# We found some credentials
2091
def register(self, key, obj, help=None, override_existing=False,
2093
"""Register a new object to a name.
2095
:param key: This is the key to use to request the object later.
2096
:param obj: The object to register.
2097
:param help: Help text for this entry. This may be a string or
2098
a callable. If it is a callable, it should take two
2099
parameters (registry, key): this registry and the key that
2100
the help was registered under.
2101
:param override_existing: Raise KeyErorr if False and something has
2102
already been registered for that key. If True, ignore if there
2103
is an existing key (always register the new value).
2104
:param fallback: Whether this credential store should be
2107
return super(CredentialStoreRegistry,
2108
self).register(key, obj, help, info=fallback,
2109
override_existing=override_existing)
2111
def register_lazy(self, key, module_name, member_name,
2112
help=None, override_existing=False,
2114
"""Register a new credential store to be loaded on request.
2116
:param module_name: The python path to the module. Such as 'os.path'.
2117
:param member_name: The member of the module to return. If empty or
2118
None, get() will return the module itself.
2119
:param help: Help text for this entry. This may be a string or
2121
:param override_existing: If True, replace the existing object
2122
with the new one. If False, if there is already something
2123
registered with the same key, raise a KeyError
2124
:param fallback: Whether this credential store should be
2127
return super(CredentialStoreRegistry, self).register_lazy(
2128
key, module_name, member_name, help,
2129
info=fallback, override_existing=override_existing)
2132
credential_store_registry = CredentialStoreRegistry()
2135
class CredentialStore(object):
2136
"""An abstract class to implement storage for credentials"""
2138
def decode_password(self, credentials):
2139
"""Returns a clear text password for the provided credentials."""
2140
raise NotImplementedError(self.decode_password)
2142
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2144
"""Return the matching credentials from this credential store.
2146
This method is only called on fallback credential stores.
2148
raise NotImplementedError(self.get_credentials)
2152
class PlainTextCredentialStore(CredentialStore):
2153
__doc__ = """Plain text credential store for the authentication.conf file"""
2155
def decode_password(self, credentials):
2156
"""See CredentialStore.decode_password."""
2157
return credentials['password']
2160
credential_store_registry.register('plain', PlainTextCredentialStore,
2161
help=PlainTextCredentialStore.__doc__)
2162
credential_store_registry.default_key = 'plain'
2165
class Base64CredentialStore(CredentialStore):
2166
__doc__ = """Base64 credential store for the authentication.conf file"""
2168
def decode_password(self, credentials):
2169
"""See CredentialStore.decode_password."""
2170
# GZ 2012-07-28: Will raise binascii.Error if password is not base64,
2171
# should probably propogate as something more useful.
2172
return base64.decodestring(credentials['password'])
2174
credential_store_registry.register('base64', Base64CredentialStore,
2175
help=Base64CredentialStore.__doc__)
2178
class BzrDirConfig(object):
2180
def __init__(self, bzrdir):
2181
self._bzrdir = bzrdir
2182
self._config = bzrdir._get_config()
2184
def set_default_stack_on(self, value):
2185
"""Set the default stacking location.
2187
It may be set to a location, or None.
2189
This policy affects all branches contained by this control dir, except
2190
for those under repositories.
2192
if self._config is None:
2193
raise errors.BzrError("Cannot set configuration in %s"
2196
self._config.set_option('', 'default_stack_on')
2198
self._config.set_option(value, 'default_stack_on')
2200
def get_default_stack_on(self):
2201
"""Return the default stacking location.
2203
This will either be a location, or None.
2205
This policy affects all branches contained by this control dir, except
2206
for those under repositories.
2208
if self._config is None:
2210
value = self._config.get_option('default_stack_on')
2216
class TransportConfig(object):
2217
"""A Config that reads/writes a config file on a Transport.
2219
It is a low-level object that considers config data to be name/value pairs
2220
that may be associated with a section. Assigning meaning to these values
2221
is done at higher levels like TreeConfig.
2224
def __init__(self, transport, filename):
2225
self._transport = transport
2226
self._filename = filename
2228
def get_option(self, name, section=None, default=None):
2229
"""Return the value associated with a named option.
2231
:param name: The name of the value
2232
:param section: The section the option is in (if any)
2233
:param default: The value to return if the value is not set
2234
:return: The value or default value
2236
configobj = self._get_configobj()
2238
section_obj = configobj
2241
section_obj = configobj[section]
2244
value = section_obj.get(name, default)
2245
for hook in OldConfigHooks['get']:
2246
hook(self, name, value)
2249
def set_option(self, value, name, section=None):
2250
"""Set the value associated with a named option.
2252
:param value: The value to set
2253
:param name: The name of the value to set
2254
:param section: The section the option is in (if any)
2256
configobj = self._get_configobj()
2258
configobj[name] = value
2260
configobj.setdefault(section, {})[name] = value
2261
for hook in OldConfigHooks['set']:
2262
hook(self, name, value)
2263
self._set_configobj(configobj)
2265
def remove_option(self, option_name, section_name=None):
2266
configobj = self._get_configobj()
2267
if section_name is None:
2268
del configobj[option_name]
2270
del configobj[section_name][option_name]
2271
for hook in OldConfigHooks['remove']:
2272
hook(self, option_name)
2273
self._set_configobj(configobj)
2275
def _get_config_file(self):
2277
f = BytesIO(self._transport.get_bytes(self._filename))
2278
for hook in OldConfigHooks['load']:
2281
except errors.NoSuchFile:
2283
except errors.PermissionDenied as e:
2284
trace.warning("Permission denied while trying to open "
2285
"configuration file %s.", urlutils.unescape_for_display(
2286
urlutils.join(self._transport.base, self._filename), "utf-8"))
2289
def _external_url(self):
2290
return urlutils.join(self._transport.external_url(), self._filename)
2292
def _get_configobj(self):
2293
f = self._get_config_file()
2296
conf = ConfigObj(f, encoding='utf-8')
2297
except configobj.ConfigObjError as e:
2298
raise ParseConfigError(e.errors, self._external_url())
2299
except UnicodeDecodeError:
2300
raise ConfigContentError(self._external_url())
2305
def _set_configobj(self, configobj):
2306
out_file = BytesIO()
2307
configobj.write(out_file)
2309
self._transport.put_file(self._filename, out_file)
2310
for hook in OldConfigHooks['save']:
2314
class Option(object):
2315
"""An option definition.
2317
The option *values* are stored in config files and found in sections.
2319
Here we define various properties about the option itself, its default
2320
value, how to convert it from stores, what to do when invalid values are
2321
encoutered, in which config files it can be stored.
2324
def __init__(self, name, override_from_env=None,
2325
default=None, default_from_env=None,
2326
help=None, from_unicode=None, invalid=None, unquote=True):
2327
"""Build an option definition.
2329
:param name: the name used to refer to the option.
2331
:param override_from_env: A list of environment variables which can
2332
provide override any configuration setting.
2334
:param default: the default value to use when none exist in the config
2335
stores. This is either a string that ``from_unicode`` will convert
2336
into the proper type, a callable returning a unicode string so that
2337
``from_unicode`` can be used on the return value, or a python
2338
object that can be stringified (so only the empty list is supported
2341
:param default_from_env: A list of environment variables which can
2342
provide a default value. 'default' will be used only if none of the
2343
variables specified here are set in the environment.
2345
:param help: a doc string to explain the option to the user.
2347
:param from_unicode: a callable to convert the unicode string
2348
representing the option value in a store or its default value.
2350
:param invalid: the action to be taken when an invalid value is
2351
encountered in a store. This is called only when from_unicode is
2352
invoked to convert a string and returns None or raise ValueError or
2353
TypeError. Accepted values are: None (ignore invalid values),
2354
'warning' (emit a warning), 'error' (emit an error message and
2357
:param unquote: should the unicode value be unquoted before conversion.
2358
This should be used only when the store providing the values cannot
2359
safely unquote them (see http://pad.lv/906897). It is provided so
2360
daughter classes can handle the quoting themselves.
2362
if override_from_env is None:
2363
override_from_env = []
2364
if default_from_env is None:
2365
default_from_env = []
2367
self.override_from_env = override_from_env
2368
# Convert the default value to a unicode string so all values are
2369
# strings internally before conversion (via from_unicode) is attempted.
2372
elif isinstance(default, list):
2373
# Only the empty list is supported
2375
raise AssertionError(
2376
'Only empty lists are supported as default values')
2378
elif isinstance(default, (binary_type, text_type, bool, int, float)):
2379
# Rely on python to convert strings, booleans and integers
2380
self.default = u'%s' % (default,)
2381
elif callable(default):
2382
self.default = default
2384
# other python objects are not expected
2385
raise AssertionError('%r is not supported as a default value'
2387
self.default_from_env = default_from_env
2389
self.from_unicode = from_unicode
2390
self.unquote = unquote
2391
if invalid and invalid not in ('warning', 'error'):
2392
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2393
self.invalid = invalid
2399
def convert_from_unicode(self, store, unicode_value):
2400
if self.unquote and store is not None and unicode_value is not None:
2401
unicode_value = store.unquote(unicode_value)
2402
if self.from_unicode is None or unicode_value is None:
2403
# Don't convert or nothing to convert
2404
return unicode_value
2406
converted = self.from_unicode(unicode_value)
2407
except (ValueError, TypeError):
2408
# Invalid values are ignored
2410
if converted is None and self.invalid is not None:
2411
# The conversion failed
2412
if self.invalid == 'warning':
2413
trace.warning('Value "%s" is not valid for "%s"',
2414
unicode_value, self.name)
2415
elif self.invalid == 'error':
2416
raise ConfigOptionValueError(self.name, unicode_value)
2419
def get_override(self):
2421
for var in self.override_from_env:
2423
# If the env variable is defined, its value takes precedence
2424
value = os.environ[var].decode(osutils.get_user_encoding())
2430
def get_default(self):
2432
for var in self.default_from_env:
2434
# If the env variable is defined, its value is the default one
2435
value = os.environ[var]
2437
value = value.decode(osutils.get_user_encoding())
2442
# Otherwise, fallback to the value defined at registration
2443
if callable(self.default):
2444
value = self.default()
2445
if not isinstance(value, text_type):
2446
raise AssertionError(
2447
"Callable default value for '%s' should be unicode"
2450
value = self.default
2453
def get_help_topic(self):
2456
def get_help_text(self, additional_see_also=None, plain=True):
2458
from breezy import help_topics
2459
result += help_topics._format_see_also(additional_see_also)
2461
result = help_topics.help_as_plain_text(result)
2465
# Predefined converters to get proper values from store
2467
def bool_from_store(unicode_str):
2468
return ui.bool_from_string(unicode_str)
2471
def int_from_store(unicode_str):
2472
return int(unicode_str)
2475
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2477
def int_SI_from_store(unicode_str):
2478
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2480
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2481
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2484
:return Integer, expanded to its base-10 value if a proper SI unit is
2485
found, None otherwise.
2487
regexp = "^(\\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2488
p = re.compile(regexp, re.IGNORECASE)
2489
m = p.match(unicode_str)
2492
val, _, unit = m.groups()
2496
coeff = _unit_suffixes[unit.upper()]
2498
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2503
def float_from_store(unicode_str):
2504
return float(unicode_str)
2507
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2509
_list_converter_config = configobj.ConfigObj(
2510
{}, encoding='utf-8', list_values=True, interpolation=False)
2513
class ListOption(Option):
2515
def __init__(self, name, default=None, default_from_env=None,
2516
help=None, invalid=None):
2517
"""A list Option definition.
2519
This overrides the base class so the conversion from a unicode string
2520
can take quoting into account.
2522
super(ListOption, self).__init__(
2523
name, default=default, default_from_env=default_from_env,
2524
from_unicode=self.from_unicode, help=help,
2525
invalid=invalid, unquote=False)
2527
def from_unicode(self, unicode_str):
2528
if not isinstance(unicode_str, string_types):
2530
# Now inject our string directly as unicode. All callers got their
2531
# value from configobj, so values that need to be quoted are already
2533
_list_converter_config.reset()
2534
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2535
maybe_list = _list_converter_config['list']
2536
if isinstance(maybe_list, string_types):
2538
# A single value, most probably the user forgot (or didn't care
2539
# to add) the final ','
2542
# The empty string, convert to empty list
2545
# We rely on ConfigObj providing us with a list already
2550
class RegistryOption(Option):
2551
"""Option for a choice from a registry."""
2553
def __init__(self, name, registry, default_from_env=None,
2554
help=None, invalid=None):
2555
"""A registry based Option definition.
2557
This overrides the base class so the conversion from a unicode string
2558
can take quoting into account.
2560
super(RegistryOption, self).__init__(
2561
name, default=lambda: unicode(registry.default_key),
2562
default_from_env=default_from_env,
2563
from_unicode=self.from_unicode, help=help,
2564
invalid=invalid, unquote=False)
2565
self.registry = registry
2567
def from_unicode(self, unicode_str):
2568
if not isinstance(unicode_str, string_types):
2571
return self.registry.get(unicode_str)
2574
"Invalid value %s for %s."
2575
"See help for a list of possible values." % (unicode_str,
2580
ret = [self._help, "\n\nThe following values are supported:\n"]
2581
for key in self.registry.keys():
2582
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2586
_option_ref_re = lazy_regex.lazy_compile('({[^\\d\\W](?:\\.\\w|-\\w|\\w)*})')
2587
"""Describes an expandable option reference.
2589
We want to match the most embedded reference first.
2591
I.e. for '{{foo}}' we will get '{foo}',
2592
for '{bar{baz}}' we will get '{baz}'
2595
def iter_option_refs(string):
2596
# Split isolate refs so every other chunk is a ref
2598
for chunk in _option_ref_re.split(string):
2603
class OptionRegistry(registry.Registry):
2604
"""Register config options by their name.
2606
This overrides ``registry.Registry`` to simplify registration by acquiring
2607
some information from the option object itself.
2610
def _check_option_name(self, option_name):
2611
"""Ensures an option name is valid.
2613
:param option_name: The name to validate.
2615
if _option_ref_re.match('{%s}' % option_name) is None:
2616
raise IllegalOptionName(option_name)
2618
def register(self, option):
2619
"""Register a new option to its name.
2621
:param option: The option to register. Its name is used as the key.
2623
self._check_option_name(option.name)
2624
super(OptionRegistry, self).register(option.name, option,
2627
def register_lazy(self, key, module_name, member_name):
2628
"""Register a new option to be loaded on request.
2630
:param key: the key to request the option later. Since the registration
2631
is lazy, it should be provided and match the option name.
2633
:param module_name: the python path to the module. Such as 'os.path'.
2635
:param member_name: the member of the module to return. If empty or
2636
None, get() will return the module itself.
2638
self._check_option_name(key)
2639
super(OptionRegistry, self).register_lazy(key,
2640
module_name, member_name)
2642
def get_help(self, key=None):
2643
"""Get the help text associated with the given key"""
2644
option = self.get(key)
2645
the_help = option.help
2646
if callable(the_help):
2647
return the_help(self, key)
2651
option_registry = OptionRegistry()
2654
# Registered options in lexicographical order
2656
option_registry.register(
2657
Option('append_revisions_only',
2658
default=None, from_unicode=bool_from_store, invalid='warning',
2660
Whether to only append revisions to the mainline.
2662
If this is set to true, then it is not possible to change the
2663
existing mainline of the branch.
2665
option_registry.register(
2666
ListOption('acceptable_keys',
2669
List of GPG key patterns which are acceptable for verification.
2671
option_registry.register(
2672
Option('add.maximum_file_size',
2673
default=u'20MB', from_unicode=int_SI_from_store,
2675
Size above which files should be added manually.
2677
Files below this size are added automatically when using ``bzr add`` without
2680
A negative value means disable the size check.
2682
option_registry.register(
2684
default=None, from_unicode=bool_from_store,
2686
Is the branch bound to ``bound_location``.
2688
If set to "True", the branch should act as a checkout, and push each commit to
2689
the bound_location. This option is normally set by ``bind``/``unbind``.
2691
See also: bound_location.
2693
option_registry.register(
2694
Option('bound_location',
2697
The location that commits should go to when acting as a checkout.
2699
This option is normally set by ``bind``.
2703
option_registry.register(
2704
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2706
Whether revisions associated with tags should be fetched.
2708
option_registry.register_lazy(
2709
'transform.orphan_policy', 'breezy.transform', 'opt_transform_orphan')
2710
option_registry.register(
2711
Option('bzr.workingtree.worth_saving_limit', default=10,
2712
from_unicode=int_from_store, invalid='warning',
2714
How many changes before saving the dirstate.
2716
-1 means that we will never rewrite the dirstate file for only
2717
stat-cache changes. Regardless of this setting, we will always rewrite
2718
the dirstate file if a file is added/removed/renamed/etc. This flag only
2719
affects the behavior of updating the dirstate file after we notice that
2720
a file has been touched.
2722
option_registry.register(
2723
Option('bugtracker', default=None,
2725
Default bug tracker to use.
2727
This bug tracker will be used for example when marking bugs
2728
as fixed using ``bzr commit --fixes``, if no explicit
2729
bug tracker was specified.
2731
option_registry.register(
2732
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2733
from_unicode=signature_policy_from_unicode,
2735
GPG checking policy.
2737
Possible values: require, ignore, check-available (default)
2739
this option will control whether bzr will require good gpg
2740
signatures, ignore them, or check them if they are
2743
option_registry.register(
2744
Option('child_submit_format',
2745
help='''The preferred format of submissions to this branch.'''))
2746
option_registry.register(
2747
Option('child_submit_to',
2748
help='''Where submissions to this branch are mailed to.'''))
2749
option_registry.register(
2750
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2751
from_unicode=signing_policy_from_unicode,
2755
Possible values: always, never, when-required (default)
2757
This option controls whether bzr will always create
2758
gpg signatures or not on commits.
2760
option_registry.register(
2761
Option('dirstate.fdatasync', default=True,
2762
from_unicode=bool_from_store,
2764
Flush dirstate changes onto physical disk?
2766
If true (default), working tree metadata changes are flushed through the
2767
OS buffers to physical disk. This is somewhat slower, but means data
2768
should not be lost if the machine crashes. See also repository.fdatasync.
2770
option_registry.register(
2771
ListOption('debug_flags', default=[],
2772
help='Debug flags to activate.'))
2773
option_registry.register(
2774
Option('default_format', default='2a',
2775
help='Format used when creating branches.'))
2776
option_registry.register(
2777
Option('dpush_strict', default=None,
2778
from_unicode=bool_from_store,
2780
The default value for ``dpush --strict``.
2782
If present, defines the ``--strict`` option default value for checking
2783
uncommitted changes before pushing into a different VCS without any
2784
custom bzr metadata.
2786
option_registry.register(
2788
help='The command called to launch an editor to enter a message.'))
2789
option_registry.register(
2790
Option('email', override_from_env=['BRZ_EMAIL'], default=default_email,
2791
help='The users identity'))
2792
option_registry.register(
2793
Option('gpg_signing_key',
2796
GPG key to use for signing.
2798
This defaults to the first key associated with the users email.
2800
option_registry.register(
2802
help='Language to translate messages into.'))
2803
option_registry.register(
2804
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2806
Steal locks that appears to be dead.
2808
If set to True, bzr will check if a lock is supposed to be held by an
2809
active process from the same user on the same machine. If the user and
2810
machine match, but no process with the given PID is active, then bzr
2811
will automatically break the stale lock, and create a new lock for
2813
Otherwise, bzr will prompt as normal to break the lock.
2815
option_registry.register(
2816
Option('log_format', default='long',
2818
Log format to use when displaying revisions.
2820
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2821
may be provided by plugins.
2823
option_registry.register_lazy('mail_client', 'breezy.mail_client',
2825
option_registry.register(
2826
Option('output_encoding',
2827
help= 'Unicode encoding for output'
2828
' (terminal encoding if not specified).'))
2829
option_registry.register(
2830
Option('parent_location',
2833
The location of the default branch for pull or merge.
2835
This option is normally set when creating a branch, the first ``pull`` or by
2836
``pull --remember``.
2838
option_registry.register(
2839
Option('post_commit', default=None,
2841
Post commit functions.
2843
An ordered list of python functions to call, separated by spaces.
2845
Each function takes branch, rev_id as parameters.
2847
option_registry.register_lazy('progress_bar', 'breezy.ui.text',
2849
option_registry.register(
2850
Option('public_branch',
2853
A publically-accessible version of this branch.
2855
This implies that the branch setting this option is not publically-accessible.
2856
Used and set by ``bzr send``.
2858
option_registry.register(
2859
Option('push_location',
2862
The location of the default branch for push.
2864
This option is normally set by the first ``push`` or ``push --remember``.
2866
option_registry.register(
2867
Option('push_strict', default=None,
2868
from_unicode=bool_from_store,
2870
The default value for ``push --strict``.
2872
If present, defines the ``--strict`` option default value for checking
2873
uncommitted changes before sending a merge directive.
2875
option_registry.register(
2876
Option('repository.fdatasync', default=True,
2877
from_unicode=bool_from_store,
2879
Flush repository changes onto physical disk?
2881
If true (default), repository changes are flushed through the OS buffers
2882
to physical disk. This is somewhat slower, but means data should not be
2883
lost if the machine crashes. See also dirstate.fdatasync.
2885
option_registry.register_lazy('smtp_server',
2886
'breezy.smtp_connection', 'smtp_server')
2887
option_registry.register_lazy('smtp_password',
2888
'breezy.smtp_connection', 'smtp_password')
2889
option_registry.register_lazy('smtp_username',
2890
'breezy.smtp_connection', 'smtp_username')
2891
option_registry.register(
2892
Option('selftest.timeout',
2894
from_unicode=int_from_store,
2895
help='Abort selftest if one test takes longer than this many seconds',
2898
option_registry.register(
2899
Option('send_strict', default=None,
2900
from_unicode=bool_from_store,
2902
The default value for ``send --strict``.
2904
If present, defines the ``--strict`` option default value for checking
2905
uncommitted changes before sending a bundle.
2908
option_registry.register(
2909
Option('serve.client_timeout',
2910
default=300.0, from_unicode=float_from_store,
2911
help="If we wait for a new request from a client for more than"
2912
" X seconds, consider the client idle, and hangup."))
2913
option_registry.register(
2914
Option('stacked_on_location',
2916
help="""The location where this branch is stacked on."""))
2917
option_registry.register(
2918
Option('submit_branch',
2921
The branch you intend to submit your current work to.
2923
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2924
by the ``submit:`` revision spec.
2926
option_registry.register(
2928
help='''Where submissions from this branch are mailed to.'''))
2929
option_registry.register(
2930
ListOption('suppress_warnings',
2932
help="List of warning classes to suppress."))
2933
option_registry.register(
2934
Option('validate_signatures_in_log', default=False,
2935
from_unicode=bool_from_store, invalid='warning',
2936
help='''Whether to validate signatures in brz log.'''))
2937
option_registry.register_lazy('ssl.ca_certs',
2938
'breezy.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2940
option_registry.register_lazy('ssl.cert_reqs',
2941
'breezy.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2944
class Section(object):
2945
"""A section defines a dict of option name => value.
2947
This is merely a read-only dict which can add some knowledge about the
2948
options. It is *not* a python dict object though and doesn't try to mimic
2952
def __init__(self, section_id, options):
2953
self.id = section_id
2954
# We re-use the dict-like object received
2955
self.options = options
2957
def get(self, name, default=None, expand=True):
2958
return self.options.get(name, default)
2960
def iter_option_names(self):
2961
for k in self.options.keys():
2965
# Mostly for debugging use
2966
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2969
_NewlyCreatedOption = object()
2970
"""Was the option created during the MutableSection lifetime"""
2971
_DeletedOption = object()
2972
"""Was the option deleted during the MutableSection lifetime"""
2975
class MutableSection(Section):
2976
"""A section allowing changes and keeping track of the original values."""
2978
def __init__(self, section_id, options):
2979
super(MutableSection, self).__init__(section_id, options)
2980
self.reset_changes()
2982
def set(self, name, value):
2983
if name not in self.options:
2984
# This is a new option
2985
self.orig[name] = _NewlyCreatedOption
2986
elif name not in self.orig:
2987
self.orig[name] = self.get(name, None)
2988
self.options[name] = value
2990
def remove(self, name):
2991
if name not in self.orig and name in self.options:
2992
self.orig[name] = self.get(name, None)
2993
del self.options[name]
2995
def reset_changes(self):
2998
def apply_changes(self, dirty, store):
2999
"""Apply option value changes.
3001
``self`` has been reloaded from the persistent storage. ``dirty``
3002
contains the changes made since the previous loading.
3004
:param dirty: the mutable section containing the changes.
3006
:param store: the store containing the section
3008
for k, expected in dirty.orig.items():
3009
actual = dirty.get(k, _DeletedOption)
3010
reloaded = self.get(k, _NewlyCreatedOption)
3011
if actual is _DeletedOption:
3012
if k in self.options:
3016
# Report concurrent updates in an ad-hoc way. This should only
3017
# occurs when different processes try to update the same option
3018
# which is not supported (as in: the config framework is not meant
3019
# to be used as a sharing mechanism).
3020
if expected != reloaded:
3021
if actual is _DeletedOption:
3022
actual = '<DELETED>'
3023
if reloaded is _NewlyCreatedOption:
3024
reloaded = '<CREATED>'
3025
if expected is _NewlyCreatedOption:
3026
expected = '<CREATED>'
3027
# Someone changed the value since we get it from the persistent
3029
trace.warning(gettext(
3030
"Option {0} in section {1} of {2} was changed"
3031
" from {3} to {4}. The {5} value will be saved.".format(
3032
k, self.id, store.external_url(), expected,
3034
# No need to keep track of these changes
3035
self.reset_changes()
3038
class Store(object):
3039
"""Abstract interface to persistent storage for configuration options."""
3041
readonly_section_class = Section
3042
mutable_section_class = MutableSection
3045
# Which sections need to be saved (by section id). We use a dict here
3046
# so the dirty sections can be shared by multiple callers.
3047
self.dirty_sections = {}
3049
def is_loaded(self):
3050
"""Returns True if the Store has been loaded.
3052
This is used to implement lazy loading and ensure the persistent
3053
storage is queried only when needed.
3055
raise NotImplementedError(self.is_loaded)
3058
"""Loads the Store from persistent storage."""
3059
raise NotImplementedError(self.load)
3061
def _load_from_string(self, bytes):
3062
"""Create a store from a string in configobj syntax.
3064
:param bytes: A string representing the file content.
3066
raise NotImplementedError(self._load_from_string)
3069
"""Unloads the Store.
3071
This should make is_loaded() return False. This is used when the caller
3072
knows that the persistent storage has changed or may have change since
3075
raise NotImplementedError(self.unload)
3077
def quote(self, value):
3078
"""Quote a configuration option value for storing purposes.
3080
This allows Stacks to present values as they will be stored.
3084
def unquote(self, value):
3085
"""Unquote a configuration option value into unicode.
3087
The received value is quoted as stored.
3092
"""Saves the Store to persistent storage."""
3093
raise NotImplementedError(self.save)
3095
def _need_saving(self):
3096
for s in self.dirty_sections.values():
3098
# At least one dirty section contains a modification
3102
def apply_changes(self, dirty_sections):
3103
"""Apply changes from dirty sections while checking for coherency.
3105
The Store content is discarded and reloaded from persistent storage to
3106
acquire up-to-date values.
3108
Dirty sections are MutableSection which kept track of the value they
3109
are expected to update.
3111
# We need an up-to-date version from the persistent storage, unload the
3112
# store. The reload will occur when needed (triggered by the first
3113
# get_mutable_section() call below.
3115
# Apply the changes from the preserved dirty sections
3116
for section_id, dirty in dirty_sections.items():
3117
clean = self.get_mutable_section(section_id)
3118
clean.apply_changes(dirty, self)
3119
# Everything is clean now
3120
self.dirty_sections = {}
3122
def save_changes(self):
3123
"""Saves the Store to persistent storage if changes occurred.
3125
Apply the changes recorded in the mutable sections to a store content
3126
refreshed from persistent storage.
3128
raise NotImplementedError(self.save_changes)
3130
def external_url(self):
3131
raise NotImplementedError(self.external_url)
3133
def get_sections(self):
3134
"""Returns an ordered iterable of existing sections.
3136
:returns: An iterable of (store, section).
3138
raise NotImplementedError(self.get_sections)
3140
def get_mutable_section(self, section_id=None):
3141
"""Returns the specified mutable section.
3143
:param section_id: The section identifier
3145
raise NotImplementedError(self.get_mutable_section)
3148
# Mostly for debugging use
3149
return "<config.%s(%s)>" % (self.__class__.__name__,
3150
self.external_url())
3153
class CommandLineStore(Store):
3154
"A store to carry command line overrides for the config options."""
3156
def __init__(self, opts=None):
3157
super(CommandLineStore, self).__init__()
3164
# The dict should be cleared but not replaced so it can be shared.
3165
self.options.clear()
3167
def _from_cmdline(self, overrides):
3168
# Reset before accepting new definitions
3170
for over in overrides:
3172
name, value = over.split('=', 1)
3174
raise errors.BzrCommandError(
3175
gettext("Invalid '%s', should be of the form 'name=value'")
3177
self.options[name] = value
3179
def external_url(self):
3180
# Not an url but it makes debugging easier and is never needed
3184
def get_sections(self):
3185
yield self, self.readonly_section_class(None, self.options)
3188
class IniFileStore(Store):
3189
"""A config Store using ConfigObj for storage.
3191
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3192
serialize/deserialize the config file.
3196
"""A config Store using ConfigObj for storage.
3198
super(IniFileStore, self).__init__()
3199
self._config_obj = None
3201
def is_loaded(self):
3202
return self._config_obj != None
3205
self._config_obj = None
3206
self.dirty_sections = {}
3208
def _load_content(self):
3209
"""Load the config file bytes.
3211
This should be provided by subclasses
3213
:return: Byte string
3215
raise NotImplementedError(self._load_content)
3217
def _save_content(self, content):
3218
"""Save the config file bytes.
3220
This should be provided by subclasses
3222
:param content: Config file bytes to write
3224
raise NotImplementedError(self._save_content)
3227
"""Load the store from the associated file."""
3228
if self.is_loaded():
3230
content = self._load_content()
3231
self._load_from_string(content)
3232
for hook in ConfigHooks['load']:
3235
def _load_from_string(self, bytes):
3236
"""Create a config store from a string.
3238
:param bytes: A string representing the file content.
3240
if self.is_loaded():
3241
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3242
co_input = BytesIO(bytes)
3244
# The config files are always stored utf8-encoded
3245
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3247
except configobj.ConfigObjError as e:
3248
self._config_obj = None
3249
raise ParseConfigError(e.errors, self.external_url())
3250
except UnicodeDecodeError:
3251
raise ConfigContentError(self.external_url())
3253
def save_changes(self):
3254
if not self.is_loaded():
3257
if not self._need_saving():
3259
# Preserve the current version
3260
dirty_sections = self.dirty_sections.copy()
3261
self.apply_changes(dirty_sections)
3262
# Save to the persistent storage
3266
if not self.is_loaded():
3270
self._config_obj.write(out)
3271
self._save_content(out.getvalue())
3272
for hook in ConfigHooks['save']:
3275
def get_sections(self):
3276
"""Get the configobj section in the file order.
3278
:returns: An iterable of (store, section).
3280
# We need a loaded store
3283
except (errors.NoSuchFile, errors.PermissionDenied):
3284
# If the file can't be read, there is no sections
3286
cobj = self._config_obj
3288
yield self, self.readonly_section_class(None, cobj)
3289
for section_name in cobj.sections:
3291
self.readonly_section_class(section_name,
3292
cobj[section_name]))
3294
def get_mutable_section(self, section_id=None):
3295
# We need a loaded store
3298
except errors.NoSuchFile:
3299
# The file doesn't exist, let's pretend it was empty
3300
self._load_from_string(b'')
3301
if section_id in self.dirty_sections:
3302
# We already created a mutable section for this id
3303
return self.dirty_sections[section_id]
3304
if section_id is None:
3305
section = self._config_obj
3307
section = self._config_obj.setdefault(section_id, {})
3308
mutable_section = self.mutable_section_class(section_id, section)
3309
# All mutable sections can become dirty
3310
self.dirty_sections[section_id] = mutable_section
3311
return mutable_section
3313
def quote(self, value):
3315
# configobj conflates automagical list values and quoting
3316
self._config_obj.list_values = True
3317
return self._config_obj._quote(value)
3319
self._config_obj.list_values = False
3321
def unquote(self, value):
3322
if value and isinstance(value, string_types):
3323
# _unquote doesn't handle None nor empty strings nor anything that
3324
# is not a string, really.
3325
value = self._config_obj._unquote(value)
3328
def external_url(self):
3329
# Since an IniFileStore can be used without a file (at least in tests),
3330
# it's better to provide something than raising a NotImplementedError.
3331
# All daughter classes are supposed to provide an implementation
3333
return 'In-Process Store, no URL'
3336
class TransportIniFileStore(IniFileStore):
3337
"""IniFileStore that loads files from a transport.
3339
:ivar transport: The transport object where the config file is located.
3341
:ivar file_name: The config file basename in the transport directory.
3344
def __init__(self, transport, file_name):
3345
"""A Store using a ini file on a Transport
3347
:param transport: The transport object where the config file is located.
3348
:param file_name: The config file basename in the transport directory.
3350
super(TransportIniFileStore, self).__init__()
3351
self.transport = transport
3352
self.file_name = file_name
3354
def _load_content(self):
3356
return self.transport.get_bytes(self.file_name)
3357
except errors.PermissionDenied:
3358
trace.warning("Permission denied while trying to load "
3359
"configuration store %s.", self.external_url())
3362
def _save_content(self, content):
3363
self.transport.put_bytes(self.file_name, content)
3365
def external_url(self):
3366
# FIXME: external_url should really accepts an optional relpath
3367
# parameter (bug #750169) :-/ -- vila 2011-04-04
3368
# The following will do in the interim but maybe we don't want to
3369
# expose a path here but rather a config ID and its associated
3370
# object </hand wawe>.
3371
return urlutils.join(
3372
self.transport.external_url(), urlutils.escape(self.file_name))
3375
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3376
# unlockable stores for use with objects that can already ensure the locking
3377
# (think branches). If different stores (not based on ConfigObj) are created,
3378
# they may face the same issue.
3381
class LockableIniFileStore(TransportIniFileStore):
3382
"""A ConfigObjStore using locks on save to ensure store integrity."""
3384
def __init__(self, transport, file_name, lock_dir_name=None):
3385
"""A config Store using ConfigObj for storage.
3387
:param transport: The transport object where the config file is located.
3389
:param file_name: The config file basename in the transport directory.
3391
if lock_dir_name is None:
3392
lock_dir_name = 'lock'
3393
self.lock_dir_name = lock_dir_name
3394
super(LockableIniFileStore, self).__init__(transport, file_name)
3395
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3397
def lock_write(self, token=None):
3398
"""Takes a write lock in the directory containing the config file.
3400
If the directory doesn't exist it is created.
3402
# FIXME: This doesn't check the ownership of the created directories as
3403
# ensure_config_dir_exists does. It should if the transport is local
3404
# -- vila 2011-04-06
3405
self.transport.create_prefix()
3406
token = self._lock.lock_write(token)
3407
return lock.LogicalLockResult(self.unlock, token)
3412
def break_lock(self):
3413
self._lock.break_lock()
3416
with self.lock_write():
3417
# We need to be able to override the undecorated implementation
3418
self.save_without_locking()
3420
def save_without_locking(self):
3421
super(LockableIniFileStore, self).save()
3424
# FIXME: global, breezy, shouldn't that be 'user' instead or even
3425
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3426
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3428
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3429
# functions or a registry will make it easier and clearer for tests, focusing
3430
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3431
# on a poolie's remark)
3432
class GlobalStore(LockableIniFileStore):
3433
"""A config store for global options.
3435
There is a single GlobalStore for a given process.
3438
def __init__(self, possible_transports=None):
3439
(path, kind) = _config_dir()
3440
t = transport.get_transport_from_path(
3441
path, possible_transports=possible_transports)
3442
filename = {'bazaar': 'bazaar.conf', 'breezy': 'breezy.conf'}[kind]
3443
super(GlobalStore, self).__init__(t, filename)
3447
class LocationStore(LockableIniFileStore):
3448
"""A config store for options specific to a location.
3450
There is a single LocationStore for a given process.
3453
def __init__(self, possible_transports=None):
3454
t = transport.get_transport_from_path(
3455
config_dir(), possible_transports=possible_transports)
3456
super(LocationStore, self).__init__(t, 'locations.conf')
3457
self.id = 'locations'
3460
class BranchStore(TransportIniFileStore):
3461
"""A config store for branch options.
3463
There is a single BranchStore for a given branch.
3466
def __init__(self, branch):
3467
super(BranchStore, self).__init__(branch.control_transport,
3469
self.branch = branch
3473
class ControlStore(LockableIniFileStore):
3475
def __init__(self, bzrdir):
3476
super(ControlStore, self).__init__(bzrdir.transport,
3478
lock_dir_name='branch_lock')
3482
class SectionMatcher(object):
3483
"""Select sections into a given Store.
3485
This is intended to be used to postpone getting an iterable of sections
3489
def __init__(self, store):
3492
def get_sections(self):
3493
# This is where we require loading the store so we can see all defined
3495
sections = self.store.get_sections()
3496
# Walk the revisions in the order provided
3497
for store, s in sections:
3501
def match(self, section):
3502
"""Does the proposed section match.
3504
:param section: A Section object.
3506
:returns: True if the section matches, False otherwise.
3508
raise NotImplementedError(self.match)
3511
class NameMatcher(SectionMatcher):
3513
def __init__(self, store, section_id):
3514
super(NameMatcher, self).__init__(store)
3515
self.section_id = section_id
3517
def match(self, section):
3518
return section.id == self.section_id
3521
class LocationSection(Section):
3523
def __init__(self, section, extra_path, branch_name=None):
3524
super(LocationSection, self).__init__(section.id, section.options)
3525
self.extra_path = extra_path
3526
if branch_name is None:
3528
self.locals = {'relpath': extra_path,
3529
'basename': urlutils.basename(extra_path),
3530
'branchname': branch_name}
3532
def get(self, name, default=None, expand=True):
3533
value = super(LocationSection, self).get(name, default)
3534
if value is not None and expand:
3535
policy_name = self.get(name + ':policy', None)
3536
policy = _policy_value.get(policy_name, POLICY_NONE)
3537
if policy == POLICY_APPENDPATH:
3538
value = urlutils.join(value, self.extra_path)
3539
# expand section local options right now (since POLICY_APPENDPATH
3540
# will never add options references, it's ok to expand after it).
3542
for is_ref, chunk in iter_option_refs(value):
3544
chunks.append(chunk)
3547
if ref in self.locals:
3548
chunks.append(self.locals[ref])
3550
chunks.append(chunk)
3551
value = ''.join(chunks)
3555
class StartingPathMatcher(SectionMatcher):
3556
"""Select sections for a given location respecting the Store order."""
3558
# FIXME: Both local paths and urls can be used for section names as well as
3559
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3560
# inherited the fuzziness from the previous ``LocationConfig``
3561
# implementation. We probably need to revisit which encoding is allowed for
3562
# both ``location`` and section names and how we normalize
3563
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3564
# related too. -- vila 2012-01-04
3566
def __init__(self, store, location):
3567
super(StartingPathMatcher, self).__init__(store)
3568
if location.startswith('file://'):
3569
location = urlutils.local_path_from_url(location)
3570
self.location = location
3572
def get_sections(self):
3573
"""Get all sections matching ``location`` in the store.
3575
The most generic sections are described first in the store, then more
3576
specific ones can be provided for reduced scopes.
3578
The returned section are therefore returned in the reversed order so
3579
the most specific ones can be found first.
3581
location_parts = self.location.rstrip('/').split('/')
3583
# Later sections are more specific, they should be returned first
3584
for _, section in reversed(list(store.get_sections())):
3585
if section.id is None:
3586
# The no-name section is always included if present
3587
yield store, LocationSection(section, self.location)
3589
section_path = section.id
3590
if section_path.startswith('file://'):
3591
# the location is already a local path or URL, convert the
3592
# section id to the same format
3593
section_path = urlutils.local_path_from_url(section_path)
3594
if (self.location.startswith(section_path)
3595
or fnmatch.fnmatch(self.location, section_path)):
3596
section_parts = section_path.rstrip('/').split('/')
3597
extra_path = '/'.join(location_parts[len(section_parts):])
3598
yield store, LocationSection(section, extra_path)
3601
class LocationMatcher(SectionMatcher):
3603
def __init__(self, store, location):
3604
super(LocationMatcher, self).__init__(store)
3605
url, params = urlutils.split_segment_parameters(location)
3606
if location.startswith('file://'):
3607
location = urlutils.local_path_from_url(location)
3608
self.location = location
3609
branch_name = params.get('branch')
3610
if branch_name is None:
3611
self.branch_name = urlutils.basename(self.location)
3613
self.branch_name = urlutils.unescape(branch_name)
3615
def _get_matching_sections(self):
3616
"""Get all sections matching ``location``."""
3617
# We slightly diverge from LocalConfig here by allowing the no-name
3618
# section as the most generic one and the lower priority.
3619
no_name_section = None
3621
# Filter out the no_name_section so _iter_for_location_by_parts can be
3622
# used (it assumes all sections have a name).
3623
for _, section in self.store.get_sections():
3624
if section.id is None:
3625
no_name_section = section
3627
all_sections.append(section)
3628
# Unfortunately _iter_for_location_by_parts deals with section names so
3629
# we have to resync.
3630
filtered_sections = _iter_for_location_by_parts(
3631
[s.id for s in all_sections], self.location)
3632
iter_all_sections = iter(all_sections)
3633
matching_sections = []
3634
if no_name_section is not None:
3635
matching_sections.append(
3636
(0, LocationSection(no_name_section, self.location)))
3637
for section_id, extra_path, length in filtered_sections:
3638
# a section id is unique for a given store so it's safe to take the
3639
# first matching section while iterating. Also, all filtered
3640
# sections are part of 'all_sections' and will always be found
3643
section = next(iter_all_sections)
3644
if section_id == section.id:
3645
section = LocationSection(section, extra_path,
3647
matching_sections.append((length, section))
3649
return matching_sections
3651
def get_sections(self):
3652
# Override the default implementation as we want to change the order
3653
# We want the longest (aka more specific) locations first
3654
sections = sorted(self._get_matching_sections(),
3655
key=lambda match: (match[0], match[1].id),
3657
# Sections mentioning 'ignore_parents' restrict the selection
3658
for _, section in sections:
3659
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3660
ignore = section.get('ignore_parents', None)
3661
if ignore is not None:
3662
ignore = ui.bool_from_string(ignore)
3665
# Finally, we have a valid section
3666
yield self.store, section
3669
# FIXME: _shared_stores should be an attribute of a library state once a
3670
# library_state object is always available.
3672
_shared_stores_at_exit_installed = False
3674
class Stack(object):
3675
"""A stack of configurations where an option can be defined"""
3677
def __init__(self, sections_def, store=None, mutable_section_id=None):
3678
"""Creates a stack of sections with an optional store for changes.
3680
:param sections_def: A list of Section or callables that returns an
3681
iterable of Section. This defines the Sections for the Stack and
3682
can be called repeatedly if needed.
3684
:param store: The optional Store where modifications will be
3685
recorded. If none is specified, no modifications can be done.
3687
:param mutable_section_id: The id of the MutableSection where changes
3688
are recorded. This requires the ``store`` parameter to be
3691
self.sections_def = sections_def
3693
self.mutable_section_id = mutable_section_id
3695
def iter_sections(self):
3696
"""Iterate all the defined sections."""
3697
# Ensuring lazy loading is achieved by delaying section matching (which
3698
# implies querying the persistent storage) until it can't be avoided
3699
# anymore by using callables to describe (possibly empty) section
3701
for sections in self.sections_def:
3702
for store, section in sections():
3703
yield store, section
3705
def get(self, name, expand=True, convert=True):
3706
"""Return the *first* option value found in the sections.
3708
This is where we guarantee that sections coming from Store are loaded
3709
lazily: the loading is delayed until we need to either check that an
3710
option exists or get its value, which in turn may require to discover
3711
in which sections it can be defined. Both of these (section and option
3712
existence) require loading the store (even partially).
3714
:param name: The queried option.
3716
:param expand: Whether options references should be expanded.
3718
:param convert: Whether the option value should be converted from
3719
unicode (do nothing for non-registered options).
3721
:returns: The value of the option.
3723
# FIXME: No caching of options nor sections yet -- vila 20110503
3725
found_store = None # Where the option value has been found
3726
# If the option is registered, it may provide additional info about
3729
opt = option_registry.get(name)
3734
def expand_and_convert(val):
3735
# This may need to be called in different contexts if the value is
3736
# None or ends up being None during expansion or conversion.
3739
if isinstance(val, string_types):
3740
val = self._expand_options_in_string(val)
3742
trace.warning('Cannot expand "%s":'
3743
' %s does not support option expansion'
3744
% (name, type(val)))
3746
val = found_store.unquote(val)
3748
val = opt.convert_from_unicode(found_store, val)
3751
# First of all, check if the environment can override the configuration
3753
if opt is not None and opt.override_from_env:
3754
value = opt.get_override()
3755
value = expand_and_convert(value)
3757
for store, section in self.iter_sections():
3758
value = section.get(name)
3759
if value is not None:
3762
value = expand_and_convert(value)
3763
if opt is not None and value is None:
3764
# If the option is registered, it may provide a default value
3765
value = opt.get_default()
3766
value = expand_and_convert(value)
3767
for hook in ConfigHooks['get']:
3768
hook(self, name, value)
3771
def expand_options(self, string, env=None):
3772
"""Expand option references in the string in the configuration context.
3774
:param string: The string containing option(s) to expand.
3776
:param env: An option dict defining additional configuration options or
3777
overriding existing ones.
3779
:returns: The expanded string.
3781
return self._expand_options_in_string(string, env)
3783
def _expand_options_in_string(self, string, env=None, _refs=None):
3784
"""Expand options in the string in the configuration context.
3786
:param string: The string to be expanded.
3788
:param env: An option dict defining additional configuration options or
3789
overriding existing ones.
3791
:param _refs: Private list (FIFO) containing the options being expanded
3794
:returns: The expanded string.
3797
# Not much to expand there
3800
# What references are currently resolved (to detect loops)
3803
# We need to iterate until no more refs appear ({{foo}} will need two
3804
# iterations for example).
3809
for is_ref, chunk in iter_option_refs(result):
3811
chunks.append(chunk)
3816
raise OptionExpansionLoop(string, _refs)
3818
value = self._expand_option(name, env, _refs)
3820
raise ExpandingUnknownOption(name, string)
3821
chunks.append(value)
3823
result = ''.join(chunks)
3826
def _expand_option(self, name, env, _refs):
3827
if env is not None and name in env:
3828
# Special case, values provided in env takes precedence over
3832
value = self.get(name, expand=False, convert=False)
3833
value = self._expand_options_in_string(value, env, _refs)
3836
def _get_mutable_section(self):
3837
"""Get the MutableSection for the Stack.
3839
This is where we guarantee that the mutable section is lazily loaded:
3840
this means we won't load the corresponding store before setting a value
3841
or deleting an option. In practice the store will often be loaded but
3842
this helps catching some programming errors.
3845
section = store.get_mutable_section(self.mutable_section_id)
3846
return store, section
3848
def set(self, name, value):
3849
"""Set a new value for the option."""
3850
store, section = self._get_mutable_section()
3851
section.set(name, store.quote(value))
3852
for hook in ConfigHooks['set']:
3853
hook(self, name, value)
3855
def remove(self, name):
3856
"""Remove an existing option."""
3857
_, section = self._get_mutable_section()
3858
section.remove(name)
3859
for hook in ConfigHooks['remove']:
3863
# Mostly for debugging use
3864
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3866
def _get_overrides(self):
3867
if breezy._global_state is not None:
3868
# TODO(jelmer): Urgh, this is circular so we can't call breezy.get_global_state()
3869
return breezy._global_state.cmdline_overrides.get_sections()
3872
def get_shared_store(self, store, state=None):
3873
"""Get a known shared store.
3875
Store urls uniquely identify them and are used to ensure a single copy
3876
is shared across all users.
3878
:param store: The store known to the caller.
3880
:param state: The library state where the known stores are kept.
3882
:returns: The store received if it's not a known one, an already known
3886
# TODO(jelmer): Urgh, this is circular so we can't call breezy.get_global_state()
3887
state = breezy._global_state
3889
global _shared_stores_at_exit_installed
3890
stores = _shared_stores
3891
def save_config_changes():
3892
for k, store in stores.items():
3893
store.save_changes()
3894
if not _shared_stores_at_exit_installed:
3895
# FIXME: Ugly hack waiting for library_state to always be
3896
# available. -- vila 20120731
3898
atexit.register(save_config_changes)
3899
_shared_stores_at_exit_installed = True
3901
stores = state.config_stores
3902
url = store.external_url()
3910
class MemoryStack(Stack):
3911
"""A configuration stack defined from a string.
3913
This is mainly intended for tests and requires no disk resources.
3916
def __init__(self, content=None):
3917
"""Create an in-memory stack from a given content.
3919
It uses a single store based on configobj and support reading and
3922
:param content: The initial content of the store. If None, the store is
3923
not loaded and ``_load_from_string`` can and should be used if
3926
store = IniFileStore()
3927
if content is not None:
3928
store._load_from_string(content)
3929
super(MemoryStack, self).__init__(
3930
[store.get_sections], store)
3933
class _CompatibleStack(Stack):
3934
"""Place holder for compatibility with previous design.
3936
This is intended to ease the transition from the Config-based design to the
3937
Stack-based design and should not be used nor relied upon by plugins.
3939
One assumption made here is that the daughter classes will all use Stores
3940
derived from LockableIniFileStore).
3942
It implements set() and remove () by re-loading the store before applying
3943
the modification and saving it.
3945
The long term plan being to implement a single write by store to save
3946
all modifications, this class should not be used in the interim.
3949
def set(self, name, value):
3952
super(_CompatibleStack, self).set(name, value)
3953
# Force a write to persistent storage
3956
def remove(self, name):
3959
super(_CompatibleStack, self).remove(name)
3960
# Force a write to persistent storage
3964
class GlobalStack(Stack):
3965
"""Global options only stack.
3967
The following sections are queried:
3969
* command-line overrides,
3971
* the 'DEFAULT' section in bazaar.conf
3973
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3978
gstore = self.get_shared_store(GlobalStore())
3979
super(GlobalStack, self).__init__(
3980
[self._get_overrides,
3981
NameMatcher(gstore, 'DEFAULT').get_sections],
3982
gstore, mutable_section_id='DEFAULT')
3985
class LocationStack(Stack):
3986
"""Per-location options falling back to global options stack.
3989
The following sections are queried:
3991
* command-line overrides,
3993
* the sections matching ``location`` in ``locations.conf``, the order being
3994
defined by the number of path components in the section glob, higher
3995
numbers first (from most specific section to most generic).
3997
* the 'DEFAULT' section in bazaar.conf
3999
This stack will use the ``location`` section in locations.conf as its
4003
def __init__(self, location):
4004
"""Make a new stack for a location and global configuration.
4006
:param location: A URL prefix to """
4007
lstore = self.get_shared_store(LocationStore())
4008
if location.startswith('file://'):
4009
location = urlutils.local_path_from_url(location)
4010
gstore = self.get_shared_store(GlobalStore())
4011
super(LocationStack, self).__init__(
4012
[self._get_overrides,
4013
LocationMatcher(lstore, location).get_sections,
4014
NameMatcher(gstore, 'DEFAULT').get_sections],
4015
lstore, mutable_section_id=location)
4018
class BranchStack(Stack):
4019
"""Per-location options falling back to branch then global options stack.
4021
The following sections are queried:
4023
* command-line overrides,
4025
* the sections matching ``location`` in ``locations.conf``, the order being
4026
defined by the number of path components in the section glob, higher
4027
numbers first (from most specific section to most generic),
4029
* the no-name section in branch.conf,
4031
* the ``DEFAULT`` section in ``bazaar.conf``.
4033
This stack will use the no-name section in ``branch.conf`` as its
4037
def __init__(self, branch):
4038
lstore = self.get_shared_store(LocationStore())
4039
bstore = branch._get_config_store()
4040
gstore = self.get_shared_store(GlobalStore())
4041
super(BranchStack, self).__init__(
4042
[self._get_overrides,
4043
LocationMatcher(lstore, branch.base).get_sections,
4044
NameMatcher(bstore, None).get_sections,
4045
NameMatcher(gstore, 'DEFAULT').get_sections],
4047
self.branch = branch
4049
def lock_write(self, token=None):
4050
return self.branch.lock_write(token)
4053
return self.branch.unlock()
4055
def set(self, name, value):
4056
with self.lock_write():
4057
super(BranchStack, self).set(name, value)
4058
# Unlocking the branch will trigger a store.save_changes() so the
4059
# last unlock saves all the changes.
4061
def remove(self, name):
4062
with self.lock_write():
4063
super(BranchStack, self).remove(name)
4064
# Unlocking the branch will trigger a store.save_changes() so the
4065
# last unlock saves all the changes.
4068
class RemoteControlStack(Stack):
4069
"""Remote control-only options stack."""
4071
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4072
# with the stack used for remote bzr dirs. RemoteControlStack only uses
4073
# control.conf and is used only for stack options.
4075
def __init__(self, bzrdir):
4076
cstore = bzrdir._get_config_store()
4077
super(RemoteControlStack, self).__init__(
4078
[NameMatcher(cstore, None).get_sections],
4080
self.controldir = bzrdir
4083
class BranchOnlyStack(Stack):
4084
"""Branch-only options stack."""
4086
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4087
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4088
# -- vila 2011-12-16
4090
def __init__(self, branch):
4091
bstore = branch._get_config_store()
4092
super(BranchOnlyStack, self).__init__(
4093
[NameMatcher(bstore, None).get_sections],
4095
self.branch = branch
4097
def lock_write(self, token=None):
4098
return self.branch.lock_write(token)
4101
return self.branch.unlock()
4103
def set(self, name, value):
4104
with self.lock_write():
4105
super(BranchOnlyStack, self).set(name, value)
4106
# Force a write to persistent storage
4107
self.store.save_changes()
4109
def remove(self, name):
4110
with self.lock_write():
4111
super(BranchOnlyStack, self).remove(name)
4112
# Force a write to persistent storage
4113
self.store.save_changes()
4116
class cmd_config(commands.Command):
4117
__doc__ = """Display, set or remove a configuration option.
4119
Display the active value for option NAME.
4121
If --all is specified, NAME is interpreted as a regular expression and all
4122
matching options are displayed mentioning their scope and without resolving
4123
option references in the value). The active value that bzr will take into
4124
account is the first one displayed for each option.
4126
If NAME is not given, --all .* is implied (all options are displayed for the
4129
Setting a value is achieved by using NAME=value without spaces. The value
4130
is set in the most relevant scope and can be checked by displaying the
4133
Removing a value is achieved by using --remove NAME.
4136
takes_args = ['name?']
4140
# FIXME: This should be a registry option so that plugins can register
4141
# their own config files (or not) and will also address
4142
# http://pad.lv/788991 -- vila 20101115
4143
commands.Option('scope', help='Reduce the scope to the specified'
4144
' configuration file.',
4146
commands.Option('all',
4147
help='Display all the defined values for the matching options.',
4149
commands.Option('remove', help='Remove the option from'
4150
' the configuration file.'),
4153
_see_also = ['configuration']
4155
@commands.display_command
4156
def run(self, name=None, all=False, directory=None, scope=None,
4158
if directory is None:
4160
directory = directory_service.directories.dereference(directory)
4161
directory = urlutils.normalize_url(directory)
4163
raise errors.BzrError(
4164
'--all and --remove are mutually exclusive.')
4166
# Delete the option in the given scope
4167
self._remove_config_option(name, directory, scope)
4169
# Defaults to all options
4170
self._show_matching_options('.*', directory, scope)
4173
name, value = name.split('=', 1)
4175
# Display the option(s) value(s)
4177
self._show_matching_options(name, directory, scope)
4179
self._show_value(name, directory, scope)
4182
raise errors.BzrError(
4183
'Only one option can be set.')
4184
# Set the option value
4185
self._set_config_option(name, value, directory, scope)
4187
def _get_stack(self, directory, scope=None, write_access=False):
4188
"""Get the configuration stack specified by ``directory`` and ``scope``.
4190
:param directory: Where the configurations are derived from.
4192
:param scope: A specific config to start from.
4194
:param write_access: Whether a write access to the stack will be
4197
# FIXME: scope should allow access to plugin-specific stacks (even
4198
# reduced to the plugin-specific store), related to
4199
# http://pad.lv/788991 -- vila 2011-11-15
4200
if scope is not None:
4201
if scope == 'breezy':
4202
return GlobalStack()
4203
elif scope == 'locations':
4204
return LocationStack(directory)
4205
elif scope == 'branch':
4207
controldir.ControlDir.open_containing_tree_or_branch(
4210
self.add_cleanup(br.lock_write().unlock)
4211
return br.get_config_stack()
4212
raise NoSuchConfig(scope)
4216
controldir.ControlDir.open_containing_tree_or_branch(
4219
self.add_cleanup(br.lock_write().unlock)
4220
return br.get_config_stack()
4221
except errors.NotBranchError:
4222
return LocationStack(directory)
4224
def _quote_multiline(self, value):
4226
value = '"""' + value + '"""'
4229
def _show_value(self, name, directory, scope):
4230
conf = self._get_stack(directory, scope)
4231
value = conf.get(name, expand=True, convert=False)
4232
if value is not None:
4233
# Quote the value appropriately
4234
value = self._quote_multiline(value)
4235
self.outf.write('%s\n' % (value,))
4237
raise NoSuchConfigOption(name)
4239
def _show_matching_options(self, name, directory, scope):
4240
name = lazy_regex.lazy_compile(name)
4241
# We want any error in the regexp to be raised *now* so we need to
4242
# avoid the delay introduced by the lazy regexp. But, we still do
4243
# want the nicer errors raised by lazy_regex.
4244
name._compile_and_collapse()
4247
conf = self._get_stack(directory, scope)
4248
for store, section in conf.iter_sections():
4249
for oname in section.iter_option_names():
4250
if name.search(oname):
4251
if cur_store_id != store.id:
4252
# Explain where the options are defined
4253
self.outf.write('%s:\n' % (store.id,))
4254
cur_store_id = store.id
4256
if (section.id is not None and cur_section != section.id):
4257
# Display the section id as it appears in the store
4258
# (None doesn't appear by definition)
4259
self.outf.write(' [%s]\n' % (section.id,))
4260
cur_section = section.id
4261
value = section.get(oname, expand=False)
4262
# Quote the value appropriately
4263
value = self._quote_multiline(value)
4264
self.outf.write(' %s = %s\n' % (oname, value))
4266
def _set_config_option(self, name, value, directory, scope):
4267
conf = self._get_stack(directory, scope, write_access=True)
4268
conf.set(name, value)
4269
# Explicitly save the changes
4270
conf.store.save_changes()
4272
def _remove_config_option(self, name, directory, scope):
4274
raise errors.BzrCommandError(
4275
'--remove expects an option to remove.')
4276
conf = self._get_stack(directory, scope, write_access=True)
4279
# Explicitly save the changes
4280
conf.store.save_changes()
4282
raise NoSuchConfigOption(name)
4287
# We need adapters that can build a Store or a Stack in a test context. Test
4288
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4289
# themselves. The builder will receive a test instance and should return a
4290
# ready-to-use store or stack. Plugins that define new store/stacks can also
4291
# register themselves here to be tested against the tests defined in
4292
# breezy.tests.test_config. Note that the builder can be called multiple times
4293
# for the same test.
4295
# The registered object should be a callable receiving a test instance
4296
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4298
test_store_builder_registry = registry.Registry()
4300
# The registered object should be a callable receiving a test instance
4301
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4303
test_stack_builder_registry = registry.Registry()
added
removed
breezy/config.py
