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 Bazaar.
21
Currently this configuration resides in ~/.bazaar/bazaar.conf
22
and ~/.bazaar/locations.conf, which is written to by brz.
24
In bazaar.conf the following options may be set:
26
editor=name-of-program
27
email=Your Name <your@email.address>
28
check_signatures=require|ignore|check-available(default)
29
create_signatures=always|never|when-required(default)
30
gpg_signing_command=name-of-program
31
log_format=name-of-format
32
validate_signatures_in_log=true|false(default)
33
acceptable_keys=pattern1,pattern2
34
gpg_signing_key=amy@example.com
36
in locations.conf, you specify the url of a branch and options for it.
37
Wildcards may be used - * and ? as normal in shell completion. Options
38
set in both bazaar.conf and locations.conf are overridden by the locations.conf
40
[/home/robertc/source]
41
recurse=False|True(default)
43
check_signatures= as above
44
create_signatures= as above.
45
validate_signatures_in_log=as above
46
acceptable_keys=as above
48
explanation of options
49
----------------------
50
editor - this option sets the pop up editor to use during commits.
51
email - this option sets the user id brz will use when committing.
52
check_signatures - this option will control whether brz will require good gpg
53
signatures, ignore them, or check them if they are
54
present. Currently it is unused except that check_signatures
55
turns on create_signatures.
56
create_signatures - this option controls whether brz will always create
57
gpg signatures or not on commits. There is an unused
58
option which in future is expected to work if
59
branch settings require signatures.
60
log_format - this option sets the default log format. Possible values are
61
long, short, line, or a plugin can register new formats.
62
validate_signatures_in_log - show GPG signature validity in log output
63
acceptable_keys - comma separated list of key patterns acceptable for
64
verify-signatures command
66
In bazaar.conf you can also define aliases in the ALIASES sections, example
69
lastlog=log --line -r-10..-1
70
ll=log --line -r-10..-1
75
from __future__ import absolute_import
82
from .decorators import needs_write_lock
83
from .lazy_import import lazy_import
84
lazy_import(globals(), """
108
from breezy.i18n import gettext
116
from .sixish import (
137
POLICY_APPENDPATH = 2
141
POLICY_NORECURSE: 'norecurse',
142
POLICY_APPENDPATH: 'appendpath',
147
'norecurse': POLICY_NORECURSE,
148
'appendpath': POLICY_APPENDPATH,
152
STORE_LOCATION = POLICY_NONE
153
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
154
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
159
def signature_policy_from_unicode(signature_string):
160
"""Convert a string to a signing policy."""
161
if signature_string.lower() == 'check-available':
162
return CHECK_IF_POSSIBLE
163
if signature_string.lower() == 'ignore':
165
if signature_string.lower() == 'require':
167
raise ValueError("Invalid signatures policy '%s'"
171
def signing_policy_from_unicode(signature_string):
172
"""Convert a string to a signing policy."""
173
if signature_string.lower() == 'when-required':
174
return SIGN_WHEN_REQUIRED
175
if signature_string.lower() == 'never':
177
if signature_string.lower() == 'always':
179
raise ValueError("Invalid signing policy '%s'"
183
def _has_decode_bug():
184
"""True if configobj will fail to decode to unicode on Python 2."""
185
if sys.version_info > (3,):
187
conf = configobj.ConfigObj()
188
decode = getattr(conf, "_decode", None)
190
result = decode(b"\xc2\xa7", "utf-8")
191
if isinstance(result[0], str):
196
def _has_triplequote_bug():
197
"""True if triple quote logic is reversed, see lp:710410."""
198
conf = configobj.ConfigObj()
199
quote = getattr(conf, "_get_triple_quote", None)
200
if quote and quote('"""') != "'''":
205
class ConfigObj(configobj.ConfigObj):
207
def __init__(self, infile=None, **kwargs):
208
# We define our own interpolation mechanism calling it option expansion
209
super(ConfigObj, self).__init__(infile=infile,
213
if _has_decode_bug():
214
def _decode(self, infile, encoding):
215
if isinstance(infile, str) and encoding:
216
return infile.decode(encoding).splitlines(True)
217
return super(ConfigObj, self)._decode(infile, encoding)
219
if _has_triplequote_bug():
220
def _get_triple_quote(self, value):
221
quot = super(ConfigObj, self)._get_triple_quote(value)
222
if quot == configobj.tdquot:
223
return configobj.tsquot
224
return configobj.tdquot
226
def get_bool(self, section, key):
227
return self[section].as_bool(key)
229
def get_value(self, section, name):
230
# Try [] for the old DEFAULT section.
231
if section == "DEFAULT":
236
return self[section][name]
239
class Config(object):
240
"""A configuration policy - what username, editor, gpg needs etc."""
243
super(Config, self).__init__()
246
"""Returns a unique ID for the config."""
247
raise NotImplementedError(self.config_id)
249
def get_change_editor(self, old_tree, new_tree):
250
from breezy import diff
251
cmd = self._get_change_editor()
254
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
257
def _get_signature_checking(self):
258
"""Template method to override signature checking policy."""
260
def _get_signing_policy(self):
261
"""Template method to override signature creation policy."""
265
def expand_options(self, string, env=None):
266
"""Expand option references in the string in the configuration context.
268
:param string: The string containing option to expand.
270
:param env: An option dict defining additional configuration options or
271
overriding existing ones.
273
:returns: The expanded string.
275
return self._expand_options_in_string(string, env)
277
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
278
"""Expand options in a list of strings in the configuration context.
280
:param slist: A list of strings.
282
:param env: An option dict defining additional configuration options or
283
overriding existing ones.
285
:param _ref_stack: Private list containing the options being
286
expanded to detect loops.
288
:returns: The flatten list of expanded strings.
290
# expand options in each value separately flattening lists
293
value = self._expand_options_in_string(s, env, _ref_stack)
294
if isinstance(value, list):
300
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
301
"""Expand options in the string in the configuration context.
303
:param string: The string to be expanded.
305
:param env: An option dict defining additional configuration options or
306
overriding existing ones.
308
:param _ref_stack: Private list containing the options being
309
expanded to detect loops.
311
:returns: The expanded string.
314
# Not much to expand there
316
if _ref_stack is None:
317
# What references are currently resolved (to detect loops)
319
if self.option_ref_re is None:
320
# We want to match the most embedded reference first (i.e. for
321
# '{{foo}}' we will get '{foo}',
322
# for '{bar{baz}}' we will get '{baz}'
323
self.option_ref_re = re.compile('({[^{}]+})')
325
# We need to iterate until no more refs appear ({{foo}} will need two
326
# iterations for example).
328
raw_chunks = self.option_ref_re.split(result)
329
if len(raw_chunks) == 1:
330
# Shorcut the trivial case: no refs
334
# Split will isolate refs so that every other chunk is a ref
336
for chunk in raw_chunks:
339
# Keep only non-empty strings (or we get bogus empty
340
# slots when a list value is involved).
345
if name in _ref_stack:
346
raise errors.OptionExpansionLoop(string, _ref_stack)
347
_ref_stack.append(name)
348
value = self._expand_option(name, env, _ref_stack)
350
raise errors.ExpandingUnknownOption(name, string)
351
if isinstance(value, list):
359
# Once a list appears as the result of an expansion, all
360
# callers will get a list result. This allows a consistent
361
# behavior even when some options in the expansion chain
362
# defined as strings (no comma in their value) but their
363
# expanded value is a list.
364
return self._expand_options_in_list(chunks, env, _ref_stack)
366
result = ''.join(chunks)
369
def _expand_option(self, name, env, _ref_stack):
370
if env is not None and name in env:
371
# Special case, values provided in env takes precedence over
375
# FIXME: This is a limited implementation, what we really need is a
376
# way to query the brz config for the value of an option,
377
# respecting the scope rules (That is, once we implement fallback
378
# configs, getting the option value should restart from the top
379
# config, not the current one) -- vila 20101222
380
value = self.get_user_option(name, expand=False)
381
if isinstance(value, list):
382
value = self._expand_options_in_list(value, env, _ref_stack)
384
value = self._expand_options_in_string(value, env, _ref_stack)
387
def _get_user_option(self, option_name):
388
"""Template method to provide a user option."""
391
def get_user_option(self, option_name, expand=True):
392
"""Get a generic option - no special process, no default.
394
:param option_name: The queried option.
396
:param expand: Whether options references should be expanded.
398
:returns: The value of the option.
400
value = self._get_user_option(option_name)
402
if isinstance(value, list):
403
value = self._expand_options_in_list(value)
404
elif isinstance(value, dict):
405
trace.warning('Cannot expand "%s":'
406
' Dicts do not support option expansion'
409
value = self._expand_options_in_string(value)
410
for hook in OldConfigHooks['get']:
411
hook(self, option_name, value)
414
def get_user_option_as_bool(self, option_name, expand=None, default=None):
415
"""Get a generic option as a boolean.
417
:param expand: Allow expanding references to other config values.
418
:param default: Default value if nothing is configured
419
:return None if the option doesn't exist or its value can't be
420
interpreted as a boolean. Returns True or False otherwise.
422
s = self.get_user_option(option_name, expand=expand)
424
# The option doesn't exist
426
val = ui.bool_from_string(s)
428
# The value can't be interpreted as a boolean
429
trace.warning('Value "%s" is not a boolean for "%s"',
433
def get_user_option_as_list(self, option_name, expand=None):
434
"""Get a generic option as a list - no special process, no default.
436
:return None if the option doesn't exist. Returns the value as a list
439
l = self.get_user_option(option_name, expand=expand)
440
if isinstance(l, string_types):
441
# A single value, most probably the user forgot (or didn't care to
446
def _log_format(self):
447
"""See log_format()."""
450
def validate_signatures_in_log(self):
451
"""Show GPG signature validity in log"""
452
result = self._validate_signatures_in_log()
459
def _validate_signatures_in_log(self):
460
"""See validate_signatures_in_log()."""
463
def _post_commit(self):
464
"""See Config.post_commit."""
467
def user_email(self):
468
"""Return just the email component of a username."""
469
return extract_email_address(self.username())
472
"""Return email-style username.
474
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
476
$BRZ_EMAIL can be set to override this, then
477
the concrete policy type is checked, and finally
479
If no username can be found, errors.NoWhoami exception is raised.
481
v = os.environ.get('BRZ_EMAIL')
484
v = v.decode(osutils.get_user_encoding())
486
v = self._get_user_id()
489
return default_email()
491
def ensure_username(self):
492
"""Raise errors.NoWhoami if username is not set.
494
This method relies on the username() function raising the error.
498
def get_alias(self, value):
499
return self._get_alias(value)
501
def _get_alias(self, value):
504
def get_nickname(self):
505
return self._get_nickname()
507
def _get_nickname(self):
510
def get_bzr_remote_path(self):
512
return os.environ['BZR_REMOTE_PATH']
514
path = self.get_user_option("bzr_remote_path")
519
def suppress_warning(self, warning):
520
"""Should the warning be suppressed or emitted.
522
:param warning: The name of the warning being tested.
524
:returns: True if the warning should be suppressed, False otherwise.
526
warnings = self.get_user_option_as_list('suppress_warnings')
527
if warnings is None or warning not in warnings:
532
def get_merge_tools(self):
534
for (oname, value, section, conf_id, parser) in self._get_options():
535
if oname.startswith('bzr.mergetool.'):
536
tool_name = oname[len('bzr.mergetool.'):]
537
tools[tool_name] = self.get_user_option(oname, False)
538
trace.mutter('loaded merge tools: %r' % tools)
541
def find_merge_tool(self, name):
542
# We fake a defaults mechanism here by checking if the given name can
543
# be found in the known_merge_tools if it's not found in the config.
544
# This should be done through the proposed config defaults mechanism
545
# when it becomes available in the future.
546
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
548
or mergetools.known_merge_tools.get(name, None))
552
class _ConfigHooks(hooks.Hooks):
553
"""A dict mapping hook names and a list of callables for configs.
557
"""Create the default hooks.
559
These are all empty initially, because by default nothing should get
562
super(_ConfigHooks, self).__init__('breezy.config', 'ConfigHooks')
563
self.add_hook('load',
564
'Invoked when a config store is loaded.'
565
' The signature is (store).',
567
self.add_hook('save',
568
'Invoked when a config store is saved.'
569
' The signature is (store).',
571
# The hooks for config options
573
'Invoked when a config option is read.'
574
' The signature is (stack, name, value).',
577
'Invoked when a config option is set.'
578
' The signature is (stack, name, value).',
580
self.add_hook('remove',
581
'Invoked when a config option is removed.'
582
' The signature is (stack, name).',
584
ConfigHooks = _ConfigHooks()
587
class _OldConfigHooks(hooks.Hooks):
588
"""A dict mapping hook names and a list of callables for configs.
592
"""Create the default hooks.
594
These are all empty initially, because by default nothing should get
597
super(_OldConfigHooks, self).__init__('breezy.config', 'OldConfigHooks')
598
self.add_hook('load',
599
'Invoked when a config store is loaded.'
600
' The signature is (config).',
602
self.add_hook('save',
603
'Invoked when a config store is saved.'
604
' The signature is (config).',
606
# The hooks for config options
608
'Invoked when a config option is read.'
609
' The signature is (config, name, value).',
612
'Invoked when a config option is set.'
613
' The signature is (config, name, value).',
615
self.add_hook('remove',
616
'Invoked when a config option is removed.'
617
' The signature is (config, name).',
619
OldConfigHooks = _OldConfigHooks()
622
class IniBasedConfig(Config):
623
"""A configuration policy that draws from ini files."""
625
def __init__(self, file_name=None):
626
"""Base class for configuration files using an ini-like syntax.
628
:param file_name: The configuration file path.
630
super(IniBasedConfig, self).__init__()
631
self.file_name = file_name
632
self.file_name = file_name
637
def from_string(cls, str_or_unicode, file_name=None, save=False):
638
"""Create a config object from a string.
640
:param str_or_unicode: A string representing the file content. This will
643
:param file_name: The configuration file path.
645
:param _save: Whether the file should be saved upon creation.
647
conf = cls(file_name=file_name)
648
conf._create_from_string(str_or_unicode, save)
651
def _create_from_string(self, str_or_unicode, save):
652
self._content = BytesIO(str_or_unicode.encode('utf-8'))
653
# Some tests use in-memory configs, some other always need the config
654
# file to exist on disk.
656
self._write_config_file()
658
def _get_parser(self):
659
if self._parser is not None:
661
if self._content is not None:
662
co_input = self._content
663
elif self.file_name is None:
664
raise AssertionError('We have no content to create the config')
666
co_input = self.file_name
668
self._parser = ConfigObj(co_input, encoding='utf-8')
669
except configobj.ConfigObjError as e:
670
raise errors.ParseConfigError(e.errors, e.config.filename)
671
except UnicodeDecodeError:
672
raise errors.ConfigContentError(self.file_name)
673
# Make sure self.reload() will use the right file name
674
self._parser.filename = self.file_name
675
for hook in OldConfigHooks['load']:
680
"""Reload the config file from disk."""
681
if self.file_name is None:
682
raise AssertionError('We need a file name to reload the config')
683
if self._parser is not None:
684
self._parser.reload()
685
for hook in ConfigHooks['load']:
688
def _get_matching_sections(self):
689
"""Return an ordered list of (section_name, extra_path) pairs.
691
If the section contains inherited configuration, extra_path is
692
a string containing the additional path components.
694
section = self._get_section()
695
if section is not None:
696
return [(section, '')]
700
def _get_section(self):
701
"""Override this to define the section used by the config."""
704
def _get_sections(self, name=None):
705
"""Returns an iterator of the sections specified by ``name``.
707
:param name: The section name. If None is supplied, the default
708
configurations are yielded.
710
:return: A tuple (name, section, config_id) for all sections that will
711
be walked by user_get_option() in the 'right' order. The first one
712
is where set_user_option() will update the value.
714
parser = self._get_parser()
716
yield (name, parser[name], self.config_id())
718
# No section name has been given so we fallback to the configobj
719
# itself which holds the variables defined outside of any section.
720
yield (None, parser, self.config_id())
722
def _get_options(self, sections=None):
723
"""Return an ordered list of (name, value, section, config_id) tuples.
725
All options are returned with their associated value and the section
726
they appeared in. ``config_id`` is a unique identifier for the
727
configuration file the option is defined in.
729
:param sections: Default to ``_get_matching_sections`` if not
730
specified. This gives a better control to daughter classes about
731
which sections should be searched. This is a list of (name,
736
parser = self._get_parser()
738
for (section_name, _) in self._get_matching_sections():
740
section = parser[section_name]
742
# This could happen for an empty file for which we define a
743
# DEFAULT section. FIXME: Force callers to provide sections
744
# instead ? -- vila 20100930
746
sections.append((section_name, section))
747
config_id = self.config_id()
748
for (section_name, section) in sections:
749
for (name, value) in section.iteritems():
750
yield (name, parser._quote(value), section_name,
753
def _get_option_policy(self, section, option_name):
754
"""Return the policy for the given (section, option_name) pair."""
757
def _get_change_editor(self):
758
return self.get_user_option('change_editor')
760
def _get_signature_checking(self):
761
"""See Config._get_signature_checking."""
762
policy = self._get_user_option('check_signatures')
764
return signature_policy_from_unicode(policy)
766
def _get_signing_policy(self):
767
"""See Config._get_signing_policy"""
768
policy = self._get_user_option('create_signatures')
770
return signing_policy_from_unicode(policy)
772
def _get_user_id(self):
773
"""Get the user id from the 'email' key in the current section."""
774
return self._get_user_option('email')
776
def _get_user_option(self, option_name):
777
"""See Config._get_user_option."""
778
for (section, extra_path) in self._get_matching_sections():
780
value = self._get_parser().get_value(section, option_name)
783
policy = self._get_option_policy(section, option_name)
784
if policy == POLICY_NONE:
786
elif policy == POLICY_NORECURSE:
787
# norecurse items only apply to the exact path
792
elif policy == POLICY_APPENDPATH:
794
value = urlutils.join(value, extra_path)
797
raise AssertionError('Unexpected config policy %r' % policy)
801
def _gpg_signing_command(self):
802
"""See Config.gpg_signing_command."""
803
return self._get_user_option('gpg_signing_command')
805
def _log_format(self):
806
"""See Config.log_format."""
807
return self._get_user_option('log_format')
809
def _validate_signatures_in_log(self):
810
"""See Config.validate_signatures_in_log."""
811
return self._get_user_option('validate_signatures_in_log')
813
def _acceptable_keys(self):
814
"""See Config.acceptable_keys."""
815
return self._get_user_option('acceptable_keys')
817
def _post_commit(self):
818
"""See Config.post_commit."""
819
return self._get_user_option('post_commit')
821
def _get_alias(self, value):
823
return self._get_parser().get_value("ALIASES",
828
def _get_nickname(self):
829
return self.get_user_option('nickname')
831
def remove_user_option(self, option_name, section_name=None):
832
"""Remove a user option and save the configuration file.
834
:param option_name: The option to be removed.
836
:param section_name: The section the option is defined in, default to
840
parser = self._get_parser()
841
if section_name is None:
844
section = parser[section_name]
846
del section[option_name]
848
raise errors.NoSuchConfigOption(option_name)
849
self._write_config_file()
850
for hook in OldConfigHooks['remove']:
851
hook(self, option_name)
853
def _write_config_file(self):
854
if self.file_name is None:
855
raise AssertionError('We cannot save, self.file_name is None')
856
conf_dir = os.path.dirname(self.file_name)
857
ensure_config_dir_exists(conf_dir)
858
atomic_file = atomicfile.AtomicFile(self.file_name)
859
self._get_parser().write(atomic_file)
862
osutils.copy_ownership_from_path(self.file_name)
863
for hook in OldConfigHooks['save']:
867
class LockableConfig(IniBasedConfig):
868
"""A configuration needing explicit locking for access.
870
If several processes try to write the config file, the accesses need to be
873
Daughter classes should decorate all methods that update a config with the
874
``@needs_write_lock`` decorator (they call, directly or indirectly, the
875
``_write_config_file()`` method. These methods (typically ``set_option()``
876
and variants must reload the config file from disk before calling
877
``_write_config_file()``), this can be achieved by calling the
878
``self.reload()`` method. Note that the lock scope should cover both the
879
reading and the writing of the config file which is why the decorator can't
880
be applied to ``_write_config_file()`` only.
882
This should be enough to implement the following logic:
883
- lock for exclusive write access,
884
- reload the config file from disk,
888
This logic guarantees that a writer can update a value without erasing an
889
update made by another writer.
894
def __init__(self, file_name):
895
super(LockableConfig, self).__init__(file_name=file_name)
896
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
897
# FIXME: It doesn't matter that we don't provide possible_transports
898
# below since this is currently used only for local config files ;
899
# local transports are not shared. But if/when we start using
900
# LockableConfig for other kind of transports, we will need to reuse
901
# whatever connection is already established -- vila 20100929
902
self.transport = transport.get_transport_from_path(self.dir)
903
self._lock = lockdir.LockDir(self.transport, self.lock_name)
905
def _create_from_string(self, unicode_bytes, save):
906
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
908
# We need to handle the saving here (as opposed to IniBasedConfig)
911
self._write_config_file()
914
def lock_write(self, token=None):
915
"""Takes a write lock in the directory containing the config file.
917
If the directory doesn't exist it is created.
919
ensure_config_dir_exists(self.dir)
920
return self._lock.lock_write(token)
925
def break_lock(self):
926
self._lock.break_lock()
929
def remove_user_option(self, option_name, section_name=None):
930
super(LockableConfig, self).remove_user_option(option_name,
933
def _write_config_file(self):
934
if self._lock is None or not self._lock.is_held:
935
# NB: if the following exception is raised it probably means a
936
# missing @needs_write_lock decorator on one of the callers.
937
raise errors.ObjectNotLocked(self)
938
super(LockableConfig, self)._write_config_file()
941
class GlobalConfig(LockableConfig):
942
"""The configuration that should be used for a specific location."""
945
super(GlobalConfig, self).__init__(file_name=config_filename())
951
def from_string(cls, str_or_unicode, save=False):
952
"""Create a config object from a string.
954
:param str_or_unicode: A string representing the file content. This
955
will be utf-8 encoded.
957
:param save: Whether the file should be saved upon creation.
960
conf._create_from_string(str_or_unicode, save)
964
def set_user_option(self, option, value):
965
"""Save option and its value in the configuration."""
966
self._set_option(option, value, 'DEFAULT')
968
def get_aliases(self):
969
"""Return the aliases section."""
970
if 'ALIASES' in self._get_parser():
971
return self._get_parser()['ALIASES']
976
def set_alias(self, alias_name, alias_command):
977
"""Save the alias in the configuration."""
978
self._set_option(alias_name, alias_command, 'ALIASES')
981
def unset_alias(self, alias_name):
982
"""Unset an existing alias."""
984
aliases = self._get_parser().get('ALIASES')
985
if not aliases or alias_name not in aliases:
986
raise errors.NoSuchAlias(alias_name)
987
del aliases[alias_name]
988
self._write_config_file()
990
def _set_option(self, option, value, section):
992
self._get_parser().setdefault(section, {})[option] = value
993
self._write_config_file()
994
for hook in OldConfigHooks['set']:
995
hook(self, option, value)
997
def _get_sections(self, name=None):
998
"""See IniBasedConfig._get_sections()."""
999
parser = self._get_parser()
1000
# We don't give access to options defined outside of any section, we
1001
# used the DEFAULT section by... default.
1002
if name in (None, 'DEFAULT'):
1003
# This could happen for an empty file where the DEFAULT section
1004
# doesn't exist yet. So we force DEFAULT when yielding
1006
if 'DEFAULT' not in parser:
1007
parser['DEFAULT']= {}
1008
yield (name, parser[name], self.config_id())
1011
def remove_user_option(self, option_name, section_name=None):
1012
if section_name is None:
1013
# We need to force the default section.
1014
section_name = 'DEFAULT'
1015
# We need to avoid the LockableConfig implementation or we'll lock
1017
super(LockableConfig, self).remove_user_option(option_name,
1020
def _iter_for_location_by_parts(sections, location):
1021
"""Keep only the sessions matching the specified location.
1023
:param sections: An iterable of section names.
1025
:param location: An url or a local path to match against.
1027
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1028
number of path components in the section name, section is the section
1029
name and extra_path is the difference between location and the section
1032
``location`` will always be a local path and never a 'file://' url but the
1033
section names themselves can be in either form.
1035
location_parts = location.rstrip('/').split('/')
1037
for section in sections:
1038
# location is a local path if possible, so we need to convert 'file://'
1039
# urls in section names to local paths if necessary.
1041
# This also avoids having file:///path be a more exact
1042
# match than '/path'.
1044
# FIXME: This still raises an issue if a user defines both file:///path
1045
# *and* /path. Should we raise an error in this case -- vila 20110505
1047
if section.startswith('file://'):
1048
section_path = urlutils.local_path_from_url(section)
1050
section_path = section
1051
section_parts = section_path.rstrip('/').split('/')
1054
if len(section_parts) > len(location_parts):
1055
# More path components in the section, they can't match
1058
# Rely on zip truncating in length to the length of the shortest
1059
# argument sequence.
1060
for name in zip(location_parts, section_parts):
1061
if not fnmatch.fnmatch(name[0], name[1]):
1066
# build the path difference between the section and the location
1067
extra_path = '/'.join(location_parts[len(section_parts):])
1068
yield section, extra_path, len(section_parts)
1071
class LocationConfig(LockableConfig):
1072
"""A configuration object that gives the policy for a location."""
1074
def __init__(self, location):
1075
super(LocationConfig, self).__init__(
1076
file_name=locations_config_filename())
1077
# local file locations are looked up by local path, rather than
1078
# by file url. This is because the config file is a user
1079
# file, and we would rather not expose the user to file urls.
1080
if location.startswith('file://'):
1081
location = urlutils.local_path_from_url(location)
1082
self.location = location
1084
def config_id(self):
1088
def from_string(cls, str_or_unicode, location, save=False):
1089
"""Create a config object from a string.
1091
:param str_or_unicode: A string representing the file content. This will
1094
:param location: The location url to filter the configuration.
1096
:param save: Whether the file should be saved upon creation.
1098
conf = cls(location)
1099
conf._create_from_string(str_or_unicode, save)
1102
def _get_matching_sections(self):
1103
"""Return an ordered list of section names matching this location."""
1104
# put the longest (aka more specific) locations first
1106
_iter_for_location_by_parts(self._get_parser(), self.location),
1107
key=lambda match: (match[2], match[0]),
1109
for (section, extra_path, length) in matches:
1110
yield section, extra_path
1111
# should we stop looking for parent configs here?
1113
if self._get_parser()[section].as_bool('ignore_parents'):
1118
def _get_sections(self, name=None):
1119
"""See IniBasedConfig._get_sections()."""
1120
# We ignore the name here as the only sections handled are named with
1121
# the location path and we don't expose embedded sections either.
1122
parser = self._get_parser()
1123
for name, extra_path in self._get_matching_sections():
1124
yield (name, parser[name], self.config_id())
1126
def _get_option_policy(self, section, option_name):
1127
"""Return the policy for the given (section, option_name) pair."""
1128
# check for the old 'recurse=False' flag
1130
recurse = self._get_parser()[section].as_bool('recurse')
1134
return POLICY_NORECURSE
1136
policy_key = option_name + ':policy'
1138
policy_name = self._get_parser()[section][policy_key]
1142
return _policy_value[policy_name]
1144
def _set_option_policy(self, section, option_name, option_policy):
1145
"""Set the policy for the given option name in the given section."""
1146
policy_key = option_name + ':policy'
1147
policy_name = _policy_name[option_policy]
1148
if policy_name is not None:
1149
self._get_parser()[section][policy_key] = policy_name
1151
if policy_key in self._get_parser()[section]:
1152
del self._get_parser()[section][policy_key]
1155
def set_user_option(self, option, value, store=STORE_LOCATION):
1156
"""Save option and its value in the configuration."""
1157
if store not in [STORE_LOCATION,
1158
STORE_LOCATION_NORECURSE,
1159
STORE_LOCATION_APPENDPATH]:
1160
raise ValueError('bad storage policy %r for %r' %
1163
location = self.location
1164
if location.endswith('/'):
1165
location = location[:-1]
1166
parser = self._get_parser()
1167
if not location in parser and not location + '/' in parser:
1168
parser[location] = {}
1169
elif location + '/' in parser:
1170
location = location + '/'
1171
parser[location][option]=value
1172
# the allowed values of store match the config policies
1173
self._set_option_policy(location, option, store)
1174
self._write_config_file()
1175
for hook in OldConfigHooks['set']:
1176
hook(self, option, value)
1179
class BranchConfig(Config):
1180
"""A configuration object giving the policy for a branch."""
1182
def __init__(self, branch):
1183
super(BranchConfig, self).__init__()
1184
self._location_config = None
1185
self._branch_data_config = None
1186
self._global_config = None
1187
self.branch = branch
1188
self.option_sources = (self._get_location_config,
1189
self._get_branch_data_config,
1190
self._get_global_config)
1192
def config_id(self):
1195
def _get_branch_data_config(self):
1196
if self._branch_data_config is None:
1197
self._branch_data_config = TreeConfig(self.branch)
1198
self._branch_data_config.config_id = self.config_id
1199
return self._branch_data_config
1201
def _get_location_config(self):
1202
if self._location_config is None:
1203
self._location_config = LocationConfig(self.branch.base)
1204
return self._location_config
1206
def _get_global_config(self):
1207
if self._global_config is None:
1208
self._global_config = GlobalConfig()
1209
return self._global_config
1211
def _get_best_value(self, option_name):
1212
"""This returns a user option from local, tree or global config.
1214
They are tried in that order. Use get_safe_value if trusted values
1217
for source in self.option_sources:
1218
value = getattr(source(), option_name)()
1219
if value is not None:
1223
def _get_safe_value(self, option_name):
1224
"""This variant of get_best_value never returns untrusted values.
1226
It does not return values from the branch data, because the branch may
1227
not be controlled by the user.
1229
We may wish to allow locations.conf to control whether branches are
1230
trusted in the future.
1232
for source in (self._get_location_config, self._get_global_config):
1233
value = getattr(source(), option_name)()
1234
if value is not None:
1238
def _get_user_id(self):
1239
"""Return the full user id for the branch.
1241
e.g. "John Hacker <jhacker@example.com>"
1242
This is looked up in the email controlfile for the branch.
1244
return self._get_best_value('_get_user_id')
1246
def _get_change_editor(self):
1247
return self._get_best_value('_get_change_editor')
1249
def _get_signature_checking(self):
1250
"""See Config._get_signature_checking."""
1251
return self._get_best_value('_get_signature_checking')
1253
def _get_signing_policy(self):
1254
"""See Config._get_signing_policy."""
1255
return self._get_best_value('_get_signing_policy')
1257
def _get_user_option(self, option_name):
1258
"""See Config._get_user_option."""
1259
for source in self.option_sources:
1260
value = source()._get_user_option(option_name)
1261
if value is not None:
1265
def _get_sections(self, name=None):
1266
"""See IniBasedConfig.get_sections()."""
1267
for source in self.option_sources:
1268
for section in source()._get_sections(name):
1271
def _get_options(self, sections=None):
1273
# First the locations options
1274
for option in self._get_location_config()._get_options():
1276
# Then the branch options
1277
branch_config = self._get_branch_data_config()
1278
if sections is None:
1279
sections = [('DEFAULT', branch_config._get_parser())]
1280
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1281
# Config itself has no notion of sections :( -- vila 20101001
1282
config_id = self.config_id()
1283
for (section_name, section) in sections:
1284
for (name, value) in section.iteritems():
1285
yield (name, value, section_name,
1286
config_id, branch_config._get_parser())
1287
# Then the global options
1288
for option in self._get_global_config()._get_options():
1291
def set_user_option(self, name, value, store=STORE_BRANCH,
1293
if store == STORE_BRANCH:
1294
self._get_branch_data_config().set_option(value, name)
1295
elif store == STORE_GLOBAL:
1296
self._get_global_config().set_user_option(name, value)
1298
self._get_location_config().set_user_option(name, value, store)
1301
if store in (STORE_GLOBAL, STORE_BRANCH):
1302
mask_value = self._get_location_config().get_user_option(name)
1303
if mask_value is not None:
1304
trace.warning('Value "%s" is masked by "%s" from'
1305
' locations.conf', value, mask_value)
1307
if store == STORE_GLOBAL:
1308
branch_config = self._get_branch_data_config()
1309
mask_value = branch_config.get_user_option(name)
1310
if mask_value is not None:
1311
trace.warning('Value "%s" is masked by "%s" from'
1312
' branch.conf', value, mask_value)
1314
def remove_user_option(self, option_name, section_name=None):
1315
self._get_branch_data_config().remove_option(option_name, section_name)
1317
def _gpg_signing_command(self):
1318
"""See Config.gpg_signing_command."""
1319
return self._get_safe_value('_gpg_signing_command')
1321
def _post_commit(self):
1322
"""See Config.post_commit."""
1323
return self._get_safe_value('_post_commit')
1325
def _get_nickname(self):
1326
value = self._get_explicit_nickname()
1327
if value is not None:
1329
if self.branch.name:
1330
return self.branch.name
1331
return urlutils.unescape(self.branch.base.split('/')[-2])
1333
def has_explicit_nickname(self):
1334
"""Return true if a nickname has been explicitly assigned."""
1335
return self._get_explicit_nickname() is not None
1337
def _get_explicit_nickname(self):
1338
return self._get_best_value('_get_nickname')
1340
def _log_format(self):
1341
"""See Config.log_format."""
1342
return self._get_best_value('_log_format')
1344
def _validate_signatures_in_log(self):
1345
"""See Config.validate_signatures_in_log."""
1346
return self._get_best_value('_validate_signatures_in_log')
1348
def _acceptable_keys(self):
1349
"""See Config.acceptable_keys."""
1350
return self._get_best_value('_acceptable_keys')
1353
def ensure_config_dir_exists(path=None):
1354
"""Make sure a configuration directory exists.
1355
This makes sure that the directory exists.
1356
On windows, since configuration directories are 2 levels deep,
1357
it makes sure both the directory and the parent directory exists.
1361
if not os.path.isdir(path):
1362
if sys.platform == 'win32':
1363
parent_dir = os.path.dirname(path)
1364
if not os.path.isdir(parent_dir):
1365
trace.mutter('creating config parent directory: %r', parent_dir)
1366
os.mkdir(parent_dir)
1367
trace.mutter('creating config directory: %r', path)
1369
osutils.copy_ownership_from_path(path)
1372
def bazaar_config_dir():
1373
"""Return per-user configuration directory as unicode string
1375
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1376
and Linux. On Mac OS X and Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1377
that will be used instead.
1379
TODO: Global option --config-dir to override this.
1381
base = osutils.path_from_environ('BZR_HOME')
1382
if sys.platform == 'win32':
1384
base = win32utils.get_appdata_location()
1386
base = win32utils.get_home_location()
1387
# GZ 2012-02-01: Really the two level subdirs only make sense inside
1388
# APPDATA, but hard to move. See bug 348640 for more.
1389
return osutils.pathjoin(base, 'bazaar', '2.0')
1391
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1393
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1394
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1395
if osutils.isdir(xdg_dir):
1397
"Using configuration in XDG directory %s." % xdg_dir)
1399
base = osutils._get_home_dir()
1400
return osutils.pathjoin(base, ".bazaar")
1404
"""Return per-user configuration directory as unicode string
1406
By default this is %APPDATA%/breezy on Windows, $XDG_CONFIG_HOME/breezy on
1407
Mac OS X and Linux. If the breezy config directory doesn't exist but
1408
the bazaar one (see bazaar_config_dir()) does, use that instead.
1410
TODO: Global option --config-dir to override this.
1412
base = osutils.path_from_environ('BRZ_HOME')
1413
if sys.platform == 'win32':
1415
base = win32utils.get_appdata_location()
1417
base = win32utils.get_home_location()
1418
# GZ 2012-02-01: Really the two level subdirs only make sense inside
1419
# APPDATA, but hard to move. See bug 348640 for more.
1421
base = osutils.path_from_environ('XDG_CONFIG_HOME')
1423
base = osutils.pathjoin(osutils._get_home_dir(), ".config")
1424
breezy_dir = osutils.pathjoin(base, 'breezy')
1425
if osutils.isdir(breezy_dir):
1427
# If the breezy directory doesn't exist, but the bazaar one does, use that:
1428
bazaar_dir = bazaar_config_dir()
1429
if osutils.isdir(bazaar_dir):
1431
"Using Bazaar configuration directory (%s)", bazaar_dir)
1436
def config_filename():
1437
"""Return per-user configuration ini file filename."""
1438
return osutils.pathjoin(config_dir(), 'bazaar.conf')
1441
def locations_config_filename():
1442
"""Return per-user configuration ini file filename."""
1443
return osutils.pathjoin(config_dir(), 'locations.conf')
1446
def authentication_config_filename():
1447
"""Return per-user authentication ini file filename."""
1448
return osutils.pathjoin(config_dir(), 'authentication.conf')
1451
def user_ignore_config_filename():
1452
"""Return the user default ignore filename"""
1453
return osutils.pathjoin(config_dir(), 'ignore')
1457
"""Return the directory name to store crash files.
1459
This doesn't implicitly create it.
1461
On Windows it's in the config directory; elsewhere it's /var/crash
1462
which may be monitored by apport. It can be overridden by
1465
if sys.platform == 'win32':
1466
return osutils.pathjoin(config_dir(), 'Crash')
1468
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1470
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1473
def xdg_cache_dir():
1474
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1475
# Possibly this should be different on Windows?
1476
e = os.environ.get('XDG_CACHE_HOME', None)
1480
return os.path.expanduser('~/.cache')
1483
def _get_default_mail_domain(mailname_file='/etc/mailname'):
1484
"""If possible, return the assumed default email domain.
1486
:returns: string mail domain, or None.
1488
if sys.platform == 'win32':
1489
# No implementation yet; patches welcome
1492
f = open(mailname_file)
1493
except (IOError, OSError) as e:
1496
domain = f.readline().strip()
1502
def default_email():
1503
v = os.environ.get('BRZ_EMAIL')
1506
v = v.decode(osutils.get_user_encoding())
1508
v = os.environ.get('EMAIL')
1511
v = v.decode(osutils.get_user_encoding())
1513
name, email = _auto_user_id()
1515
return u'%s <%s>' % (name, email)
1518
raise errors.NoWhoami()
1521
def _auto_user_id():
1522
"""Calculate automatic user identification.
1524
:returns: (realname, email), either of which may be None if they can't be
1527
Only used when none is set in the environment or the id file.
1529
This only returns an email address if we can be fairly sure the
1530
address is reasonable, ie if /etc/mailname is set on unix.
1532
This doesn't use the FQDN as the default domain because that may be
1533
slow, and it doesn't use the hostname alone because that's not normally
1534
a reasonable address.
1536
if sys.platform == 'win32':
1537
# No implementation to reliably determine Windows default mail
1538
# address; please add one.
1541
default_mail_domain = _get_default_mail_domain()
1542
if not default_mail_domain:
1548
w = pwd.getpwuid(uid)
1550
trace.mutter('no passwd entry for uid %d?' % uid)
1553
# we try utf-8 first, because on many variants (like Linux),
1554
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1555
# false positives. (many users will have their user encoding set to
1556
# latin-1, which cannot raise UnicodeError.)
1558
gecos = w.pw_gecos.decode('utf-8')
1560
except UnicodeError:
1562
encoding = osutils.get_user_encoding()
1563
gecos = w.pw_gecos.decode(encoding)
1564
except UnicodeError as e:
1565
trace.mutter("cannot decode passwd entry %s" % w)
1568
username = w.pw_name.decode(encoding)
1569
except UnicodeError as e:
1570
trace.mutter("cannot decode passwd entry %s" % w)
1573
comma = gecos.find(',')
1577
realname = gecos[:comma]
1579
return realname, (username + '@' + default_mail_domain)
1582
def parse_username(username):
1583
"""Parse e-mail username and return a (name, address) tuple."""
1584
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1586
return (username, '')
1588
return (match.group(1), match.group(2))
1591
def extract_email_address(e):
1592
"""Return just the address part of an email string.
1594
That is just the user@domain part, nothing else.
1595
This part is required to contain only ascii characters.
1596
If it can't be extracted, raises an error.
1598
>>> extract_email_address('Jane Tester <jane@test.com>')
1601
name, email = parse_username(e)
1603
raise errors.NoEmailInUsername(e)
1607
class TreeConfig(IniBasedConfig):
1608
"""Branch configuration data associated with its contents, not location"""
1610
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1612
def __init__(self, branch):
1613
self._config = branch._get_config()
1614
self.branch = branch
1616
def _get_parser(self, file=None):
1617
if file is not None:
1618
return IniBasedConfig._get_parser(file)
1619
return self._config._get_configobj()
1621
def get_option(self, name, section=None, default=None):
1622
self.branch.lock_read()
1624
return self._config.get_option(name, section, default)
1626
self.branch.unlock()
1628
def set_option(self, value, name, section=None):
1629
"""Set a per-branch configuration option"""
1630
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1631
# higher levels providing the right lock -- vila 20101004
1632
self.branch.lock_write()
1634
self._config.set_option(value, name, section)
1636
self.branch.unlock()
1638
def remove_option(self, option_name, section_name=None):
1639
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1640
# higher levels providing the right lock -- vila 20101004
1641
self.branch.lock_write()
1643
self._config.remove_option(option_name, section_name)
1645
self.branch.unlock()
1648
_authentication_config_permission_errors = set()
1651
class AuthenticationConfig(object):
1652
"""The authentication configuration file based on a ini file.
1654
Implements the authentication.conf file described in
1655
doc/developers/authentication-ring.txt.
1658
def __init__(self, _file=None):
1659
self._config = None # The ConfigObj
1661
self._filename = authentication_config_filename()
1662
self._input = self._filename = authentication_config_filename()
1663
self._check_permissions()
1665
# Tests can provide a string as _file
1666
self._filename = None
1669
def _get_config(self):
1670
if self._config is not None:
1673
# FIXME: Should we validate something here ? Includes: empty
1674
# sections are useless, at least one of
1675
# user/password/password_encoding should be defined, etc.
1677
# Note: the encoding below declares that the file itself is utf-8
1678
# encoded, but the values in the ConfigObj are always Unicode.
1679
self._config = ConfigObj(self._input, encoding='utf-8')
1680
except configobj.ConfigObjError as e:
1681
raise errors.ParseConfigError(e.errors, e.config.filename)
1682
except UnicodeError:
1683
raise errors.ConfigContentError(self._filename)
1686
def _check_permissions(self):
1687
"""Check permission of auth file are user read/write able only."""
1689
st = os.stat(self._filename)
1690
except OSError as e:
1691
if e.errno != errno.ENOENT:
1692
trace.mutter('Unable to stat %r: %r', self._filename, e)
1694
mode = stat.S_IMODE(st.st_mode)
1695
if ((stat.S_IXOTH | stat.S_IWOTH | stat.S_IROTH | stat.S_IXGRP |
1696
stat.S_IWGRP | stat.S_IRGRP ) & mode):
1698
if (not self._filename in _authentication_config_permission_errors
1699
and not GlobalConfig().suppress_warning(
1700
'insecure_permissions')):
1701
trace.warning("The file '%s' has insecure "
1702
"file permissions. Saved passwords may be accessible "
1703
"by other users.", self._filename)
1704
_authentication_config_permission_errors.add(self._filename)
1707
"""Save the config file, only tests should use it for now."""
1708
conf_dir = os.path.dirname(self._filename)
1709
ensure_config_dir_exists(conf_dir)
1710
fd = os.open(self._filename, os.O_RDWR|os.O_CREAT, 0o600)
1712
f = os.fdopen(fd, 'wb')
1713
self._get_config().write(f)
1717
def _set_option(self, section_name, option_name, value):
1718
"""Set an authentication configuration option"""
1719
conf = self._get_config()
1720
section = conf.get(section_name)
1723
section = conf[section]
1724
section[option_name] = value
1727
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1729
"""Returns the matching credentials from authentication.conf file.
1731
:param scheme: protocol
1733
:param host: the server address
1735
:param port: the associated port (optional)
1737
:param user: login (optional)
1739
:param path: the absolute path on the server (optional)
1741
:param realm: the http authentication realm (optional)
1743
:return: A dict containing the matching credentials or None.
1745
- name: the section name of the credentials in the
1746
authentication.conf file,
1747
- user: can't be different from the provided user if any,
1748
- scheme: the server protocol,
1749
- host: the server address,
1750
- port: the server port (can be None),
1751
- path: the absolute server path (can be None),
1752
- realm: the http specific authentication realm (can be None),
1753
- password: the decoded password, could be None if the credential
1754
defines only the user
1755
- verify_certificates: https specific, True if the server
1756
certificate should be verified, False otherwise.
1759
for auth_def_name, auth_def in self._get_config().iteritems():
1760
if not isinstance(auth_def, configobj.Section):
1761
raise ValueError("%s defined outside a section" % auth_def_name)
1763
a_scheme, a_host, a_user, a_path = map(
1764
auth_def.get, ['scheme', 'host', 'user', 'path'])
1767
a_port = auth_def.as_int('port')
1771
raise ValueError("'port' not numeric in %s" % auth_def_name)
1773
a_verify_certificates = auth_def.as_bool('verify_certificates')
1775
a_verify_certificates = True
1778
"'verify_certificates' not boolean in %s" % auth_def_name)
1781
if a_scheme is not None and scheme != a_scheme:
1783
if a_host is not None:
1784
if not (host == a_host
1785
or (a_host.startswith('.') and host.endswith(a_host))):
1787
if a_port is not None and port != a_port:
1789
if (a_path is not None and path is not None
1790
and not path.startswith(a_path)):
1792
if (a_user is not None and user is not None
1793
and a_user != user):
1794
# Never contradict the caller about the user to be used
1799
# Prepare a credentials dictionary with additional keys
1800
# for the credential providers
1801
credentials = dict(name=auth_def_name,
1808
password=auth_def.get('password', None),
1809
verify_certificates=a_verify_certificates)
1810
# Decode the password in the credentials (or get one)
1811
self.decode_password(credentials,
1812
auth_def.get('password_encoding', None))
1813
if 'auth' in debug.debug_flags:
1814
trace.mutter("Using authentication section: %r", auth_def_name)
1817
if credentials is None:
1818
# No credentials were found in authentication.conf, try the fallback
1819
# credentials stores.
1820
credentials = credential_store_registry.get_fallback_credentials(
1821
scheme, host, port, user, path, realm)
1825
def set_credentials(self, name, host, user, scheme=None, password=None,
1826
port=None, path=None, verify_certificates=None,
1828
"""Set authentication credentials for a host.
1830
Any existing credentials with matching scheme, host, port and path
1831
will be deleted, regardless of name.
1833
:param name: An arbitrary name to describe this set of credentials.
1834
:param host: Name of the host that accepts these credentials.
1835
:param user: The username portion of these credentials.
1836
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1838
:param password: Password portion of these credentials.
1839
:param port: The IP port on the host that these credentials apply to.
1840
:param path: A filesystem path on the host that these credentials
1842
:param verify_certificates: On https, verify server certificates if
1844
:param realm: The http authentication realm (optional).
1846
values = {'host': host, 'user': user}
1847
if password is not None:
1848
values['password'] = password
1849
if scheme is not None:
1850
values['scheme'] = scheme
1851
if port is not None:
1852
values['port'] = '%d' % port
1853
if path is not None:
1854
values['path'] = path
1855
if verify_certificates is not None:
1856
values['verify_certificates'] = str(verify_certificates)
1857
if realm is not None:
1858
values['realm'] = realm
1859
config = self._get_config()
1861
for section, existing_values in config.iteritems():
1862
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1863
if existing_values.get(key) != values.get(key):
1867
config.update({name: values})
1870
def get_user(self, scheme, host, port=None, realm=None, path=None,
1871
prompt=None, ask=False, default=None):
1872
"""Get a user from authentication file.
1874
:param scheme: protocol
1876
:param host: the server address
1878
:param port: the associated port (optional)
1880
:param realm: the realm sent by the server (optional)
1882
:param path: the absolute path on the server (optional)
1884
:param ask: Ask the user if there is no explicitly configured username
1887
:param default: The username returned if none is defined (optional).
1889
:return: The found user.
1891
credentials = self.get_credentials(scheme, host, port, user=None,
1892
path=path, realm=realm)
1893
if credentials is not None:
1894
user = credentials['user']
1900
# Create a default prompt suitable for most cases
1901
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1902
# Special handling for optional fields in the prompt
1903
if port is not None:
1904
prompt_host = '%s:%d' % (host, port)
1907
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1912
def get_password(self, scheme, host, user, port=None,
1913
realm=None, path=None, prompt=None):
1914
"""Get a password from authentication file or prompt the user for one.
1916
:param scheme: protocol
1918
:param host: the server address
1920
:param port: the associated port (optional)
1924
:param realm: the realm sent by the server (optional)
1926
:param path: the absolute path on the server (optional)
1928
:return: The found password or the one entered by the user.
1930
credentials = self.get_credentials(scheme, host, port, user, path,
1932
if credentials is not None:
1933
password = credentials['password']
1934
if password is not None and scheme is 'ssh':
1935
trace.warning('password ignored in section [%s],'
1936
' use an ssh agent instead'
1937
% credentials['name'])
1941
# Prompt user only if we could't find a password
1942
if password is None:
1944
# Create a default prompt suitable for most cases
1945
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
1946
# Special handling for optional fields in the prompt
1947
if port is not None:
1948
prompt_host = '%s:%d' % (host, port)
1951
password = ui.ui_factory.get_password(prompt,
1952
host=prompt_host, user=user)
1955
def decode_password(self, credentials, encoding):
1957
cs = credential_store_registry.get_credential_store(encoding)
1959
raise ValueError('%r is not a known password_encoding' % encoding)
1960
credentials['password'] = cs.decode_password(credentials)
1964
class CredentialStoreRegistry(registry.Registry):
1965
"""A class that registers credential stores.
1967
A credential store provides access to credentials via the password_encoding
1968
field in authentication.conf sections.
1970
Except for stores provided by brz itself, most stores are expected to be
1971
provided by plugins that will therefore use
1972
register_lazy(password_encoding, module_name, member_name, help=help,
1973
fallback=fallback) to install themselves.
1975
A fallback credential store is one that is queried if no credentials can be
1976
found via authentication.conf.
1979
def get_credential_store(self, encoding=None):
1980
cs = self.get(encoding)
1985
def is_fallback(self, name):
1986
"""Check if the named credentials store should be used as fallback."""
1987
return self.get_info(name)
1989
def get_fallback_credentials(self, scheme, host, port=None, user=None,
1990
path=None, realm=None):
1991
"""Request credentials from all fallback credentials stores.
1993
The first credentials store that can provide credentials wins.
1996
for name in self.keys():
1997
if not self.is_fallback(name):
1999
cs = self.get_credential_store(name)
2000
credentials = cs.get_credentials(scheme, host, port, user,
2002
if credentials is not None:
2003
# We found some credentials
2007
def register(self, key, obj, help=None, override_existing=False,
2009
"""Register a new object to a name.
2011
:param key: This is the key to use to request the object later.
2012
:param obj: The object to register.
2013
:param help: Help text for this entry. This may be a string or
2014
a callable. If it is a callable, it should take two
2015
parameters (registry, key): this registry and the key that
2016
the help was registered under.
2017
:param override_existing: Raise KeyErorr if False and something has
2018
already been registered for that key. If True, ignore if there
2019
is an existing key (always register the new value).
2020
:param fallback: Whether this credential store should be
2023
return super(CredentialStoreRegistry,
2024
self).register(key, obj, help, info=fallback,
2025
override_existing=override_existing)
2027
def register_lazy(self, key, module_name, member_name,
2028
help=None, override_existing=False,
2030
"""Register a new credential store to be loaded on request.
2032
:param module_name: The python path to the module. Such as 'os.path'.
2033
:param member_name: The member of the module to return. If empty or
2034
None, get() will return the module itself.
2035
:param help: Help text for this entry. This may be a string or
2037
:param override_existing: If True, replace the existing object
2038
with the new one. If False, if there is already something
2039
registered with the same key, raise a KeyError
2040
:param fallback: Whether this credential store should be
2043
return super(CredentialStoreRegistry, self).register_lazy(
2044
key, module_name, member_name, help,
2045
info=fallback, override_existing=override_existing)
2048
credential_store_registry = CredentialStoreRegistry()
2051
class CredentialStore(object):
2052
"""An abstract class to implement storage for credentials"""
2054
def decode_password(self, credentials):
2055
"""Returns a clear text password for the provided credentials."""
2056
raise NotImplementedError(self.decode_password)
2058
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2060
"""Return the matching credentials from this credential store.
2062
This method is only called on fallback credential stores.
2064
raise NotImplementedError(self.get_credentials)
2068
class PlainTextCredentialStore(CredentialStore):
2069
__doc__ = """Plain text credential store for the authentication.conf file"""
2071
def decode_password(self, credentials):
2072
"""See CredentialStore.decode_password."""
2073
return credentials['password']
2076
credential_store_registry.register('plain', PlainTextCredentialStore,
2077
help=PlainTextCredentialStore.__doc__)
2078
credential_store_registry.default_key = 'plain'
2081
class Base64CredentialStore(CredentialStore):
2082
__doc__ = """Base64 credential store for the authentication.conf file"""
2084
def decode_password(self, credentials):
2085
"""See CredentialStore.decode_password."""
2086
# GZ 2012-07-28: Will raise binascii.Error if password is not base64,
2087
# should probably propogate as something more useful.
2088
return base64.decodestring(credentials['password'])
2090
credential_store_registry.register('base64', Base64CredentialStore,
2091
help=Base64CredentialStore.__doc__)
2094
class BzrDirConfig(object):
2096
def __init__(self, bzrdir):
2097
self._bzrdir = bzrdir
2098
self._config = bzrdir._get_config()
2100
def set_default_stack_on(self, value):
2101
"""Set the default stacking location.
2103
It may be set to a location, or None.
2105
This policy affects all branches contained by this control dir, except
2106
for those under repositories.
2108
if self._config is None:
2109
raise errors.BzrError("Cannot set configuration in %s"
2112
self._config.set_option('', 'default_stack_on')
2114
self._config.set_option(value, 'default_stack_on')
2116
def get_default_stack_on(self):
2117
"""Return the default stacking location.
2119
This will either be a location, or None.
2121
This policy affects all branches contained by this control dir, except
2122
for those under repositories.
2124
if self._config is None:
2126
value = self._config.get_option('default_stack_on')
2132
class TransportConfig(object):
2133
"""A Config that reads/writes a config file on a Transport.
2135
It is a low-level object that considers config data to be name/value pairs
2136
that may be associated with a section. Assigning meaning to these values
2137
is done at higher levels like TreeConfig.
2140
def __init__(self, transport, filename):
2141
self._transport = transport
2142
self._filename = filename
2144
def get_option(self, name, section=None, default=None):
2145
"""Return the value associated with a named option.
2147
:param name: The name of the value
2148
:param section: The section the option is in (if any)
2149
:param default: The value to return if the value is not set
2150
:return: The value or default value
2152
configobj = self._get_configobj()
2154
section_obj = configobj
2157
section_obj = configobj[section]
2160
value = section_obj.get(name, default)
2161
for hook in OldConfigHooks['get']:
2162
hook(self, name, value)
2165
def set_option(self, value, name, section=None):
2166
"""Set the value associated with a named option.
2168
:param value: The value to set
2169
:param name: The name of the value to set
2170
:param section: The section the option is in (if any)
2172
configobj = self._get_configobj()
2174
configobj[name] = value
2176
configobj.setdefault(section, {})[name] = value
2177
for hook in OldConfigHooks['set']:
2178
hook(self, name, value)
2179
self._set_configobj(configobj)
2181
def remove_option(self, option_name, section_name=None):
2182
configobj = self._get_configobj()
2183
if section_name is None:
2184
del configobj[option_name]
2186
del configobj[section_name][option_name]
2187
for hook in OldConfigHooks['remove']:
2188
hook(self, option_name)
2189
self._set_configobj(configobj)
2191
def _get_config_file(self):
2193
f = BytesIO(self._transport.get_bytes(self._filename))
2194
for hook in OldConfigHooks['load']:
2197
except errors.NoSuchFile:
2199
except errors.PermissionDenied as e:
2200
trace.warning("Permission denied while trying to open "
2201
"configuration file %s.", urlutils.unescape_for_display(
2202
urlutils.join(self._transport.base, self._filename), "utf-8"))
2205
def _external_url(self):
2206
return urlutils.join(self._transport.external_url(), self._filename)
2208
def _get_configobj(self):
2209
f = self._get_config_file()
2212
conf = ConfigObj(f, encoding='utf-8')
2213
except configobj.ConfigObjError as e:
2214
raise errors.ParseConfigError(e.errors, self._external_url())
2215
except UnicodeDecodeError:
2216
raise errors.ConfigContentError(self._external_url())
2221
def _set_configobj(self, configobj):
2222
out_file = BytesIO()
2223
configobj.write(out_file)
2225
self._transport.put_file(self._filename, out_file)
2226
for hook in OldConfigHooks['save']:
2230
class Option(object):
2231
"""An option definition.
2233
The option *values* are stored in config files and found in sections.
2235
Here we define various properties about the option itself, its default
2236
value, how to convert it from stores, what to do when invalid values are
2237
encoutered, in which config files it can be stored.
2240
def __init__(self, name, override_from_env=None,
2241
default=None, default_from_env=None,
2242
help=None, from_unicode=None, invalid=None, unquote=True):
2243
"""Build an option definition.
2245
:param name: the name used to refer to the option.
2247
:param override_from_env: A list of environment variables which can
2248
provide override any configuration setting.
2250
:param default: the default value to use when none exist in the config
2251
stores. This is either a string that ``from_unicode`` will convert
2252
into the proper type, a callable returning a unicode string so that
2253
``from_unicode`` can be used on the return value, or a python
2254
object that can be stringified (so only the empty list is supported
2257
:param default_from_env: A list of environment variables which can
2258
provide a default value. 'default' will be used only if none of the
2259
variables specified here are set in the environment.
2261
:param help: a doc string to explain the option to the user.
2263
:param from_unicode: a callable to convert the unicode string
2264
representing the option value in a store or its default value.
2266
:param invalid: the action to be taken when an invalid value is
2267
encountered in a store. This is called only when from_unicode is
2268
invoked to convert a string and returns None or raise ValueError or
2269
TypeError. Accepted values are: None (ignore invalid values),
2270
'warning' (emit a warning), 'error' (emit an error message and
2273
:param unquote: should the unicode value be unquoted before conversion.
2274
This should be used only when the store providing the values cannot
2275
safely unquote them (see http://pad.lv/906897). It is provided so
2276
daughter classes can handle the quoting themselves.
2278
if override_from_env is None:
2279
override_from_env = []
2280
if default_from_env is None:
2281
default_from_env = []
2283
self.override_from_env = override_from_env
2284
# Convert the default value to a unicode string so all values are
2285
# strings internally before conversion (via from_unicode) is attempted.
2288
elif isinstance(default, list):
2289
# Only the empty list is supported
2291
raise AssertionError(
2292
'Only empty lists are supported as default values')
2294
elif isinstance(default, (binary_type, text_type, bool, int, float)):
2295
# Rely on python to convert strings, booleans and integers
2296
self.default = u'%s' % (default,)
2297
elif callable(default):
2298
self.default = default
2300
# other python objects are not expected
2301
raise AssertionError('%r is not supported as a default value'
2303
self.default_from_env = default_from_env
2305
self.from_unicode = from_unicode
2306
self.unquote = unquote
2307
if invalid and invalid not in ('warning', 'error'):
2308
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2309
self.invalid = invalid
2315
def convert_from_unicode(self, store, unicode_value):
2316
if self.unquote and store is not None and unicode_value is not None:
2317
unicode_value = store.unquote(unicode_value)
2318
if self.from_unicode is None or unicode_value is None:
2319
# Don't convert or nothing to convert
2320
return unicode_value
2322
converted = self.from_unicode(unicode_value)
2323
except (ValueError, TypeError):
2324
# Invalid values are ignored
2326
if converted is None and self.invalid is not None:
2327
# The conversion failed
2328
if self.invalid == 'warning':
2329
trace.warning('Value "%s" is not valid for "%s"',
2330
unicode_value, self.name)
2331
elif self.invalid == 'error':
2332
raise errors.ConfigOptionValueError(self.name, unicode_value)
2335
def get_override(self):
2337
for var in self.override_from_env:
2339
# If the env variable is defined, its value takes precedence
2340
value = os.environ[var].decode(osutils.get_user_encoding())
2346
def get_default(self):
2348
for var in self.default_from_env:
2350
# If the env variable is defined, its value is the default one
2351
value = os.environ[var]
2353
value = value.decode(osutils.get_user_encoding())
2358
# Otherwise, fallback to the value defined at registration
2359
if callable(self.default):
2360
value = self.default()
2361
if not isinstance(value, text_type):
2362
raise AssertionError(
2363
"Callable default value for '%s' should be unicode"
2366
value = self.default
2369
def get_help_topic(self):
2372
def get_help_text(self, additional_see_also=None, plain=True):
2374
from breezy import help_topics
2375
result += help_topics._format_see_also(additional_see_also)
2377
result = help_topics.help_as_plain_text(result)
2381
# Predefined converters to get proper values from store
2383
def bool_from_store(unicode_str):
2384
return ui.bool_from_string(unicode_str)
2387
def int_from_store(unicode_str):
2388
return int(unicode_str)
2391
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2393
def int_SI_from_store(unicode_str):
2394
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2396
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2397
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2400
:return Integer, expanded to its base-10 value if a proper SI unit is
2401
found, None otherwise.
2403
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2404
p = re.compile(regexp, re.IGNORECASE)
2405
m = p.match(unicode_str)
2408
val, _, unit = m.groups()
2412
coeff = _unit_suffixes[unit.upper()]
2414
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2419
def float_from_store(unicode_str):
2420
return float(unicode_str)
2423
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2425
_list_converter_config = configobj.ConfigObj(
2426
{}, encoding='utf-8', list_values=True, interpolation=False)
2429
class ListOption(Option):
2431
def __init__(self, name, default=None, default_from_env=None,
2432
help=None, invalid=None):
2433
"""A list Option definition.
2435
This overrides the base class so the conversion from a unicode string
2436
can take quoting into account.
2438
super(ListOption, self).__init__(
2439
name, default=default, default_from_env=default_from_env,
2440
from_unicode=self.from_unicode, help=help,
2441
invalid=invalid, unquote=False)
2443
def from_unicode(self, unicode_str):
2444
if not isinstance(unicode_str, string_types):
2446
# Now inject our string directly as unicode. All callers got their
2447
# value from configobj, so values that need to be quoted are already
2449
_list_converter_config.reset()
2450
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2451
maybe_list = _list_converter_config['list']
2452
if isinstance(maybe_list, string_types):
2454
# A single value, most probably the user forgot (or didn't care
2455
# to add) the final ','
2458
# The empty string, convert to empty list
2461
# We rely on ConfigObj providing us with a list already
2466
class RegistryOption(Option):
2467
"""Option for a choice from a registry."""
2469
def __init__(self, name, registry, default_from_env=None,
2470
help=None, invalid=None):
2471
"""A registry based Option definition.
2473
This overrides the base class so the conversion from a unicode string
2474
can take quoting into account.
2476
super(RegistryOption, self).__init__(
2477
name, default=lambda: unicode(registry.default_key),
2478
default_from_env=default_from_env,
2479
from_unicode=self.from_unicode, help=help,
2480
invalid=invalid, unquote=False)
2481
self.registry = registry
2483
def from_unicode(self, unicode_str):
2484
if not isinstance(unicode_str, string_types):
2487
return self.registry.get(unicode_str)
2490
"Invalid value %s for %s."
2491
"See help for a list of possible values." % (unicode_str,
2496
ret = [self._help, "\n\nThe following values are supported:\n"]
2497
for key in self.registry.keys():
2498
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2502
_option_ref_re = lazy_regex.lazy_compile('({[^\d\W](?:\.\w|-\w|\w)*})')
2503
"""Describes an expandable option reference.
2505
We want to match the most embedded reference first.
2507
I.e. for '{{foo}}' we will get '{foo}',
2508
for '{bar{baz}}' we will get '{baz}'
2511
def iter_option_refs(string):
2512
# Split isolate refs so every other chunk is a ref
2514
for chunk in _option_ref_re.split(string):
2519
class OptionRegistry(registry.Registry):
2520
"""Register config options by their name.
2522
This overrides ``registry.Registry`` to simplify registration by acquiring
2523
some information from the option object itself.
2526
def _check_option_name(self, option_name):
2527
"""Ensures an option name is valid.
2529
:param option_name: The name to validate.
2531
if _option_ref_re.match('{%s}' % option_name) is None:
2532
raise errors.IllegalOptionName(option_name)
2534
def register(self, option):
2535
"""Register a new option to its name.
2537
:param option: The option to register. Its name is used as the key.
2539
self._check_option_name(option.name)
2540
super(OptionRegistry, self).register(option.name, option,
2543
def register_lazy(self, key, module_name, member_name):
2544
"""Register a new option to be loaded on request.
2546
:param key: the key to request the option later. Since the registration
2547
is lazy, it should be provided and match the option name.
2549
:param module_name: the python path to the module. Such as 'os.path'.
2551
:param member_name: the member of the module to return. If empty or
2552
None, get() will return the module itself.
2554
self._check_option_name(key)
2555
super(OptionRegistry, self).register_lazy(key,
2556
module_name, member_name)
2558
def get_help(self, key=None):
2559
"""Get the help text associated with the given key"""
2560
option = self.get(key)
2561
the_help = option.help
2562
if callable(the_help):
2563
return the_help(self, key)
2567
option_registry = OptionRegistry()
2570
# Registered options in lexicographical order
2572
option_registry.register(
2573
Option('append_revisions_only',
2574
default=None, from_unicode=bool_from_store, invalid='warning',
2576
Whether to only append revisions to the mainline.
2578
If this is set to true, then it is not possible to change the
2579
existing mainline of the branch.
2581
option_registry.register(
2582
ListOption('acceptable_keys',
2585
List of GPG key patterns which are acceptable for verification.
2587
option_registry.register(
2588
Option('add.maximum_file_size',
2589
default=u'20MB', from_unicode=int_SI_from_store,
2591
Size above which files should be added manually.
2593
Files below this size are added automatically when using ``bzr add`` without
2596
A negative value means disable the size check.
2598
option_registry.register(
2600
default=None, from_unicode=bool_from_store,
2602
Is the branch bound to ``bound_location``.
2604
If set to "True", the branch should act as a checkout, and push each commit to
2605
the bound_location. This option is normally set by ``bind``/``unbind``.
2607
See also: bound_location.
2609
option_registry.register(
2610
Option('bound_location',
2613
The location that commits should go to when acting as a checkout.
2615
This option is normally set by ``bind``.
2619
option_registry.register(
2620
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2622
Whether revisions associated with tags should be fetched.
2624
option_registry.register_lazy(
2625
'bzr.transform.orphan_policy', 'breezy.transform', 'opt_transform_orphan')
2626
option_registry.register(
2627
Option('bzr.workingtree.worth_saving_limit', default=10,
2628
from_unicode=int_from_store, invalid='warning',
2630
How many changes before saving the dirstate.
2632
-1 means that we will never rewrite the dirstate file for only
2633
stat-cache changes. Regardless of this setting, we will always rewrite
2634
the dirstate file if a file is added/removed/renamed/etc. This flag only
2635
affects the behavior of updating the dirstate file after we notice that
2636
a file has been touched.
2638
option_registry.register(
2639
Option('bugtracker', default=None,
2641
Default bug tracker to use.
2643
This bug tracker will be used for example when marking bugs
2644
as fixed using ``bzr commit --fixes``, if no explicit
2645
bug tracker was specified.
2647
option_registry.register(
2648
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2649
from_unicode=signature_policy_from_unicode,
2651
GPG checking policy.
2653
Possible values: require, ignore, check-available (default)
2655
this option will control whether bzr will require good gpg
2656
signatures, ignore them, or check them if they are
2659
option_registry.register(
2660
Option('child_submit_format',
2661
help='''The preferred format of submissions to this branch.'''))
2662
option_registry.register(
2663
Option('child_submit_to',
2664
help='''Where submissions to this branch are mailed to.'''))
2665
option_registry.register(
2666
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2667
from_unicode=signing_policy_from_unicode,
2671
Possible values: always, never, when-required (default)
2673
This option controls whether bzr will always create
2674
gpg signatures or not on commits.
2676
option_registry.register(
2677
Option('dirstate.fdatasync', default=True,
2678
from_unicode=bool_from_store,
2680
Flush dirstate changes onto physical disk?
2682
If true (default), working tree metadata changes are flushed through the
2683
OS buffers to physical disk. This is somewhat slower, but means data
2684
should not be lost if the machine crashes. See also repository.fdatasync.
2686
option_registry.register(
2687
ListOption('debug_flags', default=[],
2688
help='Debug flags to activate.'))
2689
option_registry.register(
2690
Option('default_format', default='2a',
2691
help='Format used when creating branches.'))
2692
option_registry.register(
2693
Option('dpush_strict', default=None,
2694
from_unicode=bool_from_store,
2696
The default value for ``dpush --strict``.
2698
If present, defines the ``--strict`` option default value for checking
2699
uncommitted changes before pushing into a different VCS without any
2700
custom bzr metadata.
2702
option_registry.register(
2704
help='The command called to launch an editor to enter a message.'))
2705
option_registry.register(
2706
Option('email', override_from_env=['BRZ_EMAIL'], default=default_email,
2707
help='The users identity'))
2708
option_registry.register(
2709
Option('gpg_signing_command',
2712
Program to use use for creating signatures.
2714
This should support at least the -u and --clearsign options.
2716
option_registry.register(
2717
Option('gpg_signing_key',
2720
GPG key to use for signing.
2722
This defaults to the first key associated with the users email.
2724
option_registry.register(
2726
help='Language to translate messages into.'))
2727
option_registry.register(
2728
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2730
Steal locks that appears to be dead.
2732
If set to True, bzr will check if a lock is supposed to be held by an
2733
active process from the same user on the same machine. If the user and
2734
machine match, but no process with the given PID is active, then bzr
2735
will automatically break the stale lock, and create a new lock for
2737
Otherwise, bzr will prompt as normal to break the lock.
2739
option_registry.register(
2740
Option('log_format', default='long',
2742
Log format to use when displaying revisions.
2744
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2745
may be provided by plugins.
2747
option_registry.register_lazy('mail_client', 'breezy.mail_client',
2749
option_registry.register(
2750
Option('output_encoding',
2751
help= 'Unicode encoding for output'
2752
' (terminal encoding if not specified).'))
2753
option_registry.register(
2754
Option('parent_location',
2757
The location of the default branch for pull or merge.
2759
This option is normally set when creating a branch, the first ``pull`` or by
2760
``pull --remember``.
2762
option_registry.register(
2763
Option('post_commit', default=None,
2765
Post commit functions.
2767
An ordered list of python functions to call, separated by spaces.
2769
Each function takes branch, rev_id as parameters.
2771
option_registry.register_lazy('progress_bar', 'breezy.ui.text',
2773
option_registry.register(
2774
Option('public_branch',
2777
A publically-accessible version of this branch.
2779
This implies that the branch setting this option is not publically-accessible.
2780
Used and set by ``bzr send``.
2782
option_registry.register(
2783
Option('push_location',
2786
The location of the default branch for push.
2788
This option is normally set by the first ``push`` or ``push --remember``.
2790
option_registry.register(
2791
Option('push_strict', default=None,
2792
from_unicode=bool_from_store,
2794
The default value for ``push --strict``.
2796
If present, defines the ``--strict`` option default value for checking
2797
uncommitted changes before sending a merge directive.
2799
option_registry.register(
2800
Option('repository.fdatasync', default=True,
2801
from_unicode=bool_from_store,
2803
Flush repository changes onto physical disk?
2805
If true (default), repository changes are flushed through the OS buffers
2806
to physical disk. This is somewhat slower, but means data should not be
2807
lost if the machine crashes. See also dirstate.fdatasync.
2809
option_registry.register_lazy('smtp_server',
2810
'breezy.smtp_connection', 'smtp_server')
2811
option_registry.register_lazy('smtp_password',
2812
'breezy.smtp_connection', 'smtp_password')
2813
option_registry.register_lazy('smtp_username',
2814
'breezy.smtp_connection', 'smtp_username')
2815
option_registry.register(
2816
Option('selftest.timeout',
2818
from_unicode=int_from_store,
2819
help='Abort selftest if one test takes longer than this many seconds',
2822
option_registry.register(
2823
Option('send_strict', default=None,
2824
from_unicode=bool_from_store,
2826
The default value for ``send --strict``.
2828
If present, defines the ``--strict`` option default value for checking
2829
uncommitted changes before sending a bundle.
2832
option_registry.register(
2833
Option('serve.client_timeout',
2834
default=300.0, from_unicode=float_from_store,
2835
help="If we wait for a new request from a client for more than"
2836
" X seconds, consider the client idle, and hangup."))
2837
option_registry.register(
2838
Option('stacked_on_location',
2840
help="""The location where this branch is stacked on."""))
2841
option_registry.register(
2842
Option('submit_branch',
2845
The branch you intend to submit your current work to.
2847
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2848
by the ``submit:`` revision spec.
2850
option_registry.register(
2852
help='''Where submissions from this branch are mailed to.'''))
2853
option_registry.register(
2854
ListOption('suppress_warnings',
2856
help="List of warning classes to suppress."))
2857
option_registry.register(
2858
Option('validate_signatures_in_log', default=False,
2859
from_unicode=bool_from_store, invalid='warning',
2860
help='''Whether to validate signatures in brz log.'''))
2861
option_registry.register_lazy('ssl.ca_certs',
2862
'breezy.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2864
option_registry.register_lazy('ssl.cert_reqs',
2865
'breezy.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2868
class Section(object):
2869
"""A section defines a dict of option name => value.
2871
This is merely a read-only dict which can add some knowledge about the
2872
options. It is *not* a python dict object though and doesn't try to mimic
2876
def __init__(self, section_id, options):
2877
self.id = section_id
2878
# We re-use the dict-like object received
2879
self.options = options
2881
def get(self, name, default=None, expand=True):
2882
return self.options.get(name, default)
2884
def iter_option_names(self):
2885
for k in self.options.keys():
2889
# Mostly for debugging use
2890
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2893
_NewlyCreatedOption = object()
2894
"""Was the option created during the MutableSection lifetime"""
2895
_DeletedOption = object()
2896
"""Was the option deleted during the MutableSection lifetime"""
2899
class MutableSection(Section):
2900
"""A section allowing changes and keeping track of the original values."""
2902
def __init__(self, section_id, options):
2903
super(MutableSection, self).__init__(section_id, options)
2904
self.reset_changes()
2906
def set(self, name, value):
2907
if name not in self.options:
2908
# This is a new option
2909
self.orig[name] = _NewlyCreatedOption
2910
elif name not in self.orig:
2911
self.orig[name] = self.get(name, None)
2912
self.options[name] = value
2914
def remove(self, name):
2915
if name not in self.orig and name in self.options:
2916
self.orig[name] = self.get(name, None)
2917
del self.options[name]
2919
def reset_changes(self):
2922
def apply_changes(self, dirty, store):
2923
"""Apply option value changes.
2925
``self`` has been reloaded from the persistent storage. ``dirty``
2926
contains the changes made since the previous loading.
2928
:param dirty: the mutable section containing the changes.
2930
:param store: the store containing the section
2932
for k, expected in dirty.orig.items():
2933
actual = dirty.get(k, _DeletedOption)
2934
reloaded = self.get(k, _NewlyCreatedOption)
2935
if actual is _DeletedOption:
2936
if k in self.options:
2940
# Report concurrent updates in an ad-hoc way. This should only
2941
# occurs when different processes try to update the same option
2942
# which is not supported (as in: the config framework is not meant
2943
# to be used as a sharing mechanism).
2944
if expected != reloaded:
2945
if actual is _DeletedOption:
2946
actual = '<DELETED>'
2947
if reloaded is _NewlyCreatedOption:
2948
reloaded = '<CREATED>'
2949
if expected is _NewlyCreatedOption:
2950
expected = '<CREATED>'
2951
# Someone changed the value since we get it from the persistent
2953
trace.warning(gettext(
2954
"Option {0} in section {1} of {2} was changed"
2955
" from {3} to {4}. The {5} value will be saved.".format(
2956
k, self.id, store.external_url(), expected,
2958
# No need to keep track of these changes
2959
self.reset_changes()
2962
class Store(object):
2963
"""Abstract interface to persistent storage for configuration options."""
2965
readonly_section_class = Section
2966
mutable_section_class = MutableSection
2969
# Which sections need to be saved (by section id). We use a dict here
2970
# so the dirty sections can be shared by multiple callers.
2971
self.dirty_sections = {}
2973
def is_loaded(self):
2974
"""Returns True if the Store has been loaded.
2976
This is used to implement lazy loading and ensure the persistent
2977
storage is queried only when needed.
2979
raise NotImplementedError(self.is_loaded)
2982
"""Loads the Store from persistent storage."""
2983
raise NotImplementedError(self.load)
2985
def _load_from_string(self, bytes):
2986
"""Create a store from a string in configobj syntax.
2988
:param bytes: A string representing the file content.
2990
raise NotImplementedError(self._load_from_string)
2993
"""Unloads the Store.
2995
This should make is_loaded() return False. This is used when the caller
2996
knows that the persistent storage has changed or may have change since
2999
raise NotImplementedError(self.unload)
3001
def quote(self, value):
3002
"""Quote a configuration option value for storing purposes.
3004
This allows Stacks to present values as they will be stored.
3008
def unquote(self, value):
3009
"""Unquote a configuration option value into unicode.
3011
The received value is quoted as stored.
3016
"""Saves the Store to persistent storage."""
3017
raise NotImplementedError(self.save)
3019
def _need_saving(self):
3020
for s in self.dirty_sections.values():
3022
# At least one dirty section contains a modification
3026
def apply_changes(self, dirty_sections):
3027
"""Apply changes from dirty sections while checking for coherency.
3029
The Store content is discarded and reloaded from persistent storage to
3030
acquire up-to-date values.
3032
Dirty sections are MutableSection which kept track of the value they
3033
are expected to update.
3035
# We need an up-to-date version from the persistent storage, unload the
3036
# store. The reload will occur when needed (triggered by the first
3037
# get_mutable_section() call below.
3039
# Apply the changes from the preserved dirty sections
3040
for section_id, dirty in dirty_sections.items():
3041
clean = self.get_mutable_section(section_id)
3042
clean.apply_changes(dirty, self)
3043
# Everything is clean now
3044
self.dirty_sections = {}
3046
def save_changes(self):
3047
"""Saves the Store to persistent storage if changes occurred.
3049
Apply the changes recorded in the mutable sections to a store content
3050
refreshed from persistent storage.
3052
raise NotImplementedError(self.save_changes)
3054
def external_url(self):
3055
raise NotImplementedError(self.external_url)
3057
def get_sections(self):
3058
"""Returns an ordered iterable of existing sections.
3060
:returns: An iterable of (store, section).
3062
raise NotImplementedError(self.get_sections)
3064
def get_mutable_section(self, section_id=None):
3065
"""Returns the specified mutable section.
3067
:param section_id: The section identifier
3069
raise NotImplementedError(self.get_mutable_section)
3072
# Mostly for debugging use
3073
return "<config.%s(%s)>" % (self.__class__.__name__,
3074
self.external_url())
3077
class CommandLineStore(Store):
3078
"A store to carry command line overrides for the config options."""
3080
def __init__(self, opts=None):
3081
super(CommandLineStore, self).__init__()
3088
# The dict should be cleared but not replaced so it can be shared.
3089
self.options.clear()
3091
def _from_cmdline(self, overrides):
3092
# Reset before accepting new definitions
3094
for over in overrides:
3096
name, value = over.split('=', 1)
3098
raise errors.BzrCommandError(
3099
gettext("Invalid '%s', should be of the form 'name=value'")
3101
self.options[name] = value
3103
def external_url(self):
3104
# Not an url but it makes debugging easier and is never needed
3108
def get_sections(self):
3109
yield self, self.readonly_section_class(None, self.options)
3112
class IniFileStore(Store):
3113
"""A config Store using ConfigObj for storage.
3115
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3116
serialize/deserialize the config file.
3120
"""A config Store using ConfigObj for storage.
3122
super(IniFileStore, self).__init__()
3123
self._config_obj = None
3125
def is_loaded(self):
3126
return self._config_obj != None
3129
self._config_obj = None
3130
self.dirty_sections = {}
3132
def _load_content(self):
3133
"""Load the config file bytes.
3135
This should be provided by subclasses
3137
:return: Byte string
3139
raise NotImplementedError(self._load_content)
3141
def _save_content(self, content):
3142
"""Save the config file bytes.
3144
This should be provided by subclasses
3146
:param content: Config file bytes to write
3148
raise NotImplementedError(self._save_content)
3151
"""Load the store from the associated file."""
3152
if self.is_loaded():
3154
content = self._load_content()
3155
self._load_from_string(content)
3156
for hook in ConfigHooks['load']:
3159
def _load_from_string(self, bytes):
3160
"""Create a config store from a string.
3162
:param bytes: A string representing the file content.
3164
if self.is_loaded():
3165
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3166
co_input = BytesIO(bytes)
3168
# The config files are always stored utf8-encoded
3169
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3171
except configobj.ConfigObjError as e:
3172
self._config_obj = None
3173
raise errors.ParseConfigError(e.errors, self.external_url())
3174
except UnicodeDecodeError:
3175
raise errors.ConfigContentError(self.external_url())
3177
def save_changes(self):
3178
if not self.is_loaded():
3181
if not self._need_saving():
3183
# Preserve the current version
3184
dirty_sections = self.dirty_sections.copy()
3185
self.apply_changes(dirty_sections)
3186
# Save to the persistent storage
3190
if not self.is_loaded():
3194
self._config_obj.write(out)
3195
self._save_content(out.getvalue())
3196
for hook in ConfigHooks['save']:
3199
def get_sections(self):
3200
"""Get the configobj section in the file order.
3202
:returns: An iterable of (store, section).
3204
# We need a loaded store
3207
except (errors.NoSuchFile, errors.PermissionDenied):
3208
# If the file can't be read, there is no sections
3210
cobj = self._config_obj
3212
yield self, self.readonly_section_class(None, cobj)
3213
for section_name in cobj.sections:
3215
self.readonly_section_class(section_name,
3216
cobj[section_name]))
3218
def get_mutable_section(self, section_id=None):
3219
# We need a loaded store
3222
except errors.NoSuchFile:
3223
# The file doesn't exist, let's pretend it was empty
3224
self._load_from_string(b'')
3225
if section_id in self.dirty_sections:
3226
# We already created a mutable section for this id
3227
return self.dirty_sections[section_id]
3228
if section_id is None:
3229
section = self._config_obj
3231
section = self._config_obj.setdefault(section_id, {})
3232
mutable_section = self.mutable_section_class(section_id, section)
3233
# All mutable sections can become dirty
3234
self.dirty_sections[section_id] = mutable_section
3235
return mutable_section
3237
def quote(self, value):
3239
# configobj conflates automagical list values and quoting
3240
self._config_obj.list_values = True
3241
return self._config_obj._quote(value)
3243
self._config_obj.list_values = False
3245
def unquote(self, value):
3246
if value and isinstance(value, string_types):
3247
# _unquote doesn't handle None nor empty strings nor anything that
3248
# is not a string, really.
3249
value = self._config_obj._unquote(value)
3252
def external_url(self):
3253
# Since an IniFileStore can be used without a file (at least in tests),
3254
# it's better to provide something than raising a NotImplementedError.
3255
# All daughter classes are supposed to provide an implementation
3257
return 'In-Process Store, no URL'
3260
class TransportIniFileStore(IniFileStore):
3261
"""IniFileStore that loads files from a transport.
3263
:ivar transport: The transport object where the config file is located.
3265
:ivar file_name: The config file basename in the transport directory.
3268
def __init__(self, transport, file_name):
3269
"""A Store using a ini file on a Transport
3271
:param transport: The transport object where the config file is located.
3272
:param file_name: The config file basename in the transport directory.
3274
super(TransportIniFileStore, self).__init__()
3275
self.transport = transport
3276
self.file_name = file_name
3278
def _load_content(self):
3280
return self.transport.get_bytes(self.file_name)
3281
except errors.PermissionDenied:
3282
trace.warning("Permission denied while trying to load "
3283
"configuration store %s.", self.external_url())
3286
def _save_content(self, content):
3287
self.transport.put_bytes(self.file_name, content)
3289
def external_url(self):
3290
# FIXME: external_url should really accepts an optional relpath
3291
# parameter (bug #750169) :-/ -- vila 2011-04-04
3292
# The following will do in the interim but maybe we don't want to
3293
# expose a path here but rather a config ID and its associated
3294
# object </hand wawe>.
3295
return urlutils.join(
3296
self.transport.external_url(), urlutils.escape(self.file_name))
3299
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3300
# unlockable stores for use with objects that can already ensure the locking
3301
# (think branches). If different stores (not based on ConfigObj) are created,
3302
# they may face the same issue.
3305
class LockableIniFileStore(TransportIniFileStore):
3306
"""A ConfigObjStore using locks on save to ensure store integrity."""
3308
def __init__(self, transport, file_name, lock_dir_name=None):
3309
"""A config Store using ConfigObj for storage.
3311
:param transport: The transport object where the config file is located.
3313
:param file_name: The config file basename in the transport directory.
3315
if lock_dir_name is None:
3316
lock_dir_name = 'lock'
3317
self.lock_dir_name = lock_dir_name
3318
super(LockableIniFileStore, self).__init__(transport, file_name)
3319
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3321
def lock_write(self, token=None):
3322
"""Takes a write lock in the directory containing the config file.
3324
If the directory doesn't exist it is created.
3326
# FIXME: This doesn't check the ownership of the created directories as
3327
# ensure_config_dir_exists does. It should if the transport is local
3328
# -- vila 2011-04-06
3329
self.transport.create_prefix()
3330
return self._lock.lock_write(token)
3335
def break_lock(self):
3336
self._lock.break_lock()
3340
# We need to be able to override the undecorated implementation
3341
self.save_without_locking()
3343
def save_without_locking(self):
3344
super(LockableIniFileStore, self).save()
3347
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3348
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3349
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3351
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3352
# functions or a registry will make it easier and clearer for tests, focusing
3353
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3354
# on a poolie's remark)
3355
class GlobalStore(LockableIniFileStore):
3356
"""A config store for global options.
3358
There is a single GlobalStore for a given process.
3361
def __init__(self, possible_transports=None):
3362
t = transport.get_transport_from_path(
3363
config_dir(), possible_transports=possible_transports)
3364
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3368
class LocationStore(LockableIniFileStore):
3369
"""A config store for options specific to a location.
3371
There is a single LocationStore for a given process.
3374
def __init__(self, possible_transports=None):
3375
t = transport.get_transport_from_path(
3376
config_dir(), possible_transports=possible_transports)
3377
super(LocationStore, self).__init__(t, 'locations.conf')
3378
self.id = 'locations'
3381
class BranchStore(TransportIniFileStore):
3382
"""A config store for branch options.
3384
There is a single BranchStore for a given branch.
3387
def __init__(self, branch):
3388
super(BranchStore, self).__init__(branch.control_transport,
3390
self.branch = branch
3394
class ControlStore(LockableIniFileStore):
3396
def __init__(self, bzrdir):
3397
super(ControlStore, self).__init__(bzrdir.transport,
3399
lock_dir_name='branch_lock')
3403
class SectionMatcher(object):
3404
"""Select sections into a given Store.
3406
This is intended to be used to postpone getting an iterable of sections
3410
def __init__(self, store):
3413
def get_sections(self):
3414
# This is where we require loading the store so we can see all defined
3416
sections = self.store.get_sections()
3417
# Walk the revisions in the order provided
3418
for store, s in sections:
3422
def match(self, section):
3423
"""Does the proposed section match.
3425
:param section: A Section object.
3427
:returns: True if the section matches, False otherwise.
3429
raise NotImplementedError(self.match)
3432
class NameMatcher(SectionMatcher):
3434
def __init__(self, store, section_id):
3435
super(NameMatcher, self).__init__(store)
3436
self.section_id = section_id
3438
def match(self, section):
3439
return section.id == self.section_id
3442
class LocationSection(Section):
3444
def __init__(self, section, extra_path, branch_name=None):
3445
super(LocationSection, self).__init__(section.id, section.options)
3446
self.extra_path = extra_path
3447
if branch_name is None:
3449
self.locals = {'relpath': extra_path,
3450
'basename': urlutils.basename(extra_path),
3451
'branchname': branch_name}
3453
def get(self, name, default=None, expand=True):
3454
value = super(LocationSection, self).get(name, default)
3455
if value is not None and expand:
3456
policy_name = self.get(name + ':policy', None)
3457
policy = _policy_value.get(policy_name, POLICY_NONE)
3458
if policy == POLICY_APPENDPATH:
3459
value = urlutils.join(value, self.extra_path)
3460
# expand section local options right now (since POLICY_APPENDPATH
3461
# will never add options references, it's ok to expand after it).
3463
for is_ref, chunk in iter_option_refs(value):
3465
chunks.append(chunk)
3468
if ref in self.locals:
3469
chunks.append(self.locals[ref])
3471
chunks.append(chunk)
3472
value = ''.join(chunks)
3476
class StartingPathMatcher(SectionMatcher):
3477
"""Select sections for a given location respecting the Store order."""
3479
# FIXME: Both local paths and urls can be used for section names as well as
3480
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3481
# inherited the fuzziness from the previous ``LocationConfig``
3482
# implementation. We probably need to revisit which encoding is allowed for
3483
# both ``location`` and section names and how we normalize
3484
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3485
# related too. -- vila 2012-01-04
3487
def __init__(self, store, location):
3488
super(StartingPathMatcher, self).__init__(store)
3489
if location.startswith('file://'):
3490
location = urlutils.local_path_from_url(location)
3491
self.location = location
3493
def get_sections(self):
3494
"""Get all sections matching ``location`` in the store.
3496
The most generic sections are described first in the store, then more
3497
specific ones can be provided for reduced scopes.
3499
The returned section are therefore returned in the reversed order so
3500
the most specific ones can be found first.
3502
location_parts = self.location.rstrip('/').split('/')
3504
# Later sections are more specific, they should be returned first
3505
for _, section in reversed(list(store.get_sections())):
3506
if section.id is None:
3507
# The no-name section is always included if present
3508
yield store, LocationSection(section, self.location)
3510
section_path = section.id
3511
if section_path.startswith('file://'):
3512
# the location is already a local path or URL, convert the
3513
# section id to the same format
3514
section_path = urlutils.local_path_from_url(section_path)
3515
if (self.location.startswith(section_path)
3516
or fnmatch.fnmatch(self.location, section_path)):
3517
section_parts = section_path.rstrip('/').split('/')
3518
extra_path = '/'.join(location_parts[len(section_parts):])
3519
yield store, LocationSection(section, extra_path)
3522
class LocationMatcher(SectionMatcher):
3524
def __init__(self, store, location):
3525
super(LocationMatcher, self).__init__(store)
3526
url, params = urlutils.split_segment_parameters(location)
3527
if location.startswith('file://'):
3528
location = urlutils.local_path_from_url(location)
3529
self.location = location
3530
branch_name = params.get('branch')
3531
if branch_name is None:
3532
self.branch_name = urlutils.basename(self.location)
3534
self.branch_name = urlutils.unescape(branch_name)
3536
def _get_matching_sections(self):
3537
"""Get all sections matching ``location``."""
3538
# We slightly diverge from LocalConfig here by allowing the no-name
3539
# section as the most generic one and the lower priority.
3540
no_name_section = None
3542
# Filter out the no_name_section so _iter_for_location_by_parts can be
3543
# used (it assumes all sections have a name).
3544
for _, section in self.store.get_sections():
3545
if section.id is None:
3546
no_name_section = section
3548
all_sections.append(section)
3549
# Unfortunately _iter_for_location_by_parts deals with section names so
3550
# we have to resync.
3551
filtered_sections = _iter_for_location_by_parts(
3552
[s.id for s in all_sections], self.location)
3553
iter_all_sections = iter(all_sections)
3554
matching_sections = []
3555
if no_name_section is not None:
3556
matching_sections.append(
3557
(0, LocationSection(no_name_section, self.location)))
3558
for section_id, extra_path, length in filtered_sections:
3559
# a section id is unique for a given store so it's safe to take the
3560
# first matching section while iterating. Also, all filtered
3561
# sections are part of 'all_sections' and will always be found
3564
section = next(iter_all_sections)
3565
if section_id == section.id:
3566
section = LocationSection(section, extra_path,
3568
matching_sections.append((length, section))
3570
return matching_sections
3572
def get_sections(self):
3573
# Override the default implementation as we want to change the order
3574
# We want the longest (aka more specific) locations first
3575
sections = sorted(self._get_matching_sections(),
3576
key=lambda match: (match[0], match[1].id),
3578
# Sections mentioning 'ignore_parents' restrict the selection
3579
for _, section in sections:
3580
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3581
ignore = section.get('ignore_parents', None)
3582
if ignore is not None:
3583
ignore = ui.bool_from_string(ignore)
3586
# Finally, we have a valid section
3587
yield self.store, section
3590
# FIXME: _shared_stores should be an attribute of a library state once a
3591
# library_state object is always available.
3593
_shared_stores_at_exit_installed = False
3595
class Stack(object):
3596
"""A stack of configurations where an option can be defined"""
3598
def __init__(self, sections_def, store=None, mutable_section_id=None):
3599
"""Creates a stack of sections with an optional store for changes.
3601
:param sections_def: A list of Section or callables that returns an
3602
iterable of Section. This defines the Sections for the Stack and
3603
can be called repeatedly if needed.
3605
:param store: The optional Store where modifications will be
3606
recorded. If none is specified, no modifications can be done.
3608
:param mutable_section_id: The id of the MutableSection where changes
3609
are recorded. This requires the ``store`` parameter to be
3612
self.sections_def = sections_def
3614
self.mutable_section_id = mutable_section_id
3616
def iter_sections(self):
3617
"""Iterate all the defined sections."""
3618
# Ensuring lazy loading is achieved by delaying section matching (which
3619
# implies querying the persistent storage) until it can't be avoided
3620
# anymore by using callables to describe (possibly empty) section
3622
for sections in self.sections_def:
3623
for store, section in sections():
3624
yield store, section
3626
def get(self, name, expand=True, convert=True):
3627
"""Return the *first* option value found in the sections.
3629
This is where we guarantee that sections coming from Store are loaded
3630
lazily: the loading is delayed until we need to either check that an
3631
option exists or get its value, which in turn may require to discover
3632
in which sections it can be defined. Both of these (section and option
3633
existence) require loading the store (even partially).
3635
:param name: The queried option.
3637
:param expand: Whether options references should be expanded.
3639
:param convert: Whether the option value should be converted from
3640
unicode (do nothing for non-registered options).
3642
:returns: The value of the option.
3644
# FIXME: No caching of options nor sections yet -- vila 20110503
3646
found_store = None # Where the option value has been found
3647
# If the option is registered, it may provide additional info about
3650
opt = option_registry.get(name)
3655
def expand_and_convert(val):
3656
# This may need to be called in different contexts if the value is
3657
# None or ends up being None during expansion or conversion.
3660
if isinstance(val, string_types):
3661
val = self._expand_options_in_string(val)
3663
trace.warning('Cannot expand "%s":'
3664
' %s does not support option expansion'
3665
% (name, type(val)))
3667
val = found_store.unquote(val)
3669
val = opt.convert_from_unicode(found_store, val)
3672
# First of all, check if the environment can override the configuration
3674
if opt is not None and opt.override_from_env:
3675
value = opt.get_override()
3676
value = expand_and_convert(value)
3678
for store, section in self.iter_sections():
3679
value = section.get(name)
3680
if value is not None:
3683
value = expand_and_convert(value)
3684
if opt is not None and value is None:
3685
# If the option is registered, it may provide a default value
3686
value = opt.get_default()
3687
value = expand_and_convert(value)
3688
for hook in ConfigHooks['get']:
3689
hook(self, name, value)
3692
def expand_options(self, string, env=None):
3693
"""Expand option references in the string in the configuration context.
3695
:param string: The string containing option(s) to expand.
3697
:param env: An option dict defining additional configuration options or
3698
overriding existing ones.
3700
:returns: The expanded string.
3702
return self._expand_options_in_string(string, env)
3704
def _expand_options_in_string(self, string, env=None, _refs=None):
3705
"""Expand options in the string in the configuration context.
3707
:param string: The string to be expanded.
3709
:param env: An option dict defining additional configuration options or
3710
overriding existing ones.
3712
:param _refs: Private list (FIFO) containing the options being expanded
3715
:returns: The expanded string.
3718
# Not much to expand there
3721
# What references are currently resolved (to detect loops)
3724
# We need to iterate until no more refs appear ({{foo}} will need two
3725
# iterations for example).
3730
for is_ref, chunk in iter_option_refs(result):
3732
chunks.append(chunk)
3737
raise errors.OptionExpansionLoop(string, _refs)
3739
value = self._expand_option(name, env, _refs)
3741
raise errors.ExpandingUnknownOption(name, string)
3742
chunks.append(value)
3744
result = ''.join(chunks)
3747
def _expand_option(self, name, env, _refs):
3748
if env is not None and name in env:
3749
# Special case, values provided in env takes precedence over
3753
value = self.get(name, expand=False, convert=False)
3754
value = self._expand_options_in_string(value, env, _refs)
3757
def _get_mutable_section(self):
3758
"""Get the MutableSection for the Stack.
3760
This is where we guarantee that the mutable section is lazily loaded:
3761
this means we won't load the corresponding store before setting a value
3762
or deleting an option. In practice the store will often be loaded but
3763
this helps catching some programming errors.
3766
section = store.get_mutable_section(self.mutable_section_id)
3767
return store, section
3769
def set(self, name, value):
3770
"""Set a new value for the option."""
3771
store, section = self._get_mutable_section()
3772
section.set(name, store.quote(value))
3773
for hook in ConfigHooks['set']:
3774
hook(self, name, value)
3776
def remove(self, name):
3777
"""Remove an existing option."""
3778
_, section = self._get_mutable_section()
3779
section.remove(name)
3780
for hook in ConfigHooks['remove']:
3784
# Mostly for debugging use
3785
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3787
def _get_overrides(self):
3788
# FIXME: Hack around library_state.initialize never called
3789
if breezy.global_state is not None:
3790
return breezy.global_state.cmdline_overrides.get_sections()
3793
def get_shared_store(self, store, state=None):
3794
"""Get a known shared store.
3796
Store urls uniquely identify them and are used to ensure a single copy
3797
is shared across all users.
3799
:param store: The store known to the caller.
3801
:param state: The library state where the known stores are kept.
3803
:returns: The store received if it's not a known one, an already known
3807
state = breezy.global_state
3809
global _shared_stores_at_exit_installed
3810
stores = _shared_stores
3811
def save_config_changes():
3812
for k, store in stores.items():
3813
store.save_changes()
3814
if not _shared_stores_at_exit_installed:
3815
# FIXME: Ugly hack waiting for library_state to always be
3816
# available. -- vila 20120731
3818
atexit.register(save_config_changes)
3819
_shared_stores_at_exit_installed = True
3821
stores = state.config_stores
3822
url = store.external_url()
3830
class MemoryStack(Stack):
3831
"""A configuration stack defined from a string.
3833
This is mainly intended for tests and requires no disk resources.
3836
def __init__(self, content=None):
3837
"""Create an in-memory stack from a given content.
3839
It uses a single store based on configobj and support reading and
3842
:param content: The initial content of the store. If None, the store is
3843
not loaded and ``_load_from_string`` can and should be used if
3846
store = IniFileStore()
3847
if content is not None:
3848
store._load_from_string(content)
3849
super(MemoryStack, self).__init__(
3850
[store.get_sections], store)
3853
class _CompatibleStack(Stack):
3854
"""Place holder for compatibility with previous design.
3856
This is intended to ease the transition from the Config-based design to the
3857
Stack-based design and should not be used nor relied upon by plugins.
3859
One assumption made here is that the daughter classes will all use Stores
3860
derived from LockableIniFileStore).
3862
It implements set() and remove () by re-loading the store before applying
3863
the modification and saving it.
3865
The long term plan being to implement a single write by store to save
3866
all modifications, this class should not be used in the interim.
3869
def set(self, name, value):
3872
super(_CompatibleStack, self).set(name, value)
3873
# Force a write to persistent storage
3876
def remove(self, name):
3879
super(_CompatibleStack, self).remove(name)
3880
# Force a write to persistent storage
3884
class GlobalStack(Stack):
3885
"""Global options only stack.
3887
The following sections are queried:
3889
* command-line overrides,
3891
* the 'DEFAULT' section in bazaar.conf
3893
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3898
gstore = self.get_shared_store(GlobalStore())
3899
super(GlobalStack, self).__init__(
3900
[self._get_overrides,
3901
NameMatcher(gstore, 'DEFAULT').get_sections],
3902
gstore, mutable_section_id='DEFAULT')
3905
class LocationStack(Stack):
3906
"""Per-location options falling back to global options stack.
3909
The following sections are queried:
3911
* command-line overrides,
3913
* the sections matching ``location`` in ``locations.conf``, the order being
3914
defined by the number of path components in the section glob, higher
3915
numbers first (from most specific section to most generic).
3917
* the 'DEFAULT' section in bazaar.conf
3919
This stack will use the ``location`` section in locations.conf as its
3923
def __init__(self, location):
3924
"""Make a new stack for a location and global configuration.
3926
:param location: A URL prefix to """
3927
lstore = self.get_shared_store(LocationStore())
3928
if location.startswith('file://'):
3929
location = urlutils.local_path_from_url(location)
3930
gstore = self.get_shared_store(GlobalStore())
3931
super(LocationStack, self).__init__(
3932
[self._get_overrides,
3933
LocationMatcher(lstore, location).get_sections,
3934
NameMatcher(gstore, 'DEFAULT').get_sections],
3935
lstore, mutable_section_id=location)
3938
class BranchStack(Stack):
3939
"""Per-location options falling back to branch then global options stack.
3941
The following sections are queried:
3943
* command-line overrides,
3945
* the sections matching ``location`` in ``locations.conf``, the order being
3946
defined by the number of path components in the section glob, higher
3947
numbers first (from most specific section to most generic),
3949
* the no-name section in branch.conf,
3951
* the ``DEFAULT`` section in ``bazaar.conf``.
3953
This stack will use the no-name section in ``branch.conf`` as its
3957
def __init__(self, branch):
3958
lstore = self.get_shared_store(LocationStore())
3959
bstore = branch._get_config_store()
3960
gstore = self.get_shared_store(GlobalStore())
3961
super(BranchStack, self).__init__(
3962
[self._get_overrides,
3963
LocationMatcher(lstore, branch.base).get_sections,
3964
NameMatcher(bstore, None).get_sections,
3965
NameMatcher(gstore, 'DEFAULT').get_sections],
3967
self.branch = branch
3969
def lock_write(self, token=None):
3970
return self.branch.lock_write(token)
3973
return self.branch.unlock()
3976
def set(self, name, value):
3977
super(BranchStack, self).set(name, value)
3978
# Unlocking the branch will trigger a store.save_changes() so the last
3979
# unlock saves all the changes.
3982
def remove(self, name):
3983
super(BranchStack, self).remove(name)
3984
# Unlocking the branch will trigger a store.save_changes() so the last
3985
# unlock saves all the changes.
3988
class RemoteControlStack(Stack):
3989
"""Remote control-only options stack."""
3991
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3992
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3993
# control.conf and is used only for stack options.
3995
def __init__(self, bzrdir):
3996
cstore = bzrdir._get_config_store()
3997
super(RemoteControlStack, self).__init__(
3998
[NameMatcher(cstore, None).get_sections],
4000
self.controldir = bzrdir
4003
class BranchOnlyStack(Stack):
4004
"""Branch-only options stack."""
4006
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4007
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4008
# -- vila 2011-12-16
4010
def __init__(self, branch):
4011
bstore = branch._get_config_store()
4012
super(BranchOnlyStack, self).__init__(
4013
[NameMatcher(bstore, None).get_sections],
4015
self.branch = branch
4017
def lock_write(self, token=None):
4018
return self.branch.lock_write(token)
4021
return self.branch.unlock()
4024
def set(self, name, value):
4025
super(BranchOnlyStack, self).set(name, value)
4026
# Force a write to persistent storage
4027
self.store.save_changes()
4030
def remove(self, name):
4031
super(BranchOnlyStack, self).remove(name)
4032
# Force a write to persistent storage
4033
self.store.save_changes()
4036
class cmd_config(commands.Command):
4037
__doc__ = """Display, set or remove a configuration option.
4039
Display the active value for option NAME.
4041
If --all is specified, NAME is interpreted as a regular expression and all
4042
matching options are displayed mentioning their scope and without resolving
4043
option references in the value). The active value that bzr will take into
4044
account is the first one displayed for each option.
4046
If NAME is not given, --all .* is implied (all options are displayed for the
4049
Setting a value is achieved by using NAME=value without spaces. The value
4050
is set in the most relevant scope and can be checked by displaying the
4053
Removing a value is achieved by using --remove NAME.
4056
takes_args = ['name?']
4060
# FIXME: This should be a registry option so that plugins can register
4061
# their own config files (or not) and will also address
4062
# http://pad.lv/788991 -- vila 20101115
4063
commands.Option('scope', help='Reduce the scope to the specified'
4064
' configuration file.',
4066
commands.Option('all',
4067
help='Display all the defined values for the matching options.',
4069
commands.Option('remove', help='Remove the option from'
4070
' the configuration file.'),
4073
_see_also = ['configuration']
4075
@commands.display_command
4076
def run(self, name=None, all=False, directory=None, scope=None,
4078
if directory is None:
4080
directory = directory_service.directories.dereference(directory)
4081
directory = urlutils.normalize_url(directory)
4083
raise errors.BzrError(
4084
'--all and --remove are mutually exclusive.')
4086
# Delete the option in the given scope
4087
self._remove_config_option(name, directory, scope)
4089
# Defaults to all options
4090
self._show_matching_options('.*', directory, scope)
4093
name, value = name.split('=', 1)
4095
# Display the option(s) value(s)
4097
self._show_matching_options(name, directory, scope)
4099
self._show_value(name, directory, scope)
4102
raise errors.BzrError(
4103
'Only one option can be set.')
4104
# Set the option value
4105
self._set_config_option(name, value, directory, scope)
4107
def _get_stack(self, directory, scope=None, write_access=False):
4108
"""Get the configuration stack specified by ``directory`` and ``scope``.
4110
:param directory: Where the configurations are derived from.
4112
:param scope: A specific config to start from.
4114
:param write_access: Whether a write access to the stack will be
4117
# FIXME: scope should allow access to plugin-specific stacks (even
4118
# reduced to the plugin-specific store), related to
4119
# http://pad.lv/788991 -- vila 2011-11-15
4120
if scope is not None:
4121
if scope == 'bazaar':
4122
return GlobalStack()
4123
elif scope == 'locations':
4124
return LocationStack(directory)
4125
elif scope == 'branch':
4127
controldir.ControlDir.open_containing_tree_or_branch(
4130
self.add_cleanup(br.lock_write().unlock)
4131
return br.get_config_stack()
4132
raise errors.NoSuchConfig(scope)
4136
controldir.ControlDir.open_containing_tree_or_branch(
4139
self.add_cleanup(br.lock_write().unlock)
4140
return br.get_config_stack()
4141
except errors.NotBranchError:
4142
return LocationStack(directory)
4144
def _quote_multiline(self, value):
4146
value = '"""' + value + '"""'
4149
def _show_value(self, name, directory, scope):
4150
conf = self._get_stack(directory, scope)
4151
value = conf.get(name, expand=True, convert=False)
4152
if value is not None:
4153
# Quote the value appropriately
4154
value = self._quote_multiline(value)
4155
self.outf.write('%s\n' % (value,))
4157
raise errors.NoSuchConfigOption(name)
4159
def _show_matching_options(self, name, directory, scope):
4160
name = lazy_regex.lazy_compile(name)
4161
# We want any error in the regexp to be raised *now* so we need to
4162
# avoid the delay introduced by the lazy regexp. But, we still do
4163
# want the nicer errors raised by lazy_regex.
4164
name._compile_and_collapse()
4167
conf = self._get_stack(directory, scope)
4168
for store, section in conf.iter_sections():
4169
for oname in section.iter_option_names():
4170
if name.search(oname):
4171
if cur_store_id != store.id:
4172
# Explain where the options are defined
4173
self.outf.write('%s:\n' % (store.id,))
4174
cur_store_id = store.id
4176
if (section.id is not None and cur_section != section.id):
4177
# Display the section id as it appears in the store
4178
# (None doesn't appear by definition)
4179
self.outf.write(' [%s]\n' % (section.id,))
4180
cur_section = section.id
4181
value = section.get(oname, expand=False)
4182
# Quote the value appropriately
4183
value = self._quote_multiline(value)
4184
self.outf.write(' %s = %s\n' % (oname, value))
4186
def _set_config_option(self, name, value, directory, scope):
4187
conf = self._get_stack(directory, scope, write_access=True)
4188
conf.set(name, value)
4189
# Explicitly save the changes
4190
conf.store.save_changes()
4192
def _remove_config_option(self, name, directory, scope):
4194
raise errors.BzrCommandError(
4195
'--remove expects an option to remove.')
4196
conf = self._get_stack(directory, scope, write_access=True)
4199
# Explicitly save the changes
4200
conf.store.save_changes()
4202
raise errors.NoSuchConfigOption(name)
4207
# We need adapters that can build a Store or a Stack in a test context. Test
4208
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4209
# themselves. The builder will receive a test instance and should return a
4210
# ready-to-use store or stack. Plugins that define new store/stacks can also
4211
# register themselves here to be tested against the tests defined in
4212
# breezy.tests.test_config. Note that the builder can be called multiple times
4213
# for the same test.
4215
# The registered object should be a callable receiving a test instance
4216
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4218
test_store_builder_registry = registry.Registry()
4220
# The registered object should be a callable receiving a test instance
4221
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4223
test_stack_builder_registry = registry.Registry()
added
removed
breezy/config.py
