186
173
"""Get a generic option - no special process, no default."""
187
174
return self._get_user_option(option_name)
189
def get_user_option_as_bool(self, option_name):
190
"""Get a generic option as a boolean - no special process, no default.
192
:return None if the option doesn't exist or its value can't be
193
interpreted as a boolean. Returns True or False otherwise.
195
s = self._get_user_option(option_name)
197
# The option doesn't exist
199
val = ui.bool_from_string(s)
201
# The value can't be interpreted as a boolean
202
trace.warning('Value "%s" is not a boolean for "%s"',
206
def get_user_option_as_list(self, option_name):
207
"""Get a generic option as a list - no special process, no default.
209
:return None if the option doesn't exist. Returns the value as a list
212
l = self._get_user_option(option_name)
213
if isinstance(l, (str, unicode)):
214
# A single value, most probably the user forgot the final ','
218
176
def gpg_signing_command(self):
219
177
"""What program should be used to sign signatures?"""
220
178
result = self._gpg_signing_command()
1088
1004
:param user: login (optional)
1090
1006
:param path: the absolute path on the server (optional)
1092
:param realm: the http authentication realm (optional)
1094
1008
:return: A dict containing the matching credentials or None.
1096
1010
- name: the section name of the credentials in the
1097
1011
authentication.conf file,
1098
- user: can't be different from the provided user if any,
1099
- scheme: the server protocol,
1100
- host: the server address,
1101
- port: the server port (can be None),
1102
- path: the absolute server path (can be None),
1103
- realm: the http specific authentication realm (can be None),
1012
- user: can't de different from the provided user if any,
1104
1013
- password: the decoded password, could be None if the credential
1105
1014
defines only the user
1106
1015
- verify_certificates: https specific, True if the server
1147
1056
if a_user is None:
1148
1057
# Can't find a user
1150
# Prepare a credentials dictionary with additional keys
1151
# for the credential providers
1152
1059
credentials = dict(name=auth_def_name,
1159
1061
password=auth_def.get('password', None),
1160
1062
verify_certificates=a_verify_certificates)
1161
# Decode the password in the credentials (or get one)
1162
1063
self.decode_password(credentials,
1163
1064
auth_def.get('password_encoding', None))
1164
1065
if 'auth' in debug.debug_flags:
1165
1066
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
1069
return credentials
1176
1071
def set_credentials(self, name, host, user, scheme=None, password=None,
1177
port=None, path=None, verify_certificates=None,
1072
port=None, path=None, verify_certificates=None):
1179
1073
"""Set authentication credentials for a host.
1181
1075
Any existing credentials with matching scheme, host, port and path
1304
1176
return password
1306
1178
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
1182
class BzrDirConfig(object):
1434
def __init__(self, bzrdir):
1435
self._bzrdir = bzrdir
1436
self._config = bzrdir._get_config()
1184
def __init__(self, transport):
1185
self._config = TransportConfig(transport, 'control.conf')
1438
1187
def set_default_stack_on(self, value):
1439
1188
"""Set the default stacking location.
added
removed
bzrlib/config.py
