1
# Copyright (C) 2005-2014, 2016 Canonical Ltd
2
# Authors: Robert Collins <robert.collins@canonical.com>
5
# This program is free software; you can redistribute it and/or modify
6
# it under the terms of the GNU General Public License as published by
7
# the Free Software Foundation; either version 2 of the License, or
8
# (at your option) any later version.
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
# GNU General Public License for more details.
15
# You should have received a copy of the GNU General Public License
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
"""Configuration that affects the behaviour of Breezy.
21
Currently this configuration resides in ~/.config/breezy/breezy.conf
22
and ~/.config/breezy/locations.conf, which is written to by brz.
24
If the first location doesn't exist, then brz falls back to reading
25
Bazaar configuration files in ~/.bazaar or ~/.config/bazaar.
27
In breezy.conf the following options may be set:
29
editor=name-of-program
30
email=Your Name <your@email.address>
31
check_signatures=require|ignore|check-available(default)
32
create_signatures=always|never|when-required(default)
33
log_format=name-of-format
34
validate_signatures_in_log=true|false(default)
35
acceptable_keys=pattern1,pattern2
36
gpg_signing_key=amy@example.com
38
in locations.conf, you specify the url of a branch and options for it.
39
Wildcards may be used - * and ? as normal in shell completion. Options
40
set in both breezy.conf and locations.conf are overridden by the locations.conf
42
[/home/robertc/source]
43
recurse=False|True(default)
45
check_signatures= as above
46
create_signatures= as above.
47
validate_signatures_in_log=as above
48
acceptable_keys=as above
50
explanation of options
51
----------------------
52
editor - this option sets the pop up editor to use during commits.
53
email - this option sets the user id brz will use when committing.
54
check_signatures - this option will control whether brz will require good gpg
55
signatures, ignore them, or check them if they are
56
present. Currently it is unused except that check_signatures
57
turns on create_signatures.
58
create_signatures - this option controls whether brz will always create
59
gpg signatures or not on commits. There is an unused
60
option which in future is expected to work if
61
branch settings require signatures.
62
log_format - this option sets the default log format. Possible values are
63
long, short, line, or a plugin can register new formats.
64
validate_signatures_in_log - show GPG signature validity in log output
65
acceptable_keys - comma separated list of key patterns acceptable for
66
verify-signatures command
68
In breezy.conf you can also define aliases in the ALIASES sections, example
71
lastlog=log --line -r-10..-1
72
ll=log --line -r-10..-1
77
from __future__ import absolute_import
84
from .decorators import needs_write_lock
85
from .lazy_import import lazy_import
86
lazy_import(globals(), """
109
from breezy.i18n import gettext
118
from .sixish import (
139
POLICY_APPENDPATH = 2
143
POLICY_NORECURSE: 'norecurse',
144
POLICY_APPENDPATH: 'appendpath',
149
'norecurse': POLICY_NORECURSE,
150
'appendpath': POLICY_APPENDPATH,
154
STORE_LOCATION = POLICY_NONE
155
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
156
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
161
class OptionExpansionLoop(errors.BzrError):
163
_fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
165
def __init__(self, string, refs):
167
self.refs = '->'.join(refs)
170
class ExpandingUnknownOption(errors.BzrError):
172
_fmt = 'Option "%(name)s" is not defined while expanding "%(string)s".'
174
def __init__(self, name, string):
179
class IllegalOptionName(errors.BzrError):
181
_fmt = 'Option "%(name)s" is not allowed.'
183
def __init__(self, name):
187
class ConfigContentError(errors.BzrError):
189
_fmt = "Config file %(filename)s is not UTF-8 encoded\n"
191
def __init__(self, filename):
192
self.filename = filename
195
class ParseConfigError(errors.BzrError):
197
_fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
199
def __init__(self, errors, filename):
200
self.filename = filename
201
self.errors = '\n'.join(e.msg for e in errors)
204
class ConfigOptionValueError(errors.BzrError):
206
_fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
207
'See ``brz help %(name)s``')
209
def __init__(self, name, value):
210
errors.BzrError.__init__(self, name=name, value=value)
213
class NoEmailInUsername(errors.BzrError):
215
_fmt = "%(username)r does not seem to contain a reasonable email address"
217
def __init__(self, username):
218
self.username = username
221
class NoSuchConfig(errors.BzrError):
223
_fmt = ('The "%(config_id)s" configuration does not exist.')
225
def __init__(self, config_id):
226
errors.BzrError.__init__(self, config_id=config_id)
229
class NoSuchConfigOption(errors.BzrError):
231
_fmt = ('The "%(option_name)s" configuration option does not exist.')
233
def __init__(self, option_name):
234
errors.BzrError.__init__(self, option_name=option_name)
237
class NoWhoami(errors.BzrError):
239
_fmt = ('Unable to determine your name.\n'
240
"Please, set your name with the 'whoami' command.\n"
241
'E.g. brz whoami "Your Name <name@example.com>"')
244
def signature_policy_from_unicode(signature_string):
245
"""Convert a string to a signing policy."""
246
if signature_string.lower() == 'check-available':
247
return CHECK_IF_POSSIBLE
248
if signature_string.lower() == 'ignore':
250
if signature_string.lower() == 'require':
252
raise ValueError("Invalid signatures policy '%s'"
256
def signing_policy_from_unicode(signature_string):
257
"""Convert a string to a signing policy."""
258
if signature_string.lower() == 'when-required':
259
return SIGN_WHEN_REQUIRED
260
if signature_string.lower() == 'never':
262
if signature_string.lower() == 'always':
264
raise ValueError("Invalid signing policy '%s'"
268
def _has_decode_bug():
269
"""True if configobj will fail to decode to unicode on Python 2."""
270
if sys.version_info > (3,):
272
conf = configobj.ConfigObj()
273
decode = getattr(conf, "_decode", None)
275
result = decode(b"\xc2\xa7", "utf-8")
276
if isinstance(result[0], str):
281
def _has_triplequote_bug():
282
"""True if triple quote logic is reversed, see lp:710410."""
283
conf = configobj.ConfigObj()
284
quote = getattr(conf, "_get_triple_quote", None)
285
if quote and quote('"""') != "'''":
290
class ConfigObj(configobj.ConfigObj):
292
def __init__(self, infile=None, **kwargs):
293
# We define our own interpolation mechanism calling it option expansion
294
super(ConfigObj, self).__init__(infile=infile,
298
if _has_decode_bug():
299
def _decode(self, infile, encoding):
300
if isinstance(infile, str) and encoding:
301
return infile.decode(encoding).splitlines(True)
302
return super(ConfigObj, self)._decode(infile, encoding)
304
if _has_triplequote_bug():
305
def _get_triple_quote(self, value):
306
quot = super(ConfigObj, self)._get_triple_quote(value)
307
if quot == configobj.tdquot:
308
return configobj.tsquot
309
return configobj.tdquot
311
def get_bool(self, section, key):
312
return self[section].as_bool(key)
314
def get_value(self, section, name):
315
# Try [] for the old DEFAULT section.
316
if section == "DEFAULT":
321
return self[section][name]
324
class Config(object):
325
"""A configuration policy - what username, editor, gpg needs etc."""
328
super(Config, self).__init__()
331
"""Returns a unique ID for the config."""
332
raise NotImplementedError(self.config_id)
334
def get_change_editor(self, old_tree, new_tree):
335
from breezy import diff
336
cmd = self._get_change_editor()
339
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
342
def _get_signature_checking(self):
343
"""Template method to override signature checking policy."""
345
def _get_signing_policy(self):
346
"""Template method to override signature creation policy."""
350
def expand_options(self, string, env=None):
351
"""Expand option references in the string in the configuration context.
353
:param string: The string containing option to expand.
355
:param env: An option dict defining additional configuration options or
356
overriding existing ones.
358
:returns: The expanded string.
360
return self._expand_options_in_string(string, env)
362
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
363
"""Expand options in a list of strings in the configuration context.
365
:param slist: A list of strings.
367
:param env: An option dict defining additional configuration options or
368
overriding existing ones.
370
:param _ref_stack: Private list containing the options being
371
expanded to detect loops.
373
:returns: The flatten list of expanded strings.
375
# expand options in each value separately flattening lists
378
value = self._expand_options_in_string(s, env, _ref_stack)
379
if isinstance(value, list):
385
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
386
"""Expand options in the string in the configuration context.
388
:param string: The string to be expanded.
390
:param env: An option dict defining additional configuration options or
391
overriding existing ones.
393
:param _ref_stack: Private list containing the options being
394
expanded to detect loops.
396
:returns: The expanded string.
399
# Not much to expand there
401
if _ref_stack is None:
402
# What references are currently resolved (to detect loops)
404
if self.option_ref_re is None:
405
# We want to match the most embedded reference first (i.e. for
406
# '{{foo}}' we will get '{foo}',
407
# for '{bar{baz}}' we will get '{baz}'
408
self.option_ref_re = re.compile('({[^{}]+})')
410
# We need to iterate until no more refs appear ({{foo}} will need two
411
# iterations for example).
413
raw_chunks = self.option_ref_re.split(result)
414
if len(raw_chunks) == 1:
415
# Shorcut the trivial case: no refs
419
# Split will isolate refs so that every other chunk is a ref
421
for chunk in raw_chunks:
424
# Keep only non-empty strings (or we get bogus empty
425
# slots when a list value is involved).
430
if name in _ref_stack:
431
raise OptionExpansionLoop(string, _ref_stack)
432
_ref_stack.append(name)
433
value = self._expand_option(name, env, _ref_stack)
435
raise ExpandingUnknownOption(name, string)
436
if isinstance(value, list):
444
# Once a list appears as the result of an expansion, all
445
# callers will get a list result. This allows a consistent
446
# behavior even when some options in the expansion chain
447
# defined as strings (no comma in their value) but their
448
# expanded value is a list.
449
return self._expand_options_in_list(chunks, env, _ref_stack)
451
result = ''.join(chunks)
454
def _expand_option(self, name, env, _ref_stack):
455
if env is not None and name in env:
456
# Special case, values provided in env takes precedence over
460
# FIXME: This is a limited implementation, what we really need is a
461
# way to query the brz config for the value of an option,
462
# respecting the scope rules (That is, once we implement fallback
463
# configs, getting the option value should restart from the top
464
# config, not the current one) -- vila 20101222
465
value = self.get_user_option(name, expand=False)
466
if isinstance(value, list):
467
value = self._expand_options_in_list(value, env, _ref_stack)
469
value = self._expand_options_in_string(value, env, _ref_stack)
472
def _get_user_option(self, option_name):
473
"""Template method to provide a user option."""
476
def get_user_option(self, option_name, expand=True):
477
"""Get a generic option - no special process, no default.
479
:param option_name: The queried option.
481
:param expand: Whether options references should be expanded.
483
:returns: The value of the option.
485
value = self._get_user_option(option_name)
487
if isinstance(value, list):
488
value = self._expand_options_in_list(value)
489
elif isinstance(value, dict):
490
trace.warning('Cannot expand "%s":'
491
' Dicts do not support option expansion'
494
value = self._expand_options_in_string(value)
495
for hook in OldConfigHooks['get']:
496
hook(self, option_name, value)
499
def get_user_option_as_bool(self, option_name, expand=None, default=None):
500
"""Get a generic option as a boolean.
502
:param expand: Allow expanding references to other config values.
503
:param default: Default value if nothing is configured
504
:return None if the option doesn't exist or its value can't be
505
interpreted as a boolean. Returns True or False otherwise.
507
s = self.get_user_option(option_name, expand=expand)
509
# The option doesn't exist
511
val = ui.bool_from_string(s)
513
# The value can't be interpreted as a boolean
514
trace.warning('Value "%s" is not a boolean for "%s"',
518
def get_user_option_as_list(self, option_name, expand=None):
519
"""Get a generic option as a list - no special process, no default.
521
:return None if the option doesn't exist. Returns the value as a list
524
l = self.get_user_option(option_name, expand=expand)
525
if isinstance(l, string_types):
526
# A single value, most probably the user forgot (or didn't care to
531
def _log_format(self):
532
"""See log_format()."""
535
def validate_signatures_in_log(self):
536
"""Show GPG signature validity in log"""
537
result = self._validate_signatures_in_log()
544
def _validate_signatures_in_log(self):
545
"""See validate_signatures_in_log()."""
548
def _post_commit(self):
549
"""See Config.post_commit."""
552
def user_email(self):
553
"""Return just the email component of a username."""
554
return extract_email_address(self.username())
557
"""Return email-style username.
559
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
561
$BRZ_EMAIL can be set to override this, then
562
the concrete policy type is checked, and finally
564
If no username can be found, NoWhoami exception is raised.
566
v = os.environ.get('BRZ_EMAIL')
569
v = v.decode(osutils.get_user_encoding())
571
v = self._get_user_id()
574
return default_email()
576
def ensure_username(self):
577
"""Raise NoWhoami if username is not set.
579
This method relies on the username() function raising the error.
583
def get_alias(self, value):
584
return self._get_alias(value)
586
def _get_alias(self, value):
589
def get_nickname(self):
590
return self._get_nickname()
592
def _get_nickname(self):
595
def get_bzr_remote_path(self):
597
return os.environ['BZR_REMOTE_PATH']
599
path = self.get_user_option("bzr_remote_path")
604
def suppress_warning(self, warning):
605
"""Should the warning be suppressed or emitted.
607
:param warning: The name of the warning being tested.
609
:returns: True if the warning should be suppressed, False otherwise.
611
warnings = self.get_user_option_as_list('suppress_warnings')
612
if warnings is None or warning not in warnings:
617
def get_merge_tools(self):
619
for (oname, value, section, conf_id, parser) in self._get_options():
620
if oname.startswith('bzr.mergetool.'):
621
tool_name = oname[len('bzr.mergetool.'):]
622
tools[tool_name] = self.get_user_option(oname, False)
623
trace.mutter('loaded merge tools: %r' % tools)
626
def find_merge_tool(self, name):
627
# We fake a defaults mechanism here by checking if the given name can
628
# be found in the known_merge_tools if it's not found in the config.
629
# This should be done through the proposed config defaults mechanism
630
# when it becomes available in the future.
631
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
633
or mergetools.known_merge_tools.get(name, None))
637
class _ConfigHooks(hooks.Hooks):
638
"""A dict mapping hook names and a list of callables for configs.
642
"""Create the default hooks.
644
These are all empty initially, because by default nothing should get
647
super(_ConfigHooks, self).__init__('breezy.config', 'ConfigHooks')
648
self.add_hook('load',
649
'Invoked when a config store is loaded.'
650
' The signature is (store).',
652
self.add_hook('save',
653
'Invoked when a config store is saved.'
654
' The signature is (store).',
656
# The hooks for config options
658
'Invoked when a config option is read.'
659
' The signature is (stack, name, value).',
662
'Invoked when a config option is set.'
663
' The signature is (stack, name, value).',
665
self.add_hook('remove',
666
'Invoked when a config option is removed.'
667
' The signature is (stack, name).',
669
ConfigHooks = _ConfigHooks()
672
class _OldConfigHooks(hooks.Hooks):
673
"""A dict mapping hook names and a list of callables for configs.
677
"""Create the default hooks.
679
These are all empty initially, because by default nothing should get
682
super(_OldConfigHooks, self).__init__('breezy.config', 'OldConfigHooks')
683
self.add_hook('load',
684
'Invoked when a config store is loaded.'
685
' The signature is (config).',
687
self.add_hook('save',
688
'Invoked when a config store is saved.'
689
' The signature is (config).',
691
# The hooks for config options
693
'Invoked when a config option is read.'
694
' The signature is (config, name, value).',
697
'Invoked when a config option is set.'
698
' The signature is (config, name, value).',
700
self.add_hook('remove',
701
'Invoked when a config option is removed.'
702
' The signature is (config, name).',
704
OldConfigHooks = _OldConfigHooks()
707
class IniBasedConfig(Config):
708
"""A configuration policy that draws from ini files."""
710
def __init__(self, file_name=None):
711
"""Base class for configuration files using an ini-like syntax.
713
:param file_name: The configuration file path.
715
super(IniBasedConfig, self).__init__()
716
self.file_name = file_name
717
self.file_name = file_name
722
def from_string(cls, str_or_unicode, file_name=None, save=False):
723
"""Create a config object from a string.
725
:param str_or_unicode: A string representing the file content. This will
728
:param file_name: The configuration file path.
730
:param _save: Whether the file should be saved upon creation.
732
conf = cls(file_name=file_name)
733
conf._create_from_string(str_or_unicode, save)
736
def _create_from_string(self, str_or_unicode, save):
737
self._content = BytesIO(str_or_unicode.encode('utf-8'))
738
# Some tests use in-memory configs, some other always need the config
739
# file to exist on disk.
741
self._write_config_file()
743
def _get_parser(self):
744
if self._parser is not None:
746
if self._content is not None:
747
co_input = self._content
748
elif self.file_name is None:
749
raise AssertionError('We have no content to create the config')
751
co_input = self.file_name
753
self._parser = ConfigObj(co_input, encoding='utf-8')
754
except configobj.ConfigObjError as e:
755
raise ParseConfigError(e.errors, e.config.filename)
756
except UnicodeDecodeError:
757
raise ConfigContentError(self.file_name)
758
# Make sure self.reload() will use the right file name
759
self._parser.filename = self.file_name
760
for hook in OldConfigHooks['load']:
765
"""Reload the config file from disk."""
766
if self.file_name is None:
767
raise AssertionError('We need a file name to reload the config')
768
if self._parser is not None:
769
self._parser.reload()
770
for hook in ConfigHooks['load']:
773
def _get_matching_sections(self):
774
"""Return an ordered list of (section_name, extra_path) pairs.
776
If the section contains inherited configuration, extra_path is
777
a string containing the additional path components.
779
section = self._get_section()
780
if section is not None:
781
return [(section, '')]
785
def _get_section(self):
786
"""Override this to define the section used by the config."""
789
def _get_sections(self, name=None):
790
"""Returns an iterator of the sections specified by ``name``.
792
:param name: The section name. If None is supplied, the default
793
configurations are yielded.
795
:return: A tuple (name, section, config_id) for all sections that will
796
be walked by user_get_option() in the 'right' order. The first one
797
is where set_user_option() will update the value.
799
parser = self._get_parser()
801
yield (name, parser[name], self.config_id())
803
# No section name has been given so we fallback to the configobj
804
# itself which holds the variables defined outside of any section.
805
yield (None, parser, self.config_id())
807
def _get_options(self, sections=None):
808
"""Return an ordered list of (name, value, section, config_id) tuples.
810
All options are returned with their associated value and the section
811
they appeared in. ``config_id`` is a unique identifier for the
812
configuration file the option is defined in.
814
:param sections: Default to ``_get_matching_sections`` if not
815
specified. This gives a better control to daughter classes about
816
which sections should be searched. This is a list of (name,
821
parser = self._get_parser()
823
for (section_name, _) in self._get_matching_sections():
825
section = parser[section_name]
827
# This could happen for an empty file for which we define a
828
# DEFAULT section. FIXME: Force callers to provide sections
829
# instead ? -- vila 20100930
831
sections.append((section_name, section))
832
config_id = self.config_id()
833
for (section_name, section) in sections:
834
for (name, value) in section.iteritems():
835
yield (name, parser._quote(value), section_name,
838
def _get_option_policy(self, section, option_name):
839
"""Return the policy for the given (section, option_name) pair."""
842
def _get_change_editor(self):
843
return self.get_user_option('change_editor')
845
def _get_signature_checking(self):
846
"""See Config._get_signature_checking."""
847
policy = self._get_user_option('check_signatures')
849
return signature_policy_from_unicode(policy)
851
def _get_signing_policy(self):
852
"""See Config._get_signing_policy"""
853
policy = self._get_user_option('create_signatures')
855
return signing_policy_from_unicode(policy)
857
def _get_user_id(self):
858
"""Get the user id from the 'email' key in the current section."""
859
return self._get_user_option('email')
861
def _get_user_option(self, option_name):
862
"""See Config._get_user_option."""
863
for (section, extra_path) in self._get_matching_sections():
865
value = self._get_parser().get_value(section, option_name)
868
policy = self._get_option_policy(section, option_name)
869
if policy == POLICY_NONE:
871
elif policy == POLICY_NORECURSE:
872
# norecurse items only apply to the exact path
877
elif policy == POLICY_APPENDPATH:
879
value = urlutils.join(value, extra_path)
882
raise AssertionError('Unexpected config policy %r' % policy)
886
def _log_format(self):
887
"""See Config.log_format."""
888
return self._get_user_option('log_format')
890
def _validate_signatures_in_log(self):
891
"""See Config.validate_signatures_in_log."""
892
return self._get_user_option('validate_signatures_in_log')
894
def _acceptable_keys(self):
895
"""See Config.acceptable_keys."""
896
return self._get_user_option('acceptable_keys')
898
def _post_commit(self):
899
"""See Config.post_commit."""
900
return self._get_user_option('post_commit')
902
def _get_alias(self, value):
904
return self._get_parser().get_value("ALIASES",
909
def _get_nickname(self):
910
return self.get_user_option('nickname')
912
def remove_user_option(self, option_name, section_name=None):
913
"""Remove a user option and save the configuration file.
915
:param option_name: The option to be removed.
917
:param section_name: The section the option is defined in, default to
921
parser = self._get_parser()
922
if section_name is None:
925
section = parser[section_name]
927
del section[option_name]
929
raise NoSuchConfigOption(option_name)
930
self._write_config_file()
931
for hook in OldConfigHooks['remove']:
932
hook(self, option_name)
934
def _write_config_file(self):
935
if self.file_name is None:
936
raise AssertionError('We cannot save, self.file_name is None')
937
conf_dir = os.path.dirname(self.file_name)
938
ensure_config_dir_exists(conf_dir)
939
atomic_file = atomicfile.AtomicFile(self.file_name)
940
self._get_parser().write(atomic_file)
943
osutils.copy_ownership_from_path(self.file_name)
944
for hook in OldConfigHooks['save']:
948
class LockableConfig(IniBasedConfig):
949
"""A configuration needing explicit locking for access.
951
If several processes try to write the config file, the accesses need to be
954
Daughter classes should decorate all methods that update a config with the
955
``@needs_write_lock`` decorator (they call, directly or indirectly, the
956
``_write_config_file()`` method. These methods (typically ``set_option()``
957
and variants must reload the config file from disk before calling
958
``_write_config_file()``), this can be achieved by calling the
959
``self.reload()`` method. Note that the lock scope should cover both the
960
reading and the writing of the config file which is why the decorator can't
961
be applied to ``_write_config_file()`` only.
963
This should be enough to implement the following logic:
964
- lock for exclusive write access,
965
- reload the config file from disk,
969
This logic guarantees that a writer can update a value without erasing an
970
update made by another writer.
975
def __init__(self, file_name):
976
super(LockableConfig, self).__init__(file_name=file_name)
977
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
978
# FIXME: It doesn't matter that we don't provide possible_transports
979
# below since this is currently used only for local config files ;
980
# local transports are not shared. But if/when we start using
981
# LockableConfig for other kind of transports, we will need to reuse
982
# whatever connection is already established -- vila 20100929
983
self.transport = transport.get_transport_from_path(self.dir)
984
self._lock = lockdir.LockDir(self.transport, self.lock_name)
986
def _create_from_string(self, unicode_bytes, save):
987
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
989
# We need to handle the saving here (as opposed to IniBasedConfig)
992
self._write_config_file()
995
def lock_write(self, token=None):
996
"""Takes a write lock in the directory containing the config file.
998
If the directory doesn't exist it is created.
1000
ensure_config_dir_exists(self.dir)
1001
return self._lock.lock_write(token)
1006
def break_lock(self):
1007
self._lock.break_lock()
1010
def remove_user_option(self, option_name, section_name=None):
1011
super(LockableConfig, self).remove_user_option(option_name,
1014
def _write_config_file(self):
1015
if self._lock is None or not self._lock.is_held:
1016
# NB: if the following exception is raised it probably means a
1017
# missing @needs_write_lock decorator on one of the callers.
1018
raise errors.ObjectNotLocked(self)
1019
super(LockableConfig, self)._write_config_file()
1022
class GlobalConfig(LockableConfig):
1023
"""The configuration that should be used for a specific location."""
1026
super(GlobalConfig, self).__init__(file_name=config_filename())
1028
def config_id(self):
1032
def from_string(cls, str_or_unicode, save=False):
1033
"""Create a config object from a string.
1035
:param str_or_unicode: A string representing the file content. This
1036
will be utf-8 encoded.
1038
:param save: Whether the file should be saved upon creation.
1041
conf._create_from_string(str_or_unicode, save)
1045
def set_user_option(self, option, value):
1046
"""Save option and its value in the configuration."""
1047
self._set_option(option, value, 'DEFAULT')
1049
def get_aliases(self):
1050
"""Return the aliases section."""
1051
if 'ALIASES' in self._get_parser():
1052
return self._get_parser()['ALIASES']
1057
def set_alias(self, alias_name, alias_command):
1058
"""Save the alias in the configuration."""
1059
self._set_option(alias_name, alias_command, 'ALIASES')
1062
def unset_alias(self, alias_name):
1063
"""Unset an existing alias."""
1065
aliases = self._get_parser().get('ALIASES')
1066
if not aliases or alias_name not in aliases:
1067
raise errors.NoSuchAlias(alias_name)
1068
del aliases[alias_name]
1069
self._write_config_file()
1071
def _set_option(self, option, value, section):
1073
self._get_parser().setdefault(section, {})[option] = value
1074
self._write_config_file()
1075
for hook in OldConfigHooks['set']:
1076
hook(self, option, value)
1078
def _get_sections(self, name=None):
1079
"""See IniBasedConfig._get_sections()."""
1080
parser = self._get_parser()
1081
# We don't give access to options defined outside of any section, we
1082
# used the DEFAULT section by... default.
1083
if name in (None, 'DEFAULT'):
1084
# This could happen for an empty file where the DEFAULT section
1085
# doesn't exist yet. So we force DEFAULT when yielding
1087
if 'DEFAULT' not in parser:
1088
parser['DEFAULT']= {}
1089
yield (name, parser[name], self.config_id())
1092
def remove_user_option(self, option_name, section_name=None):
1093
if section_name is None:
1094
# We need to force the default section.
1095
section_name = 'DEFAULT'
1096
# We need to avoid the LockableConfig implementation or we'll lock
1098
super(LockableConfig, self).remove_user_option(option_name,
1101
def _iter_for_location_by_parts(sections, location):
1102
"""Keep only the sessions matching the specified location.
1104
:param sections: An iterable of section names.
1106
:param location: An url or a local path to match against.
1108
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1109
number of path components in the section name, section is the section
1110
name and extra_path is the difference between location and the section
1113
``location`` will always be a local path and never a 'file://' url but the
1114
section names themselves can be in either form.
1116
location_parts = location.rstrip('/').split('/')
1118
for section in sections:
1119
# location is a local path if possible, so we need to convert 'file://'
1120
# urls in section names to local paths if necessary.
1122
# This also avoids having file:///path be a more exact
1123
# match than '/path'.
1125
# FIXME: This still raises an issue if a user defines both file:///path
1126
# *and* /path. Should we raise an error in this case -- vila 20110505
1128
if section.startswith('file://'):
1129
section_path = urlutils.local_path_from_url(section)
1131
section_path = section
1132
section_parts = section_path.rstrip('/').split('/')
1135
if len(section_parts) > len(location_parts):
1136
# More path components in the section, they can't match
1139
# Rely on zip truncating in length to the length of the shortest
1140
# argument sequence.
1141
for name in zip(location_parts, section_parts):
1142
if not fnmatch.fnmatch(name[0], name[1]):
1147
# build the path difference between the section and the location
1148
extra_path = '/'.join(location_parts[len(section_parts):])
1149
yield section, extra_path, len(section_parts)
1152
class LocationConfig(LockableConfig):
1153
"""A configuration object that gives the policy for a location."""
1155
def __init__(self, location):
1156
super(LocationConfig, self).__init__(
1157
file_name=locations_config_filename())
1158
# local file locations are looked up by local path, rather than
1159
# by file url. This is because the config file is a user
1160
# file, and we would rather not expose the user to file urls.
1161
if location.startswith('file://'):
1162
location = urlutils.local_path_from_url(location)
1163
self.location = location
1165
def config_id(self):
1169
def from_string(cls, str_or_unicode, location, save=False):
1170
"""Create a config object from a string.
1172
:param str_or_unicode: A string representing the file content. This will
1175
:param location: The location url to filter the configuration.
1177
:param save: Whether the file should be saved upon creation.
1179
conf = cls(location)
1180
conf._create_from_string(str_or_unicode, save)
1183
def _get_matching_sections(self):
1184
"""Return an ordered list of section names matching this location."""
1185
# put the longest (aka more specific) locations first
1187
_iter_for_location_by_parts(self._get_parser(), self.location),
1188
key=lambda match: (match[2], match[0]),
1190
for (section, extra_path, length) in matches:
1191
yield section, extra_path
1192
# should we stop looking for parent configs here?
1194
if self._get_parser()[section].as_bool('ignore_parents'):
1199
def _get_sections(self, name=None):
1200
"""See IniBasedConfig._get_sections()."""
1201
# We ignore the name here as the only sections handled are named with
1202
# the location path and we don't expose embedded sections either.
1203
parser = self._get_parser()
1204
for name, extra_path in self._get_matching_sections():
1205
yield (name, parser[name], self.config_id())
1207
def _get_option_policy(self, section, option_name):
1208
"""Return the policy for the given (section, option_name) pair."""
1209
# check for the old 'recurse=False' flag
1211
recurse = self._get_parser()[section].as_bool('recurse')
1215
return POLICY_NORECURSE
1217
policy_key = option_name + ':policy'
1219
policy_name = self._get_parser()[section][policy_key]
1223
return _policy_value[policy_name]
1225
def _set_option_policy(self, section, option_name, option_policy):
1226
"""Set the policy for the given option name in the given section."""
1227
policy_key = option_name + ':policy'
1228
policy_name = _policy_name[option_policy]
1229
if policy_name is not None:
1230
self._get_parser()[section][policy_key] = policy_name
1232
if policy_key in self._get_parser()[section]:
1233
del self._get_parser()[section][policy_key]
1236
def set_user_option(self, option, value, store=STORE_LOCATION):
1237
"""Save option and its value in the configuration."""
1238
if store not in [STORE_LOCATION,
1239
STORE_LOCATION_NORECURSE,
1240
STORE_LOCATION_APPENDPATH]:
1241
raise ValueError('bad storage policy %r for %r' %
1244
location = self.location
1245
if location.endswith('/'):
1246
location = location[:-1]
1247
parser = self._get_parser()
1248
if not location in parser and not location + '/' in parser:
1249
parser[location] = {}
1250
elif location + '/' in parser:
1251
location = location + '/'
1252
parser[location][option]=value
1253
# the allowed values of store match the config policies
1254
self._set_option_policy(location, option, store)
1255
self._write_config_file()
1256
for hook in OldConfigHooks['set']:
1257
hook(self, option, value)
1260
class BranchConfig(Config):
1261
"""A configuration object giving the policy for a branch."""
1263
def __init__(self, branch):
1264
super(BranchConfig, self).__init__()
1265
self._location_config = None
1266
self._branch_data_config = None
1267
self._global_config = None
1268
self.branch = branch
1269
self.option_sources = (self._get_location_config,
1270
self._get_branch_data_config,
1271
self._get_global_config)
1273
def config_id(self):
1276
def _get_branch_data_config(self):
1277
if self._branch_data_config is None:
1278
self._branch_data_config = TreeConfig(self.branch)
1279
self._branch_data_config.config_id = self.config_id
1280
return self._branch_data_config
1282
def _get_location_config(self):
1283
if self._location_config is None:
1284
self._location_config = LocationConfig(self.branch.base)
1285
return self._location_config
1287
def _get_global_config(self):
1288
if self._global_config is None:
1289
self._global_config = GlobalConfig()
1290
return self._global_config
1292
def _get_best_value(self, option_name):
1293
"""This returns a user option from local, tree or global config.
1295
They are tried in that order. Use get_safe_value if trusted values
1298
for source in self.option_sources:
1299
value = getattr(source(), option_name)()
1300
if value is not None:
1304
def _get_safe_value(self, option_name):
1305
"""This variant of get_best_value never returns untrusted values.
1307
It does not return values from the branch data, because the branch may
1308
not be controlled by the user.
1310
We may wish to allow locations.conf to control whether branches are
1311
trusted in the future.
1313
for source in (self._get_location_config, self._get_global_config):
1314
value = getattr(source(), option_name)()
1315
if value is not None:
1319
def _get_user_id(self):
1320
"""Return the full user id for the branch.
1322
e.g. "John Hacker <jhacker@example.com>"
1323
This is looked up in the email controlfile for the branch.
1325
return self._get_best_value('_get_user_id')
1327
def _get_change_editor(self):
1328
return self._get_best_value('_get_change_editor')
1330
def _get_signature_checking(self):
1331
"""See Config._get_signature_checking."""
1332
return self._get_best_value('_get_signature_checking')
1334
def _get_signing_policy(self):
1335
"""See Config._get_signing_policy."""
1336
return self._get_best_value('_get_signing_policy')
1338
def _get_user_option(self, option_name):
1339
"""See Config._get_user_option."""
1340
for source in self.option_sources:
1341
value = source()._get_user_option(option_name)
1342
if value is not None:
1346
def _get_sections(self, name=None):
1347
"""See IniBasedConfig.get_sections()."""
1348
for source in self.option_sources:
1349
for section in source()._get_sections(name):
1352
def _get_options(self, sections=None):
1354
# First the locations options
1355
for option in self._get_location_config()._get_options():
1357
# Then the branch options
1358
branch_config = self._get_branch_data_config()
1359
if sections is None:
1360
sections = [('DEFAULT', branch_config._get_parser())]
1361
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1362
# Config itself has no notion of sections :( -- vila 20101001
1363
config_id = self.config_id()
1364
for (section_name, section) in sections:
1365
for (name, value) in section.iteritems():
1366
yield (name, value, section_name,
1367
config_id, branch_config._get_parser())
1368
# Then the global options
1369
for option in self._get_global_config()._get_options():
1372
def set_user_option(self, name, value, store=STORE_BRANCH,
1374
if store == STORE_BRANCH:
1375
self._get_branch_data_config().set_option(value, name)
1376
elif store == STORE_GLOBAL:
1377
self._get_global_config().set_user_option(name, value)
1379
self._get_location_config().set_user_option(name, value, store)
1382
if store in (STORE_GLOBAL, STORE_BRANCH):
1383
mask_value = self._get_location_config().get_user_option(name)
1384
if mask_value is not None:
1385
trace.warning('Value "%s" is masked by "%s" from'
1386
' locations.conf', value, mask_value)
1388
if store == STORE_GLOBAL:
1389
branch_config = self._get_branch_data_config()
1390
mask_value = branch_config.get_user_option(name)
1391
if mask_value is not None:
1392
trace.warning('Value "%s" is masked by "%s" from'
1393
' branch.conf', value, mask_value)
1395
def remove_user_option(self, option_name, section_name=None):
1396
self._get_branch_data_config().remove_option(option_name, section_name)
1398
def _post_commit(self):
1399
"""See Config.post_commit."""
1400
return self._get_safe_value('_post_commit')
1402
def _get_nickname(self):
1403
value = self._get_explicit_nickname()
1404
if value is not None:
1406
if self.branch.name:
1407
return self.branch.name
1408
return urlutils.unescape(self.branch.base.split('/')[-2])
1410
def has_explicit_nickname(self):
1411
"""Return true if a nickname has been explicitly assigned."""
1412
return self._get_explicit_nickname() is not None
1414
def _get_explicit_nickname(self):
1415
return self._get_best_value('_get_nickname')
1417
def _log_format(self):
1418
"""See Config.log_format."""
1419
return self._get_best_value('_log_format')
1421
def _validate_signatures_in_log(self):
1422
"""See Config.validate_signatures_in_log."""
1423
return self._get_best_value('_validate_signatures_in_log')
1425
def _acceptable_keys(self):
1426
"""See Config.acceptable_keys."""
1427
return self._get_best_value('_acceptable_keys')
1430
def ensure_config_dir_exists(path=None):
1431
"""Make sure a configuration directory exists.
1432
This makes sure that the directory exists.
1433
On windows, since configuration directories are 2 levels deep,
1434
it makes sure both the directory and the parent directory exists.
1438
if not os.path.isdir(path):
1439
if sys.platform == 'win32':
1440
parent_dir = os.path.dirname(path)
1441
if not os.path.isdir(parent_dir):
1442
trace.mutter('creating config parent directory: %r', parent_dir)
1443
os.mkdir(parent_dir)
1444
trace.mutter('creating config directory: %r', path)
1446
osutils.copy_ownership_from_path(path)
1449
def bazaar_config_dir():
1450
"""Return per-user configuration directory as unicode string
1452
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1453
and Linux. On Mac OS X and Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1454
that will be used instead.
1456
TODO: Global option --config-dir to override this.
1458
base = osutils.path_from_environ('BZR_HOME')
1459
if sys.platform == 'win32':
1461
base = win32utils.get_appdata_location()
1463
base = win32utils.get_home_location()
1464
return osutils.pathjoin(base, 'bazaar', '2.0')
1466
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1468
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1469
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1470
if osutils.isdir(xdg_dir):
1472
"Using configuration in XDG directory %s." % xdg_dir)
1474
base = osutils._get_home_dir()
1475
return osutils.pathjoin(base, ".bazaar")
1479
"""Return per-user configuration directory as unicode string
1481
By default this is %APPDATA%/breezy on Windows, $XDG_CONFIG_HOME/breezy on
1482
Mac OS X and Linux. If the breezy config directory doesn't exist but
1483
the bazaar one (see bazaar_config_dir()) does, use that instead.
1485
# TODO: Global option --config-dir to override this.
1486
base = osutils.path_from_environ('BRZ_HOME')
1487
if sys.platform == 'win32':
1489
base = win32utils.get_appdata_location()
1491
base = win32utils.get_home_location()
1493
base = osutils.path_from_environ('XDG_CONFIG_HOME')
1495
base = osutils.pathjoin(osutils._get_home_dir(), ".config")
1496
breezy_dir = osutils.pathjoin(base, 'breezy')
1497
if osutils.isdir(breezy_dir):
1498
return (breezy_dir, 'breezy')
1499
# If the breezy directory doesn't exist, but the bazaar one does, use that:
1500
bazaar_dir = bazaar_config_dir()
1501
if osutils.isdir(bazaar_dir):
1503
"Using Bazaar configuration directory (%s)", bazaar_dir)
1504
return (bazaar_dir, 'bazaar')
1505
return (breezy_dir, 'breezy')
1509
"""Return per-user configuration directory as unicode string
1511
By default this is %APPDATA%/breezy on Windows, $XDG_CONFIG_HOME/breezy on
1512
Mac OS X and Linux. If the breezy config directory doesn't exist but
1513
the bazaar one (see bazaar_config_dir()) does, use that instead.
1515
return _config_dir()[0]
1518
def config_filename():
1519
"""Return per-user configuration ini file filename."""
1520
path, kind = _config_dir()
1521
if kind == 'bazaar':
1522
return osutils.pathjoin(path, 'bazaar.conf')
1524
return osutils.pathjoin(path, 'breezy.conf')
1527
def locations_config_filename():
1528
"""Return per-user configuration ini file filename."""
1529
return osutils.pathjoin(config_dir(), 'locations.conf')
1532
def authentication_config_filename():
1533
"""Return per-user authentication ini file filename."""
1534
return osutils.pathjoin(config_dir(), 'authentication.conf')
1537
def user_ignore_config_filename():
1538
"""Return the user default ignore filename"""
1539
return osutils.pathjoin(config_dir(), 'ignore')
1543
"""Return the directory name to store crash files.
1545
This doesn't implicitly create it.
1547
On Windows it's in the config directory; elsewhere it's /var/crash
1548
which may be monitored by apport. It can be overridden by
1551
if sys.platform == 'win32':
1552
return osutils.pathjoin(config_dir(), 'Crash')
1554
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1556
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1559
def xdg_cache_dir():
1560
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1561
# Possibly this should be different on Windows?
1562
e = os.environ.get('XDG_CACHE_HOME', None)
1566
return os.path.expanduser('~/.cache')
1569
def _get_default_mail_domain(mailname_file='/etc/mailname'):
1570
"""If possible, return the assumed default email domain.
1572
:returns: string mail domain, or None.
1574
if sys.platform == 'win32':
1575
# No implementation yet; patches welcome
1578
f = open(mailname_file)
1579
except (IOError, OSError) as e:
1582
domain = f.readline().strip()
1588
def default_email():
1589
v = os.environ.get('BRZ_EMAIL')
1592
v = v.decode(osutils.get_user_encoding())
1594
v = os.environ.get('EMAIL')
1597
v = v.decode(osutils.get_user_encoding())
1599
name, email = _auto_user_id()
1601
return u'%s <%s>' % (name, email)
1607
def _auto_user_id():
1608
"""Calculate automatic user identification.
1610
:returns: (realname, email), either of which may be None if they can't be
1613
Only used when none is set in the environment or the id file.
1615
This only returns an email address if we can be fairly sure the
1616
address is reasonable, ie if /etc/mailname is set on unix.
1618
This doesn't use the FQDN as the default domain because that may be
1619
slow, and it doesn't use the hostname alone because that's not normally
1620
a reasonable address.
1622
if sys.platform == 'win32':
1623
# No implementation to reliably determine Windows default mail
1624
# address; please add one.
1627
default_mail_domain = _get_default_mail_domain()
1628
if not default_mail_domain:
1634
w = pwd.getpwuid(uid)
1636
trace.mutter('no passwd entry for uid %d?' % uid)
1639
# we try utf-8 first, because on many variants (like Linux),
1640
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1641
# false positives. (many users will have their user encoding set to
1642
# latin-1, which cannot raise UnicodeError.)
1644
gecos = w.pw_gecos.decode('utf-8')
1646
except UnicodeError:
1648
encoding = osutils.get_user_encoding()
1649
gecos = w.pw_gecos.decode(encoding)
1650
except UnicodeError as e:
1651
trace.mutter("cannot decode passwd entry %s" % w)
1654
username = w.pw_name.decode(encoding)
1655
except UnicodeError as e:
1656
trace.mutter("cannot decode passwd entry %s" % w)
1659
comma = gecos.find(',')
1663
realname = gecos[:comma]
1665
return realname, (username + '@' + default_mail_domain)
1668
def parse_username(username):
1669
"""Parse e-mail username and return a (name, address) tuple."""
1670
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1672
return (username, '')
1674
return (match.group(1), match.group(2))
1677
def extract_email_address(e):
1678
"""Return just the address part of an email string.
1680
That is just the user@domain part, nothing else.
1681
This part is required to contain only ascii characters.
1682
If it can't be extracted, raises an error.
1684
>>> extract_email_address('Jane Tester <jane@test.com>')
1687
name, email = parse_username(e)
1689
raise NoEmailInUsername(e)
1693
class TreeConfig(IniBasedConfig):
1694
"""Branch configuration data associated with its contents, not location"""
1696
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1698
def __init__(self, branch):
1699
self._config = branch._get_config()
1700
self.branch = branch
1702
def _get_parser(self, file=None):
1703
if file is not None:
1704
return IniBasedConfig._get_parser(file)
1705
return self._config._get_configobj()
1707
def get_option(self, name, section=None, default=None):
1708
self.branch.lock_read()
1710
return self._config.get_option(name, section, default)
1712
self.branch.unlock()
1714
def set_option(self, value, name, section=None):
1715
"""Set a per-branch configuration option"""
1716
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1717
# higher levels providing the right lock -- vila 20101004
1718
self.branch.lock_write()
1720
self._config.set_option(value, name, section)
1722
self.branch.unlock()
1724
def remove_option(self, option_name, section_name=None):
1725
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1726
# higher levels providing the right lock -- vila 20101004
1727
self.branch.lock_write()
1729
self._config.remove_option(option_name, section_name)
1731
self.branch.unlock()
1734
_authentication_config_permission_errors = set()
1737
class AuthenticationConfig(object):
1738
"""The authentication configuration file based on a ini file.
1740
Implements the authentication.conf file described in
1741
doc/developers/authentication-ring.txt.
1744
def __init__(self, _file=None):
1745
self._config = None # The ConfigObj
1747
self._filename = authentication_config_filename()
1748
self._input = self._filename = authentication_config_filename()
1749
self._check_permissions()
1751
# Tests can provide a string as _file
1752
self._filename = None
1755
def _get_config(self):
1756
if self._config is not None:
1759
# FIXME: Should we validate something here ? Includes: empty
1760
# sections are useless, at least one of
1761
# user/password/password_encoding should be defined, etc.
1763
# Note: the encoding below declares that the file itself is utf-8
1764
# encoded, but the values in the ConfigObj are always Unicode.
1765
self._config = ConfigObj(self._input, encoding='utf-8')
1766
except configobj.ConfigObjError as e:
1767
raise ParseConfigError(e.errors, e.config.filename)
1768
except UnicodeError:
1769
raise ConfigContentError(self._filename)
1772
def _check_permissions(self):
1773
"""Check permission of auth file are user read/write able only."""
1775
st = os.stat(self._filename)
1776
except OSError as e:
1777
if e.errno != errno.ENOENT:
1778
trace.mutter('Unable to stat %r: %r', self._filename, e)
1780
mode = stat.S_IMODE(st.st_mode)
1781
if ((stat.S_IXOTH | stat.S_IWOTH | stat.S_IROTH | stat.S_IXGRP |
1782
stat.S_IWGRP | stat.S_IRGRP ) & mode):
1784
if (not self._filename in _authentication_config_permission_errors
1785
and not GlobalConfig().suppress_warning(
1786
'insecure_permissions')):
1787
trace.warning("The file '%s' has insecure "
1788
"file permissions. Saved passwords may be accessible "
1789
"by other users.", self._filename)
1790
_authentication_config_permission_errors.add(self._filename)
1793
"""Save the config file, only tests should use it for now."""
1794
conf_dir = os.path.dirname(self._filename)
1795
ensure_config_dir_exists(conf_dir)
1796
fd = os.open(self._filename, os.O_RDWR|os.O_CREAT, 0o600)
1798
f = os.fdopen(fd, 'wb')
1799
self._get_config().write(f)
1803
def _set_option(self, section_name, option_name, value):
1804
"""Set an authentication configuration option"""
1805
conf = self._get_config()
1806
section = conf.get(section_name)
1809
section = conf[section]
1810
section[option_name] = value
1813
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1815
"""Returns the matching credentials from authentication.conf file.
1817
:param scheme: protocol
1819
:param host: the server address
1821
:param port: the associated port (optional)
1823
:param user: login (optional)
1825
:param path: the absolute path on the server (optional)
1827
:param realm: the http authentication realm (optional)
1829
:return: A dict containing the matching credentials or None.
1831
- name: the section name of the credentials in the
1832
authentication.conf file,
1833
- user: can't be different from the provided user if any,
1834
- scheme: the server protocol,
1835
- host: the server address,
1836
- port: the server port (can be None),
1837
- path: the absolute server path (can be None),
1838
- realm: the http specific authentication realm (can be None),
1839
- password: the decoded password, could be None if the credential
1840
defines only the user
1841
- verify_certificates: https specific, True if the server
1842
certificate should be verified, False otherwise.
1845
for auth_def_name, auth_def in self._get_config().iteritems():
1846
if not isinstance(auth_def, configobj.Section):
1847
raise ValueError("%s defined outside a section" % auth_def_name)
1849
a_scheme, a_host, a_user, a_path = map(
1850
auth_def.get, ['scheme', 'host', 'user', 'path'])
1853
a_port = auth_def.as_int('port')
1857
raise ValueError("'port' not numeric in %s" % auth_def_name)
1859
a_verify_certificates = auth_def.as_bool('verify_certificates')
1861
a_verify_certificates = True
1864
"'verify_certificates' not boolean in %s" % auth_def_name)
1867
if a_scheme is not None and scheme != a_scheme:
1869
if a_host is not None:
1870
if not (host == a_host
1871
or (a_host.startswith('.') and host.endswith(a_host))):
1873
if a_port is not None and port != a_port:
1875
if (a_path is not None and path is not None
1876
and not path.startswith(a_path)):
1878
if (a_user is not None and user is not None
1879
and a_user != user):
1880
# Never contradict the caller about the user to be used
1885
# Prepare a credentials dictionary with additional keys
1886
# for the credential providers
1887
credentials = dict(name=auth_def_name,
1894
password=auth_def.get('password', None),
1895
verify_certificates=a_verify_certificates)
1896
# Decode the password in the credentials (or get one)
1897
self.decode_password(credentials,
1898
auth_def.get('password_encoding', None))
1899
if 'auth' in debug.debug_flags:
1900
trace.mutter("Using authentication section: %r", auth_def_name)
1903
if credentials is None:
1904
# No credentials were found in authentication.conf, try the fallback
1905
# credentials stores.
1906
credentials = credential_store_registry.get_fallback_credentials(
1907
scheme, host, port, user, path, realm)
1911
def set_credentials(self, name, host, user, scheme=None, password=None,
1912
port=None, path=None, verify_certificates=None,
1914
"""Set authentication credentials for a host.
1916
Any existing credentials with matching scheme, host, port and path
1917
will be deleted, regardless of name.
1919
:param name: An arbitrary name to describe this set of credentials.
1920
:param host: Name of the host that accepts these credentials.
1921
:param user: The username portion of these credentials.
1922
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1924
:param password: Password portion of these credentials.
1925
:param port: The IP port on the host that these credentials apply to.
1926
:param path: A filesystem path on the host that these credentials
1928
:param verify_certificates: On https, verify server certificates if
1930
:param realm: The http authentication realm (optional).
1932
values = {'host': host, 'user': user}
1933
if password is not None:
1934
values['password'] = password
1935
if scheme is not None:
1936
values['scheme'] = scheme
1937
if port is not None:
1938
values['port'] = '%d' % port
1939
if path is not None:
1940
values['path'] = path
1941
if verify_certificates is not None:
1942
values['verify_certificates'] = str(verify_certificates)
1943
if realm is not None:
1944
values['realm'] = realm
1945
config = self._get_config()
1947
for section, existing_values in config.iteritems():
1948
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1949
if existing_values.get(key) != values.get(key):
1953
config.update({name: values})
1956
def get_user(self, scheme, host, port=None, realm=None, path=None,
1957
prompt=None, ask=False, default=None):
1958
"""Get a user from authentication file.
1960
:param scheme: protocol
1962
:param host: the server address
1964
:param port: the associated port (optional)
1966
:param realm: the realm sent by the server (optional)
1968
:param path: the absolute path on the server (optional)
1970
:param ask: Ask the user if there is no explicitly configured username
1973
:param default: The username returned if none is defined (optional).
1975
:return: The found user.
1977
credentials = self.get_credentials(scheme, host, port, user=None,
1978
path=path, realm=realm)
1979
if credentials is not None:
1980
user = credentials['user']
1986
# Create a default prompt suitable for most cases
1987
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1988
# Special handling for optional fields in the prompt
1989
if port is not None:
1990
prompt_host = '%s:%d' % (host, port)
1993
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1998
def get_password(self, scheme, host, user, port=None,
1999
realm=None, path=None, prompt=None):
2000
"""Get a password from authentication file or prompt the user for one.
2002
:param scheme: protocol
2004
:param host: the server address
2006
:param port: the associated port (optional)
2010
:param realm: the realm sent by the server (optional)
2012
:param path: the absolute path on the server (optional)
2014
:return: The found password or the one entered by the user.
2016
credentials = self.get_credentials(scheme, host, port, user, path,
2018
if credentials is not None:
2019
password = credentials['password']
2020
if password is not None and scheme is 'ssh':
2021
trace.warning('password ignored in section [%s],'
2022
' use an ssh agent instead'
2023
% credentials['name'])
2027
# Prompt user only if we could't find a password
2028
if password is None:
2030
# Create a default prompt suitable for most cases
2031
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
2032
# Special handling for optional fields in the prompt
2033
if port is not None:
2034
prompt_host = '%s:%d' % (host, port)
2037
password = ui.ui_factory.get_password(prompt,
2038
host=prompt_host, user=user)
2041
def decode_password(self, credentials, encoding):
2043
cs = credential_store_registry.get_credential_store(encoding)
2045
raise ValueError('%r is not a known password_encoding' % encoding)
2046
credentials['password'] = cs.decode_password(credentials)
2050
class CredentialStoreRegistry(registry.Registry):
2051
"""A class that registers credential stores.
2053
A credential store provides access to credentials via the password_encoding
2054
field in authentication.conf sections.
2056
Except for stores provided by brz itself, most stores are expected to be
2057
provided by plugins that will therefore use
2058
register_lazy(password_encoding, module_name, member_name, help=help,
2059
fallback=fallback) to install themselves.
2061
A fallback credential store is one that is queried if no credentials can be
2062
found via authentication.conf.
2065
def get_credential_store(self, encoding=None):
2066
cs = self.get(encoding)
2071
def is_fallback(self, name):
2072
"""Check if the named credentials store should be used as fallback."""
2073
return self.get_info(name)
2075
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2076
path=None, realm=None):
2077
"""Request credentials from all fallback credentials stores.
2079
The first credentials store that can provide credentials wins.
2082
for name in self.keys():
2083
if not self.is_fallback(name):
2085
cs = self.get_credential_store(name)
2086
credentials = cs.get_credentials(scheme, host, port, user,
2088
if credentials is not None:
2089
# We found some credentials
2093
def register(self, key, obj, help=None, override_existing=False,
2095
"""Register a new object to a name.
2097
:param key: This is the key to use to request the object later.
2098
:param obj: The object to register.
2099
:param help: Help text for this entry. This may be a string or
2100
a callable. If it is a callable, it should take two
2101
parameters (registry, key): this registry and the key that
2102
the help was registered under.
2103
:param override_existing: Raise KeyErorr if False and something has
2104
already been registered for that key. If True, ignore if there
2105
is an existing key (always register the new value).
2106
:param fallback: Whether this credential store should be
2109
return super(CredentialStoreRegistry,
2110
self).register(key, obj, help, info=fallback,
2111
override_existing=override_existing)
2113
def register_lazy(self, key, module_name, member_name,
2114
help=None, override_existing=False,
2116
"""Register a new credential store to be loaded on request.
2118
:param module_name: The python path to the module. Such as 'os.path'.
2119
:param member_name: The member of the module to return. If empty or
2120
None, get() will return the module itself.
2121
:param help: Help text for this entry. This may be a string or
2123
:param override_existing: If True, replace the existing object
2124
with the new one. If False, if there is already something
2125
registered with the same key, raise a KeyError
2126
:param fallback: Whether this credential store should be
2129
return super(CredentialStoreRegistry, self).register_lazy(
2130
key, module_name, member_name, help,
2131
info=fallback, override_existing=override_existing)
2134
credential_store_registry = CredentialStoreRegistry()
2137
class CredentialStore(object):
2138
"""An abstract class to implement storage for credentials"""
2140
def decode_password(self, credentials):
2141
"""Returns a clear text password for the provided credentials."""
2142
raise NotImplementedError(self.decode_password)
2144
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2146
"""Return the matching credentials from this credential store.
2148
This method is only called on fallback credential stores.
2150
raise NotImplementedError(self.get_credentials)
2154
class PlainTextCredentialStore(CredentialStore):
2155
__doc__ = """Plain text credential store for the authentication.conf file"""
2157
def decode_password(self, credentials):
2158
"""See CredentialStore.decode_password."""
2159
return credentials['password']
2162
credential_store_registry.register('plain', PlainTextCredentialStore,
2163
help=PlainTextCredentialStore.__doc__)
2164
credential_store_registry.default_key = 'plain'
2167
class Base64CredentialStore(CredentialStore):
2168
__doc__ = """Base64 credential store for the authentication.conf file"""
2170
def decode_password(self, credentials):
2171
"""See CredentialStore.decode_password."""
2172
# GZ 2012-07-28: Will raise binascii.Error if password is not base64,
2173
# should probably propogate as something more useful.
2174
return base64.decodestring(credentials['password'])
2176
credential_store_registry.register('base64', Base64CredentialStore,
2177
help=Base64CredentialStore.__doc__)
2180
class BzrDirConfig(object):
2182
def __init__(self, bzrdir):
2183
self._bzrdir = bzrdir
2184
self._config = bzrdir._get_config()
2186
def set_default_stack_on(self, value):
2187
"""Set the default stacking location.
2189
It may be set to a location, or None.
2191
This policy affects all branches contained by this control dir, except
2192
for those under repositories.
2194
if self._config is None:
2195
raise errors.BzrError("Cannot set configuration in %s"
2198
self._config.set_option('', 'default_stack_on')
2200
self._config.set_option(value, 'default_stack_on')
2202
def get_default_stack_on(self):
2203
"""Return the default stacking location.
2205
This will either be a location, or None.
2207
This policy affects all branches contained by this control dir, except
2208
for those under repositories.
2210
if self._config is None:
2212
value = self._config.get_option('default_stack_on')
2218
class TransportConfig(object):
2219
"""A Config that reads/writes a config file on a Transport.
2221
It is a low-level object that considers config data to be name/value pairs
2222
that may be associated with a section. Assigning meaning to these values
2223
is done at higher levels like TreeConfig.
2226
def __init__(self, transport, filename):
2227
self._transport = transport
2228
self._filename = filename
2230
def get_option(self, name, section=None, default=None):
2231
"""Return the value associated with a named option.
2233
:param name: The name of the value
2234
:param section: The section the option is in (if any)
2235
:param default: The value to return if the value is not set
2236
:return: The value or default value
2238
configobj = self._get_configobj()
2240
section_obj = configobj
2243
section_obj = configobj[section]
2246
value = section_obj.get(name, default)
2247
for hook in OldConfigHooks['get']:
2248
hook(self, name, value)
2251
def set_option(self, value, name, section=None):
2252
"""Set the value associated with a named option.
2254
:param value: The value to set
2255
:param name: The name of the value to set
2256
:param section: The section the option is in (if any)
2258
configobj = self._get_configobj()
2260
configobj[name] = value
2262
configobj.setdefault(section, {})[name] = value
2263
for hook in OldConfigHooks['set']:
2264
hook(self, name, value)
2265
self._set_configobj(configobj)
2267
def remove_option(self, option_name, section_name=None):
2268
configobj = self._get_configobj()
2269
if section_name is None:
2270
del configobj[option_name]
2272
del configobj[section_name][option_name]
2273
for hook in OldConfigHooks['remove']:
2274
hook(self, option_name)
2275
self._set_configobj(configobj)
2277
def _get_config_file(self):
2279
f = BytesIO(self._transport.get_bytes(self._filename))
2280
for hook in OldConfigHooks['load']:
2283
except errors.NoSuchFile:
2285
except errors.PermissionDenied as e:
2286
trace.warning("Permission denied while trying to open "
2287
"configuration file %s.", urlutils.unescape_for_display(
2288
urlutils.join(self._transport.base, self._filename), "utf-8"))
2291
def _external_url(self):
2292
return urlutils.join(self._transport.external_url(), self._filename)
2294
def _get_configobj(self):
2295
f = self._get_config_file()
2298
conf = ConfigObj(f, encoding='utf-8')
2299
except configobj.ConfigObjError as e:
2300
raise ParseConfigError(e.errors, self._external_url())
2301
except UnicodeDecodeError:
2302
raise ConfigContentError(self._external_url())
2307
def _set_configobj(self, configobj):
2308
out_file = BytesIO()
2309
configobj.write(out_file)
2311
self._transport.put_file(self._filename, out_file)
2312
for hook in OldConfigHooks['save']:
2316
class Option(object):
2317
"""An option definition.
2319
The option *values* are stored in config files and found in sections.
2321
Here we define various properties about the option itself, its default
2322
value, how to convert it from stores, what to do when invalid values are
2323
encoutered, in which config files it can be stored.
2326
def __init__(self, name, override_from_env=None,
2327
default=None, default_from_env=None,
2328
help=None, from_unicode=None, invalid=None, unquote=True):
2329
"""Build an option definition.
2331
:param name: the name used to refer to the option.
2333
:param override_from_env: A list of environment variables which can
2334
provide override any configuration setting.
2336
:param default: the default value to use when none exist in the config
2337
stores. This is either a string that ``from_unicode`` will convert
2338
into the proper type, a callable returning a unicode string so that
2339
``from_unicode`` can be used on the return value, or a python
2340
object that can be stringified (so only the empty list is supported
2343
:param default_from_env: A list of environment variables which can
2344
provide a default value. 'default' will be used only if none of the
2345
variables specified here are set in the environment.
2347
:param help: a doc string to explain the option to the user.
2349
:param from_unicode: a callable to convert the unicode string
2350
representing the option value in a store or its default value.
2352
:param invalid: the action to be taken when an invalid value is
2353
encountered in a store. This is called only when from_unicode is
2354
invoked to convert a string and returns None or raise ValueError or
2355
TypeError. Accepted values are: None (ignore invalid values),
2356
'warning' (emit a warning), 'error' (emit an error message and
2359
:param unquote: should the unicode value be unquoted before conversion.
2360
This should be used only when the store providing the values cannot
2361
safely unquote them (see http://pad.lv/906897). It is provided so
2362
daughter classes can handle the quoting themselves.
2364
if override_from_env is None:
2365
override_from_env = []
2366
if default_from_env is None:
2367
default_from_env = []
2369
self.override_from_env = override_from_env
2370
# Convert the default value to a unicode string so all values are
2371
# strings internally before conversion (via from_unicode) is attempted.
2374
elif isinstance(default, list):
2375
# Only the empty list is supported
2377
raise AssertionError(
2378
'Only empty lists are supported as default values')
2380
elif isinstance(default, (binary_type, text_type, bool, int, float)):
2381
# Rely on python to convert strings, booleans and integers
2382
self.default = u'%s' % (default,)
2383
elif callable(default):
2384
self.default = default
2386
# other python objects are not expected
2387
raise AssertionError('%r is not supported as a default value'
2389
self.default_from_env = default_from_env
2391
self.from_unicode = from_unicode
2392
self.unquote = unquote
2393
if invalid and invalid not in ('warning', 'error'):
2394
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2395
self.invalid = invalid
2401
def convert_from_unicode(self, store, unicode_value):
2402
if self.unquote and store is not None and unicode_value is not None:
2403
unicode_value = store.unquote(unicode_value)
2404
if self.from_unicode is None or unicode_value is None:
2405
# Don't convert or nothing to convert
2406
return unicode_value
2408
converted = self.from_unicode(unicode_value)
2409
except (ValueError, TypeError):
2410
# Invalid values are ignored
2412
if converted is None and self.invalid is not None:
2413
# The conversion failed
2414
if self.invalid == 'warning':
2415
trace.warning('Value "%s" is not valid for "%s"',
2416
unicode_value, self.name)
2417
elif self.invalid == 'error':
2418
raise ConfigOptionValueError(self.name, unicode_value)
2421
def get_override(self):
2423
for var in self.override_from_env:
2425
# If the env variable is defined, its value takes precedence
2426
value = os.environ[var].decode(osutils.get_user_encoding())
2432
def get_default(self):
2434
for var in self.default_from_env:
2436
# If the env variable is defined, its value is the default one
2437
value = os.environ[var]
2439
value = value.decode(osutils.get_user_encoding())
2444
# Otherwise, fallback to the value defined at registration
2445
if callable(self.default):
2446
value = self.default()
2447
if not isinstance(value, text_type):
2448
raise AssertionError(
2449
"Callable default value for '%s' should be unicode"
2452
value = self.default
2455
def get_help_topic(self):
2458
def get_help_text(self, additional_see_also=None, plain=True):
2460
from breezy import help_topics
2461
result += help_topics._format_see_also(additional_see_also)
2463
result = help_topics.help_as_plain_text(result)
2467
# Predefined converters to get proper values from store
2469
def bool_from_store(unicode_str):
2470
return ui.bool_from_string(unicode_str)
2473
def int_from_store(unicode_str):
2474
return int(unicode_str)
2477
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2479
def int_SI_from_store(unicode_str):
2480
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2482
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2483
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2486
:return Integer, expanded to its base-10 value if a proper SI unit is
2487
found, None otherwise.
2489
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2490
p = re.compile(regexp, re.IGNORECASE)
2491
m = p.match(unicode_str)
2494
val, _, unit = m.groups()
2498
coeff = _unit_suffixes[unit.upper()]
2500
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2505
def float_from_store(unicode_str):
2506
return float(unicode_str)
2509
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2511
_list_converter_config = configobj.ConfigObj(
2512
{}, encoding='utf-8', list_values=True, interpolation=False)
2515
class ListOption(Option):
2517
def __init__(self, name, default=None, default_from_env=None,
2518
help=None, invalid=None):
2519
"""A list Option definition.
2521
This overrides the base class so the conversion from a unicode string
2522
can take quoting into account.
2524
super(ListOption, self).__init__(
2525
name, default=default, default_from_env=default_from_env,
2526
from_unicode=self.from_unicode, help=help,
2527
invalid=invalid, unquote=False)
2529
def from_unicode(self, unicode_str):
2530
if not isinstance(unicode_str, string_types):
2532
# Now inject our string directly as unicode. All callers got their
2533
# value from configobj, so values that need to be quoted are already
2535
_list_converter_config.reset()
2536
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2537
maybe_list = _list_converter_config['list']
2538
if isinstance(maybe_list, string_types):
2540
# A single value, most probably the user forgot (or didn't care
2541
# to add) the final ','
2544
# The empty string, convert to empty list
2547
# We rely on ConfigObj providing us with a list already
2552
class RegistryOption(Option):
2553
"""Option for a choice from a registry."""
2555
def __init__(self, name, registry, default_from_env=None,
2556
help=None, invalid=None):
2557
"""A registry based Option definition.
2559
This overrides the base class so the conversion from a unicode string
2560
can take quoting into account.
2562
super(RegistryOption, self).__init__(
2563
name, default=lambda: unicode(registry.default_key),
2564
default_from_env=default_from_env,
2565
from_unicode=self.from_unicode, help=help,
2566
invalid=invalid, unquote=False)
2567
self.registry = registry
2569
def from_unicode(self, unicode_str):
2570
if not isinstance(unicode_str, string_types):
2573
return self.registry.get(unicode_str)
2576
"Invalid value %s for %s."
2577
"See help for a list of possible values." % (unicode_str,
2582
ret = [self._help, "\n\nThe following values are supported:\n"]
2583
for key in self.registry.keys():
2584
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2588
_option_ref_re = lazy_regex.lazy_compile('({[^\d\W](?:\.\w|-\w|\w)*})')
2589
"""Describes an expandable option reference.
2591
We want to match the most embedded reference first.
2593
I.e. for '{{foo}}' we will get '{foo}',
2594
for '{bar{baz}}' we will get '{baz}'
2597
def iter_option_refs(string):
2598
# Split isolate refs so every other chunk is a ref
2600
for chunk in _option_ref_re.split(string):
2605
class OptionRegistry(registry.Registry):
2606
"""Register config options by their name.
2608
This overrides ``registry.Registry`` to simplify registration by acquiring
2609
some information from the option object itself.
2612
def _check_option_name(self, option_name):
2613
"""Ensures an option name is valid.
2615
:param option_name: The name to validate.
2617
if _option_ref_re.match('{%s}' % option_name) is None:
2618
raise IllegalOptionName(option_name)
2620
def register(self, option):
2621
"""Register a new option to its name.
2623
:param option: The option to register. Its name is used as the key.
2625
self._check_option_name(option.name)
2626
super(OptionRegistry, self).register(option.name, option,
2629
def register_lazy(self, key, module_name, member_name):
2630
"""Register a new option to be loaded on request.
2632
:param key: the key to request the option later. Since the registration
2633
is lazy, it should be provided and match the option name.
2635
:param module_name: the python path to the module. Such as 'os.path'.
2637
:param member_name: the member of the module to return. If empty or
2638
None, get() will return the module itself.
2640
self._check_option_name(key)
2641
super(OptionRegistry, self).register_lazy(key,
2642
module_name, member_name)
2644
def get_help(self, key=None):
2645
"""Get the help text associated with the given key"""
2646
option = self.get(key)
2647
the_help = option.help
2648
if callable(the_help):
2649
return the_help(self, key)
2653
option_registry = OptionRegistry()
2656
# Registered options in lexicographical order
2658
option_registry.register(
2659
Option('append_revisions_only',
2660
default=None, from_unicode=bool_from_store, invalid='warning',
2662
Whether to only append revisions to the mainline.
2664
If this is set to true, then it is not possible to change the
2665
existing mainline of the branch.
2667
option_registry.register(
2668
ListOption('acceptable_keys',
2671
List of GPG key patterns which are acceptable for verification.
2673
option_registry.register(
2674
Option('add.maximum_file_size',
2675
default=u'20MB', from_unicode=int_SI_from_store,
2677
Size above which files should be added manually.
2679
Files below this size are added automatically when using ``bzr add`` without
2682
A negative value means disable the size check.
2684
option_registry.register(
2686
default=None, from_unicode=bool_from_store,
2688
Is the branch bound to ``bound_location``.
2690
If set to "True", the branch should act as a checkout, and push each commit to
2691
the bound_location. This option is normally set by ``bind``/``unbind``.
2693
See also: bound_location.
2695
option_registry.register(
2696
Option('bound_location',
2699
The location that commits should go to when acting as a checkout.
2701
This option is normally set by ``bind``.
2705
option_registry.register(
2706
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2708
Whether revisions associated with tags should be fetched.
2710
option_registry.register_lazy(
2711
'bzr.transform.orphan_policy', 'breezy.transform', 'opt_transform_orphan')
2712
option_registry.register(
2713
Option('bzr.workingtree.worth_saving_limit', default=10,
2714
from_unicode=int_from_store, invalid='warning',
2716
How many changes before saving the dirstate.
2718
-1 means that we will never rewrite the dirstate file for only
2719
stat-cache changes. Regardless of this setting, we will always rewrite
2720
the dirstate file if a file is added/removed/renamed/etc. This flag only
2721
affects the behavior of updating the dirstate file after we notice that
2722
a file has been touched.
2724
option_registry.register(
2725
Option('bugtracker', default=None,
2727
Default bug tracker to use.
2729
This bug tracker will be used for example when marking bugs
2730
as fixed using ``bzr commit --fixes``, if no explicit
2731
bug tracker was specified.
2733
option_registry.register(
2734
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2735
from_unicode=signature_policy_from_unicode,
2737
GPG checking policy.
2739
Possible values: require, ignore, check-available (default)
2741
this option will control whether bzr will require good gpg
2742
signatures, ignore them, or check them if they are
2745
option_registry.register(
2746
Option('child_submit_format',
2747
help='''The preferred format of submissions to this branch.'''))
2748
option_registry.register(
2749
Option('child_submit_to',
2750
help='''Where submissions to this branch are mailed to.'''))
2751
option_registry.register(
2752
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2753
from_unicode=signing_policy_from_unicode,
2757
Possible values: always, never, when-required (default)
2759
This option controls whether bzr will always create
2760
gpg signatures or not on commits.
2762
option_registry.register(
2763
Option('dirstate.fdatasync', default=True,
2764
from_unicode=bool_from_store,
2766
Flush dirstate changes onto physical disk?
2768
If true (default), working tree metadata changes are flushed through the
2769
OS buffers to physical disk. This is somewhat slower, but means data
2770
should not be lost if the machine crashes. See also repository.fdatasync.
2772
option_registry.register(
2773
ListOption('debug_flags', default=[],
2774
help='Debug flags to activate.'))
2775
option_registry.register(
2776
Option('default_format', default='2a',
2777
help='Format used when creating branches.'))
2778
option_registry.register(
2779
Option('dpush_strict', default=None,
2780
from_unicode=bool_from_store,
2782
The default value for ``dpush --strict``.
2784
If present, defines the ``--strict`` option default value for checking
2785
uncommitted changes before pushing into a different VCS without any
2786
custom bzr metadata.
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 != 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
return self._lock.lock_write(token)
3413
def break_lock(self):
3414
self._lock.break_lock()
3418
# We need to be able to override the undecorated implementation
3419
self.save_without_locking()
3421
def save_without_locking(self):
3422
super(LockableIniFileStore, self).save()
3425
# FIXME: global, breezy, shouldn't that be 'user' instead or even
3426
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3427
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3429
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3430
# functions or a registry will make it easier and clearer for tests, focusing
3431
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3432
# on a poolie's remark)
3433
class GlobalStore(LockableIniFileStore):
3434
"""A config store for global options.
3436
There is a single GlobalStore for a given process.
3439
def __init__(self, possible_transports=None):
3440
(path, kind) = _config_dir()
3441
t = transport.get_transport_from_path(
3442
path, possible_transports=possible_transports)
3443
filename = {'bazaar': 'bazaar.conf', 'breezy': 'breezy.conf'}[kind]
3444
super(GlobalStore, self).__init__(t, filename)
3448
class LocationStore(LockableIniFileStore):
3449
"""A config store for options specific to a location.
3451
There is a single LocationStore for a given process.
3454
def __init__(self, possible_transports=None):
3455
t = transport.get_transport_from_path(
3456
config_dir(), possible_transports=possible_transports)
3457
super(LocationStore, self).__init__(t, 'locations.conf')
3458
self.id = 'locations'
3461
class BranchStore(TransportIniFileStore):
3462
"""A config store for branch options.
3464
There is a single BranchStore for a given branch.
3467
def __init__(self, branch):
3468
super(BranchStore, self).__init__(branch.control_transport,
3470
self.branch = branch
3474
class ControlStore(LockableIniFileStore):
3476
def __init__(self, bzrdir):
3477
super(ControlStore, self).__init__(bzrdir.transport,
3479
lock_dir_name='branch_lock')
3483
class SectionMatcher(object):
3484
"""Select sections into a given Store.
3486
This is intended to be used to postpone getting an iterable of sections
3490
def __init__(self, store):
3493
def get_sections(self):
3494
# This is where we require loading the store so we can see all defined
3496
sections = self.store.get_sections()
3497
# Walk the revisions in the order provided
3498
for store, s in sections:
3502
def match(self, section):
3503
"""Does the proposed section match.
3505
:param section: A Section object.
3507
:returns: True if the section matches, False otherwise.
3509
raise NotImplementedError(self.match)
3512
class NameMatcher(SectionMatcher):
3514
def __init__(self, store, section_id):
3515
super(NameMatcher, self).__init__(store)
3516
self.section_id = section_id
3518
def match(self, section):
3519
return section.id == self.section_id
3522
class LocationSection(Section):
3524
def __init__(self, section, extra_path, branch_name=None):
3525
super(LocationSection, self).__init__(section.id, section.options)
3526
self.extra_path = extra_path
3527
if branch_name is None:
3529
self.locals = {'relpath': extra_path,
3530
'basename': urlutils.basename(extra_path),
3531
'branchname': branch_name}
3533
def get(self, name, default=None, expand=True):
3534
value = super(LocationSection, self).get(name, default)
3535
if value is not None and expand:
3536
policy_name = self.get(name + ':policy', None)
3537
policy = _policy_value.get(policy_name, POLICY_NONE)
3538
if policy == POLICY_APPENDPATH:
3539
value = urlutils.join(value, self.extra_path)
3540
# expand section local options right now (since POLICY_APPENDPATH
3541
# will never add options references, it's ok to expand after it).
3543
for is_ref, chunk in iter_option_refs(value):
3545
chunks.append(chunk)
3548
if ref in self.locals:
3549
chunks.append(self.locals[ref])
3551
chunks.append(chunk)
3552
value = ''.join(chunks)
3556
class StartingPathMatcher(SectionMatcher):
3557
"""Select sections for a given location respecting the Store order."""
3559
# FIXME: Both local paths and urls can be used for section names as well as
3560
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3561
# inherited the fuzziness from the previous ``LocationConfig``
3562
# implementation. We probably need to revisit which encoding is allowed for
3563
# both ``location`` and section names and how we normalize
3564
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3565
# related too. -- vila 2012-01-04
3567
def __init__(self, store, location):
3568
super(StartingPathMatcher, self).__init__(store)
3569
if location.startswith('file://'):
3570
location = urlutils.local_path_from_url(location)
3571
self.location = location
3573
def get_sections(self):
3574
"""Get all sections matching ``location`` in the store.
3576
The most generic sections are described first in the store, then more
3577
specific ones can be provided for reduced scopes.
3579
The returned section are therefore returned in the reversed order so
3580
the most specific ones can be found first.
3582
location_parts = self.location.rstrip('/').split('/')
3584
# Later sections are more specific, they should be returned first
3585
for _, section in reversed(list(store.get_sections())):
3586
if section.id is None:
3587
# The no-name section is always included if present
3588
yield store, LocationSection(section, self.location)
3590
section_path = section.id
3591
if section_path.startswith('file://'):
3592
# the location is already a local path or URL, convert the
3593
# section id to the same format
3594
section_path = urlutils.local_path_from_url(section_path)
3595
if (self.location.startswith(section_path)
3596
or fnmatch.fnmatch(self.location, section_path)):
3597
section_parts = section_path.rstrip('/').split('/')
3598
extra_path = '/'.join(location_parts[len(section_parts):])
3599
yield store, LocationSection(section, extra_path)
3602
class LocationMatcher(SectionMatcher):
3604
def __init__(self, store, location):
3605
super(LocationMatcher, self).__init__(store)
3606
url, params = urlutils.split_segment_parameters(location)
3607
if location.startswith('file://'):
3608
location = urlutils.local_path_from_url(location)
3609
self.location = location
3610
branch_name = params.get('branch')
3611
if branch_name is None:
3612
self.branch_name = urlutils.basename(self.location)
3614
self.branch_name = urlutils.unescape(branch_name)
3616
def _get_matching_sections(self):
3617
"""Get all sections matching ``location``."""
3618
# We slightly diverge from LocalConfig here by allowing the no-name
3619
# section as the most generic one and the lower priority.
3620
no_name_section = None
3622
# Filter out the no_name_section so _iter_for_location_by_parts can be
3623
# used (it assumes all sections have a name).
3624
for _, section in self.store.get_sections():
3625
if section.id is None:
3626
no_name_section = section
3628
all_sections.append(section)
3629
# Unfortunately _iter_for_location_by_parts deals with section names so
3630
# we have to resync.
3631
filtered_sections = _iter_for_location_by_parts(
3632
[s.id for s in all_sections], self.location)
3633
iter_all_sections = iter(all_sections)
3634
matching_sections = []
3635
if no_name_section is not None:
3636
matching_sections.append(
3637
(0, LocationSection(no_name_section, self.location)))
3638
for section_id, extra_path, length in filtered_sections:
3639
# a section id is unique for a given store so it's safe to take the
3640
# first matching section while iterating. Also, all filtered
3641
# sections are part of 'all_sections' and will always be found
3644
section = next(iter_all_sections)
3645
if section_id == section.id:
3646
section = LocationSection(section, extra_path,
3648
matching_sections.append((length, section))
3650
return matching_sections
3652
def get_sections(self):
3653
# Override the default implementation as we want to change the order
3654
# We want the longest (aka more specific) locations first
3655
sections = sorted(self._get_matching_sections(),
3656
key=lambda match: (match[0], match[1].id),
3658
# Sections mentioning 'ignore_parents' restrict the selection
3659
for _, section in sections:
3660
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3661
ignore = section.get('ignore_parents', None)
3662
if ignore is not None:
3663
ignore = ui.bool_from_string(ignore)
3666
# Finally, we have a valid section
3667
yield self.store, section
3670
# FIXME: _shared_stores should be an attribute of a library state once a
3671
# library_state object is always available.
3673
_shared_stores_at_exit_installed = False
3675
class Stack(object):
3676
"""A stack of configurations where an option can be defined"""
3678
def __init__(self, sections_def, store=None, mutable_section_id=None):
3679
"""Creates a stack of sections with an optional store for changes.
3681
:param sections_def: A list of Section or callables that returns an
3682
iterable of Section. This defines the Sections for the Stack and
3683
can be called repeatedly if needed.
3685
:param store: The optional Store where modifications will be
3686
recorded. If none is specified, no modifications can be done.
3688
:param mutable_section_id: The id of the MutableSection where changes
3689
are recorded. This requires the ``store`` parameter to be
3692
self.sections_def = sections_def
3694
self.mutable_section_id = mutable_section_id
3696
def iter_sections(self):
3697
"""Iterate all the defined sections."""
3698
# Ensuring lazy loading is achieved by delaying section matching (which
3699
# implies querying the persistent storage) until it can't be avoided
3700
# anymore by using callables to describe (possibly empty) section
3702
for sections in self.sections_def:
3703
for store, section in sections():
3704
yield store, section
3706
def get(self, name, expand=True, convert=True):
3707
"""Return the *first* option value found in the sections.
3709
This is where we guarantee that sections coming from Store are loaded
3710
lazily: the loading is delayed until we need to either check that an
3711
option exists or get its value, which in turn may require to discover
3712
in which sections it can be defined. Both of these (section and option
3713
existence) require loading the store (even partially).
3715
:param name: The queried option.
3717
:param expand: Whether options references should be expanded.
3719
:param convert: Whether the option value should be converted from
3720
unicode (do nothing for non-registered options).
3722
:returns: The value of the option.
3724
# FIXME: No caching of options nor sections yet -- vila 20110503
3726
found_store = None # Where the option value has been found
3727
# If the option is registered, it may provide additional info about
3730
opt = option_registry.get(name)
3735
def expand_and_convert(val):
3736
# This may need to be called in different contexts if the value is
3737
# None or ends up being None during expansion or conversion.
3740
if isinstance(val, string_types):
3741
val = self._expand_options_in_string(val)
3743
trace.warning('Cannot expand "%s":'
3744
' %s does not support option expansion'
3745
% (name, type(val)))
3747
val = found_store.unquote(val)
3749
val = opt.convert_from_unicode(found_store, val)
3752
# First of all, check if the environment can override the configuration
3754
if opt is not None and opt.override_from_env:
3755
value = opt.get_override()
3756
value = expand_and_convert(value)
3758
for store, section in self.iter_sections():
3759
value = section.get(name)
3760
if value is not None:
3763
value = expand_and_convert(value)
3764
if opt is not None and value is None:
3765
# If the option is registered, it may provide a default value
3766
value = opt.get_default()
3767
value = expand_and_convert(value)
3768
for hook in ConfigHooks['get']:
3769
hook(self, name, value)
3772
def expand_options(self, string, env=None):
3773
"""Expand option references in the string in the configuration context.
3775
:param string: The string containing option(s) to expand.
3777
:param env: An option dict defining additional configuration options or
3778
overriding existing ones.
3780
:returns: The expanded string.
3782
return self._expand_options_in_string(string, env)
3784
def _expand_options_in_string(self, string, env=None, _refs=None):
3785
"""Expand options in the string in the configuration context.
3787
:param string: The string to be expanded.
3789
:param env: An option dict defining additional configuration options or
3790
overriding existing ones.
3792
:param _refs: Private list (FIFO) containing the options being expanded
3795
:returns: The expanded string.
3798
# Not much to expand there
3801
# What references are currently resolved (to detect loops)
3804
# We need to iterate until no more refs appear ({{foo}} will need two
3805
# iterations for example).
3810
for is_ref, chunk in iter_option_refs(result):
3812
chunks.append(chunk)
3817
raise OptionExpansionLoop(string, _refs)
3819
value = self._expand_option(name, env, _refs)
3821
raise ExpandingUnknownOption(name, string)
3822
chunks.append(value)
3824
result = ''.join(chunks)
3827
def _expand_option(self, name, env, _refs):
3828
if env is not None and name in env:
3829
# Special case, values provided in env takes precedence over
3833
value = self.get(name, expand=False, convert=False)
3834
value = self._expand_options_in_string(value, env, _refs)
3837
def _get_mutable_section(self):
3838
"""Get the MutableSection for the Stack.
3840
This is where we guarantee that the mutable section is lazily loaded:
3841
this means we won't load the corresponding store before setting a value
3842
or deleting an option. In practice the store will often be loaded but
3843
this helps catching some programming errors.
3846
section = store.get_mutable_section(self.mutable_section_id)
3847
return store, section
3849
def set(self, name, value):
3850
"""Set a new value for the option."""
3851
store, section = self._get_mutable_section()
3852
section.set(name, store.quote(value))
3853
for hook in ConfigHooks['set']:
3854
hook(self, name, value)
3856
def remove(self, name):
3857
"""Remove an existing option."""
3858
_, section = self._get_mutable_section()
3859
section.remove(name)
3860
for hook in ConfigHooks['remove']:
3864
# Mostly for debugging use
3865
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3867
def _get_overrides(self):
3868
# FIXME: Hack around library_state.initialize never called
3869
if breezy.global_state is not None:
3870
return breezy.global_state.cmdline_overrides.get_sections()
3873
def get_shared_store(self, store, state=None):
3874
"""Get a known shared store.
3876
Store urls uniquely identify them and are used to ensure a single copy
3877
is shared across all users.
3879
:param store: The store known to the caller.
3881
:param state: The library state where the known stores are kept.
3883
:returns: The store received if it's not a known one, an already known
3887
state = breezy.global_state
3889
global _shared_stores_at_exit_installed
3890
stores = _shared_stores
3891
def save_config_changes():
3892
for k, store in stores.items():
3893
store.save_changes()
3894
if not _shared_stores_at_exit_installed:
3895
# FIXME: Ugly hack waiting for library_state to always be
3896
# available. -- vila 20120731
3898
atexit.register(save_config_changes)
3899
_shared_stores_at_exit_installed = True
3901
stores = state.config_stores
3902
url = store.external_url()
3910
class MemoryStack(Stack):
3911
"""A configuration stack defined from a string.
3913
This is mainly intended for tests and requires no disk resources.
3916
def __init__(self, content=None):
3917
"""Create an in-memory stack from a given content.
3919
It uses a single store based on configobj and support reading and
3922
:param content: The initial content of the store. If None, the store is
3923
not loaded and ``_load_from_string`` can and should be used if
3926
store = IniFileStore()
3927
if content is not None:
3928
store._load_from_string(content)
3929
super(MemoryStack, self).__init__(
3930
[store.get_sections], store)
3933
class _CompatibleStack(Stack):
3934
"""Place holder for compatibility with previous design.
3936
This is intended to ease the transition from the Config-based design to the
3937
Stack-based design and should not be used nor relied upon by plugins.
3939
One assumption made here is that the daughter classes will all use Stores
3940
derived from LockableIniFileStore).
3942
It implements set() and remove () by re-loading the store before applying
3943
the modification and saving it.
3945
The long term plan being to implement a single write by store to save
3946
all modifications, this class should not be used in the interim.
3949
def set(self, name, value):
3952
super(_CompatibleStack, self).set(name, value)
3953
# Force a write to persistent storage
3956
def remove(self, name):
3959
super(_CompatibleStack, self).remove(name)
3960
# Force a write to persistent storage
3964
class GlobalStack(Stack):
3965
"""Global options only stack.
3967
The following sections are queried:
3969
* command-line overrides,
3971
* the 'DEFAULT' section in bazaar.conf
3973
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3978
gstore = self.get_shared_store(GlobalStore())
3979
super(GlobalStack, self).__init__(
3980
[self._get_overrides,
3981
NameMatcher(gstore, 'DEFAULT').get_sections],
3982
gstore, mutable_section_id='DEFAULT')
3985
class LocationStack(Stack):
3986
"""Per-location options falling back to global options stack.
3989
The following sections are queried:
3991
* command-line overrides,
3993
* the sections matching ``location`` in ``locations.conf``, the order being
3994
defined by the number of path components in the section glob, higher
3995
numbers first (from most specific section to most generic).
3997
* the 'DEFAULT' section in bazaar.conf
3999
This stack will use the ``location`` section in locations.conf as its
4003
def __init__(self, location):
4004
"""Make a new stack for a location and global configuration.
4006
:param location: A URL prefix to """
4007
lstore = self.get_shared_store(LocationStore())
4008
if location.startswith('file://'):
4009
location = urlutils.local_path_from_url(location)
4010
gstore = self.get_shared_store(GlobalStore())
4011
super(LocationStack, self).__init__(
4012
[self._get_overrides,
4013
LocationMatcher(lstore, location).get_sections,
4014
NameMatcher(gstore, 'DEFAULT').get_sections],
4015
lstore, mutable_section_id=location)
4018
class BranchStack(Stack):
4019
"""Per-location options falling back to branch then global options stack.
4021
The following sections are queried:
4023
* command-line overrides,
4025
* the sections matching ``location`` in ``locations.conf``, the order being
4026
defined by the number of path components in the section glob, higher
4027
numbers first (from most specific section to most generic),
4029
* the no-name section in branch.conf,
4031
* the ``DEFAULT`` section in ``bazaar.conf``.
4033
This stack will use the no-name section in ``branch.conf`` as its
4037
def __init__(self, branch):
4038
lstore = self.get_shared_store(LocationStore())
4039
bstore = branch._get_config_store()
4040
gstore = self.get_shared_store(GlobalStore())
4041
super(BranchStack, self).__init__(
4042
[self._get_overrides,
4043
LocationMatcher(lstore, branch.base).get_sections,
4044
NameMatcher(bstore, None).get_sections,
4045
NameMatcher(gstore, 'DEFAULT').get_sections],
4047
self.branch = branch
4049
def lock_write(self, token=None):
4050
return self.branch.lock_write(token)
4053
return self.branch.unlock()
4056
def set(self, name, value):
4057
super(BranchStack, self).set(name, value)
4058
# Unlocking the branch will trigger a store.save_changes() so the last
4059
# unlock saves all the changes.
4062
def remove(self, name):
4063
super(BranchStack, self).remove(name)
4064
# Unlocking the branch will trigger a store.save_changes() so the last
4065
# unlock saves all the changes.
4068
class RemoteControlStack(Stack):
4069
"""Remote control-only options stack."""
4071
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4072
# with the stack used for remote bzr dirs. RemoteControlStack only uses
4073
# control.conf and is used only for stack options.
4075
def __init__(self, bzrdir):
4076
cstore = bzrdir._get_config_store()
4077
super(RemoteControlStack, self).__init__(
4078
[NameMatcher(cstore, None).get_sections],
4080
self.controldir = bzrdir
4083
class BranchOnlyStack(Stack):
4084
"""Branch-only options stack."""
4086
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4087
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4088
# -- vila 2011-12-16
4090
def __init__(self, branch):
4091
bstore = branch._get_config_store()
4092
super(BranchOnlyStack, self).__init__(
4093
[NameMatcher(bstore, None).get_sections],
4095
self.branch = branch
4097
def lock_write(self, token=None):
4098
return self.branch.lock_write(token)
4101
return self.branch.unlock()
4104
def set(self, name, value):
4105
super(BranchOnlyStack, self).set(name, value)
4106
# Force a write to persistent storage
4107
self.store.save_changes()
4110
def remove(self, name):
4111
super(BranchOnlyStack, self).remove(name)
4112
# Force a write to persistent storage
4113
self.store.save_changes()
4116
class cmd_config(commands.Command):
4117
__doc__ = """Display, set or remove a configuration option.
4119
Display the active value for option NAME.
4121
If --all is specified, NAME is interpreted as a regular expression and all
4122
matching options are displayed mentioning their scope and without resolving
4123
option references in the value). The active value that bzr will take into
4124
account is the first one displayed for each option.
4126
If NAME is not given, --all .* is implied (all options are displayed for the
4129
Setting a value is achieved by using NAME=value without spaces. The value
4130
is set in the most relevant scope and can be checked by displaying the
4133
Removing a value is achieved by using --remove NAME.
4136
takes_args = ['name?']
4140
# FIXME: This should be a registry option so that plugins can register
4141
# their own config files (or not) and will also address
4142
# http://pad.lv/788991 -- vila 20101115
4143
commands.Option('scope', help='Reduce the scope to the specified'
4144
' configuration file.',
4146
commands.Option('all',
4147
help='Display all the defined values for the matching options.',
4149
commands.Option('remove', help='Remove the option from'
4150
' the configuration file.'),
4153
_see_also = ['configuration']
4155
@commands.display_command
4156
def run(self, name=None, all=False, directory=None, scope=None,
4158
if directory is None:
4160
directory = directory_service.directories.dereference(directory)
4161
directory = urlutils.normalize_url(directory)
4163
raise errors.BzrError(
4164
'--all and --remove are mutually exclusive.')
4166
# Delete the option in the given scope
4167
self._remove_config_option(name, directory, scope)
4169
# Defaults to all options
4170
self._show_matching_options('.*', directory, scope)
4173
name, value = name.split('=', 1)
4175
# Display the option(s) value(s)
4177
self._show_matching_options(name, directory, scope)
4179
self._show_value(name, directory, scope)
4182
raise errors.BzrError(
4183
'Only one option can be set.')
4184
# Set the option value
4185
self._set_config_option(name, value, directory, scope)
4187
def _get_stack(self, directory, scope=None, write_access=False):
4188
"""Get the configuration stack specified by ``directory`` and ``scope``.
4190
:param directory: Where the configurations are derived from.
4192
:param scope: A specific config to start from.
4194
:param write_access: Whether a write access to the stack will be
4197
# FIXME: scope should allow access to plugin-specific stacks (even
4198
# reduced to the plugin-specific store), related to
4199
# http://pad.lv/788991 -- vila 2011-11-15
4200
if scope is not None:
4201
if scope == 'breezy':
4202
return GlobalStack()
4203
elif scope == 'locations':
4204
return LocationStack(directory)
4205
elif scope == 'branch':
4207
controldir.ControlDir.open_containing_tree_or_branch(
4210
self.add_cleanup(br.lock_write().unlock)
4211
return br.get_config_stack()
4212
raise NoSuchConfig(scope)
4216
controldir.ControlDir.open_containing_tree_or_branch(
4219
self.add_cleanup(br.lock_write().unlock)
4220
return br.get_config_stack()
4221
except errors.NotBranchError:
4222
return LocationStack(directory)
4224
def _quote_multiline(self, value):
4226
value = '"""' + value + '"""'
4229
def _show_value(self, name, directory, scope):
4230
conf = self._get_stack(directory, scope)
4231
value = conf.get(name, expand=True, convert=False)
4232
if value is not None:
4233
# Quote the value appropriately
4234
value = self._quote_multiline(value)
4235
self.outf.write('%s\n' % (value,))
4237
raise NoSuchConfigOption(name)
4239
def _show_matching_options(self, name, directory, scope):
4240
name = lazy_regex.lazy_compile(name)
4241
# We want any error in the regexp to be raised *now* so we need to
4242
# avoid the delay introduced by the lazy regexp. But, we still do
4243
# want the nicer errors raised by lazy_regex.
4244
name._compile_and_collapse()
4247
conf = self._get_stack(directory, scope)
4248
for store, section in conf.iter_sections():
4249
for oname in section.iter_option_names():
4250
if name.search(oname):
4251
if cur_store_id != store.id:
4252
# Explain where the options are defined
4253
self.outf.write('%s:\n' % (store.id,))
4254
cur_store_id = store.id
4256
if (section.id is not None and cur_section != section.id):
4257
# Display the section id as it appears in the store
4258
# (None doesn't appear by definition)
4259
self.outf.write(' [%s]\n' % (section.id,))
4260
cur_section = section.id
4261
value = section.get(oname, expand=False)
4262
# Quote the value appropriately
4263
value = self._quote_multiline(value)
4264
self.outf.write(' %s = %s\n' % (oname, value))
4266
def _set_config_option(self, name, value, directory, scope):
4267
conf = self._get_stack(directory, scope, write_access=True)
4268
conf.set(name, value)
4269
# Explicitly save the changes
4270
conf.store.save_changes()
4272
def _remove_config_option(self, name, directory, scope):
4274
raise errors.BzrCommandError(
4275
'--remove expects an option to remove.')
4276
conf = self._get_stack(directory, scope, write_access=True)
4279
# Explicitly save the changes
4280
conf.store.save_changes()
4282
raise NoSuchConfigOption(name)
4287
# We need adapters that can build a Store or a Stack in a test context. Test
4288
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4289
# themselves. The builder will receive a test instance and should return a
4290
# ready-to-use store or stack. Plugins that define new store/stacks can also
4291
# register themselves here to be tested against the tests defined in
4292
# breezy.tests.test_config. Note that the builder can be called multiple times
4293
# for the same test.
4295
# The registered object should be a callable receiving a test instance
4296
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4298
test_store_builder_registry = registry.Registry()
4300
# The registered object should be a callable receiving a test instance
4301
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4303
test_stack_builder_registry = registry.Registry()
added
removed
breezy/config.py
