884
244
raise errors.BzrError("Invalid signatures policy '%s'"
885
245
% signature_string)
887
def _string_to_signing_policy(self, signature_string):
888
"""Convert a string to a signing policy."""
889
if signature_string.lower() == 'when-required':
890
return SIGN_WHEN_REQUIRED
891
if signature_string.lower() == 'never':
893
if signature_string.lower() == 'always':
895
raise errors.BzrError("Invalid signing policy '%s'"
898
def _get_alias(self, value):
900
return self._get_parser().get_value("ALIASES",
905
def _get_nickname(self):
906
return self.get_user_option('nickname')
908
def remove_user_option(self, option_name, section_name=None):
909
"""Remove a user option and save the configuration file.
911
:param option_name: The option to be removed.
913
:param section_name: The section the option is defined in, default to
917
parser = self._get_parser()
918
if section_name is None:
921
section = parser[section_name]
923
del section[option_name]
925
raise errors.NoSuchConfigOption(option_name)
926
self._write_config_file()
927
for hook in OldConfigHooks['remove']:
928
hook(self, option_name)
930
def _write_config_file(self):
931
if self.file_name is None:
932
raise AssertionError('We cannot save, self.file_name is None')
933
conf_dir = os.path.dirname(self.file_name)
934
ensure_config_dir_exists(conf_dir)
935
atomic_file = atomicfile.AtomicFile(self.file_name)
936
self._get_parser().write(atomic_file)
939
osutils.copy_ownership_from_path(self.file_name)
940
for hook in OldConfigHooks['save']:
944
class LockableConfig(IniBasedConfig):
945
"""A configuration needing explicit locking for access.
947
If several processes try to write the config file, the accesses need to be
950
Daughter classes should decorate all methods that update a config with the
951
``@needs_write_lock`` decorator (they call, directly or indirectly, the
952
``_write_config_file()`` method. These methods (typically ``set_option()``
953
and variants must reload the config file from disk before calling
954
``_write_config_file()``), this can be achieved by calling the
955
``self.reload()`` method. Note that the lock scope should cover both the
956
reading and the writing of the config file which is why the decorator can't
957
be applied to ``_write_config_file()`` only.
959
This should be enough to implement the following logic:
960
- lock for exclusive write access,
961
- reload the config file from disk,
965
This logic guarantees that a writer can update a value without erasing an
966
update made by another writer.
971
def __init__(self, file_name):
972
super(LockableConfig, self).__init__(file_name=file_name)
973
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
974
# FIXME: It doesn't matter that we don't provide possible_transports
975
# below since this is currently used only for local config files ;
976
# local transports are not shared. But if/when we start using
977
# LockableConfig for other kind of transports, we will need to reuse
978
# whatever connection is already established -- vila 20100929
979
self.transport = transport.get_transport(self.dir)
980
self._lock = lockdir.LockDir(self.transport, self.lock_name)
982
def _create_from_string(self, unicode_bytes, save):
983
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
985
# We need to handle the saving here (as opposed to IniBasedConfig)
988
self._write_config_file()
991
def lock_write(self, token=None):
992
"""Takes a write lock in the directory containing the config file.
994
If the directory doesn't exist it is created.
996
ensure_config_dir_exists(self.dir)
997
return self._lock.lock_write(token)
1002
def break_lock(self):
1003
self._lock.break_lock()
1006
def remove_user_option(self, option_name, section_name=None):
1007
super(LockableConfig, self).remove_user_option(option_name,
1010
def _write_config_file(self):
1011
if self._lock is None or not self._lock.is_held:
1012
# NB: if the following exception is raised it probably means a
1013
# missing @needs_write_lock decorator on one of the callers.
1014
raise errors.ObjectNotLocked(self)
1015
super(LockableConfig, self)._write_config_file()
1018
class GlobalConfig(LockableConfig):
248
class GlobalConfig(IniBasedConfig):
1019
249
"""The configuration that should be used for a specific location."""
1022
super(GlobalConfig, self).__init__(file_name=config_filename())
1024
def config_id(self):
1028
def from_string(cls, str_or_unicode, save=False):
1029
"""Create a config object from a string.
1031
:param str_or_unicode: A string representing the file content. This
1032
will be utf-8 encoded.
1034
:param save: Whether the file should be saved upon creation.
1037
conf._create_from_string(str_or_unicode, save)
1040
@deprecated_method(deprecated_in((2, 4, 0)))
1041
251
def get_editor(self):
1042
252
return self._get_user_option('editor')
1045
def set_user_option(self, option, value):
1046
"""Save option and its value in the configuration."""
1047
self._set_option(option, value, 'DEFAULT')
1049
def get_aliases(self):
1050
"""Return the aliases section."""
1051
if 'ALIASES' in self._get_parser():
1052
return self._get_parser()['ALIASES']
1057
def set_alias(self, alias_name, alias_command):
1058
"""Save the alias in the configuration."""
1059
self._set_option(alias_name, alias_command, 'ALIASES')
1062
def unset_alias(self, alias_name):
1063
"""Unset an existing alias."""
1065
aliases = self._get_parser().get('ALIASES')
1066
if not aliases or alias_name not in aliases:
1067
raise errors.NoSuchAlias(alias_name)
1068
del aliases[alias_name]
1069
self._write_config_file()
1071
def _set_option(self, option, value, section):
1073
self._get_parser().setdefault(section, {})[option] = value
1074
self._write_config_file()
1075
for hook in OldConfigHooks['set']:
1076
hook(self, option, value)
1078
def _get_sections(self, name=None):
1079
"""See IniBasedConfig._get_sections()."""
1080
parser = self._get_parser()
1081
# We don't give access to options defined outside of any section, we
1082
# used the DEFAULT section by... default.
1083
if name in (None, 'DEFAULT'):
1084
# This could happen for an empty file where the DEFAULT section
1085
# doesn't exist yet. So we force DEFAULT when yielding
1087
if 'DEFAULT' not in parser:
1088
parser['DEFAULT']= {}
1089
yield (name, parser[name], self.config_id())
1092
def remove_user_option(self, option_name, section_name=None):
1093
if section_name is None:
1094
# We need to force the default section.
1095
section_name = 'DEFAULT'
1096
# We need to avoid the LockableConfig implementation or we'll lock
1098
super(LockableConfig, self).remove_user_option(option_name,
1101
def _iter_for_location_by_parts(sections, location):
1102
"""Keep only the sessions matching the specified location.
1104
:param sections: An iterable of section names.
1106
:param location: An url or a local path to match against.
1108
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1109
number of path components in the section name, section is the section
1110
name and extra_path is the difference between location and the section
1113
``location`` will always be a local path and never a 'file://' url but the
1114
section names themselves can be in either form.
1116
location_parts = location.rstrip('/').split('/')
1118
for section in sections:
1119
# location is a local path if possible, so we need to convert 'file://'
1120
# urls in section names to local paths if necessary.
1122
# This also avoids having file:///path be a more exact
1123
# match than '/path'.
1125
# FIXME: This still raises an issue if a user defines both file:///path
1126
# *and* /path. Should we raise an error in this case -- vila 20110505
1128
if section.startswith('file://'):
1129
section_path = urlutils.local_path_from_url(section)
1131
section_path = section
1132
section_parts = section_path.rstrip('/').split('/')
1135
if len(section_parts) > len(location_parts):
1136
# More path components in the section, they can't match
1139
# Rely on zip truncating in length to the length of the shortest
1140
# argument sequence.
1141
names = zip(location_parts, section_parts)
255
super(GlobalConfig, self).__init__(config_filename)
258
class LocationConfig(IniBasedConfig):
259
"""A configuration object that gives the policy for a location."""
261
def __init__(self, location):
262
super(LocationConfig, self).__init__(branches_config_filename)
263
self._global_config = None
264
self.location = location
266
def _get_global_config(self):
267
if self._global_config is None:
268
self._global_config = GlobalConfig()
269
return self._global_config
271
def _get_section(self):
272
"""Get the section we should look in for config items.
274
Returns None if none exists.
275
TODO: perhaps return a NullSection that thunks through to the
278
sections = self._get_parser()
279
location_names = self.location.split('/')
280
if self.location.endswith('/'):
281
del location_names[-1]
283
for section in sections:
284
section_names = section.split('/')
285
if section.endswith('/'):
286
del section_names[-1]
287
names = zip(location_names, section_names)
1142
289
for name in names:
1143
if not fnmatch.fnmatch(name[0], name[1]):
290
if not fnmatch(name[0], name[1]):
1148
# build the path difference between the section and the location
1149
extra_path = '/'.join(location_parts[len(section_parts):])
1150
yield section, extra_path, len(section_parts)
1153
class LocationConfig(LockableConfig):
1154
"""A configuration object that gives the policy for a location."""
1156
def __init__(self, location):
1157
super(LocationConfig, self).__init__(
1158
file_name=locations_config_filename())
1159
# local file locations are looked up by local path, rather than
1160
# by file url. This is because the config file is a user
1161
# file, and we would rather not expose the user to file urls.
1162
if location.startswith('file://'):
1163
location = urlutils.local_path_from_url(location)
1164
self.location = location
1166
def config_id(self):
1170
def from_string(cls, str_or_unicode, location, save=False):
1171
"""Create a config object from a string.
1173
:param str_or_unicode: A string representing the file content. This will
1176
:param location: The location url to filter the configuration.
1178
:param save: Whether the file should be saved upon creation.
1180
conf = cls(location)
1181
conf._create_from_string(str_or_unicode, save)
1184
def _get_matching_sections(self):
1185
"""Return an ordered list of section names matching this location."""
1186
matches = list(_iter_for_location_by_parts(self._get_parser(),
1188
# put the longest (aka more specific) locations first
1190
key=lambda (section, extra_path, length): (length, section),
1192
for (section, extra_path, length) in matches:
1193
yield section, extra_path
1194
# should we stop looking for parent configs here?
1196
if self._get_parser()[section].as_bool('ignore_parents'):
1201
def _get_sections(self, name=None):
1202
"""See IniBasedConfig._get_sections()."""
1203
# We ignore the name here as the only sections handled are named with
1204
# the location path and we don't expose embedded sections either.
1205
parser = self._get_parser()
1206
for name, extra_path in self._get_matching_sections():
1207
yield (name, parser[name], self.config_id())
1209
def _get_option_policy(self, section, option_name):
1210
"""Return the policy for the given (section, option_name) pair."""
1211
# check for the old 'recurse=False' flag
1213
recurse = self._get_parser()[section].as_bool('recurse')
1217
return POLICY_NORECURSE
1219
policy_key = option_name + ':policy'
1221
policy_name = self._get_parser()[section][policy_key]
1225
return _policy_value[policy_name]
1227
def _set_option_policy(self, section, option_name, option_policy):
1228
"""Set the policy for the given option name in the given section."""
1229
# The old recurse=False option affects all options in the
1230
# section. To handle multiple policies in the section, we
1231
# need to convert it to a policy_norecurse key.
1233
recurse = self._get_parser()[section].as_bool('recurse')
1237
symbol_versioning.warn(
1238
'The recurse option is deprecated as of 0.14. '
1239
'The section "%s" has been converted to use policies.'
1242
del self._get_parser()[section]['recurse']
1244
for key in self._get_parser()[section].keys():
1245
if not key.endswith(':policy'):
1246
self._get_parser()[section][key +
1247
':policy'] = 'norecurse'
1249
policy_key = option_name + ':policy'
1250
policy_name = _policy_name[option_policy]
1251
if policy_name is not None:
1252
self._get_parser()[section][policy_key] = policy_name
1254
if policy_key in self._get_parser()[section]:
1255
del self._get_parser()[section][policy_key]
1258
def set_user_option(self, option, value, store=STORE_LOCATION):
295
# so, for the common prefix they matched.
296
# if section is longer, no match.
297
if len(section_names) > len(location_names):
299
# if path is longer, and recurse is not true, no match
300
if len(section_names) < len(location_names):
302
if not self._get_parser().get_bool(section, 'recurse'):
306
matches.append((len(section_names), section))
309
matches.sort(reverse=True)
312
def _gpg_signing_command(self):
313
"""See Config.gpg_signing_command."""
314
command = super(LocationConfig, self)._gpg_signing_command()
315
if command is not None:
317
return self._get_global_config()._gpg_signing_command()
319
def _get_user_id(self):
320
user_id = super(LocationConfig, self)._get_user_id()
321
if user_id is not None:
323
return self._get_global_config()._get_user_id()
325
def _get_user_option(self, option_name):
326
"""See Config._get_user_option."""
327
option_value = super(LocationConfig,
328
self)._get_user_option(option_name)
329
if option_value is not None:
331
return self._get_global_config()._get_user_option(option_name)
333
def _get_signature_checking(self):
334
"""See Config._get_signature_checking."""
335
check = super(LocationConfig, self)._get_signature_checking()
336
if check is not None:
338
return self._get_global_config()._get_signature_checking()
340
def _post_commit(self):
341
"""See Config.post_commit."""
342
hook = self._get_user_option('post_commit')
345
return self._get_global_config()._post_commit()
347
def set_user_option(self, option, value):
1259
348
"""Save option and its value in the configuration."""
1260
if store not in [STORE_LOCATION,
1261
STORE_LOCATION_NORECURSE,
1262
STORE_LOCATION_APPENDPATH]:
1263
raise ValueError('bad storage policy %r for %r' %
349
# FIXME: RBC 20051029 This should refresh the parser and also take a
350
# file lock on branches.conf.
351
if not os.path.isdir(os.path.dirname(self._get_filename())):
352
os.mkdir(os.path.dirname(self._get_filename()))
1266
353
location = self.location
1267
354
if location.endswith('/'):
1268
355
location = location[:-1]
1269
parser = self._get_parser()
1270
if not location in parser and not location + '/' in parser:
1271
parser[location] = {}
1272
elif location + '/' in parser:
356
if (not location in self._get_parser() and
357
not location + '/' in self._get_parser()):
358
self._get_parser()[location]={}
359
elif location + '/' in self._get_parser():
1273
360
location = location + '/'
1274
parser[location][option]=value
1275
# the allowed values of store match the config policies
1276
self._set_option_policy(location, option, store)
1277
self._write_config_file()
1278
for hook in OldConfigHooks['set']:
1279
hook(self, option, value)
361
self._get_parser()[location][option]=value
362
self._get_parser().write()
1282
365
class BranchConfig(Config):
1283
366
"""A configuration object giving the policy for a branch."""
1285
def __init__(self, branch):
1286
super(BranchConfig, self).__init__()
1287
self._location_config = None
1288
self._branch_data_config = None
1289
self._global_config = None
1290
self.branch = branch
1291
self.option_sources = (self._get_location_config,
1292
self._get_branch_data_config,
1293
self._get_global_config)
1295
def config_id(self):
1298
def _get_branch_data_config(self):
1299
if self._branch_data_config is None:
1300
self._branch_data_config = TreeConfig(self.branch)
1301
self._branch_data_config.config_id = self.config_id
1302
return self._branch_data_config
1304
368
def _get_location_config(self):
1305
369
if self._location_config is None:
1306
370
self._location_config = LocationConfig(self.branch.base)
1307
371
return self._location_config
1309
def _get_global_config(self):
1310
if self._global_config is None:
1311
self._global_config = GlobalConfig()
1312
return self._global_config
1314
def _get_best_value(self, option_name):
1315
"""This returns a user option from local, tree or global config.
1317
They are tried in that order. Use get_safe_value if trusted values
1320
for source in self.option_sources:
1321
value = getattr(source(), option_name)()
1322
if value is not None:
1326
def _get_safe_value(self, option_name):
1327
"""This variant of get_best_value never returns untrusted values.
1329
It does not return values from the branch data, because the branch may
1330
not be controlled by the user.
1332
We may wish to allow locations.conf to control whether branches are
1333
trusted in the future.
1335
for source in (self._get_location_config, self._get_global_config):
1336
value = getattr(source(), option_name)()
1337
if value is not None:
1341
373
def _get_user_id(self):
1342
374
"""Return the full user id for the branch.
1344
e.g. "John Hacker <jhacker@example.com>"
376
e.g. "John Hacker <jhacker@foo.org>"
1345
377
This is looked up in the email controlfile for the branch.
1348
return (self.branch._transport.get_bytes("email")
1349
.decode(osutils.get_user_encoding())
380
return (self.branch.controlfile("email", "r")
382
.decode(bzrlib.user_encoding)
1350
383
.rstrip("\r\n"))
1351
384
except errors.NoSuchFile, e:
1354
return self._get_best_value('_get_user_id')
1356
def _get_change_editor(self):
1357
return self._get_best_value('_get_change_editor')
387
return self._get_location_config()._get_user_id()
1359
389
def _get_signature_checking(self):
1360
390
"""See Config._get_signature_checking."""
1361
return self._get_best_value('_get_signature_checking')
1363
def _get_signing_policy(self):
1364
"""See Config._get_signing_policy."""
1365
return self._get_best_value('_get_signing_policy')
391
return self._get_location_config()._get_signature_checking()
1367
393
def _get_user_option(self, option_name):
1368
394
"""See Config._get_user_option."""
1369
for source in self.option_sources:
1370
value = source()._get_user_option(option_name)
1371
if value is not None:
1375
def _get_sections(self, name=None):
1376
"""See IniBasedConfig.get_sections()."""
1377
for source in self.option_sources:
1378
for section in source()._get_sections(name):
1381
def _get_options(self, sections=None):
1383
# First the locations options
1384
for option in self._get_location_config()._get_options():
1386
# Then the branch options
1387
branch_config = self._get_branch_data_config()
1388
if sections is None:
1389
sections = [('DEFAULT', branch_config._get_parser())]
1390
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1391
# Config itself has no notion of sections :( -- vila 20101001
1392
config_id = self.config_id()
1393
for (section_name, section) in sections:
1394
for (name, value) in section.iteritems():
1395
yield (name, value, section_name,
1396
config_id, branch_config._get_parser())
1397
# Then the global options
1398
for option in self._get_global_config()._get_options():
1401
def set_user_option(self, name, value, store=STORE_BRANCH,
1403
if store == STORE_BRANCH:
1404
self._get_branch_data_config().set_option(value, name)
1405
elif store == STORE_GLOBAL:
1406
self._get_global_config().set_user_option(name, value)
1408
self._get_location_config().set_user_option(name, value, store)
1411
if store in (STORE_GLOBAL, STORE_BRANCH):
1412
mask_value = self._get_location_config().get_user_option(name)
1413
if mask_value is not None:
1414
trace.warning('Value "%s" is masked by "%s" from'
1415
' locations.conf', value, mask_value)
1417
if store == STORE_GLOBAL:
1418
branch_config = self._get_branch_data_config()
1419
mask_value = branch_config.get_user_option(name)
1420
if mask_value is not None:
1421
trace.warning('Value "%s" is masked by "%s" from'
1422
' branch.conf', value, mask_value)
1424
def remove_user_option(self, option_name, section_name=None):
1425
self._get_branch_data_config().remove_option(option_name, section_name)
395
return self._get_location_config()._get_user_option(option_name)
1427
397
def _gpg_signing_command(self):
1428
398
"""See Config.gpg_signing_command."""
1429
return self._get_safe_value('_gpg_signing_command')
399
return self._get_location_config()._gpg_signing_command()
401
def __init__(self, branch):
402
super(BranchConfig, self).__init__()
403
self._location_config = None
1431
406
def _post_commit(self):
1432
407
"""See Config.post_commit."""
1433
return self._get_safe_value('_post_commit')
1435
def _get_nickname(self):
1436
value = self._get_explicit_nickname()
1437
if value is not None:
1439
return urlutils.unescape(self.branch.base.split('/')[-2])
1441
def has_explicit_nickname(self):
1442
"""Return true if a nickname has been explicitly assigned."""
1443
return self._get_explicit_nickname() is not None
1445
def _get_explicit_nickname(self):
1446
return self._get_best_value('_get_nickname')
1448
def _log_format(self):
1449
"""See Config.log_format."""
1450
return self._get_best_value('_log_format')
1452
def _validate_signatures_in_log(self):
1453
"""See Config.validate_signatures_in_log."""
1454
return self._get_best_value('_validate_signatures_in_log')
1456
def _acceptable_keys(self):
1457
"""See Config.acceptable_keys."""
1458
return self._get_best_value('_acceptable_keys')
1461
def ensure_config_dir_exists(path=None):
1462
"""Make sure a configuration directory exists.
1463
This makes sure that the directory exists.
1464
On windows, since configuration directories are 2 levels deep,
1465
it makes sure both the directory and the parent directory exists.
1469
if not os.path.isdir(path):
1470
if sys.platform == 'win32':
1471
parent_dir = os.path.dirname(path)
1472
if not os.path.isdir(parent_dir):
1473
trace.mutter('creating config parent directory: %r', parent_dir)
1474
os.mkdir(parent_dir)
1475
trace.mutter('creating config directory: %r', path)
1477
osutils.copy_ownership_from_path(path)
408
return self._get_location_config()._post_commit()
1480
411
def config_dir():
1481
412
"""Return per-user configuration directory.
1483
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1484
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1485
that will be used instead.
414
By default this is ~/.bazaar/
1487
416
TODO: Global option --config-dir to override this.
1489
418
base = os.environ.get('BZR_HOME', None)
1490
419
if sys.platform == 'win32':
1491
# environ variables on Windows are in user encoding/mbcs. So decode
1493
if base is not None:
1494
base = base.decode('mbcs')
1495
420
if base is None:
1496
base = win32utils.get_appdata_location_unicode()
421
base = os.environ.get('APPDATA', None)
1497
422
if base is None:
1498
423
base = os.environ.get('HOME', None)
1499
if base is not None:
1500
base = base.decode('mbcs')
1502
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1504
return osutils.pathjoin(base, 'bazaar', '2.0')
1506
if base is not None:
1507
base = base.decode(osutils._fs_enc)
1508
if sys.platform == 'darwin':
1510
# this takes into account $HOME
1511
base = os.path.expanduser("~")
1512
return osutils.pathjoin(base, '.bazaar')
1515
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1517
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1518
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1519
if osutils.isdir(xdg_dir):
1521
"Using configuration in XDG directory %s." % xdg_dir)
1523
base = os.path.expanduser("~")
1524
return osutils.pathjoin(base, ".bazaar")
425
raise BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
426
return os.path.join(base, 'bazaar', '2.0')
428
# cygwin, linux, and darwin all have a $HOME directory
430
base = os.path.expanduser("~")
431
return os.path.join(base, ".bazaar")
1527
434
def config_filename():
1528
435
"""Return per-user configuration ini file filename."""
1529
return osutils.pathjoin(config_dir(), 'bazaar.conf')
1532
def locations_config_filename():
436
return os.path.join(config_dir(), 'bazaar.conf')
439
def branches_config_filename():
1533
440
"""Return per-user configuration ini file filename."""
1534
return osutils.pathjoin(config_dir(), 'locations.conf')
1537
def authentication_config_filename():
1538
"""Return per-user authentication ini file filename."""
1539
return osutils.pathjoin(config_dir(), 'authentication.conf')
1542
def user_ignore_config_filename():
1543
"""Return the user default ignore filename"""
1544
return osutils.pathjoin(config_dir(), 'ignore')
1548
"""Return the directory name to store crash files.
1550
This doesn't implicitly create it.
1552
On Windows it's in the config directory; elsewhere it's /var/crash
1553
which may be monitored by apport. It can be overridden by
1556
if sys.platform == 'win32':
1557
return osutils.pathjoin(config_dir(), 'Crash')
1559
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1561
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1564
def xdg_cache_dir():
1565
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1566
# Possibly this should be different on Windows?
1567
e = os.environ.get('XDG_CACHE_DIR', None)
1571
return os.path.expanduser('~/.cache')
1574
def _get_default_mail_domain():
1575
"""If possible, return the assumed default email domain.
1577
:returns: string mail domain, or None.
1579
if sys.platform == 'win32':
1580
# No implementation yet; patches welcome
1583
f = open('/etc/mailname')
1584
except (IOError, OSError), e:
1587
domain = f.read().strip()
441
return os.path.join(config_dir(), 'branches.conf')
1593
444
def _auto_user_id():
1594
445
"""Calculate automatic user identification.
1596
:returns: (realname, email), either of which may be None if they can't be
447
Returns (realname, email).
1599
449
Only used when none is set in the environment or the id file.
1601
This only returns an email address if we can be fairly sure the
1602
address is reasonable, ie if /etc/mailname is set on unix.
1604
This doesn't use the FQDN as the default domain because that may be
1605
slow, and it doesn't use the hostname alone because that's not normally
1606
a reasonable address.
451
This previously used the FQDN as the default domain, but that can
452
be very slow on machines where DNS is broken. So now we simply
1608
if sys.platform == 'win32':
1609
# No implementation to reliably determine Windows default mail
1610
# address; please add one.
1613
default_mail_domain = _get_default_mail_domain()
1614
if not default_mail_domain:
457
# XXX: Any good way to get real user name on win32?
1620
462
w = pwd.getpwuid(uid)
1622
trace.mutter('no passwd entry for uid %d?' % uid)
1625
# we try utf-8 first, because on many variants (like Linux),
1626
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1627
# false positives. (many users will have their user encoding set to
1628
# latin-1, which cannot raise UnicodeError.)
1630
gecos = w.pw_gecos.decode('utf-8')
1632
except UnicodeError:
1634
encoding = osutils.get_user_encoding()
1635
gecos = w.pw_gecos.decode(encoding)
1636
except UnicodeError, e:
1637
trace.mutter("cannot decode passwd entry %s" % w)
1640
username = w.pw_name.decode(encoding)
1641
except UnicodeError, e:
1642
trace.mutter("cannot decode passwd entry %s" % w)
1645
comma = gecos.find(',')
1649
realname = gecos[:comma]
1651
return realname, (username + '@' + default_mail_domain)
1654
def parse_username(username):
1655
"""Parse e-mail username and return a (name, address) tuple."""
1656
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1658
return (username, '')
1660
return (match.group(1), match.group(2))
463
gecos = w.pw_gecos.decode(bzrlib.user_encoding)
464
username = w.pw_name.decode(bzrlib.user_encoding)
465
comma = gecos.find(',')
469
realname = gecos[:comma]
475
realname = username = getpass.getuser().decode(bzrlib.user_encoding)
477
return realname, (username + '@' + socket.gethostname())
1663
480
def extract_email_address(e):
1664
481
"""Return just the address part of an email string.
1666
That is just the user@domain part, nothing else.
483
That is just the user@domain part, nothing else.
1667
484
This part is required to contain only ascii characters.
1668
485
If it can't be extracted, raises an error.
1670
487
>>> extract_email_address('Jane Tester <jane@test.com>')
1673
name, email = parse_username(e)
1675
raise errors.NoEmailInUsername(e)
1679
class TreeConfig(IniBasedConfig):
490
m = re.search(r'[\w+.-]+@[\w+.-]+', e)
492
raise errors.BzrError("%r doesn't seem to contain "
493
"a reasonable email address" % e)
496
class TreeConfig(object):
1680
497
"""Branch configuration data associated with its contents, not location"""
1682
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1684
498
def __init__(self, branch):
1685
self._config = branch._get_config()
1686
499
self.branch = branch
1688
def _get_parser(self, file=None):
1689
if file is not None:
1690
return IniBasedConfig._get_parser(file)
1691
return self._config._get_configobj()
501
def _get_config(self):
503
obj = ConfigObj(self.branch.controlfile('branch.conf',
506
except errors.NoSuchFile:
1693
510
def get_option(self, name, section=None, default=None):
1694
511
self.branch.lock_read()
1696
return self._config.get_option(name, section, default)
513
obj = self._get_config()
515
if section is not None:
1698
521
self.branch.unlock()
1700
524
def set_option(self, value, name, section=None):
1701
525
"""Set a per-branch configuration option"""
1702
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1703
# higher levels providing the right lock -- vila 20101004
1704
self.branch.lock_write()
1706
self._config.set_option(value, name, section)
1708
self.branch.unlock()
1710
def remove_option(self, option_name, section_name=None):
1711
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1712
# higher levels providing the right lock -- vila 20101004
1713
self.branch.lock_write()
1715
self._config.remove_option(option_name, section_name)
1717
self.branch.unlock()
1720
class AuthenticationConfig(object):
1721
"""The authentication configuration file based on a ini file.
1723
Implements the authentication.conf file described in
1724
doc/developers/authentication-ring.txt.
1727
def __init__(self, _file=None):
1728
self._config = None # The ConfigObj
1730
self._filename = authentication_config_filename()
1731
self._input = self._filename = authentication_config_filename()
1733
# Tests can provide a string as _file
1734
self._filename = None
1737
def _get_config(self):
1738
if self._config is not None:
1741
# FIXME: Should we validate something here ? Includes: empty
1742
# sections are useless, at least one of
1743
# user/password/password_encoding should be defined, etc.
1745
# Note: the encoding below declares that the file itself is utf-8
1746
# encoded, but the values in the ConfigObj are always Unicode.
1747
self._config = ConfigObj(self._input, encoding='utf-8')
1748
except configobj.ConfigObjError, e:
1749
raise errors.ParseConfigError(e.errors, e.config.filename)
1750
except UnicodeError:
1751
raise errors.ConfigContentError(self._filename)
1755
"""Save the config file, only tests should use it for now."""
1756
conf_dir = os.path.dirname(self._filename)
1757
ensure_config_dir_exists(conf_dir)
1758
f = file(self._filename, 'wb')
1760
self._get_config().write(f)
1764
def _set_option(self, section_name, option_name, value):
1765
"""Set an authentication configuration option"""
1766
conf = self._get_config()
1767
section = conf.get(section_name)
1770
section = conf[section]
1771
section[option_name] = value
1774
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1776
"""Returns the matching credentials from authentication.conf file.
1778
:param scheme: protocol
1780
:param host: the server address
1782
:param port: the associated port (optional)
1784
:param user: login (optional)
1786
:param path: the absolute path on the server (optional)
1788
:param realm: the http authentication realm (optional)
1790
:return: A dict containing the matching credentials or None.
1792
- name: the section name of the credentials in the
1793
authentication.conf file,
1794
- user: can't be different from the provided user if any,
1795
- scheme: the server protocol,
1796
- host: the server address,
1797
- port: the server port (can be None),
1798
- path: the absolute server path (can be None),
1799
- realm: the http specific authentication realm (can be None),
1800
- password: the decoded password, could be None if the credential
1801
defines only the user
1802
- verify_certificates: https specific, True if the server
1803
certificate should be verified, False otherwise.
1806
for auth_def_name, auth_def in self._get_config().items():
1807
if type(auth_def) is not configobj.Section:
1808
raise ValueError("%s defined outside a section" % auth_def_name)
1810
a_scheme, a_host, a_user, a_path = map(
1811
auth_def.get, ['scheme', 'host', 'user', 'path'])
1814
a_port = auth_def.as_int('port')
1818
raise ValueError("'port' not numeric in %s" % auth_def_name)
1820
a_verify_certificates = auth_def.as_bool('verify_certificates')
1822
a_verify_certificates = True
1825
"'verify_certificates' not boolean in %s" % auth_def_name)
1828
if a_scheme is not None and scheme != a_scheme:
1830
if a_host is not None:
1831
if not (host == a_host
1832
or (a_host.startswith('.') and host.endswith(a_host))):
1834
if a_port is not None and port != a_port:
1836
if (a_path is not None and path is not None
1837
and not path.startswith(a_path)):
1839
if (a_user is not None and user is not None
1840
and a_user != user):
1841
# Never contradict the caller about the user to be used
1846
# Prepare a credentials dictionary with additional keys
1847
# for the credential providers
1848
credentials = dict(name=auth_def_name,
1855
password=auth_def.get('password', None),
1856
verify_certificates=a_verify_certificates)
1857
# Decode the password in the credentials (or get one)
1858
self.decode_password(credentials,
1859
auth_def.get('password_encoding', None))
1860
if 'auth' in debug.debug_flags:
1861
trace.mutter("Using authentication section: %r", auth_def_name)
1864
if credentials is None:
1865
# No credentials were found in authentication.conf, try the fallback
1866
# credentials stores.
1867
credentials = credential_store_registry.get_fallback_credentials(
1868
scheme, host, port, user, path, realm)
1872
def set_credentials(self, name, host, user, scheme=None, password=None,
1873
port=None, path=None, verify_certificates=None,
1875
"""Set authentication credentials for a host.
1877
Any existing credentials with matching scheme, host, port and path
1878
will be deleted, regardless of name.
1880
:param name: An arbitrary name to describe this set of credentials.
1881
:param host: Name of the host that accepts these credentials.
1882
:param user: The username portion of these credentials.
1883
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1885
:param password: Password portion of these credentials.
1886
:param port: The IP port on the host that these credentials apply to.
1887
:param path: A filesystem path on the host that these credentials
1889
:param verify_certificates: On https, verify server certificates if
1891
:param realm: The http authentication realm (optional).
1893
values = {'host': host, 'user': user}
1894
if password is not None:
1895
values['password'] = password
1896
if scheme is not None:
1897
values['scheme'] = scheme
1898
if port is not None:
1899
values['port'] = '%d' % port
1900
if path is not None:
1901
values['path'] = path
1902
if verify_certificates is not None:
1903
values['verify_certificates'] = str(verify_certificates)
1904
if realm is not None:
1905
values['realm'] = realm
1906
config = self._get_config()
1908
for section, existing_values in config.items():
1909
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1910
if existing_values.get(key) != values.get(key):
1914
config.update({name: values})
1917
def get_user(self, scheme, host, port=None, realm=None, path=None,
1918
prompt=None, ask=False, default=None):
1919
"""Get a user from authentication file.
1921
:param scheme: protocol
1923
:param host: the server address
1925
:param port: the associated port (optional)
1927
:param realm: the realm sent by the server (optional)
1929
:param path: the absolute path on the server (optional)
1931
:param ask: Ask the user if there is no explicitly configured username
1934
:param default: The username returned if none is defined (optional).
1936
:return: The found user.
1938
credentials = self.get_credentials(scheme, host, port, user=None,
1939
path=path, realm=realm)
1940
if credentials is not None:
1941
user = credentials['user']
1947
# Create a default prompt suitable for most cases
1948
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1949
# Special handling for optional fields in the prompt
1950
if port is not None:
1951
prompt_host = '%s:%d' % (host, port)
1954
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1959
def get_password(self, scheme, host, user, port=None,
1960
realm=None, path=None, prompt=None):
1961
"""Get a password from authentication file or prompt the user for one.
1963
:param scheme: protocol
1965
:param host: the server address
1967
:param port: the associated port (optional)
1971
:param realm: the realm sent by the server (optional)
1973
:param path: the absolute path on the server (optional)
1975
:return: The found password or the one entered by the user.
1977
credentials = self.get_credentials(scheme, host, port, user, path,
1979
if credentials is not None:
1980
password = credentials['password']
1981
if password is not None and scheme is 'ssh':
1982
trace.warning('password ignored in section [%s],'
1983
' use an ssh agent instead'
1984
% credentials['name'])
1988
# Prompt user only if we could't find a password
1989
if password is None:
1991
# Create a default prompt suitable for most cases
1992
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
1993
# Special handling for optional fields in the prompt
1994
if port is not None:
1995
prompt_host = '%s:%d' % (host, port)
1998
password = ui.ui_factory.get_password(prompt,
1999
host=prompt_host, user=user)
2002
def decode_password(self, credentials, encoding):
2004
cs = credential_store_registry.get_credential_store(encoding)
2006
raise ValueError('%r is not a known password_encoding' % encoding)
2007
credentials['password'] = cs.decode_password(credentials)
2011
class CredentialStoreRegistry(registry.Registry):
2012
"""A class that registers credential stores.
2014
A credential store provides access to credentials via the password_encoding
2015
field in authentication.conf sections.
2017
Except for stores provided by bzr itself, most stores are expected to be
2018
provided by plugins that will therefore use
2019
register_lazy(password_encoding, module_name, member_name, help=help,
2020
fallback=fallback) to install themselves.
2022
A fallback credential store is one that is queried if no credentials can be
2023
found via authentication.conf.
2026
def get_credential_store(self, encoding=None):
2027
cs = self.get(encoding)
2032
def is_fallback(self, name):
2033
"""Check if the named credentials store should be used as fallback."""
2034
return self.get_info(name)
2036
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2037
path=None, realm=None):
2038
"""Request credentials from all fallback credentials stores.
2040
The first credentials store that can provide credentials wins.
2043
for name in self.keys():
2044
if not self.is_fallback(name):
2046
cs = self.get_credential_store(name)
2047
credentials = cs.get_credentials(scheme, host, port, user,
2049
if credentials is not None:
2050
# We found some credentials
2054
def register(self, key, obj, help=None, override_existing=False,
2056
"""Register a new object to a name.
2058
:param key: This is the key to use to request the object later.
2059
:param obj: The object to register.
2060
:param help: Help text for this entry. This may be a string or
2061
a callable. If it is a callable, it should take two
2062
parameters (registry, key): this registry and the key that
2063
the help was registered under.
2064
:param override_existing: Raise KeyErorr if False and something has
2065
already been registered for that key. If True, ignore if there
2066
is an existing key (always register the new value).
2067
:param fallback: Whether this credential store should be
2070
return super(CredentialStoreRegistry,
2071
self).register(key, obj, help, info=fallback,
2072
override_existing=override_existing)
2074
def register_lazy(self, key, module_name, member_name,
2075
help=None, override_existing=False,
2077
"""Register a new credential store to be loaded on request.
2079
:param module_name: The python path to the module. Such as 'os.path'.
2080
:param member_name: The member of the module to return. If empty or
2081
None, get() will return the module itself.
2082
:param help: Help text for this entry. This may be a string or
2084
:param override_existing: If True, replace the existing object
2085
with the new one. If False, if there is already something
2086
registered with the same key, raise a KeyError
2087
:param fallback: Whether this credential store should be
2090
return super(CredentialStoreRegistry, self).register_lazy(
2091
key, module_name, member_name, help,
2092
info=fallback, override_existing=override_existing)
2095
credential_store_registry = CredentialStoreRegistry()
2098
class CredentialStore(object):
2099
"""An abstract class to implement storage for credentials"""
2101
def decode_password(self, credentials):
2102
"""Returns a clear text password for the provided credentials."""
2103
raise NotImplementedError(self.decode_password)
2105
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2107
"""Return the matching credentials from this credential store.
2109
This method is only called on fallback credential stores.
2111
raise NotImplementedError(self.get_credentials)
2115
class PlainTextCredentialStore(CredentialStore):
2116
__doc__ = """Plain text credential store for the authentication.conf file"""
2118
def decode_password(self, credentials):
2119
"""See CredentialStore.decode_password."""
2120
return credentials['password']
2123
credential_store_registry.register('plain', PlainTextCredentialStore,
2124
help=PlainTextCredentialStore.__doc__)
2125
credential_store_registry.default_key = 'plain'
2128
class BzrDirConfig(object):
2130
def __init__(self, bzrdir):
2131
self._bzrdir = bzrdir
2132
self._config = bzrdir._get_config()
2134
def set_default_stack_on(self, value):
2135
"""Set the default stacking location.
2137
It may be set to a location, or None.
2139
This policy affects all branches contained by this bzrdir, except for
2140
those under repositories.
2142
if self._config is None:
2143
raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
2145
self._config.set_option('', 'default_stack_on')
2147
self._config.set_option(value, 'default_stack_on')
2149
def get_default_stack_on(self):
2150
"""Return the default stacking location.
2152
This will either be a location, or None.
2154
This policy affects all branches contained by this bzrdir, except for
2155
those under repositories.
2157
if self._config is None:
2159
value = self._config.get_option('default_stack_on')
2165
class TransportConfig(object):
2166
"""A Config that reads/writes a config file on a Transport.
2168
It is a low-level object that considers config data to be name/value pairs
2169
that may be associated with a section. Assigning meaning to these values
2170
is done at higher levels like TreeConfig.
2173
def __init__(self, transport, filename):
2174
self._transport = transport
2175
self._filename = filename
2177
def get_option(self, name, section=None, default=None):
2178
"""Return the value associated with a named option.
2180
:param name: The name of the value
2181
:param section: The section the option is in (if any)
2182
:param default: The value to return if the value is not set
2183
:return: The value or default value
2185
configobj = self._get_configobj()
2187
section_obj = configobj
2190
section_obj = configobj[section]
2193
value = section_obj.get(name, default)
2194
for hook in OldConfigHooks['get']:
2195
hook(self, name, value)
2198
def set_option(self, value, name, section=None):
2199
"""Set the value associated with a named option.
2201
:param value: The value to set
2202
:param name: The name of the value to set
2203
:param section: The section the option is in (if any)
2205
configobj = self._get_configobj()
2207
configobj[name] = value
2209
configobj.setdefault(section, {})[name] = value
2210
for hook in OldConfigHooks['set']:
2211
hook(self, name, value)
2212
self._set_configobj(configobj)
2214
def remove_option(self, option_name, section_name=None):
2215
configobj = self._get_configobj()
2216
if section_name is None:
2217
del configobj[option_name]
2219
del configobj[section_name][option_name]
2220
for hook in OldConfigHooks['remove']:
2221
hook(self, option_name)
2222
self._set_configobj(configobj)
2224
def _get_config_file(self):
2226
f = StringIO(self._transport.get_bytes(self._filename))
2227
for hook in OldConfigHooks['load']:
2230
except errors.NoSuchFile:
2233
def _external_url(self):
2234
return urlutils.join(self._transport.external_url(), self._filename)
2236
def _get_configobj(self):
2237
f = self._get_config_file()
2240
conf = ConfigObj(f, encoding='utf-8')
2241
except configobj.ConfigObjError, e:
2242
raise errors.ParseConfigError(e.errors, self._external_url())
2243
except UnicodeDecodeError:
2244
raise errors.ConfigContentError(self._external_url())
2249
def _set_configobj(self, configobj):
2250
out_file = StringIO()
2251
configobj.write(out_file)
2253
self._transport.put_file(self._filename, out_file)
2254
for hook in OldConfigHooks['save']:
2258
class Option(object):
2259
"""An option definition.
2261
The option *values* are stored in config files and found in sections.
2263
Here we define various properties about the option itself, its default
2264
value, in which config files it can be stored, etc (TBC).
2267
def __init__(self, name, default=None, from_unicode=None):
2269
self.default = default
2270
self.from_unicode = from_unicode
2272
def get_default(self):
2276
# Predefined converters to get proper values from store
2278
def bool_from_store(unicode_str):
2279
return ui.bool_from_string(unicode_str)
2284
option_registry = registry.Registry()
2287
option_registry.register(
2288
'editor', Option('editor'),
2289
help='The command called to launch an editor to enter a message.')
2291
option_registry.register(
2292
'dirstate.fdatasync', Option('dirstate.fdatasync', default=True,
2293
from_unicode=bool_from_store),
2294
help='Flush dirstate changes onto physical disk?')
2296
option_registry.register(
2297
'repository.fdatasync',
2298
Option('repository.fdatasync', default=True, from_unicode=bool_from_store),
2299
help='Flush repository changes onto physical disk?')
2302
class Section(object):
2303
"""A section defines a dict of option name => value.
2305
This is merely a read-only dict which can add some knowledge about the
2306
options. It is *not* a python dict object though and doesn't try to mimic
2310
def __init__(self, section_id, options):
2311
self.id = section_id
2312
# We re-use the dict-like object received
2313
self.options = options
2315
def get(self, name, default=None):
2316
return self.options.get(name, default)
2319
# Mostly for debugging use
2320
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2323
_NewlyCreatedOption = object()
2324
"""Was the option created during the MutableSection lifetime"""
2327
class MutableSection(Section):
2328
"""A section allowing changes and keeping track of the original values."""
2330
def __init__(self, section_id, options):
2331
super(MutableSection, self).__init__(section_id, options)
2334
def set(self, name, value):
2335
if name not in self.options:
2336
# This is a new option
2337
self.orig[name] = _NewlyCreatedOption
2338
elif name not in self.orig:
2339
self.orig[name] = self.get(name, None)
2340
self.options[name] = value
2342
def remove(self, name):
2343
if name not in self.orig:
2344
self.orig[name] = self.get(name, None)
2345
del self.options[name]
2348
class Store(object):
2349
"""Abstract interface to persistent storage for configuration options."""
2351
readonly_section_class = Section
2352
mutable_section_class = MutableSection
2354
def is_loaded(self):
2355
"""Returns True if the Store has been loaded.
2357
This is used to implement lazy loading and ensure the persistent
2358
storage is queried only when needed.
2360
raise NotImplementedError(self.is_loaded)
2363
"""Loads the Store from persistent storage."""
2364
raise NotImplementedError(self.load)
2366
def _load_from_string(self, bytes):
2367
"""Create a store from a string in configobj syntax.
2369
:param bytes: A string representing the file content.
2371
raise NotImplementedError(self._load_from_string)
2374
"""Unloads the Store.
2376
This should make is_loaded() return False. This is used when the caller
2377
knows that the persistent storage has changed or may have change since
2380
raise NotImplementedError(self.unload)
2383
"""Saves the Store to persistent storage."""
2384
raise NotImplementedError(self.save)
2386
def external_url(self):
2387
raise NotImplementedError(self.external_url)
2389
def get_sections(self):
2390
"""Returns an ordered iterable of existing sections.
2392
:returns: An iterable of (name, dict).
2394
raise NotImplementedError(self.get_sections)
2396
def get_mutable_section(self, section_name=None):
2397
"""Returns the specified mutable section.
2399
:param section_name: The section identifier
2401
raise NotImplementedError(self.get_mutable_section)
2404
# Mostly for debugging use
2405
return "<config.%s(%s)>" % (self.__class__.__name__,
2406
self.external_url())
2409
class IniFileStore(Store):
2410
"""A config Store using ConfigObj for storage.
2412
:ivar transport: The transport object where the config file is located.
2414
:ivar file_name: The config file basename in the transport directory.
2416
:ivar _config_obj: Private member to hold the ConfigObj instance used to
2417
serialize/deserialize the config file.
2420
def __init__(self, transport, file_name):
2421
"""A config Store using ConfigObj for storage.
2423
:param transport: The transport object where the config file is located.
2425
:param file_name: The config file basename in the transport directory.
2427
super(IniFileStore, self).__init__()
2428
self.transport = transport
2429
self.file_name = file_name
2430
self._config_obj = None
2432
def is_loaded(self):
2433
return self._config_obj != None
2436
self._config_obj = None
2439
"""Load the store from the associated file."""
2440
if self.is_loaded():
2442
content = self.transport.get_bytes(self.file_name)
2443
self._load_from_string(content)
2444
for hook in ConfigHooks['load']:
2447
def _load_from_string(self, bytes):
2448
"""Create a config store from a string.
2450
:param bytes: A string representing the file content.
2452
if self.is_loaded():
2453
raise AssertionError('Already loaded: %r' % (self._config_obj,))
2454
co_input = StringIO(bytes)
2456
# The config files are always stored utf8-encoded
2457
self._config_obj = ConfigObj(co_input, encoding='utf-8')
2458
except configobj.ConfigObjError, e:
2459
self._config_obj = None
2460
raise errors.ParseConfigError(e.errors, self.external_url())
2461
except UnicodeDecodeError:
2462
raise errors.ConfigContentError(self.external_url())
2465
if not self.is_loaded():
2469
self._config_obj.write(out)
2470
self.transport.put_bytes(self.file_name, out.getvalue())
2471
for hook in ConfigHooks['save']:
2474
def external_url(self):
2475
# FIXME: external_url should really accepts an optional relpath
2476
# parameter (bug #750169) :-/ -- vila 2011-04-04
2477
# The following will do in the interim but maybe we don't want to
2478
# expose a path here but rather a config ID and its associated
2479
# object </hand wawe>.
2480
return urlutils.join(self.transport.external_url(), self.file_name)
2482
def get_sections(self):
2483
"""Get the configobj section in the file order.
2485
:returns: An iterable of (name, dict).
2487
# We need a loaded store
2490
except errors.NoSuchFile:
2491
# If the file doesn't exist, there is no sections
2493
cobj = self._config_obj
2495
yield self.readonly_section_class(None, cobj)
2496
for section_name in cobj.sections:
2497
yield self.readonly_section_class(section_name, cobj[section_name])
2499
def get_mutable_section(self, section_name=None):
2500
# We need a loaded store
2503
except errors.NoSuchFile:
2504
# The file doesn't exist, let's pretend it was empty
2505
self._load_from_string('')
2506
if section_name is None:
2507
section = self._config_obj
2509
section = self._config_obj.setdefault(section_name, {})
2510
return self.mutable_section_class(section_name, section)
2513
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
2514
# unlockable stores for use with objects that can already ensure the locking
2515
# (think branches). If different stores (not based on ConfigObj) are created,
2516
# they may face the same issue.
2519
class LockableIniFileStore(IniFileStore):
2520
"""A ConfigObjStore using locks on save to ensure store integrity."""
2522
def __init__(self, transport, file_name, lock_dir_name=None):
2523
"""A config Store using ConfigObj for storage.
2525
:param transport: The transport object where the config file is located.
2527
:param file_name: The config file basename in the transport directory.
2529
if lock_dir_name is None:
2530
lock_dir_name = 'lock'
2531
self.lock_dir_name = lock_dir_name
2532
super(LockableIniFileStore, self).__init__(transport, file_name)
2533
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
2535
def lock_write(self, token=None):
2536
"""Takes a write lock in the directory containing the config file.
2538
If the directory doesn't exist it is created.
2540
# FIXME: This doesn't check the ownership of the created directories as
2541
# ensure_config_dir_exists does. It should if the transport is local
2542
# -- vila 2011-04-06
2543
self.transport.create_prefix()
2544
return self._lock.lock_write(token)
2549
def break_lock(self):
2550
self._lock.break_lock()
2554
# We need to be able to override the undecorated implementation
2555
self.save_without_locking()
2557
def save_without_locking(self):
2558
super(LockableIniFileStore, self).save()
2561
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
2562
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
2563
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
2565
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
2566
# functions or a registry will make it easier and clearer for tests, focusing
2567
# on the relevant parts of the API that needs testing -- vila 20110503 (based
2568
# on a poolie's remark)
2569
class GlobalStore(LockableIniFileStore):
2571
def __init__(self, possible_transports=None):
2572
t = transport.get_transport(config_dir(),
2573
possible_transports=possible_transports)
2574
super(GlobalStore, self).__init__(t, 'bazaar.conf')
2577
class LocationStore(LockableIniFileStore):
2579
def __init__(self, possible_transports=None):
2580
t = transport.get_transport(config_dir(),
2581
possible_transports=possible_transports)
2582
super(LocationStore, self).__init__(t, 'locations.conf')
2585
class BranchStore(IniFileStore):
2587
def __init__(self, branch):
2588
super(BranchStore, self).__init__(branch.control_transport,
2590
self.branch = branch
2592
def lock_write(self, token=None):
2593
return self.branch.lock_write(token)
2596
return self.branch.unlock()
2600
# We need to be able to override the undecorated implementation
2601
self.save_without_locking()
2603
def save_without_locking(self):
2604
super(BranchStore, self).save()
2607
class SectionMatcher(object):
2608
"""Select sections into a given Store.
2610
This intended to be used to postpone getting an iterable of sections from a
2614
def __init__(self, store):
2617
def get_sections(self):
2618
# This is where we require loading the store so we can see all defined
2620
sections = self.store.get_sections()
2621
# Walk the revisions in the order provided
2626
def match(self, secion):
2627
raise NotImplementedError(self.match)
2630
class LocationSection(Section):
2632
def __init__(self, section, length, extra_path):
2633
super(LocationSection, self).__init__(section.id, section.options)
2634
self.length = length
2635
self.extra_path = extra_path
2637
def get(self, name, default=None):
2638
value = super(LocationSection, self).get(name, default)
2639
if value is not None:
2640
policy_name = self.get(name + ':policy', None)
2641
policy = _policy_value.get(policy_name, POLICY_NONE)
2642
if policy == POLICY_APPENDPATH:
2643
value = urlutils.join(value, self.extra_path)
2647
class LocationMatcher(SectionMatcher):
2649
def __init__(self, store, location):
2650
super(LocationMatcher, self).__init__(store)
2651
if location.startswith('file://'):
2652
location = urlutils.local_path_from_url(location)
2653
self.location = location
2655
def _get_matching_sections(self):
2656
"""Get all sections matching ``location``."""
2657
# We slightly diverge from LocalConfig here by allowing the no-name
2658
# section as the most generic one and the lower priority.
2659
no_name_section = None
2661
# Filter out the no_name_section so _iter_for_location_by_parts can be
2662
# used (it assumes all sections have a name).
2663
for section in self.store.get_sections():
2664
if section.id is None:
2665
no_name_section = section
2667
all_sections.append(section)
2668
# Unfortunately _iter_for_location_by_parts deals with section names so
2669
# we have to resync.
2670
filtered_sections = _iter_for_location_by_parts(
2671
[s.id for s in all_sections], self.location)
2672
iter_all_sections = iter(all_sections)
2673
matching_sections = []
2674
if no_name_section is not None:
2675
matching_sections.append(
2676
LocationSection(no_name_section, 0, self.location))
2677
for section_id, extra_path, length in filtered_sections:
2678
# a section id is unique for a given store so it's safe to take the
2679
# first matching section while iterating. Also, all filtered
2680
# sections are part of 'all_sections' and will always be found
2683
section = iter_all_sections.next()
2684
if section_id == section.id:
2685
matching_sections.append(
2686
LocationSection(section, length, extra_path))
2688
return matching_sections
2690
def get_sections(self):
2691
# Override the default implementation as we want to change the order
2692
matching_sections = self._get_matching_sections()
2693
# We want the longest (aka more specific) locations first
2694
sections = sorted(matching_sections,
2695
key=lambda section: (section.length, section.id),
2697
# Sections mentioning 'ignore_parents' restrict the selection
2698
for section in sections:
2699
# FIXME: We really want to use as_bool below -- vila 2011-04-07
2700
ignore = section.get('ignore_parents', None)
2701
if ignore is not None:
2702
ignore = ui.bool_from_string(ignore)
2705
# Finally, we have a valid section
2709
class Stack(object):
2710
"""A stack of configurations where an option can be defined"""
2712
def __init__(self, sections_def, store=None, mutable_section_name=None):
2713
"""Creates a stack of sections with an optional store for changes.
2715
:param sections_def: A list of Section or callables that returns an
2716
iterable of Section. This defines the Sections for the Stack and
2717
can be called repeatedly if needed.
2719
:param store: The optional Store where modifications will be
2720
recorded. If none is specified, no modifications can be done.
2722
:param mutable_section_name: The name of the MutableSection where
2723
changes are recorded. This requires the ``store`` parameter to be
2726
self.sections_def = sections_def
2728
self.mutable_section_name = mutable_section_name
2730
def get(self, name):
2731
"""Return the *first* option value found in the sections.
2733
This is where we guarantee that sections coming from Store are loaded
2734
lazily: the loading is delayed until we need to either check that an
2735
option exists or get its value, which in turn may require to discover
2736
in which sections it can be defined. Both of these (section and option
2737
existence) require loading the store (even partially).
2739
# FIXME: No caching of options nor sections yet -- vila 20110503
2741
# Ensuring lazy loading is achieved by delaying section matching (which
2742
# implies querying the persistent storage) until it can't be avoided
2743
# anymore by using callables to describe (possibly empty) section
2745
for section_or_callable in self.sections_def:
2746
# Each section can expand to multiple ones when a callable is used
2747
if callable(section_or_callable):
2748
sections = section_or_callable()
2750
sections = [section_or_callable]
2751
for section in sections:
2752
value = section.get(name)
2753
if value is not None:
2755
if value is not None:
2757
# If the option is registered, it may provide additional info about
2760
opt = option_registry.get(name)
2764
if (opt is not None and opt.from_unicode is not None
2765
and value is not None):
2766
# If a value exists and the option provides a converter, use it
2768
converted = opt.from_unicode(value)
2769
except (ValueError, TypeError):
2770
# Invalid values are ignored
2774
# If the option is registered, it may provide a default value
2776
value = opt.get_default()
2777
if opt is not None and value is None:
2778
value = opt.get_default()
2779
for hook in ConfigHooks['get']:
2780
hook(self, name, value)
2783
def _get_mutable_section(self):
2784
"""Get the MutableSection for the Stack.
2786
This is where we guarantee that the mutable section is lazily loaded:
2787
this means we won't load the corresponding store before setting a value
2788
or deleting an option. In practice the store will often be loaded but
2789
this allows helps catching some programming errors.
2791
section = self.store.get_mutable_section(self.mutable_section_name)
2794
def set(self, name, value):
2795
"""Set a new value for the option."""
2796
section = self._get_mutable_section()
2797
section.set(name, value)
2798
for hook in ConfigHooks['set']:
2799
hook(self, name, value)
2801
def remove(self, name):
2802
"""Remove an existing option."""
2803
section = self._get_mutable_section()
2804
section.remove(name)
2805
for hook in ConfigHooks['remove']:
2809
# Mostly for debugging use
2810
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
2813
class _CompatibleStack(Stack):
2814
"""Place holder for compatibility with previous design.
2816
This is intended to ease the transition from the Config-based design to the
2817
Stack-based design and should not be used nor relied upon by plugins.
2819
One assumption made here is that the daughter classes will all use Stores
2820
derived from LockableIniFileStore).
2822
It implements set() by re-loading the store before applying the
2823
modification and saving it.
2825
The long term plan being to implement a single write by store to save
2826
all modifications, this class should not be used in the interim.
2829
def set(self, name, value):
2832
super(_CompatibleStack, self).set(name, value)
2833
# Force a write to persistent storage
2837
class GlobalStack(_CompatibleStack):
2841
gstore = GlobalStore()
2842
super(GlobalStack, self).__init__([gstore.get_sections], gstore)
2845
class LocationStack(_CompatibleStack):
2847
def __init__(self, location):
2848
"""Make a new stack for a location and global configuration.
2850
:param location: A URL prefix to """
2851
lstore = LocationStore()
2852
matcher = LocationMatcher(lstore, location)
2853
gstore = GlobalStore()
2854
super(LocationStack, self).__init__(
2855
[matcher.get_sections, gstore.get_sections], lstore)
2857
class BranchStack(_CompatibleStack):
2859
def __init__(self, branch):
2860
bstore = BranchStore(branch)
2861
lstore = LocationStore()
2862
matcher = LocationMatcher(lstore, branch.base)
2863
gstore = GlobalStore()
2864
super(BranchStack, self).__init__(
2865
[matcher.get_sections, bstore.get_sections, gstore.get_sections],
2867
self.branch = branch
2870
class cmd_config(commands.Command):
2871
__doc__ = """Display, set or remove a configuration option.
2873
Display the active value for a given option.
2875
If --all is specified, NAME is interpreted as a regular expression and all
2876
matching options are displayed mentioning their scope. The active value
2877
that bzr will take into account is the first one displayed for each option.
2879
If no NAME is given, --all .* is implied.
2881
Setting a value is achieved by using name=value without spaces. The value
2882
is set in the most relevant scope and can be checked by displaying the
2886
takes_args = ['name?']
2890
# FIXME: This should be a registry option so that plugins can register
2891
# their own config files (or not) -- vila 20101002
2892
commands.Option('scope', help='Reduce the scope to the specified'
2893
' configuration file',
2895
commands.Option('all',
2896
help='Display all the defined values for the matching options.',
2898
commands.Option('remove', help='Remove the option from'
2899
' the configuration file'),
2902
_see_also = ['configuration']
2904
@commands.display_command
2905
def run(self, name=None, all=False, directory=None, scope=None,
2907
if directory is None:
2909
directory = urlutils.normalize_url(directory)
2911
raise errors.BzrError(
2912
'--all and --remove are mutually exclusive.')
2914
# Delete the option in the given scope
2915
self._remove_config_option(name, directory, scope)
2917
# Defaults to all options
2918
self._show_matching_options('.*', directory, scope)
2921
name, value = name.split('=', 1)
2923
# Display the option(s) value(s)
2925
self._show_matching_options(name, directory, scope)
2927
self._show_value(name, directory, scope)
2930
raise errors.BzrError(
2931
'Only one option can be set.')
2932
# Set the option value
2933
self._set_config_option(name, value, directory, scope)
2935
def _get_configs(self, directory, scope=None):
2936
"""Iterate the configurations specified by ``directory`` and ``scope``.
2938
:param directory: Where the configurations are derived from.
2940
:param scope: A specific config to start from.
2942
if scope is not None:
2943
if scope == 'bazaar':
2944
yield GlobalConfig()
2945
elif scope == 'locations':
2946
yield LocationConfig(directory)
2947
elif scope == 'branch':
2948
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2950
yield br.get_config()
2953
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2955
yield br.get_config()
2956
except errors.NotBranchError:
2957
yield LocationConfig(directory)
2958
yield GlobalConfig()
2960
def _show_value(self, name, directory, scope):
2962
for c in self._get_configs(directory, scope):
2965
for (oname, value, section, conf_id, parser) in c._get_options():
2967
# Display only the first value and exit
2969
# FIXME: We need to use get_user_option to take policies
2970
# into account and we need to make sure the option exists
2971
# too (hence the two for loops), this needs a better API
2973
value = c.get_user_option(name)
2974
# Quote the value appropriately
2975
value = parser._quote(value)
2976
self.outf.write('%s\n' % (value,))
2980
raise errors.NoSuchConfigOption(name)
2982
def _show_matching_options(self, name, directory, scope):
2983
name = lazy_regex.lazy_compile(name)
2984
# We want any error in the regexp to be raised *now* so we need to
2985
# avoid the delay introduced by the lazy regexp. But, we still do
2986
# want the nicer errors raised by lazy_regex.
2987
name._compile_and_collapse()
2990
for c in self._get_configs(directory, scope):
2991
for (oname, value, section, conf_id, parser) in c._get_options():
2992
if name.search(oname):
2993
if cur_conf_id != conf_id:
2994
# Explain where the options are defined
2995
self.outf.write('%s:\n' % (conf_id,))
2996
cur_conf_id = conf_id
2998
if (section not in (None, 'DEFAULT')
2999
and cur_section != section):
3000
# Display the section if it's not the default (or only)
3002
self.outf.write(' [%s]\n' % (section,))
3003
cur_section = section
3004
self.outf.write(' %s = %s\n' % (oname, value))
3006
def _set_config_option(self, name, value, directory, scope):
3007
for conf in self._get_configs(directory, scope):
3008
conf.set_user_option(name, value)
3011
raise errors.NoSuchConfig(scope)
3013
def _remove_config_option(self, name, directory, scope):
3015
raise errors.BzrCommandError(
3016
'--remove expects an option to remove.')
3018
for conf in self._get_configs(directory, scope):
3019
for (section_name, section, conf_id) in conf._get_sections():
3020
if scope is not None and conf_id != scope:
3021
# Not the right configuration file
3024
if conf_id != conf.config_id():
3025
conf = self._get_configs(directory, conf_id).next()
3026
# We use the first section in the first config where the
3027
# option is defined to remove it
3028
conf.remove_user_option(name, section_name)
3033
raise errors.NoSuchConfig(scope)
3035
raise errors.NoSuchConfigOption(name)
3039
# We need adapters that can build a Store or a Stack in a test context. Test
3040
# classes, based on TestCaseWithTransport, can use the registry to parametrize
3041
# themselves. The builder will receive a test instance and should return a
3042
# ready-to-use store or stack. Plugins that define new store/stacks can also
3043
# register themselves here to be tested against the tests defined in
3044
# bzrlib.tests.test_config. Note that the builder can be called multiple times
3045
# for the same tests.
3047
# The registered object should be a callable receiving a test instance
3048
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
3050
test_store_builder_registry = registry.Registry()
3052
# The registered object should be a callable receiving a test instance
3053
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
3055
test_stack_builder_registry = registry.Registry()
526
self.branch.lock_write()
528
cfg_obj = self._get_config()
533
obj = cfg_obj[section]
535
cfg_obj[section] = {}
536
obj = cfg_obj[section]
538
cfg_obj.encode('UTF-8')
539
out_file = StringIO(''.join([l+'\n' for l in cfg_obj.write()]))
541
self.branch.put_controlfile('branch.conf', out_file, encode=False)
added
removed
bzrlib/config.py
