126
def ConfigObj(*args, **kwargs):
128
if _ConfigObj is None:
129
class ConfigObj(configobj.ConfigObj):
131
def get_bool(self, section, key):
132
return self[section].as_bool(key)
134
def get_value(self, section, name):
135
# Try [] for the old DEFAULT section.
136
if section == "DEFAULT":
141
return self[section][name]
142
_ConfigObj = ConfigObj
143
return _ConfigObj(*args, **kwargs)
127
class ConfigObj(configobj.ConfigObj):
129
def get_bool(self, section, key):
130
return self[section].as_bool(key)
132
def get_value(self, section, name):
133
# Try [] for the old DEFAULT section.
134
if section == "DEFAULT":
139
return self[section][name]
146
142
class Config(object):
147
143
"""A configuration policy - what username, editor, gpg needs etc."""
150
super(Config, self).__init__()
152
145
def get_editor(self):
153
146
"""Get the users pop up editor."""
154
147
raise NotImplementedError
156
def get_change_editor(self, old_tree, new_tree):
157
from bzrlib import diff
158
cmd = self._get_change_editor()
161
return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
165
149
def get_mail_client(self):
166
150
"""Get a mail client to use"""
167
151
selected_client = self.get_user_option('mail_client')
168
_registry = mail_client.mail_client_registry
170
mail_client_class = _registry.get(selected_client)
153
mail_client_class = {
154
None: mail_client.DefaultMail,
156
'evolution': mail_client.Evolution,
157
'kmail': mail_client.KMail,
158
'mutt': mail_client.Mutt,
159
'thunderbird': mail_client.Thunderbird,
161
'default': mail_client.DefaultMail,
162
'editor': mail_client.Editor,
163
'mapi': mail_client.MAPIClient,
164
'xdg-email': mail_client.XDGEmail,
172
167
raise errors.UnknownMailClient(selected_client)
173
168
return mail_client_class(self)
489
449
def set_user_option(self, option, value):
490
450
"""Save option and its value in the configuration."""
491
self._set_option(option, value, 'DEFAULT')
493
def get_aliases(self):
494
"""Return the aliases section."""
495
if 'ALIASES' in self._get_parser():
496
return self._get_parser()['ALIASES']
500
def set_alias(self, alias_name, alias_command):
501
"""Save the alias in the configuration."""
502
self._set_option(alias_name, alias_command, 'ALIASES')
504
def unset_alias(self, alias_name):
505
"""Unset an existing alias."""
506
aliases = self._get_parser().get('ALIASES')
507
if not aliases or alias_name not in aliases:
508
raise errors.NoSuchAlias(alias_name)
509
del aliases[alias_name]
510
self._write_config_file()
512
def _set_option(self, option, value, section):
513
451
# FIXME: RBC 20051029 This should refresh the parser and also take a
514
452
# file lock on bazaar.conf.
515
453
conf_dir = os.path.dirname(self._get_filename())
516
454
ensure_config_dir_exists(conf_dir)
517
self._get_parser().setdefault(section, {})[option] = value
518
self._write_config_file()
520
def _write_config_file(self):
521
path = self._get_filename()
523
osutils.copy_ownership_from_path(path)
455
if 'DEFAULT' not in self._get_parser():
456
self._get_parser()['DEFAULT'] = {}
457
self._get_parser()['DEFAULT'][option] = value
458
f = open(self._get_filename(), 'wb')
524
459
self._get_parser().write(f)
963
862
except ImportError:
966
user_encoding = osutils.get_user_encoding()
967
realname = username = getpass.getuser().decode(user_encoding)
865
realname = username = getpass.getuser().decode(bzrlib.user_encoding)
968
866
except UnicodeDecodeError:
969
867
raise errors.BzrError("Can't decode username as %s." % \
868
bzrlib.user_encoding)
972
870
return realname, (username + '@' + socket.gethostname())
975
def parse_username(username):
976
"""Parse e-mail username and return a (name, address) tuple."""
977
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
979
return (username, '')
981
return (match.group(1), match.group(2))
984
873
def extract_email_address(e):
985
874
"""Return just the address part of an email string.
987
That is just the user@domain part, nothing else.
876
That is just the user@domain part, nothing else.
988
877
This part is required to contain only ascii characters.
989
878
If it can't be extracted, raises an error.
991
880
>>> extract_email_address('Jane Tester <jane@test.com>')
994
name, email = parse_username(e)
883
m = re.search(r'[\w+.-]+@[\w+.-]+', e)
996
885
raise errors.NoEmailInUsername(e)
1000
889
class TreeConfig(IniBasedConfig):
1001
890
"""Branch configuration data associated with its contents, not location"""
1003
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1005
892
def __init__(self, branch):
1006
self._config = branch._get_config()
1007
893
self.branch = branch
1009
895
def _get_parser(self, file=None):
1010
896
if file is not None:
1011
897
return IniBasedConfig._get_parser(file)
1012
return self._config._get_configobj()
898
return self._get_config()
900
def _get_config(self):
902
obj = ConfigObj(self.branch.control_files.get('branch.conf'),
904
except errors.NoSuchFile:
905
obj = ConfigObj(encoding='utf=8')
1014
908
def get_option(self, name, section=None, default=None):
1015
909
self.branch.lock_read()
1017
return self._config.get_option(name, section, default)
911
obj = self._get_config()
913
if section is not None:
1019
919
self.branch.unlock()
1021
922
def set_option(self, value, name, section=None):
1022
923
"""Set a per-branch configuration option"""
1023
924
self.branch.lock_write()
1025
self._config.set_option(value, name, section)
926
cfg_obj = self._get_config()
931
obj = cfg_obj[section]
933
cfg_obj[section] = {}
934
obj = cfg_obj[section]
936
out_file = StringIO()
937
cfg_obj.write(out_file)
939
self.branch.control_files.put('branch.conf', out_file)
1027
941
self.branch.unlock()
1147
1047
if a_user is None:
1148
1048
# Can't find a user
1150
# Prepare a credentials dictionary with additional keys
1151
# for the credential providers
1152
credentials = dict(name=auth_def_name,
1159
password=auth_def.get('password', None),
1160
verify_certificates=a_verify_certificates)
1161
# Decode the password in the credentials (or get one)
1162
self.decode_password(credentials,
1163
auth_def.get('password_encoding', None))
1050
a_password, a_encoding = map(auth_def.get,
1051
['password', 'password_encoding'])
1052
password = self.decode_password(a_password, a_encoding)
1053
credentials = {'name': auth_def_name,
1054
'user': a_user, 'password': password,
1055
'verify_certificates': a_verify_certificates,
1164
1057
if 'auth' in debug.debug_flags:
1165
1058
trace.mutter("Using authentication section: %r", auth_def_name)
1168
if credentials is None:
1169
# No credentials were found in authentication.conf, try the fallback
1170
# credentials stores.
1171
credentials = credential_store_registry.get_fallback_credentials(
1172
scheme, host, port, user, path, realm)
1174
1061
return credentials
1176
def set_credentials(self, name, host, user, scheme=None, password=None,
1177
port=None, path=None, verify_certificates=None,
1179
"""Set authentication credentials for a host.
1181
Any existing credentials with matching scheme, host, port and path
1182
will be deleted, regardless of name.
1184
:param name: An arbitrary name to describe this set of credentials.
1185
:param host: Name of the host that accepts these credentials.
1186
:param user: The username portion of these credentials.
1187
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1189
:param password: Password portion of these credentials.
1190
:param port: The IP port on the host that these credentials apply to.
1191
:param path: A filesystem path on the host that these credentials
1193
:param verify_certificates: On https, verify server certificates if
1195
:param realm: The http authentication realm (optional).
1197
values = {'host': host, 'user': user}
1198
if password is not None:
1199
values['password'] = password
1200
if scheme is not None:
1201
values['scheme'] = scheme
1202
if port is not None:
1203
values['port'] = '%d' % port
1204
if path is not None:
1205
values['path'] = path
1206
if verify_certificates is not None:
1207
values['verify_certificates'] = str(verify_certificates)
1208
if realm is not None:
1209
values['realm'] = realm
1210
config = self._get_config()
1212
for section, existing_values in config.items():
1213
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1214
if existing_values.get(key) != values.get(key):
1218
config.update({name: values})
1221
def get_user(self, scheme, host, port=None, realm=None, path=None,
1222
prompt=None, ask=False, default=None):
1063
def get_user(self, scheme, host, port=None,
1064
realm=None, path=None, prompt=None):
1223
1065
"""Get a user from authentication file.
1225
1067
:param scheme: protocol
1279
1103
:return: The found password or the one entered by the user.
1281
credentials = self.get_credentials(scheme, host, port, user, path,
1105
credentials = self.get_credentials(scheme, host, port, user, path)
1283
1106
if credentials is not None:
1284
1107
password = credentials['password']
1285
if password is not None and scheme is 'ssh':
1286
trace.warning('password ignored in section [%s],'
1287
' use an ssh agent instead'
1288
% credentials['name'])
1291
1109
password = None
1292
# Prompt user only if we could't find a password
1293
1110
if password is None:
1111
# Prompt user only if we could't find a password
1294
1112
if prompt is None:
1295
# Create a default prompt suitable for most cases
1296
prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
1113
prompt = ('%s' % scheme.upper()
1114
+ ' %(user)s@%(host)s%(realm)s password')
1297
1115
# Special handling for optional fields in the prompt
1298
1116
if port is not None:
1299
1117
prompt_host = '%s:%d' % (host, port)
1301
1119
prompt_host = host
1302
password = ui.ui_factory.get_password(prompt,
1303
host=prompt_host, user=user)
1306
def decode_password(self, credentials, encoding):
1308
cs = credential_store_registry.get_credential_store(encoding)
1310
raise ValueError('%r is not a known password_encoding' % encoding)
1311
credentials['password'] = cs.decode_password(credentials)
1315
class CredentialStoreRegistry(registry.Registry):
1316
"""A class that registers credential stores.
1318
A credential store provides access to credentials via the password_encoding
1319
field in authentication.conf sections.
1321
Except for stores provided by bzr itself, most stores are expected to be
1322
provided by plugins that will therefore use
1323
register_lazy(password_encoding, module_name, member_name, help=help,
1324
fallback=fallback) to install themselves.
1326
A fallback credential store is one that is queried if no credentials can be
1327
found via authentication.conf.
1330
def get_credential_store(self, encoding=None):
1331
cs = self.get(encoding)
1336
def is_fallback(self, name):
1337
"""Check if the named credentials store should be used as fallback."""
1338
return self.get_info(name)
1340
def get_fallback_credentials(self, scheme, host, port=None, user=None,
1341
path=None, realm=None):
1342
"""Request credentials from all fallback credentials stores.
1344
The first credentials store that can provide credentials wins.
1347
for name in self.keys():
1348
if not self.is_fallback(name):
1350
cs = self.get_credential_store(name)
1351
credentials = cs.get_credentials(scheme, host, port, user,
1353
if credentials is not None:
1354
# We found some credentials
1358
def register(self, key, obj, help=None, override_existing=False,
1360
"""Register a new object to a name.
1362
:param key: This is the key to use to request the object later.
1363
:param obj: The object to register.
1364
:param help: Help text for this entry. This may be a string or
1365
a callable. If it is a callable, it should take two
1366
parameters (registry, key): this registry and the key that
1367
the help was registered under.
1368
:param override_existing: Raise KeyErorr if False and something has
1369
already been registered for that key. If True, ignore if there
1370
is an existing key (always register the new value).
1371
:param fallback: Whether this credential store should be
1374
return super(CredentialStoreRegistry,
1375
self).register(key, obj, help, info=fallback,
1376
override_existing=override_existing)
1378
def register_lazy(self, key, module_name, member_name,
1379
help=None, override_existing=False,
1381
"""Register a new credential store to be loaded on request.
1383
:param module_name: The python path to the module. Such as 'os.path'.
1384
:param member_name: The member of the module to return. If empty or
1385
None, get() will return the module itself.
1386
:param help: Help text for this entry. This may be a string or
1388
:param override_existing: If True, replace the existing object
1389
with the new one. If False, if there is already something
1390
registered with the same key, raise a KeyError
1391
:param fallback: Whether this credential store should be
1394
return super(CredentialStoreRegistry, self).register_lazy(
1395
key, module_name, member_name, help,
1396
info=fallback, override_existing=override_existing)
1399
credential_store_registry = CredentialStoreRegistry()
1402
class CredentialStore(object):
1403
"""An abstract class to implement storage for credentials"""
1405
def decode_password(self, credentials):
1406
"""Returns a clear text password for the provided credentials."""
1407
raise NotImplementedError(self.decode_password)
1409
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1411
"""Return the matching credentials from this credential store.
1413
This method is only called on fallback credential stores.
1415
raise NotImplementedError(self.get_credentials)
1419
class PlainTextCredentialStore(CredentialStore):
1420
__doc__ = """Plain text credential store for the authentication.conf file"""
1422
def decode_password(self, credentials):
1423
"""See CredentialStore.decode_password."""
1424
return credentials['password']
1427
credential_store_registry.register('plain', PlainTextCredentialStore,
1428
help=PlainTextCredentialStore.__doc__)
1429
credential_store_registry.default_key = 'plain'
1432
class BzrDirConfig(object):
1434
def __init__(self, bzrdir):
1435
self._bzrdir = bzrdir
1436
self._config = bzrdir._get_config()
1438
def set_default_stack_on(self, value):
1439
"""Set the default stacking location.
1441
It may be set to a location, or None.
1443
This policy affects all branches contained by this bzrdir, except for
1444
those under repositories.
1446
if self._config is None:
1447
raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
1449
self._config.set_option('', 'default_stack_on')
1451
self._config.set_option(value, 'default_stack_on')
1453
def get_default_stack_on(self):
1454
"""Return the default stacking location.
1456
This will either be a location, or None.
1458
This policy affects all branches contained by this bzrdir, except for
1459
those under repositories.
1461
if self._config is None:
1463
value = self._config.get_option('default_stack_on')
1469
class TransportConfig(object):
1470
"""A Config that reads/writes a config file on a Transport.
1472
It is a low-level object that considers config data to be name/value pairs
1473
that may be associated with a section. Assigning meaning to the these
1474
values is done at higher levels like TreeConfig.
1477
def __init__(self, transport, filename):
1478
self._transport = transport
1479
self._filename = filename
1481
def get_option(self, name, section=None, default=None):
1482
"""Return the value associated with a named option.
1484
:param name: The name of the value
1485
:param section: The section the option is in (if any)
1486
:param default: The value to return if the value is not set
1487
:return: The value or default value
1489
configobj = self._get_configobj()
1491
section_obj = configobj
1494
section_obj = configobj[section]
1497
return section_obj.get(name, default)
1499
def set_option(self, value, name, section=None):
1500
"""Set the value associated with a named option.
1502
:param value: The value to set
1503
:param name: The name of the value to set
1504
:param section: The section the option is in (if any)
1506
configobj = self._get_configobj()
1508
configobj[name] = value
1510
configobj.setdefault(section, {})[name] = value
1511
self._set_configobj(configobj)
1513
def _get_config_file(self):
1515
return StringIO(self._transport.get_bytes(self._filename))
1516
except errors.NoSuchFile:
1519
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
1522
def _set_configobj(self, configobj):
1523
out_file = StringIO()
1524
configobj.write(out_file)
1526
self._transport.put_file(self._filename, out_file)
1120
if realm is not None:
1121
prompt_realm = ", Realm: '%s'" % realm
1124
password = ui.ui_factory.get_password(prompt, host=prompt_host,
1129
def decode_password(self, password, encoding):
added
removed
bzrlib/config.py
