1
# Copyright (C) 2005-2011 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
33
in locations.conf, you specify the url of a branch and options for it.
34
Wildcards may be used - * and ? as normal in shell completion. Options
35
set in both bazaar.conf and locations.conf are overridden by the locations.conf
37
[/home/robertc/source]
38
recurse=False|True(default)
40
check_signatures= as above
41
create_signatures= as above.
43
explanation of options
44
----------------------
45
editor - this option sets the pop up editor to use during commits.
46
email - this option sets the user id bzr will use when committing.
47
check_signatures - this option controls whether bzr will require good gpg
48
signatures, ignore them, or check them if they are
50
create_signatures - this option controls whether bzr will always create
51
gpg signatures, never create them, or create them if the
52
branch is configured to require them.
53
log_format - this option sets the default log format. Possible values are
54
long, short, line, or a plugin can register new formats.
56
In bazaar.conf you can also define aliases in the ALIASES sections, example
59
lastlog=log --line -r-10..-1
60
ll=log --line -r-10..-1
69
from bzrlib import commands
70
from bzrlib.decorators import needs_write_lock
71
from bzrlib.lazy_import import lazy_import
72
lazy_import(globals(), """
75
from cStringIO import StringIO
95
from bzrlib.util.configobj import configobj
111
POLICY_APPENDPATH = 2
115
POLICY_NORECURSE: 'norecurse',
116
POLICY_APPENDPATH: 'appendpath',
121
'norecurse': POLICY_NORECURSE,
122
'appendpath': POLICY_APPENDPATH,
126
STORE_LOCATION = POLICY_NONE
127
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
128
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
133
class ConfigObj(configobj.ConfigObj):
135
def __init__(self, infile=None, **kwargs):
136
# We define our own interpolation mechanism calling it option expansion
137
super(ConfigObj, self).__init__(infile=infile,
142
def get_bool(self, section, key):
143
return self[section].as_bool(key)
145
def get_value(self, section, name):
146
# Try [] for the old DEFAULT section.
147
if section == "DEFAULT":
152
return self[section][name]
155
# FIXME: Until we can guarantee that each config file is loaded once and and
156
# only once for a given bzrlib session, we don't want to re-read the file every
157
# time we query for an option so we cache the value (bad ! watch out for tests
158
# needing to restore the proper value).This shouldn't be part of 2.4.0 final,
159
# yell at mgz^W vila and the RM if this is still present at that time
161
_expand_default_value = None
162
def _get_expand_default_value():
163
global _expand_default_value
164
if _expand_default_value is not None:
165
return _expand_default_value
166
conf = GlobalConfig()
167
# Note that we must not use None for the expand value below or we'll run
168
# into infinite recursion. Using False really would be quite silly ;)
169
expand = conf.get_user_option_as_bool('bzr.config.expand', expand=True)
171
# This is an opt-in feature, you *really* need to clearly say you want
174
_expand_default_value = expand
178
class Config(object):
179
"""A configuration policy - what username, editor, gpg needs etc."""
182
super(Config, self).__init__()
185
"""Returns a unique ID for the config."""
186
raise NotImplementedError(self.config_id)
188
def get_editor(self):
189
"""Get the users pop up editor."""
190
raise NotImplementedError
192
def get_change_editor(self, old_tree, new_tree):
193
from bzrlib import diff
194
cmd = self._get_change_editor()
197
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
201
def get_mail_client(self):
202
"""Get a mail client to use"""
203
selected_client = self.get_user_option('mail_client')
204
_registry = mail_client.mail_client_registry
206
mail_client_class = _registry.get(selected_client)
208
raise errors.UnknownMailClient(selected_client)
209
return mail_client_class(self)
211
def _get_signature_checking(self):
212
"""Template method to override signature checking policy."""
214
def _get_signing_policy(self):
215
"""Template method to override signature creation policy."""
219
def expand_options(self, string, env=None):
220
"""Expand option references in the string in the configuration context.
222
:param string: The string containing option to expand.
224
:param env: An option dict defining additional configuration options or
225
overriding existing ones.
227
:returns: The expanded string.
229
return self._expand_options_in_string(string, env)
231
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
232
"""Expand options in a list of strings in the configuration context.
234
:param slist: A list of strings.
236
:param env: An option dict defining additional configuration options or
237
overriding existing ones.
239
:param _ref_stack: Private list containing the options being
240
expanded to detect loops.
242
:returns: The flatten list of expanded strings.
244
# expand options in each value separately flattening lists
247
value = self._expand_options_in_string(s, env, _ref_stack)
248
if isinstance(value, list):
254
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
255
"""Expand options in the string in the configuration context.
257
:param string: The string to be expanded.
259
:param env: An option dict defining additional configuration options or
260
overriding existing ones.
262
:param _ref_stack: Private list containing the options being
263
expanded to detect loops.
265
:returns: The expanded string.
268
# Not much to expand there
270
if _ref_stack is None:
271
# What references are currently resolved (to detect loops)
273
if self.option_ref_re is None:
274
# We want to match the most embedded reference first (i.e. for
275
# '{{foo}}' we will get '{foo}',
276
# for '{bar{baz}}' we will get '{baz}'
277
self.option_ref_re = re.compile('({[^{}]+})')
279
# We need to iterate until no more refs appear ({{foo}} will need two
280
# iterations for example).
282
raw_chunks = self.option_ref_re.split(result)
283
if len(raw_chunks) == 1:
284
# Shorcut the trivial case: no refs
288
# Split will isolate refs so that every other chunk is a ref
290
for chunk in raw_chunks:
293
# Keep only non-empty strings (or we get bogus empty
294
# slots when a list value is involved).
299
if name in _ref_stack:
300
raise errors.OptionExpansionLoop(string, _ref_stack)
301
_ref_stack.append(name)
302
value = self._expand_option(name, env, _ref_stack)
304
raise errors.ExpandingUnknownOption(name, string)
305
if isinstance(value, list):
313
# Once a list appears as the result of an expansion, all
314
# callers will get a list result. This allows a consistent
315
# behavior even when some options in the expansion chain
316
# defined as strings (no comma in their value) but their
317
# expanded value is a list.
318
return self._expand_options_in_list(chunks, env, _ref_stack)
320
result = ''.join(chunks)
323
def _expand_option(self, name, env, _ref_stack):
324
if env is not None and name in env:
325
# Special case, values provided in env takes precedence over
329
# FIXME: This is a limited implementation, what we really need is a
330
# way to query the bzr config for the value of an option,
331
# respecting the scope rules (That is, once we implement fallback
332
# configs, getting the option value should restart from the top
333
# config, not the current one) -- vila 20101222
334
value = self.get_user_option(name, expand=False)
335
if isinstance(value, list):
336
value = self._expand_options_in_list(value, env, _ref_stack)
338
value = self._expand_options_in_string(value, env, _ref_stack)
341
def _get_user_option(self, option_name):
342
"""Template method to provide a user option."""
345
def get_user_option(self, option_name, expand=None):
346
"""Get a generic option - no special process, no default.
348
:param option_name: The queried option.
350
:param expand: Whether options references should be expanded.
352
:returns: The value of the option.
355
expand = _get_expand_default_value()
356
value = self._get_user_option(option_name)
358
if isinstance(value, list):
359
value = self._expand_options_in_list(value)
360
elif isinstance(value, dict):
361
trace.warning('Cannot expand "%s":'
362
' Dicts do not support option expansion'
365
value = self._expand_options_in_string(value)
368
def get_user_option_as_bool(self, option_name, expand=None):
369
"""Get a generic option as a boolean - no special process, no default.
371
:return None if the option doesn't exist or its value can't be
372
interpreted as a boolean. Returns True or False otherwise.
374
s = self.get_user_option(option_name, expand=expand)
376
# The option doesn't exist
378
val = ui.bool_from_string(s)
380
# The value can't be interpreted as a boolean
381
trace.warning('Value "%s" is not a boolean for "%s"',
385
def get_user_option_as_list(self, option_name, expand=None):
386
"""Get a generic option as a list - no special process, no default.
388
:return None if the option doesn't exist. Returns the value as a list
391
l = self.get_user_option(option_name, expand=expand)
392
if isinstance(l, (str, unicode)):
393
# A single value, most probably the user forgot (or didn't care to
398
def gpg_signing_command(self):
399
"""What program should be used to sign signatures?"""
400
result = self._gpg_signing_command()
405
def _gpg_signing_command(self):
406
"""See gpg_signing_command()."""
409
def log_format(self):
410
"""What log format should be used"""
411
result = self._log_format()
416
def _log_format(self):
417
"""See log_format()."""
420
def post_commit(self):
421
"""An ordered list of python functions to call.
423
Each function takes branch, rev_id as parameters.
425
return self._post_commit()
427
def _post_commit(self):
428
"""See Config.post_commit."""
431
def user_email(self):
432
"""Return just the email component of a username."""
433
return extract_email_address(self.username())
436
"""Return email-style username.
438
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
440
$BZR_EMAIL can be set to override this, then
441
the concrete policy type is checked, and finally
443
If no username can be found, errors.NoWhoami exception is raised.
445
v = os.environ.get('BZR_EMAIL')
447
return v.decode(osutils.get_user_encoding())
448
v = self._get_user_id()
451
v = os.environ.get('EMAIL')
453
return v.decode(osutils.get_user_encoding())
454
name, email = _auto_user_id()
456
return '%s <%s>' % (name, email)
459
raise errors.NoWhoami()
461
def ensure_username(self):
462
"""Raise errors.NoWhoami if username is not set.
464
This method relies on the username() function raising the error.
468
def signature_checking(self):
469
"""What is the current policy for signature checking?."""
470
policy = self._get_signature_checking()
471
if policy is not None:
473
return CHECK_IF_POSSIBLE
475
def signing_policy(self):
476
"""What is the current policy for signature checking?."""
477
policy = self._get_signing_policy()
478
if policy is not None:
480
return SIGN_WHEN_REQUIRED
482
def signature_needed(self):
483
"""Is a signature needed when committing ?."""
484
policy = self._get_signing_policy()
486
policy = self._get_signature_checking()
487
if policy is not None:
488
trace.warning("Please use create_signatures,"
489
" not check_signatures to set signing policy.")
490
if policy == CHECK_ALWAYS:
492
elif policy == SIGN_ALWAYS:
496
def get_alias(self, value):
497
return self._get_alias(value)
499
def _get_alias(self, value):
502
def get_nickname(self):
503
return self._get_nickname()
505
def _get_nickname(self):
508
def get_bzr_remote_path(self):
510
return os.environ['BZR_REMOTE_PATH']
512
path = self.get_user_option("bzr_remote_path")
517
def suppress_warning(self, warning):
518
"""Should the warning be suppressed or emitted.
520
:param warning: The name of the warning being tested.
522
:returns: True if the warning should be suppressed, False otherwise.
524
warnings = self.get_user_option_as_list('suppress_warnings')
525
if warnings is None or warning not in warnings:
530
def get_merge_tools(self):
532
for (oname, value, section, conf_id, parser) in self._get_options():
533
if oname.startswith('bzr.mergetool.'):
534
tool_name = oname[len('bzr.mergetool.'):]
535
tools[tool_name] = value
536
trace.mutter('loaded merge tools: %r' % tools)
539
def find_merge_tool(self, name):
540
# We fake a defaults mechanism here by checking if the given name can
541
# be found in the known_merge_tools if it's not found in the config.
542
# This should be done through the proposed config defaults mechanism
543
# when it becomes available in the future.
544
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
546
or mergetools.known_merge_tools.get(name, None))
550
class IniBasedConfig(Config):
551
"""A configuration policy that draws from ini files."""
553
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
555
"""Base class for configuration files using an ini-like syntax.
557
:param file_name: The configuration file path.
559
super(IniBasedConfig, self).__init__()
560
self.file_name = file_name
561
if symbol_versioning.deprecated_passed(get_filename):
562
symbol_versioning.warn(
563
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
564
' Use file_name instead.',
567
if get_filename is not None:
568
self.file_name = get_filename()
570
self.file_name = file_name
575
def from_string(cls, str_or_unicode, file_name=None, save=False):
576
"""Create a config object from a string.
578
:param str_or_unicode: A string representing the file content. This will
581
:param file_name: The configuration file path.
583
:param _save: Whether the file should be saved upon creation.
585
conf = cls(file_name=file_name)
586
conf._create_from_string(str_or_unicode, save)
589
def _create_from_string(self, str_or_unicode, save):
590
self._content = StringIO(str_or_unicode.encode('utf-8'))
591
# Some tests use in-memory configs, some other always need the config
592
# file to exist on disk.
594
self._write_config_file()
596
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
597
if self._parser is not None:
599
if symbol_versioning.deprecated_passed(file):
600
symbol_versioning.warn(
601
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
602
' Use IniBasedConfig(_content=xxx) instead.',
605
if self._content is not None:
606
co_input = self._content
607
elif self.file_name is None:
608
raise AssertionError('We have no content to create the config')
610
co_input = self.file_name
612
self._parser = ConfigObj(co_input, encoding='utf-8')
613
except configobj.ConfigObjError, e:
614
raise errors.ParseConfigError(e.errors, e.config.filename)
615
# Make sure self.reload() will use the right file name
616
self._parser.filename = self.file_name
620
"""Reload the config file from disk."""
621
if self.file_name is None:
622
raise AssertionError('We need a file name to reload the config')
623
if self._parser is not None:
624
self._parser.reload()
626
def _get_matching_sections(self):
627
"""Return an ordered list of (section_name, extra_path) pairs.
629
If the section contains inherited configuration, extra_path is
630
a string containing the additional path components.
632
section = self._get_section()
633
if section is not None:
634
return [(section, '')]
638
def _get_section(self):
639
"""Override this to define the section used by the config."""
642
def _get_sections(self, name=None):
643
"""Returns an iterator of the sections specified by ``name``.
645
:param name: The section name. If None is supplied, the default
646
configurations are yielded.
648
:return: A tuple (name, section, config_id) for all sections that will
649
be walked by user_get_option() in the 'right' order. The first one
650
is where set_user_option() will update the value.
652
parser = self._get_parser()
654
yield (name, parser[name], self.config_id())
656
# No section name has been given so we fallback to the configobj
657
# itself which holds the variables defined outside of any section.
658
yield (None, parser, self.config_id())
660
def _get_options(self, sections=None):
661
"""Return an ordered list of (name, value, section, config_id) tuples.
663
All options are returned with their associated value and the section
664
they appeared in. ``config_id`` is a unique identifier for the
665
configuration file the option is defined in.
667
:param sections: Default to ``_get_matching_sections`` if not
668
specified. This gives a better control to daughter classes about
669
which sections should be searched. This is a list of (name,
674
parser = self._get_parser()
676
for (section_name, _) in self._get_matching_sections():
678
section = parser[section_name]
680
# This could happen for an empty file for which we define a
681
# DEFAULT section. FIXME: Force callers to provide sections
682
# instead ? -- vila 20100930
684
sections.append((section_name, section))
685
config_id = self.config_id()
686
for (section_name, section) in sections:
687
for (name, value) in section.iteritems():
688
yield (name, parser._quote(value), section_name,
691
def _get_option_policy(self, section, option_name):
692
"""Return the policy for the given (section, option_name) pair."""
695
def _get_change_editor(self):
696
return self.get_user_option('change_editor')
698
def _get_signature_checking(self):
699
"""See Config._get_signature_checking."""
700
policy = self._get_user_option('check_signatures')
702
return self._string_to_signature_policy(policy)
704
def _get_signing_policy(self):
705
"""See Config._get_signing_policy"""
706
policy = self._get_user_option('create_signatures')
708
return self._string_to_signing_policy(policy)
710
def _get_user_id(self):
711
"""Get the user id from the 'email' key in the current section."""
712
return self._get_user_option('email')
714
def _get_user_option(self, option_name):
715
"""See Config._get_user_option."""
716
for (section, extra_path) in self._get_matching_sections():
718
value = self._get_parser().get_value(section, option_name)
721
policy = self._get_option_policy(section, option_name)
722
if policy == POLICY_NONE:
724
elif policy == POLICY_NORECURSE:
725
# norecurse items only apply to the exact path
730
elif policy == POLICY_APPENDPATH:
732
value = urlutils.join(value, extra_path)
735
raise AssertionError('Unexpected config policy %r' % policy)
739
def _gpg_signing_command(self):
740
"""See Config.gpg_signing_command."""
741
return self._get_user_option('gpg_signing_command')
743
def _log_format(self):
744
"""See Config.log_format."""
745
return self._get_user_option('log_format')
747
def _post_commit(self):
748
"""See Config.post_commit."""
749
return self._get_user_option('post_commit')
751
def _string_to_signature_policy(self, signature_string):
752
"""Convert a string to a signing policy."""
753
if signature_string.lower() == 'check-available':
754
return CHECK_IF_POSSIBLE
755
if signature_string.lower() == 'ignore':
757
if signature_string.lower() == 'require':
759
raise errors.BzrError("Invalid signatures policy '%s'"
762
def _string_to_signing_policy(self, signature_string):
763
"""Convert a string to a signing policy."""
764
if signature_string.lower() == 'when-required':
765
return SIGN_WHEN_REQUIRED
766
if signature_string.lower() == 'never':
768
if signature_string.lower() == 'always':
770
raise errors.BzrError("Invalid signing policy '%s'"
773
def _get_alias(self, value):
775
return self._get_parser().get_value("ALIASES",
780
def _get_nickname(self):
781
return self.get_user_option('nickname')
783
def remove_user_option(self, option_name, section_name=None):
784
"""Remove a user option and save the configuration file.
786
:param option_name: The option to be removed.
788
:param section_name: The section the option is defined in, default to
792
parser = self._get_parser()
793
if section_name is None:
796
section = parser[section_name]
798
del section[option_name]
800
raise errors.NoSuchConfigOption(option_name)
801
self._write_config_file()
803
def _write_config_file(self):
804
if self.file_name is None:
805
raise AssertionError('We cannot save, self.file_name is None')
806
conf_dir = os.path.dirname(self.file_name)
807
ensure_config_dir_exists(conf_dir)
808
atomic_file = atomicfile.AtomicFile(self.file_name)
809
self._get_parser().write(atomic_file)
812
osutils.copy_ownership_from_path(self.file_name)
815
class LockableConfig(IniBasedConfig):
816
"""A configuration needing explicit locking for access.
818
If several processes try to write the config file, the accesses need to be
821
Daughter classes should decorate all methods that update a config with the
822
``@needs_write_lock`` decorator (they call, directly or indirectly, the
823
``_write_config_file()`` method. These methods (typically ``set_option()``
824
and variants must reload the config file from disk before calling
825
``_write_config_file()``), this can be achieved by calling the
826
``self.reload()`` method. Note that the lock scope should cover both the
827
reading and the writing of the config file which is why the decorator can't
828
be applied to ``_write_config_file()`` only.
830
This should be enough to implement the following logic:
831
- lock for exclusive write access,
832
- reload the config file from disk,
836
This logic guarantees that a writer can update a value without erasing an
837
update made by another writer.
842
def __init__(self, file_name):
843
super(LockableConfig, self).__init__(file_name=file_name)
844
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
845
# FIXME: It doesn't matter that we don't provide possible_transports
846
# below since this is currently used only for local config files ;
847
# local transports are not shared. But if/when we start using
848
# LockableConfig for other kind of transports, we will need to reuse
849
# whatever connection is already established -- vila 20100929
850
self.transport = transport.get_transport(self.dir)
851
self._lock = lockdir.LockDir(self.transport, 'lock')
853
def _create_from_string(self, unicode_bytes, save):
854
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
856
# We need to handle the saving here (as opposed to IniBasedConfig)
859
self._write_config_file()
862
def lock_write(self, token=None):
863
"""Takes a write lock in the directory containing the config file.
865
If the directory doesn't exist it is created.
867
ensure_config_dir_exists(self.dir)
868
return self._lock.lock_write(token)
873
def break_lock(self):
874
self._lock.break_lock()
877
def remove_user_option(self, option_name, section_name=None):
878
super(LockableConfig, self).remove_user_option(option_name,
881
def _write_config_file(self):
882
if self._lock is None or not self._lock.is_held:
883
# NB: if the following exception is raised it probably means a
884
# missing @needs_write_lock decorator on one of the callers.
885
raise errors.ObjectNotLocked(self)
886
super(LockableConfig, self)._write_config_file()
889
class GlobalConfig(LockableConfig):
890
"""The configuration that should be used for a specific location."""
893
super(GlobalConfig, self).__init__(file_name=config_filename())
899
def from_string(cls, str_or_unicode, save=False):
900
"""Create a config object from a string.
902
:param str_or_unicode: A string representing the file content. This
903
will be utf-8 encoded.
905
:param save: Whether the file should be saved upon creation.
908
conf._create_from_string(str_or_unicode, save)
911
def get_editor(self):
912
return self._get_user_option('editor')
915
def set_user_option(self, option, value):
916
"""Save option and its value in the configuration."""
917
self._set_option(option, value, 'DEFAULT')
919
def get_aliases(self):
920
"""Return the aliases section."""
921
if 'ALIASES' in self._get_parser():
922
return self._get_parser()['ALIASES']
927
def set_alias(self, alias_name, alias_command):
928
"""Save the alias in the configuration."""
929
self._set_option(alias_name, alias_command, 'ALIASES')
932
def unset_alias(self, alias_name):
933
"""Unset an existing alias."""
935
aliases = self._get_parser().get('ALIASES')
936
if not aliases or alias_name not in aliases:
937
raise errors.NoSuchAlias(alias_name)
938
del aliases[alias_name]
939
self._write_config_file()
941
def _set_option(self, option, value, section):
943
self._get_parser().setdefault(section, {})[option] = value
944
self._write_config_file()
947
def _get_sections(self, name=None):
948
"""See IniBasedConfig._get_sections()."""
949
parser = self._get_parser()
950
# We don't give access to options defined outside of any section, we
951
# used the DEFAULT section by... default.
952
if name in (None, 'DEFAULT'):
953
# This could happen for an empty file where the DEFAULT section
954
# doesn't exist yet. So we force DEFAULT when yielding
956
if 'DEFAULT' not in parser:
957
parser['DEFAULT']= {}
958
yield (name, parser[name], self.config_id())
961
def remove_user_option(self, option_name, section_name=None):
962
if section_name is None:
963
# We need to force the default section.
964
section_name = 'DEFAULT'
965
# We need to avoid the LockableConfig implementation or we'll lock
967
super(LockableConfig, self).remove_user_option(option_name,
970
def _iter_for_location_by_parts(sections, location):
971
"""Keep only the sessions matching the specified location.
973
:param sections: An iterable of section names.
975
:param location: An url or a local path to match against.
977
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
978
number of path components in the section name, section is the section
979
name and extra_path is the difference between location and the section
982
location_parts = location.rstrip('/').split('/')
984
for section in sections:
985
# location is a local path if possible, so we need
986
# to convert 'file://' urls to local paths if necessary.
988
# FIXME: I don't think the above comment is still up to date,
989
# LocationConfig is always instantiated with an url -- vila 2011-04-07
991
# This also avoids having file:///path be a more exact
992
# match than '/path'.
994
# FIXME: Not sure about the above either, but since the path components
995
# are compared in sync, adding two empty components (//) is likely to
996
# trick the comparison and also trick the check on the number of
997
# components, so we *should* take only the relevant part of the url. On
998
# the other hand, this means 'file://' urls *can't* be used in sections
999
# so more work is probably needed -- vila 2011-04-07
1001
if section.startswith('file://'):
1002
section_path = urlutils.local_path_from_url(section)
1004
section_path = section
1005
section_parts = section_path.rstrip('/').split('/')
1008
if len(section_parts) > len(location_parts):
1009
# More path components in the section, they can't match
1012
# Rely on zip truncating in length to the length of the shortest
1013
# argument sequence.
1014
names = zip(location_parts, section_parts)
1016
if not fnmatch.fnmatch(name[0], name[1]):
1021
# build the path difference between the section and the location
1022
extra_path = '/'.join(location_parts[len(section_parts):])
1023
yield section, extra_path, len(section_parts)
1026
class LocationConfig(LockableConfig):
1027
"""A configuration object that gives the policy for a location."""
1029
def __init__(self, location):
1030
super(LocationConfig, self).__init__(
1031
file_name=locations_config_filename())
1032
# local file locations are looked up by local path, rather than
1033
# by file url. This is because the config file is a user
1034
# file, and we would rather not expose the user to file urls.
1035
if location.startswith('file://'):
1036
location = urlutils.local_path_from_url(location)
1037
self.location = location
1039
def config_id(self):
1043
def from_string(cls, str_or_unicode, location, save=False):
1044
"""Create a config object from a string.
1046
:param str_or_unicode: A string representing the file content. This will
1049
:param location: The location url to filter the configuration.
1051
:param save: Whether the file should be saved upon creation.
1053
conf = cls(location)
1054
conf._create_from_string(str_or_unicode, save)
1057
def _get_matching_sections(self):
1058
"""Return an ordered list of section names matching this location."""
1059
matches = list(_iter_for_location_by_parts(self._get_parser(),
1061
# put the longest (aka more specific) locations first
1063
key=lambda (section, extra_path, length): (length, section),
1065
for (section, extra_path, length) in matches:
1066
yield section, extra_path
1067
# should we stop looking for parent configs here?
1069
if self._get_parser()[section].as_bool('ignore_parents'):
1074
def _get_sections(self, name=None):
1075
"""See IniBasedConfig._get_sections()."""
1076
# We ignore the name here as the only sections handled are named with
1077
# the location path and we don't expose embedded sections either.
1078
parser = self._get_parser()
1079
for name, extra_path in self._get_matching_sections():
1080
yield (name, parser[name], self.config_id())
1082
def _get_option_policy(self, section, option_name):
1083
"""Return the policy for the given (section, option_name) pair."""
1084
# check for the old 'recurse=False' flag
1086
recurse = self._get_parser()[section].as_bool('recurse')
1090
return POLICY_NORECURSE
1092
policy_key = option_name + ':policy'
1094
policy_name = self._get_parser()[section][policy_key]
1098
return _policy_value[policy_name]
1100
def _set_option_policy(self, section, option_name, option_policy):
1101
"""Set the policy for the given option name in the given section."""
1102
# The old recurse=False option affects all options in the
1103
# section. To handle multiple policies in the section, we
1104
# need to convert it to a policy_norecurse key.
1106
recurse = self._get_parser()[section].as_bool('recurse')
1110
symbol_versioning.warn(
1111
'The recurse option is deprecated as of 0.14. '
1112
'The section "%s" has been converted to use policies.'
1115
del self._get_parser()[section]['recurse']
1117
for key in self._get_parser()[section].keys():
1118
if not key.endswith(':policy'):
1119
self._get_parser()[section][key +
1120
':policy'] = 'norecurse'
1122
policy_key = option_name + ':policy'
1123
policy_name = _policy_name[option_policy]
1124
if policy_name is not None:
1125
self._get_parser()[section][policy_key] = policy_name
1127
if policy_key in self._get_parser()[section]:
1128
del self._get_parser()[section][policy_key]
1131
def set_user_option(self, option, value, store=STORE_LOCATION):
1132
"""Save option and its value in the configuration."""
1133
if store not in [STORE_LOCATION,
1134
STORE_LOCATION_NORECURSE,
1135
STORE_LOCATION_APPENDPATH]:
1136
raise ValueError('bad storage policy %r for %r' %
1139
location = self.location
1140
if location.endswith('/'):
1141
location = location[:-1]
1142
parser = self._get_parser()
1143
if not location in parser and not location + '/' in parser:
1144
parser[location] = {}
1145
elif location + '/' in parser:
1146
location = location + '/'
1147
parser[location][option]=value
1148
# the allowed values of store match the config policies
1149
self._set_option_policy(location, option, store)
1150
self._write_config_file()
1153
class BranchConfig(Config):
1154
"""A configuration object giving the policy for a branch."""
1156
def __init__(self, branch):
1157
super(BranchConfig, self).__init__()
1158
self._location_config = None
1159
self._branch_data_config = None
1160
self._global_config = None
1161
self.branch = branch
1162
self.option_sources = (self._get_location_config,
1163
self._get_branch_data_config,
1164
self._get_global_config)
1166
def config_id(self):
1169
def _get_branch_data_config(self):
1170
if self._branch_data_config is None:
1171
self._branch_data_config = TreeConfig(self.branch)
1172
self._branch_data_config.config_id = self.config_id
1173
return self._branch_data_config
1175
def _get_location_config(self):
1176
if self._location_config is None:
1177
self._location_config = LocationConfig(self.branch.base)
1178
return self._location_config
1180
def _get_global_config(self):
1181
if self._global_config is None:
1182
self._global_config = GlobalConfig()
1183
return self._global_config
1185
def _get_best_value(self, option_name):
1186
"""This returns a user option from local, tree or global config.
1188
They are tried in that order. Use get_safe_value if trusted values
1191
for source in self.option_sources:
1192
value = getattr(source(), option_name)()
1193
if value is not None:
1197
def _get_safe_value(self, option_name):
1198
"""This variant of get_best_value never returns untrusted values.
1200
It does not return values from the branch data, because the branch may
1201
not be controlled by the user.
1203
We may wish to allow locations.conf to control whether branches are
1204
trusted in the future.
1206
for source in (self._get_location_config, self._get_global_config):
1207
value = getattr(source(), option_name)()
1208
if value is not None:
1212
def _get_user_id(self):
1213
"""Return the full user id for the branch.
1215
e.g. "John Hacker <jhacker@example.com>"
1216
This is looked up in the email controlfile for the branch.
1219
return (self.branch._transport.get_bytes("email")
1220
.decode(osutils.get_user_encoding())
1222
except errors.NoSuchFile, e:
1225
return self._get_best_value('_get_user_id')
1227
def _get_change_editor(self):
1228
return self._get_best_value('_get_change_editor')
1230
def _get_signature_checking(self):
1231
"""See Config._get_signature_checking."""
1232
return self._get_best_value('_get_signature_checking')
1234
def _get_signing_policy(self):
1235
"""See Config._get_signing_policy."""
1236
return self._get_best_value('_get_signing_policy')
1238
def _get_user_option(self, option_name):
1239
"""See Config._get_user_option."""
1240
for source in self.option_sources:
1241
value = source()._get_user_option(option_name)
1242
if value is not None:
1246
def _get_sections(self, name=None):
1247
"""See IniBasedConfig.get_sections()."""
1248
for source in self.option_sources:
1249
for section in source()._get_sections(name):
1252
def _get_options(self, sections=None):
1254
# First the locations options
1255
for option in self._get_location_config()._get_options():
1257
# Then the branch options
1258
branch_config = self._get_branch_data_config()
1259
if sections is None:
1260
sections = [('DEFAULT', branch_config._get_parser())]
1261
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1262
# Config itself has no notion of sections :( -- vila 20101001
1263
config_id = self.config_id()
1264
for (section_name, section) in sections:
1265
for (name, value) in section.iteritems():
1266
yield (name, value, section_name,
1267
config_id, branch_config._get_parser())
1268
# Then the global options
1269
for option in self._get_global_config()._get_options():
1272
def set_user_option(self, name, value, store=STORE_BRANCH,
1274
if store == STORE_BRANCH:
1275
self._get_branch_data_config().set_option(value, name)
1276
elif store == STORE_GLOBAL:
1277
self._get_global_config().set_user_option(name, value)
1279
self._get_location_config().set_user_option(name, value, store)
1282
if store in (STORE_GLOBAL, STORE_BRANCH):
1283
mask_value = self._get_location_config().get_user_option(name)
1284
if mask_value is not None:
1285
trace.warning('Value "%s" is masked by "%s" from'
1286
' locations.conf', value, mask_value)
1288
if store == STORE_GLOBAL:
1289
branch_config = self._get_branch_data_config()
1290
mask_value = branch_config.get_user_option(name)
1291
if mask_value is not None:
1292
trace.warning('Value "%s" is masked by "%s" from'
1293
' branch.conf', value, mask_value)
1295
def remove_user_option(self, option_name, section_name=None):
1296
self._get_branch_data_config().remove_option(option_name, section_name)
1298
def _gpg_signing_command(self):
1299
"""See Config.gpg_signing_command."""
1300
return self._get_safe_value('_gpg_signing_command')
1302
def _post_commit(self):
1303
"""See Config.post_commit."""
1304
return self._get_safe_value('_post_commit')
1306
def _get_nickname(self):
1307
value = self._get_explicit_nickname()
1308
if value is not None:
1310
return urlutils.unescape(self.branch.base.split('/')[-2])
1312
def has_explicit_nickname(self):
1313
"""Return true if a nickname has been explicitly assigned."""
1314
return self._get_explicit_nickname() is not None
1316
def _get_explicit_nickname(self):
1317
return self._get_best_value('_get_nickname')
1319
def _log_format(self):
1320
"""See Config.log_format."""
1321
return self._get_best_value('_log_format')
1324
def ensure_config_dir_exists(path=None):
1325
"""Make sure a configuration directory exists.
1326
This makes sure that the directory exists.
1327
On windows, since configuration directories are 2 levels deep,
1328
it makes sure both the directory and the parent directory exists.
1332
if not os.path.isdir(path):
1333
if sys.platform == 'win32':
1334
parent_dir = os.path.dirname(path)
1335
if not os.path.isdir(parent_dir):
1336
trace.mutter('creating config parent directory: %r', parent_dir)
1337
os.mkdir(parent_dir)
1338
trace.mutter('creating config directory: %r', path)
1340
osutils.copy_ownership_from_path(path)
1344
"""Return per-user configuration directory.
1346
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1347
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1348
that will be used instead.
1350
TODO: Global option --config-dir to override this.
1352
base = os.environ.get('BZR_HOME', None)
1353
if sys.platform == 'win32':
1354
# environ variables on Windows are in user encoding/mbcs. So decode
1356
if base is not None:
1357
base = base.decode('mbcs')
1359
base = win32utils.get_appdata_location_unicode()
1361
base = os.environ.get('HOME', None)
1362
if base is not None:
1363
base = base.decode('mbcs')
1365
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1367
return osutils.pathjoin(base, 'bazaar', '2.0')
1368
elif sys.platform == 'darwin':
1370
# this takes into account $HOME
1371
base = os.path.expanduser("~")
1372
return osutils.pathjoin(base, '.bazaar')
1376
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1378
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1379
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1380
if osutils.isdir(xdg_dir):
1382
"Using configuration in XDG directory %s." % xdg_dir)
1385
base = os.path.expanduser("~")
1386
return osutils.pathjoin(base, ".bazaar")
1389
def config_filename():
1390
"""Return per-user configuration ini file filename."""
1391
return osutils.pathjoin(config_dir(), 'bazaar.conf')
1394
def locations_config_filename():
1395
"""Return per-user configuration ini file filename."""
1396
return osutils.pathjoin(config_dir(), 'locations.conf')
1399
def authentication_config_filename():
1400
"""Return per-user authentication ini file filename."""
1401
return osutils.pathjoin(config_dir(), 'authentication.conf')
1404
def user_ignore_config_filename():
1405
"""Return the user default ignore filename"""
1406
return osutils.pathjoin(config_dir(), 'ignore')
1410
"""Return the directory name to store crash files.
1412
This doesn't implicitly create it.
1414
On Windows it's in the config directory; elsewhere it's /var/crash
1415
which may be monitored by apport. It can be overridden by
1418
if sys.platform == 'win32':
1419
return osutils.pathjoin(config_dir(), 'Crash')
1421
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1423
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1426
def xdg_cache_dir():
1427
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1428
# Possibly this should be different on Windows?
1429
e = os.environ.get('XDG_CACHE_DIR', None)
1433
return os.path.expanduser('~/.cache')
1436
def _get_default_mail_domain():
1437
"""If possible, return the assumed default email domain.
1439
:returns: string mail domain, or None.
1441
if sys.platform == 'win32':
1442
# No implementation yet; patches welcome
1445
f = open('/etc/mailname')
1446
except (IOError, OSError), e:
1449
domain = f.read().strip()
1455
def _auto_user_id():
1456
"""Calculate automatic user identification.
1458
:returns: (realname, email), either of which may be None if they can't be
1461
Only used when none is set in the environment or the id file.
1463
This only returns an email address if we can be fairly sure the
1464
address is reasonable, ie if /etc/mailname is set on unix.
1466
This doesn't use the FQDN as the default domain because that may be
1467
slow, and it doesn't use the hostname alone because that's not normally
1468
a reasonable address.
1470
if sys.platform == 'win32':
1471
# No implementation to reliably determine Windows default mail
1472
# address; please add one.
1475
default_mail_domain = _get_default_mail_domain()
1476
if not default_mail_domain:
1482
w = pwd.getpwuid(uid)
1484
mutter('no passwd entry for uid %d?' % uid)
1487
# we try utf-8 first, because on many variants (like Linux),
1488
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1489
# false positives. (many users will have their user encoding set to
1490
# latin-1, which cannot raise UnicodeError.)
1492
gecos = w.pw_gecos.decode('utf-8')
1494
except UnicodeError:
1496
encoding = osutils.get_user_encoding()
1497
gecos = w.pw_gecos.decode(encoding)
1498
except UnicodeError, e:
1499
mutter("cannot decode passwd entry %s" % w)
1502
username = w.pw_name.decode(encoding)
1503
except UnicodeError, e:
1504
mutter("cannot decode passwd entry %s" % w)
1507
comma = gecos.find(',')
1511
realname = gecos[:comma]
1513
return realname, (username + '@' + default_mail_domain)
1516
def parse_username(username):
1517
"""Parse e-mail username and return a (name, address) tuple."""
1518
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1520
return (username, '')
1522
return (match.group(1), match.group(2))
1525
def extract_email_address(e):
1526
"""Return just the address part of an email string.
1528
That is just the user@domain part, nothing else.
1529
This part is required to contain only ascii characters.
1530
If it can't be extracted, raises an error.
1532
>>> extract_email_address('Jane Tester <jane@test.com>')
1535
name, email = parse_username(e)
1537
raise errors.NoEmailInUsername(e)
1541
class TreeConfig(IniBasedConfig):
1542
"""Branch configuration data associated with its contents, not location"""
1544
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1546
def __init__(self, branch):
1547
self._config = branch._get_config()
1548
self.branch = branch
1550
def _get_parser(self, file=None):
1551
if file is not None:
1552
return IniBasedConfig._get_parser(file)
1553
return self._config._get_configobj()
1555
def get_option(self, name, section=None, default=None):
1556
self.branch.lock_read()
1558
return self._config.get_option(name, section, default)
1560
self.branch.unlock()
1562
def set_option(self, value, name, section=None):
1563
"""Set a per-branch configuration option"""
1564
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1565
# higher levels providing the right lock -- vila 20101004
1566
self.branch.lock_write()
1568
self._config.set_option(value, name, section)
1570
self.branch.unlock()
1572
def remove_option(self, option_name, section_name=None):
1573
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1574
# higher levels providing the right lock -- vila 20101004
1575
self.branch.lock_write()
1577
self._config.remove_option(option_name, section_name)
1579
self.branch.unlock()
1582
class AuthenticationConfig(object):
1583
"""The authentication configuration file based on a ini file.
1585
Implements the authentication.conf file described in
1586
doc/developers/authentication-ring.txt.
1589
def __init__(self, _file=None):
1590
self._config = None # The ConfigObj
1592
self._filename = authentication_config_filename()
1593
self._input = self._filename = authentication_config_filename()
1595
# Tests can provide a string as _file
1596
self._filename = None
1599
def _get_config(self):
1600
if self._config is not None:
1603
# FIXME: Should we validate something here ? Includes: empty
1604
# sections are useless, at least one of
1605
# user/password/password_encoding should be defined, etc.
1607
# Note: the encoding below declares that the file itself is utf-8
1608
# encoded, but the values in the ConfigObj are always Unicode.
1609
self._config = ConfigObj(self._input, encoding='utf-8')
1610
except configobj.ConfigObjError, e:
1611
raise errors.ParseConfigError(e.errors, e.config.filename)
1615
"""Save the config file, only tests should use it for now."""
1616
conf_dir = os.path.dirname(self._filename)
1617
ensure_config_dir_exists(conf_dir)
1618
f = file(self._filename, 'wb')
1620
self._get_config().write(f)
1624
def _set_option(self, section_name, option_name, value):
1625
"""Set an authentication configuration option"""
1626
conf = self._get_config()
1627
section = conf.get(section_name)
1630
section = conf[section]
1631
section[option_name] = value
1634
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1636
"""Returns the matching credentials from authentication.conf file.
1638
:param scheme: protocol
1640
:param host: the server address
1642
:param port: the associated port (optional)
1644
:param user: login (optional)
1646
:param path: the absolute path on the server (optional)
1648
:param realm: the http authentication realm (optional)
1650
:return: A dict containing the matching credentials or None.
1652
- name: the section name of the credentials in the
1653
authentication.conf file,
1654
- user: can't be different from the provided user if any,
1655
- scheme: the server protocol,
1656
- host: the server address,
1657
- port: the server port (can be None),
1658
- path: the absolute server path (can be None),
1659
- realm: the http specific authentication realm (can be None),
1660
- password: the decoded password, could be None if the credential
1661
defines only the user
1662
- verify_certificates: https specific, True if the server
1663
certificate should be verified, False otherwise.
1666
for auth_def_name, auth_def in self._get_config().items():
1667
if type(auth_def) is not configobj.Section:
1668
raise ValueError("%s defined outside a section" % auth_def_name)
1670
a_scheme, a_host, a_user, a_path = map(
1671
auth_def.get, ['scheme', 'host', 'user', 'path'])
1674
a_port = auth_def.as_int('port')
1678
raise ValueError("'port' not numeric in %s" % auth_def_name)
1680
a_verify_certificates = auth_def.as_bool('verify_certificates')
1682
a_verify_certificates = True
1685
"'verify_certificates' not boolean in %s" % auth_def_name)
1688
if a_scheme is not None and scheme != a_scheme:
1690
if a_host is not None:
1691
if not (host == a_host
1692
or (a_host.startswith('.') and host.endswith(a_host))):
1694
if a_port is not None and port != a_port:
1696
if (a_path is not None and path is not None
1697
and not path.startswith(a_path)):
1699
if (a_user is not None and user is not None
1700
and a_user != user):
1701
# Never contradict the caller about the user to be used
1706
# Prepare a credentials dictionary with additional keys
1707
# for the credential providers
1708
credentials = dict(name=auth_def_name,
1715
password=auth_def.get('password', None),
1716
verify_certificates=a_verify_certificates)
1717
# Decode the password in the credentials (or get one)
1718
self.decode_password(credentials,
1719
auth_def.get('password_encoding', None))
1720
if 'auth' in debug.debug_flags:
1721
trace.mutter("Using authentication section: %r", auth_def_name)
1724
if credentials is None:
1725
# No credentials were found in authentication.conf, try the fallback
1726
# credentials stores.
1727
credentials = credential_store_registry.get_fallback_credentials(
1728
scheme, host, port, user, path, realm)
1732
def set_credentials(self, name, host, user, scheme=None, password=None,
1733
port=None, path=None, verify_certificates=None,
1735
"""Set authentication credentials for a host.
1737
Any existing credentials with matching scheme, host, port and path
1738
will be deleted, regardless of name.
1740
:param name: An arbitrary name to describe this set of credentials.
1741
:param host: Name of the host that accepts these credentials.
1742
:param user: The username portion of these credentials.
1743
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1745
:param password: Password portion of these credentials.
1746
:param port: The IP port on the host that these credentials apply to.
1747
:param path: A filesystem path on the host that these credentials
1749
:param verify_certificates: On https, verify server certificates if
1751
:param realm: The http authentication realm (optional).
1753
values = {'host': host, 'user': user}
1754
if password is not None:
1755
values['password'] = password
1756
if scheme is not None:
1757
values['scheme'] = scheme
1758
if port is not None:
1759
values['port'] = '%d' % port
1760
if path is not None:
1761
values['path'] = path
1762
if verify_certificates is not None:
1763
values['verify_certificates'] = str(verify_certificates)
1764
if realm is not None:
1765
values['realm'] = realm
1766
config = self._get_config()
1768
for section, existing_values in config.items():
1769
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1770
if existing_values.get(key) != values.get(key):
1774
config.update({name: values})
1777
def get_user(self, scheme, host, port=None, realm=None, path=None,
1778
prompt=None, ask=False, default=None):
1779
"""Get a user from authentication file.
1781
:param scheme: protocol
1783
:param host: the server address
1785
:param port: the associated port (optional)
1787
:param realm: the realm sent by the server (optional)
1789
:param path: the absolute path on the server (optional)
1791
:param ask: Ask the user if there is no explicitly configured username
1794
:param default: The username returned if none is defined (optional).
1796
:return: The found user.
1798
credentials = self.get_credentials(scheme, host, port, user=None,
1799
path=path, realm=realm)
1800
if credentials is not None:
1801
user = credentials['user']
1807
# Create a default prompt suitable for most cases
1808
prompt = scheme.upper() + ' %(host)s username'
1809
# Special handling for optional fields in the prompt
1810
if port is not None:
1811
prompt_host = '%s:%d' % (host, port)
1814
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1819
def get_password(self, scheme, host, user, port=None,
1820
realm=None, path=None, prompt=None):
1821
"""Get a password from authentication file or prompt the user for one.
1823
:param scheme: protocol
1825
:param host: the server address
1827
:param port: the associated port (optional)
1831
:param realm: the realm sent by the server (optional)
1833
:param path: the absolute path on the server (optional)
1835
:return: The found password or the one entered by the user.
1837
credentials = self.get_credentials(scheme, host, port, user, path,
1839
if credentials is not None:
1840
password = credentials['password']
1841
if password is not None and scheme is 'ssh':
1842
trace.warning('password ignored in section [%s],'
1843
' use an ssh agent instead'
1844
% credentials['name'])
1848
# Prompt user only if we could't find a password
1849
if password is None:
1851
# Create a default prompt suitable for most cases
1852
prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
1853
# Special handling for optional fields in the prompt
1854
if port is not None:
1855
prompt_host = '%s:%d' % (host, port)
1858
password = ui.ui_factory.get_password(prompt,
1859
host=prompt_host, user=user)
1862
def decode_password(self, credentials, encoding):
1864
cs = credential_store_registry.get_credential_store(encoding)
1866
raise ValueError('%r is not a known password_encoding' % encoding)
1867
credentials['password'] = cs.decode_password(credentials)
1871
class CredentialStoreRegistry(registry.Registry):
1872
"""A class that registers credential stores.
1874
A credential store provides access to credentials via the password_encoding
1875
field in authentication.conf sections.
1877
Except for stores provided by bzr itself, most stores are expected to be
1878
provided by plugins that will therefore use
1879
register_lazy(password_encoding, module_name, member_name, help=help,
1880
fallback=fallback) to install themselves.
1882
A fallback credential store is one that is queried if no credentials can be
1883
found via authentication.conf.
1886
def get_credential_store(self, encoding=None):
1887
cs = self.get(encoding)
1892
def is_fallback(self, name):
1893
"""Check if the named credentials store should be used as fallback."""
1894
return self.get_info(name)
1896
def get_fallback_credentials(self, scheme, host, port=None, user=None,
1897
path=None, realm=None):
1898
"""Request credentials from all fallback credentials stores.
1900
The first credentials store that can provide credentials wins.
1903
for name in self.keys():
1904
if not self.is_fallback(name):
1906
cs = self.get_credential_store(name)
1907
credentials = cs.get_credentials(scheme, host, port, user,
1909
if credentials is not None:
1910
# We found some credentials
1914
def register(self, key, obj, help=None, override_existing=False,
1916
"""Register a new object to a name.
1918
:param key: This is the key to use to request the object later.
1919
:param obj: The object to register.
1920
:param help: Help text for this entry. This may be a string or
1921
a callable. If it is a callable, it should take two
1922
parameters (registry, key): this registry and the key that
1923
the help was registered under.
1924
:param override_existing: Raise KeyErorr if False and something has
1925
already been registered for that key. If True, ignore if there
1926
is an existing key (always register the new value).
1927
:param fallback: Whether this credential store should be
1930
return super(CredentialStoreRegistry,
1931
self).register(key, obj, help, info=fallback,
1932
override_existing=override_existing)
1934
def register_lazy(self, key, module_name, member_name,
1935
help=None, override_existing=False,
1937
"""Register a new credential store to be loaded on request.
1939
:param module_name: The python path to the module. Such as 'os.path'.
1940
:param member_name: The member of the module to return. If empty or
1941
None, get() will return the module itself.
1942
:param help: Help text for this entry. This may be a string or
1944
:param override_existing: If True, replace the existing object
1945
with the new one. If False, if there is already something
1946
registered with the same key, raise a KeyError
1947
:param fallback: Whether this credential store should be
1950
return super(CredentialStoreRegistry, self).register_lazy(
1951
key, module_name, member_name, help,
1952
info=fallback, override_existing=override_existing)
1955
credential_store_registry = CredentialStoreRegistry()
1958
class CredentialStore(object):
1959
"""An abstract class to implement storage for credentials"""
1961
def decode_password(self, credentials):
1962
"""Returns a clear text password for the provided credentials."""
1963
raise NotImplementedError(self.decode_password)
1965
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1967
"""Return the matching credentials from this credential store.
1969
This method is only called on fallback credential stores.
1971
raise NotImplementedError(self.get_credentials)
1975
class PlainTextCredentialStore(CredentialStore):
1976
__doc__ = """Plain text credential store for the authentication.conf file"""
1978
def decode_password(self, credentials):
1979
"""See CredentialStore.decode_password."""
1980
return credentials['password']
1983
credential_store_registry.register('plain', PlainTextCredentialStore,
1984
help=PlainTextCredentialStore.__doc__)
1985
credential_store_registry.default_key = 'plain'
1988
class BzrDirConfig(object):
1990
def __init__(self, bzrdir):
1991
self._bzrdir = bzrdir
1992
self._config = bzrdir._get_config()
1994
def set_default_stack_on(self, value):
1995
"""Set the default stacking location.
1997
It may be set to a location, or None.
1999
This policy affects all branches contained by this bzrdir, except for
2000
those under repositories.
2002
if self._config is None:
2003
raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
2005
self._config.set_option('', 'default_stack_on')
2007
self._config.set_option(value, 'default_stack_on')
2009
def get_default_stack_on(self):
2010
"""Return the default stacking location.
2012
This will either be a location, or None.
2014
This policy affects all branches contained by this bzrdir, except for
2015
those under repositories.
2017
if self._config is None:
2019
value = self._config.get_option('default_stack_on')
2025
class TransportConfig(object):
2026
"""A Config that reads/writes a config file on a Transport.
2028
It is a low-level object that considers config data to be name/value pairs
2029
that may be associated with a section. Assigning meaning to these values
2030
is done at higher levels like TreeConfig.
2033
def __init__(self, transport, filename):
2034
self._transport = transport
2035
self._filename = filename
2037
def get_option(self, name, section=None, default=None):
2038
"""Return the value associated with a named option.
2040
:param name: The name of the value
2041
:param section: The section the option is in (if any)
2042
:param default: The value to return if the value is not set
2043
:return: The value or default value
2045
configobj = self._get_configobj()
2047
section_obj = configobj
2050
section_obj = configobj[section]
2053
return section_obj.get(name, default)
2055
def set_option(self, value, name, section=None):
2056
"""Set the value associated with a named option.
2058
:param value: The value to set
2059
:param name: The name of the value to set
2060
:param section: The section the option is in (if any)
2062
configobj = self._get_configobj()
2064
configobj[name] = value
2066
configobj.setdefault(section, {})[name] = value
2067
self._set_configobj(configobj)
2069
def remove_option(self, option_name, section_name=None):
2070
configobj = self._get_configobj()
2071
if section_name is None:
2072
del configobj[option_name]
2074
del configobj[section_name][option_name]
2075
self._set_configobj(configobj)
2077
def _get_config_file(self):
2079
return StringIO(self._transport.get_bytes(self._filename))
2080
except errors.NoSuchFile:
2083
def _get_configobj(self):
2084
f = self._get_config_file()
2086
return ConfigObj(f, encoding='utf-8')
2090
def _set_configobj(self, configobj):
2091
out_file = StringIO()
2092
configobj.write(out_file)
2094
self._transport.put_file(self._filename, out_file)
2097
class cmd_config(commands.Command):
2098
__doc__ = """Display, set or remove a configuration option.
2100
Display the active value for a given option.
2102
If --all is specified, NAME is interpreted as a regular expression and all
2103
matching options are displayed mentioning their scope. The active value
2104
that bzr will take into account is the first one displayed for each option.
2106
If no NAME is given, --all .* is implied.
2108
Setting a value is achieved by using name=value without spaces. The value
2109
is set in the most relevant scope and can be checked by displaying the
2113
takes_args = ['name?']
2117
# FIXME: This should be a registry option so that plugins can register
2118
# their own config files (or not) -- vila 20101002
2119
commands.Option('scope', help='Reduce the scope to the specified'
2120
' configuration file',
2122
commands.Option('all',
2123
help='Display all the defined values for the matching options.',
2125
commands.Option('remove', help='Remove the option from'
2126
' the configuration file'),
2129
@commands.display_command
2130
def run(self, name=None, all=False, directory=None, scope=None,
2132
if directory is None:
2134
directory = urlutils.normalize_url(directory)
2136
raise errors.BzrError(
2137
'--all and --remove are mutually exclusive.')
2139
# Delete the option in the given scope
2140
self._remove_config_option(name, directory, scope)
2142
# Defaults to all options
2143
self._show_matching_options('.*', directory, scope)
2146
name, value = name.split('=', 1)
2148
# Display the option(s) value(s)
2150
self._show_matching_options(name, directory, scope)
2152
self._show_value(name, directory, scope)
2155
raise errors.BzrError(
2156
'Only one option can be set.')
2157
# Set the option value
2158
self._set_config_option(name, value, directory, scope)
2160
def _get_configs(self, directory, scope=None):
2161
"""Iterate the configurations specified by ``directory`` and ``scope``.
2163
:param directory: Where the configurations are derived from.
2165
:param scope: A specific config to start from.
2167
if scope is not None:
2168
if scope == 'bazaar':
2169
yield GlobalConfig()
2170
elif scope == 'locations':
2171
yield LocationConfig(directory)
2172
elif scope == 'branch':
2173
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2175
yield br.get_config()
2178
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2180
yield br.get_config()
2181
except errors.NotBranchError:
2182
yield LocationConfig(directory)
2183
yield GlobalConfig()
2185
def _show_value(self, name, directory, scope):
2187
for c in self._get_configs(directory, scope):
2190
for (oname, value, section, conf_id, parser) in c._get_options():
2192
# Display only the first value and exit
2194
# FIXME: We need to use get_user_option to take policies
2195
# into account and we need to make sure the option exists
2196
# too (hence the two for loops), this needs a better API
2198
value = c.get_user_option(name)
2199
# Quote the value appropriately
2200
value = parser._quote(value)
2201
self.outf.write('%s\n' % (value,))
2205
raise errors.NoSuchConfigOption(name)
2207
def _show_matching_options(self, name, directory, scope):
2208
name = re.compile(name)
2209
# We want any error in the regexp to be raised *now* so we need to
2210
# avoid the delay introduced by the lazy regexp.
2211
name._compile_and_collapse()
2214
for c in self._get_configs(directory, scope):
2215
for (oname, value, section, conf_id, parser) in c._get_options():
2216
if name.search(oname):
2217
if cur_conf_id != conf_id:
2218
# Explain where the options are defined
2219
self.outf.write('%s:\n' % (conf_id,))
2220
cur_conf_id = conf_id
2222
if (section not in (None, 'DEFAULT')
2223
and cur_section != section):
2224
# Display the section if it's not the default (or only)
2226
self.outf.write(' [%s]\n' % (section,))
2227
cur_section = section
2228
self.outf.write(' %s = %s\n' % (oname, value))
2230
def _set_config_option(self, name, value, directory, scope):
2231
for conf in self._get_configs(directory, scope):
2232
conf.set_user_option(name, value)
2235
raise errors.NoSuchConfig(scope)
2237
def _remove_config_option(self, name, directory, scope):
2239
raise errors.BzrCommandError(
2240
'--remove expects an option to remove.')
2242
for conf in self._get_configs(directory, scope):
2243
for (section_name, section, conf_id) in conf._get_sections():
2244
if scope is not None and conf_id != scope:
2245
# Not the right configuration file
2248
if conf_id != conf.config_id():
2249
conf = self._get_configs(directory, conf_id).next()
2250
# We use the first section in the first config where the
2251
# option is defined to remove it
2252
conf.remove_user_option(name, section_name)
2257
raise errors.NoSuchConfig(scope)
2259
raise errors.NoSuchConfigOption(name)
added
removed
bzrlib/config.py
