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
57
check_signatures 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(), """
107
from breezy.i18n import gettext
116
from .sixish import (
125
CHECK_IF_POSSIBLE = 0
130
SIGN_WHEN_REQUIRED = 0
137
POLICY_APPENDPATH = 2
141
POLICY_NORECURSE: 'norecurse',
142
POLICY_APPENDPATH: 'appendpath',
147
'norecurse': POLICY_NORECURSE,
148
'appendpath': POLICY_APPENDPATH,
152
STORE_LOCATION = POLICY_NONE
153
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
154
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
159
class OptionExpansionLoop(errors.BzrError):
161
_fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
163
def __init__(self, string, refs):
165
self.refs = '->'.join(refs)
168
class ExpandingUnknownOption(errors.BzrError):
170
_fmt = 'Option "%(name)s" is not defined while expanding "%(string)s".'
172
def __init__(self, name, string):
177
class IllegalOptionName(errors.BzrError):
179
_fmt = 'Option "%(name)s" is not allowed.'
181
def __init__(self, name):
185
class ConfigContentError(errors.BzrError):
187
_fmt = "Config file %(filename)s is not UTF-8 encoded\n"
189
def __init__(self, filename):
190
self.filename = filename
193
class ParseConfigError(errors.BzrError):
195
_fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
197
def __init__(self, errors, filename):
198
self.filename = filename
199
self.errors = '\n'.join(e.msg for e in errors)
202
class ConfigOptionValueError(errors.BzrError):
204
_fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
205
'See ``brz help %(name)s``')
207
def __init__(self, name, value):
208
errors.BzrError.__init__(self, name=name, value=value)
211
class NoEmailInUsername(errors.BzrError):
213
_fmt = "%(username)r does not seem to contain a reasonable email address"
215
def __init__(self, username):
216
self.username = username
219
class NoSuchConfig(errors.BzrError):
221
_fmt = ('The "%(config_id)s" configuration does not exist.')
223
def __init__(self, config_id):
224
errors.BzrError.__init__(self, config_id=config_id)
227
class NoSuchConfigOption(errors.BzrError):
229
_fmt = ('The "%(option_name)s" configuration option does not exist.')
231
def __init__(self, option_name):
232
errors.BzrError.__init__(self, option_name=option_name)
235
class NoWhoami(errors.BzrError):
237
_fmt = ('Unable to determine your name.\n'
238
"Please, set your name with the 'whoami' command.\n"
239
'E.g. brz whoami "Your Name <name@example.com>"')
242
def signature_policy_from_unicode(signature_string):
243
"""Convert a string to a signing policy."""
244
if signature_string.lower() == 'check-available':
245
return CHECK_IF_POSSIBLE
246
if signature_string.lower() == 'ignore':
248
if signature_string.lower() == 'require':
250
raise ValueError("Invalid signatures policy '%s'"
254
def signing_policy_from_unicode(signature_string):
255
"""Convert a string to a signing policy."""
256
if signature_string.lower() == 'when-required':
257
return SIGN_WHEN_REQUIRED
258
if signature_string.lower() == 'never':
260
if signature_string.lower() == 'always':
262
raise ValueError("Invalid signing policy '%s'"
266
def _has_decode_bug():
267
"""True if configobj will fail to decode to unicode on Python 2."""
268
if sys.version_info > (3,):
270
conf = configobj.ConfigObj()
271
decode = getattr(conf, "_decode", None)
273
result = decode(b"\xc2\xa7", "utf-8")
274
if isinstance(result[0], str):
279
def _has_triplequote_bug():
280
"""True if triple quote logic is reversed, see lp:710410."""
281
conf = configobj.ConfigObj()
282
quote = getattr(conf, "_get_triple_quote", None)
283
if quote and quote('"""') != "'''":
288
class ConfigObj(configobj.ConfigObj):
290
def __init__(self, infile=None, **kwargs):
291
# We define our own interpolation mechanism calling it option expansion
292
super(ConfigObj, self).__init__(infile=infile,
296
if _has_decode_bug():
297
def _decode(self, infile, encoding):
298
if isinstance(infile, str) and encoding:
299
return infile.decode(encoding).splitlines(True)
300
return super(ConfigObj, self)._decode(infile, encoding)
302
if _has_triplequote_bug():
303
def _get_triple_quote(self, value):
304
quot = super(ConfigObj, self)._get_triple_quote(value)
305
if quot == configobj.tdquot:
306
return configobj.tsquot
307
return configobj.tdquot
309
def get_bool(self, section, key):
310
return self[section].as_bool(key)
312
def get_value(self, section, name):
313
# Try [] for the old DEFAULT section.
314
if section == "DEFAULT":
319
return self[section][name]
322
class Config(object):
323
"""A configuration policy - what username, editor, gpg needs etc."""
326
super(Config, self).__init__()
329
"""Returns a unique ID for the config."""
330
raise NotImplementedError(self.config_id)
332
def get_change_editor(self, old_tree, new_tree):
333
from breezy import diff
334
cmd = self._get_change_editor()
337
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
340
def _get_signature_checking(self):
341
"""Template method to override signature checking policy."""
343
def _get_signing_policy(self):
344
"""Template method to override signature creation policy."""
348
def expand_options(self, string, env=None):
349
"""Expand option references in the string in the configuration context.
351
:param string: The string containing option to expand.
353
:param env: An option dict defining additional configuration options or
354
overriding existing ones.
356
:returns: The expanded string.
358
return self._expand_options_in_string(string, env)
360
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
361
"""Expand options in a list of strings in the configuration context.
363
:param slist: A list of strings.
365
:param env: An option dict defining additional configuration options or
366
overriding existing ones.
368
:param _ref_stack: Private list containing the options being
369
expanded to detect loops.
371
:returns: The flatten list of expanded strings.
373
# expand options in each value separately flattening lists
376
value = self._expand_options_in_string(s, env, _ref_stack)
377
if isinstance(value, list):
383
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
384
"""Expand options in the string in the configuration context.
386
:param string: The string to be expanded.
388
:param env: An option dict defining additional configuration options or
389
overriding existing ones.
391
:param _ref_stack: Private list containing the options being
392
expanded to detect loops.
394
:returns: The expanded string.
397
# Not much to expand there
399
if _ref_stack is None:
400
# What references are currently resolved (to detect loops)
402
if self.option_ref_re is None:
403
# We want to match the most embedded reference first (i.e. for
404
# '{{foo}}' we will get '{foo}',
405
# for '{bar{baz}}' we will get '{baz}'
406
self.option_ref_re = re.compile('({[^{}]+})')
408
# We need to iterate until no more refs appear ({{foo}} will need two
409
# iterations for example).
411
raw_chunks = self.option_ref_re.split(result)
412
if len(raw_chunks) == 1:
413
# Shorcut the trivial case: no refs
417
# Split will isolate refs so that every other chunk is a ref
419
for chunk in raw_chunks:
422
# Keep only non-empty strings (or we get bogus empty
423
# slots when a list value is involved).
428
if name in _ref_stack:
429
raise OptionExpansionLoop(string, _ref_stack)
430
_ref_stack.append(name)
431
value = self._expand_option(name, env, _ref_stack)
433
raise ExpandingUnknownOption(name, string)
434
if isinstance(value, list):
442
# Once a list appears as the result of an expansion, all
443
# callers will get a list result. This allows a consistent
444
# behavior even when some options in the expansion chain
445
# defined as strings (no comma in their value) but their
446
# expanded value is a list.
447
return self._expand_options_in_list(chunks, env, _ref_stack)
449
result = ''.join(chunks)
452
def _expand_option(self, name, env, _ref_stack):
453
if env is not None and name in env:
454
# Special case, values provided in env takes precedence over
458
# FIXME: This is a limited implementation, what we really need is a
459
# way to query the brz config for the value of an option,
460
# respecting the scope rules (That is, once we implement fallback
461
# configs, getting the option value should restart from the top
462
# config, not the current one) -- vila 20101222
463
value = self.get_user_option(name, expand=False)
464
if isinstance(value, list):
465
value = self._expand_options_in_list(value, env, _ref_stack)
467
value = self._expand_options_in_string(value, env, _ref_stack)
470
def _get_user_option(self, option_name):
471
"""Template method to provide a user option."""
474
def get_user_option(self, option_name, expand=True):
475
"""Get a generic option - no special process, no default.
477
:param option_name: The queried option.
479
:param expand: Whether options references should be expanded.
481
:returns: The value of the option.
483
value = self._get_user_option(option_name)
485
if isinstance(value, list):
486
value = self._expand_options_in_list(value)
487
elif isinstance(value, dict):
488
trace.warning('Cannot expand "%s":'
489
' Dicts do not support option expansion'
492
value = self._expand_options_in_string(value)
493
for hook in OldConfigHooks['get']:
494
hook(self, option_name, value)
497
def get_user_option_as_bool(self, option_name, expand=None, default=None):
498
"""Get a generic option as a boolean.
500
:param expand: Allow expanding references to other config values.
501
:param default: Default value if nothing is configured
502
:return None if the option doesn't exist or its value can't be
503
interpreted as a boolean. Returns True or False otherwise.
505
s = self.get_user_option(option_name, expand=expand)
507
# The option doesn't exist
509
val = ui.bool_from_string(s)
511
# The value can't be interpreted as a boolean
512
trace.warning('Value "%s" is not a boolean for "%s"',
516
def get_user_option_as_list(self, option_name, expand=None):
517
"""Get a generic option as a list - no special process, no default.
519
:return None if the option doesn't exist. Returns the value as a list
522
l = self.get_user_option(option_name, expand=expand)
523
if isinstance(l, string_types):
524
# A single value, most probably the user forgot (or didn't care to
529
def _log_format(self):
530
"""See log_format()."""
533
def validate_signatures_in_log(self):
534
"""Show GPG signature validity in log"""
535
result = self._validate_signatures_in_log()
542
def _validate_signatures_in_log(self):
543
"""See validate_signatures_in_log()."""
546
def _post_commit(self):
547
"""See Config.post_commit."""
550
def user_email(self):
551
"""Return just the email component of a username."""
552
return extract_email_address(self.username())
555
"""Return email-style username.
557
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
559
$BRZ_EMAIL can be set to override this, then
560
the concrete policy type is checked, and finally
562
If no username can be found, NoWhoami exception is raised.
564
v = os.environ.get('BRZ_EMAIL')
567
v = v.decode(osutils.get_user_encoding())
569
v = self._get_user_id()
572
return default_email()
574
def ensure_username(self):
575
"""Raise NoWhoami if username is not set.
577
This method relies on the username() function raising the error.
581
def get_alias(self, value):
582
return self._get_alias(value)
584
def _get_alias(self, value):
587
def get_nickname(self):
588
return self._get_nickname()
590
def _get_nickname(self):
593
def get_bzr_remote_path(self):
595
return os.environ['BZR_REMOTE_PATH']
597
path = self.get_user_option("bzr_remote_path")
602
def suppress_warning(self, warning):
603
"""Should the warning be suppressed or emitted.
605
:param warning: The name of the warning being tested.
607
:returns: True if the warning should be suppressed, False otherwise.
609
warnings = self.get_user_option_as_list('suppress_warnings')
610
if warnings is None or warning not in warnings:
615
def get_merge_tools(self):
617
for (oname, value, section, conf_id, parser) in self._get_options():
618
if oname.startswith('bzr.mergetool.'):
619
tool_name = oname[len('bzr.mergetool.'):]
620
tools[tool_name] = self.get_user_option(oname, False)
621
trace.mutter('loaded merge tools: %r' % tools)
624
def find_merge_tool(self, name):
625
# We fake a defaults mechanism here by checking if the given name can
626
# be found in the known_merge_tools if it's not found in the config.
627
# This should be done through the proposed config defaults mechanism
628
# when it becomes available in the future.
629
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
631
mergetools.known_merge_tools.get(name, None))
635
class _ConfigHooks(hooks.Hooks):
636
"""A dict mapping hook names and a list of callables for configs.
640
"""Create the default hooks.
642
These are all empty initially, because by default nothing should get
645
super(_ConfigHooks, self).__init__('breezy.config', 'ConfigHooks')
646
self.add_hook('load',
647
'Invoked when a config store is loaded.'
648
' The signature is (store).',
650
self.add_hook('save',
651
'Invoked when a config store is saved.'
652
' The signature is (store).',
654
# The hooks for config options
656
'Invoked when a config option is read.'
657
' The signature is (stack, name, value).',
660
'Invoked when a config option is set.'
661
' The signature is (stack, name, value).',
663
self.add_hook('remove',
664
'Invoked when a config option is removed.'
665
' 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__(
683
'breezy.config', 'OldConfigHooks')
684
self.add_hook('load',
685
'Invoked when a config store is loaded.'
686
' The signature is (config).',
688
self.add_hook('save',
689
'Invoked when a config store is saved.'
690
' The signature is (config).',
692
# The hooks for config options
694
'Invoked when a config option is read.'
695
' The signature is (config, name, value).',
698
'Invoked when a config option is set.'
699
' The signature is (config, name, value).',
701
self.add_hook('remove',
702
'Invoked when a config option is removed.'
703
' The signature is (config, name).',
707
OldConfigHooks = _OldConfigHooks()
710
class IniBasedConfig(Config):
711
"""A configuration policy that draws from ini files."""
713
def __init__(self, file_name=None):
714
"""Base class for configuration files using an ini-like syntax.
716
:param file_name: The configuration file path.
718
super(IniBasedConfig, self).__init__()
719
self.file_name = file_name
720
self.file_name = file_name
725
def from_string(cls, str_or_unicode, file_name=None, save=False):
726
"""Create a config object from a string.
728
:param str_or_unicode: A string representing the file content. This
729
will be utf-8 encoded.
731
:param file_name: The configuration file path.
733
:param _save: Whether the file should be saved upon creation.
735
conf = cls(file_name=file_name)
736
conf._create_from_string(str_or_unicode, save)
739
def _create_from_string(self, str_or_unicode, save):
740
if isinstance(str_or_unicode, text_type):
741
str_or_unicode = str_or_unicode.encode('utf-8')
742
self._content = BytesIO(str_or_unicode)
743
# Some tests use in-memory configs, some other always need the config
744
# file to exist on disk.
746
self._write_config_file()
748
def _get_parser(self):
749
if self._parser is not None:
751
if self._content is not None:
752
co_input = self._content
753
elif self.file_name is None:
754
raise AssertionError('We have no content to create the config')
756
co_input = self.file_name
758
self._parser = ConfigObj(co_input, encoding='utf-8')
759
except configobj.ConfigObjError as e:
760
raise ParseConfigError(e.errors, e.config.filename)
761
except UnicodeDecodeError:
762
raise ConfigContentError(self.file_name)
763
# Make sure self.reload() will use the right file name
764
self._parser.filename = self.file_name
765
for hook in OldConfigHooks['load']:
770
"""Reload the config file from disk."""
771
if self.file_name is None:
772
raise AssertionError('We need a file name to reload the config')
773
if self._parser is not None:
774
self._parser.reload()
775
for hook in ConfigHooks['load']:
778
def _get_matching_sections(self):
779
"""Return an ordered list of (section_name, extra_path) pairs.
781
If the section contains inherited configuration, extra_path is
782
a string containing the additional path components.
784
section = self._get_section()
785
if section is not None:
786
return [(section, '')]
790
def _get_section(self):
791
"""Override this to define the section used by the config."""
794
def _get_sections(self, name=None):
795
"""Returns an iterator of the sections specified by ``name``.
797
:param name: The section name. If None is supplied, the default
798
configurations are yielded.
800
:return: A tuple (name, section, config_id) for all sections that will
801
be walked by user_get_option() in the 'right' order. The first one
802
is where set_user_option() will update the value.
804
parser = self._get_parser()
806
yield (name, parser[name], self.config_id())
808
# No section name has been given so we fallback to the configobj
809
# itself which holds the variables defined outside of any section.
810
yield (None, parser, self.config_id())
812
def _get_options(self, sections=None):
813
"""Return an ordered list of (name, value, section, config_id) tuples.
815
All options are returned with their associated value and the section
816
they appeared in. ``config_id`` is a unique identifier for the
817
configuration file the option is defined in.
819
:param sections: Default to ``_get_matching_sections`` if not
820
specified. This gives a better control to daughter classes about
821
which sections should be searched. This is a list of (name,
825
parser = self._get_parser()
827
for (section_name, _) in self._get_matching_sections():
829
section = parser[section_name]
831
# This could happen for an empty file for which we define a
832
# DEFAULT section. FIXME: Force callers to provide sections
833
# instead ? -- vila 20100930
835
sections.append((section_name, section))
836
config_id = self.config_id()
837
for (section_name, section) in sections:
838
for (name, value) in section.iteritems():
839
yield (name, parser._quote(value), section_name,
842
def _get_option_policy(self, section, option_name):
843
"""Return the policy for the given (section, option_name) pair."""
846
def _get_change_editor(self):
847
return self.get_user_option('change_editor')
849
def _get_signature_checking(self):
850
"""See Config._get_signature_checking."""
851
policy = self._get_user_option('check_signatures')
853
return signature_policy_from_unicode(policy)
855
def _get_signing_policy(self):
856
"""See Config._get_signing_policy"""
857
policy = self._get_user_option('create_signatures')
859
return signing_policy_from_unicode(policy)
861
def _get_user_id(self):
862
"""Get the user id from the 'email' key in the current section."""
863
return self._get_user_option('email')
865
def _get_user_option(self, option_name):
866
"""See Config._get_user_option."""
867
for (section, extra_path) in self._get_matching_sections():
869
value = self._get_parser().get_value(section, option_name)
872
policy = self._get_option_policy(section, option_name)
873
if policy == POLICY_NONE:
875
elif policy == POLICY_NORECURSE:
876
# norecurse items only apply to the exact path
881
elif policy == POLICY_APPENDPATH:
883
value = urlutils.join(value, extra_path)
886
raise AssertionError('Unexpected config policy %r' % policy)
890
def _log_format(self):
891
"""See Config.log_format."""
892
return self._get_user_option('log_format')
894
def _validate_signatures_in_log(self):
895
"""See Config.validate_signatures_in_log."""
896
return self._get_user_option('validate_signatures_in_log')
898
def _acceptable_keys(self):
899
"""See Config.acceptable_keys."""
900
return self._get_user_option('acceptable_keys')
902
def _post_commit(self):
903
"""See Config.post_commit."""
904
return self._get_user_option('post_commit')
906
def _get_alias(self, value):
908
return self._get_parser().get_value("ALIASES",
913
def _get_nickname(self):
914
return self.get_user_option('nickname')
916
def remove_user_option(self, option_name, section_name=None):
917
"""Remove a user option and save the configuration file.
919
:param option_name: The option to be removed.
921
:param section_name: The section the option is defined in, default to
925
parser = self._get_parser()
926
if section_name is None:
929
section = parser[section_name]
931
del section[option_name]
933
raise NoSuchConfigOption(option_name)
934
self._write_config_file()
935
for hook in OldConfigHooks['remove']:
936
hook(self, option_name)
938
def _write_config_file(self):
939
if self.file_name is None:
940
raise AssertionError('We cannot save, self.file_name is None')
941
conf_dir = os.path.dirname(self.file_name)
942
ensure_config_dir_exists(conf_dir)
943
with atomicfile.AtomicFile(self.file_name) as atomic_file:
944
self._get_parser().write(atomic_file)
945
osutils.copy_ownership_from_path(self.file_name)
946
for hook in OldConfigHooks['save']:
950
class LockableConfig(IniBasedConfig):
951
"""A configuration needing explicit locking for access.
953
If several processes try to write the config file, the accesses need to be
956
Daughter classes should use the self.lock_write() decorator method when
957
they upate a config (they call, directly or indirectly, the
958
``_write_config_file()`` method. These methods (typically ``set_option()``
959
and variants must reload the config file from disk before calling
960
``_write_config_file()``), this can be achieved by calling the
961
``self.reload()`` method. Note that the lock scope should cover both the
962
reading and the writing of the config file which is why the decorator can't
963
be applied to ``_write_config_file()`` only.
965
This should be enough to implement the following logic:
966
- lock for exclusive write access,
967
- reload the config file from disk,
971
This logic guarantees that a writer can update a value without erasing an
972
update made by another writer.
977
def __init__(self, file_name):
978
super(LockableConfig, self).__init__(file_name=file_name)
979
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
980
# FIXME: It doesn't matter that we don't provide possible_transports
981
# below since this is currently used only for local config files ;
982
# local transports are not shared. But if/when we start using
983
# LockableConfig for other kind of transports, we will need to reuse
984
# whatever connection is already established -- vila 20100929
985
self.transport = transport.get_transport_from_path(self.dir)
986
self._lock = lockdir.LockDir(self.transport, self.lock_name)
988
def _create_from_string(self, unicode_bytes, save):
989
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
991
# We need to handle the saving here (as opposed to IniBasedConfig)
994
self._write_config_file()
997
def lock_write(self, token=None):
998
"""Takes a write lock in the directory containing the config file.
1000
If the directory doesn't exist it is created.
1002
ensure_config_dir_exists(self.dir)
1003
token = self._lock.lock_write(token)
1004
return lock.LogicalLockResult(self.unlock, token)
1009
def break_lock(self):
1010
self._lock.break_lock()
1012
def remove_user_option(self, option_name, section_name=None):
1013
with self.lock_write():
1014
super(LockableConfig, self).remove_user_option(
1015
option_name, section_name)
1017
def _write_config_file(self):
1018
if self._lock is None or not self._lock.is_held:
1019
# NB: if the following exception is raised it probably means a
1020
# missing call to lock_write() by one of the callers.
1021
raise errors.ObjectNotLocked(self)
1022
super(LockableConfig, self)._write_config_file()
1025
class GlobalConfig(LockableConfig):
1026
"""The configuration that should be used for a specific location."""
1029
super(GlobalConfig, self).__init__(file_name=config_filename())
1031
def config_id(self):
1035
def from_string(cls, str_or_unicode, save=False):
1036
"""Create a config object from a string.
1038
:param str_or_unicode: A string representing the file content. This
1039
will be utf-8 encoded.
1041
:param save: Whether the file should be saved upon creation.
1044
conf._create_from_string(str_or_unicode, save)
1047
def set_user_option(self, option, value):
1048
"""Save option and its value in the configuration."""
1049
with self.lock_write():
1050
self._set_option(option, value, 'DEFAULT')
1052
def get_aliases(self):
1053
"""Return the aliases section."""
1054
if 'ALIASES' in self._get_parser():
1055
return self._get_parser()['ALIASES']
1059
def set_alias(self, alias_name, alias_command):
1060
"""Save the alias in the configuration."""
1061
with self.lock_write():
1062
self._set_option(alias_name, alias_command, 'ALIASES')
1064
def unset_alias(self, alias_name):
1065
"""Unset an existing alias."""
1066
with self.lock_write():
1068
aliases = self._get_parser().get('ALIASES')
1069
if not aliases or alias_name not in aliases:
1070
raise errors.NoSuchAlias(alias_name)
1071
del aliases[alias_name]
1072
self._write_config_file()
1074
def _set_option(self, option, value, section):
1076
self._get_parser().setdefault(section, {})[option] = value
1077
self._write_config_file()
1078
for hook in OldConfigHooks['set']:
1079
hook(self, option, value)
1081
def _get_sections(self, name=None):
1082
"""See IniBasedConfig._get_sections()."""
1083
parser = self._get_parser()
1084
# We don't give access to options defined outside of any section, we
1085
# used the DEFAULT section by... default.
1086
if name in (None, 'DEFAULT'):
1087
# This could happen for an empty file where the DEFAULT section
1088
# doesn't exist yet. So we force DEFAULT when yielding
1090
if 'DEFAULT' not in parser:
1091
parser['DEFAULT'] = {}
1092
yield (name, parser[name], self.config_id())
1094
def remove_user_option(self, option_name, section_name=None):
1095
if section_name is None:
1096
# We need to force the default section.
1097
section_name = 'DEFAULT'
1098
with self.lock_write():
1099
# We need to avoid the LockableConfig implementation or we'll lock
1101
super(LockableConfig, self).remove_user_option(
1102
option_name, section_name)
1105
def _iter_for_location_by_parts(sections, location):
1106
"""Keep only the sessions matching the specified location.
1108
:param sections: An iterable of section names.
1110
:param location: An url or a local path to match against.
1112
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1113
number of path components in the section name, section is the section
1114
name and extra_path is the difference between location and the section
1117
``location`` will always be a local path and never a 'file://' url but the
1118
section names themselves can be in either form.
1120
location_parts = location.rstrip('/').split('/')
1122
for section in sections:
1123
# location is a local path if possible, so we need to convert 'file://'
1124
# urls in section names to local paths if necessary.
1126
# This also avoids having file:///path be a more exact
1127
# match than '/path'.
1129
# FIXME: This still raises an issue if a user defines both file:///path
1130
# *and* /path. Should we raise an error in this case -- vila 20110505
1132
if section.startswith('file://'):
1133
section_path = urlutils.local_path_from_url(section)
1135
section_path = section
1136
section_parts = section_path.rstrip('/').split('/')
1139
if len(section_parts) > len(location_parts):
1140
# More path components in the section, they can't match
1143
# Rely on zip truncating in length to the length of the shortest
1144
# argument sequence.
1145
for name in zip(location_parts, section_parts):
1146
if not fnmatch.fnmatch(name[0], name[1]):
1151
# build the path difference between the section and the location
1152
extra_path = '/'.join(location_parts[len(section_parts):])
1153
yield section, extra_path, len(section_parts)
1156
class LocationConfig(LockableConfig):
1157
"""A configuration object that gives the policy for a location."""
1159
def __init__(self, location):
1160
super(LocationConfig, self).__init__(
1161
file_name=locations_config_filename())
1162
# local file locations are looked up by local path, rather than
1163
# by file url. This is because the config file is a user
1164
# file, and we would rather not expose the user to file urls.
1165
if location.startswith('file://'):
1166
location = urlutils.local_path_from_url(location)
1167
self.location = location
1169
def config_id(self):
1173
def from_string(cls, str_or_unicode, location, save=False):
1174
"""Create a config object from a string.
1176
:param str_or_unicode: A string representing the file content. This will
1179
:param location: The location url to filter the configuration.
1181
:param save: Whether the file should be saved upon creation.
1183
conf = cls(location)
1184
conf._create_from_string(str_or_unicode, save)
1187
def _get_matching_sections(self):
1188
"""Return an ordered list of section names matching this location."""
1189
# put the longest (aka more specific) locations first
1191
_iter_for_location_by_parts(self._get_parser(), self.location),
1192
key=lambda match: (match[2], match[0]),
1194
for (section, extra_path, length) in matches:
1195
yield section, extra_path
1196
# should we stop looking for parent configs here?
1198
if self._get_parser()[section].as_bool('ignore_parents'):
1203
def _get_sections(self, name=None):
1204
"""See IniBasedConfig._get_sections()."""
1205
# We ignore the name here as the only sections handled are named with
1206
# the location path and we don't expose embedded sections either.
1207
parser = self._get_parser()
1208
for name, extra_path in self._get_matching_sections():
1209
yield (name, parser[name], self.config_id())
1211
def _get_option_policy(self, section, option_name):
1212
"""Return the policy for the given (section, option_name) pair."""
1213
# check for the old 'recurse=False' flag
1215
recurse = self._get_parser()[section].as_bool('recurse')
1219
return POLICY_NORECURSE
1221
policy_key = option_name + ':policy'
1223
policy_name = self._get_parser()[section][policy_key]
1227
return _policy_value[policy_name]
1229
def _set_option_policy(self, section, option_name, option_policy):
1230
"""Set the policy for the given option name in the given section."""
1231
policy_key = option_name + ':policy'
1232
policy_name = _policy_name[option_policy]
1233
if policy_name is not None:
1234
self._get_parser()[section][policy_key] = policy_name
1236
if policy_key in self._get_parser()[section]:
1237
del self._get_parser()[section][policy_key]
1239
def set_user_option(self, option, value, store=STORE_LOCATION):
1240
"""Save option and its value in the configuration."""
1241
if store not in [STORE_LOCATION,
1242
STORE_LOCATION_NORECURSE,
1243
STORE_LOCATION_APPENDPATH]:
1244
raise ValueError('bad storage policy %r for %r' %
1246
with self.lock_write():
1248
location = self.location
1249
if location.endswith('/'):
1250
location = location[:-1]
1251
parser = self._get_parser()
1252
if location not in parser and not location + '/' in parser:
1253
parser[location] = {}
1254
elif location + '/' in parser:
1255
location = location + '/'
1256
parser[location][option] = value
1257
# the allowed values of store match the config policies
1258
self._set_option_policy(location, option, store)
1259
self._write_config_file()
1260
for hook in OldConfigHooks['set']:
1261
hook(self, option, value)
1264
class BranchConfig(Config):
1265
"""A configuration object giving the policy for a branch."""
1267
def __init__(self, branch):
1268
super(BranchConfig, self).__init__()
1269
self._location_config = None
1270
self._branch_data_config = None
1271
self._global_config = None
1272
self.branch = branch
1273
self.option_sources = (self._get_location_config,
1274
self._get_branch_data_config,
1275
self._get_global_config)
1277
def config_id(self):
1280
def _get_branch_data_config(self):
1281
if self._branch_data_config is None:
1282
self._branch_data_config = TreeConfig(self.branch)
1283
self._branch_data_config.config_id = self.config_id
1284
return self._branch_data_config
1286
def _get_location_config(self):
1287
if self._location_config is None:
1288
self._location_config = LocationConfig(self.branch.base)
1289
return self._location_config
1291
def _get_global_config(self):
1292
if self._global_config is None:
1293
self._global_config = GlobalConfig()
1294
return self._global_config
1296
def _get_best_value(self, option_name):
1297
"""This returns a user option from local, tree or global config.
1299
They are tried in that order. Use get_safe_value if trusted values
1302
for source in self.option_sources:
1303
value = getattr(source(), option_name)()
1304
if value is not None:
1308
def _get_safe_value(self, option_name):
1309
"""This variant of get_best_value never returns untrusted values.
1311
It does not return values from the branch data, because the branch may
1312
not be controlled by the user.
1314
We may wish to allow locations.conf to control whether branches are
1315
trusted in the future.
1317
for source in (self._get_location_config, self._get_global_config):
1318
value = getattr(source(), option_name)()
1319
if value is not None:
1323
def _get_user_id(self):
1324
"""Return the full user id for the branch.
1326
e.g. "John Hacker <jhacker@example.com>"
1327
This is looked up in the email controlfile for the branch.
1329
return self._get_best_value('_get_user_id')
1331
def _get_change_editor(self):
1332
return self._get_best_value('_get_change_editor')
1334
def _get_signature_checking(self):
1335
"""See Config._get_signature_checking."""
1336
return self._get_best_value('_get_signature_checking')
1338
def _get_signing_policy(self):
1339
"""See Config._get_signing_policy."""
1340
return self._get_best_value('_get_signing_policy')
1342
def _get_user_option(self, option_name):
1343
"""See Config._get_user_option."""
1344
for source in self.option_sources:
1345
value = source()._get_user_option(option_name)
1346
if value is not None:
1350
def _get_sections(self, name=None):
1351
"""See IniBasedConfig.get_sections()."""
1352
for source in self.option_sources:
1353
for section in source()._get_sections(name):
1356
def _get_options(self, sections=None):
1357
# First the locations options
1358
for option in self._get_location_config()._get_options():
1360
# Then the branch options
1361
branch_config = self._get_branch_data_config()
1362
if sections is None:
1363
sections = [('DEFAULT', branch_config._get_parser())]
1364
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1365
# Config itself has no notion of sections :( -- vila 20101001
1366
config_id = self.config_id()
1367
for (section_name, section) in sections:
1368
for (name, value) in section.iteritems():
1369
yield (name, value, section_name,
1370
config_id, branch_config._get_parser())
1371
# Then the global options
1372
for option in self._get_global_config()._get_options():
1375
def set_user_option(self, name, value, store=STORE_BRANCH,
1377
if store == STORE_BRANCH:
1378
self._get_branch_data_config().set_option(value, name)
1379
elif store == STORE_GLOBAL:
1380
self._get_global_config().set_user_option(name, value)
1382
self._get_location_config().set_user_option(name, value, store)
1385
if store in (STORE_GLOBAL, STORE_BRANCH):
1386
mask_value = self._get_location_config().get_user_option(name)
1387
if mask_value is not None:
1388
trace.warning('Value "%s" is masked by "%s" from'
1389
' locations.conf', value, mask_value)
1391
if store == STORE_GLOBAL:
1392
branch_config = self._get_branch_data_config()
1393
mask_value = branch_config.get_user_option(name)
1394
if mask_value is not None:
1395
trace.warning('Value "%s" is masked by "%s" from'
1396
' branch.conf', value, mask_value)
1398
def remove_user_option(self, option_name, section_name=None):
1399
self._get_branch_data_config().remove_option(option_name, section_name)
1401
def _post_commit(self):
1402
"""See Config.post_commit."""
1403
return self._get_safe_value('_post_commit')
1405
def _get_nickname(self):
1406
value = self._get_explicit_nickname()
1407
if value is not None:
1409
if self.branch.name:
1410
return self.branch.name
1411
return urlutils.unescape(self.branch.base.split('/')[-2])
1413
def has_explicit_nickname(self):
1414
"""Return true if a nickname has been explicitly assigned."""
1415
return self._get_explicit_nickname() is not None
1417
def _get_explicit_nickname(self):
1418
return self._get_best_value('_get_nickname')
1420
def _log_format(self):
1421
"""See Config.log_format."""
1422
return self._get_best_value('_log_format')
1424
def _validate_signatures_in_log(self):
1425
"""See Config.validate_signatures_in_log."""
1426
return self._get_best_value('_validate_signatures_in_log')
1428
def _acceptable_keys(self):
1429
"""See Config.acceptable_keys."""
1430
return self._get_best_value('_acceptable_keys')
1433
def ensure_config_dir_exists(path=None):
1434
"""Make sure a configuration directory exists.
1435
This makes sure that the directory exists.
1436
On windows, since configuration directories are 2 levels deep,
1437
it makes sure both the directory and the parent directory exists.
1441
if not os.path.isdir(path):
1442
if sys.platform == 'win32':
1443
parent_dir = os.path.dirname(path)
1444
if not os.path.isdir(parent_dir):
1446
'creating config parent directory: %r', parent_dir)
1447
os.mkdir(parent_dir)
1448
trace.mutter('creating config directory: %r', path)
1450
osutils.copy_ownership_from_path(path)
1453
def bazaar_config_dir():
1454
"""Return per-user configuration directory as unicode string
1456
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1457
and Linux. On Mac OS X and Linux, if there is a $XDG_CONFIG_HOME/bazaar
1458
directory, that will be used instead
1460
TODO: Global option --config-dir to override this.
1462
base = osutils.path_from_environ('BZR_HOME')
1463
if sys.platform == 'win32':
1465
base = win32utils.get_appdata_location()
1467
base = win32utils.get_home_location()
1468
return osutils.pathjoin(base, 'bazaar', '2.0')
1470
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1472
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1473
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1474
if osutils.isdir(xdg_dir):
1476
"Using configuration in XDG directory %s." % xdg_dir)
1478
base = osutils._get_home_dir()
1479
return osutils.pathjoin(base, ".bazaar")
1483
"""Return per-user configuration directory as unicode string
1485
By default this is %APPDATA%/breezy on Windows, $XDG_CONFIG_HOME/breezy on
1486
Mac OS X and Linux. If the breezy config directory doesn't exist but
1487
the bazaar one (see bazaar_config_dir()) does, use that instead.
1489
# TODO: Global option --config-dir to override this.
1490
base = osutils.path_from_environ('BRZ_HOME')
1491
if sys.platform == 'win32':
1493
base = win32utils.get_appdata_location()
1495
base = win32utils.get_home_location()
1497
base = osutils.path_from_environ('XDG_CONFIG_HOME')
1499
base = osutils.pathjoin(osutils._get_home_dir(), ".config")
1500
breezy_dir = osutils.pathjoin(base, 'breezy')
1501
if osutils.isdir(breezy_dir):
1502
return (breezy_dir, 'breezy')
1503
# If the breezy directory doesn't exist, but the bazaar one does, use that:
1504
bazaar_dir = bazaar_config_dir()
1505
if osutils.isdir(bazaar_dir):
1507
"Using Bazaar configuration directory (%s)", bazaar_dir)
1508
return (bazaar_dir, 'bazaar')
1509
return (breezy_dir, 'breezy')
1513
"""Return per-user configuration directory as unicode string
1515
By default this is %APPDATA%/breezy on Windows, $XDG_CONFIG_HOME/breezy on
1516
Mac OS X and Linux. If the breezy config directory doesn't exist but
1517
the bazaar one (see bazaar_config_dir()) does, use that instead.
1519
return _config_dir()[0]
1522
def config_filename():
1523
"""Return per-user configuration ini file filename."""
1524
path, kind = _config_dir()
1525
if kind == 'bazaar':
1526
return osutils.pathjoin(path, 'bazaar.conf')
1528
return osutils.pathjoin(path, 'breezy.conf')
1531
def locations_config_filename():
1532
"""Return per-user configuration ini file filename."""
1533
return osutils.pathjoin(config_dir(), 'locations.conf')
1536
def authentication_config_filename():
1537
"""Return per-user authentication ini file filename."""
1538
return osutils.pathjoin(config_dir(), 'authentication.conf')
1541
def user_ignore_config_filename():
1542
"""Return the user default ignore filename"""
1543
return osutils.pathjoin(config_dir(), 'ignore')
1547
"""Return the directory name to store crash files.
1549
This doesn't implicitly create it.
1551
On Windows it's in the config directory; elsewhere it's /var/crash
1552
which may be monitored by apport. It can be overridden by
1555
if sys.platform == 'win32':
1556
return osutils.pathjoin(config_dir(), 'Crash')
1558
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1560
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1563
def xdg_cache_dir():
1564
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1565
# Possibly this should be different on Windows?
1566
e = os.environ.get('XDG_CACHE_HOME', None)
1570
return os.path.expanduser('~/.cache')
1573
def _get_default_mail_domain(mailname_file='/etc/mailname'):
1574
"""If possible, return the assumed default email domain.
1576
:returns: string mail domain, or None.
1578
if sys.platform == 'win32':
1579
# No implementation yet; patches welcome
1582
f = open(mailname_file)
1583
except (IOError, OSError):
1586
domain = f.readline().strip()
1592
def default_email():
1593
v = os.environ.get('BRZ_EMAIL')
1596
v = v.decode(osutils.get_user_encoding())
1598
v = os.environ.get('EMAIL')
1601
v = v.decode(osutils.get_user_encoding())
1603
name, email = _auto_user_id()
1605
return u'%s <%s>' % (name, email)
1611
def _auto_user_id():
1612
"""Calculate automatic user identification.
1614
:returns: (realname, email), either of which may be None if they can't be
1617
Only used when none is set in the environment or the id file.
1619
This only returns an email address if we can be fairly sure the
1620
address is reasonable, ie if /etc/mailname is set on unix.
1622
This doesn't use the FQDN as the default domain because that may be
1623
slow, and it doesn't use the hostname alone because that's not normally
1624
a reasonable address.
1626
if sys.platform == 'win32':
1627
# No implementation to reliably determine Windows default mail
1628
# address; please add one.
1631
default_mail_domain = _get_default_mail_domain()
1632
if not default_mail_domain:
1638
w = pwd.getpwuid(uid)
1640
trace.mutter('no passwd entry for uid %d?' % uid)
1643
# we try utf-8 first, because on many variants (like Linux),
1644
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1645
# false positives. (many users will have their user encoding set to
1646
# latin-1, which cannot raise UnicodeError.)
1648
if isinstance(gecos, bytes):
1650
gecos = gecos.decode('utf-8')
1652
except UnicodeError:
1654
encoding = osutils.get_user_encoding()
1655
gecos = gecos.decode(encoding)
1656
except UnicodeError:
1657
trace.mutter("cannot decode passwd entry %s" % w)
1660
username = w.pw_name
1661
if isinstance(username, bytes):
1663
username = username.decode(encoding)
1664
except UnicodeError:
1665
trace.mutter("cannot decode passwd entry %s" % w)
1668
comma = gecos.find(',')
1672
realname = gecos[:comma]
1674
return realname, (username + '@' + default_mail_domain)
1677
def parse_username(username):
1678
"""Parse e-mail username and return a (name, address) tuple."""
1679
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1681
return (username, '')
1683
return (match.group(1), match.group(2))
1686
def extract_email_address(e):
1687
"""Return just the address part of an email string.
1689
That is just the user@domain part, nothing else.
1690
This part is required to contain only ascii characters.
1691
If it can't be extracted, raises an error.
1693
>>> extract_email_address('Jane Tester <jane@test.com>')
1696
name, email = parse_username(e)
1698
raise NoEmailInUsername(e)
1702
class TreeConfig(IniBasedConfig):
1703
"""Branch configuration data associated with its contents, not location"""
1705
# XXX: Really needs a better name, as this is not part of the tree!
1708
def __init__(self, branch):
1709
self._config = branch._get_config()
1710
self.branch = branch
1712
def _get_parser(self, file=None):
1713
if file is not None:
1714
return IniBasedConfig._get_parser(file)
1715
return self._config._get_configobj()
1717
def get_option(self, name, section=None, default=None):
1718
with self.branch.lock_read():
1719
return self._config.get_option(name, section, default)
1721
def set_option(self, value, name, section=None):
1722
"""Set a per-branch configuration option"""
1723
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1724
# higher levels providing the right lock -- vila 20101004
1725
with self.branch.lock_write():
1726
self._config.set_option(value, name, section)
1728
def remove_option(self, option_name, section_name=None):
1729
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1730
# higher levels providing the right lock -- vila 20101004
1731
with self.branch.lock_write():
1732
self._config.remove_option(option_name, section_name)
1735
_authentication_config_permission_errors = set()
1738
class AuthenticationConfig(object):
1739
"""The authentication configuration file based on a ini file.
1741
Implements the authentication.conf file described in
1742
doc/developers/authentication-ring.txt.
1745
def __init__(self, _file=None):
1746
self._config = None # The ConfigObj
1748
self._filename = authentication_config_filename()
1749
self._input = self._filename = authentication_config_filename()
1750
self._check_permissions()
1752
# Tests can provide a string as _file
1753
self._filename = None
1756
def _get_config(self):
1757
if self._config is not None:
1760
# FIXME: Should we validate something here ? Includes: empty
1761
# sections are useless, at least one of
1762
# user/password/password_encoding should be defined, etc.
1764
# Note: the encoding below declares that the file itself is utf-8
1765
# encoded, but the values in the ConfigObj are always Unicode.
1766
self._config = ConfigObj(self._input, encoding='utf-8')
1767
except configobj.ConfigObjError as e:
1768
raise ParseConfigError(e.errors, e.config.filename)
1769
except UnicodeError:
1770
raise ConfigContentError(self._filename)
1773
def _check_permissions(self):
1774
"""Check permission of auth file are user read/write able only."""
1776
st = os.stat(self._filename)
1777
except OSError as e:
1778
if e.errno != errno.ENOENT:
1779
trace.mutter('Unable to stat %r: %r', self._filename, e)
1781
mode = stat.S_IMODE(st.st_mode)
1782
if ((stat.S_IXOTH | stat.S_IWOTH | stat.S_IROTH | stat.S_IXGRP
1783
| stat.S_IWGRP | stat.S_IRGRP) & mode):
1785
if (self._filename not in _authentication_config_permission_errors and
1786
not GlobalConfig().suppress_warning(
1787
'insecure_permissions')):
1788
trace.warning("The file '%s' has insecure "
1789
"file permissions. Saved passwords may be accessible "
1790
"by other users.", self._filename)
1791
_authentication_config_permission_errors.add(self._filename)
1794
"""Save the config file, only tests should use it for now."""
1795
conf_dir = os.path.dirname(self._filename)
1796
ensure_config_dir_exists(conf_dir)
1797
fd = os.open(self._filename, os.O_RDWR | os.O_CREAT, 0o600)
1799
f = os.fdopen(fd, 'wb')
1800
self._get_config().write(f)
1804
def _set_option(self, section_name, option_name, value):
1805
"""Set an authentication configuration option"""
1806
conf = self._get_config()
1807
section = conf.get(section_name)
1810
section = conf[section]
1811
section[option_name] = value
1814
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1816
"""Returns the matching credentials from authentication.conf file.
1818
:param scheme: protocol
1820
:param host: the server address
1822
:param port: the associated port (optional)
1824
:param user: login (optional)
1826
:param path: the absolute path on the server (optional)
1828
:param realm: the http authentication realm (optional)
1830
:return: A dict containing the matching credentials or None.
1832
- name: the section name of the credentials in the
1833
authentication.conf file,
1834
- user: can't be different from the provided user if any,
1835
- scheme: the server protocol,
1836
- host: the server address,
1837
- port: the server port (can be None),
1838
- path: the absolute server path (can be None),
1839
- realm: the http specific authentication realm (can be None),
1840
- password: the decoded password, could be None if the credential
1841
defines only the user
1842
- verify_certificates: https specific, True if the server
1843
certificate should be verified, False otherwise.
1846
for auth_def_name, auth_def in self._get_config().iteritems():
1847
if not isinstance(auth_def, configobj.Section):
1848
raise ValueError("%s defined outside a section" %
1851
a_scheme, a_host, a_user, a_path = map(
1852
auth_def.get, ['scheme', 'host', 'user', 'path'])
1855
a_port = auth_def.as_int('port')
1859
raise ValueError("'port' not numeric in %s" % auth_def_name)
1861
a_verify_certificates = auth_def.as_bool('verify_certificates')
1863
a_verify_certificates = True
1866
"'verify_certificates' not boolean in %s" % auth_def_name)
1869
if a_scheme is not None and scheme != a_scheme:
1871
if a_host is not None:
1872
if not (host == a_host or
1873
(a_host.startswith('.') and host.endswith(a_host))):
1875
if a_port is not None and port != a_port:
1877
if (a_path is not None and path is not None and
1878
not path.startswith(a_path)):
1880
if (a_user is not None and user is not None and
1882
# Never contradict the caller about the user to be used
1887
# Prepare a credentials dictionary with additional keys
1888
# for the credential providers
1889
credentials = dict(name=auth_def_name,
1896
password=auth_def.get('password', None),
1897
verify_certificates=a_verify_certificates)
1898
# Decode the password in the credentials (or get one)
1899
self.decode_password(credentials,
1900
auth_def.get('password_encoding', None))
1901
if 'auth' in debug.debug_flags:
1902
trace.mutter("Using authentication section: %r", auth_def_name)
1905
if credentials is None:
1906
# No credentials were found in authentication.conf, try the fallback
1907
# credentials stores.
1908
credentials = credential_store_registry.get_fallback_credentials(
1909
scheme, host, port, user, path, realm)
1913
def set_credentials(self, name, host, user, scheme=None, password=None,
1914
port=None, path=None, verify_certificates=None,
1916
"""Set authentication credentials for a host.
1918
Any existing credentials with matching scheme, host, port and path
1919
will be deleted, regardless of name.
1921
:param name: An arbitrary name to describe this set of credentials.
1922
:param host: Name of the host that accepts these credentials.
1923
:param user: The username portion of these credentials.
1924
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1926
:param password: Password portion of these credentials.
1927
:param port: The IP port on the host that these credentials apply to.
1928
:param path: A filesystem path on the host that these credentials
1930
:param verify_certificates: On https, verify server certificates if
1932
:param realm: The http authentication realm (optional).
1934
values = {'host': host, 'user': user}
1935
if password is not None:
1936
values['password'] = password
1937
if scheme is not None:
1938
values['scheme'] = scheme
1939
if port is not None:
1940
values['port'] = '%d' % port
1941
if path is not None:
1942
values['path'] = path
1943
if verify_certificates is not None:
1944
values['verify_certificates'] = str(verify_certificates)
1945
if realm is not None:
1946
values['realm'] = realm
1947
config = self._get_config()
1948
for section, existing_values in config.iteritems():
1949
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1950
if existing_values.get(key) != values.get(key):
1954
config.update({name: values})
1957
def get_user(self, scheme, host, port=None, realm=None, path=None,
1958
prompt=None, ask=False, default=None):
1959
"""Get a user from authentication file.
1961
:param scheme: protocol
1963
:param host: the server address
1965
:param port: the associated port (optional)
1967
:param realm: the realm sent by the server (optional)
1969
:param path: the absolute path on the server (optional)
1971
:param ask: Ask the user if there is no explicitly configured username
1974
:param default: The username returned if none is defined (optional).
1976
:return: The found user.
1978
credentials = self.get_credentials(scheme, host, port, user=None,
1979
path=path, realm=realm)
1980
if credentials is not None:
1981
user = credentials['user']
1987
# Create a default prompt suitable for most cases
1988
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1989
# Special handling for optional fields in the prompt
1990
if port is not None:
1991
prompt_host = '%s:%d' % (host, port)
1994
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1999
def get_password(self, scheme, host, user, port=None,
2000
realm=None, path=None, prompt=None):
2001
"""Get a password from authentication file or prompt the user for one.
2003
:param scheme: protocol
2005
:param host: the server address
2007
:param port: the associated port (optional)
2011
:param realm: the realm sent by the server (optional)
2013
:param path: the absolute path on the server (optional)
2015
:return: The found password or the one entered by the user.
2017
credentials = self.get_credentials(scheme, host, port, user, path,
2019
if credentials is not None:
2020
password = credentials['password']
2021
if password is not None and scheme == 'ssh':
2022
trace.warning('password ignored in section [%s],'
2023
' use an ssh agent instead'
2024
% credentials['name'])
2028
# Prompt user only if we could't find a password
2029
if password is None:
2031
# Create a default prompt suitable for most cases
2033
scheme.upper() + u' %(user)s@%(host)s password')
2034
# Special handling for optional fields in the prompt
2035
if port is not None:
2036
prompt_host = '%s:%d' % (host, port)
2039
password = ui.ui_factory.get_password(prompt,
2040
host=prompt_host, user=user)
2043
def decode_password(self, credentials, encoding):
2045
cs = credential_store_registry.get_credential_store(encoding)
2047
raise ValueError('%r is not a known password_encoding' % encoding)
2048
credentials['password'] = cs.decode_password(credentials)
2052
class CredentialStoreRegistry(registry.Registry):
2053
"""A class that registers credential stores.
2055
A credential store provides access to credentials via the password_encoding
2056
field in authentication.conf sections.
2058
Except for stores provided by brz itself, most stores are expected to be
2059
provided by plugins that will therefore use
2060
register_lazy(password_encoding, module_name, member_name, help=help,
2061
fallback=fallback) to install themselves.
2063
A fallback credential store is one that is queried if no credentials can be
2064
found via authentication.conf.
2067
def get_credential_store(self, encoding=None):
2068
cs = self.get(encoding)
2073
def is_fallback(self, name):
2074
"""Check if the named credentials store should be used as fallback."""
2075
return self.get_info(name)
2077
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2078
path=None, realm=None):
2079
"""Request credentials from all fallback credentials stores.
2081
The first credentials store that can provide credentials wins.
2084
for name in self.keys():
2085
if not self.is_fallback(name):
2087
cs = self.get_credential_store(name)
2088
credentials = cs.get_credentials(scheme, host, port, user,
2090
if credentials is not None:
2091
# We found some credentials
2095
def register(self, key, obj, help=None, override_existing=False,
2097
"""Register a new object to a name.
2099
:param key: This is the key to use to request the object later.
2100
:param obj: The object to register.
2101
:param help: Help text for this entry. This may be a string or
2102
a callable. If it is a callable, it should take two
2103
parameters (registry, key): this registry and the key that
2104
the help was registered under.
2105
:param override_existing: Raise KeyErorr if False and something has
2106
already been registered for that key. If True, ignore if there
2107
is an existing key (always register the new value).
2108
:param fallback: Whether this credential store should be
2111
return super(CredentialStoreRegistry,
2112
self).register(key, obj, help, info=fallback,
2113
override_existing=override_existing)
2115
def register_lazy(self, key, module_name, member_name,
2116
help=None, override_existing=False,
2118
"""Register a new credential store to be loaded on request.
2120
:param module_name: The python path to the module. Such as 'os.path'.
2121
:param member_name: The member of the module to return. If empty or
2122
None, get() will return the module itself.
2123
:param help: Help text for this entry. This may be a string or
2125
:param override_existing: If True, replace the existing object
2126
with the new one. If False, if there is already something
2127
registered with the same key, raise a KeyError
2128
:param fallback: Whether this credential store should be
2131
return super(CredentialStoreRegistry, self).register_lazy(
2132
key, module_name, member_name, help,
2133
info=fallback, override_existing=override_existing)
2136
credential_store_registry = CredentialStoreRegistry()
2139
class CredentialStore(object):
2140
"""An abstract class to implement storage for credentials"""
2142
def decode_password(self, credentials):
2143
"""Returns a clear text password for the provided credentials."""
2144
raise NotImplementedError(self.decode_password)
2146
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2148
"""Return the matching credentials from this credential store.
2150
This method is only called on fallback credential stores.
2152
raise NotImplementedError(self.get_credentials)
2155
class PlainTextCredentialStore(CredentialStore):
2156
__doc__ = """Plain text credential store for the authentication.conf file"""
2158
def decode_password(self, credentials):
2159
"""See CredentialStore.decode_password."""
2160
return credentials['password']
2163
credential_store_registry.register('plain', PlainTextCredentialStore,
2164
help=PlainTextCredentialStore.__doc__)
2165
credential_store_registry.default_key = 'plain'
2168
class Base64CredentialStore(CredentialStore):
2169
__doc__ = """Base64 credential store for the authentication.conf file"""
2171
def decode_password(self, credentials):
2172
"""See CredentialStore.decode_password."""
2173
# GZ 2012-07-28: Will raise binascii.Error if password is not base64,
2174
# should probably propogate as something more useful.
2175
return base64.standard_b64decode(credentials['password'])
2178
credential_store_registry.register('base64', Base64CredentialStore,
2179
help=Base64CredentialStore.__doc__)
2182
class BzrDirConfig(object):
2184
def __init__(self, bzrdir):
2185
self._bzrdir = bzrdir
2186
self._config = bzrdir._get_config()
2188
def set_default_stack_on(self, value):
2189
"""Set the default stacking location.
2191
It may be set to a location, or None.
2193
This policy affects all branches contained by this control dir, except
2194
for those under repositories.
2196
if self._config is None:
2197
raise errors.BzrError("Cannot set configuration in %s"
2200
self._config.set_option('', 'default_stack_on')
2202
self._config.set_option(value, 'default_stack_on')
2204
def get_default_stack_on(self):
2205
"""Return the default stacking location.
2207
This will either be a location, or None.
2209
This policy affects all branches contained by this control dir, except
2210
for those under repositories.
2212
if self._config is None:
2214
value = self._config.get_option('default_stack_on')
2220
class TransportConfig(object):
2221
"""A Config that reads/writes a config file on a Transport.
2223
It is a low-level object that considers config data to be name/value pairs
2224
that may be associated with a section. Assigning meaning to these values
2225
is done at higher levels like TreeConfig.
2228
def __init__(self, transport, filename):
2229
self._transport = transport
2230
self._filename = filename
2232
def get_option(self, name, section=None, default=None):
2233
"""Return the value associated with a named option.
2235
:param name: The name of the value
2236
:param section: The section the option is in (if any)
2237
:param default: The value to return if the value is not set
2238
:return: The value or default value
2240
configobj = self._get_configobj()
2242
section_obj = configobj
2245
section_obj = configobj[section]
2248
value = section_obj.get(name, default)
2249
for hook in OldConfigHooks['get']:
2250
hook(self, name, value)
2253
def set_option(self, value, name, section=None):
2254
"""Set the value associated with a named option.
2256
:param value: The value to set
2257
:param name: The name of the value to set
2258
:param section: The section the option is in (if any)
2260
configobj = self._get_configobj()
2262
configobj[name] = value
2264
configobj.setdefault(section, {})[name] = value
2265
for hook in OldConfigHooks['set']:
2266
hook(self, name, value)
2267
self._set_configobj(configobj)
2269
def remove_option(self, option_name, section_name=None):
2270
configobj = self._get_configobj()
2271
if section_name is None:
2272
del configobj[option_name]
2274
del configobj[section_name][option_name]
2275
for hook in OldConfigHooks['remove']:
2276
hook(self, option_name)
2277
self._set_configobj(configobj)
2279
def _get_config_file(self):
2281
f = BytesIO(self._transport.get_bytes(self._filename))
2282
for hook in OldConfigHooks['load']:
2285
except errors.NoSuchFile:
2287
except errors.PermissionDenied:
2289
"Permission denied while trying to open "
2290
"configuration file %s.",
2291
urlutils.unescape_for_display(
2292
urlutils.join(self._transport.base, self._filename),
2296
def _external_url(self):
2297
return urlutils.join(self._transport.external_url(), self._filename)
2299
def _get_configobj(self):
2300
f = self._get_config_file()
2303
conf = ConfigObj(f, encoding='utf-8')
2304
except configobj.ConfigObjError as e:
2305
raise ParseConfigError(e.errors, self._external_url())
2306
except UnicodeDecodeError:
2307
raise ConfigContentError(self._external_url())
2312
def _set_configobj(self, configobj):
2313
out_file = BytesIO()
2314
configobj.write(out_file)
2316
self._transport.put_file(self._filename, out_file)
2317
for hook in OldConfigHooks['save']:
2321
class Option(object):
2322
"""An option definition.
2324
The option *values* are stored in config files and found in sections.
2326
Here we define various properties about the option itself, its default
2327
value, how to convert it from stores, what to do when invalid values are
2328
encoutered, in which config files it can be stored.
2331
def __init__(self, name, override_from_env=None,
2332
default=None, default_from_env=None,
2333
help=None, from_unicode=None, invalid=None, unquote=True):
2334
"""Build an option definition.
2336
:param name: the name used to refer to the option.
2338
:param override_from_env: A list of environment variables which can
2339
provide override any configuration setting.
2341
:param default: the default value to use when none exist in the config
2342
stores. This is either a string that ``from_unicode`` will convert
2343
into the proper type, a callable returning a unicode string so that
2344
``from_unicode`` can be used on the return value, or a python
2345
object that can be stringified (so only the empty list is supported
2348
:param default_from_env: A list of environment variables which can
2349
provide a default value. 'default' will be used only if none of the
2350
variables specified here are set in the environment.
2352
:param help: a doc string to explain the option to the user.
2354
:param from_unicode: a callable to convert the unicode string
2355
representing the option value in a store or its default value.
2357
:param invalid: the action to be taken when an invalid value is
2358
encountered in a store. This is called only when from_unicode is
2359
invoked to convert a string and returns None or raise ValueError or
2360
TypeError. Accepted values are: None (ignore invalid values),
2361
'warning' (emit a warning), 'error' (emit an error message and
2364
:param unquote: should the unicode value be unquoted before conversion.
2365
This should be used only when the store providing the values cannot
2366
safely unquote them (see http://pad.lv/906897). It is provided so
2367
daughter classes can handle the quoting themselves.
2369
if override_from_env is None:
2370
override_from_env = []
2371
if default_from_env is None:
2372
default_from_env = []
2374
self.override_from_env = override_from_env
2375
# Convert the default value to a unicode string so all values are
2376
# strings internally before conversion (via from_unicode) is attempted.
2379
elif isinstance(default, list):
2380
# Only the empty list is supported
2382
raise AssertionError(
2383
'Only empty lists are supported as default values')
2385
elif isinstance(default, (binary_type, text_type, bool, int, float)):
2386
# Rely on python to convert strings, booleans and integers
2387
self.default = u'%s' % (default,)
2388
elif callable(default):
2389
self.default = default
2391
# other python objects are not expected
2392
raise AssertionError('%r is not supported as a default value'
2394
self.default_from_env = default_from_env
2396
self.from_unicode = from_unicode
2397
self.unquote = unquote
2398
if invalid and invalid not in ('warning', 'error'):
2399
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2400
self.invalid = invalid
2406
def convert_from_unicode(self, store, unicode_value):
2407
if self.unquote and store is not None and unicode_value is not None:
2408
unicode_value = store.unquote(unicode_value)
2409
if self.from_unicode is None or unicode_value is None:
2410
# Don't convert or nothing to convert
2411
return unicode_value
2413
converted = self.from_unicode(unicode_value)
2414
except (ValueError, TypeError):
2415
# Invalid values are ignored
2417
if converted is None and self.invalid is not None:
2418
# The conversion failed
2419
if self.invalid == 'warning':
2420
trace.warning('Value "%s" is not valid for "%s"',
2421
unicode_value, self.name)
2422
elif self.invalid == 'error':
2423
raise ConfigOptionValueError(self.name, unicode_value)
2426
def get_override(self):
2428
for var in self.override_from_env:
2430
# If the env variable is defined, its value takes precedence
2431
value = os.environ[var]
2433
value = value.decode(osutils.get_user_encoding())
2439
def get_default(self):
2441
for var in self.default_from_env:
2443
# If the env variable is defined, its value is the default one
2444
value = os.environ[var]
2446
value = value.decode(osutils.get_user_encoding())
2451
# Otherwise, fallback to the value defined at registration
2452
if callable(self.default):
2453
value = self.default()
2454
if not isinstance(value, text_type):
2455
raise AssertionError(
2456
"Callable default value for '%s' should be unicode"
2459
value = self.default
2462
def get_help_topic(self):
2465
def get_help_text(self, additional_see_also=None, plain=True):
2467
from breezy import help_topics
2468
result += help_topics._format_see_also(additional_see_also)
2470
result = help_topics.help_as_plain_text(result)
2474
# Predefined converters to get proper values from store
2476
def bool_from_store(unicode_str):
2477
return ui.bool_from_string(unicode_str)
2480
def int_from_store(unicode_str):
2481
return int(unicode_str)
2484
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2487
def int_SI_from_store(unicode_str):
2488
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2490
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2491
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2494
:return Integer, expanded to its base-10 value if a proper SI unit is
2495
found, None otherwise.
2497
regexp = "^(\\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2498
p = re.compile(regexp, re.IGNORECASE)
2499
m = p.match(unicode_str)
2502
val, _, unit = m.groups()
2506
coeff = _unit_suffixes[unit.upper()]
2509
gettext('{0} is not an SI unit.').format(unit))
2514
def float_from_store(unicode_str):
2515
return float(unicode_str)
2518
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2520
_list_converter_config = configobj.ConfigObj(
2521
{}, encoding='utf-8', list_values=True, interpolation=False)
2524
class ListOption(Option):
2526
def __init__(self, name, default=None, default_from_env=None,
2527
help=None, invalid=None):
2528
"""A list Option definition.
2530
This overrides the base class so the conversion from a unicode string
2531
can take quoting into account.
2533
super(ListOption, self).__init__(
2534
name, default=default, default_from_env=default_from_env,
2535
from_unicode=self.from_unicode, help=help,
2536
invalid=invalid, unquote=False)
2538
def from_unicode(self, unicode_str):
2539
if not isinstance(unicode_str, string_types):
2541
# Now inject our string directly as unicode. All callers got their
2542
# value from configobj, so values that need to be quoted are already
2544
_list_converter_config.reset()
2545
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2546
maybe_list = _list_converter_config['list']
2547
if isinstance(maybe_list, string_types):
2549
# A single value, most probably the user forgot (or didn't care
2550
# to add) the final ','
2553
# The empty string, convert to empty list
2556
# We rely on ConfigObj providing us with a list already
2561
class RegistryOption(Option):
2562
"""Option for a choice from a registry."""
2564
def __init__(self, name, registry, default_from_env=None,
2565
help=None, invalid=None):
2566
"""A registry based Option definition.
2568
This overrides the base class so the conversion from a unicode string
2569
can take quoting into account.
2571
super(RegistryOption, self).__init__(
2572
name, default=lambda: registry.default_key,
2573
default_from_env=default_from_env,
2574
from_unicode=self.from_unicode, help=help,
2575
invalid=invalid, unquote=False)
2576
self.registry = registry
2578
def from_unicode(self, unicode_str):
2579
if not isinstance(unicode_str, string_types):
2582
return self.registry.get(unicode_str)
2585
"Invalid value %s for %s."
2586
"See help for a list of possible values." % (unicode_str,
2591
ret = [self._help, "\n\nThe following values are supported:\n"]
2592
for key in self.registry.keys():
2593
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2597
_option_ref_re = lazy_regex.lazy_compile('({[^\\d\\W](?:\\.\\w|-\\w|\\w)*})')
2598
"""Describes an expandable option reference.
2600
We want to match the most embedded reference first.
2602
I.e. for '{{foo}}' we will get '{foo}',
2603
for '{bar{baz}}' we will get '{baz}'
2607
def iter_option_refs(string):
2608
# Split isolate refs so every other chunk is a ref
2610
for chunk in _option_ref_re.split(string):
2615
class OptionRegistry(registry.Registry):
2616
"""Register config options by their name.
2618
This overrides ``registry.Registry`` to simplify registration by acquiring
2619
some information from the option object itself.
2622
def _check_option_name(self, option_name):
2623
"""Ensures an option name is valid.
2625
:param option_name: The name to validate.
2627
if _option_ref_re.match('{%s}' % option_name) is None:
2628
raise IllegalOptionName(option_name)
2630
def register(self, option):
2631
"""Register a new option to its name.
2633
:param option: The option to register. Its name is used as the key.
2635
self._check_option_name(option.name)
2636
super(OptionRegistry, self).register(option.name, option,
2639
def register_lazy(self, key, module_name, member_name):
2640
"""Register a new option to be loaded on request.
2642
:param key: the key to request the option later. Since the registration
2643
is lazy, it should be provided and match the option name.
2645
:param module_name: the python path to the module. Such as 'os.path'.
2647
:param member_name: the member of the module to return. If empty or
2648
None, get() will return the module itself.
2650
self._check_option_name(key)
2651
super(OptionRegistry, self).register_lazy(key,
2652
module_name, member_name)
2654
def get_help(self, key=None):
2655
"""Get the help text associated with the given key"""
2656
option = self.get(key)
2657
the_help = option.help
2658
if callable(the_help):
2659
return the_help(self, key)
2663
option_registry = OptionRegistry()
2666
# Registered options in lexicographical order
2668
option_registry.register(
2669
Option('append_revisions_only',
2670
default=None, from_unicode=bool_from_store, invalid='warning',
2672
Whether to only append revisions to the mainline.
2674
If this is set to true, then it is not possible to change the
2675
existing mainline of the branch.
2677
option_registry.register(
2678
ListOption('acceptable_keys',
2681
List of GPG key patterns which are acceptable for verification.
2683
option_registry.register(
2684
Option('add.maximum_file_size',
2685
default=u'20MB', from_unicode=int_SI_from_store,
2687
Size above which files should be added manually.
2689
Files below this size are added automatically when using ``bzr add`` without
2692
A negative value means disable the size check.
2694
option_registry.register(
2696
default=None, from_unicode=bool_from_store,
2698
Is the branch bound to ``bound_location``.
2700
If set to "True", the branch should act as a checkout, and push each commit to
2701
the bound_location. This option is normally set by ``bind``/``unbind``.
2703
See also: bound_location.
2705
option_registry.register(
2706
Option('bound_location',
2709
The location that commits should go to when acting as a checkout.
2711
This option is normally set by ``bind``.
2715
option_registry.register(
2716
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2718
Whether revisions associated with tags should be fetched.
2720
option_registry.register_lazy(
2721
'transform.orphan_policy', 'breezy.transform', 'opt_transform_orphan')
2722
option_registry.register(
2723
Option('bzr.workingtree.worth_saving_limit', default=10,
2724
from_unicode=int_from_store, invalid='warning',
2726
How many changes before saving the dirstate.
2728
-1 means that we will never rewrite the dirstate file for only
2729
stat-cache changes. Regardless of this setting, we will always rewrite
2730
the dirstate file if a file is added/removed/renamed/etc. This flag only
2731
affects the behavior of updating the dirstate file after we notice that
2732
a file has been touched.
2734
option_registry.register(
2735
Option('bugtracker', default=None,
2737
Default bug tracker to use.
2739
This bug tracker will be used for example when marking bugs
2740
as fixed using ``bzr commit --fixes``, if no explicit
2741
bug tracker was specified.
2743
option_registry.register(
2744
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2745
from_unicode=signature_policy_from_unicode,
2747
GPG checking policy.
2749
Possible values: require, ignore, check-available (default)
2751
this option will control whether bzr will require good gpg
2752
signatures, ignore them, or check them if they are
2755
option_registry.register(
2756
Option('child_submit_format',
2757
help='''The preferred format of submissions to this branch.'''))
2758
option_registry.register(
2759
Option('child_submit_to',
2760
help='''Where submissions to this branch are mailed to.'''))
2761
option_registry.register(
2762
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2763
from_unicode=signing_policy_from_unicode,
2767
Possible values: always, never, when-required (default)
2769
This option controls whether bzr will always create
2770
gpg signatures or not on commits.
2772
option_registry.register(
2773
Option('dirstate.fdatasync', default=True,
2774
from_unicode=bool_from_store,
2776
Flush dirstate changes onto physical disk?
2778
If true (default), working tree metadata changes are flushed through the
2779
OS buffers to physical disk. This is somewhat slower, but means data
2780
should not be lost if the machine crashes. See also repository.fdatasync.
2782
option_registry.register(
2783
ListOption('debug_flags', default=[],
2784
help='Debug flags to activate.'))
2785
option_registry.register(
2786
Option('default_format', default='2a',
2787
help='Format used when creating branches.'))
2788
option_registry.register(
2790
help='The command called to launch an editor to enter a message.'))
2791
option_registry.register(
2792
Option('email', override_from_env=['BRZ_EMAIL'], default=default_email,
2793
help='The users identity'))
2794
option_registry.register(
2795
Option('gpg_signing_key',
2798
GPG key to use for signing.
2800
This defaults to the first key associated with the users email.
2802
option_registry.register(
2804
help='Language to translate messages into.'))
2805
option_registry.register(
2806
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2808
Steal locks that appears to be dead.
2810
If set to True, bzr will check if a lock is supposed to be held by an
2811
active process from the same user on the same machine. If the user and
2812
machine match, but no process with the given PID is active, then bzr
2813
will automatically break the stale lock, and create a new lock for
2815
Otherwise, bzr will prompt as normal to break the lock.
2817
option_registry.register(
2818
Option('log_format', default='long',
2820
Log format to use when displaying revisions.
2822
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2823
may be provided by plugins.
2825
option_registry.register_lazy('mail_client', 'breezy.mail_client',
2827
option_registry.register(
2828
Option('output_encoding',
2829
help='Unicode encoding for output'
2830
' (terminal encoding if not specified).'))
2831
option_registry.register(
2832
Option('parent_location',
2835
The location of the default branch for pull or merge.
2837
This option is normally set when creating a branch, the first ``pull`` or by
2838
``pull --remember``.
2840
option_registry.register(
2841
Option('post_commit', default=None,
2843
Post commit functions.
2845
An ordered list of python functions to call, separated by spaces.
2847
Each function takes branch, rev_id as parameters.
2849
option_registry.register_lazy('progress_bar', 'breezy.ui.text',
2851
option_registry.register(
2852
Option('public_branch',
2855
A publically-accessible version of this branch.
2857
This implies that the branch setting this option is not publically-accessible.
2858
Used and set by ``bzr send``.
2860
option_registry.register(
2861
Option('push_location',
2864
The location of the default branch for push.
2866
This option is normally set by the first ``push`` or ``push --remember``.
2868
option_registry.register(
2869
Option('push_strict', default=None,
2870
from_unicode=bool_from_store,
2872
The default value for ``push --strict``.
2874
If present, defines the ``--strict`` option default value for checking
2875
uncommitted changes before sending a merge directive.
2877
option_registry.register(
2878
Option('repository.fdatasync', default=True,
2879
from_unicode=bool_from_store,
2881
Flush repository changes onto physical disk?
2883
If true (default), repository changes are flushed through the OS buffers
2884
to physical disk. This is somewhat slower, but means data should not be
2885
lost if the machine crashes. See also dirstate.fdatasync.
2887
option_registry.register_lazy('smtp_server',
2888
'breezy.smtp_connection', 'smtp_server')
2889
option_registry.register_lazy('smtp_password',
2890
'breezy.smtp_connection', 'smtp_password')
2891
option_registry.register_lazy('smtp_username',
2892
'breezy.smtp_connection', 'smtp_username')
2893
option_registry.register(
2894
Option('selftest.timeout',
2896
from_unicode=int_from_store,
2897
help='Abort selftest if one test takes longer than this many seconds',
2900
option_registry.register(
2901
Option('send_strict', default=None,
2902
from_unicode=bool_from_store,
2904
The default value for ``send --strict``.
2906
If present, defines the ``--strict`` option default value for checking
2907
uncommitted changes before sending a bundle.
2910
option_registry.register(
2911
Option('serve.client_timeout',
2912
default=300.0, from_unicode=float_from_store,
2913
help="If we wait for a new request from a client for more than"
2914
" X seconds, consider the client idle, and hangup."))
2915
option_registry.register(
2916
Option('stacked_on_location',
2918
help="""The location where this branch is stacked on."""))
2919
option_registry.register(
2920
Option('submit_branch',
2923
The branch you intend to submit your current work to.
2925
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2926
by the ``submit:`` revision spec.
2928
option_registry.register(
2930
help='''Where submissions from this branch are mailed to.'''))
2931
option_registry.register(
2932
ListOption('suppress_warnings',
2934
help="List of warning classes to suppress."))
2935
option_registry.register(
2936
Option('validate_signatures_in_log', default=False,
2937
from_unicode=bool_from_store, invalid='warning',
2938
help='''Whether to validate signatures in brz log.'''))
2939
option_registry.register_lazy('ssl.ca_certs',
2940
'breezy.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2942
option_registry.register_lazy('ssl.cert_reqs',
2943
'breezy.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2946
class Section(object):
2947
"""A section defines a dict of option name => value.
2949
This is merely a read-only dict which can add some knowledge about the
2950
options. It is *not* a python dict object though and doesn't try to mimic
2954
def __init__(self, section_id, options):
2955
self.id = section_id
2956
# We re-use the dict-like object received
2957
self.options = options
2959
def get(self, name, default=None, expand=True):
2960
return self.options.get(name, default)
2962
def iter_option_names(self):
2963
for k in self.options.keys():
2967
# Mostly for debugging use
2968
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2971
_NewlyCreatedOption = object()
2972
"""Was the option created during the MutableSection lifetime"""
2973
_DeletedOption = object()
2974
"""Was the option deleted during the MutableSection lifetime"""
2977
class MutableSection(Section):
2978
"""A section allowing changes and keeping track of the original values."""
2980
def __init__(self, section_id, options):
2981
super(MutableSection, self).__init__(section_id, options)
2982
self.reset_changes()
2984
def set(self, name, value):
2985
if name not in self.options:
2986
# This is a new option
2987
self.orig[name] = _NewlyCreatedOption
2988
elif name not in self.orig:
2989
self.orig[name] = self.get(name, None)
2990
self.options[name] = value
2992
def remove(self, name):
2993
if name not in self.orig and name in self.options:
2994
self.orig[name] = self.get(name, None)
2995
del self.options[name]
2997
def reset_changes(self):
3000
def apply_changes(self, dirty, store):
3001
"""Apply option value changes.
3003
``self`` has been reloaded from the persistent storage. ``dirty``
3004
contains the changes made since the previous loading.
3006
:param dirty: the mutable section containing the changes.
3008
:param store: the store containing the section
3010
for k, expected in dirty.orig.items():
3011
actual = dirty.get(k, _DeletedOption)
3012
reloaded = self.get(k, _NewlyCreatedOption)
3013
if actual is _DeletedOption:
3014
if k in self.options:
3018
# Report concurrent updates in an ad-hoc way. This should only
3019
# occurs when different processes try to update the same option
3020
# which is not supported (as in: the config framework is not meant
3021
# to be used as a sharing mechanism).
3022
if expected != reloaded:
3023
if actual is _DeletedOption:
3024
actual = '<DELETED>'
3025
if reloaded is _NewlyCreatedOption:
3026
reloaded = '<CREATED>'
3027
if expected is _NewlyCreatedOption:
3028
expected = '<CREATED>'
3029
# Someone changed the value since we get it from the persistent
3031
trace.warning(gettext(
3032
"Option {0} in section {1} of {2} was changed"
3033
" from {3} to {4}. The {5} value will be saved.".format(
3034
k, self.id, store.external_url(), expected,
3036
# No need to keep track of these changes
3037
self.reset_changes()
3040
class Store(object):
3041
"""Abstract interface to persistent storage for configuration options."""
3043
readonly_section_class = Section
3044
mutable_section_class = MutableSection
3047
# Which sections need to be saved (by section id). We use a dict here
3048
# so the dirty sections can be shared by multiple callers.
3049
self.dirty_sections = {}
3051
def is_loaded(self):
3052
"""Returns True if the Store has been loaded.
3054
This is used to implement lazy loading and ensure the persistent
3055
storage is queried only when needed.
3057
raise NotImplementedError(self.is_loaded)
3060
"""Loads the Store from persistent storage."""
3061
raise NotImplementedError(self.load)
3063
def _load_from_string(self, bytes):
3064
"""Create a store from a string in configobj syntax.
3066
:param bytes: A string representing the file content.
3068
raise NotImplementedError(self._load_from_string)
3071
"""Unloads the Store.
3073
This should make is_loaded() return False. This is used when the caller
3074
knows that the persistent storage has changed or may have change since
3077
raise NotImplementedError(self.unload)
3079
def quote(self, value):
3080
"""Quote a configuration option value for storing purposes.
3082
This allows Stacks to present values as they will be stored.
3086
def unquote(self, value):
3087
"""Unquote a configuration option value into unicode.
3089
The received value is quoted as stored.
3094
"""Saves the Store to persistent storage."""
3095
raise NotImplementedError(self.save)
3097
def _need_saving(self):
3098
for s in self.dirty_sections.values():
3100
# At least one dirty section contains a modification
3104
def apply_changes(self, dirty_sections):
3105
"""Apply changes from dirty sections while checking for coherency.
3107
The Store content is discarded and reloaded from persistent storage to
3108
acquire up-to-date values.
3110
Dirty sections are MutableSection which kept track of the value they
3111
are expected to update.
3113
# We need an up-to-date version from the persistent storage, unload the
3114
# store. The reload will occur when needed (triggered by the first
3115
# get_mutable_section() call below.
3117
# Apply the changes from the preserved dirty sections
3118
for section_id, dirty in dirty_sections.items():
3119
clean = self.get_mutable_section(section_id)
3120
clean.apply_changes(dirty, self)
3121
# Everything is clean now
3122
self.dirty_sections = {}
3124
def save_changes(self):
3125
"""Saves the Store to persistent storage if changes occurred.
3127
Apply the changes recorded in the mutable sections to a store content
3128
refreshed from persistent storage.
3130
raise NotImplementedError(self.save_changes)
3132
def external_url(self):
3133
raise NotImplementedError(self.external_url)
3135
def get_sections(self):
3136
"""Returns an ordered iterable of existing sections.
3138
:returns: An iterable of (store, section).
3140
raise NotImplementedError(self.get_sections)
3142
def get_mutable_section(self, section_id=None):
3143
"""Returns the specified mutable section.
3145
:param section_id: The section identifier
3147
raise NotImplementedError(self.get_mutable_section)
3150
# Mostly for debugging use
3151
return "<config.%s(%s)>" % (self.__class__.__name__,
3152
self.external_url())
3155
class CommandLineStore(Store):
3156
"A store to carry command line overrides for the config options."""
3158
def __init__(self, opts=None):
3159
super(CommandLineStore, self).__init__()
3166
# The dict should be cleared but not replaced so it can be shared.
3167
self.options.clear()
3169
def _from_cmdline(self, overrides):
3170
# Reset before accepting new definitions
3172
for over in overrides:
3174
name, value = over.split('=', 1)
3176
raise errors.BzrCommandError(
3177
gettext("Invalid '%s', should be of the form 'name=value'")
3179
self.options[name] = value
3181
def external_url(self):
3182
# Not an url but it makes debugging easier and is never needed
3186
def get_sections(self):
3187
yield self, self.readonly_section_class(None, self.options)
3190
class IniFileStore(Store):
3191
"""A config Store using ConfigObj for storage.
3193
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3194
serialize/deserialize the config file.
3198
"""A config Store using ConfigObj for storage.
3200
super(IniFileStore, self).__init__()
3201
self._config_obj = None
3203
def is_loaded(self):
3204
return self._config_obj is not None
3207
self._config_obj = None
3208
self.dirty_sections = {}
3210
def _load_content(self):
3211
"""Load the config file bytes.
3213
This should be provided by subclasses
3215
:return: Byte string
3217
raise NotImplementedError(self._load_content)
3219
def _save_content(self, content):
3220
"""Save the config file bytes.
3222
This should be provided by subclasses
3224
:param content: Config file bytes to write
3226
raise NotImplementedError(self._save_content)
3229
"""Load the store from the associated file."""
3230
if self.is_loaded():
3232
content = self._load_content()
3233
self._load_from_string(content)
3234
for hook in ConfigHooks['load']:
3237
def _load_from_string(self, bytes):
3238
"""Create a config store from a string.
3240
:param bytes: A string representing the file content.
3242
if self.is_loaded():
3243
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3244
co_input = BytesIO(bytes)
3246
# The config files are always stored utf8-encoded
3247
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3249
except configobj.ConfigObjError as e:
3250
self._config_obj = None
3251
raise ParseConfigError(e.errors, self.external_url())
3252
except UnicodeDecodeError:
3253
raise ConfigContentError(self.external_url())
3255
def save_changes(self):
3256
if not self.is_loaded():
3259
if not self._need_saving():
3261
# Preserve the current version
3262
dirty_sections = self.dirty_sections.copy()
3263
self.apply_changes(dirty_sections)
3264
# Save to the persistent storage
3268
if not self.is_loaded():
3272
self._config_obj.write(out)
3273
self._save_content(out.getvalue())
3274
for hook in ConfigHooks['save']:
3277
def get_sections(self):
3278
"""Get the configobj section in the file order.
3280
:returns: An iterable of (store, section).
3282
# We need a loaded store
3285
except (errors.NoSuchFile, errors.PermissionDenied):
3286
# If the file can't be read, there is no sections
3288
cobj = self._config_obj
3290
yield self, self.readonly_section_class(None, cobj)
3291
for section_name in cobj.sections:
3293
self.readonly_section_class(section_name,
3294
cobj[section_name]))
3296
def get_mutable_section(self, section_id=None):
3297
# We need a loaded store
3300
except errors.NoSuchFile:
3301
# The file doesn't exist, let's pretend it was empty
3302
self._load_from_string(b'')
3303
if section_id in self.dirty_sections:
3304
# We already created a mutable section for this id
3305
return self.dirty_sections[section_id]
3306
if section_id is None:
3307
section = self._config_obj
3309
section = self._config_obj.setdefault(section_id, {})
3310
mutable_section = self.mutable_section_class(section_id, section)
3311
# All mutable sections can become dirty
3312
self.dirty_sections[section_id] = mutable_section
3313
return mutable_section
3315
def quote(self, value):
3317
# configobj conflates automagical list values and quoting
3318
self._config_obj.list_values = True
3319
return self._config_obj._quote(value)
3321
self._config_obj.list_values = False
3323
def unquote(self, value):
3324
if value and isinstance(value, string_types):
3325
# _unquote doesn't handle None nor empty strings nor anything that
3326
# is not a string, really.
3327
value = self._config_obj._unquote(value)
3330
def external_url(self):
3331
# Since an IniFileStore can be used without a file (at least in tests),
3332
# it's better to provide something than raising a NotImplementedError.
3333
# All daughter classes are supposed to provide an implementation
3335
return 'In-Process Store, no URL'
3338
class TransportIniFileStore(IniFileStore):
3339
"""IniFileStore that loads files from a transport.
3341
:ivar transport: The transport object where the config file is located.
3343
:ivar file_name: The config file basename in the transport directory.
3346
def __init__(self, transport, file_name):
3347
"""A Store using a ini file on a Transport
3349
:param transport: The transport object where the config file is located.
3350
:param file_name: The config file basename in the transport directory.
3352
super(TransportIniFileStore, self).__init__()
3353
self.transport = transport
3354
self.file_name = file_name
3356
def _load_content(self):
3358
return self.transport.get_bytes(self.file_name)
3359
except errors.PermissionDenied:
3360
trace.warning("Permission denied while trying to load "
3361
"configuration store %s.", self.external_url())
3364
def _save_content(self, content):
3365
self.transport.put_bytes(self.file_name, content)
3367
def external_url(self):
3368
# FIXME: external_url should really accepts an optional relpath
3369
# parameter (bug #750169) :-/ -- vila 2011-04-04
3370
# The following will do in the interim but maybe we don't want to
3371
# expose a path here but rather a config ID and its associated
3372
# object </hand wawe>.
3373
return urlutils.join(
3374
self.transport.external_url(), urlutils.escape(self.file_name))
3377
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3378
# unlockable stores for use with objects that can already ensure the locking
3379
# (think branches). If different stores (not based on ConfigObj) are created,
3380
# they may face the same issue.
3383
class LockableIniFileStore(TransportIniFileStore):
3384
"""A ConfigObjStore using locks on save to ensure store integrity."""
3386
def __init__(self, transport, file_name, lock_dir_name=None):
3387
"""A config Store using ConfigObj for storage.
3389
:param transport: The transport object where the config file is located.
3391
:param file_name: The config file basename in the transport directory.
3393
if lock_dir_name is None:
3394
lock_dir_name = 'lock'
3395
self.lock_dir_name = lock_dir_name
3396
super(LockableIniFileStore, self).__init__(transport, file_name)
3397
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3399
def lock_write(self, token=None):
3400
"""Takes a write lock in the directory containing the config file.
3402
If the directory doesn't exist it is created.
3404
# FIXME: This doesn't check the ownership of the created directories as
3405
# ensure_config_dir_exists does. It should if the transport is local
3406
# -- vila 2011-04-06
3407
self.transport.create_prefix()
3408
token = self._lock.lock_write(token)
3409
return lock.LogicalLockResult(self.unlock, token)
3414
def break_lock(self):
3415
self._lock.break_lock()
3418
with self.lock_write():
3419
# We need to be able to override the undecorated implementation
3420
self.save_without_locking()
3422
def save_without_locking(self):
3423
super(LockableIniFileStore, self).save()
3426
# FIXME: global, breezy, shouldn't that be 'user' instead or even
3427
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3428
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3430
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3431
# functions or a registry will make it easier and clearer for tests, focusing
3432
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3433
# on a poolie's remark)
3434
class GlobalStore(LockableIniFileStore):
3435
"""A config store for global options.
3437
There is a single GlobalStore for a given process.
3440
def __init__(self, possible_transports=None):
3441
(path, kind) = _config_dir()
3442
t = transport.get_transport_from_path(
3443
path, possible_transports=possible_transports)
3444
filename = {'bazaar': 'bazaar.conf', 'breezy': 'breezy.conf'}[kind]
3445
super(GlobalStore, self).__init__(t, filename)
3449
class LocationStore(LockableIniFileStore):
3450
"""A config store for options specific to a location.
3452
There is a single LocationStore for a given process.
3455
def __init__(self, possible_transports=None):
3456
t = transport.get_transport_from_path(
3457
config_dir(), possible_transports=possible_transports)
3458
super(LocationStore, self).__init__(t, 'locations.conf')
3459
self.id = 'locations'
3462
class BranchStore(TransportIniFileStore):
3463
"""A config store for branch options.
3465
There is a single BranchStore for a given branch.
3468
def __init__(self, branch):
3469
super(BranchStore, self).__init__(branch.control_transport,
3471
self.branch = branch
3475
class ControlStore(LockableIniFileStore):
3477
def __init__(self, bzrdir):
3478
super(ControlStore, self).__init__(bzrdir.transport,
3480
lock_dir_name='branch_lock')
3484
class SectionMatcher(object):
3485
"""Select sections into a given Store.
3487
This is intended to be used to postpone getting an iterable of sections
3491
def __init__(self, store):
3494
def get_sections(self):
3495
# This is where we require loading the store so we can see all defined
3497
sections = self.store.get_sections()
3498
# Walk the revisions in the order provided
3499
for store, s in sections:
3503
def match(self, section):
3504
"""Does the proposed section match.
3506
:param section: A Section object.
3508
:returns: True if the section matches, False otherwise.
3510
raise NotImplementedError(self.match)
3513
class NameMatcher(SectionMatcher):
3515
def __init__(self, store, section_id):
3516
super(NameMatcher, self).__init__(store)
3517
self.section_id = section_id
3519
def match(self, section):
3520
return section.id == self.section_id
3523
class LocationSection(Section):
3525
def __init__(self, section, extra_path, branch_name=None):
3526
super(LocationSection, self).__init__(section.id, section.options)
3527
self.extra_path = extra_path
3528
if branch_name is None:
3530
self.locals = {'relpath': extra_path,
3531
'basename': urlutils.basename(extra_path),
3532
'branchname': branch_name}
3534
def get(self, name, default=None, expand=True):
3535
value = super(LocationSection, self).get(name, default)
3536
if value is not None and expand:
3537
policy_name = self.get(name + ':policy', None)
3538
policy = _policy_value.get(policy_name, POLICY_NONE)
3539
if policy == POLICY_APPENDPATH:
3540
value = urlutils.join(value, self.extra_path)
3541
# expand section local options right now (since POLICY_APPENDPATH
3542
# will never add options references, it's ok to expand after it).
3544
for is_ref, chunk in iter_option_refs(value):
3546
chunks.append(chunk)
3549
if ref in self.locals:
3550
chunks.append(self.locals[ref])
3552
chunks.append(chunk)
3553
value = ''.join(chunks)
3557
class StartingPathMatcher(SectionMatcher):
3558
"""Select sections for a given location respecting the Store order."""
3560
# FIXME: Both local paths and urls can be used for section names as well as
3561
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3562
# inherited the fuzziness from the previous ``LocationConfig``
3563
# implementation. We probably need to revisit which encoding is allowed for
3564
# both ``location`` and section names and how we normalize
3565
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3566
# related too. -- vila 2012-01-04
3568
def __init__(self, store, location):
3569
super(StartingPathMatcher, self).__init__(store)
3570
if location.startswith('file://'):
3571
location = urlutils.local_path_from_url(location)
3572
self.location = location
3574
def get_sections(self):
3575
"""Get all sections matching ``location`` in the store.
3577
The most generic sections are described first in the store, then more
3578
specific ones can be provided for reduced scopes.
3580
The returned section are therefore returned in the reversed order so
3581
the most specific ones can be found first.
3583
location_parts = self.location.rstrip('/').split('/')
3585
# Later sections are more specific, they should be returned first
3586
for _, section in reversed(list(store.get_sections())):
3587
if section.id is None:
3588
# The no-name section is always included if present
3589
yield store, LocationSection(section, self.location)
3591
section_path = section.id
3592
if section_path.startswith('file://'):
3593
# the location is already a local path or URL, convert the
3594
# section id to the same format
3595
section_path = urlutils.local_path_from_url(section_path)
3596
if (self.location.startswith(section_path) or
3597
fnmatch.fnmatch(self.location, section_path)):
3598
section_parts = section_path.rstrip('/').split('/')
3599
extra_path = '/'.join(location_parts[len(section_parts):])
3600
yield store, LocationSection(section, extra_path)
3603
class LocationMatcher(SectionMatcher):
3605
def __init__(self, store, location):
3606
super(LocationMatcher, self).__init__(store)
3607
url, params = urlutils.split_segment_parameters(location)
3608
if location.startswith('file://'):
3609
location = urlutils.local_path_from_url(location)
3610
self.location = location
3611
branch_name = params.get('branch')
3612
if branch_name is None:
3613
self.branch_name = urlutils.basename(self.location)
3615
self.branch_name = urlutils.unescape(branch_name)
3617
def _get_matching_sections(self):
3618
"""Get all sections matching ``location``."""
3619
# We slightly diverge from LocalConfig here by allowing the no-name
3620
# section as the most generic one and the lower priority.
3621
no_name_section = None
3623
# Filter out the no_name_section so _iter_for_location_by_parts can be
3624
# used (it assumes all sections have a name).
3625
for _, section in self.store.get_sections():
3626
if section.id is None:
3627
no_name_section = section
3629
all_sections.append(section)
3630
# Unfortunately _iter_for_location_by_parts deals with section names so
3631
# we have to resync.
3632
filtered_sections = _iter_for_location_by_parts(
3633
[s.id for s in all_sections], self.location)
3634
iter_all_sections = iter(all_sections)
3635
matching_sections = []
3636
if no_name_section is not None:
3637
matching_sections.append(
3638
(0, LocationSection(no_name_section, self.location)))
3639
for section_id, extra_path, length in filtered_sections:
3640
# a section id is unique for a given store so it's safe to take the
3641
# first matching section while iterating. Also, all filtered
3642
# sections are part of 'all_sections' and will always be found
3645
section = next(iter_all_sections)
3646
if section_id == section.id:
3647
section = LocationSection(section, extra_path,
3649
matching_sections.append((length, section))
3651
return matching_sections
3653
def get_sections(self):
3654
# Override the default implementation as we want to change the order
3655
# We want the longest (aka more specific) locations first
3656
sections = sorted(self._get_matching_sections(),
3657
key=lambda match: (match[0], match[1].id),
3659
# Sections mentioning 'ignore_parents' restrict the selection
3660
for _, section in sections:
3661
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3662
ignore = section.get('ignore_parents', None)
3663
if ignore is not None:
3664
ignore = ui.bool_from_string(ignore)
3667
# Finally, we have a valid section
3668
yield self.store, section
3671
# FIXME: _shared_stores should be an attribute of a library state once a
3672
# library_state object is always available.
3674
_shared_stores_at_exit_installed = False
3677
class Stack(object):
3678
"""A stack of configurations where an option can be defined"""
3680
def __init__(self, sections_def, store=None, mutable_section_id=None):
3681
"""Creates a stack of sections with an optional store for changes.
3683
:param sections_def: A list of Section or callables that returns an
3684
iterable of Section. This defines the Sections for the Stack and
3685
can be called repeatedly if needed.
3687
:param store: The optional Store where modifications will be
3688
recorded. If none is specified, no modifications can be done.
3690
:param mutable_section_id: The id of the MutableSection where changes
3691
are recorded. This requires the ``store`` parameter to be
3694
self.sections_def = sections_def
3696
self.mutable_section_id = mutable_section_id
3698
def iter_sections(self):
3699
"""Iterate all the defined sections."""
3700
# Ensuring lazy loading is achieved by delaying section matching (which
3701
# implies querying the persistent storage) until it can't be avoided
3702
# anymore by using callables to describe (possibly empty) section
3704
for sections in self.sections_def:
3705
for store, section in sections():
3706
yield store, section
3708
def get(self, name, expand=True, convert=True):
3709
"""Return the *first* option value found in the sections.
3711
This is where we guarantee that sections coming from Store are loaded
3712
lazily: the loading is delayed until we need to either check that an
3713
option exists or get its value, which in turn may require to discover
3714
in which sections it can be defined. Both of these (section and option
3715
existence) require loading the store (even partially).
3717
:param name: The queried option.
3719
:param expand: Whether options references should be expanded.
3721
:param convert: Whether the option value should be converted from
3722
unicode (do nothing for non-registered options).
3724
:returns: The value of the option.
3726
# FIXME: No caching of options nor sections yet -- vila 20110503
3728
found_store = None # Where the option value has been found
3729
# If the option is registered, it may provide additional info about
3732
opt = option_registry.get(name)
3737
def expand_and_convert(val):
3738
# This may need to be called in different contexts if the value is
3739
# None or ends up being None during expansion or conversion.
3742
if isinstance(val, string_types):
3743
val = self._expand_options_in_string(val)
3745
trace.warning('Cannot expand "%s":'
3746
' %s does not support option expansion'
3747
% (name, type(val)))
3749
val = found_store.unquote(val)
3751
val = opt.convert_from_unicode(found_store, val)
3754
# First of all, check if the environment can override the configuration
3756
if opt is not None and opt.override_from_env:
3757
value = opt.get_override()
3758
value = expand_and_convert(value)
3760
for store, section in self.iter_sections():
3761
value = section.get(name)
3762
if value is not None:
3765
value = expand_and_convert(value)
3766
if opt is not None and value is None:
3767
# If the option is registered, it may provide a default value
3768
value = opt.get_default()
3769
value = expand_and_convert(value)
3770
for hook in ConfigHooks['get']:
3771
hook(self, name, value)
3774
def expand_options(self, string, env=None):
3775
"""Expand option references in the string in the configuration context.
3777
:param string: The string containing option(s) to expand.
3779
:param env: An option dict defining additional configuration options or
3780
overriding existing ones.
3782
:returns: The expanded string.
3784
return self._expand_options_in_string(string, env)
3786
def _expand_options_in_string(self, string, env=None, _refs=None):
3787
"""Expand options in the string in the configuration context.
3789
:param string: The string to be expanded.
3791
:param env: An option dict defining additional configuration options or
3792
overriding existing ones.
3794
:param _refs: Private list (FIFO) containing the options being expanded
3797
:returns: The expanded string.
3800
# Not much to expand there
3803
# What references are currently resolved (to detect loops)
3806
# We need to iterate until no more refs appear ({{foo}} will need two
3807
# iterations for example).
3812
for is_ref, chunk in iter_option_refs(result):
3814
chunks.append(chunk)
3819
raise OptionExpansionLoop(string, _refs)
3821
value = self._expand_option(name, env, _refs)
3823
raise ExpandingUnknownOption(name, string)
3824
chunks.append(value)
3826
result = ''.join(chunks)
3829
def _expand_option(self, name, env, _refs):
3830
if env is not None and name in env:
3831
# Special case, values provided in env takes precedence over
3835
value = self.get(name, expand=False, convert=False)
3836
value = self._expand_options_in_string(value, env, _refs)
3839
def _get_mutable_section(self):
3840
"""Get the MutableSection for the Stack.
3842
This is where we guarantee that the mutable section is lazily loaded:
3843
this means we won't load the corresponding store before setting a value
3844
or deleting an option. In practice the store will often be loaded but
3845
this helps catching some programming errors.
3848
section = store.get_mutable_section(self.mutable_section_id)
3849
return store, section
3851
def set(self, name, value):
3852
"""Set a new value for the option."""
3853
store, section = self._get_mutable_section()
3854
section.set(name, store.quote(value))
3855
for hook in ConfigHooks['set']:
3856
hook(self, name, value)
3858
def remove(self, name):
3859
"""Remove an existing option."""
3860
_, section = self._get_mutable_section()
3861
section.remove(name)
3862
for hook in ConfigHooks['remove']:
3866
# Mostly for debugging use
3867
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3869
def _get_overrides(self):
3870
if breezy._global_state is not None:
3871
# TODO(jelmer): Urgh, this is circular so we can't call breezy.get_global_state()
3872
return breezy._global_state.cmdline_overrides.get_sections()
3875
def get_shared_store(self, store, state=None):
3876
"""Get a known shared store.
3878
Store urls uniquely identify them and are used to ensure a single copy
3879
is shared across all users.
3881
:param store: The store known to the caller.
3883
:param state: The library state where the known stores are kept.
3885
:returns: The store received if it's not a known one, an already known
3889
# TODO(jelmer): Urgh, this is circular so we can't call breezy.get_global_state()
3890
state = breezy._global_state
3892
global _shared_stores_at_exit_installed
3893
stores = _shared_stores
3895
def save_config_changes():
3896
for k, store in stores.items():
3897
store.save_changes()
3898
if not _shared_stores_at_exit_installed:
3899
# FIXME: Ugly hack waiting for library_state to always be
3900
# available. -- vila 20120731
3902
atexit.register(save_config_changes)
3903
_shared_stores_at_exit_installed = True
3905
stores = state.config_stores
3906
url = store.external_url()
3914
class MemoryStack(Stack):
3915
"""A configuration stack defined from a string.
3917
This is mainly intended for tests and requires no disk resources.
3920
def __init__(self, content=None):
3921
"""Create an in-memory stack from a given content.
3923
It uses a single store based on configobj and support reading and
3926
:param content: The initial content of the store. If None, the store is
3927
not loaded and ``_load_from_string`` can and should be used if
3930
store = IniFileStore()
3931
if content is not None:
3932
store._load_from_string(content)
3933
super(MemoryStack, self).__init__(
3934
[store.get_sections], store)
3937
class _CompatibleStack(Stack):
3938
"""Place holder for compatibility with previous design.
3940
This is intended to ease the transition from the Config-based design to the
3941
Stack-based design and should not be used nor relied upon by plugins.
3943
One assumption made here is that the daughter classes will all use Stores
3944
derived from LockableIniFileStore).
3946
It implements set() and remove () by re-loading the store before applying
3947
the modification and saving it.
3949
The long term plan being to implement a single write by store to save
3950
all modifications, this class should not be used in the interim.
3953
def set(self, name, value):
3956
super(_CompatibleStack, self).set(name, value)
3957
# Force a write to persistent storage
3960
def remove(self, name):
3963
super(_CompatibleStack, self).remove(name)
3964
# Force a write to persistent storage
3968
class GlobalStack(Stack):
3969
"""Global options only stack.
3971
The following sections are queried:
3973
* command-line overrides,
3975
* the 'DEFAULT' section in bazaar.conf
3977
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3982
gstore = self.get_shared_store(GlobalStore())
3983
super(GlobalStack, self).__init__(
3984
[self._get_overrides,
3985
NameMatcher(gstore, 'DEFAULT').get_sections],
3986
gstore, mutable_section_id='DEFAULT')
3989
class LocationStack(Stack):
3990
"""Per-location options falling back to global options stack.
3993
The following sections are queried:
3995
* command-line overrides,
3997
* the sections matching ``location`` in ``locations.conf``, the order being
3998
defined by the number of path components in the section glob, higher
3999
numbers first (from most specific section to most generic).
4001
* the 'DEFAULT' section in bazaar.conf
4003
This stack will use the ``location`` section in locations.conf as its
4007
def __init__(self, location):
4008
"""Make a new stack for a location and global configuration.
4010
:param location: A URL prefix to """
4011
lstore = self.get_shared_store(LocationStore())
4012
if location.startswith('file://'):
4013
location = urlutils.local_path_from_url(location)
4014
gstore = self.get_shared_store(GlobalStore())
4015
super(LocationStack, self).__init__(
4016
[self._get_overrides,
4017
LocationMatcher(lstore, location).get_sections,
4018
NameMatcher(gstore, 'DEFAULT').get_sections],
4019
lstore, mutable_section_id=location)
4022
class BranchStack(Stack):
4023
"""Per-location options falling back to branch then global options stack.
4025
The following sections are queried:
4027
* command-line overrides,
4029
* the sections matching ``location`` in ``locations.conf``, the order being
4030
defined by the number of path components in the section glob, higher
4031
numbers first (from most specific section to most generic),
4033
* the no-name section in branch.conf,
4035
* the ``DEFAULT`` section in ``bazaar.conf``.
4037
This stack will use the no-name section in ``branch.conf`` as its
4041
def __init__(self, branch):
4042
lstore = self.get_shared_store(LocationStore())
4043
bstore = branch._get_config_store()
4044
gstore = self.get_shared_store(GlobalStore())
4045
super(BranchStack, self).__init__(
4046
[self._get_overrides,
4047
LocationMatcher(lstore, branch.base).get_sections,
4048
NameMatcher(bstore, None).get_sections,
4049
NameMatcher(gstore, 'DEFAULT').get_sections],
4051
self.branch = branch
4053
def lock_write(self, token=None):
4054
return self.branch.lock_write(token)
4057
return self.branch.unlock()
4059
def set(self, name, value):
4060
with self.lock_write():
4061
super(BranchStack, self).set(name, value)
4062
# Unlocking the branch will trigger a store.save_changes() so the
4063
# last unlock saves all the changes.
4065
def remove(self, name):
4066
with self.lock_write():
4067
super(BranchStack, self).remove(name)
4068
# Unlocking the branch will trigger a store.save_changes() so the
4069
# last unlock saves all the changes.
4072
class RemoteControlStack(Stack):
4073
"""Remote control-only options stack."""
4075
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4076
# with the stack used for remote bzr dirs. RemoteControlStack only uses
4077
# control.conf and is used only for stack options.
4079
def __init__(self, bzrdir):
4080
cstore = bzrdir._get_config_store()
4081
super(RemoteControlStack, self).__init__(
4082
[NameMatcher(cstore, None).get_sections],
4084
self.controldir = bzrdir
4087
class BranchOnlyStack(Stack):
4088
"""Branch-only options stack."""
4090
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4091
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4092
# -- vila 2011-12-16
4094
def __init__(self, branch):
4095
bstore = branch._get_config_store()
4096
super(BranchOnlyStack, self).__init__(
4097
[NameMatcher(bstore, None).get_sections],
4099
self.branch = branch
4101
def lock_write(self, token=None):
4102
return self.branch.lock_write(token)
4105
return self.branch.unlock()
4107
def set(self, name, value):
4108
with self.lock_write():
4109
super(BranchOnlyStack, self).set(name, value)
4110
# Force a write to persistent storage
4111
self.store.save_changes()
4113
def remove(self, name):
4114
with self.lock_write():
4115
super(BranchOnlyStack, self).remove(name)
4116
# Force a write to persistent storage
4117
self.store.save_changes()
4120
class cmd_config(commands.Command):
4121
__doc__ = """Display, set or remove a configuration option.
4123
Display the active value for option NAME.
4125
If --all is specified, NAME is interpreted as a regular expression and all
4126
matching options are displayed mentioning their scope and without resolving
4127
option references in the value). The active value that bzr will take into
4128
account is the first one displayed for each option.
4130
If NAME is not given, --all .* is implied (all options are displayed for the
4133
Setting a value is achieved by using NAME=value without spaces. The value
4134
is set in the most relevant scope and can be checked by displaying the
4137
Removing a value is achieved by using --remove NAME.
4140
takes_args = ['name?']
4144
# FIXME: This should be a registry option so that plugins can register
4145
# their own config files (or not) and will also address
4146
# http://pad.lv/788991 -- vila 20101115
4147
commands.Option('scope', help='Reduce the scope to the specified'
4148
' configuration file.',
4150
commands.Option('all',
4151
help='Display all the defined values for the matching options.',
4153
commands.Option('remove', help='Remove the option from'
4154
' the configuration file.'),
4157
_see_also = ['configuration']
4159
@commands.display_command
4160
def run(self, name=None, all=False, directory=None, scope=None,
4162
if directory is None:
4164
directory = directory_service.directories.dereference(directory)
4165
directory = urlutils.normalize_url(directory)
4167
raise errors.BzrError(
4168
'--all and --remove are mutually exclusive.')
4170
# Delete the option in the given scope
4171
self._remove_config_option(name, directory, scope)
4173
# Defaults to all options
4174
self._show_matching_options('.*', directory, scope)
4177
name, value = name.split('=', 1)
4179
# Display the option(s) value(s)
4181
self._show_matching_options(name, directory, scope)
4183
self._show_value(name, directory, scope)
4186
raise errors.BzrError(
4187
'Only one option can be set.')
4188
# Set the option value
4189
self._set_config_option(name, value, directory, scope)
4191
def _get_stack(self, directory, scope=None, write_access=False):
4192
"""Get the configuration stack specified by ``directory`` and ``scope``.
4194
:param directory: Where the configurations are derived from.
4196
:param scope: A specific config to start from.
4198
:param write_access: Whether a write access to the stack will be
4201
# FIXME: scope should allow access to plugin-specific stacks (even
4202
# reduced to the plugin-specific store), related to
4203
# http://pad.lv/788991 -- vila 2011-11-15
4204
if scope is not None:
4205
if scope == 'breezy':
4206
return GlobalStack()
4207
elif scope == 'locations':
4208
return LocationStack(directory)
4209
elif scope == 'branch':
4211
controldir.ControlDir.open_containing_tree_or_branch(
4214
self.add_cleanup(br.lock_write().unlock)
4215
return br.get_config_stack()
4216
raise NoSuchConfig(scope)
4220
controldir.ControlDir.open_containing_tree_or_branch(
4223
self.add_cleanup(br.lock_write().unlock)
4224
return br.get_config_stack()
4225
except errors.NotBranchError:
4226
return LocationStack(directory)
4228
def _quote_multiline(self, value):
4230
value = '"""' + value + '"""'
4233
def _show_value(self, name, directory, scope):
4234
conf = self._get_stack(directory, scope)
4235
value = conf.get(name, expand=True, convert=False)
4236
if value is not None:
4237
# Quote the value appropriately
4238
value = self._quote_multiline(value)
4239
self.outf.write('%s\n' % (value,))
4241
raise NoSuchConfigOption(name)
4243
def _show_matching_options(self, name, directory, scope):
4244
name = lazy_regex.lazy_compile(name)
4245
# We want any error in the regexp to be raised *now* so we need to
4246
# avoid the delay introduced by the lazy regexp. But, we still do
4247
# want the nicer errors raised by lazy_regex.
4248
name._compile_and_collapse()
4251
conf = self._get_stack(directory, scope)
4252
for store, section in conf.iter_sections():
4253
for oname in section.iter_option_names():
4254
if name.search(oname):
4255
if cur_store_id != store.id:
4256
# Explain where the options are defined
4257
self.outf.write('%s:\n' % (store.id,))
4258
cur_store_id = store.id
4260
if (section.id is not None and cur_section != section.id):
4261
# Display the section id as it appears in the store
4262
# (None doesn't appear by definition)
4263
self.outf.write(' [%s]\n' % (section.id,))
4264
cur_section = section.id
4265
value = section.get(oname, expand=False)
4266
# Quote the value appropriately
4267
value = self._quote_multiline(value)
4268
self.outf.write(' %s = %s\n' % (oname, value))
4270
def _set_config_option(self, name, value, directory, scope):
4271
conf = self._get_stack(directory, scope, write_access=True)
4272
conf.set(name, value)
4273
# Explicitly save the changes
4274
conf.store.save_changes()
4276
def _remove_config_option(self, name, directory, scope):
4278
raise errors.BzrCommandError(
4279
'--remove expects an option to remove.')
4280
conf = self._get_stack(directory, scope, write_access=True)
4283
# Explicitly save the changes
4284
conf.store.save_changes()
4286
raise NoSuchConfigOption(name)
4291
# We need adapters that can build a Store or a Stack in a test context. Test
4292
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4293
# themselves. The builder will receive a test instance and should return a
4294
# ready-to-use store or stack. Plugins that define new store/stacks can also
4295
# register themselves here to be tested against the tests defined in
4296
# breezy.tests.test_config. Note that the builder can be called multiple times
4297
# for the same test.
4299
# The registered object should be a callable receiving a test instance
4300
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4302
test_store_builder_registry = registry.Registry()
4304
# The registered object should be a callable receiving a test instance
4305
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4307
test_stack_builder_registry = registry.Registry()
added
removed
breezy/config.py
