← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: John Arbash Meinel
  • Date: 2009-03-27 22:29:55 UTC
  • mto: (3735.39.2 clean)
  • mto: This revision was merged to the branch mainline in revision 4280.
  • Revision ID: john@arbash-meinel.com-20090327222955-utifmfm888zerixt
Implement apply_delta_to_source which doesn't have to malloc another string.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
709
709
                        trace.warning('Value "%s" is masked by "%s" from'
710
710
                                      ' branch.conf', value, mask_value)
711
711
 
 
712
 
712
713
    def _gpg_signing_command(self):
713
714
        """See Config.gpg_signing_command."""
714
715
        return self._get_safe_value('_gpg_signing_command')
916
917
    # XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
917
918
 
918
919
    def __init__(self, branch):
919
 
        self._config = branch._get_config()
 
920
        # XXX: Really this should be asking the branch for its configuration
 
921
        # data, rather than relying on a Transport, so that it can work
 
922
        # more cleanly with a RemoteBranch that has no transport.
 
923
        self._config = TransportConfig(branch._transport, 'branch.conf')
920
924
        self.branch = branch
921
925
 
922
926
    def _get_parser(self, file=None):
1079
1083
                trace.mutter("Using authentication section: %r", auth_def_name)
1080
1084
            break
1081
1085
 
1082
 
        if credentials is None:
1083
 
            # No credentials were found in authentication.conf, try the fallback
1084
 
            # credentials stores.
1085
 
            credentials = credential_store_registry.get_fallback_credentials(
1086
 
                scheme, host, port, user, path, realm)
1087
 
 
1088
1086
        return credentials
1089
1087
 
