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()
873
812
return osutils.pathjoin(config_dir(), 'ignore')
877
"""Return the directory name to store crash files.
879
This doesn't implicitly create it.
881
On Windows it's in the config directory; elsewhere it's /var/crash
882
which may be monitored by apport. It can be overridden by
816
"""Calculate automatic user identification.
818
Returns (realname, email).
820
Only used when none is set in the environment or the id file.
822
This previously used the FQDN as the default domain, but that can
823
be very slow on machines where DNS is broken. So now we simply
885
828
if sys.platform == 'win32':
886
return osutils.pathjoin(config_dir(), 'Crash')
888
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
890
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
894
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
895
# Possibly this should be different on Windows?
896
e = os.environ.get('XDG_CACHE_DIR', None)
900
return os.path.expanduser('~/.cache')
829
name = win32utils.get_user_name_unicode()
831
raise errors.BzrError("Cannot autodetect user name.\n"
832
"Please, set your name with command like:\n"
833
'bzr whoami "Your Name <name@domain.com>"')
834
host = win32utils.get_host_name_unicode()
836
host = socket.gethostname()
837
return name, (name + '@' + host)
842
w = pwd.getpwuid(uid)
844
# we try utf-8 first, because on many variants (like Linux),
845
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
846
# false positives. (many users will have their user encoding set to
847
# latin-1, which cannot raise UnicodeError.)
849
gecos = w.pw_gecos.decode('utf-8')
853
encoding = osutils.get_user_encoding()
854
gecos = w.pw_gecos.decode(encoding)
856
raise errors.BzrCommandError('Unable to determine your name. '
857
'Use "bzr whoami" to set it.')
859
username = w.pw_name.decode(encoding)
861
raise errors.BzrCommandError('Unable to determine your name. '
862
'Use "bzr whoami" to set it.')
864
comma = gecos.find(',')
868
realname = gecos[:comma]
875
user_encoding = osutils.get_user_encoding()
876
realname = username = getpass.getuser().decode(user_encoding)
877
except UnicodeDecodeError:
878
raise errors.BzrError("Can't decode username as %s." % \
881
return realname, (username + '@' + socket.gethostname())
903
884
def parse_username(username):
1020
1000
:param user: login (optional)
1022
1002
:param path: the absolute path on the server (optional)
1024
:param realm: the http authentication realm (optional)
1026
1004
:return: A dict containing the matching credentials or None.
1028
1006
- name: the section name of the credentials in the
1029
1007
authentication.conf file,
1030
- user: can't be different from the provided user if any,
1031
- scheme: the server protocol,
1032
- host: the server address,
1033
- port: the server port (can be None),
1034
- path: the absolute server path (can be None),
1035
- realm: the http specific authentication realm (can be None),
1008
- user: can't de different from the provided user if any,
1036
1009
- password: the decoded password, could be None if the credential
1037
1010
defines only the user
1038
1011
- verify_certificates: https specific, True if the server
1079
1052
if a_user is None:
1080
1053
# Can't find a user
1082
# Prepare a credentials dictionary with additional keys
1083
# for the credential providers
1084
1055
credentials = dict(name=auth_def_name,
1091
1057
password=auth_def.get('password', None),
1092
1058
verify_certificates=a_verify_certificates)
1093
# Decode the password in the credentials (or get one)
1094
1059
self.decode_password(credentials,
1095
1060
auth_def.get('password_encoding', None))
1096
1061
if 'auth' in debug.debug_flags:
1097
1062
trace.mutter("Using authentication section: %r", auth_def_name)
1100
if credentials is None:
1101
# No credentials were found in authentication.conf, try the fallback
1102
# credentials stores.
1103
credentials = credential_store_registry.get_fallback_credentials(
1104
scheme, host, port, user, path, realm)
1106
1065
return credentials
1108
1067
def set_credentials(self, name, host, user, scheme=None, password=None,
1109
port=None, path=None, verify_certificates=None,
1068
port=None, path=None, verify_certificates=None):
1111
1069
"""Set authentication credentials for a host.
1113
1071
Any existing credentials with matching scheme, host, port and path
1236
1172
return password
1238
1174
def decode_password(self, credentials, encoding):
1240
cs = credential_store_registry.get_credential_store(encoding)
1242
raise ValueError('%r is not a known password_encoding' % encoding)
1243
credentials['password'] = cs.decode_password(credentials)
1247
class CredentialStoreRegistry(registry.Registry):
1248
"""A class that registers credential stores.
1250
A credential store provides access to credentials via the password_encoding
1251
field in authentication.conf sections.
1253
Except for stores provided by bzr itself, most stores are expected to be
1254
provided by plugins that will therefore use
1255
register_lazy(password_encoding, module_name, member_name, help=help,
1256
fallback=fallback) to install themselves.
1258
A fallback credential store is one that is queried if no credentials can be
1259
found via authentication.conf.
1262
def get_credential_store(self, encoding=None):
1263
cs = self.get(encoding)
1268
def is_fallback(self, name):
1269
"""Check if the named credentials store should be used as fallback."""
1270
return self.get_info(name)
1272
def get_fallback_credentials(self, scheme, host, port=None, user=None,
1273
path=None, realm=None):
1274
"""Request credentials from all fallback credentials stores.
1276
The first credentials store that can provide credentials wins.
1279
for name in self.keys():
1280
if not self.is_fallback(name):
1282
cs = self.get_credential_store(name)
1283
credentials = cs.get_credentials(scheme, host, port, user,
1285
if credentials is not None:
1286
# We found some credentials
1290
def register(self, key, obj, help=None, override_existing=False,
1292
"""Register a new object to a name.
1294
:param key: This is the key to use to request the object later.
1295
:param obj: The object to register.
1296
:param help: Help text for this entry. This may be a string or
1297
a callable. If it is a callable, it should take two
1298
parameters (registry, key): this registry and the key that
1299
the help was registered under.
1300
:param override_existing: Raise KeyErorr if False and something has
1301
already been registered for that key. If True, ignore if there
1302
is an existing key (always register the new value).
1303
:param fallback: Whether this credential store should be
1306
return super(CredentialStoreRegistry,
1307
self).register(key, obj, help, info=fallback,
1308
override_existing=override_existing)
1310
def register_lazy(self, key, module_name, member_name,
1311
help=None, override_existing=False,
1313
"""Register a new credential store to be loaded on request.
1315
:param module_name: The python path to the module. Such as 'os.path'.
1316
:param member_name: The member of the module to return. If empty or
1317
None, get() will return the module itself.
1318
:param help: Help text for this entry. This may be a string or
1320
:param override_existing: If True, replace the existing object
1321
with the new one. If False, if there is already something
1322
registered with the same key, raise a KeyError
1323
:param fallback: Whether this credential store should be
1326
return super(CredentialStoreRegistry, self).register_lazy(
1327
key, module_name, member_name, help,
1328
info=fallback, override_existing=override_existing)
1331
credential_store_registry = CredentialStoreRegistry()
1334
class CredentialStore(object):
1335
"""An abstract class to implement storage for credentials"""
1337
def decode_password(self, credentials):
1338
"""Returns a clear text password for the provided credentials."""
1339
raise NotImplementedError(self.decode_password)
1341
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1343
"""Return the matching credentials from this credential store.
1345
This method is only called on fallback credential stores.
1347
raise NotImplementedError(self.get_credentials)
1351
class PlainTextCredentialStore(CredentialStore):
1352
__doc__ = """Plain text credential store for the authentication.conf file"""
1354
def decode_password(self, credentials):
1355
"""See CredentialStore.decode_password."""
1356
return credentials['password']
1359
credential_store_registry.register('plain', PlainTextCredentialStore,
1360
help=PlainTextCredentialStore.__doc__)
1361
credential_store_registry.default_key = 'plain'
1364
1178
class BzrDirConfig(object):
1366
def __init__(self, bzrdir):
1367
self._bzrdir = bzrdir
1368
self._config = bzrdir._get_config()
1180
def __init__(self, transport):
1181
self._config = TransportConfig(transport, 'control.conf')
1370
1183
def set_default_stack_on(self, value):
1371
1184
"""Set the default stacking location.
added
removed
bzrlib/config.py
