133
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
136
178
class Config(object):
137
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)
139
188
def get_editor(self):
140
189
"""Get the users pop up editor."""
141
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)
143
211
def _get_signature_checking(self):
144
212
"""Template method to override signature checking policy."""
146
214
def _get_signing_policy(self):
147
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)
149
341
def _get_user_option(self, option_name):
150
342
"""Template method to provide a user option."""
153
def get_user_option(self, option_name):
154
"""Get a generic option - no special process, no default."""
155
return self._get_user_option(option_name)
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
157
398
def gpg_signing_command(self):
158
399
"""What program should be used to sign signatures?"""
397
780
def _get_nickname(self):
398
781
return self.get_user_option('nickname')
401
class GlobalConfig(IniBasedConfig):
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):
402
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)
404
911
def get_editor(self):
405
912
return self._get_user_option('editor')
408
super(GlobalConfig, self).__init__(config_filename)
410
915
def set_user_option(self, option, value):
411
916
"""Save option and its value in the configuration."""
412
# FIXME: RBC 20051029 This should refresh the parser and also take a
413
# file lock on bazaar.conf.
414
conf_dir = os.path.dirname(self._get_filename())
415
ensure_config_dir_exists(conf_dir)
416
if 'DEFAULT' not in self._get_parser():
417
self._get_parser()['DEFAULT'] = {}
418
self._get_parser()['DEFAULT'][option] = value
419
f = open(self._get_filename(), 'wb')
420
self._get_parser().write(f)
424
class LocationConfig(IniBasedConfig):
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):
425
1027
"""A configuration object that gives the policy for a location."""
427
1029
def __init__(self, location):
428
name_generator = locations_config_filename
429
if (not os.path.exists(name_generator()) and
430
os.path.exists(branches_config_filename())):
431
if sys.platform == 'win32':
432
warning('Please rename %s to %s'
433
% (branches_config_filename(),
434
locations_config_filename()))
436
warning('Please rename ~/.bazaar/branches.conf'
437
' to ~/.bazaar/locations.conf')
438
name_generator = branches_config_filename
439
super(LocationConfig, self).__init__(name_generator)
1030
super(LocationConfig, self).__init__(
1031
file_name=locations_config_filename())
440
1032
# local file locations are looked up by local path, rather than
441
1033
# by file url. This is because the config file is a user
442
1034
# file, and we would rather not expose the user to file urls.
727
1391
return osutils.pathjoin(config_dir(), 'bazaar.conf')
730
def branches_config_filename():
731
"""Return per-user configuration ini file filename."""
732
return osutils.pathjoin(config_dir(), 'branches.conf')
735
1394
def locations_config_filename():
736
1395
"""Return per-user configuration ini file filename."""
737
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')
740
1404
def user_ignore_config_filename():
741
1405
"""Return the user default ignore filename"""
742
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()
745
1455
def _auto_user_id():
746
1456
"""Calculate automatic user identification.
748
Returns (realname, email).
1458
:returns: (realname, email), either of which may be None if they can't be
750
1461
Only used when none is set in the environment or the id file.
752
This previously used the FQDN as the default domain, but that can
753
be very slow on machines where DNS is broken. So now we simply
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.
758
# XXX: Any good way to get real user name on win32?
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:
763
1482
w = pwd.getpwuid(uid)
765
# we try utf-8 first, because on many variants (like Linux),
766
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
767
# false positives. (many users will have their user encoding set to
768
# latin-1, which cannot raise UnicodeError.)
770
gecos = w.pw_gecos.decode('utf-8')
774
gecos = w.pw_gecos.decode(bzrlib.user_encoding)
775
encoding = bzrlib.user_encoding
777
raise errors.BzrCommandError('Unable to determine your name. '
778
'Use "bzr whoami" to set it.')
780
username = w.pw_name.decode(encoding)
782
raise errors.BzrCommandError('Unable to determine your name. '
783
'Use "bzr whoami" to set it.')
785
comma = gecos.find(',')
789
realname = gecos[:comma]
796
realname = username = getpass.getuser().decode(bzrlib.user_encoding)
797
except UnicodeDecodeError:
798
raise errors.BzrError("Can't decode username as %s." % \
799
bzrlib.user_encoding)
801
return realname, (username + '@' + socket.gethostname())
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))
804
1525
def extract_email_address(e):
805
1526
"""Return just the address part of an email string.
807
That is just the user@domain part, nothing else.
1528
That is just the user@domain part, nothing else.
808
1529
This part is required to contain only ascii characters.
809
1530
If it can't be extracted, raises an error.
811
1532
>>> extract_email_address('Jane Tester <jane@test.com>')
814
m = re.search(r'[\w+.-]+@[\w+.-]+', e)
1535
name, email = parse_username(e)
816
1537
raise errors.NoEmailInUsername(e)
820
1541
class TreeConfig(IniBasedConfig):
821
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
822
1546
def __init__(self, branch):
1547
self._config = branch._get_config()
823
1548
self.branch = branch
825
1550
def _get_parser(self, file=None):
826
1551
if file is not None:
827
1552
return IniBasedConfig._get_parser(file)
828
return self._get_config()
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
830
1599
def _get_config(self):
832
obj = ConfigObj(self.branch.control_files.get('branch.conf'),
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))
834
2080
except errors.NoSuchFile:
835
obj = ConfigObj(encoding='utf=8')
838
def get_option(self, name, section=None, default=None):
839
self.branch.lock_read()
2083
def _get_configobj(self):
2084
f = self._get_config_file()
841
obj = self._get_config()
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)
843
if section is not None:
852
def set_option(self, value, name, section=None):
853
"""Set a per-branch configuration option"""
854
self.branch.lock_write()
856
cfg_obj = self._get_config()
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)
861
obj = cfg_obj[section]
863
cfg_obj[section] = {}
864
obj = cfg_obj[section]
866
out_file = StringIO()
867
cfg_obj.write(out_file)
869
self.branch.control_files.put('branch.conf', out_file)
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
