952
821
except ImportError:
955
user_encoding = osutils.get_user_encoding()
956
realname = username = getpass.getuser().decode(user_encoding)
824
realname = username = getpass.getuser().decode(bzrlib.user_encoding)
957
825
except UnicodeDecodeError:
958
826
raise errors.BzrError("Can't decode username as %s." % \
827
bzrlib.user_encoding)
961
829
return realname, (username + '@' + socket.gethostname())
964
def parse_username(username):
965
"""Parse e-mail username and return a (name, address) tuple."""
966
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
968
return (username, '')
970
return (match.group(1), match.group(2))
973
832
def extract_email_address(e):
974
833
"""Return just the address part of an email string.
976
That is just the user@domain part, nothing else.
835
That is just the user@domain part, nothing else.
977
836
This part is required to contain only ascii characters.
978
837
If it can't be extracted, raises an error.
980
839
>>> extract_email_address('Jane Tester <jane@test.com>')
983
name, email = parse_username(e)
842
m = re.search(r'[\w+.-]+@[\w+.-]+', e)
985
844
raise errors.NoEmailInUsername(e)
989
848
class TreeConfig(IniBasedConfig):
990
849
"""Branch configuration data associated with its contents, not location"""
992
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
994
850
def __init__(self, branch):
995
self._config = branch._get_config()
996
851
self.branch = branch
998
853
def _get_parser(self, file=None):
999
854
if file is not None:
1000
855
return IniBasedConfig._get_parser(file)
1001
return self._config._get_configobj()
856
return self._get_config()
858
def _get_config(self):
860
obj = ConfigObj(self.branch.control_files.get('branch.conf'),
862
except errors.NoSuchFile:
863
obj = ConfigObj(encoding='utf=8')
1003
866
def get_option(self, name, section=None, default=None):
1004
867
self.branch.lock_read()
1006
return self._config.get_option(name, section, default)
869
obj = self._get_config()
871
if section is not None:
1008
877
self.branch.unlock()
1010
880
def set_option(self, value, name, section=None):
1011
881
"""Set a per-branch configuration option"""
1012
882
self.branch.lock_write()
1014
self._config.set_option(value, name, section)
884
cfg_obj = self._get_config()
889
obj = cfg_obj[section]
891
cfg_obj[section] = {}
892
obj = cfg_obj[section]
894
out_file = StringIO()
895
cfg_obj.write(out_file)
897
self.branch.control_files.put('branch.conf', out_file)
1016
899
self.branch.unlock()
1019
class AuthenticationConfig(object):
1020
"""The authentication configuration file based on a ini file.
1022
Implements the authentication.conf file described in
1023
doc/developers/authentication-ring.txt.
1026
def __init__(self, _file=None):
1027
self._config = None # The ConfigObj
1029
self._filename = authentication_config_filename()
1030
self._input = self._filename = authentication_config_filename()
1032
# Tests can provide a string as _file
1033
self._filename = None
1036
def _get_config(self):
1037
if self._config is not None:
1040
# FIXME: Should we validate something here ? Includes: empty
1041
# sections are useless, at least one of
1042
# user/password/password_encoding should be defined, etc.
1044
# Note: the encoding below declares that the file itself is utf-8
1045
# encoded, but the values in the ConfigObj are always Unicode.
1046
self._config = ConfigObj(self._input, encoding='utf-8')
1047
except configobj.ConfigObjError, e:
1048
raise errors.ParseConfigError(e.errors, e.config.filename)
1052
"""Save the config file, only tests should use it for now."""
1053
conf_dir = os.path.dirname(self._filename)
1054
ensure_config_dir_exists(conf_dir)
1055
self._get_config().write(file(self._filename, 'wb'))
1057
def _set_option(self, section_name, option_name, value):
1058
"""Set an authentication configuration option"""
1059
conf = self._get_config()
1060
section = conf.get(section_name)
1063
section = conf[section]
1064
section[option_name] = value
1067
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1069
"""Returns the matching credentials from authentication.conf file.
1071
:param scheme: protocol
1073
:param host: the server address
1075
:param port: the associated port (optional)
1077
:param user: login (optional)
1079
:param path: the absolute path on the server (optional)
1081
:param realm: the http authentication realm (optional)
1083
:return: A dict containing the matching credentials or None.
1085
- name: the section name of the credentials in the
1086
authentication.conf file,
1087
- user: can't be different from the provided user if any,
1088
- scheme: the server protocol,
1089
- host: the server address,
1090
- port: the server port (can be None),
1091
- path: the absolute server path (can be None),
1092
- realm: the http specific authentication realm (can be None),
1093
- password: the decoded password, could be None if the credential
1094
defines only the user
1095
- verify_certificates: https specific, True if the server
1096
certificate should be verified, False otherwise.
1099
for auth_def_name, auth_def in self._get_config().items():
1100
if type(auth_def) is not configobj.Section:
1101
raise ValueError("%s defined outside a section" % auth_def_name)
1103
a_scheme, a_host, a_user, a_path = map(
1104
auth_def.get, ['scheme', 'host', 'user', 'path'])
1107
a_port = auth_def.as_int('port')
1111
raise ValueError("'port' not numeric in %s" % auth_def_name)
1113
a_verify_certificates = auth_def.as_bool('verify_certificates')
1115
a_verify_certificates = True
1118
"'verify_certificates' not boolean in %s" % auth_def_name)
1121
if a_scheme is not None and scheme != a_scheme:
1123
if a_host is not None:
1124
if not (host == a_host
1125
or (a_host.startswith('.') and host.endswith(a_host))):
1127
if a_port is not None and port != a_port:
1129
if (a_path is not None and path is not None
1130
and not path.startswith(a_path)):
1132
if (a_user is not None and user is not None
1133
and a_user != user):
1134
# Never contradict the caller about the user to be used
1139
# Prepare a credentials dictionary with additional keys
1140
# for the credential providers
1141
credentials = dict(name=auth_def_name,
1148
password=auth_def.get('password', None),
1149
verify_certificates=a_verify_certificates)
1150
# Decode the password in the credentials (or get one)
1151
self.decode_password(credentials,
1152
auth_def.get('password_encoding', None))
1153
if 'auth' in debug.debug_flags:
1154
trace.mutter("Using authentication section: %r", auth_def_name)
1157
if credentials is None:
1158
# No credentials were found in authentication.conf, try the fallback
1159
# credentials stores.
1160
credentials = credential_store_registry.get_fallback_credentials(
1161
scheme, host, port, user, path, realm)
1165
def set_credentials(self, name, host, user, scheme=None, password=None,
1166
port=None, path=None, verify_certificates=None,
1168
"""Set authentication credentials for a host.
1170
Any existing credentials with matching scheme, host, port and path
1171
will be deleted, regardless of name.
1173
:param name: An arbitrary name to describe this set of credentials.
1174
:param host: Name of the host that accepts these credentials.
1175
:param user: The username portion of these credentials.
1176
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1178
:param password: Password portion of these credentials.
1179
:param port: The IP port on the host that these credentials apply to.
1180
:param path: A filesystem path on the host that these credentials
1182
:param verify_certificates: On https, verify server certificates if
1184
:param realm: The http authentication realm (optional).
1186
values = {'host': host, 'user': user}
1187
if password is not None:
1188
values['password'] = password
1189
if scheme is not None:
1190
values['scheme'] = scheme
1191
if port is not None:
1192
values['port'] = '%d' % port
1193
if path is not None:
1194
values['path'] = path
1195
if verify_certificates is not None:
1196
values['verify_certificates'] = str(verify_certificates)
1197
if realm is not None:
1198
values['realm'] = realm
1199
config = self._get_config()
1201
for section, existing_values in config.items():
1202
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1203
if existing_values.get(key) != values.get(key):
1207
config.update({name: values})
1210
def get_user(self, scheme, host, port=None, realm=None, path=None,
1211
prompt=None, ask=False, default=None):
1212
"""Get a user from authentication file.
1214
:param scheme: protocol
1216
:param host: the server address
1218
:param port: the associated port (optional)
1220
:param realm: the realm sent by the server (optional)
1222
:param path: the absolute path on the server (optional)
1224
:param ask: Ask the user if there is no explicitly configured username
1227
:param default: The username returned if none is defined (optional).
1229
:return: The found user.
1231
credentials = self.get_credentials(scheme, host, port, user=None,
1232
path=path, realm=realm)
1233
if credentials is not None:
1234
user = credentials['user']
1240
# Create a default prompt suitable for most cases
1241
prompt = scheme.upper() + ' %(host)s username'
1242
# Special handling for optional fields in the prompt
1243
if port is not None:
1244
prompt_host = '%s:%d' % (host, port)
1247
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1252
def get_password(self, scheme, host, user, port=None,
1253
realm=None, path=None, prompt=None):
1254
"""Get a password from authentication file or prompt the user for one.
1256
:param scheme: protocol
1258
:param host: the server address
1260
:param port: the associated port (optional)
1264
:param realm: the realm sent by the server (optional)
1266
:param path: the absolute path on the server (optional)
1268
:return: The found password or the one entered by the user.
1270
credentials = self.get_credentials(scheme, host, port, user, path,
1272
if credentials is not None:
1273
password = credentials['password']
1274
if password is not None and scheme is 'ssh':
1275
trace.warning('password ignored in section [%s],'
1276
' use an ssh agent instead'
1277
% credentials['name'])
1281
# Prompt user only if we could't find a password
1282
if password is None:
1284
# Create a default prompt suitable for most cases
1285
prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
1286
# Special handling for optional fields in the prompt
1287
if port is not None:
1288
prompt_host = '%s:%d' % (host, port)
1291
password = ui.ui_factory.get_password(prompt,
1292
host=prompt_host, user=user)
1295
def decode_password(self, credentials, encoding):
1297
cs = credential_store_registry.get_credential_store(encoding)
1299
raise ValueError('%r is not a known password_encoding' % encoding)
1300
credentials['password'] = cs.decode_password(credentials)
1304
class CredentialStoreRegistry(registry.Registry):
1305
"""A class that registers credential stores.
1307
A credential store provides access to credentials via the password_encoding
1308
field in authentication.conf sections.
1310
Except for stores provided by bzr itself, most stores are expected to be
1311
provided by plugins that will therefore use
1312
register_lazy(password_encoding, module_name, member_name, help=help,
1313
fallback=fallback) to install themselves.
1315
A fallback credential store is one that is queried if no credentials can be
1316
found via authentication.conf.
1319
def get_credential_store(self, encoding=None):
1320
cs = self.get(encoding)
1325
def is_fallback(self, name):
1326
"""Check if the named credentials store should be used as fallback."""
1327
return self.get_info(name)
1329
def get_fallback_credentials(self, scheme, host, port=None, user=None,
1330
path=None, realm=None):
1331
"""Request credentials from all fallback credentials stores.
1333
The first credentials store that can provide credentials wins.
1336
for name in self.keys():
1337
if not self.is_fallback(name):
1339
cs = self.get_credential_store(name)
1340
credentials = cs.get_credentials(scheme, host, port, user,
1342
if credentials is not None:
1343
# We found some credentials
1347
def register(self, key, obj, help=None, override_existing=False,
1349
"""Register a new object to a name.
1351
:param key: This is the key to use to request the object later.
1352
:param obj: The object to register.
1353
:param help: Help text for this entry. This may be a string or
1354
a callable. If it is a callable, it should take two
1355
parameters (registry, key): this registry and the key that
1356
the help was registered under.
1357
:param override_existing: Raise KeyErorr if False and something has
1358
already been registered for that key. If True, ignore if there
1359
is an existing key (always register the new value).
1360
:param fallback: Whether this credential store should be
1363
return super(CredentialStoreRegistry,
1364
self).register(key, obj, help, info=fallback,
1365
override_existing=override_existing)
1367
def register_lazy(self, key, module_name, member_name,
1368
help=None, override_existing=False,
1370
"""Register a new credential store to be loaded on request.
1372
:param module_name: The python path to the module. Such as 'os.path'.
1373
:param member_name: The member of the module to return. If empty or
1374
None, get() will return the module itself.
1375
:param help: Help text for this entry. This may be a string or
1377
:param override_existing: If True, replace the existing object
1378
with the new one. If False, if there is already something
1379
registered with the same key, raise a KeyError
1380
:param fallback: Whether this credential store should be
1383
return super(CredentialStoreRegistry, self).register_lazy(
1384
key, module_name, member_name, help,
1385
info=fallback, override_existing=override_existing)
1388
credential_store_registry = CredentialStoreRegistry()
1391
class CredentialStore(object):
1392
"""An abstract class to implement storage for credentials"""
1394
def decode_password(self, credentials):
1395
"""Returns a clear text password for the provided credentials."""
1396
raise NotImplementedError(self.decode_password)
1398
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1400
"""Return the matching credentials from this credential store.
1402
This method is only called on fallback credential stores.
1404
raise NotImplementedError(self.get_credentials)
1408
class PlainTextCredentialStore(CredentialStore):
1409
"""Plain text credential store for the authentication.conf file."""
1411
def decode_password(self, credentials):
1412
"""See CredentialStore.decode_password."""
1413
return credentials['password']
1416
credential_store_registry.register('plain', PlainTextCredentialStore,
1417
help=PlainTextCredentialStore.__doc__)
1418
credential_store_registry.default_key = 'plain'
1421
class BzrDirConfig(object):
1423
def __init__(self, bzrdir):
1424
self._bzrdir = bzrdir
1425
self._config = bzrdir._get_config()
1427
def set_default_stack_on(self, value):
1428
"""Set the default stacking location.
1430
It may be set to a location, or None.
1432
This policy affects all branches contained by this bzrdir, except for
1433
those under repositories.
1435
if self._config is None:
1436
raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
1438
self._config.set_option('', 'default_stack_on')
1440
self._config.set_option(value, 'default_stack_on')
1442
def get_default_stack_on(self):
1443
"""Return the default stacking location.
1445
This will either be a location, or None.
1447
This policy affects all branches contained by this bzrdir, except for
1448
those under repositories.
1450
if self._config is None:
1452
value = self._config.get_option('default_stack_on')
1458
class TransportConfig(object):
1459
"""A Config that reads/writes a config file on a Transport.
1461
It is a low-level object that considers config data to be name/value pairs
1462
that may be associated with a section. Assigning meaning to the these
1463
values is done at higher levels like TreeConfig.
1466
def __init__(self, transport, filename):
1467
self._transport = transport
1468
self._filename = filename
1470
def get_option(self, name, section=None, default=None):
1471
"""Return the value associated with a named option.
1473
:param name: The name of the value
1474
:param section: The section the option is in (if any)
1475
:param default: The value to return if the value is not set
1476
:return: The value or default value
1478
configobj = self._get_configobj()
1480
section_obj = configobj
1483
section_obj = configobj[section]
1486
return section_obj.get(name, default)
1488
def set_option(self, value, name, section=None):
1489
"""Set the value associated with a named option.
1491
:param value: The value to set
1492
:param name: The name of the value to set
1493
:param section: The section the option is in (if any)
1495
configobj = self._get_configobj()
1497
configobj[name] = value
1499
configobj.setdefault(section, {})[name] = value
1500
self._set_configobj(configobj)
1502
def _get_config_file(self):
1504
return StringIO(self._transport.get_bytes(self._filename))
1505
except errors.NoSuchFile:
1508
def _get_configobj(self):
1509
return ConfigObj(self._get_config_file(), encoding='utf-8')
1511
def _set_configobj(self, configobj):
1512
out_file = StringIO()
1513
configobj.write(out_file)
1515
self._transport.put_file(self._filename, out_file)
added
removed
bzrlib/config.py
