1
# Copyright (C) 2005-2014, 2016 Canonical Ltd
2
# Authors: Robert Collins <robert.collins@canonical.com>
5
# This program is free software; you can redistribute it and/or modify
6
# it under the terms of the GNU General Public License as published by
7
# the Free Software Foundation; either version 2 of the License, or
8
# (at your option) any later version.
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
# GNU General Public License for more details.
15
# You should have received a copy of the GNU General Public License
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
"""Configuration that affects the behaviour of Bazaar.
21
Currently this configuration resides in ~/.bazaar/bazaar.conf
22
and ~/.bazaar/locations.conf, which is written to by 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 Mac OS X and 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
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1508
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1509
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1510
if osutils.isdir(xdg_dir):
1512
"Using configuration in XDG directory %s." % xdg_dir)
1514
base = osutils._get_home_dir()
1515
return osutils.pathjoin(base, ".bazaar")
1518
def config_filename():
1519
"""Return per-user configuration ini file filename."""
1520
return osutils.pathjoin(config_dir(), 'bazaar.conf')
1523
def locations_config_filename():
1524
"""Return per-user configuration ini file filename."""
1525
return osutils.pathjoin(config_dir(), 'locations.conf')
1528
def authentication_config_filename():
1529
"""Return per-user authentication ini file filename."""
1530
return osutils.pathjoin(config_dir(), 'authentication.conf')
1533
def user_ignore_config_filename():
1534
"""Return the user default ignore filename"""
1535
return osutils.pathjoin(config_dir(), 'ignore')
1539
"""Return the directory name to store crash files.
1541
This doesn't implicitly create it.
1543
On Windows it's in the config directory; elsewhere it's /var/crash
1544
which may be monitored by apport. It can be overridden by
1547
if sys.platform == 'win32':
1548
return osutils.pathjoin(config_dir(), 'Crash')
1550
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1552
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1555
def xdg_cache_dir():
1556
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1557
# Possibly this should be different on Windows?
1558
e = os.environ.get('XDG_CACHE_HOME', None)
1562
return os.path.expanduser('~/.cache')
1565
def _get_default_mail_domain(mailname_file='/etc/mailname'):
1566
"""If possible, return the assumed default email domain.
1568
:returns: string mail domain, or None.
1570
if sys.platform == 'win32':
1571
# No implementation yet; patches welcome
1574
f = open(mailname_file)
1575
except (IOError, OSError), e:
1578
domain = f.readline().strip()
1584
def default_email():
1585
v = os.environ.get('BZR_EMAIL')
1587
return v.decode(osutils.get_user_encoding())
1588
v = os.environ.get('EMAIL')
1590
return v.decode(osutils.get_user_encoding())
1591
name, email = _auto_user_id()
1593
return u'%s <%s>' % (name, email)
1596
raise errors.NoWhoami()
1599
def _auto_user_id():
1600
"""Calculate automatic user identification.
1602
:returns: (realname, email), either of which may be None if they can't be
1605
Only used when none is set in the environment or the id file.
1607
This only returns an email address if we can be fairly sure the
1608
address is reasonable, ie if /etc/mailname is set on unix.
1610
This doesn't use the FQDN as the default domain because that may be
1611
slow, and it doesn't use the hostname alone because that's not normally
1612
a reasonable address.
1614
if sys.platform == 'win32':
1615
# No implementation to reliably determine Windows default mail
1616
# address; please add one.
1619
default_mail_domain = _get_default_mail_domain()
1620
if not default_mail_domain:
1626
w = pwd.getpwuid(uid)
1628
trace.mutter('no passwd entry for uid %d?' % uid)
1631
# we try utf-8 first, because on many variants (like Linux),
1632
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1633
# false positives. (many users will have their user encoding set to
1634
# latin-1, which cannot raise UnicodeError.)
1636
gecos = w.pw_gecos.decode('utf-8')
1638
except UnicodeError:
1640
encoding = osutils.get_user_encoding()
1641
gecos = w.pw_gecos.decode(encoding)
1642
except UnicodeError, e:
1643
trace.mutter("cannot decode passwd entry %s" % w)
1646
username = w.pw_name.decode(encoding)
1647
except UnicodeError, e:
1648
trace.mutter("cannot decode passwd entry %s" % w)
1651
comma = gecos.find(',')
1655
realname = gecos[:comma]
1657
return realname, (username + '@' + default_mail_domain)
1660
def parse_username(username):
1661
"""Parse e-mail username and return a (name, address) tuple."""
1662
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1664
return (username, '')
1666
return (match.group(1), match.group(2))
1669
def extract_email_address(e):
1670
"""Return just the address part of an email string.
1672
That is just the user@domain part, nothing else.
1673
This part is required to contain only ascii characters.
1674
If it can't be extracted, raises an error.
1676
>>> extract_email_address('Jane Tester <jane@test.com>')
1679
name, email = parse_username(e)
1681
raise errors.NoEmailInUsername(e)
1685
class TreeConfig(IniBasedConfig):
1686
"""Branch configuration data associated with its contents, not location"""
1688
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1690
def __init__(self, branch):
1691
self._config = branch._get_config()
1692
self.branch = branch
1694
def _get_parser(self, file=None):
1695
if file is not None:
1696
return IniBasedConfig._get_parser(file)
1697
return self._config._get_configobj()
1699
def get_option(self, name, section=None, default=None):
1700
self.branch.lock_read()
1702
return self._config.get_option(name, section, default)
1704
self.branch.unlock()
1706
def set_option(self, value, name, section=None):
1707
"""Set a per-branch configuration option"""
1708
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1709
# higher levels providing the right lock -- vila 20101004
1710
self.branch.lock_write()
1712
self._config.set_option(value, name, section)
1714
self.branch.unlock()
1716
def remove_option(self, option_name, section_name=None):
1717
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1718
# higher levels providing the right lock -- vila 20101004
1719
self.branch.lock_write()
1721
self._config.remove_option(option_name, section_name)
1723
self.branch.unlock()
1726
class AuthenticationConfig(object):
1727
"""The authentication configuration file based on a ini file.
1729
Implements the authentication.conf file described in
1730
doc/developers/authentication-ring.txt.
1733
def __init__(self, _file=None):
1734
self._config = None # The ConfigObj
1736
self._filename = authentication_config_filename()
1737
self._input = self._filename = authentication_config_filename()
1739
# Tests can provide a string as _file
1740
self._filename = None
1743
def _get_config(self):
1744
if self._config is not None:
1747
# FIXME: Should we validate something here ? Includes: empty
1748
# sections are useless, at least one of
1749
# user/password/password_encoding should be defined, etc.
1751
# Note: the encoding below declares that the file itself is utf-8
1752
# encoded, but the values in the ConfigObj are always Unicode.
1753
self._config = ConfigObj(self._input, encoding='utf-8')
1754
except configobj.ConfigObjError, e:
1755
raise errors.ParseConfigError(e.errors, e.config.filename)
1756
except UnicodeError:
1757
raise errors.ConfigContentError(self._filename)
1761
"""Save the config file, only tests should use it for now."""
1762
conf_dir = os.path.dirname(self._filename)
1763
ensure_config_dir_exists(conf_dir)
1764
f = file(self._filename, 'wb')
1766
self._get_config().write(f)
1770
def _set_option(self, section_name, option_name, value):
1771
"""Set an authentication configuration option"""
1772
conf = self._get_config()
1773
section = conf.get(section_name)
1776
section = conf[section]
1777
section[option_name] = value
1780
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1782
"""Returns the matching credentials from authentication.conf file.
1784
:param scheme: protocol
1786
:param host: the server address
1788
:param port: the associated port (optional)
1790
:param user: login (optional)
1792
:param path: the absolute path on the server (optional)
1794
:param realm: the http authentication realm (optional)
1796
:return: A dict containing the matching credentials or None.
1798
- name: the section name of the credentials in the
1799
authentication.conf file,
1800
- user: can't be different from the provided user if any,
1801
- scheme: the server protocol,
1802
- host: the server address,
1803
- port: the server port (can be None),
1804
- path: the absolute server path (can be None),
1805
- realm: the http specific authentication realm (can be None),
1806
- password: the decoded password, could be None if the credential
1807
defines only the user
1808
- verify_certificates: https specific, True if the server
1809
certificate should be verified, False otherwise.
1812
for auth_def_name, auth_def in self._get_config().items():
1813
if type(auth_def) is not configobj.Section:
1814
raise ValueError("%s defined outside a section" % auth_def_name)
1816
a_scheme, a_host, a_user, a_path = map(
1817
auth_def.get, ['scheme', 'host', 'user', 'path'])
1820
a_port = auth_def.as_int('port')
1824
raise ValueError("'port' not numeric in %s" % auth_def_name)
1826
a_verify_certificates = auth_def.as_bool('verify_certificates')
1828
a_verify_certificates = True
1831
"'verify_certificates' not boolean in %s" % auth_def_name)
1834
if a_scheme is not None and scheme != a_scheme:
1836
if a_host is not None:
1837
if not (host == a_host
1838
or (a_host.startswith('.') and host.endswith(a_host))):
1840
if a_port is not None and port != a_port:
1842
if (a_path is not None and path is not None
1843
and not path.startswith(a_path)):
1845
if (a_user is not None and user is not None
1846
and a_user != user):
1847
# Never contradict the caller about the user to be used
1852
# Prepare a credentials dictionary with additional keys
1853
# for the credential providers
1854
credentials = dict(name=auth_def_name,
1861
password=auth_def.get('password', None),
1862
verify_certificates=a_verify_certificates)
1863
# Decode the password in the credentials (or get one)
1864
self.decode_password(credentials,
1865
auth_def.get('password_encoding', None))
1866
if 'auth' in debug.debug_flags:
1867
trace.mutter("Using authentication section: %r", auth_def_name)
1870
if credentials is None:
1871
# No credentials were found in authentication.conf, try the fallback
1872
# credentials stores.
1873
credentials = credential_store_registry.get_fallback_credentials(
1874
scheme, host, port, user, path, realm)
1878
def set_credentials(self, name, host, user, scheme=None, password=None,
1879
port=None, path=None, verify_certificates=None,
1881
"""Set authentication credentials for a host.
1883
Any existing credentials with matching scheme, host, port and path
1884
will be deleted, regardless of name.
1886
:param name: An arbitrary name to describe this set of credentials.
1887
:param host: Name of the host that accepts these credentials.
1888
:param user: The username portion of these credentials.
1889
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1891
:param password: Password portion of these credentials.
1892
:param port: The IP port on the host that these credentials apply to.
1893
:param path: A filesystem path on the host that these credentials
1895
:param verify_certificates: On https, verify server certificates if
1897
:param realm: The http authentication realm (optional).
1899
values = {'host': host, 'user': user}
1900
if password is not None:
1901
values['password'] = password
1902
if scheme is not None:
1903
values['scheme'] = scheme
1904
if port is not None:
1905
values['port'] = '%d' % port
1906
if path is not None:
1907
values['path'] = path
1908
if verify_certificates is not None:
1909
values['verify_certificates'] = str(verify_certificates)
1910
if realm is not None:
1911
values['realm'] = realm
1912
config = self._get_config()
1914
for section, existing_values in config.items():
1915
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1916
if existing_values.get(key) != values.get(key):
1920
config.update({name: values})
1923
def get_user(self, scheme, host, port=None, realm=None, path=None,
1924
prompt=None, ask=False, default=None):
1925
"""Get a user from authentication file.
1927
:param scheme: protocol
1929
:param host: the server address
1931
:param port: the associated port (optional)
1933
:param realm: the realm sent by the server (optional)
1935
:param path: the absolute path on the server (optional)
1937
:param ask: Ask the user if there is no explicitly configured username
1940
:param default: The username returned if none is defined (optional).
1942
:return: The found user.
1944
credentials = self.get_credentials(scheme, host, port, user=None,
1945
path=path, realm=realm)
1946
if credentials is not None:
1947
user = credentials['user']
1953
# Create a default prompt suitable for most cases
1954
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1955
# Special handling for optional fields in the prompt
1956
if port is not None:
1957
prompt_host = '%s:%d' % (host, port)
1960
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1965
def get_password(self, scheme, host, user, port=None,
1966
realm=None, path=None, prompt=None):
1967
"""Get a password from authentication file or prompt the user for one.
1969
:param scheme: protocol
1971
:param host: the server address
1973
:param port: the associated port (optional)
1977
:param realm: the realm sent by the server (optional)
1979
:param path: the absolute path on the server (optional)
1981
:return: The found password or the one entered by the user.
1983
credentials = self.get_credentials(scheme, host, port, user, path,
1985
if credentials is not None:
1986
password = credentials['password']
1987
if password is not None and scheme is 'ssh':
1988
trace.warning('password ignored in section [%s],'
1989
' use an ssh agent instead'
1990
% credentials['name'])
1994
# Prompt user only if we could't find a password
1995
if password is None:
1997
# Create a default prompt suitable for most cases
1998
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
1999
# Special handling for optional fields in the prompt
2000
if port is not None:
2001
prompt_host = '%s:%d' % (host, port)
2004
password = ui.ui_factory.get_password(prompt,
2005
host=prompt_host, user=user)
2008
def decode_password(self, credentials, encoding):
2010
cs = credential_store_registry.get_credential_store(encoding)
2012
raise ValueError('%r is not a known password_encoding' % encoding)
2013
credentials['password'] = cs.decode_password(credentials)
2017
class CredentialStoreRegistry(registry.Registry):
2018
"""A class that registers credential stores.
2020
A credential store provides access to credentials via the password_encoding
2021
field in authentication.conf sections.
2023
Except for stores provided by bzr itself, most stores are expected to be
2024
provided by plugins that will therefore use
2025
register_lazy(password_encoding, module_name, member_name, help=help,
2026
fallback=fallback) to install themselves.
2028
A fallback credential store is one that is queried if no credentials can be
2029
found via authentication.conf.
2032
def get_credential_store(self, encoding=None):
2033
cs = self.get(encoding)
2038
def is_fallback(self, name):
2039
"""Check if the named credentials store should be used as fallback."""
2040
return self.get_info(name)
2042
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2043
path=None, realm=None):
2044
"""Request credentials from all fallback credentials stores.
2046
The first credentials store that can provide credentials wins.
2049
for name in self.keys():
2050
if not self.is_fallback(name):
2052
cs = self.get_credential_store(name)
2053
credentials = cs.get_credentials(scheme, host, port, user,
2055
if credentials is not None:
2056
# We found some credentials
2060
def register(self, key, obj, help=None, override_existing=False,
2062
"""Register a new object to a name.
2064
:param key: This is the key to use to request the object later.
2065
:param obj: The object to register.
2066
:param help: Help text for this entry. This may be a string or
2067
a callable. If it is a callable, it should take two
2068
parameters (registry, key): this registry and the key that
2069
the help was registered under.
2070
:param override_existing: Raise KeyErorr if False and something has
2071
already been registered for that key. If True, ignore if there
2072
is an existing key (always register the new value).
2073
:param fallback: Whether this credential store should be
2076
return super(CredentialStoreRegistry,
2077
self).register(key, obj, help, info=fallback,
2078
override_existing=override_existing)
2080
def register_lazy(self, key, module_name, member_name,
2081
help=None, override_existing=False,
2083
"""Register a new credential store to be loaded on request.
2085
:param module_name: The python path to the module. Such as 'os.path'.
2086
:param member_name: The member of the module to return. If empty or
2087
None, get() will return the module itself.
2088
:param help: Help text for this entry. This may be a string or
2090
:param override_existing: If True, replace the existing object
2091
with the new one. If False, if there is already something
2092
registered with the same key, raise a KeyError
2093
:param fallback: Whether this credential store should be
2096
return super(CredentialStoreRegistry, self).register_lazy(
2097
key, module_name, member_name, help,
2098
info=fallback, override_existing=override_existing)
2101
credential_store_registry = CredentialStoreRegistry()
2104
class CredentialStore(object):
2105
"""An abstract class to implement storage for credentials"""
2107
def decode_password(self, credentials):
2108
"""Returns a clear text password for the provided credentials."""
2109
raise NotImplementedError(self.decode_password)
2111
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2113
"""Return the matching credentials from this credential store.
2115
This method is only called on fallback credential stores.
2117
raise NotImplementedError(self.get_credentials)
2121
class PlainTextCredentialStore(CredentialStore):
2122
__doc__ = """Plain text credential store for the authentication.conf file"""
2124
def decode_password(self, credentials):
2125
"""See CredentialStore.decode_password."""
2126
return credentials['password']
2129
credential_store_registry.register('plain', PlainTextCredentialStore,
2130
help=PlainTextCredentialStore.__doc__)
2131
credential_store_registry.default_key = 'plain'
2134
class Base64CredentialStore(CredentialStore):
2135
__doc__ = """Base64 credential store for the authentication.conf file"""
2137
def decode_password(self, credentials):
2138
"""See CredentialStore.decode_password."""
2139
# GZ 2012-07-28: Will raise binascii.Error if password is not base64,
2140
# should probably propogate as something more useful.
2141
return base64.decodestring(credentials['password'])
2143
credential_store_registry.register('base64', Base64CredentialStore,
2144
help=Base64CredentialStore.__doc__)
2147
class BzrDirConfig(object):
2149
def __init__(self, bzrdir):
2150
self._bzrdir = bzrdir
2151
self._config = bzrdir._get_config()
2153
def set_default_stack_on(self, value):
2154
"""Set the default stacking location.
2156
It may be set to a location, or None.
2158
This policy affects all branches contained by this control dir, except
2159
for those under repositories.
2161
if self._config is None:
2162
raise errors.BzrError("Cannot set configuration in %s"
2165
self._config.set_option('', 'default_stack_on')
2167
self._config.set_option(value, 'default_stack_on')
2169
def get_default_stack_on(self):
2170
"""Return the default stacking location.
2172
This will either be a location, or None.
2174
This policy affects all branches contained by this control dir, except
2175
for those under repositories.
2177
if self._config is None:
2179
value = self._config.get_option('default_stack_on')
2185
class TransportConfig(object):
2186
"""A Config that reads/writes a config file on a Transport.
2188
It is a low-level object that considers config data to be name/value pairs
2189
that may be associated with a section. Assigning meaning to these values
2190
is done at higher levels like TreeConfig.
2193
def __init__(self, transport, filename):
2194
self._transport = transport
2195
self._filename = filename
2197
def get_option(self, name, section=None, default=None):
2198
"""Return the value associated with a named option.
2200
:param name: The name of the value
2201
:param section: The section the option is in (if any)
2202
:param default: The value to return if the value is not set
2203
:return: The value or default value
2205
configobj = self._get_configobj()
2207
section_obj = configobj
2210
section_obj = configobj[section]
2213
value = section_obj.get(name, default)
2214
for hook in OldConfigHooks['get']:
2215
hook(self, name, value)
2218
def set_option(self, value, name, section=None):
2219
"""Set the value associated with a named option.
2221
:param value: The value to set
2222
:param name: The name of the value to set
2223
:param section: The section the option is in (if any)
2225
configobj = self._get_configobj()
2227
configobj[name] = value
2229
configobj.setdefault(section, {})[name] = value
2230
for hook in OldConfigHooks['set']:
2231
hook(self, name, value)
2232
self._set_configobj(configobj)
2234
def remove_option(self, option_name, section_name=None):
2235
configobj = self._get_configobj()
2236
if section_name is None:
2237
del configobj[option_name]
2239
del configobj[section_name][option_name]
2240
for hook in OldConfigHooks['remove']:
2241
hook(self, option_name)
2242
self._set_configobj(configobj)
2244
def _get_config_file(self):
2246
f = StringIO(self._transport.get_bytes(self._filename))
2247
for hook in OldConfigHooks['load']:
2250
except errors.NoSuchFile:
2252
except errors.PermissionDenied, e:
2253
trace.warning("Permission denied while trying to open "
2254
"configuration file %s.", urlutils.unescape_for_display(
2255
urlutils.join(self._transport.base, self._filename), "utf-8"))
2258
def _external_url(self):
2259
return urlutils.join(self._transport.external_url(), self._filename)
2261
def _get_configobj(self):
2262
f = self._get_config_file()
2265
conf = ConfigObj(f, encoding='utf-8')
2266
except configobj.ConfigObjError, e:
2267
raise errors.ParseConfigError(e.errors, self._external_url())
2268
except UnicodeDecodeError:
2269
raise errors.ConfigContentError(self._external_url())
2274
def _set_configobj(self, configobj):
2275
out_file = StringIO()
2276
configobj.write(out_file)
2278
self._transport.put_file(self._filename, out_file)
2279
for hook in OldConfigHooks['save']:
2283
class Option(object):
2284
"""An option definition.
2286
The option *values* are stored in config files and found in sections.
2288
Here we define various properties about the option itself, its default
2289
value, how to convert it from stores, what to do when invalid values are
2290
encoutered, in which config files it can be stored.
2293
def __init__(self, name, override_from_env=None,
2294
default=None, default_from_env=None,
2295
help=None, from_unicode=None, invalid=None, unquote=True):
2296
"""Build an option definition.
2298
:param name: the name used to refer to the option.
2300
:param override_from_env: A list of environment variables which can
2301
provide override any configuration setting.
2303
:param default: the default value to use when none exist in the config
2304
stores. This is either a string that ``from_unicode`` will convert
2305
into the proper type, a callable returning a unicode string so that
2306
``from_unicode`` can be used on the return value, or a python
2307
object that can be stringified (so only the empty list is supported
2310
:param default_from_env: A list of environment variables which can
2311
provide a default value. 'default' will be used only if none of the
2312
variables specified here are set in the environment.
2314
:param help: a doc string to explain the option to the user.
2316
:param from_unicode: a callable to convert the unicode string
2317
representing the option value in a store or its default value.
2319
:param invalid: the action to be taken when an invalid value is
2320
encountered in a store. This is called only when from_unicode is
2321
invoked to convert a string and returns None or raise ValueError or
2322
TypeError. Accepted values are: None (ignore invalid values),
2323
'warning' (emit a warning), 'error' (emit an error message and
2326
:param unquote: should the unicode value be unquoted before conversion.
2327
This should be used only when the store providing the values cannot
2328
safely unquote them (see http://pad.lv/906897). It is provided so
2329
daughter classes can handle the quoting themselves.
2331
if override_from_env is None:
2332
override_from_env = []
2333
if default_from_env is None:
2334
default_from_env = []
2336
self.override_from_env = override_from_env
2337
# Convert the default value to a unicode string so all values are
2338
# strings internally before conversion (via from_unicode) is attempted.
2341
elif isinstance(default, list):
2342
# Only the empty list is supported
2344
raise AssertionError(
2345
'Only empty lists are supported as default values')
2347
elif isinstance(default, (str, unicode, bool, int, float)):
2348
# Rely on python to convert strings, booleans and integers
2349
self.default = u'%s' % (default,)
2350
elif callable(default):
2351
self.default = default
2353
# other python objects are not expected
2354
raise AssertionError('%r is not supported as a default value'
2356
self.default_from_env = default_from_env
2358
self.from_unicode = from_unicode
2359
self.unquote = unquote
2360
if invalid and invalid not in ('warning', 'error'):
2361
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2362
self.invalid = invalid
2368
def convert_from_unicode(self, store, unicode_value):
2369
if self.unquote and store is not None and unicode_value is not None:
2370
unicode_value = store.unquote(unicode_value)
2371
if self.from_unicode is None or unicode_value is None:
2372
# Don't convert or nothing to convert
2373
return unicode_value
2375
converted = self.from_unicode(unicode_value)
2376
except (ValueError, TypeError):
2377
# Invalid values are ignored
2379
if converted is None and self.invalid is not None:
2380
# The conversion failed
2381
if self.invalid == 'warning':
2382
trace.warning('Value "%s" is not valid for "%s"',
2383
unicode_value, self.name)
2384
elif self.invalid == 'error':
2385
raise errors.ConfigOptionValueError(self.name, unicode_value)
2388
def get_override(self):
2390
for var in self.override_from_env:
2392
# If the env variable is defined, its value takes precedence
2393
value = os.environ[var].decode(osutils.get_user_encoding())
2399
def get_default(self):
2401
for var in self.default_from_env:
2403
# If the env variable is defined, its value is the default one
2404
value = os.environ[var].decode(osutils.get_user_encoding())
2409
# Otherwise, fallback to the value defined at registration
2410
if callable(self.default):
2411
value = self.default()
2412
if not isinstance(value, unicode):
2413
raise AssertionError(
2414
"Callable default value for '%s' should be unicode"
2417
value = self.default
2420
def get_help_topic(self):
2423
def get_help_text(self, additional_see_also=None, plain=True):
2425
from bzrlib import help_topics
2426
result += help_topics._format_see_also(additional_see_also)
2428
result = help_topics.help_as_plain_text(result)
2432
# Predefined converters to get proper values from store
2434
def bool_from_store(unicode_str):
2435
return ui.bool_from_string(unicode_str)
2438
def int_from_store(unicode_str):
2439
return int(unicode_str)
2442
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2444
def int_SI_from_store(unicode_str):
2445
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2447
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2448
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2451
:return Integer, expanded to its base-10 value if a proper SI unit is
2452
found, None otherwise.
2454
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2455
p = re.compile(regexp, re.IGNORECASE)
2456
m = p.match(unicode_str)
2459
val, _, unit = m.groups()
2463
coeff = _unit_suffixes[unit.upper()]
2465
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2470
def float_from_store(unicode_str):
2471
return float(unicode_str)
2474
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2476
_list_converter_config = configobj.ConfigObj(
2477
{}, encoding='utf-8', list_values=True, interpolation=False)
2480
class ListOption(Option):
2482
def __init__(self, name, default=None, default_from_env=None,
2483
help=None, invalid=None):
2484
"""A list Option definition.
2486
This overrides the base class so the conversion from a unicode string
2487
can take quoting into account.
2489
super(ListOption, self).__init__(
2490
name, default=default, default_from_env=default_from_env,
2491
from_unicode=self.from_unicode, help=help,
2492
invalid=invalid, unquote=False)
2494
def from_unicode(self, unicode_str):
2495
if not isinstance(unicode_str, basestring):
2497
# Now inject our string directly as unicode. All callers got their
2498
# value from configobj, so values that need to be quoted are already
2500
_list_converter_config.reset()
2501
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2502
maybe_list = _list_converter_config['list']
2503
if isinstance(maybe_list, basestring):
2505
# A single value, most probably the user forgot (or didn't care
2506
# to add) the final ','
2509
# The empty string, convert to empty list
2512
# We rely on ConfigObj providing us with a list already
2517
class RegistryOption(Option):
2518
"""Option for a choice from a registry."""
2520
def __init__(self, name, registry, default_from_env=None,
2521
help=None, invalid=None):
2522
"""A registry based Option definition.
2524
This overrides the base class so the conversion from a unicode string
2525
can take quoting into account.
2527
super(RegistryOption, self).__init__(
2528
name, default=lambda: unicode(registry.default_key),
2529
default_from_env=default_from_env,
2530
from_unicode=self.from_unicode, help=help,
2531
invalid=invalid, unquote=False)
2532
self.registry = registry
2534
def from_unicode(self, unicode_str):
2535
if not isinstance(unicode_str, basestring):
2538
return self.registry.get(unicode_str)
2541
"Invalid value %s for %s."
2542
"See help for a list of possible values." % (unicode_str,
2547
ret = [self._help, "\n\nThe following values are supported:\n"]
2548
for key in self.registry.keys():
2549
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2553
_option_ref_re = lazy_regex.lazy_compile('({[^\d\W](?:\.\w|-\w|\w)*})')
2554
"""Describes an expandable option reference.
2556
We want to match the most embedded reference first.
2558
I.e. for '{{foo}}' we will get '{foo}',
2559
for '{bar{baz}}' we will get '{baz}'
2562
def iter_option_refs(string):
2563
# Split isolate refs so every other chunk is a ref
2565
for chunk in _option_ref_re.split(string):
2570
class OptionRegistry(registry.Registry):
2571
"""Register config options by their name.
2573
This overrides ``registry.Registry`` to simplify registration by acquiring
2574
some information from the option object itself.
2577
def _check_option_name(self, option_name):
2578
"""Ensures an option name is valid.
2580
:param option_name: The name to validate.
2582
if _option_ref_re.match('{%s}' % option_name) is None:
2583
raise errors.IllegalOptionName(option_name)
2585
def register(self, option):
2586
"""Register a new option to its name.
2588
:param option: The option to register. Its name is used as the key.
2590
self._check_option_name(option.name)
2591
super(OptionRegistry, self).register(option.name, option,
2594
def register_lazy(self, key, module_name, member_name):
2595
"""Register a new option to be loaded on request.
2597
:param key: the key to request the option later. Since the registration
2598
is lazy, it should be provided and match the option name.
2600
:param module_name: the python path to the module. Such as 'os.path'.
2602
:param member_name: the member of the module to return. If empty or
2603
None, get() will return the module itself.
2605
self._check_option_name(key)
2606
super(OptionRegistry, self).register_lazy(key,
2607
module_name, member_name)
2609
def get_help(self, key=None):
2610
"""Get the help text associated with the given key"""
2611
option = self.get(key)
2612
the_help = option.help
2613
if callable(the_help):
2614
return the_help(self, key)
2618
option_registry = OptionRegistry()
2621
# Registered options in lexicographical order
2623
option_registry.register(
2624
Option('append_revisions_only',
2625
default=None, from_unicode=bool_from_store, invalid='warning',
2627
Whether to only append revisions to the mainline.
2629
If this is set to true, then it is not possible to change the
2630
existing mainline of the branch.
2632
option_registry.register(
2633
ListOption('acceptable_keys',
2636
List of GPG key patterns which are acceptable for verification.
2638
option_registry.register(
2639
Option('add.maximum_file_size',
2640
default=u'20MB', from_unicode=int_SI_from_store,
2642
Size above which files should be added manually.
2644
Files below this size are added automatically when using ``bzr add`` without
2647
A negative value means disable the size check.
2649
option_registry.register(
2651
default=None, from_unicode=bool_from_store,
2653
Is the branch bound to ``bound_location``.
2655
If set to "True", the branch should act as a checkout, and push each commit to
2656
the bound_location. This option is normally set by ``bind``/``unbind``.
2658
See also: bound_location.
2660
option_registry.register(
2661
Option('bound_location',
2664
The location that commits should go to when acting as a checkout.
2666
This option is normally set by ``bind``.
2670
option_registry.register(
2671
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2673
Whether revisions associated with tags should be fetched.
2675
option_registry.register_lazy(
2676
'bzr.transform.orphan_policy', 'bzrlib.transform', 'opt_transform_orphan')
2677
option_registry.register(
2678
Option('bzr.workingtree.worth_saving_limit', default=10,
2679
from_unicode=int_from_store, invalid='warning',
2681
How many changes before saving the dirstate.
2683
-1 means that we will never rewrite the dirstate file for only
2684
stat-cache changes. Regardless of this setting, we will always rewrite
2685
the dirstate file if a file is added/removed/renamed/etc. This flag only
2686
affects the behavior of updating the dirstate file after we notice that
2687
a file has been touched.
2689
option_registry.register(
2690
Option('bugtracker', default=None,
2692
Default bug tracker to use.
2694
This bug tracker will be used for example when marking bugs
2695
as fixed using ``bzr commit --fixes``, if no explicit
2696
bug tracker was specified.
2698
option_registry.register(
2699
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2700
from_unicode=signature_policy_from_unicode,
2702
GPG checking policy.
2704
Possible values: require, ignore, check-available (default)
2706
this option will control whether bzr will require good gpg
2707
signatures, ignore them, or check them if they are
2710
option_registry.register(
2711
Option('child_submit_format',
2712
help='''The preferred format of submissions to this branch.'''))
2713
option_registry.register(
2714
Option('child_submit_to',
2715
help='''Where submissions to this branch are mailed to.'''))
2716
option_registry.register(
2717
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2718
from_unicode=signing_policy_from_unicode,
2722
Possible values: always, never, when-required (default)
2724
This option controls whether bzr will always create
2725
gpg signatures or not on commits.
2727
option_registry.register(
2728
Option('dirstate.fdatasync', default=True,
2729
from_unicode=bool_from_store,
2731
Flush dirstate changes onto physical disk?
2733
If true (default), working tree metadata changes are flushed through the
2734
OS buffers to physical disk. This is somewhat slower, but means data
2735
should not be lost if the machine crashes. See also repository.fdatasync.
2737
option_registry.register(
2738
ListOption('debug_flags', default=[],
2739
help='Debug flags to activate.'))
2740
option_registry.register(
2741
Option('default_format', default='2a',
2742
help='Format used when creating branches.'))
2743
option_registry.register(
2744
Option('dpush_strict', default=None,
2745
from_unicode=bool_from_store,
2747
The default value for ``dpush --strict``.
2749
If present, defines the ``--strict`` option default value for checking
2750
uncommitted changes before pushing into a different VCS without any
2751
custom bzr metadata.
2753
option_registry.register(
2755
help='The command called to launch an editor to enter a message.'))
2756
option_registry.register(
2757
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2758
help='The users identity'))
2759
option_registry.register(
2760
Option('gpg_signing_command',
2763
Program to use use for creating signatures.
2765
This should support at least the -u and --clearsign options.
2767
option_registry.register(
2768
Option('gpg_signing_key',
2771
GPG key to use for signing.
2773
This defaults to the first key associated with the users email.
2775
option_registry.register(
2776
Option('ignore_missing_extensions', default=False,
2777
from_unicode=bool_from_store,
2779
Control the missing extensions warning display.
2781
The warning will not be emitted if set to True.
2783
option_registry.register(
2785
help='Language to translate messages into.'))
2786
option_registry.register(
2787
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2789
Steal locks that appears to be dead.
2791
If set to True, bzr will check if a lock is supposed to be held by an
2792
active process from the same user on the same machine. If the user and
2793
machine match, but no process with the given PID is active, then bzr
2794
will automatically break the stale lock, and create a new lock for
2796
Otherwise, bzr will prompt as normal to break the lock.
2798
option_registry.register(
2799
Option('log_format', default='long',
2801
Log format to use when displaying revisions.
2803
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2804
may be provided by plugins.
2806
option_registry.register_lazy('mail_client', 'bzrlib.mail_client',
2808
option_registry.register(
2809
Option('output_encoding',
2810
help= 'Unicode encoding for output'
2811
' (terminal encoding if not specified).'))
2812
option_registry.register(
2813
Option('parent_location',
2816
The location of the default branch for pull or merge.
2818
This option is normally set when creating a branch, the first ``pull`` or by
2819
``pull --remember``.
2821
option_registry.register(
2822
Option('post_commit', default=None,
2824
Post commit functions.
2826
An ordered list of python functions to call, separated by spaces.
2828
Each function takes branch, rev_id as parameters.
2830
option_registry.register_lazy('progress_bar', 'bzrlib.ui.text',
2832
option_registry.register(
2833
Option('public_branch',
2836
A publically-accessible version of this branch.
2838
This implies that the branch setting this option is not publically-accessible.
2839
Used and set by ``bzr send``.
2841
option_registry.register(
2842
Option('push_location',
2845
The location of the default branch for push.
2847
This option is normally set by the first ``push`` or ``push --remember``.
2849
option_registry.register(
2850
Option('push_strict', default=None,
2851
from_unicode=bool_from_store,
2853
The default value for ``push --strict``.
2855
If present, defines the ``--strict`` option default value for checking
2856
uncommitted changes before sending a merge directive.
2858
option_registry.register(
2859
Option('repository.fdatasync', default=True,
2860
from_unicode=bool_from_store,
2862
Flush repository changes onto physical disk?
2864
If true (default), repository changes are flushed through the OS buffers
2865
to physical disk. This is somewhat slower, but means data should not be
2866
lost if the machine crashes. See also dirstate.fdatasync.
2868
option_registry.register_lazy('smtp_server',
2869
'bzrlib.smtp_connection', 'smtp_server')
2870
option_registry.register_lazy('smtp_password',
2871
'bzrlib.smtp_connection', 'smtp_password')
2872
option_registry.register_lazy('smtp_username',
2873
'bzrlib.smtp_connection', 'smtp_username')
2874
option_registry.register(
2875
Option('selftest.timeout',
2877
from_unicode=int_from_store,
2878
help='Abort selftest if one test takes longer than this many seconds',
2881
option_registry.register(
2882
Option('send_strict', default=None,
2883
from_unicode=bool_from_store,
2885
The default value for ``send --strict``.
2887
If present, defines the ``--strict`` option default value for checking
2888
uncommitted changes before sending a bundle.
2891
option_registry.register(
2892
Option('serve.client_timeout',
2893
default=300.0, from_unicode=float_from_store,
2894
help="If we wait for a new request from a client for more than"
2895
" X seconds, consider the client idle, and hangup."))
2896
option_registry.register(
2897
Option('stacked_on_location',
2899
help="""The location where this branch is stacked on."""))
2900
option_registry.register(
2901
Option('submit_branch',
2904
The branch you intend to submit your current work to.
2906
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2907
by the ``submit:`` revision spec.
2909
option_registry.register(
2911
help='''Where submissions from this branch are mailed to.'''))
2912
option_registry.register(
2913
ListOption('suppress_warnings',
2915
help="List of warning classes to suppress."))
2916
option_registry.register(
2917
Option('validate_signatures_in_log', default=False,
2918
from_unicode=bool_from_store, invalid='warning',
2919
help='''Whether to validate signatures in bzr log.'''))
2920
option_registry.register_lazy('ssl.ca_certs',
2921
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2923
option_registry.register_lazy('ssl.cert_reqs',
2924
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2927
class Section(object):
2928
"""A section defines a dict of option name => value.
2930
This is merely a read-only dict which can add some knowledge about the
2931
options. It is *not* a python dict object though and doesn't try to mimic
2935
def __init__(self, section_id, options):
2936
self.id = section_id
2937
# We re-use the dict-like object received
2938
self.options = options
2940
def get(self, name, default=None, expand=True):
2941
return self.options.get(name, default)
2943
def iter_option_names(self):
2944
for k in self.options.iterkeys():
2948
# Mostly for debugging use
2949
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2952
_NewlyCreatedOption = object()
2953
"""Was the option created during the MutableSection lifetime"""
2954
_DeletedOption = object()
2955
"""Was the option deleted during the MutableSection lifetime"""
2958
class MutableSection(Section):
2959
"""A section allowing changes and keeping track of the original values."""
2961
def __init__(self, section_id, options):
2962
super(MutableSection, self).__init__(section_id, options)
2963
self.reset_changes()
2965
def set(self, name, value):
2966
if name not in self.options:
2967
# This is a new option
2968
self.orig[name] = _NewlyCreatedOption
2969
elif name not in self.orig:
2970
self.orig[name] = self.get(name, None)
2971
self.options[name] = value
2973
def remove(self, name):
2974
if name not in self.orig and name in self.options:
2975
self.orig[name] = self.get(name, None)
2976
del self.options[name]
2978
def reset_changes(self):
2981
def apply_changes(self, dirty, store):
2982
"""Apply option value changes.
2984
``self`` has been reloaded from the persistent storage. ``dirty``
2985
contains the changes made since the previous loading.
2987
:param dirty: the mutable section containing the changes.
2989
:param store: the store containing the section
2991
for k, expected in dirty.orig.iteritems():
2992
actual = dirty.get(k, _DeletedOption)
2993
reloaded = self.get(k, _NewlyCreatedOption)
2994
if actual is _DeletedOption:
2995
if k in self.options:
2999
# Report concurrent updates in an ad-hoc way. This should only
3000
# occurs when different processes try to update the same option
3001
# which is not supported (as in: the config framework is not meant
3002
# to be used as a sharing mechanism).
3003
if expected != reloaded:
3004
if actual is _DeletedOption:
3005
actual = '<DELETED>'
3006
if reloaded is _NewlyCreatedOption:
3007
reloaded = '<CREATED>'
3008
if expected is _NewlyCreatedOption:
3009
expected = '<CREATED>'
3010
# Someone changed the value since we get it from the persistent
3012
trace.warning(gettext(
3013
"Option {0} in section {1} of {2} was changed"
3014
" from {3} to {4}. The {5} value will be saved.".format(
3015
k, self.id, store.external_url(), expected,
3017
# No need to keep track of these changes
3018
self.reset_changes()
3021
class Store(object):
3022
"""Abstract interface to persistent storage for configuration options."""
3024
readonly_section_class = Section
3025
mutable_section_class = MutableSection
3028
# Which sections need to be saved (by section id). We use a dict here
3029
# so the dirty sections can be shared by multiple callers.
3030
self.dirty_sections = {}
3032
def is_loaded(self):
3033
"""Returns True if the Store has been loaded.
3035
This is used to implement lazy loading and ensure the persistent
3036
storage is queried only when needed.
3038
raise NotImplementedError(self.is_loaded)
3041
"""Loads the Store from persistent storage."""
3042
raise NotImplementedError(self.load)
3044
def _load_from_string(self, bytes):
3045
"""Create a store from a string in configobj syntax.
3047
:param bytes: A string representing the file content.
3049
raise NotImplementedError(self._load_from_string)
3052
"""Unloads the Store.
3054
This should make is_loaded() return False. This is used when the caller
3055
knows that the persistent storage has changed or may have change since
3058
raise NotImplementedError(self.unload)
3060
def quote(self, value):
3061
"""Quote a configuration option value for storing purposes.
3063
This allows Stacks to present values as they will be stored.
3067
def unquote(self, value):
3068
"""Unquote a configuration option value into unicode.
3070
The received value is quoted as stored.
3075
"""Saves the Store to persistent storage."""
3076
raise NotImplementedError(self.save)
3078
def _need_saving(self):
3079
for s in self.dirty_sections.values():
3081
# At least one dirty section contains a modification
3085
def apply_changes(self, dirty_sections):
3086
"""Apply changes from dirty sections while checking for coherency.
3088
The Store content is discarded and reloaded from persistent storage to
3089
acquire up-to-date values.
3091
Dirty sections are MutableSection which kept track of the value they
3092
are expected to update.
3094
# We need an up-to-date version from the persistent storage, unload the
3095
# store. The reload will occur when needed (triggered by the first
3096
# get_mutable_section() call below.
3098
# Apply the changes from the preserved dirty sections
3099
for section_id, dirty in dirty_sections.iteritems():
3100
clean = self.get_mutable_section(section_id)
3101
clean.apply_changes(dirty, self)
3102
# Everything is clean now
3103
self.dirty_sections = {}
3105
def save_changes(self):
3106
"""Saves the Store to persistent storage if changes occurred.
3108
Apply the changes recorded in the mutable sections to a store content
3109
refreshed from persistent storage.
3111
raise NotImplementedError(self.save_changes)
3113
def external_url(self):
3114
raise NotImplementedError(self.external_url)
3116
def get_sections(self):
3117
"""Returns an ordered iterable of existing sections.
3119
:returns: An iterable of (store, section).
3121
raise NotImplementedError(self.get_sections)
3123
def get_mutable_section(self, section_id=None):
3124
"""Returns the specified mutable section.
3126
:param section_id: The section identifier
3128
raise NotImplementedError(self.get_mutable_section)
3131
# Mostly for debugging use
3132
return "<config.%s(%s)>" % (self.__class__.__name__,
3133
self.external_url())
3136
class CommandLineStore(Store):
3137
"A store to carry command line overrides for the config options."""
3139
def __init__(self, opts=None):
3140
super(CommandLineStore, self).__init__()
3147
# The dict should be cleared but not replaced so it can be shared.
3148
self.options.clear()
3150
def _from_cmdline(self, overrides):
3151
# Reset before accepting new definitions
3153
for over in overrides:
3155
name, value = over.split('=', 1)
3157
raise errors.BzrCommandError(
3158
gettext("Invalid '%s', should be of the form 'name=value'")
3160
self.options[name] = value
3162
def external_url(self):
3163
# Not an url but it makes debugging easier and is never needed
3167
def get_sections(self):
3168
yield self, self.readonly_section_class(None, self.options)
3171
class IniFileStore(Store):
3172
"""A config Store using ConfigObj for storage.
3174
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3175
serialize/deserialize the config file.
3179
"""A config Store using ConfigObj for storage.
3181
super(IniFileStore, self).__init__()
3182
self._config_obj = None
3184
def is_loaded(self):
3185
return self._config_obj != None
3188
self._config_obj = None
3189
self.dirty_sections = {}
3191
def _load_content(self):
3192
"""Load the config file bytes.
3194
This should be provided by subclasses
3196
:return: Byte string
3198
raise NotImplementedError(self._load_content)
3200
def _save_content(self, content):
3201
"""Save the config file bytes.
3203
This should be provided by subclasses
3205
:param content: Config file bytes to write
3207
raise NotImplementedError(self._save_content)
3210
"""Load the store from the associated file."""
3211
if self.is_loaded():
3213
content = self._load_content()
3214
self._load_from_string(content)
3215
for hook in ConfigHooks['load']:
3218
def _load_from_string(self, bytes):
3219
"""Create a config store from a string.
3221
:param bytes: A string representing the file content.
3223
if self.is_loaded():
3224
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3225
co_input = StringIO(bytes)
3227
# The config files are always stored utf8-encoded
3228
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3230
except configobj.ConfigObjError, e:
3231
self._config_obj = None
3232
raise errors.ParseConfigError(e.errors, self.external_url())
3233
except UnicodeDecodeError:
3234
raise errors.ConfigContentError(self.external_url())
3236
def save_changes(self):
3237
if not self.is_loaded():
3240
if not self._need_saving():
3242
# Preserve the current version
3243
dirty_sections = dict(self.dirty_sections.items())
3244
self.apply_changes(dirty_sections)
3245
# Save to the persistent storage
3249
if not self.is_loaded():
3253
self._config_obj.write(out)
3254
self._save_content(out.getvalue())
3255
for hook in ConfigHooks['save']:
3258
def get_sections(self):
3259
"""Get the configobj section in the file order.
3261
:returns: An iterable of (store, section).
3263
# We need a loaded store
3266
except (errors.NoSuchFile, errors.PermissionDenied):
3267
# If the file can't be read, there is no sections
3269
cobj = self._config_obj
3271
yield self, self.readonly_section_class(None, cobj)
3272
for section_name in cobj.sections:
3274
self.readonly_section_class(section_name,
3275
cobj[section_name]))
3277
def get_mutable_section(self, section_id=None):
3278
# We need a loaded store
3281
except errors.NoSuchFile:
3282
# The file doesn't exist, let's pretend it was empty
3283
self._load_from_string('')
3284
if section_id in self.dirty_sections:
3285
# We already created a mutable section for this id
3286
return self.dirty_sections[section_id]
3287
if section_id is None:
3288
section = self._config_obj
3290
section = self._config_obj.setdefault(section_id, {})
3291
mutable_section = self.mutable_section_class(section_id, section)
3292
# All mutable sections can become dirty
3293
self.dirty_sections[section_id] = mutable_section
3294
return mutable_section
3296
def quote(self, value):
3298
# configobj conflates automagical list values and quoting
3299
self._config_obj.list_values = True
3300
return self._config_obj._quote(value)
3302
self._config_obj.list_values = False
3304
def unquote(self, value):
3305
if value and isinstance(value, basestring):
3306
# _unquote doesn't handle None nor empty strings nor anything that
3307
# is not a string, really.
3308
value = self._config_obj._unquote(value)
3311
def external_url(self):
3312
# Since an IniFileStore can be used without a file (at least in tests),
3313
# it's better to provide something than raising a NotImplementedError.
3314
# All daughter classes are supposed to provide an implementation
3316
return 'In-Process Store, no URL'
3319
class TransportIniFileStore(IniFileStore):
3320
"""IniFileStore that loads files from a transport.
3322
:ivar transport: The transport object where the config file is located.
3324
:ivar file_name: The config file basename in the transport directory.
3327
def __init__(self, transport, file_name):
3328
"""A Store using a ini file on a Transport
3330
:param transport: The transport object where the config file is located.
3331
:param file_name: The config file basename in the transport directory.
3333
super(TransportIniFileStore, self).__init__()
3334
self.transport = transport
3335
self.file_name = file_name
3337
def _load_content(self):
3339
return self.transport.get_bytes(self.file_name)
3340
except errors.PermissionDenied:
3341
trace.warning("Permission denied while trying to load "
3342
"configuration store %s.", self.external_url())
3345
def _save_content(self, content):
3346
self.transport.put_bytes(self.file_name, content)
3348
def external_url(self):
3349
# FIXME: external_url should really accepts an optional relpath
3350
# parameter (bug #750169) :-/ -- vila 2011-04-04
3351
# The following will do in the interim but maybe we don't want to
3352
# expose a path here but rather a config ID and its associated
3353
# object </hand wawe>.
3354
return urlutils.join(self.transport.external_url(), self.file_name)
3357
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3358
# unlockable stores for use with objects that can already ensure the locking
3359
# (think branches). If different stores (not based on ConfigObj) are created,
3360
# they may face the same issue.
3363
class LockableIniFileStore(TransportIniFileStore):
3364
"""A ConfigObjStore using locks on save to ensure store integrity."""
3366
def __init__(self, transport, file_name, lock_dir_name=None):
3367
"""A config Store using ConfigObj for storage.
3369
:param transport: The transport object where the config file is located.
3371
:param file_name: The config file basename in the transport directory.
3373
if lock_dir_name is None:
3374
lock_dir_name = 'lock'
3375
self.lock_dir_name = lock_dir_name
3376
super(LockableIniFileStore, self).__init__(transport, file_name)
3377
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3379
def lock_write(self, token=None):
3380
"""Takes a write lock in the directory containing the config file.
3382
If the directory doesn't exist it is created.
3384
# FIXME: This doesn't check the ownership of the created directories as
3385
# ensure_config_dir_exists does. It should if the transport is local
3386
# -- vila 2011-04-06
3387
self.transport.create_prefix()
3388
return self._lock.lock_write(token)
3393
def break_lock(self):
3394
self._lock.break_lock()
3398
# We need to be able to override the undecorated implementation
3399
self.save_without_locking()
3401
def save_without_locking(self):
3402
super(LockableIniFileStore, self).save()
3405
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3406
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3407
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3409
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3410
# functions or a registry will make it easier and clearer for tests, focusing
3411
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3412
# on a poolie's remark)
3413
class GlobalStore(LockableIniFileStore):
3414
"""A config store for global options.
3416
There is a single GlobalStore for a given process.
3419
def __init__(self, possible_transports=None):
3420
t = transport.get_transport_from_path(
3421
config_dir(), possible_transports=possible_transports)
3422
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3426
class LocationStore(LockableIniFileStore):
3427
"""A config store for options specific to a location.
3429
There is a single LocationStore for a given process.
3432
def __init__(self, possible_transports=None):
3433
t = transport.get_transport_from_path(
3434
config_dir(), possible_transports=possible_transports)
3435
super(LocationStore, self).__init__(t, 'locations.conf')
3436
self.id = 'locations'
3439
class BranchStore(TransportIniFileStore):
3440
"""A config store for branch options.
3442
There is a single BranchStore for a given branch.
3445
def __init__(self, branch):
3446
super(BranchStore, self).__init__(branch.control_transport,
3448
self.branch = branch
3452
class ControlStore(LockableIniFileStore):
3454
def __init__(self, bzrdir):
3455
super(ControlStore, self).__init__(bzrdir.transport,
3457
lock_dir_name='branch_lock')
3461
class SectionMatcher(object):
3462
"""Select sections into a given Store.
3464
This is intended to be used to postpone getting an iterable of sections
3468
def __init__(self, store):
3471
def get_sections(self):
3472
# This is where we require loading the store so we can see all defined
3474
sections = self.store.get_sections()
3475
# Walk the revisions in the order provided
3476
for store, s in sections:
3480
def match(self, section):
3481
"""Does the proposed section match.
3483
:param section: A Section object.
3485
:returns: True if the section matches, False otherwise.
3487
raise NotImplementedError(self.match)
3490
class NameMatcher(SectionMatcher):
3492
def __init__(self, store, section_id):
3493
super(NameMatcher, self).__init__(store)
3494
self.section_id = section_id
3496
def match(self, section):
3497
return section.id == self.section_id
3500
class LocationSection(Section):
3502
def __init__(self, section, extra_path, branch_name=None):
3503
super(LocationSection, self).__init__(section.id, section.options)
3504
self.extra_path = extra_path
3505
if branch_name is None:
3507
self.locals = {'relpath': extra_path,
3508
'basename': urlutils.basename(extra_path),
3509
'branchname': branch_name}
3511
def get(self, name, default=None, expand=True):
3512
value = super(LocationSection, self).get(name, default)
3513
if value is not None and expand:
3514
policy_name = self.get(name + ':policy', None)
3515
policy = _policy_value.get(policy_name, POLICY_NONE)
3516
if policy == POLICY_APPENDPATH:
3517
value = urlutils.join(value, self.extra_path)
3518
# expand section local options right now (since POLICY_APPENDPATH
3519
# will never add options references, it's ok to expand after it).
3521
for is_ref, chunk in iter_option_refs(value):
3523
chunks.append(chunk)
3526
if ref in self.locals:
3527
chunks.append(self.locals[ref])
3529
chunks.append(chunk)
3530
value = ''.join(chunks)
3534
class StartingPathMatcher(SectionMatcher):
3535
"""Select sections for a given location respecting the Store order."""
3537
# FIXME: Both local paths and urls can be used for section names as well as
3538
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3539
# inherited the fuzziness from the previous ``LocationConfig``
3540
# implementation. We probably need to revisit which encoding is allowed for
3541
# both ``location`` and section names and how we normalize
3542
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3543
# related too. -- vila 2012-01-04
3545
def __init__(self, store, location):
3546
super(StartingPathMatcher, self).__init__(store)
3547
if location.startswith('file://'):
3548
location = urlutils.local_path_from_url(location)
3549
self.location = location
3551
def get_sections(self):
3552
"""Get all sections matching ``location`` in the store.
3554
The most generic sections are described first in the store, then more
3555
specific ones can be provided for reduced scopes.
3557
The returned section are therefore returned in the reversed order so
3558
the most specific ones can be found first.
3560
location_parts = self.location.rstrip('/').split('/')
3562
# Later sections are more specific, they should be returned first
3563
for _, section in reversed(list(store.get_sections())):
3564
if section.id is None:
3565
# The no-name section is always included if present
3566
yield store, LocationSection(section, self.location)
3568
section_path = section.id
3569
if section_path.startswith('file://'):
3570
# the location is already a local path or URL, convert the
3571
# section id to the same format
3572
section_path = urlutils.local_path_from_url(section_path)
3573
if (self.location.startswith(section_path)
3574
or fnmatch.fnmatch(self.location, section_path)):
3575
section_parts = section_path.rstrip('/').split('/')
3576
extra_path = '/'.join(location_parts[len(section_parts):])
3577
yield store, LocationSection(section, extra_path)
3580
class LocationMatcher(SectionMatcher):
3582
def __init__(self, store, location):
3583
super(LocationMatcher, self).__init__(store)
3584
url, params = urlutils.split_segment_parameters(location)
3585
if location.startswith('file://'):
3586
location = urlutils.local_path_from_url(location)
3587
self.location = location
3588
branch_name = params.get('branch')
3589
if branch_name is None:
3590
self.branch_name = urlutils.basename(self.location)
3592
self.branch_name = urlutils.unescape(branch_name)
3594
def _get_matching_sections(self):
3595
"""Get all sections matching ``location``."""
3596
# We slightly diverge from LocalConfig here by allowing the no-name
3597
# section as the most generic one and the lower priority.
3598
no_name_section = None
3600
# Filter out the no_name_section so _iter_for_location_by_parts can be
3601
# used (it assumes all sections have a name).
3602
for _, section in self.store.get_sections():
3603
if section.id is None:
3604
no_name_section = section
3606
all_sections.append(section)
3607
# Unfortunately _iter_for_location_by_parts deals with section names so
3608
# we have to resync.
3609
filtered_sections = _iter_for_location_by_parts(
3610
[s.id for s in all_sections], self.location)
3611
iter_all_sections = iter(all_sections)
3612
matching_sections = []
3613
if no_name_section is not None:
3614
matching_sections.append(
3615
(0, LocationSection(no_name_section, self.location)))
3616
for section_id, extra_path, length in filtered_sections:
3617
# a section id is unique for a given store so it's safe to take the
3618
# first matching section while iterating. Also, all filtered
3619
# sections are part of 'all_sections' and will always be found
3622
section = iter_all_sections.next()
3623
if section_id == section.id:
3624
section = LocationSection(section, extra_path,
3626
matching_sections.append((length, section))
3628
return matching_sections
3630
def get_sections(self):
3631
# Override the default implementation as we want to change the order
3632
matching_sections = self._get_matching_sections()
3633
# We want the longest (aka more specific) locations first
3634
sections = sorted(matching_sections,
3635
key=lambda (length, section): (length, section.id),
3637
# Sections mentioning 'ignore_parents' restrict the selection
3638
for _, section in sections:
3639
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3640
ignore = section.get('ignore_parents', None)
3641
if ignore is not None:
3642
ignore = ui.bool_from_string(ignore)
3645
# Finally, we have a valid section
3646
yield self.store, section
3649
# FIXME: _shared_stores should be an attribute of a library state once a
3650
# library_state object is always available.
3652
_shared_stores_at_exit_installed = False
3654
class Stack(object):
3655
"""A stack of configurations where an option can be defined"""
3657
def __init__(self, sections_def, store=None, mutable_section_id=None):
3658
"""Creates a stack of sections with an optional store for changes.
3660
:param sections_def: A list of Section or callables that returns an
3661
iterable of Section. This defines the Sections for the Stack and
3662
can be called repeatedly if needed.
3664
:param store: The optional Store where modifications will be
3665
recorded. If none is specified, no modifications can be done.
3667
:param mutable_section_id: The id of the MutableSection where changes
3668
are recorded. This requires the ``store`` parameter to be
3671
self.sections_def = sections_def
3673
self.mutable_section_id = mutable_section_id
3675
def iter_sections(self):
3676
"""Iterate all the defined sections."""
3677
# Ensuring lazy loading is achieved by delaying section matching (which
3678
# implies querying the persistent storage) until it can't be avoided
3679
# anymore by using callables to describe (possibly empty) section
3681
for sections in self.sections_def:
3682
for store, section in sections():
3683
yield store, section
3685
def get(self, name, expand=True, convert=True):
3686
"""Return the *first* option value found in the sections.
3688
This is where we guarantee that sections coming from Store are loaded
3689
lazily: the loading is delayed until we need to either check that an
3690
option exists or get its value, which in turn may require to discover
3691
in which sections it can be defined. Both of these (section and option
3692
existence) require loading the store (even partially).
3694
:param name: The queried option.
3696
:param expand: Whether options references should be expanded.
3698
:param convert: Whether the option value should be converted from
3699
unicode (do nothing for non-registered options).
3701
:returns: The value of the option.
3703
# FIXME: No caching of options nor sections yet -- vila 20110503
3705
found_store = None # Where the option value has been found
3706
# If the option is registered, it may provide additional info about
3709
opt = option_registry.get(name)
3714
def expand_and_convert(val):
3715
# This may need to be called in different contexts if the value is
3716
# None or ends up being None during expansion or conversion.
3719
if isinstance(val, basestring):
3720
val = self._expand_options_in_string(val)
3722
trace.warning('Cannot expand "%s":'
3723
' %s does not support option expansion'
3724
% (name, type(val)))
3726
val = found_store.unquote(val)
3728
val = opt.convert_from_unicode(found_store, val)
3731
# First of all, check if the environment can override the configuration
3733
if opt is not None and opt.override_from_env:
3734
value = opt.get_override()
3735
value = expand_and_convert(value)
3737
for store, section in self.iter_sections():
3738
value = section.get(name)
3739
if value is not None:
3742
value = expand_and_convert(value)
3743
if opt is not None and value is None:
3744
# If the option is registered, it may provide a default value
3745
value = opt.get_default()
3746
value = expand_and_convert(value)
3747
for hook in ConfigHooks['get']:
3748
hook(self, name, value)
3751
def expand_options(self, string, env=None):
3752
"""Expand option references in the string in the configuration context.
3754
:param string: The string containing option(s) to expand.
3756
:param env: An option dict defining additional configuration options or
3757
overriding existing ones.
3759
:returns: The expanded string.
3761
return self._expand_options_in_string(string, env)
3763
def _expand_options_in_string(self, string, env=None, _refs=None):
3764
"""Expand options in the string in the configuration context.
3766
:param string: The string to be expanded.
3768
:param env: An option dict defining additional configuration options or
3769
overriding existing ones.
3771
:param _refs: Private list (FIFO) containing the options being expanded
3774
:returns: The expanded string.
3777
# Not much to expand there
3780
# What references are currently resolved (to detect loops)
3783
# We need to iterate until no more refs appear ({{foo}} will need two
3784
# iterations for example).
3789
for is_ref, chunk in iter_option_refs(result):
3791
chunks.append(chunk)
3796
raise errors.OptionExpansionLoop(string, _refs)
3798
value = self._expand_option(name, env, _refs)
3800
raise errors.ExpandingUnknownOption(name, string)
3801
chunks.append(value)
3803
result = ''.join(chunks)
3806
def _expand_option(self, name, env, _refs):
3807
if env is not None and name in env:
3808
# Special case, values provided in env takes precedence over
3812
value = self.get(name, expand=False, convert=False)
3813
value = self._expand_options_in_string(value, env, _refs)
3816
def _get_mutable_section(self):
3817
"""Get the MutableSection for the Stack.
3819
This is where we guarantee that the mutable section is lazily loaded:
3820
this means we won't load the corresponding store before setting a value
3821
or deleting an option. In practice the store will often be loaded but
3822
this helps catching some programming errors.
3825
section = store.get_mutable_section(self.mutable_section_id)
3826
return store, section
3828
def set(self, name, value):
3829
"""Set a new value for the option."""
3830
store, section = self._get_mutable_section()
3831
section.set(name, store.quote(value))
3832
for hook in ConfigHooks['set']:
3833
hook(self, name, value)
3835
def remove(self, name):
3836
"""Remove an existing option."""
3837
_, section = self._get_mutable_section()
3838
section.remove(name)
3839
for hook in ConfigHooks['remove']:
3843
# Mostly for debugging use
3844
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3846
def _get_overrides(self):
3847
# FIXME: Hack around library_state.initialize never called
3848
if bzrlib.global_state is not None:
3849
return bzrlib.global_state.cmdline_overrides.get_sections()
3852
def get_shared_store(self, store, state=None):
3853
"""Get a known shared store.
3855
Store urls uniquely identify them and are used to ensure a single copy
3856
is shared across all users.
3858
:param store: The store known to the caller.
3860
:param state: The library state where the known stores are kept.
3862
:returns: The store received if it's not a known one, an already known
3866
state = bzrlib.global_state
3868
global _shared_stores_at_exit_installed
3869
stores = _shared_stores
3870
def save_config_changes():
3871
for k, store in stores.iteritems():
3872
store.save_changes()
3873
if not _shared_stores_at_exit_installed:
3874
# FIXME: Ugly hack waiting for library_state to always be
3875
# available. -- vila 20120731
3877
atexit.register(save_config_changes)
3878
_shared_stores_at_exit_installed = True
3880
stores = state.config_stores
3881
url = store.external_url()
3889
class MemoryStack(Stack):
3890
"""A configuration stack defined from a string.
3892
This is mainly intended for tests and requires no disk resources.
3895
def __init__(self, content=None):
3896
"""Create an in-memory stack from a given content.
3898
It uses a single store based on configobj and support reading and
3901
:param content: The initial content of the store. If None, the store is
3902
not loaded and ``_load_from_string`` can and should be used if
3905
store = IniFileStore()
3906
if content is not None:
3907
store._load_from_string(content)
3908
super(MemoryStack, self).__init__(
3909
[store.get_sections], store)
3912
class _CompatibleStack(Stack):
3913
"""Place holder for compatibility with previous design.
3915
This is intended to ease the transition from the Config-based design to the
3916
Stack-based design and should not be used nor relied upon by plugins.
3918
One assumption made here is that the daughter classes will all use Stores
3919
derived from LockableIniFileStore).
3921
It implements set() and remove () by re-loading the store before applying
3922
the modification and saving it.
3924
The long term plan being to implement a single write by store to save
3925
all modifications, this class should not be used in the interim.
3928
def set(self, name, value):
3931
super(_CompatibleStack, self).set(name, value)
3932
# Force a write to persistent storage
3935
def remove(self, name):
3938
super(_CompatibleStack, self).remove(name)
3939
# Force a write to persistent storage
3943
class GlobalStack(Stack):
3944
"""Global options only stack.
3946
The following sections are queried:
3948
* command-line overrides,
3950
* the 'DEFAULT' section in bazaar.conf
3952
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3957
gstore = self.get_shared_store(GlobalStore())
3958
super(GlobalStack, self).__init__(
3959
[self._get_overrides,
3960
NameMatcher(gstore, 'DEFAULT').get_sections],
3961
gstore, mutable_section_id='DEFAULT')
3964
class LocationStack(Stack):
3965
"""Per-location options falling back to global options stack.
3968
The following sections are queried:
3970
* command-line overrides,
3972
* the sections matching ``location`` in ``locations.conf``, the order being
3973
defined by the number of path components in the section glob, higher
3974
numbers first (from most specific section to most generic).
3976
* the 'DEFAULT' section in bazaar.conf
3978
This stack will use the ``location`` section in locations.conf as its
3982
def __init__(self, location):
3983
"""Make a new stack for a location and global configuration.
3985
:param location: A URL prefix to """
3986
lstore = self.get_shared_store(LocationStore())
3987
if location.startswith('file://'):
3988
location = urlutils.local_path_from_url(location)
3989
gstore = self.get_shared_store(GlobalStore())
3990
super(LocationStack, self).__init__(
3991
[self._get_overrides,
3992
LocationMatcher(lstore, location).get_sections,
3993
NameMatcher(gstore, 'DEFAULT').get_sections],
3994
lstore, mutable_section_id=location)
3997
class BranchStack(Stack):
3998
"""Per-location options falling back to branch then global options stack.
4000
The following sections are queried:
4002
* command-line overrides,
4004
* the sections matching ``location`` in ``locations.conf``, the order being
4005
defined by the number of path components in the section glob, higher
4006
numbers first (from most specific section to most generic),
4008
* the no-name section in branch.conf,
4010
* the ``DEFAULT`` section in ``bazaar.conf``.
4012
This stack will use the no-name section in ``branch.conf`` as its
4016
def __init__(self, branch):
4017
lstore = self.get_shared_store(LocationStore())
4018
bstore = branch._get_config_store()
4019
gstore = self.get_shared_store(GlobalStore())
4020
super(BranchStack, self).__init__(
4021
[self._get_overrides,
4022
LocationMatcher(lstore, branch.base).get_sections,
4023
NameMatcher(bstore, None).get_sections,
4024
NameMatcher(gstore, 'DEFAULT').get_sections],
4026
self.branch = branch
4028
def lock_write(self, token=None):
4029
return self.branch.lock_write(token)
4032
return self.branch.unlock()
4035
def set(self, name, value):
4036
super(BranchStack, self).set(name, value)
4037
# Unlocking the branch will trigger a store.save_changes() so the last
4038
# unlock saves all the changes.
4041
def remove(self, name):
4042
super(BranchStack, self).remove(name)
4043
# Unlocking the branch will trigger a store.save_changes() so the last
4044
# unlock saves all the changes.
4047
class RemoteControlStack(Stack):
4048
"""Remote control-only options stack."""
4050
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4051
# with the stack used for remote bzr dirs. RemoteControlStack only uses
4052
# control.conf and is used only for stack options.
4054
def __init__(self, bzrdir):
4055
cstore = bzrdir._get_config_store()
4056
super(RemoteControlStack, self).__init__(
4057
[NameMatcher(cstore, None).get_sections],
4059
self.bzrdir = bzrdir
4062
class BranchOnlyStack(Stack):
4063
"""Branch-only options stack."""
4065
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
4066
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
4067
# -- vila 2011-12-16
4069
def __init__(self, branch):
4070
bstore = branch._get_config_store()
4071
super(BranchOnlyStack, self).__init__(
4072
[NameMatcher(bstore, None).get_sections],
4074
self.branch = branch
4076
def lock_write(self, token=None):
4077
return self.branch.lock_write(token)
4080
return self.branch.unlock()
4083
def set(self, name, value):
4084
super(BranchOnlyStack, self).set(name, value)
4085
# Force a write to persistent storage
4086
self.store.save_changes()
4089
def remove(self, name):
4090
super(BranchOnlyStack, self).remove(name)
4091
# Force a write to persistent storage
4092
self.store.save_changes()
4095
class cmd_config(commands.Command):
4096
__doc__ = """Display, set or remove a configuration option.
4098
Display the active value for option NAME.
4100
If --all is specified, NAME is interpreted as a regular expression and all
4101
matching options are displayed mentioning their scope and without resolving
4102
option references in the value). The active value that bzr will take into
4103
account is the first one displayed for each option.
4105
If NAME is not given, --all .* is implied (all options are displayed for the
4108
Setting a value is achieved by using NAME=value without spaces. The value
4109
is set in the most relevant scope and can be checked by displaying the
4112
Removing a value is achieved by using --remove NAME.
4115
takes_args = ['name?']
4119
# FIXME: This should be a registry option so that plugins can register
4120
# their own config files (or not) and will also address
4121
# http://pad.lv/788991 -- vila 20101115
4122
commands.Option('scope', help='Reduce the scope to the specified'
4123
' configuration file.',
4125
commands.Option('all',
4126
help='Display all the defined values for the matching options.',
4128
commands.Option('remove', help='Remove the option from'
4129
' the configuration file.'),
4132
_see_also = ['configuration']
4134
@commands.display_command
4135
def run(self, name=None, all=False, directory=None, scope=None,
4137
if directory is None:
4139
directory = directory_service.directories.dereference(directory)
4140
directory = urlutils.normalize_url(directory)
4142
raise errors.BzrError(
4143
'--all and --remove are mutually exclusive.')
4145
# Delete the option in the given scope
4146
self._remove_config_option(name, directory, scope)
4148
# Defaults to all options
4149
self._show_matching_options('.*', directory, scope)
4152
name, value = name.split('=', 1)
4154
# Display the option(s) value(s)
4156
self._show_matching_options(name, directory, scope)
4158
self._show_value(name, directory, scope)
4161
raise errors.BzrError(
4162
'Only one option can be set.')
4163
# Set the option value
4164
self._set_config_option(name, value, directory, scope)
4166
def _get_stack(self, directory, scope=None, write_access=False):
4167
"""Get the configuration stack specified by ``directory`` and ``scope``.
4169
:param directory: Where the configurations are derived from.
4171
:param scope: A specific config to start from.
4173
:param write_access: Whether a write access to the stack will be
4176
# FIXME: scope should allow access to plugin-specific stacks (even
4177
# reduced to the plugin-specific store), related to
4178
# http://pad.lv/788991 -- vila 2011-11-15
4179
if scope is not None:
4180
if scope == 'bazaar':
4181
return GlobalStack()
4182
elif scope == 'locations':
4183
return LocationStack(directory)
4184
elif scope == 'branch':
4186
controldir.ControlDir.open_containing_tree_or_branch(
4189
self.add_cleanup(br.lock_write().unlock)
4190
return br.get_config_stack()
4191
raise errors.NoSuchConfig(scope)
4195
controldir.ControlDir.open_containing_tree_or_branch(
4198
self.add_cleanup(br.lock_write().unlock)
4199
return br.get_config_stack()
4200
except errors.NotBranchError:
4201
return LocationStack(directory)
4203
def _quote_multiline(self, value):
4205
value = '"""' + value + '"""'
4208
def _show_value(self, name, directory, scope):
4209
conf = self._get_stack(directory, scope)
4210
value = conf.get(name, expand=True, convert=False)
4211
if value is not None:
4212
# Quote the value appropriately
4213
value = self._quote_multiline(value)
4214
self.outf.write('%s\n' % (value,))
4216
raise errors.NoSuchConfigOption(name)
4218
def _show_matching_options(self, name, directory, scope):
4219
name = lazy_regex.lazy_compile(name)
4220
# We want any error in the regexp to be raised *now* so we need to
4221
# avoid the delay introduced by the lazy regexp. But, we still do
4222
# want the nicer errors raised by lazy_regex.
4223
name._compile_and_collapse()
4226
conf = self._get_stack(directory, scope)
4227
for store, section in conf.iter_sections():
4228
for oname in section.iter_option_names():
4229
if name.search(oname):
4230
if cur_store_id != store.id:
4231
# Explain where the options are defined
4232
self.outf.write('%s:\n' % (store.id,))
4233
cur_store_id = store.id
4235
if (section.id is not None and cur_section != section.id):
4236
# Display the section id as it appears in the store
4237
# (None doesn't appear by definition)
4238
self.outf.write(' [%s]\n' % (section.id,))
4239
cur_section = section.id
4240
value = section.get(oname, expand=False)
4241
# Quote the value appropriately
4242
value = self._quote_multiline(value)
4243
self.outf.write(' %s = %s\n' % (oname, value))
4245
def _set_config_option(self, name, value, directory, scope):
4246
conf = self._get_stack(directory, scope, write_access=True)
4247
conf.set(name, value)
4248
# Explicitly save the changes
4249
conf.store.save_changes()
4251
def _remove_config_option(self, name, directory, scope):
4253
raise errors.BzrCommandError(
4254
'--remove expects an option to remove.')
4255
conf = self._get_stack(directory, scope, write_access=True)
4258
# Explicitly save the changes
4259
conf.store.save_changes()
4261
raise errors.NoSuchConfigOption(name)
4266
# We need adapters that can build a Store or a Stack in a test context. Test
4267
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4268
# themselves. The builder will receive a test instance and should return a
4269
# ready-to-use store or stack. Plugins that define new store/stacks can also
4270
# register themselves here to be tested against the tests defined in
4271
# bzrlib.tests.test_config. Note that the builder can be called multiple times
4272
# for the same test.
4274
# The registered object should be a callable receiving a test instance
4275
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4277
test_store_builder_registry = registry.Registry()
4279
# The registered object should be a callable receiving a test instance
4280
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4282
test_stack_builder_registry = registry.Registry()
added
removed
bzrlib/config.py
