← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-02-01 20:24:03 UTC
  • mfrom: (1551.10.4 Aaron's mergeable stuff)
  • Revision ID: pqm@pqm.ubuntu.com-20070201202403-7e92ef4d6842ba85
Treat Permission Denied as a lock failure, not lock contention

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
37
37
    lockable_files,
38
38
    lockdir,
39
39
    osutils,
 
40
    registry,
40
41
    revision as _mod_revision,
41
42
    symbol_versioning,
42
43
    transactions,
97
98
 
98
99
        returns the sha1 of the serialized inventory.
99
100
        """
 
101
        _mod_revision.check_not_reserved_id(revid)
100
102
        assert inv.revision_id is None or inv.revision_id == revid, \
101
103
            "Mismatch between inventory revision" \
102
104
            " id and insertion revid (%r, %r)" % (inv.revision_id, revid)
128
130
                       If supplied its signature_needed method will be used
129
131
                       to determine if a signature should be made.
130
132
        """
 
133
        _mod_revision.check_not_reserved_id(rev_id)
131
134
        if config is not None and config.signature_needed():
132
135
            if inv is None:
133
136
                inv = self.get_inventory(rev_id)
1133
1136
                                 committer, revprops, revision_id)
1134
1137
 
1135
1138
 
 
1139
class RepositoryFormatRegistry(registry.Registry):
 
1140
    """Registry of RepositoryFormats.
 
1141
    """
 
1142
    
 
1143
 
 
1144
format_registry = RepositoryFormatRegistry()
 
1145
"""Registry of formats, indexed by their identifying format string."""
 
1146
 
 
1147
 
1136
1148
class RepositoryFormat(object):
1137
1149
    """A repository format.
1138
1150
 
1157
1169
    parameterisation.
1158
1170
    """
1159
1171
 
1160
 
    _default_format = None
1161
 
    """The default format used for new repositories."""
1162
 
 
1163
 
    _formats = {}
1164
 
    """The known formats."""
1165
 
 
1166
1172
    def __str__(self):
1167
1173
        return "<%s>" % self.__class__.__name__
1168
1174
 
1169
1175
    @classmethod
1170
1176
    def find_format(klass, a_bzrdir):
1171
 
        """Return the format for the repository object in a_bzrdir."""
 
1177
        """Return the format for the repository object in a_bzrdir.
 
1178
        
 
1179
        This is used by bzr native formats that have a "format" file in
 
1180
        the repository.  Other methods may be used by different types of 
 
1181
        control directory.
 
1182
        """
1172
1183
        try:
1173
1184
            transport = a_bzrdir.get_repository_transport(None)
1174
1185
            format_string = transport.get("format").read()
1175
 
            return klass._formats[format_string]
 
1186
            return format_registry.get(format_string)
1176
1187
        except errors.NoSuchFile:
1177
1188
            raise errors.NoRepositoryPresent(a_bzrdir)
1178
1189
        except KeyError:
1179
1190
            raise errors.UnknownFormatError(format=format_string)
1180
1191
 
1181
 
    def _get_control_store(self, repo_transport, control_files):
1182
 
        """Return the control store for this repository."""
1183
 
        raise NotImplementedError(self._get_control_store)
 
1192
    @classmethod
 
1193
    @deprecated_method(symbol_versioning.zero_fourteen)
 
1194
    def set_default_format(klass, format):
 
1195
        klass._set_default_format(format)
 
1196
 
 
1197
    @classmethod
 
1198
    def _set_default_format(klass, format):
 
1199
        """Set the default format for new Repository creation.
 
1200
 
 
1201
        The format must already be registered.
 
1202
        """
 
1203
        format_registry.default_key = format.get_format_string()
 
1204
 
 
1205
    @classmethod
 
1206
    def register_format(klass, format):
 
1207
        format_registry.register(format.get_format_string(), format)
 
1208
 
 
1209
    @classmethod
 
1210
    def unregister_format(klass, format):
 
1211
        format_registry.remove(format.get_format_string())
1184
1212
    
1185
1213
    @classmethod
1186
1214
    def get_default_format(klass):
1187
1215
        """Return the current default format."""
1188
 
        return klass._default_format
 
1216
        return format_registry.get(format_registry.default_key)
 
1217
 
 
1218
    def _get_control_store(self, repo_transport, control_files):
 
1219
        """Return the control store for this repository."""
 
1220
        raise NotImplementedError(self._get_control_store)
1189
1221
 
1190
1222
    def get_format_string(self):
1191
1223
        """Return the ASCII format string that identifies this format.
1273
1305
        """
1274
1306
        raise NotImplementedError(self.open)
1275
1307
 
1276
 
    @classmethod
1277
 
    def register_format(klass, format):
1278
 
        klass._formats[format.get_format_string()] = format
1279
 
 
1280
 
    @classmethod
1281
 
    def set_default_format(klass, format):
1282
 
        klass._default_format = format
1283
 
 
1284
 
    @classmethod
1285
 
    def unregister_format(klass, format):
1286
 
        assert klass._formats[format.get_format_string()] is format
1287
 
        del klass._formats[format.get_format_string()]
1288
 
 
1289
1308
 
1290
1309
class PreSplitOutRepositoryFormat(RepositoryFormat):
1291
1310
    """Base class for the pre split out repository formats."""
1800
1819
# formats which have no format string are not discoverable
1801
1820
# and not independently creatable, so are not registered.
1802
1821
RepositoryFormat.register_format(RepositoryFormat7())
1803
 
# KEEP in sync with bzrdir.format_registry default
 
1822
# KEEP in sync with bzrdir.format_registry default, which controls the overall
 
1823
# default control directory format
1804
1824
_default_format = RepositoryFormatKnit1()
1805
1825
RepositoryFormat.register_format(_default_format)
1806
1826
RepositoryFormat.register_format(RepositoryFormatKnit2())
1807
 
RepositoryFormat.set_default_format(_default_format)
 
1827
RepositoryFormat._set_default_format(_default_format)
1808
1828
_legacy_formats = [RepositoryFormat4(),
1809
1829
                   RepositoryFormat5(),
1810
1830
                   RepositoryFormat6()]