1090
1088
    def set_credentials(self, name, host, user, scheme=None, password=None,
1132
1130
        config.update({name: values})
1133
1131
        self._save()
1134
1132
 
1135
 
    def get_user(self, scheme, host, port=None, realm=None, path=None,
1136
 
                 prompt=None, ask=False, default=None):
 
1133
    def get_user(self, scheme, host, port=None,
 
1134
                 realm=None, path=None, prompt=None):
1137
1135
        """Get a user from authentication file.
1138
1136
 
1139
1137
        :param scheme: protocol
1146
1144
 
1147
1145
        :param path: the absolute path on the server (optional)
1148
1146
 
1149
 
        :param ask: Ask the user if there is no explicitly configured username 
1150
 
                    (optional)
1151
 
 
1152
 
        :param default: The username returned if none is defined (optional).
1153
 
 
1154
1147
        :return: The found user.
1155
1148
        """
1156
1149
        credentials = self.get_credentials(scheme, host, port, user=None,
1159
1152
            user = credentials['user']
1160
1153
        else:
1161
1154
            user = None
1162
 
        if user is None:
1163
 
            if ask:
1164
 
                if prompt is None:
1165
 
                    # Create a default prompt suitable for most cases
1166
 
                    prompt = scheme.upper() + ' %(host)s username'
1167
 
                # Special handling for optional fields in the prompt
1168
 
                if port is not None:
1169
 
                    prompt_host = '%s:%d' % (host, port)
1170
 
                else:
1171
 
                    prompt_host = host
1172
 
                user = ui.ui_factory.get_username(prompt, host=prompt_host)
1173
 
            else:
1174
 
                user = default
1175
1155
        return user
1176
1156
 
1177
1157
    def get_password(self, scheme, host, user, port=None,
1232
1212
    A credential store provides access to credentials via the password_encoding
1233
1213
    field in authentication.conf sections.
1234
1214
 
1235
 
    Except for stores provided by bzr itself, most stores are expected to be
 
1215
    Except for stores provided by bzr itself,most stores are expected to be
1236
1216
    provided by plugins that will therefore use
1237
1217
    register_lazy(password_encoding, module_name, member_name, help=help,
1238
 
    fallback=fallback) to install themselves.
1239
 
 
1240
 
    A fallback credential store is one that is queried if no credentials can be
1241
 
    found via authentication.conf.
 
1218
    info=info) to install themselves.
1242
1219
    """
1243
1220
 
1244
1221
    def get_credential_store(self, encoding=None):
1247
1224
            cs = cs()
1248
1225
        return cs
1249
1226
 
1250
 
    def is_fallback(self, name):
1251
 
        """Check if the named credentials store should be used as fallback."""
1252
 
        return self.get_info(name)
1253
 
 
1254
 
    def get_fallback_credentials(self, scheme, host, port=None, user=None,
1255
 
                                 path=None, realm=None):
1256
 
        """Request credentials from all fallback credentials stores.
1257
 
 
1258
 
        The first credentials store that can provide credentials wins.
1259
 
        """
1260
 
        credentials = None
1261
 
        for name in self.keys():
1262
 
            if not self.is_fallback(name):
1263
 
                continue
1264
 
            cs = self.get_credential_store(name)
1265
 
            credentials = cs.get_credentials(scheme, host, port, user,
1266
 
                                             path, realm)
1267
 
            if credentials is not None:
1268
 
                # We found some credentials
1269
 
                break
1270
 
        return credentials
1271
 
 
1272
 
    def register(self, key, obj, help=None, override_existing=False,
1273
 
                 fallback=False):
1274
 
        """Register a new object to a name.
1275
 
 
1276
 
        :param key: This is the key to use to request the object later.
1277
 
        :param obj: The object to register.
1278
 
        :param help: Help text for this entry. This may be a string or
1279
 
                a callable. If it is a callable, it should take two
1280
 
                parameters (registry, key): this registry and the key that
1281
 
                the help was registered under.
1282
 
        :param override_existing: Raise KeyErorr if False and something has
1283
 
                already been registered for that key. If True, ignore if there
1284
 
                is an existing key (always register the new value).
1285
 
        :param fallback: Whether this credential store should be 
1286
 
                used as fallback.
1287
 
        """
1288
 
        return super(CredentialStoreRegistry,
1289
 
                     self).register(key, obj, help, info=fallback,
1290
 
                                    override_existing=override_existing)
1291
 
 
1292
 
    def register_lazy(self, key, module_name, member_name,
1293
 
                      help=None, override_existing=False,
1294
 
                      fallback=False):
1295
 
        """Register a new credential store to be loaded on request.
1296
 
 
1297
 
        :param module_name: The python path to the module. Such as 'os.path'.
1298
 
        :param member_name: The member of the module to return.  If empty or
1299
 
                None, get() will return the module itself.
1300
 
        :param help: Help text for this entry. This may be a string or
1301
 
                a callable.
1302
 
        :param override_existing: If True, replace the existing object
1303
 
                with the new one. If False, if there is already something
1304
 
                registered with the same key, raise a KeyError
1305
 
        :param fallback: Whether this credential store should be 
1306
 
                used as fallback.
1307
 
        """
1308
 
        return super(CredentialStoreRegistry, self).register_lazy(
1309
 
            key, module_name, member_name, help,
1310
 
            info=fallback, override_existing=override_existing)
1311
 
 
1312
1227
 
1313
1228
credential_store_registry = CredentialStoreRegistry()
1314
1229
 
1317
1232
    """An abstract class to implement storage for credentials"""
1318
1233
 
1319
1234
    def decode_password(self, credentials):
1320
 
        """Returns a clear text password for the provided credentials."""
 
1235
        """Returns a password for the provided credentials in clear text."""
1321
1236
        raise NotImplementedError(self.decode_password)
1322
1237
 
1323
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None,
1324
 
                        realm=None):
1325
 
        """Return the matching credentials from this credential store.
1326
 
 
1327
 
        This method is only called on fallback credential stores.
1328
 
        """
1329
 
        raise NotImplementedError(self.get_credentials)
1330
 
 
1331
 
 
1332
1238
 
1333
1239
class PlainTextCredentialStore(CredentialStore):
1334
1240
    """Plain text credential store for the authentication.conf file."""
1345
1251
 
1346
1252
class BzrDirConfig(object):
1347
1253
 
1348
 
    def __init__(self, bzrdir):
1349
 
        self._bzrdir = bzrdir
1350
 
        self._config = bzrdir._get_config()
 
1254
    def __init__(self, transport):
 
1255
        self._config = TransportConfig(transport, 'control.conf')
1351
1256
 
1352
1257
    def set_default_stack_on(self, value):
1353
1258
        """Set the default stacking location.
1357
1262
        This policy affects all branches contained by this bzrdir, except for
1358
1263
        those under repositories.
1359
1264
        """
1360
 
        if self._config is None:
1361
 
            raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
1362
1265
        if value is None:
1363
1266
            self._config.set_option('', 'default_stack_on')
1364
1267
        else:
1372
1275
        This policy affects all branches contained by this bzrdir, except for
1373
1276
        those under repositories.
1374
1277
        """
1375
 
        if self._config is None:
1376
 
            return None
1377
1278
        value = self._config.get_option('default_stack_on')
1378
1279
        if value == '':
1379
1280
            value = None
1424
1325
            configobj.setdefault(section, {})[name] = value
1425
1326
        self._set_configobj(configobj)
1426
1327
 
1427
 
    def _get_config_file(self):
 
1328
    def _get_configobj(self):
1428
1329
        try:
1429
 
            return self._transport.get(self._filename)
 
1330
            return ConfigObj(self._transport.get(self._filename),
 
1331
                             encoding='utf-8')
1430
1332
        except errors.NoSuchFile:
1431
 
            return StringIO()
1432
 
 
1433
 
    def _get_configobj(self):
1434
 
        return ConfigObj(self._get_config_file(), encoding='utf-8')
 
1333
            return ConfigObj(encoding='utf-8')
1435
1334
 
1436
1335
    def _set_configobj(self, configobj):
1437
1336
        out_file = StringIO()