1
# Copyright (C) 2005-2012 Canonical Ltd
2
# Authors: Robert Collins <robert.collins@canonical.com>
5
# This program is free software; you can redistribute it and/or modify
6
# it under the terms of the GNU General Public License as published by
7
# the Free Software Foundation; either version 2 of the License, or
8
# (at your option) any later version.
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
# GNU General Public License for more details.
15
# You should have received a copy of the GNU General Public License
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
"""Configuration that affects the behaviour of Bazaar.
21
Currently this configuration resides in ~/.bazaar/bazaar.conf
22
and ~/.bazaar/locations.conf, which is written to by bzr.
24
In bazaar.conf the following options may be set:
26
editor=name-of-program
27
email=Your Name <your@email.address>
28
check_signatures=require|ignore|check-available(default)
29
create_signatures=always|never|when-required(default)
30
gpg_signing_command=name-of-program
31
log_format=name-of-format
32
validate_signatures_in_log=true|false(default)
33
acceptable_keys=pattern1,pattern2
34
gpg_signing_key=amy@example.com
36
in locations.conf, you specify the url of a branch and options for it.
37
Wildcards may be used - * and ? as normal in shell completion. Options
38
set in both bazaar.conf and locations.conf are overridden by the locations.conf
40
[/home/robertc/source]
41
recurse=False|True(default)
43
check_signatures= as above
44
create_signatures= as above.
45
validate_signatures_in_log=as above
46
acceptable_keys=as above
48
explanation of options
49
----------------------
50
editor - this option sets the pop up editor to use during commits.
51
email - this option sets the user id bzr will use when committing.
52
check_signatures - this option will control whether bzr will require good gpg
53
signatures, ignore them, or check them if they are
54
present. Currently it is unused except that check_signatures
55
turns on create_signatures.
56
create_signatures - this option controls whether bzr will always create
57
gpg signatures or not on commits. There is an unused
58
option which in future is expected to work if
59
branch settings require signatures.
60
log_format - this option sets the default log format. Possible values are
61
long, short, line, or a plugin can register new formats.
62
validate_signatures_in_log - show GPG signature validity in log output
63
acceptable_keys - comma separated list of key patterns acceptable for
64
verify-signatures command
66
In bazaar.conf you can also define aliases in the ALIASES sections, example
69
lastlog=log --line -r-10..-1
70
ll=log --line -r-10..-1
75
from __future__ import absolute_import
76
from cStringIO import StringIO
81
from bzrlib.decorators import needs_write_lock
82
from bzrlib.lazy_import import lazy_import
83
lazy_import(globals(), """
106
from bzrlib.i18n import gettext
107
from bzrlib.util.configobj import configobj
115
from bzrlib.symbol_versioning import (
133
POLICY_APPENDPATH = 2
137
POLICY_NORECURSE: 'norecurse',
138
POLICY_APPENDPATH: 'appendpath',
143
'norecurse': POLICY_NORECURSE,
144
'appendpath': POLICY_APPENDPATH,
148
STORE_LOCATION = POLICY_NONE
149
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
150
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
155
def signature_policy_from_unicode(signature_string):
156
"""Convert a string to a signing policy."""
157
if signature_string.lower() == 'check-available':
158
return CHECK_IF_POSSIBLE
159
if signature_string.lower() == 'ignore':
161
if signature_string.lower() == 'require':
163
raise ValueError("Invalid signatures policy '%s'"
167
def signing_policy_from_unicode(signature_string):
168
"""Convert a string to a signing policy."""
169
if signature_string.lower() == 'when-required':
170
return SIGN_WHEN_REQUIRED
171
if signature_string.lower() == 'never':
173
if signature_string.lower() == 'always':
175
raise ValueError("Invalid signing policy '%s'"
179
class ConfigObj(configobj.ConfigObj):
181
def __init__(self, infile=None, **kwargs):
182
# We define our own interpolation mechanism calling it option expansion
183
super(ConfigObj, self).__init__(infile=infile,
187
def get_bool(self, section, key):
188
return self[section].as_bool(key)
190
def get_value(self, section, name):
191
# Try [] for the old DEFAULT section.
192
if section == "DEFAULT":
197
return self[section][name]
200
class Config(object):
201
"""A configuration policy - what username, editor, gpg needs etc."""
204
super(Config, self).__init__()
207
"""Returns a unique ID for the config."""
208
raise NotImplementedError(self.config_id)
210
def get_change_editor(self, old_tree, new_tree):
211
from bzrlib import diff
212
cmd = self._get_change_editor()
215
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
218
def _get_signature_checking(self):
219
"""Template method to override signature checking policy."""
221
def _get_signing_policy(self):
222
"""Template method to override signature creation policy."""
226
def expand_options(self, string, env=None):
227
"""Expand option references in the string in the configuration context.
229
:param string: The string containing option to expand.
231
:param env: An option dict defining additional configuration options or
232
overriding existing ones.
234
:returns: The expanded string.
236
return self._expand_options_in_string(string, env)
238
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
239
"""Expand options in a list of strings in the configuration context.
241
:param slist: A list of strings.
243
:param env: An option dict defining additional configuration options or
244
overriding existing ones.
246
:param _ref_stack: Private list containing the options being
247
expanded to detect loops.
249
:returns: The flatten list of expanded strings.
251
# expand options in each value separately flattening lists
254
value = self._expand_options_in_string(s, env, _ref_stack)
255
if isinstance(value, list):
261
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
262
"""Expand options in the string in the configuration context.
264
:param string: The string to be expanded.
266
:param env: An option dict defining additional configuration options or
267
overriding existing ones.
269
:param _ref_stack: Private list containing the options being
270
expanded to detect loops.
272
:returns: The expanded string.
275
# Not much to expand there
277
if _ref_stack is None:
278
# What references are currently resolved (to detect loops)
280
if self.option_ref_re is None:
281
# We want to match the most embedded reference first (i.e. for
282
# '{{foo}}' we will get '{foo}',
283
# for '{bar{baz}}' we will get '{baz}'
284
self.option_ref_re = re.compile('({[^{}]+})')
286
# We need to iterate until no more refs appear ({{foo}} will need two
287
# iterations for example).
289
raw_chunks = self.option_ref_re.split(result)
290
if len(raw_chunks) == 1:
291
# Shorcut the trivial case: no refs
295
# Split will isolate refs so that every other chunk is a ref
297
for chunk in raw_chunks:
300
# Keep only non-empty strings (or we get bogus empty
301
# slots when a list value is involved).
306
if name in _ref_stack:
307
raise errors.OptionExpansionLoop(string, _ref_stack)
308
_ref_stack.append(name)
309
value = self._expand_option(name, env, _ref_stack)
311
raise errors.ExpandingUnknownOption(name, string)
312
if isinstance(value, list):
320
# Once a list appears as the result of an expansion, all
321
# callers will get a list result. This allows a consistent
322
# behavior even when some options in the expansion chain
323
# defined as strings (no comma in their value) but their
324
# expanded value is a list.
325
return self._expand_options_in_list(chunks, env, _ref_stack)
327
result = ''.join(chunks)
330
def _expand_option(self, name, env, _ref_stack):
331
if env is not None and name in env:
332
# Special case, values provided in env takes precedence over
336
# FIXME: This is a limited implementation, what we really need is a
337
# way to query the bzr config for the value of an option,
338
# respecting the scope rules (That is, once we implement fallback
339
# configs, getting the option value should restart from the top
340
# config, not the current one) -- vila 20101222
341
value = self.get_user_option(name, expand=False)
342
if isinstance(value, list):
343
value = self._expand_options_in_list(value, env, _ref_stack)
345
value = self._expand_options_in_string(value, env, _ref_stack)
348
def _get_user_option(self, option_name):
349
"""Template method to provide a user option."""
352
def get_user_option(self, option_name, expand=True):
353
"""Get a generic option - no special process, no default.
355
:param option_name: The queried option.
357
:param expand: Whether options references should be expanded.
359
:returns: The value of the option.
361
value = self._get_user_option(option_name)
363
if isinstance(value, list):
364
value = self._expand_options_in_list(value)
365
elif isinstance(value, dict):
366
trace.warning('Cannot expand "%s":'
367
' Dicts do not support option expansion'
370
value = self._expand_options_in_string(value)
371
for hook in OldConfigHooks['get']:
372
hook(self, option_name, value)
375
def get_user_option_as_bool(self, option_name, expand=None, default=None):
376
"""Get a generic option as a boolean.
378
:param expand: Allow expanding references to other config values.
379
:param default: Default value if nothing is configured
380
:return None if the option doesn't exist or its value can't be
381
interpreted as a boolean. Returns True or False otherwise.
383
s = self.get_user_option(option_name, expand=expand)
385
# The option doesn't exist
387
val = ui.bool_from_string(s)
389
# The value can't be interpreted as a boolean
390
trace.warning('Value "%s" is not a boolean for "%s"',
394
def get_user_option_as_list(self, option_name, expand=None):
395
"""Get a generic option as a list - no special process, no default.
397
:return None if the option doesn't exist. Returns the value as a list
400
l = self.get_user_option(option_name, expand=expand)
401
if isinstance(l, (str, unicode)):
402
# A single value, most probably the user forgot (or didn't care to
407
@deprecated_method(deprecated_in((2, 5, 0)))
408
def get_user_option_as_int_from_SI(self, option_name, default=None):
409
"""Get a generic option from a human readable size in SI units, e.g 10MB
411
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
412
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
415
:return Integer, expanded to its base-10 value if a proper SI unit is
416
found. If the option doesn't exist, or isn't a value in
417
SI units, return default (which defaults to None)
419
val = self.get_user_option(option_name)
420
if isinstance(val, list):
425
p = re.compile("^(\d+)([kmg])*b*$", re.IGNORECASE)
429
val = int(m.group(1))
430
if m.group(2) is not None:
431
if m.group(2).lower() == 'k':
433
elif m.group(2).lower() == 'm':
435
elif m.group(2).lower() == 'g':
438
ui.ui_factory.show_warning(gettext('Invalid config value for "{0}" '
439
' value {1!r} is not an SI unit.').format(
446
@deprecated_method(deprecated_in((2, 5, 0)))
447
def gpg_signing_command(self):
448
"""What program should be used to sign signatures?"""
449
result = self._gpg_signing_command()
454
def _gpg_signing_command(self):
455
"""See gpg_signing_command()."""
458
@deprecated_method(deprecated_in((2, 5, 0)))
459
def log_format(self):
460
"""What log format should be used"""
461
result = self._log_format()
466
def _log_format(self):
467
"""See log_format()."""
470
def validate_signatures_in_log(self):
471
"""Show GPG signature validity in log"""
472
result = self._validate_signatures_in_log()
479
def _validate_signatures_in_log(self):
480
"""See validate_signatures_in_log()."""
483
@deprecated_method(deprecated_in((2, 5, 0)))
484
def acceptable_keys(self):
485
"""Comma separated list of key patterns acceptable to
486
verify-signatures command"""
487
result = self._acceptable_keys()
490
def _acceptable_keys(self):
491
"""See acceptable_keys()."""
494
@deprecated_method(deprecated_in((2, 5, 0)))
495
def post_commit(self):
496
"""An ordered list of python functions to call.
498
Each function takes branch, rev_id as parameters.
500
return self._post_commit()
502
def _post_commit(self):
503
"""See Config.post_commit."""
506
def user_email(self):
507
"""Return just the email component of a username."""
508
return extract_email_address(self.username())
511
"""Return email-style username.
513
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
515
$BZR_EMAIL can be set to override this, then
516
the concrete policy type is checked, and finally
518
If no username can be found, errors.NoWhoami exception is raised.
520
v = os.environ.get('BZR_EMAIL')
522
return v.decode(osutils.get_user_encoding())
523
v = self._get_user_id()
526
return default_email()
528
def ensure_username(self):
529
"""Raise errors.NoWhoami if username is not set.
531
This method relies on the username() function raising the error.
535
@deprecated_method(deprecated_in((2, 5, 0)))
536
def signature_checking(self):
537
"""What is the current policy for signature checking?."""
538
policy = self._get_signature_checking()
539
if policy is not None:
541
return CHECK_IF_POSSIBLE
543
@deprecated_method(deprecated_in((2, 5, 0)))
544
def signing_policy(self):
545
"""What is the current policy for signature checking?."""
546
policy = self._get_signing_policy()
547
if policy is not None:
549
return SIGN_WHEN_REQUIRED
551
@deprecated_method(deprecated_in((2, 5, 0)))
552
def signature_needed(self):
553
"""Is a signature needed when committing ?."""
554
policy = self._get_signing_policy()
556
policy = self._get_signature_checking()
557
if policy is not None:
558
#this warning should go away once check_signatures is
559
#implemented (if not before)
560
trace.warning("Please use create_signatures,"
561
" not check_signatures to set signing policy.")
562
elif policy == SIGN_ALWAYS:
566
@deprecated_method(deprecated_in((2, 5, 0)))
567
def gpg_signing_key(self):
568
"""GPG user-id to sign commits"""
569
key = self.get_user_option('gpg_signing_key')
570
if key == "default" or key == None:
571
return self.user_email()
575
def get_alias(self, value):
576
return self._get_alias(value)
578
def _get_alias(self, value):
581
def get_nickname(self):
582
return self._get_nickname()
584
def _get_nickname(self):
587
def get_bzr_remote_path(self):
589
return os.environ['BZR_REMOTE_PATH']
591
path = self.get_user_option("bzr_remote_path")
596
def suppress_warning(self, warning):
597
"""Should the warning be suppressed or emitted.
599
:param warning: The name of the warning being tested.
601
:returns: True if the warning should be suppressed, False otherwise.
603
warnings = self.get_user_option_as_list('suppress_warnings')
604
if warnings is None or warning not in warnings:
609
def get_merge_tools(self):
611
for (oname, value, section, conf_id, parser) in self._get_options():
612
if oname.startswith('bzr.mergetool.'):
613
tool_name = oname[len('bzr.mergetool.'):]
614
tools[tool_name] = self.get_user_option(oname, False)
615
trace.mutter('loaded merge tools: %r' % tools)
618
def find_merge_tool(self, name):
619
# We fake a defaults mechanism here by checking if the given name can
620
# be found in the known_merge_tools if it's not found in the config.
621
# This should be done through the proposed config defaults mechanism
622
# when it becomes available in the future.
623
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
625
or mergetools.known_merge_tools.get(name, None))
629
class _ConfigHooks(hooks.Hooks):
630
"""A dict mapping hook names and a list of callables for configs.
634
"""Create the default hooks.
636
These are all empty initially, because by default nothing should get
639
super(_ConfigHooks, self).__init__('bzrlib.config', 'ConfigHooks')
640
self.add_hook('load',
641
'Invoked when a config store is loaded.'
642
' The signature is (store).',
644
self.add_hook('save',
645
'Invoked when a config store is saved.'
646
' The signature is (store).',
648
# The hooks for config options
650
'Invoked when a config option is read.'
651
' The signature is (stack, name, value).',
654
'Invoked when a config option is set.'
655
' The signature is (stack, name, value).',
657
self.add_hook('remove',
658
'Invoked when a config option is removed.'
659
' The signature is (stack, name).',
661
ConfigHooks = _ConfigHooks()
664
class _OldConfigHooks(hooks.Hooks):
665
"""A dict mapping hook names and a list of callables for configs.
669
"""Create the default hooks.
671
These are all empty initially, because by default nothing should get
674
super(_OldConfigHooks, self).__init__('bzrlib.config', 'OldConfigHooks')
675
self.add_hook('load',
676
'Invoked when a config store is loaded.'
677
' The signature is (config).',
679
self.add_hook('save',
680
'Invoked when a config store is saved.'
681
' The signature is (config).',
683
# The hooks for config options
685
'Invoked when a config option is read.'
686
' The signature is (config, name, value).',
689
'Invoked when a config option is set.'
690
' The signature is (config, name, value).',
692
self.add_hook('remove',
693
'Invoked when a config option is removed.'
694
' The signature is (config, name).',
696
OldConfigHooks = _OldConfigHooks()
699
class IniBasedConfig(Config):
700
"""A configuration policy that draws from ini files."""
702
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
704
"""Base class for configuration files using an ini-like syntax.
706
:param file_name: The configuration file path.
708
super(IniBasedConfig, self).__init__()
709
self.file_name = file_name
710
if symbol_versioning.deprecated_passed(get_filename):
711
symbol_versioning.warn(
712
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
713
' Use file_name instead.',
716
if get_filename is not None:
717
self.file_name = get_filename()
719
self.file_name = file_name
724
def from_string(cls, str_or_unicode, file_name=None, save=False):
725
"""Create a config object from a string.
727
:param str_or_unicode: A string representing the file content. This will
730
:param file_name: The configuration file path.
732
:param _save: Whether the file should be saved upon creation.
734
conf = cls(file_name=file_name)
735
conf._create_from_string(str_or_unicode, save)
738
def _create_from_string(self, str_or_unicode, save):
739
self._content = StringIO(str_or_unicode.encode('utf-8'))
740
# Some tests use in-memory configs, some other always need the config
741
# file to exist on disk.
743
self._write_config_file()
745
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
746
if self._parser is not None:
748
if symbol_versioning.deprecated_passed(file):
749
symbol_versioning.warn(
750
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
751
' Use IniBasedConfig(_content=xxx) instead.',
754
if self._content is not None:
755
co_input = self._content
756
elif self.file_name is None:
757
raise AssertionError('We have no content to create the config')
759
co_input = self.file_name
761
self._parser = ConfigObj(co_input, encoding='utf-8')
762
except configobj.ConfigObjError, e:
763
raise errors.ParseConfigError(e.errors, e.config.filename)
764
except UnicodeDecodeError:
765
raise errors.ConfigContentError(self.file_name)
766
# Make sure self.reload() will use the right file name
767
self._parser.filename = self.file_name
768
for hook in OldConfigHooks['load']:
773
"""Reload the config file from disk."""
774
if self.file_name is None:
775
raise AssertionError('We need a file name to reload the config')
776
if self._parser is not None:
777
self._parser.reload()
778
for hook in ConfigHooks['load']:
781
def _get_matching_sections(self):
782
"""Return an ordered list of (section_name, extra_path) pairs.
784
If the section contains inherited configuration, extra_path is
785
a string containing the additional path components.
787
section = self._get_section()
788
if section is not None:
789
return [(section, '')]
793
def _get_section(self):
794
"""Override this to define the section used by the config."""
797
def _get_sections(self, name=None):
798
"""Returns an iterator of the sections specified by ``name``.
800
:param name: The section name. If None is supplied, the default
801
configurations are yielded.
803
:return: A tuple (name, section, config_id) for all sections that will
804
be walked by user_get_option() in the 'right' order. The first one
805
is where set_user_option() will update the value.
807
parser = self._get_parser()
809
yield (name, parser[name], self.config_id())
811
# No section name has been given so we fallback to the configobj
812
# itself which holds the variables defined outside of any section.
813
yield (None, parser, self.config_id())
815
def _get_options(self, sections=None):
816
"""Return an ordered list of (name, value, section, config_id) tuples.
818
All options are returned with their associated value and the section
819
they appeared in. ``config_id`` is a unique identifier for the
820
configuration file the option is defined in.
822
:param sections: Default to ``_get_matching_sections`` if not
823
specified. This gives a better control to daughter classes about
824
which sections should be searched. This is a list of (name,
829
parser = self._get_parser()
831
for (section_name, _) in self._get_matching_sections():
833
section = parser[section_name]
835
# This could happen for an empty file for which we define a
836
# DEFAULT section. FIXME: Force callers to provide sections
837
# instead ? -- vila 20100930
839
sections.append((section_name, section))
840
config_id = self.config_id()
841
for (section_name, section) in sections:
842
for (name, value) in section.iteritems():
843
yield (name, parser._quote(value), section_name,
846
def _get_option_policy(self, section, option_name):
847
"""Return the policy for the given (section, option_name) pair."""
850
def _get_change_editor(self):
851
return self.get_user_option('change_editor')
853
def _get_signature_checking(self):
854
"""See Config._get_signature_checking."""
855
policy = self._get_user_option('check_signatures')
857
return signature_policy_from_unicode(policy)
859
def _get_signing_policy(self):
860
"""See Config._get_signing_policy"""
861
policy = self._get_user_option('create_signatures')
863
return signing_policy_from_unicode(policy)
865
def _get_user_id(self):
866
"""Get the user id from the 'email' key in the current section."""
867
return self._get_user_option('email')
869
def _get_user_option(self, option_name):
870
"""See Config._get_user_option."""
871
for (section, extra_path) in self._get_matching_sections():
873
value = self._get_parser().get_value(section, option_name)
876
policy = self._get_option_policy(section, option_name)
877
if policy == POLICY_NONE:
879
elif policy == POLICY_NORECURSE:
880
# norecurse items only apply to the exact path
885
elif policy == POLICY_APPENDPATH:
887
value = urlutils.join(value, extra_path)
890
raise AssertionError('Unexpected config policy %r' % policy)
894
def _gpg_signing_command(self):
895
"""See Config.gpg_signing_command."""
896
return self._get_user_option('gpg_signing_command')
898
def _log_format(self):
899
"""See Config.log_format."""
900
return self._get_user_option('log_format')
902
def _validate_signatures_in_log(self):
903
"""See Config.validate_signatures_in_log."""
904
return self._get_user_option('validate_signatures_in_log')
906
def _acceptable_keys(self):
907
"""See Config.acceptable_keys."""
908
return self._get_user_option('acceptable_keys')
910
def _post_commit(self):
911
"""See Config.post_commit."""
912
return self._get_user_option('post_commit')
914
def _get_alias(self, value):
916
return self._get_parser().get_value("ALIASES",
921
def _get_nickname(self):
922
return self.get_user_option('nickname')
924
def remove_user_option(self, option_name, section_name=None):
925
"""Remove a user option and save the configuration file.
927
:param option_name: The option to be removed.
929
:param section_name: The section the option is defined in, default to
933
parser = self._get_parser()
934
if section_name is None:
937
section = parser[section_name]
939
del section[option_name]
941
raise errors.NoSuchConfigOption(option_name)
942
self._write_config_file()
943
for hook in OldConfigHooks['remove']:
944
hook(self, option_name)
946
def _write_config_file(self):
947
if self.file_name is None:
948
raise AssertionError('We cannot save, self.file_name is None')
949
conf_dir = os.path.dirname(self.file_name)
950
ensure_config_dir_exists(conf_dir)
951
atomic_file = atomicfile.AtomicFile(self.file_name)
952
self._get_parser().write(atomic_file)
955
osutils.copy_ownership_from_path(self.file_name)
956
for hook in OldConfigHooks['save']:
960
class LockableConfig(IniBasedConfig):
961
"""A configuration needing explicit locking for access.
963
If several processes try to write the config file, the accesses need to be
966
Daughter classes should decorate all methods that update a config with the
967
``@needs_write_lock`` decorator (they call, directly or indirectly, the
968
``_write_config_file()`` method. These methods (typically ``set_option()``
969
and variants must reload the config file from disk before calling
970
``_write_config_file()``), this can be achieved by calling the
971
``self.reload()`` method. Note that the lock scope should cover both the
972
reading and the writing of the config file which is why the decorator can't
973
be applied to ``_write_config_file()`` only.
975
This should be enough to implement the following logic:
976
- lock for exclusive write access,
977
- reload the config file from disk,
981
This logic guarantees that a writer can update a value without erasing an
982
update made by another writer.
987
def __init__(self, file_name):
988
super(LockableConfig, self).__init__(file_name=file_name)
989
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
990
# FIXME: It doesn't matter that we don't provide possible_transports
991
# below since this is currently used only for local config files ;
992
# local transports are not shared. But if/when we start using
993
# LockableConfig for other kind of transports, we will need to reuse
994
# whatever connection is already established -- vila 20100929
995
self.transport = transport.get_transport_from_path(self.dir)
996
self._lock = lockdir.LockDir(self.transport, self.lock_name)
998
def _create_from_string(self, unicode_bytes, save):
999
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
1001
# We need to handle the saving here (as opposed to IniBasedConfig)
1002
# to be able to lock
1004
self._write_config_file()
1007
def lock_write(self, token=None):
1008
"""Takes a write lock in the directory containing the config file.
1010
If the directory doesn't exist it is created.
1012
ensure_config_dir_exists(self.dir)
1013
return self._lock.lock_write(token)
1018
def break_lock(self):
1019
self._lock.break_lock()
1022
def remove_user_option(self, option_name, section_name=None):
1023
super(LockableConfig, self).remove_user_option(option_name,
1026
def _write_config_file(self):
1027
if self._lock is None or not self._lock.is_held:
1028
# NB: if the following exception is raised it probably means a
1029
# missing @needs_write_lock decorator on one of the callers.
1030
raise errors.ObjectNotLocked(self)
1031
super(LockableConfig, self)._write_config_file()
1034
class GlobalConfig(LockableConfig):
1035
"""The configuration that should be used for a specific location."""
1038
super(GlobalConfig, self).__init__(file_name=config_filename())
1040
def config_id(self):
1044
def from_string(cls, str_or_unicode, save=False):
1045
"""Create a config object from a string.
1047
:param str_or_unicode: A string representing the file content. This
1048
will be utf-8 encoded.
1050
:param save: Whether the file should be saved upon creation.
1053
conf._create_from_string(str_or_unicode, save)
1057
def set_user_option(self, option, value):
1058
"""Save option and its value in the configuration."""
1059
self._set_option(option, value, 'DEFAULT')
1061
def get_aliases(self):
1062
"""Return the aliases section."""
1063
if 'ALIASES' in self._get_parser():
1064
return self._get_parser()['ALIASES']
1069
def set_alias(self, alias_name, alias_command):
1070
"""Save the alias in the configuration."""
1071
self._set_option(alias_name, alias_command, 'ALIASES')
1074
def unset_alias(self, alias_name):
1075
"""Unset an existing alias."""
1077
aliases = self._get_parser().get('ALIASES')
1078
if not aliases or alias_name not in aliases:
1079
raise errors.NoSuchAlias(alias_name)
1080
del aliases[alias_name]
1081
self._write_config_file()
1083
def _set_option(self, option, value, section):
1085
self._get_parser().setdefault(section, {})[option] = value
1086
self._write_config_file()
1087
for hook in OldConfigHooks['set']:
1088
hook(self, option, value)
1090
def _get_sections(self, name=None):
1091
"""See IniBasedConfig._get_sections()."""
1092
parser = self._get_parser()
1093
# We don't give access to options defined outside of any section, we
1094
# used the DEFAULT section by... default.
1095
if name in (None, 'DEFAULT'):
1096
# This could happen for an empty file where the DEFAULT section
1097
# doesn't exist yet. So we force DEFAULT when yielding
1099
if 'DEFAULT' not in parser:
1100
parser['DEFAULT']= {}
1101
yield (name, parser[name], self.config_id())
1104
def remove_user_option(self, option_name, section_name=None):
1105
if section_name is None:
1106
# We need to force the default section.
1107
section_name = 'DEFAULT'
1108
# We need to avoid the LockableConfig implementation or we'll lock
1110
super(LockableConfig, self).remove_user_option(option_name,
1113
def _iter_for_location_by_parts(sections, location):
1114
"""Keep only the sessions matching the specified location.
1116
:param sections: An iterable of section names.
1118
:param location: An url or a local path to match against.
1120
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1121
number of path components in the section name, section is the section
1122
name and extra_path is the difference between location and the section
1125
``location`` will always be a local path and never a 'file://' url but the
1126
section names themselves can be in either form.
1128
location_parts = location.rstrip('/').split('/')
1130
for section in sections:
1131
# location is a local path if possible, so we need to convert 'file://'
1132
# urls in section names to local paths if necessary.
1134
# This also avoids having file:///path be a more exact
1135
# match than '/path'.
1137
# FIXME: This still raises an issue if a user defines both file:///path
1138
# *and* /path. Should we raise an error in this case -- vila 20110505
1140
if section.startswith('file://'):
1141
section_path = urlutils.local_path_from_url(section)
1143
section_path = section
1144
section_parts = section_path.rstrip('/').split('/')
1147
if len(section_parts) > len(location_parts):
1148
# More path components in the section, they can't match
1151
# Rely on zip truncating in length to the length of the shortest
1152
# argument sequence.
1153
names = zip(location_parts, section_parts)
1155
if not fnmatch.fnmatch(name[0], name[1]):
1160
# build the path difference between the section and the location
1161
extra_path = '/'.join(location_parts[len(section_parts):])
1162
yield section, extra_path, len(section_parts)
1165
class LocationConfig(LockableConfig):
1166
"""A configuration object that gives the policy for a location."""
1168
def __init__(self, location):
1169
super(LocationConfig, self).__init__(
1170
file_name=locations_config_filename())
1171
# local file locations are looked up by local path, rather than
1172
# by file url. This is because the config file is a user
1173
# file, and we would rather not expose the user to file urls.
1174
if location.startswith('file://'):
1175
location = urlutils.local_path_from_url(location)
1176
self.location = location
1178
def config_id(self):
1182
def from_string(cls, str_or_unicode, location, save=False):
1183
"""Create a config object from a string.
1185
:param str_or_unicode: A string representing the file content. This will
1188
:param location: The location url to filter the configuration.
1190
:param save: Whether the file should be saved upon creation.
1192
conf = cls(location)
1193
conf._create_from_string(str_or_unicode, save)
1196
def _get_matching_sections(self):
1197
"""Return an ordered list of section names matching this location."""
1198
matches = list(_iter_for_location_by_parts(self._get_parser(),
1200
# put the longest (aka more specific) locations first
1202
key=lambda (section, extra_path, length): (length, section),
1204
for (section, extra_path, length) in matches:
1205
yield section, extra_path
1206
# should we stop looking for parent configs here?
1208
if self._get_parser()[section].as_bool('ignore_parents'):
1213
def _get_sections(self, name=None):
1214
"""See IniBasedConfig._get_sections()."""
1215
# We ignore the name here as the only sections handled are named with
1216
# the location path and we don't expose embedded sections either.
1217
parser = self._get_parser()
1218
for name, extra_path in self._get_matching_sections():
1219
yield (name, parser[name], self.config_id())
1221
def _get_option_policy(self, section, option_name):
1222
"""Return the policy for the given (section, option_name) pair."""
1223
# check for the old 'recurse=False' flag
1225
recurse = self._get_parser()[section].as_bool('recurse')
1229
return POLICY_NORECURSE
1231
policy_key = option_name + ':policy'
1233
policy_name = self._get_parser()[section][policy_key]
1237
return _policy_value[policy_name]
1239
def _set_option_policy(self, section, option_name, option_policy):
1240
"""Set the policy for the given option name in the given section."""
1241
# The old recurse=False option affects all options in the
1242
# section. To handle multiple policies in the section, we
1243
# need to convert it to a policy_norecurse key.
1245
recurse = self._get_parser()[section].as_bool('recurse')
1249
symbol_versioning.warn(
1250
'The recurse option is deprecated as of 0.14. '
1251
'The section "%s" has been converted to use policies.'
1254
del self._get_parser()[section]['recurse']
1256
for key in self._get_parser()[section].keys():
1257
if not key.endswith(':policy'):
1258
self._get_parser()[section][key +
1259
':policy'] = 'norecurse'
1261
policy_key = option_name + ':policy'
1262
policy_name = _policy_name[option_policy]
1263
if policy_name is not None:
1264
self._get_parser()[section][policy_key] = policy_name
1266
if policy_key in self._get_parser()[section]:
1267
del self._get_parser()[section][policy_key]
1270
def set_user_option(self, option, value, store=STORE_LOCATION):
1271
"""Save option and its value in the configuration."""
1272
if store not in [STORE_LOCATION,
1273
STORE_LOCATION_NORECURSE,
1274
STORE_LOCATION_APPENDPATH]:
1275
raise ValueError('bad storage policy %r for %r' %
1278
location = self.location
1279
if location.endswith('/'):
1280
location = location[:-1]
1281
parser = self._get_parser()
1282
if not location in parser and not location + '/' in parser:
1283
parser[location] = {}
1284
elif location + '/' in parser:
1285
location = location + '/'
1286
parser[location][option]=value
1287
# the allowed values of store match the config policies
1288
self._set_option_policy(location, option, store)
1289
self._write_config_file()
1290
for hook in OldConfigHooks['set']:
1291
hook(self, option, value)
1294
class BranchConfig(Config):
1295
"""A configuration object giving the policy for a branch."""
1297
def __init__(self, branch):
1298
super(BranchConfig, self).__init__()
1299
self._location_config = None
1300
self._branch_data_config = None
1301
self._global_config = None
1302
self.branch = branch
1303
self.option_sources = (self._get_location_config,
1304
self._get_branch_data_config,
1305
self._get_global_config)
1307
def config_id(self):
1310
def _get_branch_data_config(self):
1311
if self._branch_data_config is None:
1312
self._branch_data_config = TreeConfig(self.branch)
1313
self._branch_data_config.config_id = self.config_id
1314
return self._branch_data_config
1316
def _get_location_config(self):
1317
if self._location_config is None:
1318
self._location_config = LocationConfig(self.branch.base)
1319
return self._location_config
1321
def _get_global_config(self):
1322
if self._global_config is None:
1323
self._global_config = GlobalConfig()
1324
return self._global_config
1326
def _get_best_value(self, option_name):
1327
"""This returns a user option from local, tree or global config.
1329
They are tried in that order. Use get_safe_value if trusted values
1332
for source in self.option_sources:
1333
value = getattr(source(), option_name)()
1334
if value is not None:
1338
def _get_safe_value(self, option_name):
1339
"""This variant of get_best_value never returns untrusted values.
1341
It does not return values from the branch data, because the branch may
1342
not be controlled by the user.
1344
We may wish to allow locations.conf to control whether branches are
1345
trusted in the future.
1347
for source in (self._get_location_config, self._get_global_config):
1348
value = getattr(source(), option_name)()
1349
if value is not None:
1353
def _get_user_id(self):
1354
"""Return the full user id for the branch.
1356
e.g. "John Hacker <jhacker@example.com>"
1357
This is looked up in the email controlfile for the branch.
1359
return self._get_best_value('_get_user_id')
1361
def _get_change_editor(self):
1362
return self._get_best_value('_get_change_editor')
1364
def _get_signature_checking(self):
1365
"""See Config._get_signature_checking."""
1366
return self._get_best_value('_get_signature_checking')
1368
def _get_signing_policy(self):
1369
"""See Config._get_signing_policy."""
1370
return self._get_best_value('_get_signing_policy')
1372
def _get_user_option(self, option_name):
1373
"""See Config._get_user_option."""
1374
for source in self.option_sources:
1375
value = source()._get_user_option(option_name)
1376
if value is not None:
1380
def _get_sections(self, name=None):
1381
"""See IniBasedConfig.get_sections()."""
1382
for source in self.option_sources:
1383
for section in source()._get_sections(name):
1386
def _get_options(self, sections=None):
1388
# First the locations options
1389
for option in self._get_location_config()._get_options():
1391
# Then the branch options
1392
branch_config = self._get_branch_data_config()
1393
if sections is None:
1394
sections = [('DEFAULT', branch_config._get_parser())]
1395
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1396
# Config itself has no notion of sections :( -- vila 20101001
1397
config_id = self.config_id()
1398
for (section_name, section) in sections:
1399
for (name, value) in section.iteritems():
1400
yield (name, value, section_name,
1401
config_id, branch_config._get_parser())
1402
# Then the global options
1403
for option in self._get_global_config()._get_options():
1406
def set_user_option(self, name, value, store=STORE_BRANCH,
1408
if store == STORE_BRANCH:
1409
self._get_branch_data_config().set_option(value, name)
1410
elif store == STORE_GLOBAL:
1411
self._get_global_config().set_user_option(name, value)
1413
self._get_location_config().set_user_option(name, value, store)
1416
if store in (STORE_GLOBAL, STORE_BRANCH):
1417
mask_value = self._get_location_config().get_user_option(name)
1418
if mask_value is not None:
1419
trace.warning('Value "%s" is masked by "%s" from'
1420
' locations.conf', value, mask_value)
1422
if store == STORE_GLOBAL:
1423
branch_config = self._get_branch_data_config()
1424
mask_value = branch_config.get_user_option(name)
1425
if mask_value is not None:
1426
trace.warning('Value "%s" is masked by "%s" from'
1427
' branch.conf', value, mask_value)
1429
def remove_user_option(self, option_name, section_name=None):
1430
self._get_branch_data_config().remove_option(option_name, section_name)
1432
def _gpg_signing_command(self):
1433
"""See Config.gpg_signing_command."""
1434
return self._get_safe_value('_gpg_signing_command')
1436
def _post_commit(self):
1437
"""See Config.post_commit."""
1438
return self._get_safe_value('_post_commit')
1440
def _get_nickname(self):
1441
value = self._get_explicit_nickname()
1442
if value is not None:
1444
if self.branch.name:
1445
return self.branch.name
1446
return urlutils.unescape(self.branch.base.split('/')[-2])
1448
def has_explicit_nickname(self):
1449
"""Return true if a nickname has been explicitly assigned."""
1450
return self._get_explicit_nickname() is not None
1452
def _get_explicit_nickname(self):
1453
return self._get_best_value('_get_nickname')
1455
def _log_format(self):
1456
"""See Config.log_format."""
1457
return self._get_best_value('_log_format')
1459
def _validate_signatures_in_log(self):
1460
"""See Config.validate_signatures_in_log."""
1461
return self._get_best_value('_validate_signatures_in_log')
1463
def _acceptable_keys(self):
1464
"""See Config.acceptable_keys."""
1465
return self._get_best_value('_acceptable_keys')
1468
def ensure_config_dir_exists(path=None):
1469
"""Make sure a configuration directory exists.
1470
This makes sure that the directory exists.
1471
On windows, since configuration directories are 2 levels deep,
1472
it makes sure both the directory and the parent directory exists.
1476
if not os.path.isdir(path):
1477
if sys.platform == 'win32':
1478
parent_dir = os.path.dirname(path)
1479
if not os.path.isdir(parent_dir):
1480
trace.mutter('creating config parent directory: %r', parent_dir)
1481
os.mkdir(parent_dir)
1482
trace.mutter('creating config directory: %r', path)
1484
osutils.copy_ownership_from_path(path)
1488
"""Return per-user configuration directory as unicode string
1490
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1491
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1492
that will be used instead.
1494
TODO: Global option --config-dir to override this.
1496
base = osutils.path_from_environ('BZR_HOME')
1497
if sys.platform == 'win32':
1499
base = win32utils.get_appdata_location()
1501
base = win32utils.get_home_location()
1502
# GZ 2012-02-01: Really the two level subdirs only make sense inside
1503
# APPDATA, but hard to move. See bug 348640 for more.
1504
return osutils.pathjoin(base, 'bazaar', '2.0')
1506
# GZ 2012-02-01: What should OSX use instead of XDG if anything?
1507
if sys.platform != 'darwin':
1508
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1510
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1511
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1512
if osutils.isdir(xdg_dir):
1514
"Using configuration in XDG directory %s." % xdg_dir)
1516
base = osutils._get_home_dir()
1517
return osutils.pathjoin(base, ".bazaar")
1520
def config_filename():
1521
"""Return per-user configuration ini file filename."""
1522
return osutils.pathjoin(config_dir(), 'bazaar.conf')
1525
def locations_config_filename():
1526
"""Return per-user configuration ini file filename."""
1527
return osutils.pathjoin(config_dir(), 'locations.conf')
1530
def authentication_config_filename():
1531
"""Return per-user authentication ini file filename."""
1532
return osutils.pathjoin(config_dir(), 'authentication.conf')
1535
def user_ignore_config_filename():
1536
"""Return the user default ignore filename"""
1537
return osutils.pathjoin(config_dir(), 'ignore')
1541
"""Return the directory name to store crash files.
1543
This doesn't implicitly create it.
1545
On Windows it's in the config directory; elsewhere it's /var/crash
1546
which may be monitored by apport. It can be overridden by
1549
if sys.platform == 'win32':
1550
return osutils.pathjoin(config_dir(), 'Crash')
1552
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1554
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1557
def xdg_cache_dir():
1558
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1559
# Possibly this should be different on Windows?
1560
e = os.environ.get('XDG_CACHE_HOME', None)
1564
return os.path.expanduser('~/.cache')
1567
def _get_default_mail_domain(mailname_file='/etc/mailname'):
1568
"""If possible, return the assumed default email domain.
1570
:returns: string mail domain, or None.
1572
if sys.platform == 'win32':
1573
# No implementation yet; patches welcome
1576
f = open(mailname_file)
1577
except (IOError, OSError), e:
1580
domain = f.readline().strip()
1586
def default_email():
1587
v = os.environ.get('BZR_EMAIL')
1589
return v.decode(osutils.get_user_encoding())
1590
v = os.environ.get('EMAIL')
1592
return v.decode(osutils.get_user_encoding())
1593
name, email = _auto_user_id()
1595
return u'%s <%s>' % (name, email)
1598
raise errors.NoWhoami()
1601
def _auto_user_id():
1602
"""Calculate automatic user identification.
1604
:returns: (realname, email), either of which may be None if they can't be
1607
Only used when none is set in the environment or the id file.
1609
This only returns an email address if we can be fairly sure the
1610
address is reasonable, ie if /etc/mailname is set on unix.
1612
This doesn't use the FQDN as the default domain because that may be
1613
slow, and it doesn't use the hostname alone because that's not normally
1614
a reasonable address.
1616
if sys.platform == 'win32':
1617
# No implementation to reliably determine Windows default mail
1618
# address; please add one.
1621
default_mail_domain = _get_default_mail_domain()
1622
if not default_mail_domain:
1628
w = pwd.getpwuid(uid)
1630
trace.mutter('no passwd entry for uid %d?' % uid)
1633
# we try utf-8 first, because on many variants (like Linux),
1634
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1635
# false positives. (many users will have their user encoding set to
1636
# latin-1, which cannot raise UnicodeError.)
1638
gecos = w.pw_gecos.decode('utf-8')
1640
except UnicodeError:
1642
encoding = osutils.get_user_encoding()
1643
gecos = w.pw_gecos.decode(encoding)
1644
except UnicodeError, e:
1645
trace.mutter("cannot decode passwd entry %s" % w)
1648
username = w.pw_name.decode(encoding)
1649
except UnicodeError, e:
1650
trace.mutter("cannot decode passwd entry %s" % w)
1653
comma = gecos.find(',')
1657
realname = gecos[:comma]
1659
return realname, (username + '@' + default_mail_domain)
1662
def parse_username(username):
1663
"""Parse e-mail username and return a (name, address) tuple."""
1664
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1666
return (username, '')
1668
return (match.group(1), match.group(2))
1671
def extract_email_address(e):
1672
"""Return just the address part of an email string.
1674
That is just the user@domain part, nothing else.
1675
This part is required to contain only ascii characters.
1676
If it can't be extracted, raises an error.
1678
>>> extract_email_address('Jane Tester <jane@test.com>')
1681
name, email = parse_username(e)
1683
raise errors.NoEmailInUsername(e)
1687
class TreeConfig(IniBasedConfig):
1688
"""Branch configuration data associated with its contents, not location"""
1690
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1692
def __init__(self, branch):
1693
self._config = branch._get_config()
1694
self.branch = branch
1696
def _get_parser(self, file=None):
1697
if file is not None:
1698
return IniBasedConfig._get_parser(file)
1699
return self._config._get_configobj()
1701
def get_option(self, name, section=None, default=None):
1702
self.branch.lock_read()
1704
return self._config.get_option(name, section, default)
1706
self.branch.unlock()
1708
def set_option(self, value, name, section=None):
1709
"""Set a per-branch configuration option"""
1710
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1711
# higher levels providing the right lock -- vila 20101004
1712
self.branch.lock_write()
1714
self._config.set_option(value, name, section)
1716
self.branch.unlock()
1718
def remove_option(self, option_name, section_name=None):
1719
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1720
# higher levels providing the right lock -- vila 20101004
1721
self.branch.lock_write()
1723
self._config.remove_option(option_name, section_name)
1725
self.branch.unlock()
1728
class AuthenticationConfig(object):
1729
"""The authentication configuration file based on a ini file.
1731
Implements the authentication.conf file described in
1732
doc/developers/authentication-ring.txt.
1735
def __init__(self, _file=None):
1736
self._config = None # The ConfigObj
1738
self._filename = authentication_config_filename()
1739
self._input = self._filename = authentication_config_filename()
1741
# Tests can provide a string as _file
1742
self._filename = None
1745
def _get_config(self):
1746
if self._config is not None:
1749
# FIXME: Should we validate something here ? Includes: empty
1750
# sections are useless, at least one of
1751
# user/password/password_encoding should be defined, etc.
1753
# Note: the encoding below declares that the file itself is utf-8
1754
# encoded, but the values in the ConfigObj are always Unicode.
1755
self._config = ConfigObj(self._input, encoding='utf-8')
1756
except configobj.ConfigObjError, e:
1757
raise errors.ParseConfigError(e.errors, e.config.filename)
1758
except UnicodeError:
1759
raise errors.ConfigContentError(self._filename)
1763
"""Save the config file, only tests should use it for now."""
1764
conf_dir = os.path.dirname(self._filename)
1765
ensure_config_dir_exists(conf_dir)
1766
f = file(self._filename, 'wb')
1768
self._get_config().write(f)
1772
def _set_option(self, section_name, option_name, value):
1773
"""Set an authentication configuration option"""
1774
conf = self._get_config()
1775
section = conf.get(section_name)
1778
section = conf[section]
1779
section[option_name] = value
1782
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1784
"""Returns the matching credentials from authentication.conf file.
1786
:param scheme: protocol
1788
:param host: the server address
1790
:param port: the associated port (optional)
1792
:param user: login (optional)
1794
:param path: the absolute path on the server (optional)
1796
:param realm: the http authentication realm (optional)
1798
:return: A dict containing the matching credentials or None.
1800
- name: the section name of the credentials in the
1801
authentication.conf file,
1802
- user: can't be different from the provided user if any,
1803
- scheme: the server protocol,
1804
- host: the server address,
1805
- port: the server port (can be None),
1806
- path: the absolute server path (can be None),
1807
- realm: the http specific authentication realm (can be None),
1808
- password: the decoded password, could be None if the credential
1809
defines only the user
1810
- verify_certificates: https specific, True if the server
1811
certificate should be verified, False otherwise.
1814
for auth_def_name, auth_def in self._get_config().items():
1815
if type(auth_def) is not configobj.Section:
1816
raise ValueError("%s defined outside a section" % auth_def_name)
1818
a_scheme, a_host, a_user, a_path = map(
1819
auth_def.get, ['scheme', 'host', 'user', 'path'])
1822
a_port = auth_def.as_int('port')
1826
raise ValueError("'port' not numeric in %s" % auth_def_name)
1828
a_verify_certificates = auth_def.as_bool('verify_certificates')
1830
a_verify_certificates = True
1833
"'verify_certificates' not boolean in %s" % auth_def_name)
1836
if a_scheme is not None and scheme != a_scheme:
1838
if a_host is not None:
1839
if not (host == a_host
1840
or (a_host.startswith('.') and host.endswith(a_host))):
1842
if a_port is not None and port != a_port:
1844
if (a_path is not None and path is not None
1845
and not path.startswith(a_path)):
1847
if (a_user is not None and user is not None
1848
and a_user != user):
1849
# Never contradict the caller about the user to be used
1854
# Prepare a credentials dictionary with additional keys
1855
# for the credential providers
1856
credentials = dict(name=auth_def_name,
1863
password=auth_def.get('password', None),
1864
verify_certificates=a_verify_certificates)
1865
# Decode the password in the credentials (or get one)
1866
self.decode_password(credentials,
1867
auth_def.get('password_encoding', None))
1868
if 'auth' in debug.debug_flags:
1869
trace.mutter("Using authentication section: %r", auth_def_name)
1872
if credentials is None:
1873
# No credentials were found in authentication.conf, try the fallback
1874
# credentials stores.
1875
credentials = credential_store_registry.get_fallback_credentials(
1876
scheme, host, port, user, path, realm)
1880
def set_credentials(self, name, host, user, scheme=None, password=None,
1881
port=None, path=None, verify_certificates=None,
1883
"""Set authentication credentials for a host.
1885
Any existing credentials with matching scheme, host, port and path
1886
will be deleted, regardless of name.
1888
:param name: An arbitrary name to describe this set of credentials.
1889
:param host: Name of the host that accepts these credentials.
1890
:param user: The username portion of these credentials.
1891
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1893
:param password: Password portion of these credentials.
1894
:param port: The IP port on the host that these credentials apply to.
1895
:param path: A filesystem path on the host that these credentials
1897
:param verify_certificates: On https, verify server certificates if
1899
:param realm: The http authentication realm (optional).
1901
values = {'host': host, 'user': user}
1902
if password is not None:
1903
values['password'] = password
1904
if scheme is not None:
1905
values['scheme'] = scheme
1906
if port is not None:
1907
values['port'] = '%d' % port
1908
if path is not None:
1909
values['path'] = path
1910
if verify_certificates is not None:
1911
values['verify_certificates'] = str(verify_certificates)
1912
if realm is not None:
1913
values['realm'] = realm
1914
config = self._get_config()
1916
for section, existing_values in config.items():
1917
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1918
if existing_values.get(key) != values.get(key):
1922
config.update({name: values})
1925
def get_user(self, scheme, host, port=None, realm=None, path=None,
1926
prompt=None, ask=False, default=None):
1927
"""Get a user from authentication file.
1929
:param scheme: protocol
1931
:param host: the server address
1933
:param port: the associated port (optional)
1935
:param realm: the realm sent by the server (optional)
1937
:param path: the absolute path on the server (optional)
1939
:param ask: Ask the user if there is no explicitly configured username
1942
:param default: The username returned if none is defined (optional).
1944
:return: The found user.
1946
credentials = self.get_credentials(scheme, host, port, user=None,
1947
path=path, realm=realm)
1948
if credentials is not None:
1949
user = credentials['user']
1955
# Create a default prompt suitable for most cases
1956
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1957
# Special handling for optional fields in the prompt
1958
if port is not None:
1959
prompt_host = '%s:%d' % (host, port)
1962
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1967
def get_password(self, scheme, host, user, port=None,
1968
realm=None, path=None, prompt=None):
1969
"""Get a password from authentication file or prompt the user for one.
1971
:param scheme: protocol
1973
:param host: the server address
1975
:param port: the associated port (optional)
1979
:param realm: the realm sent by the server (optional)
1981
:param path: the absolute path on the server (optional)
1983
:return: The found password or the one entered by the user.
1985
credentials = self.get_credentials(scheme, host, port, user, path,
1987
if credentials is not None:
1988
password = credentials['password']
1989
if password is not None and scheme is 'ssh':
1990
trace.warning('password ignored in section [%s],'
1991
' use an ssh agent instead'
1992
% credentials['name'])
1996
# Prompt user only if we could't find a password
1997
if password is None:
1999
# Create a default prompt suitable for most cases
2000
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
2001
# Special handling for optional fields in the prompt
2002
if port is not None:
2003
prompt_host = '%s:%d' % (host, port)
2006
password = ui.ui_factory.get_password(prompt,
2007
host=prompt_host, user=user)
2010
def decode_password(self, credentials, encoding):
2012
cs = credential_store_registry.get_credential_store(encoding)
2014
raise ValueError('%r is not a known password_encoding' % encoding)
2015
credentials['password'] = cs.decode_password(credentials)
2019
class CredentialStoreRegistry(registry.Registry):
2020
"""A class that registers credential stores.
2022
A credential store provides access to credentials via the password_encoding
2023
field in authentication.conf sections.
2025
Except for stores provided by bzr itself, most stores are expected to be
2026
provided by plugins that will therefore use
2027
register_lazy(password_encoding, module_name, member_name, help=help,
2028
fallback=fallback) to install themselves.
2030
A fallback credential store is one that is queried if no credentials can be
2031
found via authentication.conf.
2034
def get_credential_store(self, encoding=None):
2035
cs = self.get(encoding)
2040
def is_fallback(self, name):
2041
"""Check if the named credentials store should be used as fallback."""
2042
return self.get_info(name)
2044
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2045
path=None, realm=None):
2046
"""Request credentials from all fallback credentials stores.
2048
The first credentials store that can provide credentials wins.
2051
for name in self.keys():
2052
if not self.is_fallback(name):
2054
cs = self.get_credential_store(name)
2055
credentials = cs.get_credentials(scheme, host, port, user,
2057
if credentials is not None:
2058
# We found some credentials
2062
def register(self, key, obj, help=None, override_existing=False,
2064
"""Register a new object to a name.
2066
:param key: This is the key to use to request the object later.
2067
:param obj: The object to register.
2068
:param help: Help text for this entry. This may be a string or
2069
a callable. If it is a callable, it should take two
2070
parameters (registry, key): this registry and the key that
2071
the help was registered under.
2072
:param override_existing: Raise KeyErorr if False and something has
2073
already been registered for that key. If True, ignore if there
2074
is an existing key (always register the new value).
2075
:param fallback: Whether this credential store should be
2078
return super(CredentialStoreRegistry,
2079
self).register(key, obj, help, info=fallback,
2080
override_existing=override_existing)
2082
def register_lazy(self, key, module_name, member_name,
2083
help=None, override_existing=False,
2085
"""Register a new credential store to be loaded on request.
2087
:param module_name: The python path to the module. Such as 'os.path'.
2088
:param member_name: The member of the module to return. If empty or
2089
None, get() will return the module itself.
2090
:param help: Help text for this entry. This may be a string or
2092
:param override_existing: If True, replace the existing object
2093
with the new one. If False, if there is already something
2094
registered with the same key, raise a KeyError
2095
:param fallback: Whether this credential store should be
2098
return super(CredentialStoreRegistry, self).register_lazy(
2099
key, module_name, member_name, help,
2100
info=fallback, override_existing=override_existing)
2103
credential_store_registry = CredentialStoreRegistry()
2106
class CredentialStore(object):
2107
"""An abstract class to implement storage for credentials"""
2109
def decode_password(self, credentials):
2110
"""Returns a clear text password for the provided credentials."""
2111
raise NotImplementedError(self.decode_password)
2113
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2115
"""Return the matching credentials from this credential store.
2117
This method is only called on fallback credential stores.
2119
raise NotImplementedError(self.get_credentials)
2123
class PlainTextCredentialStore(CredentialStore):
2124
__doc__ = """Plain text credential store for the authentication.conf file"""
2126
def decode_password(self, credentials):
2127
"""See CredentialStore.decode_password."""
2128
return credentials['password']
2131
credential_store_registry.register('plain', PlainTextCredentialStore,
2132
help=PlainTextCredentialStore.__doc__)
2133
credential_store_registry.default_key = 'plain'
2136
class Base64CredentialStore(CredentialStore):
2137
__doc__ = """Base64 credential store for the authentication.conf file"""
2139
def decode_password(self, credentials):
2140
"""See CredentialStore.decode_password."""
2141
# GZ 2012-07-28: Will raise binascii.Error if password is not base64,
2142
# should probably propogate as something more useful.
2143
return base64.decodestring(credentials['password'])
2145
credential_store_registry.register('base64', Base64CredentialStore,
2146
help=Base64CredentialStore.__doc__)
2149
class BzrDirConfig(object):
2151
def __init__(self, bzrdir):
2152
self._bzrdir = bzrdir
2153
self._config = bzrdir._get_config()
2155
def set_default_stack_on(self, value):
2156
"""Set the default stacking location.
2158
It may be set to a location, or None.
2160
This policy affects all branches contained by this control dir, except
2161
for those under repositories.
2163
if self._config is None:
2164
raise errors.BzrError("Cannot set configuration in %s"
2167
self._config.set_option('', 'default_stack_on')
2169
self._config.set_option(value, 'default_stack_on')
2171
def get_default_stack_on(self):
2172
"""Return the default stacking location.
2174
This will either be a location, or None.
2176
This policy affects all branches contained by this control dir, except
2177
for those under repositories.
2179
if self._config is None:
2181
value = self._config.get_option('default_stack_on')
2187
class TransportConfig(object):
2188
"""A Config that reads/writes a config file on a Transport.
2190
It is a low-level object that considers config data to be name/value pairs
2191
that may be associated with a section. Assigning meaning to these values
2192
is done at higher levels like TreeConfig.
2195
def __init__(self, transport, filename):
2196
self._transport = transport
2197
self._filename = filename
2199
def get_option(self, name, section=None, default=None):
2200
"""Return the value associated with a named option.
2202
:param name: The name of the value
2203
:param section: The section the option is in (if any)
2204
:param default: The value to return if the value is not set
2205
:return: The value or default value
2207
configobj = self._get_configobj()
2209
section_obj = configobj
2212
section_obj = configobj[section]
2215
value = section_obj.get(name, default)
2216
for hook in OldConfigHooks['get']:
2217
hook(self, name, value)
2220
def set_option(self, value, name, section=None):
2221
"""Set the value associated with a named option.
2223
:param value: The value to set
2224
:param name: The name of the value to set
2225
:param section: The section the option is in (if any)
2227
configobj = self._get_configobj()
2229
configobj[name] = value
2231
configobj.setdefault(section, {})[name] = value
2232
for hook in OldConfigHooks['set']:
2233
hook(self, name, value)
2234
self._set_configobj(configobj)
2236
def remove_option(self, option_name, section_name=None):
2237
configobj = self._get_configobj()
2238
if section_name is None:
2239
del configobj[option_name]
2241
del configobj[section_name][option_name]
2242
for hook in OldConfigHooks['remove']:
2243
hook(self, option_name)
2244
self._set_configobj(configobj)
2246
def _get_config_file(self):
2248
f = StringIO(self._transport.get_bytes(self._filename))
2249
for hook in OldConfigHooks['load']:
2252
except errors.NoSuchFile:
2254
except errors.PermissionDenied, e:
2255
trace.warning("Permission denied while trying to open "
2256
"configuration file %s.", urlutils.unescape_for_display(
2257
urlutils.join(self._transport.base, self._filename), "utf-8"))
2260
def _external_url(self):
2261
return urlutils.join(self._transport.external_url(), self._filename)
2263
def _get_configobj(self):
2264
f = self._get_config_file()
2267
conf = ConfigObj(f, encoding='utf-8')
2268
except configobj.ConfigObjError, e:
2269
raise errors.ParseConfigError(e.errors, self._external_url())
2270
except UnicodeDecodeError:
2271
raise errors.ConfigContentError(self._external_url())
2276
def _set_configobj(self, configobj):
2277
out_file = StringIO()
2278
configobj.write(out_file)
2280
self._transport.put_file(self._filename, out_file)
2281
for hook in OldConfigHooks['save']:
2285
class Option(object):
2286
"""An option definition.
2288
The option *values* are stored in config files and found in sections.
2290
Here we define various properties about the option itself, its default
2291
value, how to convert it from stores, what to do when invalid values are
2292
encoutered, in which config files it can be stored.
2295
def __init__(self, name, override_from_env=None,
2296
default=None, default_from_env=None,
2297
help=None, from_unicode=None, invalid=None, unquote=True):
2298
"""Build an option definition.
2300
:param name: the name used to refer to the option.
2302
:param override_from_env: A list of environment variables which can
2303
provide override any configuration setting.
2305
:param default: the default value to use when none exist in the config
2306
stores. This is either a string that ``from_unicode`` will convert
2307
into the proper type, a callable returning a unicode string so that
2308
``from_unicode`` can be used on the return value, or a python
2309
object that can be stringified (so only the empty list is supported
2312
:param default_from_env: A list of environment variables which can
2313
provide a default value. 'default' will be used only if none of the
2314
variables specified here are set in the environment.
2316
:param help: a doc string to explain the option to the user.
2318
:param from_unicode: a callable to convert the unicode string
2319
representing the option value in a store or its default value.
2321
:param invalid: the action to be taken when an invalid value is
2322
encountered in a store. This is called only when from_unicode is
2323
invoked to convert a string and returns None or raise ValueError or
2324
TypeError. Accepted values are: None (ignore invalid values),
2325
'warning' (emit a warning), 'error' (emit an error message and
2328
:param unquote: should the unicode value be unquoted before conversion.
2329
This should be used only when the store providing the values cannot
2330
safely unquote them (see http://pad.lv/906897). It is provided so
2331
daughter classes can handle the quoting themselves.
2333
if override_from_env is None:
2334
override_from_env = []
2335
if default_from_env is None:
2336
default_from_env = []
2338
self.override_from_env = override_from_env
2339
# Convert the default value to a unicode string so all values are
2340
# strings internally before conversion (via from_unicode) is attempted.
2343
elif isinstance(default, list):
2344
# Only the empty list is supported
2346
raise AssertionError(
2347
'Only empty lists are supported as default values')
2349
elif isinstance(default, (str, unicode, bool, int, float)):
2350
# Rely on python to convert strings, booleans and integers
2351
self.default = u'%s' % (default,)
2352
elif callable(default):
2353
self.default = default
2355
# other python objects are not expected
2356
raise AssertionError('%r is not supported as a default value'
2358
self.default_from_env = default_from_env
2360
self.from_unicode = from_unicode
2361
self.unquote = unquote
2362
if invalid and invalid not in ('warning', 'error'):
2363
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2364
self.invalid = invalid
2370
def convert_from_unicode(self, store, unicode_value):
2371
if self.unquote and store is not None and unicode_value is not None:
2372
unicode_value = store.unquote(unicode_value)
2373
if self.from_unicode is None or unicode_value is None:
2374
# Don't convert or nothing to convert
2375
return unicode_value
2377
converted = self.from_unicode(unicode_value)
2378
except (ValueError, TypeError):
2379
# Invalid values are ignored
2381
if converted is None and self.invalid is not None:
2382
# The conversion failed
2383
if self.invalid == 'warning':
2384
trace.warning('Value "%s" is not valid for "%s"',
2385
unicode_value, self.name)
2386
elif self.invalid == 'error':
2387
raise errors.ConfigOptionValueError(self.name, unicode_value)
2390
def get_override(self):
2392
for var in self.override_from_env:
2394
# If the env variable is defined, its value takes precedence
2395
value = os.environ[var].decode(osutils.get_user_encoding())
2401
def get_default(self):
2403
for var in self.default_from_env:
2405
# If the env variable is defined, its value is the default one
2406
value = os.environ[var].decode(osutils.get_user_encoding())
2411
# Otherwise, fallback to the value defined at registration
2412
if callable(self.default):
2413
value = self.default()
2414
if not isinstance(value, unicode):
2415
raise AssertionError(
2416
"Callable default value for '%s' should be unicode"
2419
value = self.default
2422
def get_help_topic(self):
2425
def get_help_text(self, additional_see_also=None, plain=True):
2427
from bzrlib import help_topics
2428
result += help_topics._format_see_also(additional_see_also)
2430
result = help_topics.help_as_plain_text(result)
2434
# Predefined converters to get proper values from store
2436
def bool_from_store(unicode_str):
2437
return ui.bool_from_string(unicode_str)
2440
def int_from_store(unicode_str):
2441
return int(unicode_str)
2444
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2446
def int_SI_from_store(unicode_str):
2447
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2449
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2450
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2453
:return Integer, expanded to its base-10 value if a proper SI unit is
2454
found, None otherwise.
2456
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2457
p = re.compile(regexp, re.IGNORECASE)
2458
m = p.match(unicode_str)
2461
val, _, unit = m.groups()
2465
coeff = _unit_suffixes[unit.upper()]
2467
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2472
def float_from_store(unicode_str):
2473
return float(unicode_str)
2476
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2478
_list_converter_config = configobj.ConfigObj(
2479
{}, encoding='utf-8', list_values=True, interpolation=False)
2482
class ListOption(Option):
2484
def __init__(self, name, default=None, default_from_env=None,
2485
help=None, invalid=None):
2486
"""A list Option definition.
2488
This overrides the base class so the conversion from a unicode string
2489
can take quoting into account.
2491
super(ListOption, self).__init__(
2492
name, default=default, default_from_env=default_from_env,
2493
from_unicode=self.from_unicode, help=help,
2494
invalid=invalid, unquote=False)
2496
def from_unicode(self, unicode_str):
2497
if not isinstance(unicode_str, basestring):
2499
# Now inject our string directly as unicode. All callers got their
2500
# value from configobj, so values that need to be quoted are already
2502
_list_converter_config.reset()
2503
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2504
maybe_list = _list_converter_config['list']
2505
if isinstance(maybe_list, basestring):
2507
# A single value, most probably the user forgot (or didn't care
2508
# to add) the final ','
2511
# The empty string, convert to empty list
2514
# We rely on ConfigObj providing us with a list already
2519
class RegistryOption(Option):
2520
"""Option for a choice from a registry."""
2522
def __init__(self, name, registry, default_from_env=None,
2523
help=None, invalid=None):
2524
"""A registry based Option definition.
2526
This overrides the base class so the conversion from a unicode string
2527
can take quoting into account.
2529
super(RegistryOption, self).__init__(
2530
name, default=lambda: unicode(registry.default_key),
2531
default_from_env=default_from_env,
2532
from_unicode=self.from_unicode, help=help,
2533
invalid=invalid, unquote=False)
2534
self.registry = registry
2536
def from_unicode(self, unicode_str):
2537
if not isinstance(unicode_str, basestring):
2540
return self.registry.get(unicode_str)
2543
"Invalid value %s for %s."
2544
"See help for a list of possible values." % (unicode_str,
2549
ret = [self._help, "\n\nThe following values are supported:\n"]
2550
for key in self.registry.keys():
2551
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2555
_option_ref_re = lazy_regex.lazy_compile('({[^\d\W](?:\.\w|\w)*})')
2556
"""Describes an expandable option reference.
2558
We want to match the most embedded reference first.
2560
I.e. for '{{foo}}' we will get '{foo}',
2561
for '{bar{baz}}' we will get '{baz}'
2564
def iter_option_refs(string):
2565
# Split isolate refs so every other chunk is a ref
2567
for chunk in _option_ref_re.split(string):
2572
class OptionRegistry(registry.Registry):
2573
"""Register config options by their name.
2575
This overrides ``registry.Registry`` to simplify registration by acquiring
2576
some information from the option object itself.
2579
def _check_option_name(self, option_name):
2580
"""Ensures an option name is valid.
2582
:param option_name: The name to validate.
2584
if _option_ref_re.match('{%s}' % option_name) is None:
2585
raise errors.IllegalOptionName(option_name)
2587
def register(self, option):
2588
"""Register a new option to its name.
2590
:param option: The option to register. Its name is used as the key.
2592
self._check_option_name(option.name)
2593
super(OptionRegistry, self).register(option.name, option,
2596
def register_lazy(self, key, module_name, member_name):
2597
"""Register a new option to be loaded on request.
2599
:param key: the key to request the option later. Since the registration
2600
is lazy, it should be provided and match the option name.
2602
:param module_name: the python path to the module. Such as 'os.path'.
2604
:param member_name: the member of the module to return. If empty or
2605
None, get() will return the module itself.
2607
self._check_option_name(key)
2608
super(OptionRegistry, self).register_lazy(key,
2609
module_name, member_name)
2611
def get_help(self, key=None):
2612
"""Get the help text associated with the given key"""
2613
option = self.get(key)
2614
the_help = option.help
2615
if callable(the_help):
2616
return the_help(self, key)
2620
option_registry = OptionRegistry()
2623
# Registered options in lexicographical order
2625
option_registry.register(
2626
Option('append_revisions_only',
2627
default=None, from_unicode=bool_from_store, invalid='warning',
2629
Whether to only append revisions to the mainline.
2631
If this is set to true, then it is not possible to change the
2632
existing mainline of the branch.
2634
option_registry.register(
2635
ListOption('acceptable_keys',
2638
List of GPG key patterns which are acceptable for verification.
2640
option_registry.register(
2641
Option('add.maximum_file_size',
2642
default=u'20MB', from_unicode=int_SI_from_store,
2644
Size above which files should be added manually.
2646
Files below this size are added automatically when using ``bzr add`` without
2649
A negative value means disable the size check.
2651
option_registry.register(
2653
default=None, from_unicode=bool_from_store,
2655
Is the branch bound to ``bound_location``.
2657
If set to "True", the branch should act as a checkout, and push each commit to
2658
the bound_location. This option is normally set by ``bind``/``unbind``.
2660
See also: bound_location.
2662
option_registry.register(
2663
Option('bound_location',
2666
The location that commits should go to when acting as a checkout.
2668
This option is normally set by ``bind``.
2672
option_registry.register(
2673
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2675
Whether revisions associated with tags should be fetched.
2677
option_registry.register_lazy(
2678
'bzr.transform.orphan_policy', 'bzrlib.transform', 'opt_transform_orphan')
2679
option_registry.register(
2680
Option('bzr.workingtree.worth_saving_limit', default=10,
2681
from_unicode=int_from_store, invalid='warning',
2683
How many changes before saving the dirstate.
2685
-1 means that we will never rewrite the dirstate file for only
2686
stat-cache changes. Regardless of this setting, we will always rewrite
2687
the dirstate file if a file is added/removed/renamed/etc. This flag only
2688
affects the behavior of updating the dirstate file after we notice that
2689
a file has been touched.
2691
option_registry.register(
2692
Option('bugtracker', default=None,
2694
Default bug tracker to use.
2696
This bug tracker will be used for example when marking bugs
2697
as fixed using ``bzr commit --fixes``, if no explicit
2698
bug tracker was specified.
2700
option_registry.register(
2701
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2702
from_unicode=signature_policy_from_unicode,
2704
GPG checking policy.
2706
Possible values: require, ignore, check-available (default)
2708
this option will control whether bzr will require good gpg
2709
signatures, ignore them, or check them if they are
2712
option_registry.register(
2713
Option('child_submit_format',
2714
help='''The preferred format of submissions to this branch.'''))
2715
option_registry.register(
2716
Option('child_submit_to',
2717
help='''Where submissions to this branch are mailed to.'''))
2718
option_registry.register(
2719
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2720
from_unicode=signing_policy_from_unicode,
2724
Possible values: always, never, when-required (default)
2726
This option controls whether bzr will always create
2727
gpg signatures or not on commits.
2729
option_registry.register(
2730
Option('dirstate.fdatasync', default=True,
2731
from_unicode=bool_from_store,
2733
Flush dirstate changes onto physical disk?
2735
If true (default), working tree metadata changes are flushed through the
2736
OS buffers to physical disk. This is somewhat slower, but means data
2737
should not be lost if the machine crashes. See also repository.fdatasync.
2739
option_registry.register(
2740
ListOption('debug_flags', default=[],
2741
help='Debug flags to activate.'))
2742
option_registry.register(
2743
Option('default_format', default='2a',
2744
help='Format used when creating branches.'))
2745
option_registry.register(
2746
Option('dpush_strict', default=None,
2747
from_unicode=bool_from_store,
2749
The default value for ``dpush --strict``.
2751
If present, defines the ``--strict`` option default value for checking
2752
uncommitted changes before pushing into a different VCS without any
2753
custom bzr metadata.
2755
option_registry.register(
2757
help='The command called to launch an editor to enter a message.'))
2758
option_registry.register(
2759
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2760
help='The users identity'))
2761
option_registry.register(
2762
Option('gpg_signing_command',
2765
Program to use use for creating signatures.
2767
This should support at least the -u and --clearsign options.
2769
option_registry.register(
2770
Option('gpg_signing_key',
2773
GPG key to use for signing.
2775
This defaults to the first key associated with the users email.
2777
option_registry.register(
2778
Option('ignore_missing_extensions', default=False,
2779
from_unicode=bool_from_store,
2781
Control the missing extensions warning display.
2783
The warning will not be emitted if set to True.
2785
option_registry.register(
2787
help='Language to translate messages into.'))
2788
option_registry.register(
2789
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2791
Steal locks that appears to be dead.
2793
If set to True, bzr will check if a lock is supposed to be held by an
2794
active process from the same user on the same machine. If the user and
2795
machine match, but no process with the given PID is active, then bzr
2796
will automatically break the stale lock, and create a new lock for
2798
Otherwise, bzr will prompt as normal to break the lock.
2800
option_registry.register(
2801
Option('log_format', default='long',
2803
Log format to use when displaying revisions.
2805
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2806
may be provided by plugins.
2808
option_registry.register_lazy('mail_client', 'bzrlib.mail_client',
2810
option_registry.register(
2811
Option('output_encoding',
2812
help= 'Unicode encoding for output'
2813
' (terminal encoding if not specified).'))
2814
option_registry.register(
2815
Option('parent_location',
2818
The location of the default branch for pull or merge.
2820
This option is normally set when creating a branch, the first ``pull`` or by
2821
``pull --remember``.
2823
option_registry.register(
2824
Option('post_commit', default=None,
2826
Post commit functions.
2828
An ordered list of python functions to call, separated by spaces.
2830
Each function takes branch, rev_id as parameters.
2832
option_registry.register_lazy('progress_bar', 'bzrlib.ui.text',
2834
option_registry.register(
2835
Option('public_branch',
2838
A publically-accessible version of this branch.
2840
This implies that the branch setting this option is not publically-accessible.
2841
Used and set by ``bzr send``.
2843
option_registry.register(
2844
Option('push_location',
2847
The location of the default branch for push.
2849
This option is normally set by the first ``push`` or ``push --remember``.
2851
option_registry.register(
2852
Option('push_strict', default=None,
2853
from_unicode=bool_from_store,
2855
The default value for ``push --strict``.
2857
If present, defines the ``--strict`` option default value for checking
2858
uncommitted changes before sending a merge directive.
2860
option_registry.register(
2861
Option('repository.fdatasync', default=True,
2862
from_unicode=bool_from_store,
2864
Flush repository changes onto physical disk?
2866
If true (default), repository changes are flushed through the OS buffers
2867
to physical disk. This is somewhat slower, but means data should not be
2868
lost if the machine crashes. See also dirstate.fdatasync.
2870
option_registry.register_lazy('smtp_server',
2871
'bzrlib.smtp_connection', 'smtp_server')
2872
option_registry.register_lazy('smtp_password',
2873
'bzrlib.smtp_connection', 'smtp_password')
2874
option_registry.register_lazy('smtp_username',
2875
'bzrlib.smtp_connection', 'smtp_username')
2876
option_registry.register(
2877
Option('selftest.timeout',
2879
from_unicode=int_from_store,
2880
help='Abort selftest if one test takes longer than this many seconds',
2883
option_registry.register(
2884
Option('send_strict', default=None,
2885
from_unicode=bool_from_store,
2887
The default value for ``send --strict``.
2889
If present, defines the ``--strict`` option default value for checking
2890
uncommitted changes before sending a bundle.
2893
option_registry.register(
2894
Option('serve.client_timeout',
2895
default=300.0, from_unicode=float_from_store,
2896
help="If we wait for a new request from a client for more than"
2897
" X seconds, consider the client idle, and hangup."))
2898
option_registry.register(
2899
Option('stacked_on_location',
2901
help="""The location where this branch is stacked on."""))
2902
option_registry.register(
2903
Option('submit_branch',
2906
The branch you intend to submit your current work to.
2908
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2909
by the ``submit:`` revision spec.
2911
option_registry.register(
2913
help='''Where submissions from this branch are mailed to.'''))
2914
option_registry.register(
2915
ListOption('suppress_warnings',
2917
help="List of warning classes to suppress."))
2918
option_registry.register(
2919
Option('validate_signatures_in_log', default=False,
2920
from_unicode=bool_from_store, invalid='warning',
2921
help='''Whether to validate signatures in bzr log.'''))
2922
option_registry.register_lazy('ssl.ca_certs',
2923
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2925
option_registry.register_lazy('ssl.cert_reqs',
2926
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2929
class Section(object):
2930
"""A section defines a dict of option name => value.
2932
This is merely a read-only dict which can add some knowledge about the
2933
options. It is *not* a python dict object though and doesn't try to mimic
2937
def __init__(self, section_id, options):
2938
self.id = section_id
2939
# We re-use the dict-like object received
2940
self.options = options
2942
def get(self, name, default=None, expand=True):
2943
return self.options.get(name, default)
2945
def iter_option_names(self):
2946
for k in self.options.iterkeys():
2950
# Mostly for debugging use
2951
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2954
_NewlyCreatedOption = object()
2955
"""Was the option created during the MutableSection lifetime"""
2956
_DeletedOption = object()
2957
"""Was the option deleted during the MutableSection lifetime"""
2960
class MutableSection(Section):
2961
"""A section allowing changes and keeping track of the original values."""
2963
def __init__(self, section_id, options):
2964
super(MutableSection, self).__init__(section_id, options)
2965
self.reset_changes()
2967
def set(self, name, value):
2968
if name not in self.options:
2969
# This is a new option
2970
self.orig[name] = _NewlyCreatedOption
2971
elif name not in self.orig:
2972
self.orig[name] = self.get(name, None)
2973
self.options[name] = value
2975
def remove(self, name):
2976
if name not in self.orig and name in self.options:
2977
self.orig[name] = self.get(name, None)
2978
del self.options[name]
2980
def reset_changes(self):
2983
def apply_changes(self, dirty, store):
2984
"""Apply option value changes.
2986
``self`` has been reloaded from the persistent storage. ``dirty``
2987
contains the changes made since the previous loading.
2989
:param dirty: the mutable section containing the changes.
2991
:param store: the store containing the section
2993
for k, expected in dirty.orig.iteritems():
2994
actual = dirty.get(k, _DeletedOption)
2995
reloaded = self.get(k, _NewlyCreatedOption)
2996
if actual is _DeletedOption:
2997
if k in self.options:
3001
# Report concurrent updates in an ad-hoc way. This should only
3002
# occurs when different processes try to update the same option
3003
# which is not supported (as in: the config framework is not meant
3004
# to be used as a sharing mechanism).
3005
if expected != reloaded:
3006
if actual is _DeletedOption:
3007
actual = '<DELETED>'
3008
if reloaded is _NewlyCreatedOption:
3009
reloaded = '<CREATED>'
3010
if expected is _NewlyCreatedOption:
3011
expected = '<CREATED>'
3012
# Someone changed the value since we get it from the persistent
3014
trace.warning(gettext(
3015
"Option {0} in section {1} of {2} was changed"
3016
" from {3} to {4}. The {5} value will be saved.".format(
3017
k, self.id, store.external_url(), expected,
3019
# No need to keep track of these changes
3020
self.reset_changes()
3023
class Store(object):
3024
"""Abstract interface to persistent storage for configuration options."""
3026
readonly_section_class = Section
3027
mutable_section_class = MutableSection
3030
# Which sections need to be saved (by section id). We use a dict here
3031
# so the dirty sections can be shared by multiple callers.
3032
self.dirty_sections = {}
3034
def is_loaded(self):
3035
"""Returns True if the Store has been loaded.
3037
This is used to implement lazy loading and ensure the persistent
3038
storage is queried only when needed.
3040
raise NotImplementedError(self.is_loaded)
3043
"""Loads the Store from persistent storage."""
3044
raise NotImplementedError(self.load)
3046
def _load_from_string(self, bytes):
3047
"""Create a store from a string in configobj syntax.
3049
:param bytes: A string representing the file content.
3051
raise NotImplementedError(self._load_from_string)
3054
"""Unloads the Store.
3056
This should make is_loaded() return False. This is used when the caller
3057
knows that the persistent storage has changed or may have change since
3060
raise NotImplementedError(self.unload)
3062
def quote(self, value):
3063
"""Quote a configuration option value for storing purposes.
3065
This allows Stacks to present values as they will be stored.
3069
def unquote(self, value):
3070
"""Unquote a configuration option value into unicode.
3072
The received value is quoted as stored.
3077
"""Saves the Store to persistent storage."""
3078
raise NotImplementedError(self.save)
3080
def _need_saving(self):
3081
for s in self.dirty_sections.values():
3083
# At least one dirty section contains a modification
3087
def apply_changes(self, dirty_sections):
3088
"""Apply changes from dirty sections while checking for coherency.
3090
The Store content is discarded and reloaded from persistent storage to
3091
acquire up-to-date values.
3093
Dirty sections are MutableSection which kept track of the value they
3094
are expected to update.
3096
# We need an up-to-date version from the persistent storage, unload the
3097
# store. The reload will occur when needed (triggered by the first
3098
# get_mutable_section() call below.
3100
# Apply the changes from the preserved dirty sections
3101
for section_id, dirty in dirty_sections.iteritems():
3102
clean = self.get_mutable_section(section_id)
3103
clean.apply_changes(dirty, self)
3104
# Everything is clean now
3105
self.dirty_sections = {}
3107
def save_changes(self):
3108
"""Saves the Store to persistent storage if changes occurred.
3110
Apply the changes recorded in the mutable sections to a store content
3111
refreshed from persistent storage.
3113
raise NotImplementedError(self.save_changes)
3115
def external_url(self):
3116
raise NotImplementedError(self.external_url)
3118
def get_sections(self):
3119
"""Returns an ordered iterable of existing sections.
3121
:returns: An iterable of (store, section).
3123
raise NotImplementedError(self.get_sections)
3125
def get_mutable_section(self, section_id=None):
3126
"""Returns the specified mutable section.
3128
:param section_id: The section identifier
3130
raise NotImplementedError(self.get_mutable_section)
3133
# Mostly for debugging use
3134
return "<config.%s(%s)>" % (self.__class__.__name__,
3135
self.external_url())
3138
class CommandLineStore(Store):
3139
"A store to carry command line overrides for the config options."""
3141
def __init__(self, opts=None):
3142
super(CommandLineStore, self).__init__()
3149
# The dict should be cleared but not replaced so it can be shared.
3150
self.options.clear()
3152
def _from_cmdline(self, overrides):
3153
# Reset before accepting new definitions
3155
for over in overrides:
3157
name, value = over.split('=', 1)
3159
raise errors.BzrCommandError(
3160
gettext("Invalid '%s', should be of the form 'name=value'")
3162
self.options[name] = value
3164
def external_url(self):
3165
# Not an url but it makes debugging easier and is never needed
3169
def get_sections(self):
3170
yield self, self.readonly_section_class(None, self.options)
3173
class IniFileStore(Store):
3174
"""A config Store using ConfigObj for storage.
3176
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3177
serialize/deserialize the config file.
3181
"""A config Store using ConfigObj for storage.
3183
super(IniFileStore, self).__init__()
3184
self._config_obj = None
3186
def is_loaded(self):
3187
return self._config_obj != None
3190
self._config_obj = None
3191
self.dirty_sections = {}
3193
def _load_content(self):
3194
"""Load the config file bytes.
3196
This should be provided by subclasses
3198
:return: Byte string
3200
raise NotImplementedError(self._load_content)
3202
def _save_content(self, content):
3203
"""Save the config file bytes.
3205
This should be provided by subclasses
3207
:param content: Config file bytes to write
3209
raise NotImplementedError(self._save_content)
3212
"""Load the store from the associated file."""
3213
if self.is_loaded():
3215
content = self._load_content()
3216
self._load_from_string(content)
3217
for hook in ConfigHooks['load']:
3220
def _load_from_string(self, bytes):
3221
"""Create a config store from a string.
3223
:param bytes: A string representing the file content.
3225
if self.is_loaded():
3226
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3227
co_input = StringIO(bytes)
3229
# The config files are always stored utf8-encoded
3230
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3232
except configobj.ConfigObjError, e:
3233
self._config_obj = None
3234
raise errors.ParseConfigError(e.errors, self.external_url())
3235
except UnicodeDecodeError:
3236
raise errors.ConfigContentError(self.external_url())
3238
def save_changes(self):
3239
if not self.is_loaded():
3242
if not self._need_saving():
3244
# Preserve the current version
3245
dirty_sections = dict(self.dirty_sections.items())
3246
self.apply_changes(dirty_sections)
3247
# Save to the persistent storage
3251
if not self.is_loaded():
3255
self._config_obj.write(out)
3256
self._save_content(out.getvalue())
3257
for hook in ConfigHooks['save']:
3260
def get_sections(self):
3261
"""Get the configobj section in the file order.
3263
:returns: An iterable of (store, section).
3265
# We need a loaded store
3268
except (errors.NoSuchFile, errors.PermissionDenied):
3269
# If the file can't be read, there is no sections
3271
cobj = self._config_obj
3273
yield self, self.readonly_section_class(None, cobj)
3274
for section_name in cobj.sections:
3276
self.readonly_section_class(section_name,
3277
cobj[section_name]))
3279
def get_mutable_section(self, section_id=None):
3280
# We need a loaded store
3283
except errors.NoSuchFile:
3284
# The file doesn't exist, let's pretend it was empty
3285
self._load_from_string('')
3286
if section_id in self.dirty_sections:
3287
# We already created a mutable section for this id
3288
return self.dirty_sections[section_id]
3289
if section_id is None:
3290
section = self._config_obj
3292
section = self._config_obj.setdefault(section_id, {})
3293
mutable_section = self.mutable_section_class(section_id, section)
3294
# All mutable sections can become dirty
3295
self.dirty_sections[section_id] = mutable_section
3296
return mutable_section
3298
def quote(self, value):
3300
# configobj conflates automagical list values and quoting
3301
self._config_obj.list_values = True
3302
return self._config_obj._quote(value)
3304
self._config_obj.list_values = False
3306
def unquote(self, value):
3307
if value and isinstance(value, basestring):
3308
# _unquote doesn't handle None nor empty strings nor anything that
3309
# is not a string, really.
3310
value = self._config_obj._unquote(value)
3313
def external_url(self):
3314
# Since an IniFileStore can be used without a file (at least in tests),
3315
# it's better to provide something than raising a NotImplementedError.
3316
# All daughter classes are supposed to provide an implementation
3318
return 'In-Process Store, no URL'
3321
class TransportIniFileStore(IniFileStore):
3322
"""IniFileStore that loads files from a transport.
3324
:ivar transport: The transport object where the config file is located.
3326
:ivar file_name: The config file basename in the transport directory.
3329
def __init__(self, transport, file_name):
3330
"""A Store using a ini file on a Transport
3332
:param transport: The transport object where the config file is located.
3333
:param file_name: The config file basename in the transport directory.
3335
super(TransportIniFileStore, self).__init__()
3336
self.transport = transport
3337
self.file_name = file_name
3339
def _load_content(self):
3341
return self.transport.get_bytes(self.file_name)
3342
except errors.PermissionDenied:
3343
trace.warning("Permission denied while trying to load "
3344
"configuration store %s.", self.external_url())
3347
def _save_content(self, content):
3348
self.transport.put_bytes(self.file_name, content)
3350
def external_url(self):
3351
# FIXME: external_url should really accepts an optional relpath
3352
# parameter (bug #750169) :-/ -- vila 2011-04-04
3353
# The following will do in the interim but maybe we don't want to
3354
# expose a path here but rather a config ID and its associated
3355
# object </hand wawe>.
3356
return urlutils.join(self.transport.external_url(), self.file_name)
3359
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3360
# unlockable stores for use with objects that can already ensure the locking
3361
# (think branches). If different stores (not based on ConfigObj) are created,
3362
# they may face the same issue.
3365
class LockableIniFileStore(TransportIniFileStore):
3366
"""A ConfigObjStore using locks on save to ensure store integrity."""
3368
def __init__(self, transport, file_name, lock_dir_name=None):
3369
"""A config Store using ConfigObj for storage.
3371
:param transport: The transport object where the config file is located.
3373
:param file_name: The config file basename in the transport directory.
3375
if lock_dir_name is None:
3376
lock_dir_name = 'lock'
3377
self.lock_dir_name = lock_dir_name
3378
super(LockableIniFileStore, self).__init__(transport, file_name)
3379
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3381
def lock_write(self, token=None):
3382
"""Takes a write lock in the directory containing the config file.
3384
If the directory doesn't exist it is created.
3386
# FIXME: This doesn't check the ownership of the created directories as
3387
# ensure_config_dir_exists does. It should if the transport is local
3388
# -- vila 2011-04-06
3389
self.transport.create_prefix()
3390
return self._lock.lock_write(token)
3395
def break_lock(self):
3396
self._lock.break_lock()
3400
# We need to be able to override the undecorated implementation
3401
self.save_without_locking()
3403
def save_without_locking(self):
3404
super(LockableIniFileStore, self).save()
3407
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3408
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3409
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3411
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3412
# functions or a registry will make it easier and clearer for tests, focusing
3413
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3414
# on a poolie's remark)
3415
class GlobalStore(LockableIniFileStore):
3416
"""A config store for global options.
3418
There is a single GlobalStore for a given process.
3421
def __init__(self, possible_transports=None):
3422
t = transport.get_transport_from_path(
3423
config_dir(), possible_transports=possible_transports)
3424
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3428
class LocationStore(LockableIniFileStore):
3429
"""A config store for options specific to a location.
3431
There is a single LocationStore for a given process.
3434
def __init__(self, possible_transports=None):
3435
t = transport.get_transport_from_path(
3436
config_dir(), possible_transports=possible_transports)
3437
super(LocationStore, self).__init__(t, 'locations.conf')
3438
self.id = 'locations'
3441
class BranchStore(TransportIniFileStore):
3442
"""A config store for branch options.
3444
There is a single BranchStore for a given branch.
3447
def __init__(self, branch):
3448
super(BranchStore, self).__init__(branch.control_transport,
3450
self.branch = branch
3454
class ControlStore(LockableIniFileStore):
3456
def __init__(self, bzrdir):
3457
super(ControlStore, self).__init__(bzrdir.transport,
3459
lock_dir_name='branch_lock')
3463
class SectionMatcher(object):
3464
"""Select sections into a given Store.
3466
This is intended to be used to postpone getting an iterable of sections
3470
def __init__(self, store):
3473
def get_sections(self):
3474
# This is where we require loading the store so we can see all defined
3476
sections = self.store.get_sections()
3477
# Walk the revisions in the order provided
3478
for store, s in sections:
3482
def match(self, section):
3483
"""Does the proposed section match.
3485
:param section: A Section object.
3487
:returns: True if the section matches, False otherwise.
3489
raise NotImplementedError(self.match)
3492
class NameMatcher(SectionMatcher):
3494
def __init__(self, store, section_id):
3495
super(NameMatcher, self).__init__(store)
3496
self.section_id = section_id
3498
def match(self, section):
3499
return section.id == self.section_id
3502
class LocationSection(Section):
3504
def __init__(self, section, extra_path, branch_name=None):
3505
super(LocationSection, self).__init__(section.id, section.options)
3506
self.extra_path = extra_path
3507
if branch_name is None:
3509
self.locals = {'relpath': extra_path,
3510
'basename': urlutils.basename(extra_path),
3511
'branchname': branch_name}
3513
def get(self, name, default=None, expand=True):
3514
value = super(LocationSection, self).get(name, default)
3515
if value is not None and expand:
3516
policy_name = self.get(name + ':policy', None)
3517
policy = _policy_value.get(policy_name, POLICY_NONE)
3518
if policy == POLICY_APPENDPATH:
3519
value = urlutils.join(value, self.extra_path)
3520
# expand section local options right now (since POLICY_APPENDPATH
3521
# will never add options references, it's ok to expand after it).
3523
for is_ref, chunk in iter_option_refs(value):
3525
chunks.append(chunk)
3528
if ref in self.locals:
3529
chunks.append(self.locals[ref])
3531
chunks.append(chunk)
3532
value = ''.join(chunks)
3536
class StartingPathMatcher(SectionMatcher):
3537
"""Select sections for a given location respecting the Store order."""
3539
# FIXME: Both local paths and urls can be used for section names as well as
3540
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3541
# inherited the fuzziness from the previous ``LocationConfig``
3542
# implementation. We probably need to revisit which encoding is allowed for
3543
# both ``location`` and section names and how we normalize
3544
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3545
# related too. -- vila 2012-01-04
3547
def __init__(self, store, location):
3548
super(StartingPathMatcher, self).__init__(store)
3549
if location.startswith('file://'):
3550
location = urlutils.local_path_from_url(location)
3551
self.location = location
3553
def get_sections(self):
3554
"""Get all sections matching ``location`` in the store.
3556
The most generic sections are described first in the store, then more
3557
specific ones can be provided for reduced scopes.
3559
The returned section are therefore returned in the reversed order so
3560
the most specific ones can be found first.
3562
location_parts = self.location.rstrip('/').split('/')
3565
# Later sections are more specific, they should be returned first
3566
for _, section in reversed(list(store.get_sections())):
3567
if section.id is None:
3568
# The no-name section is always included if present
3569
yield store, LocationSection(section, self.location)
3571
section_path = section.id
3572
if section_path.startswith('file://'):
3573
# the location is already a local path or URL, convert the
3574
# section id to the same format
3575
section_path = urlutils.local_path_from_url(section_path)
3576
if (self.location.startswith(section_path)
3577
or fnmatch.fnmatch(self.location, section_path)):
3578
section_parts = section_path.rstrip('/').split('/')
3579
extra_path = '/'.join(location_parts[len(section_parts):])
3580
yield store, LocationSection(section, extra_path)
3583
class LocationMatcher(SectionMatcher):
3585
def __init__(self, store, location):
3586
super(LocationMatcher, self).__init__(store)
3587
url, params = urlutils.split_segment_parameters(location)
3588
if location.startswith('file://'):
3589
location = urlutils.local_path_from_url(location)
3590
self.location = location
3591
branch_name = params.get('branch')
3592
if branch_name is None:
3593
self.branch_name = urlutils.basename(self.location)
3595
self.branch_name = urlutils.unescape(branch_name)
3597
def _get_matching_sections(self):
3598
"""Get all sections matching ``location``."""
3599
# We slightly diverge from LocalConfig here by allowing the no-name
3600
# section as the most generic one and the lower priority.
3601
no_name_section = None
3603
# Filter out the no_name_section so _iter_for_location_by_parts can be
3604
# used (it assumes all sections have a name).
3605
for _, section in self.store.get_sections():
3606
if section.id is None:
3607
no_name_section = section
3609
all_sections.append(section)
3610
# Unfortunately _iter_for_location_by_parts deals with section names so
3611
# we have to resync.
3612
filtered_sections = _iter_for_location_by_parts(
3613
[s.id for s in all_sections], self.location)
3614
iter_all_sections = iter(all_sections)
3615
matching_sections = []
3616
if no_name_section is not None:
3617
matching_sections.append(
3618
(0, LocationSection(no_name_section, self.location)))
3619
for section_id, extra_path, length in filtered_sections:
3620
# a section id is unique for a given store so it's safe to take the
3621
# first matching section while iterating. Also, all filtered
3622
# sections are part of 'all_sections' and will always be found
3625
section = iter_all_sections.next()
3626
if section_id == section.id:
3627
section = LocationSection(section, extra_path,
3629
matching_sections.append((length, section))
3631
return matching_sections
3633
def get_sections(self):
3634
# Override the default implementation as we want to change the order
3635
matching_sections = self._get_matching_sections()
3636
# We want the longest (aka more specific) locations first
3637
sections = sorted(matching_sections,
3638
key=lambda (length, section): (length, section.id),
3640
# Sections mentioning 'ignore_parents' restrict the selection
3641
for _, section in sections:
3642
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3643
ignore = section.get('ignore_parents', None)
3644
if ignore is not None:
3645
ignore = ui.bool_from_string(ignore)
3648
# Finally, we have a valid section
3649
yield self.store, section
3652
# FIXME: _shared_stores should be an attribute of a library state once a
3653
# library_state object is always available.
3655
_shared_stores_at_exit_installed = False
3657
class Stack(object):
3658
"""A stack of configurations where an option can be defined"""
3660
def __init__(self, sections_def, store=None, mutable_section_id=None):
3661
"""Creates a stack of sections with an optional store for changes.
3663
:param sections_def: A list of Section or callables that returns an
3664
iterable of Section. This defines the Sections for the Stack and
3665
can be called repeatedly if needed.
3667
:param store: The optional Store where modifications will be
3668
recorded. If none is specified, no modifications can be done.
3670
:param mutable_section_id: The id of the MutableSection where changes
3671
are recorded. This requires the ``store`` parameter to be
3674
self.sections_def = sections_def
3676
self.mutable_section_id = mutable_section_id
3678
def iter_sections(self):
3679
"""Iterate all the defined sections."""
3680
# Ensuring lazy loading is achieved by delaying section matching (which
3681
# implies querying the persistent storage) until it can't be avoided
3682
# anymore by using callables to describe (possibly empty) section
3684
for sections in self.sections_def:
3685
for store, section in sections():
3686
yield store, section
3688
def get(self, name, expand=True, convert=True):
3689
"""Return the *first* option value found in the sections.
3691
This is where we guarantee that sections coming from Store are loaded
3692
lazily: the loading is delayed until we need to either check that an
3693
option exists or get its value, which in turn may require to discover
3694
in which sections it can be defined. Both of these (section and option
3695
existence) require loading the store (even partially).
3697
:param name: The queried option.
3699
:param expand: Whether options references should be expanded.
3701
:param convert: Whether the option value should be converted from
3702
unicode (do nothing for non-registered options).
3704
:returns: The value of the option.
3706
# FIXME: No caching of options nor sections yet -- vila 20110503
3708
found_store = None # Where the option value has been found
3709
# If the option is registered, it may provide additional info about
3712
opt = option_registry.get(name)
3717
def expand_and_convert(val):
3718
# This may need to be called in different contexts if the value is
3719
# None or ends up being None during expansion or conversion.
3722
if isinstance(val, basestring):
3723
val = self._expand_options_in_string(val)
3725
trace.warning('Cannot expand "%s":'
3726
' %s does not support option expansion'
3727
% (name, type(val)))
3729
val = found_store.unquote(val)
3731
val = opt.convert_from_unicode(found_store, val)
3734
# First of all, check if the environment can override the configuration
3736
if opt is not None and opt.override_from_env:
3737
value = opt.get_override()
3738
value = expand_and_convert(value)
3740
for store, section in self.iter_sections():
3741
value = section.get(name)
3742
if value is not None:
3745
value = expand_and_convert(value)
3746
if opt is not None and value is None:
3747
# If the option is registered, it may provide a default value
3748
value = opt.get_default()
3749
value = expand_and_convert(value)
3750
for hook in ConfigHooks['get']:
3751
hook(self, name, value)
3754
def expand_options(self, string, env=None):
3755
"""Expand option references in the string in the configuration context.
3757
:param string: The string containing option(s) to expand.
3759
:param env: An option dict defining additional configuration options or
3760
overriding existing ones.
3762
:returns: The expanded string.
3764
return self._expand_options_in_string(string, env)
3766
def _expand_options_in_string(self, string, env=None, _refs=None):
3767
"""Expand options in the string in the configuration context.
3769
:param string: The string to be expanded.
3771
:param env: An option dict defining additional configuration options or
3772
overriding existing ones.
3774
:param _refs: Private list (FIFO) containing the options being expanded
3777
:returns: The expanded string.
3780
# Not much to expand there
3783
# What references are currently resolved (to detect loops)
3786
# We need to iterate until no more refs appear ({{foo}} will need two
3787
# iterations for example).
3792
for is_ref, chunk in iter_option_refs(result):
3794
chunks.append(chunk)
3799
raise errors.OptionExpansionLoop(string, _refs)
3801
value = self._expand_option(name, env, _refs)
3803
raise errors.ExpandingUnknownOption(name, string)
3804
chunks.append(value)
3806
result = ''.join(chunks)
3809
def _expand_option(self, name, env, _refs):
3810
if env is not None and name in env:
3811
# Special case, values provided in env takes precedence over
3815
value = self.get(name, expand=False, convert=False)
3816
value = self._expand_options_in_string(value, env, _refs)
3819
def _get_mutable_section(self):
3820
"""Get the MutableSection for the Stack.
3822
This is where we guarantee that the mutable section is lazily loaded:
3823
this means we won't load the corresponding store before setting a value
3824
or deleting an option. In practice the store will often be loaded but
3825
this helps catching some programming errors.
3828
section = store.get_mutable_section(self.mutable_section_id)
3829
return store, section
3831
def set(self, name, value):
3832
"""Set a new value for the option."""
3833
store, section = self._get_mutable_section()
3834
section.set(name, store.quote(value))
3835
for hook in ConfigHooks['set']:
3836
hook(self, name, value)
3838
def remove(self, name):
3839
"""Remove an existing option."""
3840
_, section = self._get_mutable_section()
3841
section.remove(name)
3842
for hook in ConfigHooks['remove']:
3846
# Mostly for debugging use
3847
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3849
def _get_overrides(self):
3850
# FIXME: Hack around library_state.initialize never called
3851
if bzrlib.global_state is not None:
3852
return bzrlib.global_state.cmdline_overrides.get_sections()
3855
def get_shared_store(self, store, state=None):
3856
"""Get a known shared store.
3858
Store urls uniquely identify them and are used to ensure a single copy
3859
is shared across all users.
3861
:param store: The store known to the caller.
3863
:param state: The library state where the known stores are kept.
3865
:returns: The store received if it's not a known one, an already known
3869
state = bzrlib.global_state
3871
global _shared_stores_at_exit_installed
3872
stores = _shared_stores
3873
def save_config_changes():
3874
for k, store in stores.iteritems():
3875
store.save_changes()
3876
if not _shared_stores_at_exit_installed:
3877
# FIXME: Ugly hack waiting for library_state to always be
3878
# available. -- vila 20120731
3880
atexit.register(save_config_changes)
3881
_shared_stores_at_exit_installed = True
3883
stores = state.config_stores
3884
url = store.external_url()
3892
class MemoryStack(Stack):
3893
"""A configuration stack defined from a string.
3895
This is mainly intended for tests and requires no disk resources.
3898
def __init__(self, content=None):
3899
"""Create an in-memory stack from a given content.
3901
It uses a single store based on configobj and support reading and
3904
:param content: The initial content of the store. If None, the store is
3905
not loaded and ``_load_from_string`` can and should be used if
3908
store = IniFileStore()
3909
if content is not None:
3910
store._load_from_string(content)
3911
super(MemoryStack, self).__init__(
3912
[store.get_sections], store)
3915
class _CompatibleStack(Stack):
3916
"""Place holder for compatibility with previous design.
3918
This is intended to ease the transition from the Config-based design to the
3919
Stack-based design and should not be used nor relied upon by plugins.
3921
One assumption made here is that the daughter classes will all use Stores
3922
derived from LockableIniFileStore).
3924
It implements set() and remove () by re-loading the store before applying
3925
the modification and saving it.
3927
The long term plan being to implement a single write by store to save
3928
all modifications, this class should not be used in the interim.
3931
def set(self, name, value):
3934
super(_CompatibleStack, self).set(name, value)
3935
# Force a write to persistent storage
3938
def remove(self, name):
3941
super(_CompatibleStack, self).remove(name)
3942
# Force a write to persistent storage
3946
class GlobalStack(Stack):
3947
"""Global options only stack.
3949
The following sections are queried:
3951
* command-line overrides,
3953
* the 'DEFAULT' section in bazaar.conf
3955
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3960
gstore = self.get_shared_store(GlobalStore())
3961
super(GlobalStack, self).__init__(
3962
[self._get_overrides,
3963
NameMatcher(gstore, 'DEFAULT').get_sections],
3964
gstore, mutable_section_id='DEFAULT')
3967
class LocationStack(Stack):
3968
"""Per-location options falling back to global options stack.
3971
The following sections are queried:
3973
* command-line overrides,
3975
* the sections matching ``location`` in ``locations.conf``, the order being
3976
defined by the number of path components in the section glob, higher
3977
numbers first (from most specific section to most generic).
3979
* the 'DEFAULT' section in bazaar.conf
3981
This stack will use the ``location`` section in locations.conf as its
3985
def __init__(self, location):
3986
"""Make a new stack for a location and global configuration.
3988
:param location: A URL prefix to """
3989
lstore = self.get_shared_store(LocationStore())
3990
if location.startswith('file://'):
3991
location = urlutils.local_path_from_url(location)
3992
gstore = self.get_shared_store(GlobalStore())
3993
super(LocationStack, self).__init__(
3994
[self._get_overrides,
3995
LocationMatcher(lstore, location).get_sections,
3996
NameMatcher(gstore, 'DEFAULT').get_sections],
3997
lstore, mutable_section_id=location)
4000
class BranchStack(Stack):
4001
"""Per-location options falling back to branch then global options stack.
4003
The following sections are queried:
4005
* command-line overrides,
4007
* the sections matching ``location`` in ``locations.conf``, the order being
4008
defined by the number of path components in the section glob, higher
4009
numbers first (from most specific section to most generic),
4011
* the no-name section in branch.conf,
4013
* the ``DEFAULT`` section in ``bazaar.conf``.
4015
This stack will use the no-name section in ``branch.conf`` as its
4019
def __init__(self, branch):
4020
lstore = self.get_shared_store(LocationStore())
4021
bstore = branch._get_config_store()
4022
gstore = self.get_shared_store(GlobalStore())
4023
super(BranchStack, self).__init__(
4024
[self._get_overrides,
4025
LocationMatcher(lstore, branch.base).get_sections,
4026
NameMatcher(bstore, None).get_sections,
4027
NameMatcher(gstore, 'DEFAULT').get_sections],
4029
self.branch = branch
4031
def lock_write(self, token=None):
4032
return self.branch.lock_write(token)
4035
return self.branch.unlock()
4038
def set(self, name, value):
4039
super(BranchStack, self).set(name, value)
4040
# Unlocking the branch will trigger a store.save_changes() so the last
4041
# unlock saves all the changes.
4044
def remove(self, name):
4045
super(BranchStack, self).remove(name)
4046
# Unlocking the branch will trigger a store.save_changes() so the last
4047
# unlock saves all the changes.
4050
class RemoteControlStack(Stack):
4051
"""Remote control-only options stack."""
4053
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4054
# with the stack used for remote bzr dirs. RemoteControlStack only uses
4055
# control.conf and is used only for stack options.
4057
def __init__(self, bzrdir):
4058
cstore = bzrdir._get_config_store()
4059
super(RemoteControlStack, self).__init__(
4060
[NameMatcher(cstore, None).get_sections],
4062
self.bzrdir = bzrdir
4065
class BranchOnlyStack(Stack):
4066
"""Branch-only options stack."""
4068
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4069
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4070
# -- vila 2011-12-16
4072
def __init__(self, branch):
4073
bstore = branch._get_config_store()
4074
super(BranchOnlyStack, self).__init__(
4075
[NameMatcher(bstore, None).get_sections],
4077
self.branch = branch
4079
def lock_write(self, token=None):
4080
return self.branch.lock_write(token)
4083
return self.branch.unlock()
4086
def set(self, name, value):
4087
super(BranchOnlyStack, self).set(name, value)
4088
# Force a write to persistent storage
4089
self.store.save_changes()
4092
def remove(self, name):
4093
super(BranchOnlyStack, self).remove(name)
4094
# Force a write to persistent storage
4095
self.store.save_changes()
4098
class cmd_config(commands.Command):
4099
__doc__ = """Display, set or remove a configuration option.
4101
Display the active value for option NAME.
4103
If --all is specified, NAME is interpreted as a regular expression and all
4104
matching options are displayed mentioning their scope and without resolving
4105
option references in the value). The active value that bzr will take into
4106
account is the first one displayed for each option.
4108
If NAME is not given, --all .* is implied (all options are displayed for the
4111
Setting a value is achieved by using NAME=value without spaces. The value
4112
is set in the most relevant scope and can be checked by displaying the
4115
Removing a value is achieved by using --remove NAME.
4118
takes_args = ['name?']
4122
# FIXME: This should be a registry option so that plugins can register
4123
# their own config files (or not) and will also address
4124
# http://pad.lv/788991 -- vila 20101115
4125
commands.Option('scope', help='Reduce the scope to the specified'
4126
' configuration file.',
4128
commands.Option('all',
4129
help='Display all the defined values for the matching options.',
4131
commands.Option('remove', help='Remove the option from'
4132
' the configuration file.'),
4135
_see_also = ['configuration']
4137
@commands.display_command
4138
def run(self, name=None, all=False, directory=None, scope=None,
4140
if directory is None:
4142
directory = directory_service.directories.dereference(directory)
4143
directory = urlutils.normalize_url(directory)
4145
raise errors.BzrError(
4146
'--all and --remove are mutually exclusive.')
4148
# Delete the option in the given scope
4149
self._remove_config_option(name, directory, scope)
4151
# Defaults to all options
4152
self._show_matching_options('.*', directory, scope)
4155
name, value = name.split('=', 1)
4157
# Display the option(s) value(s)
4159
self._show_matching_options(name, directory, scope)
4161
self._show_value(name, directory, scope)
4164
raise errors.BzrError(
4165
'Only one option can be set.')
4166
# Set the option value
4167
self._set_config_option(name, value, directory, scope)
4169
def _get_stack(self, directory, scope=None, write_access=False):
4170
"""Get the configuration stack specified by ``directory`` and ``scope``.
4172
:param directory: Where the configurations are derived from.
4174
:param scope: A specific config to start from.
4176
:param write_access: Whether a write access to the stack will be
4179
# FIXME: scope should allow access to plugin-specific stacks (even
4180
# reduced to the plugin-specific store), related to
4181
# http://pad.lv/788991 -- vila 2011-11-15
4182
if scope is not None:
4183
if scope == 'bazaar':
4184
return GlobalStack()
4185
elif scope == 'locations':
4186
return LocationStack(directory)
4187
elif scope == 'branch':
4189
controldir.ControlDir.open_containing_tree_or_branch(
4192
self.add_cleanup(br.lock_write().unlock)
4193
return br.get_config_stack()
4194
raise errors.NoSuchConfig(scope)
4198
controldir.ControlDir.open_containing_tree_or_branch(
4201
self.add_cleanup(br.lock_write().unlock)
4202
return br.get_config_stack()
4203
except errors.NotBranchError:
4204
return LocationStack(directory)
4206
def _quote_multiline(self, value):
4208
value = '"""' + value + '"""'
4211
def _show_value(self, name, directory, scope):
4212
conf = self._get_stack(directory, scope)
4213
value = conf.get(name, expand=True, convert=False)
4214
if value is not None:
4215
# Quote the value appropriately
4216
value = self._quote_multiline(value)
4217
self.outf.write('%s\n' % (value,))
4219
raise errors.NoSuchConfigOption(name)
4221
def _show_matching_options(self, name, directory, scope):
4222
name = lazy_regex.lazy_compile(name)
4223
# We want any error in the regexp to be raised *now* so we need to
4224
# avoid the delay introduced by the lazy regexp. But, we still do
4225
# want the nicer errors raised by lazy_regex.
4226
name._compile_and_collapse()
4229
conf = self._get_stack(directory, scope)
4230
for store, section in conf.iter_sections():
4231
for oname in section.iter_option_names():
4232
if name.search(oname):
4233
if cur_store_id != store.id:
4234
# Explain where the options are defined
4235
self.outf.write('%s:\n' % (store.id,))
4236
cur_store_id = store.id
4238
if (section.id is not None and cur_section != section.id):
4239
# Display the section id as it appears in the store
4240
# (None doesn't appear by definition)
4241
self.outf.write(' [%s]\n' % (section.id,))
4242
cur_section = section.id
4243
value = section.get(oname, expand=False)
4244
# Quote the value appropriately
4245
value = self._quote_multiline(value)
4246
self.outf.write(' %s = %s\n' % (oname, value))
4248
def _set_config_option(self, name, value, directory, scope):
4249
conf = self._get_stack(directory, scope, write_access=True)
4250
conf.set(name, value)
4252
def _remove_config_option(self, name, directory, scope):
4254
raise errors.BzrCommandError(
4255
'--remove expects an option to remove.')
4256
conf = self._get_stack(directory, scope, write_access=True)
4260
raise errors.NoSuchConfigOption(name)
4265
# We need adapters that can build a Store or a Stack in a test context. Test
4266
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4267
# themselves. The builder will receive a test instance and should return a
4268
# ready-to-use store or stack. Plugins that define new store/stacks can also
4269
# register themselves here to be tested against the tests defined in
4270
# bzrlib.tests.test_config. Note that the builder can be called multiple times
4271
# for the same test.
4273
# The registered object should be a callable receiving a test instance
4274
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4276
test_store_builder_registry = registry.Registry()
4278
# The registered object should be a callable receiving a test instance
4279
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4281
test_stack_builder_registry = registry.Registry()
added
removed
bzrlib/config.py
