1
# Copyright (C) 2005-2012 Canonical Ltd
2
# Authors: Robert Collins <robert.collins@canonical.com>
5
# This program is free software; you can redistribute it and/or modify
6
# it under the terms of the GNU General Public License as published by
7
# the Free Software Foundation; either version 2 of the License, or
8
# (at your option) any later version.
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
# GNU General Public License for more details.
15
# You should have received a copy of the GNU General Public License
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
"""Configuration that affects the behaviour of Bazaar.
21
Currently this configuration resides in ~/.bazaar/bazaar.conf
22
and ~/.bazaar/locations.conf, which is written to by bzr.
24
In bazaar.conf the following options may be set:
26
editor=name-of-program
27
email=Your Name <your@email.address>
28
check_signatures=require|ignore|check-available(default)
29
create_signatures=always|never|when-required(default)
30
gpg_signing_command=name-of-program
31
log_format=name-of-format
32
validate_signatures_in_log=true|false(default)
33
acceptable_keys=pattern1,pattern2
34
gpg_signing_key=amy@example.com
36
in locations.conf, you specify the url of a branch and options for it.
37
Wildcards may be used - * and ? as normal in shell completion. Options
38
set in both bazaar.conf and locations.conf are overridden by the locations.conf
40
[/home/robertc/source]
41
recurse=False|True(default)
43
check_signatures= as above
44
create_signatures= as above.
45
validate_signatures_in_log=as above
46
acceptable_keys=as above
48
explanation of options
49
----------------------
50
editor - this option sets the pop up editor to use during commits.
51
email - this option sets the user id bzr will use when committing.
52
check_signatures - this option will control whether bzr will require good gpg
53
signatures, ignore them, or check them if they are
54
present. Currently it is unused except that check_signatures
55
turns on create_signatures.
56
create_signatures - this option controls whether bzr will always create
57
gpg signatures or not on commits. There is an unused
58
option which in future is expected to work if
59
branch settings require signatures.
60
log_format - this option sets the default log format. Possible values are
61
long, short, line, or a plugin can register new formats.
62
validate_signatures_in_log - show GPG signature validity in log output
63
acceptable_keys - comma separated list of key patterns acceptable for
64
verify-signatures command
66
In bazaar.conf you can also define aliases in the ALIASES sections, example
69
lastlog=log --line -r-10..-1
70
ll=log --line -r-10..-1
75
from __future__ import absolute_import
76
from cStringIO import StringIO
81
from bzrlib.decorators import needs_write_lock
82
from bzrlib.lazy_import import lazy_import
83
lazy_import(globals(), """
104
from bzrlib.i18n import gettext
105
from bzrlib.util.configobj import configobj
113
from bzrlib.symbol_versioning import (
131
POLICY_APPENDPATH = 2
135
POLICY_NORECURSE: 'norecurse',
136
POLICY_APPENDPATH: 'appendpath',
141
'norecurse': POLICY_NORECURSE,
142
'appendpath': POLICY_APPENDPATH,
146
STORE_LOCATION = POLICY_NONE
147
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
148
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
153
def signature_policy_from_unicode(signature_string):
154
"""Convert a string to a signing policy."""
155
if signature_string.lower() == 'check-available':
156
return CHECK_IF_POSSIBLE
157
if signature_string.lower() == 'ignore':
159
if signature_string.lower() == 'require':
161
raise ValueError("Invalid signatures policy '%s'"
165
def signing_policy_from_unicode(signature_string):
166
"""Convert a string to a signing policy."""
167
if signature_string.lower() == 'when-required':
168
return SIGN_WHEN_REQUIRED
169
if signature_string.lower() == 'never':
171
if signature_string.lower() == 'always':
173
raise ValueError("Invalid signing policy '%s'"
177
class ConfigObj(configobj.ConfigObj):
179
def __init__(self, infile=None, **kwargs):
180
# We define our own interpolation mechanism calling it option expansion
181
super(ConfigObj, self).__init__(infile=infile,
185
def get_bool(self, section, key):
186
return self[section].as_bool(key)
188
def get_value(self, section, name):
189
# Try [] for the old DEFAULT section.
190
if section == "DEFAULT":
195
return self[section][name]
198
class Config(object):
199
"""A configuration policy - what username, editor, gpg needs etc."""
202
super(Config, self).__init__()
205
"""Returns a unique ID for the config."""
206
raise NotImplementedError(self.config_id)
208
def get_change_editor(self, old_tree, new_tree):
209
from bzrlib import diff
210
cmd = self._get_change_editor()
213
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
216
def _get_signature_checking(self):
217
"""Template method to override signature checking policy."""
219
def _get_signing_policy(self):
220
"""Template method to override signature creation policy."""
224
def expand_options(self, string, env=None):
225
"""Expand option references in the string in the configuration context.
227
:param string: The string containing option to expand.
229
:param env: An option dict defining additional configuration options or
230
overriding existing ones.
232
:returns: The expanded string.
234
return self._expand_options_in_string(string, env)
236
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
237
"""Expand options in a list of strings in the configuration context.
239
:param slist: A list of strings.
241
:param env: An option dict defining additional configuration options or
242
overriding existing ones.
244
:param _ref_stack: Private list containing the options being
245
expanded to detect loops.
247
:returns: The flatten list of expanded strings.
249
# expand options in each value separately flattening lists
252
value = self._expand_options_in_string(s, env, _ref_stack)
253
if isinstance(value, list):
259
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
260
"""Expand options in the string in the configuration context.
262
:param string: The string to be expanded.
264
:param env: An option dict defining additional configuration options or
265
overriding existing ones.
267
:param _ref_stack: Private list containing the options being
268
expanded to detect loops.
270
:returns: The expanded string.
273
# Not much to expand there
275
if _ref_stack is None:
276
# What references are currently resolved (to detect loops)
278
if self.option_ref_re is None:
279
# We want to match the most embedded reference first (i.e. for
280
# '{{foo}}' we will get '{foo}',
281
# for '{bar{baz}}' we will get '{baz}'
282
self.option_ref_re = re.compile('({[^{}]+})')
284
# We need to iterate until no more refs appear ({{foo}} will need two
285
# iterations for example).
287
raw_chunks = self.option_ref_re.split(result)
288
if len(raw_chunks) == 1:
289
# Shorcut the trivial case: no refs
293
# Split will isolate refs so that every other chunk is a ref
295
for chunk in raw_chunks:
298
# Keep only non-empty strings (or we get bogus empty
299
# slots when a list value is involved).
304
if name in _ref_stack:
305
raise errors.OptionExpansionLoop(string, _ref_stack)
306
_ref_stack.append(name)
307
value = self._expand_option(name, env, _ref_stack)
309
raise errors.ExpandingUnknownOption(name, string)
310
if isinstance(value, list):
318
# Once a list appears as the result of an expansion, all
319
# callers will get a list result. This allows a consistent
320
# behavior even when some options in the expansion chain
321
# defined as strings (no comma in their value) but their
322
# expanded value is a list.
323
return self._expand_options_in_list(chunks, env, _ref_stack)
325
result = ''.join(chunks)
328
def _expand_option(self, name, env, _ref_stack):
329
if env is not None and name in env:
330
# Special case, values provided in env takes precedence over
334
# FIXME: This is a limited implementation, what we really need is a
335
# way to query the bzr config for the value of an option,
336
# respecting the scope rules (That is, once we implement fallback
337
# configs, getting the option value should restart from the top
338
# config, not the current one) -- vila 20101222
339
value = self.get_user_option(name, expand=False)
340
if isinstance(value, list):
341
value = self._expand_options_in_list(value, env, _ref_stack)
343
value = self._expand_options_in_string(value, env, _ref_stack)
346
def _get_user_option(self, option_name):
347
"""Template method to provide a user option."""
350
def get_user_option(self, option_name, expand=True):
351
"""Get a generic option - no special process, no default.
353
:param option_name: The queried option.
355
:param expand: Whether options references should be expanded.
357
:returns: The value of the option.
359
value = self._get_user_option(option_name)
361
if isinstance(value, list):
362
value = self._expand_options_in_list(value)
363
elif isinstance(value, dict):
364
trace.warning('Cannot expand "%s":'
365
' Dicts do not support option expansion'
368
value = self._expand_options_in_string(value)
369
for hook in OldConfigHooks['get']:
370
hook(self, option_name, value)
373
def get_user_option_as_bool(self, option_name, expand=None, default=None):
374
"""Get a generic option as a boolean.
376
:param expand: Allow expanding references to other config values.
377
:param default: Default value if nothing is configured
378
:return None if the option doesn't exist or its value can't be
379
interpreted as a boolean. Returns True or False otherwise.
381
s = self.get_user_option(option_name, expand=expand)
383
# The option doesn't exist
385
val = ui.bool_from_string(s)
387
# The value can't be interpreted as a boolean
388
trace.warning('Value "%s" is not a boolean for "%s"',
392
def get_user_option_as_list(self, option_name, expand=None):
393
"""Get a generic option as a list - no special process, no default.
395
:return None if the option doesn't exist. Returns the value as a list
398
l = self.get_user_option(option_name, expand=expand)
399
if isinstance(l, (str, unicode)):
400
# A single value, most probably the user forgot (or didn't care to
405
@deprecated_method(deprecated_in((2, 5, 0)))
406
def get_user_option_as_int_from_SI(self, option_name, default=None):
407
"""Get a generic option from a human readable size in SI units, e.g 10MB
409
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
410
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
413
:return Integer, expanded to its base-10 value if a proper SI unit is
414
found. If the option doesn't exist, or isn't a value in
415
SI units, return default (which defaults to None)
417
val = self.get_user_option(option_name)
418
if isinstance(val, list):
423
p = re.compile("^(\d+)([kmg])*b*$", re.IGNORECASE)
427
val = int(m.group(1))
428
if m.group(2) is not None:
429
if m.group(2).lower() == 'k':
431
elif m.group(2).lower() == 'm':
433
elif m.group(2).lower() == 'g':
436
ui.ui_factory.show_warning(gettext('Invalid config value for "{0}" '
437
' value {1!r} is not an SI unit.').format(
444
@deprecated_method(deprecated_in((2, 5, 0)))
445
def gpg_signing_command(self):
446
"""What program should be used to sign signatures?"""
447
result = self._gpg_signing_command()
452
def _gpg_signing_command(self):
453
"""See gpg_signing_command()."""
456
@deprecated_method(deprecated_in((2, 5, 0)))
457
def log_format(self):
458
"""What log format should be used"""
459
result = self._log_format()
464
def _log_format(self):
465
"""See log_format()."""
468
def validate_signatures_in_log(self):
469
"""Show GPG signature validity in log"""
470
result = self._validate_signatures_in_log()
477
def _validate_signatures_in_log(self):
478
"""See validate_signatures_in_log()."""
481
@deprecated_method(deprecated_in((2, 5, 0)))
482
def acceptable_keys(self):
483
"""Comma separated list of key patterns acceptable to
484
verify-signatures command"""
485
result = self._acceptable_keys()
488
def _acceptable_keys(self):
489
"""See acceptable_keys()."""
492
@deprecated_method(deprecated_in((2, 5, 0)))
493
def post_commit(self):
494
"""An ordered list of python functions to call.
496
Each function takes branch, rev_id as parameters.
498
return self._post_commit()
500
def _post_commit(self):
501
"""See Config.post_commit."""
504
def user_email(self):
505
"""Return just the email component of a username."""
506
return extract_email_address(self.username())
509
"""Return email-style username.
511
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
513
$BZR_EMAIL can be set to override this, then
514
the concrete policy type is checked, and finally
516
If no username can be found, errors.NoWhoami exception is raised.
518
v = os.environ.get('BZR_EMAIL')
520
return v.decode(osutils.get_user_encoding())
521
v = self._get_user_id()
524
return default_email()
526
def ensure_username(self):
527
"""Raise errors.NoWhoami if username is not set.
529
This method relies on the username() function raising the error.
533
@deprecated_method(deprecated_in((2, 5, 0)))
534
def signature_checking(self):
535
"""What is the current policy for signature checking?."""
536
policy = self._get_signature_checking()
537
if policy is not None:
539
return CHECK_IF_POSSIBLE
541
@deprecated_method(deprecated_in((2, 5, 0)))
542
def signing_policy(self):
543
"""What is the current policy for signature checking?."""
544
policy = self._get_signing_policy()
545
if policy is not None:
547
return SIGN_WHEN_REQUIRED
549
@deprecated_method(deprecated_in((2, 5, 0)))
550
def signature_needed(self):
551
"""Is a signature needed when committing ?."""
552
policy = self._get_signing_policy()
554
policy = self._get_signature_checking()
555
if policy is not None:
556
#this warning should go away once check_signatures is
557
#implemented (if not before)
558
trace.warning("Please use create_signatures,"
559
" not check_signatures to set signing policy.")
560
elif policy == SIGN_ALWAYS:
564
@deprecated_method(deprecated_in((2, 5, 0)))
565
def gpg_signing_key(self):
566
"""GPG user-id to sign commits"""
567
key = self.get_user_option('gpg_signing_key')
568
if key == "default" or key == None:
569
return self.user_email()
573
def get_alias(self, value):
574
return self._get_alias(value)
576
def _get_alias(self, value):
579
def get_nickname(self):
580
return self._get_nickname()
582
def _get_nickname(self):
585
def get_bzr_remote_path(self):
587
return os.environ['BZR_REMOTE_PATH']
589
path = self.get_user_option("bzr_remote_path")
594
def suppress_warning(self, warning):
595
"""Should the warning be suppressed or emitted.
597
:param warning: The name of the warning being tested.
599
:returns: True if the warning should be suppressed, False otherwise.
601
warnings = self.get_user_option_as_list('suppress_warnings')
602
if warnings is None or warning not in warnings:
607
def get_merge_tools(self):
609
for (oname, value, section, conf_id, parser) in self._get_options():
610
if oname.startswith('bzr.mergetool.'):
611
tool_name = oname[len('bzr.mergetool.'):]
612
tools[tool_name] = self.get_user_option(oname, False)
613
trace.mutter('loaded merge tools: %r' % tools)
616
def find_merge_tool(self, name):
617
# We fake a defaults mechanism here by checking if the given name can
618
# be found in the known_merge_tools if it's not found in the config.
619
# This should be done through the proposed config defaults mechanism
620
# when it becomes available in the future.
621
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
623
or mergetools.known_merge_tools.get(name, None))
627
class _ConfigHooks(hooks.Hooks):
628
"""A dict mapping hook names and a list of callables for configs.
632
"""Create the default hooks.
634
These are all empty initially, because by default nothing should get
637
super(_ConfigHooks, self).__init__('bzrlib.config', 'ConfigHooks')
638
self.add_hook('load',
639
'Invoked when a config store is loaded.'
640
' The signature is (store).',
642
self.add_hook('save',
643
'Invoked when a config store is saved.'
644
' The signature is (store).',
646
# The hooks for config options
648
'Invoked when a config option is read.'
649
' The signature is (stack, name, value).',
652
'Invoked when a config option is set.'
653
' The signature is (stack, name, value).',
655
self.add_hook('remove',
656
'Invoked when a config option is removed.'
657
' The signature is (stack, name).',
659
ConfigHooks = _ConfigHooks()
662
class _OldConfigHooks(hooks.Hooks):
663
"""A dict mapping hook names and a list of callables for configs.
667
"""Create the default hooks.
669
These are all empty initially, because by default nothing should get
672
super(_OldConfigHooks, self).__init__('bzrlib.config', 'OldConfigHooks')
673
self.add_hook('load',
674
'Invoked when a config store is loaded.'
675
' The signature is (config).',
677
self.add_hook('save',
678
'Invoked when a config store is saved.'
679
' The signature is (config).',
681
# The hooks for config options
683
'Invoked when a config option is read.'
684
' The signature is (config, name, value).',
687
'Invoked when a config option is set.'
688
' The signature is (config, name, value).',
690
self.add_hook('remove',
691
'Invoked when a config option is removed.'
692
' The signature is (config, name).',
694
OldConfigHooks = _OldConfigHooks()
697
class IniBasedConfig(Config):
698
"""A configuration policy that draws from ini files."""
700
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
702
"""Base class for configuration files using an ini-like syntax.
704
:param file_name: The configuration file path.
706
super(IniBasedConfig, self).__init__()
707
self.file_name = file_name
708
if symbol_versioning.deprecated_passed(get_filename):
709
symbol_versioning.warn(
710
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
711
' Use file_name instead.',
714
if get_filename is not None:
715
self.file_name = get_filename()
717
self.file_name = file_name
722
def from_string(cls, str_or_unicode, file_name=None, save=False):
723
"""Create a config object from a string.
725
:param str_or_unicode: A string representing the file content. This will
728
:param file_name: The configuration file path.
730
:param _save: Whether the file should be saved upon creation.
732
conf = cls(file_name=file_name)
733
conf._create_from_string(str_or_unicode, save)
736
def _create_from_string(self, str_or_unicode, save):
737
self._content = StringIO(str_or_unicode.encode('utf-8'))
738
# Some tests use in-memory configs, some other always need the config
739
# file to exist on disk.
741
self._write_config_file()
743
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
744
if self._parser is not None:
746
if symbol_versioning.deprecated_passed(file):
747
symbol_versioning.warn(
748
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
749
' Use IniBasedConfig(_content=xxx) instead.',
752
if self._content is not None:
753
co_input = self._content
754
elif self.file_name is None:
755
raise AssertionError('We have no content to create the config')
757
co_input = self.file_name
759
self._parser = ConfigObj(co_input, encoding='utf-8')
760
except configobj.ConfigObjError, e:
761
raise errors.ParseConfigError(e.errors, e.config.filename)
762
except UnicodeDecodeError:
763
raise errors.ConfigContentError(self.file_name)
764
# Make sure self.reload() will use the right file name
765
self._parser.filename = self.file_name
766
for hook in OldConfigHooks['load']:
771
"""Reload the config file from disk."""
772
if self.file_name is None:
773
raise AssertionError('We need a file name to reload the config')
774
if self._parser is not None:
775
self._parser.reload()
776
for hook in ConfigHooks['load']:
779
def _get_matching_sections(self):
780
"""Return an ordered list of (section_name, extra_path) pairs.
782
If the section contains inherited configuration, extra_path is
783
a string containing the additional path components.
785
section = self._get_section()
786
if section is not None:
787
return [(section, '')]
791
def _get_section(self):
792
"""Override this to define the section used by the config."""
795
def _get_sections(self, name=None):
796
"""Returns an iterator of the sections specified by ``name``.
798
:param name: The section name. If None is supplied, the default
799
configurations are yielded.
801
:return: A tuple (name, section, config_id) for all sections that will
802
be walked by user_get_option() in the 'right' order. The first one
803
is where set_user_option() will update the value.
805
parser = self._get_parser()
807
yield (name, parser[name], self.config_id())
809
# No section name has been given so we fallback to the configobj
810
# itself which holds the variables defined outside of any section.
811
yield (None, parser, self.config_id())
813
def _get_options(self, sections=None):
814
"""Return an ordered list of (name, value, section, config_id) tuples.
816
All options are returned with their associated value and the section
817
they appeared in. ``config_id`` is a unique identifier for the
818
configuration file the option is defined in.
820
:param sections: Default to ``_get_matching_sections`` if not
821
specified. This gives a better control to daughter classes about
822
which sections should be searched. This is a list of (name,
827
parser = self._get_parser()
829
for (section_name, _) in self._get_matching_sections():
831
section = parser[section_name]
833
# This could happen for an empty file for which we define a
834
# DEFAULT section. FIXME: Force callers to provide sections
835
# instead ? -- vila 20100930
837
sections.append((section_name, section))
838
config_id = self.config_id()
839
for (section_name, section) in sections:
840
for (name, value) in section.iteritems():
841
yield (name, parser._quote(value), section_name,
844
def _get_option_policy(self, section, option_name):
845
"""Return the policy for the given (section, option_name) pair."""
848
def _get_change_editor(self):
849
return self.get_user_option('change_editor')
851
def _get_signature_checking(self):
852
"""See Config._get_signature_checking."""
853
policy = self._get_user_option('check_signatures')
855
return signature_policy_from_unicode(policy)
857
def _get_signing_policy(self):
858
"""See Config._get_signing_policy"""
859
policy = self._get_user_option('create_signatures')
861
return signing_policy_from_unicode(policy)
863
def _get_user_id(self):
864
"""Get the user id from the 'email' key in the current section."""
865
return self._get_user_option('email')
867
def _get_user_option(self, option_name):
868
"""See Config._get_user_option."""
869
for (section, extra_path) in self._get_matching_sections():
871
value = self._get_parser().get_value(section, option_name)
874
policy = self._get_option_policy(section, option_name)
875
if policy == POLICY_NONE:
877
elif policy == POLICY_NORECURSE:
878
# norecurse items only apply to the exact path
883
elif policy == POLICY_APPENDPATH:
885
value = urlutils.join(value, extra_path)
888
raise AssertionError('Unexpected config policy %r' % policy)
892
def _gpg_signing_command(self):
893
"""See Config.gpg_signing_command."""
894
return self._get_user_option('gpg_signing_command')
896
def _log_format(self):
897
"""See Config.log_format."""
898
return self._get_user_option('log_format')
900
def _validate_signatures_in_log(self):
901
"""See Config.validate_signatures_in_log."""
902
return self._get_user_option('validate_signatures_in_log')
904
def _acceptable_keys(self):
905
"""See Config.acceptable_keys."""
906
return self._get_user_option('acceptable_keys')
908
def _post_commit(self):
909
"""See Config.post_commit."""
910
return self._get_user_option('post_commit')
912
def _get_alias(self, value):
914
return self._get_parser().get_value("ALIASES",
919
def _get_nickname(self):
920
return self.get_user_option('nickname')
922
def remove_user_option(self, option_name, section_name=None):
923
"""Remove a user option and save the configuration file.
925
:param option_name: The option to be removed.
927
:param section_name: The section the option is defined in, default to
931
parser = self._get_parser()
932
if section_name is None:
935
section = parser[section_name]
937
del section[option_name]
939
raise errors.NoSuchConfigOption(option_name)
940
self._write_config_file()
941
for hook in OldConfigHooks['remove']:
942
hook(self, option_name)
944
def _write_config_file(self):
945
if self.file_name is None:
946
raise AssertionError('We cannot save, self.file_name is None')
947
conf_dir = os.path.dirname(self.file_name)
948
ensure_config_dir_exists(conf_dir)
949
atomic_file = atomicfile.AtomicFile(self.file_name)
950
self._get_parser().write(atomic_file)
953
osutils.copy_ownership_from_path(self.file_name)
954
for hook in OldConfigHooks['save']:
958
class LockableConfig(IniBasedConfig):
959
"""A configuration needing explicit locking for access.
961
If several processes try to write the config file, the accesses need to be
964
Daughter classes should decorate all methods that update a config with the
965
``@needs_write_lock`` decorator (they call, directly or indirectly, the
966
``_write_config_file()`` method. These methods (typically ``set_option()``
967
and variants must reload the config file from disk before calling
968
``_write_config_file()``), this can be achieved by calling the
969
``self.reload()`` method. Note that the lock scope should cover both the
970
reading and the writing of the config file which is why the decorator can't
971
be applied to ``_write_config_file()`` only.
973
This should be enough to implement the following logic:
974
- lock for exclusive write access,
975
- reload the config file from disk,
979
This logic guarantees that a writer can update a value without erasing an
980
update made by another writer.
985
def __init__(self, file_name):
986
super(LockableConfig, self).__init__(file_name=file_name)
987
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
988
# FIXME: It doesn't matter that we don't provide possible_transports
989
# below since this is currently used only for local config files ;
990
# local transports are not shared. But if/when we start using
991
# LockableConfig for other kind of transports, we will need to reuse
992
# whatever connection is already established -- vila 20100929
993
self.transport = transport.get_transport_from_path(self.dir)
994
self._lock = lockdir.LockDir(self.transport, self.lock_name)
996
def _create_from_string(self, unicode_bytes, save):
997
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
999
# We need to handle the saving here (as opposed to IniBasedConfig)
1000
# to be able to lock
1002
self._write_config_file()
1005
def lock_write(self, token=None):
1006
"""Takes a write lock in the directory containing the config file.
1008
If the directory doesn't exist it is created.
1010
ensure_config_dir_exists(self.dir)
1011
return self._lock.lock_write(token)
1016
def break_lock(self):
1017
self._lock.break_lock()
1020
def remove_user_option(self, option_name, section_name=None):
1021
super(LockableConfig, self).remove_user_option(option_name,
1024
def _write_config_file(self):
1025
if self._lock is None or not self._lock.is_held:
1026
# NB: if the following exception is raised it probably means a
1027
# missing @needs_write_lock decorator on one of the callers.
1028
raise errors.ObjectNotLocked(self)
1029
super(LockableConfig, self)._write_config_file()
1032
class GlobalConfig(LockableConfig):
1033
"""The configuration that should be used for a specific location."""
1036
super(GlobalConfig, self).__init__(file_name=config_filename())
1038
def config_id(self):
1042
def from_string(cls, str_or_unicode, save=False):
1043
"""Create a config object from a string.
1045
:param str_or_unicode: A string representing the file content. This
1046
will be utf-8 encoded.
1048
:param save: Whether the file should be saved upon creation.
1051
conf._create_from_string(str_or_unicode, save)
1055
def set_user_option(self, option, value):
1056
"""Save option and its value in the configuration."""
1057
self._set_option(option, value, 'DEFAULT')
1059
def get_aliases(self):
1060
"""Return the aliases section."""
1061
if 'ALIASES' in self._get_parser():
1062
return self._get_parser()['ALIASES']
1067
def set_alias(self, alias_name, alias_command):
1068
"""Save the alias in the configuration."""
1069
self._set_option(alias_name, alias_command, 'ALIASES')
1072
def unset_alias(self, alias_name):
1073
"""Unset an existing alias."""
1075
aliases = self._get_parser().get('ALIASES')
1076
if not aliases or alias_name not in aliases:
1077
raise errors.NoSuchAlias(alias_name)
1078
del aliases[alias_name]
1079
self._write_config_file()
1081
def _set_option(self, option, value, section):
1083
self._get_parser().setdefault(section, {})[option] = value
1084
self._write_config_file()
1085
for hook in OldConfigHooks['set']:
1086
hook(self, option, value)
1088
def _get_sections(self, name=None):
1089
"""See IniBasedConfig._get_sections()."""
1090
parser = self._get_parser()
1091
# We don't give access to options defined outside of any section, we
1092
# used the DEFAULT section by... default.
1093
if name in (None, 'DEFAULT'):
1094
# This could happen for an empty file where the DEFAULT section
1095
# doesn't exist yet. So we force DEFAULT when yielding
1097
if 'DEFAULT' not in parser:
1098
parser['DEFAULT']= {}
1099
yield (name, parser[name], self.config_id())
1102
def remove_user_option(self, option_name, section_name=None):
1103
if section_name is None:
1104
# We need to force the default section.
1105
section_name = 'DEFAULT'
1106
# We need to avoid the LockableConfig implementation or we'll lock
1108
super(LockableConfig, self).remove_user_option(option_name,
1111
def _iter_for_location_by_parts(sections, location):
1112
"""Keep only the sessions matching the specified location.
1114
:param sections: An iterable of section names.
1116
:param location: An url or a local path to match against.
1118
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1119
number of path components in the section name, section is the section
1120
name and extra_path is the difference between location and the section
1123
``location`` will always be a local path and never a 'file://' url but the
1124
section names themselves can be in either form.
1126
location_parts = location.rstrip('/').split('/')
1128
for section in sections:
1129
# location is a local path if possible, so we need to convert 'file://'
1130
# urls in section names to local paths if necessary.
1132
# This also avoids having file:///path be a more exact
1133
# match than '/path'.
1135
# FIXME: This still raises an issue if a user defines both file:///path
1136
# *and* /path. Should we raise an error in this case -- vila 20110505
1138
if section.startswith('file://'):
1139
section_path = urlutils.local_path_from_url(section)
1141
section_path = section
1142
section_parts = section_path.rstrip('/').split('/')
1145
if len(section_parts) > len(location_parts):
1146
# More path components in the section, they can't match
1149
# Rely on zip truncating in length to the length of the shortest
1150
# argument sequence.
1151
names = zip(location_parts, section_parts)
1153
if not fnmatch.fnmatch(name[0], name[1]):
1158
# build the path difference between the section and the location
1159
extra_path = '/'.join(location_parts[len(section_parts):])
1160
yield section, extra_path, len(section_parts)
1163
class LocationConfig(LockableConfig):
1164
"""A configuration object that gives the policy for a location."""
1166
def __init__(self, location):
1167
super(LocationConfig, self).__init__(
1168
file_name=locations_config_filename())
1169
# local file locations are looked up by local path, rather than
1170
# by file url. This is because the config file is a user
1171
# file, and we would rather not expose the user to file urls.
1172
if location.startswith('file://'):
1173
location = urlutils.local_path_from_url(location)
1174
self.location = location
1176
def config_id(self):
1180
def from_string(cls, str_or_unicode, location, save=False):
1181
"""Create a config object from a string.
1183
:param str_or_unicode: A string representing the file content. This will
1186
:param location: The location url to filter the configuration.
1188
:param save: Whether the file should be saved upon creation.
1190
conf = cls(location)
1191
conf._create_from_string(str_or_unicode, save)
1194
def _get_matching_sections(self):
1195
"""Return an ordered list of section names matching this location."""
1196
matches = list(_iter_for_location_by_parts(self._get_parser(),
1198
# put the longest (aka more specific) locations first
1200
key=lambda (section, extra_path, length): (length, section),
1202
for (section, extra_path, length) in matches:
1203
yield section, extra_path
1204
# should we stop looking for parent configs here?
1206
if self._get_parser()[section].as_bool('ignore_parents'):
1211
def _get_sections(self, name=None):
1212
"""See IniBasedConfig._get_sections()."""
1213
# We ignore the name here as the only sections handled are named with
1214
# the location path and we don't expose embedded sections either.
1215
parser = self._get_parser()
1216
for name, extra_path in self._get_matching_sections():
1217
yield (name, parser[name], self.config_id())
1219
def _get_option_policy(self, section, option_name):
1220
"""Return the policy for the given (section, option_name) pair."""
1221
# check for the old 'recurse=False' flag
1223
recurse = self._get_parser()[section].as_bool('recurse')
1227
return POLICY_NORECURSE
1229
policy_key = option_name + ':policy'
1231
policy_name = self._get_parser()[section][policy_key]
1235
return _policy_value[policy_name]
1237
def _set_option_policy(self, section, option_name, option_policy):
1238
"""Set the policy for the given option name in the given section."""
1239
# The old recurse=False option affects all options in the
1240
# section. To handle multiple policies in the section, we
1241
# need to convert it to a policy_norecurse key.
1243
recurse = self._get_parser()[section].as_bool('recurse')
1247
symbol_versioning.warn(
1248
'The recurse option is deprecated as of 0.14. '
1249
'The section "%s" has been converted to use policies.'
1252
del self._get_parser()[section]['recurse']
1254
for key in self._get_parser()[section].keys():
1255
if not key.endswith(':policy'):
1256
self._get_parser()[section][key +
1257
':policy'] = 'norecurse'
1259
policy_key = option_name + ':policy'
1260
policy_name = _policy_name[option_policy]
1261
if policy_name is not None:
1262
self._get_parser()[section][policy_key] = policy_name
1264
if policy_key in self._get_parser()[section]:
1265
del self._get_parser()[section][policy_key]
1268
def set_user_option(self, option, value, store=STORE_LOCATION):
1269
"""Save option and its value in the configuration."""
1270
if store not in [STORE_LOCATION,
1271
STORE_LOCATION_NORECURSE,
1272
STORE_LOCATION_APPENDPATH]:
1273
raise ValueError('bad storage policy %r for %r' %
1276
location = self.location
1277
if location.endswith('/'):
1278
location = location[:-1]
1279
parser = self._get_parser()
1280
if not location in parser and not location + '/' in parser:
1281
parser[location] = {}
1282
elif location + '/' in parser:
1283
location = location + '/'
1284
parser[location][option]=value
1285
# the allowed values of store match the config policies
1286
self._set_option_policy(location, option, store)
1287
self._write_config_file()
1288
for hook in OldConfigHooks['set']:
1289
hook(self, option, value)
1292
class BranchConfig(Config):
1293
"""A configuration object giving the policy for a branch."""
1295
def __init__(self, branch):
1296
super(BranchConfig, self).__init__()
1297
self._location_config = None
1298
self._branch_data_config = None
1299
self._global_config = None
1300
self.branch = branch
1301
self.option_sources = (self._get_location_config,
1302
self._get_branch_data_config,
1303
self._get_global_config)
1305
def config_id(self):
1308
def _get_branch_data_config(self):
1309
if self._branch_data_config is None:
1310
self._branch_data_config = TreeConfig(self.branch)
1311
self._branch_data_config.config_id = self.config_id
1312
return self._branch_data_config
1314
def _get_location_config(self):
1315
if self._location_config is None:
1316
self._location_config = LocationConfig(self.branch.base)
1317
return self._location_config
1319
def _get_global_config(self):
1320
if self._global_config is None:
1321
self._global_config = GlobalConfig()
1322
return self._global_config
1324
def _get_best_value(self, option_name):
1325
"""This returns a user option from local, tree or global config.
1327
They are tried in that order. Use get_safe_value if trusted values
1330
for source in self.option_sources:
1331
value = getattr(source(), option_name)()
1332
if value is not None:
1336
def _get_safe_value(self, option_name):
1337
"""This variant of get_best_value never returns untrusted values.
1339
It does not return values from the branch data, because the branch may
1340
not be controlled by the user.
1342
We may wish to allow locations.conf to control whether branches are
1343
trusted in the future.
1345
for source in (self._get_location_config, self._get_global_config):
1346
value = getattr(source(), option_name)()
1347
if value is not None:
1351
def _get_user_id(self):
1352
"""Return the full user id for the branch.
1354
e.g. "John Hacker <jhacker@example.com>"
1355
This is looked up in the email controlfile for the branch.
1357
return self._get_best_value('_get_user_id')
1359
def _get_change_editor(self):
1360
return self._get_best_value('_get_change_editor')
1362
def _get_signature_checking(self):
1363
"""See Config._get_signature_checking."""
1364
return self._get_best_value('_get_signature_checking')
1366
def _get_signing_policy(self):
1367
"""See Config._get_signing_policy."""
1368
return self._get_best_value('_get_signing_policy')
1370
def _get_user_option(self, option_name):
1371
"""See Config._get_user_option."""
1372
for source in self.option_sources:
1373
value = source()._get_user_option(option_name)
1374
if value is not None:
1378
def _get_sections(self, name=None):
1379
"""See IniBasedConfig.get_sections()."""
1380
for source in self.option_sources:
1381
for section in source()._get_sections(name):
1384
def _get_options(self, sections=None):
1386
# First the locations options
1387
for option in self._get_location_config()._get_options():
1389
# Then the branch options
1390
branch_config = self._get_branch_data_config()
1391
if sections is None:
1392
sections = [('DEFAULT', branch_config._get_parser())]
1393
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1394
# Config itself has no notion of sections :( -- vila 20101001
1395
config_id = self.config_id()
1396
for (section_name, section) in sections:
1397
for (name, value) in section.iteritems():
1398
yield (name, value, section_name,
1399
config_id, branch_config._get_parser())
1400
# Then the global options
1401
for option in self._get_global_config()._get_options():
1404
def set_user_option(self, name, value, store=STORE_BRANCH,
1406
if store == STORE_BRANCH:
1407
self._get_branch_data_config().set_option(value, name)
1408
elif store == STORE_GLOBAL:
1409
self._get_global_config().set_user_option(name, value)
1411
self._get_location_config().set_user_option(name, value, store)
1414
if store in (STORE_GLOBAL, STORE_BRANCH):
1415
mask_value = self._get_location_config().get_user_option(name)
1416
if mask_value is not None:
1417
trace.warning('Value "%s" is masked by "%s" from'
1418
' locations.conf', value, mask_value)
1420
if store == STORE_GLOBAL:
1421
branch_config = self._get_branch_data_config()
1422
mask_value = branch_config.get_user_option(name)
1423
if mask_value is not None:
1424
trace.warning('Value "%s" is masked by "%s" from'
1425
' branch.conf', value, mask_value)
1427
def remove_user_option(self, option_name, section_name=None):
1428
self._get_branch_data_config().remove_option(option_name, section_name)
1430
def _gpg_signing_command(self):
1431
"""See Config.gpg_signing_command."""
1432
return self._get_safe_value('_gpg_signing_command')
1434
def _post_commit(self):
1435
"""See Config.post_commit."""
1436
return self._get_safe_value('_post_commit')
1438
def _get_nickname(self):
1439
value = self._get_explicit_nickname()
1440
if value is not None:
1442
if self.branch.name:
1443
return self.branch.name
1444
return urlutils.unescape(self.branch.base.split('/')[-2])
1446
def has_explicit_nickname(self):
1447
"""Return true if a nickname has been explicitly assigned."""
1448
return self._get_explicit_nickname() is not None
1450
def _get_explicit_nickname(self):
1451
return self._get_best_value('_get_nickname')
1453
def _log_format(self):
1454
"""See Config.log_format."""
1455
return self._get_best_value('_log_format')
1457
def _validate_signatures_in_log(self):
1458
"""See Config.validate_signatures_in_log."""
1459
return self._get_best_value('_validate_signatures_in_log')
1461
def _acceptable_keys(self):
1462
"""See Config.acceptable_keys."""
1463
return self._get_best_value('_acceptable_keys')
1466
def ensure_config_dir_exists(path=None):
1467
"""Make sure a configuration directory exists.
1468
This makes sure that the directory exists.
1469
On windows, since configuration directories are 2 levels deep,
1470
it makes sure both the directory and the parent directory exists.
1474
if not os.path.isdir(path):
1475
if sys.platform == 'win32':
1476
parent_dir = os.path.dirname(path)
1477
if not os.path.isdir(parent_dir):
1478
trace.mutter('creating config parent directory: %r', parent_dir)
1479
os.mkdir(parent_dir)
1480
trace.mutter('creating config directory: %r', path)
1482
osutils.copy_ownership_from_path(path)
1486
"""Return per-user configuration directory as unicode string
1488
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1489
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1490
that will be used instead.
1492
TODO: Global option --config-dir to override this.
1494
base = osutils.path_from_environ('BZR_HOME')
1495
if sys.platform == 'win32':
1497
base = win32utils.get_appdata_location()
1499
base = win32utils.get_home_location()
1500
# GZ 2012-02-01: Really the two level subdirs only make sense inside
1501
# APPDATA, but hard to move. See bug 348640 for more.
1502
return osutils.pathjoin(base, 'bazaar', '2.0')
1504
# GZ 2012-02-01: What should OSX use instead of XDG if anything?
1505
if sys.platform != 'darwin':
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_DIR', None)
1562
return os.path.expanduser('~/.cache')
1565
def _get_default_mail_domain():
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('/etc/mailname')
1575
except (IOError, OSError), e:
1578
domain = f.read().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 BzrDirConfig(object):
2136
def __init__(self, bzrdir):
2137
self._bzrdir = bzrdir
2138
self._config = bzrdir._get_config()
2140
def set_default_stack_on(self, value):
2141
"""Set the default stacking location.
2143
It may be set to a location, or None.
2145
This policy affects all branches contained by this control dir, except
2146
for those under repositories.
2148
if self._config is None:
2149
raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
2151
self._config.set_option('', 'default_stack_on')
2153
self._config.set_option(value, 'default_stack_on')
2155
def get_default_stack_on(self):
2156
"""Return the default stacking location.
2158
This will either be a location, or None.
2160
This policy affects all branches contained by this control dir, except
2161
for those under repositories.
2163
if self._config is None:
2165
value = self._config.get_option('default_stack_on')
2171
class TransportConfig(object):
2172
"""A Config that reads/writes a config file on a Transport.
2174
It is a low-level object that considers config data to be name/value pairs
2175
that may be associated with a section. Assigning meaning to these values
2176
is done at higher levels like TreeConfig.
2179
def __init__(self, transport, filename):
2180
self._transport = transport
2181
self._filename = filename
2183
def get_option(self, name, section=None, default=None):
2184
"""Return the value associated with a named option.
2186
:param name: The name of the value
2187
:param section: The section the option is in (if any)
2188
:param default: The value to return if the value is not set
2189
:return: The value or default value
2191
configobj = self._get_configobj()
2193
section_obj = configobj
2196
section_obj = configobj[section]
2199
value = section_obj.get(name, default)
2200
for hook in OldConfigHooks['get']:
2201
hook(self, name, value)
2204
def set_option(self, value, name, section=None):
2205
"""Set the value associated with a named option.
2207
:param value: The value to set
2208
:param name: The name of the value to set
2209
:param section: The section the option is in (if any)
2211
configobj = self._get_configobj()
2213
configobj[name] = value
2215
configobj.setdefault(section, {})[name] = value
2216
for hook in OldConfigHooks['set']:
2217
hook(self, name, value)
2218
self._set_configobj(configobj)
2220
def remove_option(self, option_name, section_name=None):
2221
configobj = self._get_configobj()
2222
if section_name is None:
2223
del configobj[option_name]
2225
del configobj[section_name][option_name]
2226
for hook in OldConfigHooks['remove']:
2227
hook(self, option_name)
2228
self._set_configobj(configobj)
2230
def _get_config_file(self):
2232
f = StringIO(self._transport.get_bytes(self._filename))
2233
for hook in OldConfigHooks['load']:
2236
except errors.NoSuchFile:
2238
except errors.PermissionDenied, e:
2239
trace.warning("Permission denied while trying to open "
2240
"configuration file %s.", urlutils.unescape_for_display(
2241
urlutils.join(self._transport.base, self._filename), "utf-8"))
2244
def _external_url(self):
2245
return urlutils.join(self._transport.external_url(), self._filename)
2247
def _get_configobj(self):
2248
f = self._get_config_file()
2251
conf = ConfigObj(f, encoding='utf-8')
2252
except configobj.ConfigObjError, e:
2253
raise errors.ParseConfigError(e.errors, self._external_url())
2254
except UnicodeDecodeError:
2255
raise errors.ConfigContentError(self._external_url())
2260
def _set_configobj(self, configobj):
2261
out_file = StringIO()
2262
configobj.write(out_file)
2264
self._transport.put_file(self._filename, out_file)
2265
for hook in OldConfigHooks['save']:
2269
class Option(object):
2270
"""An option definition.
2272
The option *values* are stored in config files and found in sections.
2274
Here we define various properties about the option itself, its default
2275
value, how to convert it from stores, what to do when invalid values are
2276
encoutered, in which config files it can be stored.
2279
def __init__(self, name, override_from_env=None,
2280
default=None, default_from_env=None,
2281
help=None, from_unicode=None, invalid=None, unquote=True):
2282
"""Build an option definition.
2284
:param name: the name used to refer to the option.
2286
:param override_from_env: A list of environment variables which can
2287
provide override any configuration setting.
2289
:param default: the default value to use when none exist in the config
2290
stores. This is either a string that ``from_unicode`` will convert
2291
into the proper type, a callable returning a unicode string so that
2292
``from_unicode`` can be used on the return value, or a python
2293
object that can be stringified (so only the empty list is supported
2296
:param default_from_env: A list of environment variables which can
2297
provide a default value. 'default' will be used only if none of the
2298
variables specified here are set in the environment.
2300
:param help: a doc string to explain the option to the user.
2302
:param from_unicode: a callable to convert the unicode string
2303
representing the option value in a store. This is not called for
2306
:param invalid: the action to be taken when an invalid value is
2307
encountered in a store. This is called only when from_unicode is
2308
invoked to convert a string and returns None or raise ValueError or
2309
TypeError. Accepted values are: None (ignore invalid values),
2310
'warning' (emit a warning), 'error' (emit an error message and
2313
:param unquote: should the unicode value be unquoted before conversion.
2314
This should be used only when the store providing the values cannot
2315
safely unquote them (see http://pad.lv/906897). It is provided so
2316
daughter classes can handle the quoting themselves.
2318
if override_from_env is None:
2319
override_from_env = []
2320
if default_from_env is None:
2321
default_from_env = []
2323
self.override_from_env = override_from_env
2324
# Convert the default value to a unicode string so all values are
2325
# strings internally before conversion (via from_unicode) is attempted.
2328
elif isinstance(default, list):
2329
# Only the empty list is supported
2331
raise AssertionError(
2332
'Only empty lists are supported as default values')
2334
elif isinstance(default, (str, unicode, bool, int, float)):
2335
# Rely on python to convert strings, booleans and integers
2336
self.default = u'%s' % (default,)
2337
elif callable(default):
2338
self.default = default
2340
# other python objects are not expected
2341
raise AssertionError('%r is not supported as a default value'
2343
self.default_from_env = default_from_env
2345
self.from_unicode = from_unicode
2346
self.unquote = unquote
2347
if invalid and invalid not in ('warning', 'error'):
2348
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2349
self.invalid = invalid
2355
def convert_from_unicode(self, store, unicode_value):
2356
if self.unquote and store is not None and unicode_value is not None:
2357
unicode_value = store.unquote(unicode_value)
2358
if self.from_unicode is None or unicode_value is None:
2359
# Don't convert or nothing to convert
2360
return unicode_value
2362
converted = self.from_unicode(unicode_value)
2363
except (ValueError, TypeError):
2364
# Invalid values are ignored
2366
if converted is None and self.invalid is not None:
2367
# The conversion failed
2368
if self.invalid == 'warning':
2369
trace.warning('Value "%s" is not valid for "%s"',
2370
unicode_value, self.name)
2371
elif self.invalid == 'error':
2372
raise errors.ConfigOptionValueError(self.name, unicode_value)
2375
def get_override(self):
2377
for var in self.override_from_env:
2379
# If the env variable is defined, its value takes precedence
2380
value = os.environ[var].decode(osutils.get_user_encoding())
2386
def get_default(self):
2388
for var in self.default_from_env:
2390
# If the env variable is defined, its value is the default one
2391
value = os.environ[var].decode(osutils.get_user_encoding())
2396
# Otherwise, fallback to the value defined at registration
2397
if callable(self.default):
2398
value = self.default()
2399
if not isinstance(value, unicode):
2400
raise AssertionError(
2401
'Callable default values should be unicode')
2403
value = self.default
2406
def get_help_topic(self):
2409
def get_help_text(self, additional_see_also=None, plain=True):
2411
from bzrlib import help_topics
2412
result += help_topics._format_see_also(additional_see_also)
2414
result = help_topics.help_as_plain_text(result)
2418
# Predefined converters to get proper values from store
2420
def bool_from_store(unicode_str):
2421
return ui.bool_from_string(unicode_str)
2424
def int_from_store(unicode_str):
2425
return int(unicode_str)
2428
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2430
def int_SI_from_store(unicode_str):
2431
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2433
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2434
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2437
:return Integer, expanded to its base-10 value if a proper SI unit is
2438
found, None otherwise.
2440
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2441
p = re.compile(regexp, re.IGNORECASE)
2442
m = p.match(unicode_str)
2445
val, _, unit = m.groups()
2449
coeff = _unit_suffixes[unit.upper()]
2451
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2456
def float_from_store(unicode_str):
2457
return float(unicode_str)
2460
# Use a an empty dict to initialize an empty configobj avoiding all
2461
# parsing and encoding checks
2462
_list_converter_config = configobj.ConfigObj(
2463
{}, encoding='utf-8', list_values=True, interpolation=False)
2466
class ListOption(Option):
2468
def __init__(self, name, default=None, default_from_env=None,
2469
help=None, invalid=None):
2470
"""A list Option definition.
2472
This overrides the base class so the conversion from a unicode string
2473
can take quoting into account.
2475
super(ListOption, self).__init__(
2476
name, default=default, default_from_env=default_from_env,
2477
from_unicode=self.from_unicode, help=help,
2478
invalid=invalid, unquote=False)
2480
def from_unicode(self, unicode_str):
2481
if not isinstance(unicode_str, basestring):
2483
# Now inject our string directly as unicode. All callers got their
2484
# value from configobj, so values that need to be quoted are already
2486
_list_converter_config.reset()
2487
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2488
maybe_list = _list_converter_config['list']
2489
if isinstance(maybe_list, basestring):
2491
# A single value, most probably the user forgot (or didn't care
2492
# to add) the final ','
2495
# The empty string, convert to empty list
2498
# We rely on ConfigObj providing us with a list already
2503
class RegistryOption(Option):
2504
"""Option for a choice from a registry."""
2506
def __init__(self, name, registry, default_from_env=None,
2507
help=None, invalid=None):
2508
"""A registry based Option definition.
2510
This overrides the base class so the conversion from a unicode string
2511
can take quoting into account.
2513
super(RegistryOption, self).__init__(
2514
name, default=lambda: unicode(registry.default_key),
2515
default_from_env=default_from_env,
2516
from_unicode=self.from_unicode, help=help,
2517
invalid=invalid, unquote=False)
2518
self.registry = registry
2520
def from_unicode(self, unicode_str):
2521
if not isinstance(unicode_str, basestring):
2524
return self.registry.get(unicode_str)
2527
"Invalid value %s for %s."
2528
"See help for a list of possible values." % (unicode_str,
2533
ret = [self._help, "\n\nThe following values are supported:\n"]
2534
for key in self.registry.keys():
2535
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2539
class OptionRegistry(registry.Registry):
2540
"""Register config options by their name.
2542
This overrides ``registry.Registry`` to simplify registration by acquiring
2543
some information from the option object itself.
2546
def register(self, option):
2547
"""Register a new option to its name.
2549
:param option: The option to register. Its name is used as the key.
2551
super(OptionRegistry, self).register(option.name, option,
2554
def register_lazy(self, key, module_name, member_name):
2555
"""Register a new option to be loaded on request.
2557
:param key: the key to request the option later. Since the registration
2558
is lazy, it should be provided and match the option name.
2560
:param module_name: the python path to the module. Such as 'os.path'.
2562
:param member_name: the member of the module to return. If empty or
2563
None, get() will return the module itself.
2565
super(OptionRegistry, self).register_lazy(key,
2566
module_name, member_name)
2568
def get_help(self, key=None):
2569
"""Get the help text associated with the given key"""
2570
option = self.get(key)
2571
the_help = option.help
2572
if callable(the_help):
2573
return the_help(self, key)
2577
option_registry = OptionRegistry()
2580
# Registered options in lexicographical order
2582
option_registry.register(
2583
Option('append_revisions_only',
2584
default=None, from_unicode=bool_from_store, invalid='warning',
2586
Whether to only append revisions to the mainline.
2588
If this is set to true, then it is not possible to change the
2589
existing mainline of the branch.
2591
option_registry.register(
2592
ListOption('acceptable_keys',
2595
List of GPG key patterns which are acceptable for verification.
2597
option_registry.register(
2598
Option('add.maximum_file_size',
2599
default=u'20MB', from_unicode=int_SI_from_store,
2601
Size above which files should be added manually.
2603
Files below this size are added automatically when using ``bzr add`` without
2606
A negative value means disable the size check.
2608
option_registry.register(
2610
default=None, from_unicode=bool_from_store,
2612
Is the branch bound to ``bound_location``.
2614
If set to "True", the branch should act as a checkout, and push each commit to
2615
the bound_location. This option is normally set by ``bind``/``unbind``.
2617
See also: bound_location.
2619
option_registry.register(
2620
Option('bound_location',
2623
The location that commits should go to when acting as a checkout.
2625
This option is normally set by ``bind``.
2629
option_registry.register(
2630
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2632
Whether revisions associated with tags should be fetched.
2634
option_registry.register_lazy(
2635
'bzr.transform.orphan_policy', 'bzrlib.transform', 'opt_transform_orphan')
2636
option_registry.register(
2637
Option('bzr.workingtree.worth_saving_limit', default=10,
2638
from_unicode=int_from_store, invalid='warning',
2640
How many changes before saving the dirstate.
2642
-1 means that we will never rewrite the dirstate file for only
2643
stat-cache changes. Regardless of this setting, we will always rewrite
2644
the dirstate file if a file is added/removed/renamed/etc. This flag only
2645
affects the behavior of updating the dirstate file after we notice that
2646
a file has been touched.
2648
option_registry.register(
2649
Option('bugtracker', default=None,
2651
Default bug tracker to use.
2653
This bug tracker will be used for example when marking bugs
2654
as fixed using ``bzr commit --fixes``, if no explicit
2655
bug tracker was specified.
2657
option_registry.register(
2658
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2659
from_unicode=signature_policy_from_unicode,
2661
GPG checking policy.
2663
Possible values: require, ignore, check-available (default)
2665
this option will control whether bzr will require good gpg
2666
signatures, ignore them, or check them if they are
2669
option_registry.register(
2670
Option('child_submit_format',
2671
help='''The preferred format of submissions to this branch.'''))
2672
option_registry.register(
2673
Option('child_submit_to',
2674
help='''Where submissions to this branch are mailed to.'''))
2675
option_registry.register(
2676
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2677
from_unicode=signing_policy_from_unicode,
2681
Possible values: always, never, when-required (default)
2683
This option controls whether bzr will always create
2684
gpg signatures or not on commits.
2686
option_registry.register(
2687
Option('dirstate.fdatasync', default=True,
2688
from_unicode=bool_from_store,
2690
Flush dirstate changes onto physical disk?
2692
If true (default), working tree metadata changes are flushed through the
2693
OS buffers to physical disk. This is somewhat slower, but means data
2694
should not be lost if the machine crashes. See also repository.fdatasync.
2696
option_registry.register(
2697
ListOption('debug_flags', default=[],
2698
help='Debug flags to activate.'))
2699
option_registry.register(
2700
Option('default_format', default='2a',
2701
help='Format used when creating branches.'))
2702
option_registry.register(
2703
Option('dpush_strict', default=None,
2704
from_unicode=bool_from_store,
2706
The default value for ``dpush --strict``.
2708
If present, defines the ``--strict`` option default value for checking
2709
uncommitted changes before pushing into a different VCS without any
2710
custom bzr metadata.
2712
option_registry.register(
2714
help='The command called to launch an editor to enter a message.'))
2715
option_registry.register(
2716
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2717
help='The users identity'))
2718
option_registry.register(
2719
Option('gpg_signing_command',
2722
Program to use use for creating signatures.
2724
This should support at least the -u and --clearsign options.
2726
option_registry.register(
2727
Option('gpg_signing_key',
2730
GPG key to use for signing.
2732
This defaults to the first key associated with the users email.
2734
option_registry.register(
2735
Option('ignore_missing_extensions', default=False,
2736
from_unicode=bool_from_store,
2738
Control the missing extensions warning display.
2740
The warning will not be emitted if set to True.
2742
option_registry.register(
2744
help='Language to translate messages into.'))
2745
option_registry.register(
2746
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2748
Steal locks that appears to be dead.
2750
If set to True, bzr will check if a lock is supposed to be held by an
2751
active process from the same user on the same machine. If the user and
2752
machine match, but no process with the given PID is active, then bzr
2753
will automatically break the stale lock, and create a new lock for
2755
Otherwise, bzr will prompt as normal to break the lock.
2757
option_registry.register(
2758
Option('log_format', default='long',
2760
Log format to use when displaying revisions.
2762
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2763
may be provided by plugins.
2765
option_registry.register_lazy('mail_client', 'bzrlib.mail_client',
2767
option_registry.register(
2768
Option('output_encoding',
2769
help= 'Unicode encoding for output'
2770
' (terminal encoding if not specified).'))
2771
option_registry.register(
2772
Option('parent_location',
2775
The location of the default branch for pull or merge.
2777
This option is normally set when creating a branch, the first ``pull`` or by
2778
``pull --remember``.
2780
option_registry.register(
2781
Option('post_commit', default=None,
2783
Post commit functions.
2785
An ordered list of python functions to call, separated by spaces.
2787
Each function takes branch, rev_id as parameters.
2789
option_registry.register(
2790
Option('public_branch',
2793
A publically-accessible version of this branch.
2795
This implies that the branch setting this option is not publically-accessible.
2796
Used and set by ``bzr send``.
2798
option_registry.register(
2799
Option('push_location',
2802
The location of the default branch for push.
2804
This option is normally set by the first ``push`` or ``push --remember``.
2806
option_registry.register(
2807
Option('push_strict', default=None,
2808
from_unicode=bool_from_store,
2810
The default value for ``push --strict``.
2812
If present, defines the ``--strict`` option default value for checking
2813
uncommitted changes before sending a merge directive.
2815
option_registry.register(
2816
Option('repository.fdatasync', default=True,
2817
from_unicode=bool_from_store,
2819
Flush repository changes onto physical disk?
2821
If true (default), repository changes are flushed through the OS buffers
2822
to physical disk. This is somewhat slower, but means data should not be
2823
lost if the machine crashes. See also dirstate.fdatasync.
2825
option_registry.register_lazy('smtp_server',
2826
'bzrlib.smtp_connection', 'smtp_server')
2827
option_registry.register_lazy('smtp_password',
2828
'bzrlib.smtp_connection', 'smtp_password')
2829
option_registry.register_lazy('smtp_username',
2830
'bzrlib.smtp_connection', 'smtp_username')
2831
option_registry.register(
2832
Option('selftest.timeout',
2834
from_unicode=int_from_store,
2835
help='Abort selftest if one test takes longer than this many seconds',
2838
option_registry.register(
2839
Option('send_strict', default=None,
2840
from_unicode=bool_from_store,
2842
The default value for ``send --strict``.
2844
If present, defines the ``--strict`` option default value for checking
2845
uncommitted changes before sending a bundle.
2848
option_registry.register(
2849
Option('serve.client_timeout',
2850
default=300.0, from_unicode=float_from_store,
2851
help="If we wait for a new request from a client for more than"
2852
" X seconds, consider the client idle, and hangup."))
2853
option_registry.register(
2854
Option('stacked_on_location',
2856
help="""The location where this branch is stacked on."""))
2857
option_registry.register(
2858
Option('submit_branch',
2861
The branch you intend to submit your current work to.
2863
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2864
by the ``submit:`` revision spec.
2866
option_registry.register(
2868
help='''Where submissions from this branch are mailed to.'''))
2869
option_registry.register(
2870
ListOption('suppress_warnings',
2872
help="List of warning classes to suppress."))
2873
option_registry.register(
2874
Option('validate_signatures_in_log', default=False,
2875
from_unicode=bool_from_store, invalid='warning',
2876
help='''Whether to validate signatures in bzr log.'''))
2877
option_registry.register_lazy('ssl.ca_certs',
2878
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2880
option_registry.register_lazy('ssl.cert_reqs',
2881
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2884
class Section(object):
2885
"""A section defines a dict of option name => value.
2887
This is merely a read-only dict which can add some knowledge about the
2888
options. It is *not* a python dict object though and doesn't try to mimic
2892
def __init__(self, section_id, options):
2893
self.id = section_id
2894
# We re-use the dict-like object received
2895
self.options = options
2897
def get(self, name, default=None, expand=True):
2898
return self.options.get(name, default)
2900
def iter_option_names(self):
2901
for k in self.options.iterkeys():
2905
# Mostly for debugging use
2906
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2909
_NewlyCreatedOption = object()
2910
"""Was the option created during the MutableSection lifetime"""
2911
_DeletedOption = object()
2912
"""Was the option deleted during the MutableSection lifetime"""
2915
class MutableSection(Section):
2916
"""A section allowing changes and keeping track of the original values."""
2918
def __init__(self, section_id, options):
2919
super(MutableSection, self).__init__(section_id, options)
2920
self.reset_changes()
2922
def set(self, name, value):
2923
if name not in self.options:
2924
# This is a new option
2925
self.orig[name] = _NewlyCreatedOption
2926
elif name not in self.orig:
2927
self.orig[name] = self.get(name, None)
2928
self.options[name] = value
2930
def remove(self, name):
2931
if name not in self.orig:
2932
self.orig[name] = self.get(name, None)
2933
del self.options[name]
2935
def reset_changes(self):
2938
def apply_changes(self, dirty, store):
2939
"""Apply option value changes.
2941
``self`` has been reloaded from the persistent storage. ``dirty``
2942
contains the changes made since the previous loading.
2944
:param dirty: the mutable section containing the changes.
2946
:param store: the store containing the section
2948
for k, expected in dirty.orig.iteritems():
2949
actual = dirty.get(k, _DeletedOption)
2950
reloaded = self.get(k, _NewlyCreatedOption)
2951
if actual is _DeletedOption:
2952
if k in self.options:
2956
# Report concurrent updates in an ad-hoc way. This should only
2957
# occurs when different processes try to update the same option
2958
# which is not supported (as in: the config framework is not meant
2959
# to be used a sharing mechanism).
2960
if expected != reloaded:
2961
if actual is _DeletedOption:
2962
actual = '<DELETED>'
2963
if reloaded is _NewlyCreatedOption:
2964
reloaded = '<CREATED>'
2965
if expected is _NewlyCreatedOption:
2966
expected = '<CREATED>'
2967
# Someone changed the value since we get it from the persistent
2969
trace.warning(gettext(
2970
"Option {0} in section {1} of {2} was changed"
2971
" from {3} to {4}. The {5} value will be saved.".format(
2972
k, self.id, store.external_url(), expected,
2974
# No need to keep track of these changes
2975
self.reset_changes()
2978
class Store(object):
2979
"""Abstract interface to persistent storage for configuration options."""
2981
readonly_section_class = Section
2982
mutable_section_class = MutableSection
2985
# Which sections need to be saved
2986
self.dirty_sections = []
2988
def is_loaded(self):
2989
"""Returns True if the Store has been loaded.
2991
This is used to implement lazy loading and ensure the persistent
2992
storage is queried only when needed.
2994
raise NotImplementedError(self.is_loaded)
2997
"""Loads the Store from persistent storage."""
2998
raise NotImplementedError(self.load)
3000
def _load_from_string(self, bytes):
3001
"""Create a store from a string in configobj syntax.
3003
:param bytes: A string representing the file content.
3005
raise NotImplementedError(self._load_from_string)
3008
"""Unloads the Store.
3010
This should make is_loaded() return False. This is used when the caller
3011
knows that the persistent storage has changed or may have change since
3014
raise NotImplementedError(self.unload)
3016
def quote(self, value):
3017
"""Quote a configuration option value for storing purposes.
3019
This allows Stacks to present values as they will be stored.
3023
def unquote(self, value):
3024
"""Unquote a configuration option value into unicode.
3026
The received value is quoted as stored.
3031
"""Saves the Store to persistent storage."""
3032
raise NotImplementedError(self.save)
3034
def _need_saving(self):
3035
for s in self.dirty_sections:
3037
# At least one dirty section contains a modification
3041
def apply_changes(self, dirty_sections):
3042
"""Apply changes from dirty sections while checking for coherency.
3044
The Store content is discarded and reloaded from persistent storage to
3045
acquire up-to-date values.
3047
Dirty sections are MutableSection which kept track of the value they
3048
are expected to update.
3050
# We need an up-to-date version from the persistent storage, unload the
3051
# store. The reload will occur when needed (triggered by the first
3052
# get_mutable_section() call below.
3054
# Apply the changes from the preserved dirty sections
3055
for dirty in dirty_sections:
3056
clean = self.get_mutable_section(dirty.id)
3057
clean.apply_changes(dirty, self)
3058
# Everything is clean now
3059
self.dirty_sections = []
3061
def save_changes(self):
3062
"""Saves the Store to persistent storage if changes occurred.
3064
Apply the changes recorded in the mutable sections to a store content
3065
refreshed from persistent storage.
3067
raise NotImplementedError(self.save_changes)
3069
def external_url(self):
3070
raise NotImplementedError(self.external_url)
3072
def get_sections(self):
3073
"""Returns an ordered iterable of existing sections.
3075
:returns: An iterable of (store, section).
3077
raise NotImplementedError(self.get_sections)
3079
def get_mutable_section(self, section_id=None):
3080
"""Returns the specified mutable section.
3082
:param section_id: The section identifier
3084
raise NotImplementedError(self.get_mutable_section)
3087
# Mostly for debugging use
3088
return "<config.%s(%s)>" % (self.__class__.__name__,
3089
self.external_url())
3092
class CommandLineStore(Store):
3093
"A store to carry command line overrides for the config options."""
3095
def __init__(self, opts=None):
3096
super(CommandLineStore, self).__init__()
3103
# The dict should be cleared but not replaced so it can be shared.
3104
self.options.clear()
3106
def _from_cmdline(self, overrides):
3107
# Reset before accepting new definitions
3109
for over in overrides:
3111
name, value = over.split('=', 1)
3113
raise errors.BzrCommandError(
3114
gettext("Invalid '%s', should be of the form 'name=value'")
3116
self.options[name] = value
3118
def external_url(self):
3119
# Not an url but it makes debugging easier and is never needed
3123
def get_sections(self):
3124
yield self, self.readonly_section_class(None, self.options)
3127
class IniFileStore(Store):
3128
"""A config Store using ConfigObj for storage.
3130
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3131
serialize/deserialize the config file.
3135
"""A config Store using ConfigObj for storage.
3137
super(IniFileStore, self).__init__()
3138
self._config_obj = None
3140
def is_loaded(self):
3141
return self._config_obj != None
3144
self._config_obj = None
3145
self.dirty_sections = []
3147
def _load_content(self):
3148
"""Load the config file bytes.
3150
This should be provided by subclasses
3152
:return: Byte string
3154
raise NotImplementedError(self._load_content)
3156
def _save_content(self, content):
3157
"""Save the config file bytes.
3159
This should be provided by subclasses
3161
:param content: Config file bytes to write
3163
raise NotImplementedError(self._save_content)
3166
"""Load the store from the associated file."""
3167
if self.is_loaded():
3169
content = self._load_content()
3170
self._load_from_string(content)
3171
for hook in ConfigHooks['load']:
3174
def _load_from_string(self, bytes):
3175
"""Create a config store from a string.
3177
:param bytes: A string representing the file content.
3179
if self.is_loaded():
3180
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3181
co_input = StringIO(bytes)
3183
# The config files are always stored utf8-encoded
3184
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3186
except configobj.ConfigObjError, e:
3187
self._config_obj = None
3188
raise errors.ParseConfigError(e.errors, self.external_url())
3189
except UnicodeDecodeError:
3190
raise errors.ConfigContentError(self.external_url())
3192
def save_changes(self):
3193
if not self.is_loaded():
3196
if not self._need_saving():
3198
# Preserve the current version
3199
current = self._config_obj
3200
dirty_sections = list(self.dirty_sections)
3201
self.apply_changes(dirty_sections)
3202
# Save to the persistent storage
3206
if not self.is_loaded():
3210
self._config_obj.write(out)
3211
self._save_content(out.getvalue())
3212
for hook in ConfigHooks['save']:
3215
def get_sections(self):
3216
"""Get the configobj section in the file order.
3218
:returns: An iterable of (store, section).
3220
# We need a loaded store
3223
except (errors.NoSuchFile, errors.PermissionDenied):
3224
# If the file can't be read, there is no sections
3226
cobj = self._config_obj
3228
yield self, self.readonly_section_class(None, cobj)
3229
for section_name in cobj.sections:
3231
self.readonly_section_class(section_name,
3232
cobj[section_name]))
3234
def get_mutable_section(self, section_id=None):
3235
# We need a loaded store
3238
except errors.NoSuchFile:
3239
# The file doesn't exist, let's pretend it was empty
3240
self._load_from_string('')
3241
if section_id is None:
3242
section = self._config_obj
3244
section = self._config_obj.setdefault(section_id, {})
3245
mutable_section = self.mutable_section_class(section_id, section)
3246
# All mutable sections can become dirty
3247
self.dirty_sections.append(mutable_section)
3248
return mutable_section
3250
def quote(self, value):
3252
# configobj conflates automagical list values and quoting
3253
self._config_obj.list_values = True
3254
return self._config_obj._quote(value)
3256
self._config_obj.list_values = False
3258
def unquote(self, value):
3259
if value and isinstance(value, basestring):
3260
# _unquote doesn't handle None nor empty strings nor anything that
3261
# is not a string, really.
3262
value = self._config_obj._unquote(value)
3265
def external_url(self):
3266
# Since an IniFileStore can be used without a file (at least in tests),
3267
# it's better to provide something than raising a NotImplementedError.
3268
# All daughter classes are supposed to provide an implementation
3270
return 'In-Process Store, no URL'
3272
class TransportIniFileStore(IniFileStore):
3273
"""IniFileStore that loads files from a transport.
3275
:ivar transport: The transport object where the config file is located.
3277
:ivar file_name: The config file basename in the transport directory.
3280
def __init__(self, transport, file_name):
3281
"""A Store using a ini file on a Transport
3283
:param transport: The transport object where the config file is located.
3284
:param file_name: The config file basename in the transport directory.
3286
super(TransportIniFileStore, self).__init__()
3287
self.transport = transport
3288
self.file_name = file_name
3290
def _load_content(self):
3292
return self.transport.get_bytes(self.file_name)
3293
except errors.PermissionDenied:
3294
trace.warning("Permission denied while trying to load "
3295
"configuration store %s.", self.external_url())
3298
def _save_content(self, content):
3299
self.transport.put_bytes(self.file_name, content)
3301
def external_url(self):
3302
# FIXME: external_url should really accepts an optional relpath
3303
# parameter (bug #750169) :-/ -- vila 2011-04-04
3304
# The following will do in the interim but maybe we don't want to
3305
# expose a path here but rather a config ID and its associated
3306
# object </hand wawe>.
3307
return urlutils.join(self.transport.external_url(), self.file_name)
3310
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3311
# unlockable stores for use with objects that can already ensure the locking
3312
# (think branches). If different stores (not based on ConfigObj) are created,
3313
# they may face the same issue.
3316
class LockableIniFileStore(TransportIniFileStore):
3317
"""A ConfigObjStore using locks on save to ensure store integrity."""
3319
def __init__(self, transport, file_name, lock_dir_name=None):
3320
"""A config Store using ConfigObj for storage.
3322
:param transport: The transport object where the config file is located.
3324
:param file_name: The config file basename in the transport directory.
3326
if lock_dir_name is None:
3327
lock_dir_name = 'lock'
3328
self.lock_dir_name = lock_dir_name
3329
super(LockableIniFileStore, self).__init__(transport, file_name)
3330
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3332
def lock_write(self, token=None):
3333
"""Takes a write lock in the directory containing the config file.
3335
If the directory doesn't exist it is created.
3337
# FIXME: This doesn't check the ownership of the created directories as
3338
# ensure_config_dir_exists does. It should if the transport is local
3339
# -- vila 2011-04-06
3340
self.transport.create_prefix()
3341
return self._lock.lock_write(token)
3346
def break_lock(self):
3347
self._lock.break_lock()
3351
# We need to be able to override the undecorated implementation
3352
self.save_without_locking()
3354
def save_without_locking(self):
3355
super(LockableIniFileStore, self).save()
3358
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3359
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3360
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3362
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3363
# functions or a registry will make it easier and clearer for tests, focusing
3364
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3365
# on a poolie's remark)
3366
class GlobalStore(LockableIniFileStore):
3368
def __init__(self, possible_transports=None):
3369
t = transport.get_transport_from_path(
3370
config_dir(), possible_transports=possible_transports)
3371
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3375
class LocationStore(LockableIniFileStore):
3377
def __init__(self, possible_transports=None):
3378
t = transport.get_transport_from_path(
3379
config_dir(), possible_transports=possible_transports)
3380
super(LocationStore, self).__init__(t, 'locations.conf')
3381
self.id = 'locations'
3384
class BranchStore(TransportIniFileStore):
3386
def __init__(self, branch):
3387
super(BranchStore, self).__init__(branch.control_transport,
3389
self.branch = branch
3393
class ControlStore(LockableIniFileStore):
3395
def __init__(self, bzrdir):
3396
super(ControlStore, self).__init__(bzrdir.transport,
3398
lock_dir_name='branch_lock')
3402
class SectionMatcher(object):
3403
"""Select sections into a given Store.
3405
This is intended to be used to postpone getting an iterable of sections
3409
def __init__(self, store):
3412
def get_sections(self):
3413
# This is where we require loading the store so we can see all defined
3415
sections = self.store.get_sections()
3416
# Walk the revisions in the order provided
3417
for store, s in sections:
3421
def match(self, section):
3422
"""Does the proposed section match.
3424
:param section: A Section object.
3426
:returns: True if the section matches, False otherwise.
3428
raise NotImplementedError(self.match)
3431
class NameMatcher(SectionMatcher):
3433
def __init__(self, store, section_id):
3434
super(NameMatcher, self).__init__(store)
3435
self.section_id = section_id
3437
def match(self, section):
3438
return section.id == self.section_id
3441
class LocationSection(Section):
3443
def __init__(self, section, extra_path):
3444
super(LocationSection, self).__init__(section.id, section.options)
3445
self.extra_path = extra_path
3446
self.locals = {'relpath': extra_path,
3447
'basename': urlutils.basename(extra_path)}
3449
def get(self, name, default=None, expand=True):
3450
value = super(LocationSection, self).get(name, default)
3451
if value is not None and expand:
3452
policy_name = self.get(name + ':policy', None)
3453
policy = _policy_value.get(policy_name, POLICY_NONE)
3454
if policy == POLICY_APPENDPATH:
3455
value = urlutils.join(value, self.extra_path)
3456
# expand section local options right now (since POLICY_APPENDPATH
3457
# will never add options references, it's ok to expand after it).
3459
for is_ref, chunk in iter_option_refs(value):
3461
chunks.append(chunk)
3464
if ref in self.locals:
3465
chunks.append(self.locals[ref])
3467
chunks.append(chunk)
3468
value = ''.join(chunks)
3472
class StartingPathMatcher(SectionMatcher):
3473
"""Select sections for a given location respecting the Store order."""
3475
# FIXME: Both local paths and urls can be used for section names as well as
3476
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3477
# inherited the fuzziness from the previous ``LocationConfig``
3478
# implementation. We probably need to revisit which encoding is allowed for
3479
# both ``location`` and section names and how we normalize
3480
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3481
# related too. -- vila 2012-01-04
3483
def __init__(self, store, location):
3484
super(StartingPathMatcher, self).__init__(store)
3485
if location.startswith('file://'):
3486
location = urlutils.local_path_from_url(location)
3487
self.location = location
3489
def get_sections(self):
3490
"""Get all sections matching ``location`` in the store.
3492
The most generic sections are described first in the store, then more
3493
specific ones can be provided for reduced scopes.
3495
The returned section are therefore returned in the reversed order so
3496
the most specific ones can be found first.
3498
location_parts = self.location.rstrip('/').split('/')
3501
# Later sections are more specific, they should be returned first
3502
for _, section in reversed(list(store.get_sections())):
3503
if section.id is None:
3504
# The no-name section is always included if present
3505
yield store, LocationSection(section, self.location)
3507
section_path = section.id
3508
if section_path.startswith('file://'):
3509
# the location is already a local path or URL, convert the
3510
# section id to the same format
3511
section_path = urlutils.local_path_from_url(section_path)
3512
if (self.location.startswith(section_path)
3513
or fnmatch.fnmatch(self.location, section_path)):
3514
section_parts = section_path.rstrip('/').split('/')
3515
extra_path = '/'.join(location_parts[len(section_parts):])
3516
yield store, LocationSection(section, extra_path)
3519
class LocationMatcher(SectionMatcher):
3521
def __init__(self, store, location):
3522
super(LocationMatcher, self).__init__(store)
3523
if location.startswith('file://'):
3524
location = urlutils.local_path_from_url(location)
3525
self.location = location
3527
def _get_matching_sections(self):
3528
"""Get all sections matching ``location``."""
3529
# We slightly diverge from LocalConfig here by allowing the no-name
3530
# section as the most generic one and the lower priority.
3531
no_name_section = None
3533
# Filter out the no_name_section so _iter_for_location_by_parts can be
3534
# used (it assumes all sections have a name).
3535
for _, section in self.store.get_sections():
3536
if section.id is None:
3537
no_name_section = section
3539
all_sections.append(section)
3540
# Unfortunately _iter_for_location_by_parts deals with section names so
3541
# we have to resync.
3542
filtered_sections = _iter_for_location_by_parts(
3543
[s.id for s in all_sections], self.location)
3544
iter_all_sections = iter(all_sections)
3545
matching_sections = []
3546
if no_name_section is not None:
3547
matching_sections.append(
3548
(0, LocationSection(no_name_section, self.location)))
3549
for section_id, extra_path, length in filtered_sections:
3550
# a section id is unique for a given store so it's safe to take the
3551
# first matching section while iterating. Also, all filtered
3552
# sections are part of 'all_sections' and will always be found
3555
section = iter_all_sections.next()
3556
if section_id == section.id:
3557
matching_sections.append(
3558
(length, LocationSection(section, extra_path)))
3560
return matching_sections
3562
def get_sections(self):
3563
# Override the default implementation as we want to change the order
3564
matching_sections = self._get_matching_sections()
3565
# We want the longest (aka more specific) locations first
3566
sections = sorted(matching_sections,
3567
key=lambda (length, section): (length, section.id),
3569
# Sections mentioning 'ignore_parents' restrict the selection
3570
for _, section in sections:
3571
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3572
ignore = section.get('ignore_parents', None)
3573
if ignore is not None:
3574
ignore = ui.bool_from_string(ignore)
3577
# Finally, we have a valid section
3578
yield self.store, section
3581
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3582
"""Describes an expandable option reference.
3584
We want to match the most embedded reference first.
3586
I.e. for '{{foo}}' we will get '{foo}',
3587
for '{bar{baz}}' we will get '{baz}'
3590
def iter_option_refs(string):
3591
# Split isolate refs so every other chunk is a ref
3593
for chunk in _option_ref_re.split(string):
3598
class Stack(object):
3599
"""A stack of configurations where an option can be defined"""
3601
def __init__(self, sections_def, store=None, mutable_section_id=None):
3602
"""Creates a stack of sections with an optional store for changes.
3604
:param sections_def: A list of Section or callables that returns an
3605
iterable of Section. This defines the Sections for the Stack and
3606
can be called repeatedly if needed.
3608
:param store: The optional Store where modifications will be
3609
recorded. If none is specified, no modifications can be done.
3611
:param mutable_section_id: The id of the MutableSection where changes
3612
are recorded. This requires the ``store`` parameter to be
3615
self.sections_def = sections_def
3617
self.mutable_section_id = mutable_section_id
3619
def iter_sections(self):
3620
"""Iterate all the defined sections."""
3621
# Ensuring lazy loading is achieved by delaying section matching (which
3622
# implies querying the persistent storage) until it can't be avoided
3623
# anymore by using callables to describe (possibly empty) section
3625
for sections in self.sections_def:
3626
for store, section in sections():
3627
yield store, section
3629
def get(self, name, expand=True, convert=True):
3630
"""Return the *first* option value found in the sections.
3632
This is where we guarantee that sections coming from Store are loaded
3633
lazily: the loading is delayed until we need to either check that an
3634
option exists or get its value, which in turn may require to discover
3635
in which sections it can be defined. Both of these (section and option
3636
existence) require loading the store (even partially).
3638
:param name: The queried option.
3640
:param expand: Whether options references should be expanded.
3642
:param convert: Whether the option value should be converted from
3643
unicode (do nothing for non-registered options).
3645
:returns: The value of the option.
3647
# FIXME: No caching of options nor sections yet -- vila 20110503
3649
found_store = None # Where the option value has been found
3650
# If the option is registered, it may provide additional info about
3653
opt = option_registry.get(name)
3658
def expand_and_convert(val):
3659
# This may need to be called in different contexts if the value is
3660
# None or ends up being None during expansion or conversion.
3663
if isinstance(val, basestring):
3664
val = self._expand_options_in_string(val)
3666
trace.warning('Cannot expand "%s":'
3667
' %s does not support option expansion'
3668
% (name, type(val)))
3670
val = found_store.unquote(val)
3672
val = opt.convert_from_unicode(found_store, val)
3675
# First of all, check if the environment can override the configuration
3677
if opt is not None and opt.override_from_env:
3678
value = opt.get_override()
3679
value = expand_and_convert(value)
3681
for store, section in self.iter_sections():
3682
value = section.get(name)
3683
if value is not None:
3686
value = expand_and_convert(value)
3687
if opt is not None and value is None:
3688
# If the option is registered, it may provide a default value
3689
value = opt.get_default()
3690
value = expand_and_convert(value)
3691
for hook in ConfigHooks['get']:
3692
hook(self, name, value)
3695
def expand_options(self, string, env=None):
3696
"""Expand option references in the string in the configuration context.
3698
:param string: The string containing option(s) to expand.
3700
:param env: An option dict defining additional configuration options or
3701
overriding existing ones.
3703
:returns: The expanded string.
3705
return self._expand_options_in_string(string, env)
3707
def _expand_options_in_string(self, string, env=None, _refs=None):
3708
"""Expand options in the string in the configuration context.
3710
:param string: The string to be expanded.
3712
:param env: An option dict defining additional configuration options or
3713
overriding existing ones.
3715
:param _refs: Private list (FIFO) containing the options being expanded
3718
:returns: The expanded string.
3721
# Not much to expand there
3724
# What references are currently resolved (to detect loops)
3727
# We need to iterate until no more refs appear ({{foo}} will need two
3728
# iterations for example).
3733
for is_ref, chunk in iter_option_refs(result):
3735
chunks.append(chunk)
3740
raise errors.OptionExpansionLoop(string, _refs)
3742
value = self._expand_option(name, env, _refs)
3744
raise errors.ExpandingUnknownOption(name, string)
3745
chunks.append(value)
3747
result = ''.join(chunks)
3750
def _expand_option(self, name, env, _refs):
3751
if env is not None and name in env:
3752
# Special case, values provided in env takes precedence over
3756
value = self.get(name, expand=False, convert=False)
3757
value = self._expand_options_in_string(value, env, _refs)
3760
def _get_mutable_section(self):
3761
"""Get the MutableSection for the Stack.
3763
This is where we guarantee that the mutable section is lazily loaded:
3764
this means we won't load the corresponding store before setting a value
3765
or deleting an option. In practice the store will often be loaded but
3766
this helps catching some programming errors.
3769
section = store.get_mutable_section(self.mutable_section_id)
3770
return store, section
3772
def set(self, name, value):
3773
"""Set a new value for the option."""
3774
store, section = self._get_mutable_section()
3775
section.set(name, store.quote(value))
3776
for hook in ConfigHooks['set']:
3777
hook(self, name, value)
3779
def remove(self, name):
3780
"""Remove an existing option."""
3781
_, section = self._get_mutable_section()
3782
section.remove(name)
3783
for hook in ConfigHooks['remove']:
3787
# Mostly for debugging use
3788
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3790
def _get_overrides(self):
3791
# Hack around library_state.initialize never called
3792
if bzrlib.global_state is not None:
3793
return bzrlib.global_state.cmdline_overrides.get_sections()
3797
class MemoryStack(Stack):
3798
"""A configuration stack defined from a string.
3800
This is mainly intended for tests and requires no disk resources.
3803
def __init__(self, content=None):
3804
"""Create an in-memory stack from a given content.
3806
It uses a single store based on configobj and support reading and
3809
:param content: The initial content of the store. If None, the store is
3810
not loaded and ``_load_from_string`` can and should be used if
3813
store = IniFileStore()
3814
if content is not None:
3815
store._load_from_string(content)
3816
super(MemoryStack, self).__init__(
3817
[store.get_sections], store)
3820
class _CompatibleStack(Stack):
3821
"""Place holder for compatibility with previous design.
3823
This is intended to ease the transition from the Config-based design to the
3824
Stack-based design and should not be used nor relied upon by plugins.
3826
One assumption made here is that the daughter classes will all use Stores
3827
derived from LockableIniFileStore).
3829
It implements set() and remove () by re-loading the store before applying
3830
the modification and saving it.
3832
The long term plan being to implement a single write by store to save
3833
all modifications, this class should not be used in the interim.
3836
def set(self, name, value):
3839
super(_CompatibleStack, self).set(name, value)
3840
# Force a write to persistent storage
3843
def remove(self, name):
3846
super(_CompatibleStack, self).remove(name)
3847
# Force a write to persistent storage
3851
class GlobalStack(_CompatibleStack):
3852
"""Global options only stack.
3854
The following sections are queried:
3856
* command-line overrides,
3858
* the 'DEFAULT' section in bazaar.conf
3860
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3865
gstore = GlobalStore()
3866
super(GlobalStack, self).__init__(
3867
[self._get_overrides,
3868
NameMatcher(gstore, 'DEFAULT').get_sections],
3869
gstore, mutable_section_id='DEFAULT')
3872
class LocationStack(_CompatibleStack):
3873
"""Per-location options falling back to global options stack.
3876
The following sections are queried:
3878
* command-line overrides,
3880
* the sections matching ``location`` in ``locations.conf``, the order being
3881
defined by the number of path components in the section glob, higher
3882
numbers first (from most specific section to most generic).
3884
* the 'DEFAULT' section in bazaar.conf
3886
This stack will use the ``location`` section in locations.conf as its
3890
def __init__(self, location):
3891
"""Make a new stack for a location and global configuration.
3893
:param location: A URL prefix to """
3894
lstore = LocationStore()
3895
if location.startswith('file://'):
3896
location = urlutils.local_path_from_url(location)
3897
gstore = GlobalStore()
3898
super(LocationStack, self).__init__(
3899
[self._get_overrides,
3900
LocationMatcher(lstore, location).get_sections,
3901
NameMatcher(gstore, 'DEFAULT').get_sections],
3902
lstore, mutable_section_id=location)
3905
class BranchStack(Stack):
3906
"""Per-location options falling back to branch then global options stack.
3908
The following sections are queried:
3910
* command-line overrides,
3912
* the sections matching ``location`` in ``locations.conf``, the order being
3913
defined by the number of path components in the section glob, higher
3914
numbers first (from most specific section to most generic),
3916
* the no-name section in branch.conf,
3918
* the ``DEFAULT`` section in ``bazaar.conf``.
3920
This stack will use the no-name section in ``branch.conf`` as its
3924
def __init__(self, branch):
3925
lstore = LocationStore()
3926
bstore = branch._get_config_store()
3927
gstore = GlobalStore()
3928
super(BranchStack, self).__init__(
3929
[self._get_overrides,
3930
LocationMatcher(lstore, branch.base).get_sections,
3931
NameMatcher(bstore, None).get_sections,
3932
NameMatcher(gstore, 'DEFAULT').get_sections],
3934
self.branch = branch
3936
def lock_write(self, token=None):
3937
return self.branch.lock_write(token)
3940
return self.branch.unlock()
3943
def set(self, name, value):
3944
super(BranchStack, self).set(name, value)
3945
# Unlocking the branch will trigger a store.save_changes() so the last
3946
# unlock saves all the changes.
3949
def remove(self, name):
3950
super(BranchStack, self).remove(name)
3951
# Unlocking the branch will trigger a store.save_changes() so the last
3952
# unlock saves all the changes.
3955
class RemoteControlStack(_CompatibleStack):
3956
"""Remote control-only options stack."""
3958
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3959
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3960
# control.conf and is used only for stack options.
3962
def __init__(self, bzrdir):
3963
cstore = bzrdir._get_config_store()
3964
super(RemoteControlStack, self).__init__(
3965
[NameMatcher(cstore, None).get_sections],
3967
self.bzrdir = bzrdir
3970
class BranchOnlyStack(Stack):
3971
"""Branch-only options stack."""
3973
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
3974
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
3975
# -- vila 2011-12-16
3977
def __init__(self, branch):
3978
bstore = branch._get_config_store()
3979
super(BranchOnlyStack, self).__init__(
3980
[NameMatcher(bstore, None).get_sections],
3982
self.branch = branch
3984
def lock_write(self, token=None):
3985
return self.branch.lock_write(token)
3988
return self.branch.unlock()
3991
def set(self, name, value):
3992
super(BranchOnlyStack, self).set(name, value)
3993
# Force a write to persistent storage
3994
self.store.save_changes()
3997
def remove(self, name):
3998
super(BranchOnlyStack, self).remove(name)
3999
# Force a write to persistent storage
4000
self.store.save_changes()
4003
class cmd_config(commands.Command):
4004
__doc__ = """Display, set or remove a configuration option.
4006
Display the active value for a given option.
4008
If --all is specified, NAME is interpreted as a regular expression and all
4009
matching options are displayed mentioning their scope. The active value
4010
that bzr will take into account is the first one displayed for each option.
4012
If no NAME is given, --all .* is implied.
4014
Setting a value is achieved by using name=value without spaces. The value
4015
is set in the most relevant scope and can be checked by displaying the
4019
takes_args = ['name?']
4023
# FIXME: This should be a registry option so that plugins can register
4024
# their own config files (or not) and will also address
4025
# http://pad.lv/788991 -- vila 20101115
4026
commands.Option('scope', help='Reduce the scope to the specified'
4027
' configuration file.',
4029
commands.Option('all',
4030
help='Display all the defined values for the matching options.',
4032
commands.Option('remove', help='Remove the option from'
4033
' the configuration file.'),
4036
_see_also = ['configuration']
4038
@commands.display_command
4039
def run(self, name=None, all=False, directory=None, scope=None,
4041
if directory is None:
4043
directory = urlutils.normalize_url(directory)
4045
raise errors.BzrError(
4046
'--all and --remove are mutually exclusive.')
4048
# Delete the option in the given scope
4049
self._remove_config_option(name, directory, scope)
4051
# Defaults to all options
4052
self._show_matching_options('.*', directory, scope)
4055
name, value = name.split('=', 1)
4057
# Display the option(s) value(s)
4059
self._show_matching_options(name, directory, scope)
4061
self._show_value(name, directory, scope)
4064
raise errors.BzrError(
4065
'Only one option can be set.')
4066
# Set the option value
4067
self._set_config_option(name, value, directory, scope)
4069
def _get_stack(self, directory, scope=None, write_access=False):
4070
"""Get the configuration stack specified by ``directory`` and ``scope``.
4072
:param directory: Where the configurations are derived from.
4074
:param scope: A specific config to start from.
4076
:param write_access: Whether a write access to the stack will be
4079
# FIXME: scope should allow access to plugin-specific stacks (even
4080
# reduced to the plugin-specific store), related to
4081
# http://pad.lv/788991 -- vila 2011-11-15
4082
if scope is not None:
4083
if scope == 'bazaar':
4084
return GlobalStack()
4085
elif scope == 'locations':
4086
return LocationStack(directory)
4087
elif scope == 'branch':
4089
controldir.ControlDir.open_containing_tree_or_branch(
4092
self.add_cleanup(br.lock_write().unlock)
4093
return br.get_config_stack()
4094
raise errors.NoSuchConfig(scope)
4098
controldir.ControlDir.open_containing_tree_or_branch(
4101
self.add_cleanup(br.lock_write().unlock)
4102
return br.get_config_stack()
4103
except errors.NotBranchError:
4104
return LocationStack(directory)
4106
def _quote_multiline(self, value):
4108
value = '"""' + value + '"""'
4111
def _show_value(self, name, directory, scope):
4112
conf = self._get_stack(directory, scope)
4113
value = conf.get(name, expand=True, convert=False)
4114
if value is not None:
4115
# Quote the value appropriately
4116
value = self._quote_multiline(value)
4117
self.outf.write('%s\n' % (value,))
4119
raise errors.NoSuchConfigOption(name)
4121
def _show_matching_options(self, name, directory, scope):
4122
name = lazy_regex.lazy_compile(name)
4123
# We want any error in the regexp to be raised *now* so we need to
4124
# avoid the delay introduced by the lazy regexp. But, we still do
4125
# want the nicer errors raised by lazy_regex.
4126
name._compile_and_collapse()
4129
conf = self._get_stack(directory, scope)
4130
for store, section in conf.iter_sections():
4131
for oname in section.iter_option_names():
4132
if name.search(oname):
4133
if cur_store_id != store.id:
4134
# Explain where the options are defined
4135
self.outf.write('%s:\n' % (store.id,))
4136
cur_store_id = store.id
4138
if (section.id is not None and cur_section != section.id):
4139
# Display the section id as it appears in the store
4140
# (None doesn't appear by definition)
4141
self.outf.write(' [%s]\n' % (section.id,))
4142
cur_section = section.id
4143
value = section.get(oname, expand=False)
4144
# Quote the value appropriately
4145
value = self._quote_multiline(value)
4146
self.outf.write(' %s = %s\n' % (oname, value))
4148
def _set_config_option(self, name, value, directory, scope):
4149
conf = self._get_stack(directory, scope, write_access=True)
4150
conf.set(name, value)
4152
def _remove_config_option(self, name, directory, scope):
4154
raise errors.BzrCommandError(
4155
'--remove expects an option to remove.')
4156
conf = self._get_stack(directory, scope, write_access=True)
4160
raise errors.NoSuchConfigOption(name)
4165
# We need adapters that can build a Store or a Stack in a test context. Test
4166
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4167
# themselves. The builder will receive a test instance and should return a
4168
# ready-to-use store or stack. Plugins that define new store/stacks can also
4169
# register themselves here to be tested against the tests defined in
4170
# bzrlib.tests.test_config. Note that the builder can be called multiple times
4171
# for the same test.
4173
# The registered object should be a callable receiving a test instance
4174
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4176
test_store_builder_registry = registry.Registry()
4178
# The registered object should be a callable receiving a test instance
4179
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4181
test_stack_builder_registry = registry.Registry()
added
removed
bzrlib/config.py
