15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
19
"""Configuration that affects the behaviour of Bazaar.
45
45
editor - this option sets the pop up editor to use during commits.
46
46
email - this option sets the user id bzr will use when committing.
47
47
check_signatures - this option controls whether bzr will require good gpg
48
signatures, ignore them, or check them if they are
48
signatures, ignore them, or check them if they are
50
create_signatures - this option controls whether bzr will always create
50
create_signatures - this option controls whether bzr will always create
51
51
gpg signatures, never create them, or create them if the
52
52
branch is configured to require them.
53
53
log_format - this option sets the default log format. Possible values are
146
146
class Config(object):
147
147
"""A configuration policy - what username, editor, gpg needs etc."""
150
super(Config, self).__init__()
152
149
def get_editor(self):
153
150
"""Get the users pop up editor."""
154
151
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
153
def get_mail_client(self):
166
154
"""Get a mail client to use"""
167
155
selected_client = self.get_user_option('mail_client')
186
174
"""Get a generic option - no special process, no default."""
187
175
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
177
def gpg_signing_command(self):
219
178
"""What program should be used to sign signatures?"""
220
179
result = self._gpg_signing_command()
336
def suppress_warning(self, warning):
337
"""Should the warning be suppressed or emitted.
339
:param warning: The name of the warning being tested.
341
:returns: True if the warning should be suppressed, False otherwise.
343
warnings = self.get_user_option_as_list('suppress_warnings')
344
if warnings is None or warning not in warnings:
350
299
class IniBasedConfig(Config):
351
300
"""A configuration policy that draws from ini files."""
353
def __init__(self, get_filename):
354
super(IniBasedConfig, self).__init__()
355
self._get_filename = get_filename
358
302
def _get_parser(self, file=None):
359
303
if self._parser is not None:
360
304
return self._parser
768
709
trace.warning('Value "%s" is masked by "%s" from'
769
710
' branch.conf', value, mask_value)
771
713
def _gpg_signing_command(self):
772
714
"""See Config.gpg_signing_command."""
773
715
return self._get_safe_value('_gpg_signing_command')
775
717
def __init__(self, branch):
776
718
super(BranchConfig, self).__init__()
777
719
self._location_config = None
778
720
self._branch_data_config = None
779
721
self._global_config = None
780
722
self.branch = branch
781
self.option_sources = (self._get_location_config,
723
self.option_sources = (self._get_location_config,
782
724
self._get_branch_data_config,
783
725
self._get_global_config)
872
813
return osutils.pathjoin(config_dir(), 'ignore')
876
"""Return the directory name to store crash files.
878
This doesn't implicitly create it.
880
On Windows it's in the config directory; elsewhere it's /var/crash
881
which may be monitored by apport. It can be overridden by
884
if sys.platform == 'win32':
885
return osutils.pathjoin(config_dir(), 'Crash')
887
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
889
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
893
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
894
# Possibly this should be different on Windows?
895
e = os.environ.get('XDG_CACHE_DIR', None)
899
return os.path.expanduser('~/.cache')
902
816
def _auto_user_id():
903
817
"""Calculate automatic user identification.
1003
913
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1005
915
def __init__(self, branch):
1006
self._config = branch._get_config()
916
# XXX: Really this should be asking the branch for its configuration
917
# data, rather than relying on a Transport, so that it can work
918
# more cleanly with a RemoteBranch that has no transport.
919
self._config = TransportConfig(branch._transport, 'branch.conf')
1007
920
self.branch = branch
1009
922
def _get_parser(self, file=None):
1088
1001
:param user: login (optional)
1090
1003
:param path: the absolute path on the server (optional)
1092
:param realm: the http authentication realm (optional)
1094
1005
:return: A dict containing the matching credentials or None.
1096
1007
- name: the section name of the credentials in the
1097
1008
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),
1009
- user: can't de different from the provided user if any,
1104
1010
- password: the decoded password, could be None if the credential
1105
1011
defines only the user
1106
1012
- verify_certificates: https specific, True if the server
1147
1053
if a_user is None:
1148
1054
# Can't find a user
1150
# Prepare a credentials dictionary with additional keys
1151
# for the credential providers
1152
1056
credentials = dict(name=auth_def_name,
1159
1058
password=auth_def.get('password', None),
1160
1059
verify_certificates=a_verify_certificates)
1161
# Decode the password in the credentials (or get one)
1162
1060
self.decode_password(credentials,
1163
1061
auth_def.get('password_encoding', None))
1164
1062
if 'auth' in debug.debug_flags:
1165
1063
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
1066
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):
1068
def get_user(self, scheme, host, port=None,
1069
realm=None, path=None, prompt=None):
1223
1070
"""Get a user from authentication file.
1225
1072
:param scheme: protocol
1233
1080
:param path: the absolute path on the server (optional)
1235
:param ask: Ask the user if there is no explicitly configured username
1238
:param default: The username returned if none is defined (optional).
1240
1082
:return: The found user.
1242
1084
credentials = self.get_credentials(scheme, host, port, user=None,
1243
path=path, realm=realm)
1244
1086
if credentials is not None:
1245
1087
user = credentials['user']
1251
# Create a default prompt suitable for most cases
1252
prompt = scheme.upper() + ' %(host)s username'
1253
# Special handling for optional fields in the prompt
1254
if port is not None:
1255
prompt_host = '%s:%d' % (host, port)
1258
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1263
1092
def get_password(self, scheme, host, user, port=None,
1279
1108
:return: The found password or the one entered by the user.
1281
credentials = self.get_credentials(scheme, host, port, user, path,
1110
credentials = self.get_credentials(scheme, host, port, user, path)
1283
1111
if credentials is not None:
1284
1112
password = credentials['password']
1285
1113
if password is not None and scheme is 'ssh':
1318
1146
A credential store provides access to credentials via the password_encoding
1319
1147
field in authentication.conf sections.
1321
Except for stores provided by bzr itself, most stores are expected to be
1149
Except for stores provided by bzr itself,most stores are expected to be
1322
1150
provided by plugins that will therefore use
1323
1151
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.
1152
info=info) to install themselves.
1330
1155
def get_credential_store(self, encoding=None):
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
1162
credential_store_registry = CredentialStoreRegistry()
1403
1166
"""An abstract class to implement storage for credentials"""
1405
1168
def decode_password(self, credentials):
1406
"""Returns a clear text password for the provided credentials."""
1169
"""Returns a password for the provided credentials in clear text."""
1407
1170
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
1173
class PlainTextCredentialStore(CredentialStore):
1420
__doc__ = """Plain text credential store for the authentication.conf file"""
1174
"""Plain text credential store for the authentication.conf file."""
1422
1176
def decode_password(self, credentials):
1423
1177
"""See CredentialStore.decode_password."""
1510
1259
configobj.setdefault(section, {})[name] = value
1511
1260
self._set_configobj(configobj)
1513
def _get_config_file(self):
1262
def _get_configobj(self):
1515
return StringIO(self._transport.get_bytes(self._filename))
1264
return ConfigObj(self._transport.get(self._filename),
1516
1266
except errors.NoSuchFile:
1519
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
1267
return ConfigObj(encoding='utf-8')
1522
1269
def _set_configobj(self, configobj):
1523
1270
out_file = StringIO()
added
removed
bzrlib/config.py
