« back to all changes in this revision
Viewing changes to bzrlib/bzrdir.py
- browse files at revision 6404
- compare with another revision
- compare with revision 6453
- download diff
- download tarball
- view history from revision 6404
- Committer: Patch Queue Manager
- Date: 2011-12-22 18:52:58 UTC
- mfrom: (6213.1.55 feature-flags)
- Revision ID: pqm@pqm.ubuntu.com-20111222185258-wgcba8590pbw5sf1
(jelmer) Add support for feature flags in bzr formats. (Jelmer Vernooij)
- files modified:
- bzrlib/branch.py
added
removed
bzrlib/bzrdir.py
1102
1102
return self.transport.clone(path)
1103
1103
1104
1104
1105
class BzrDirMetaComponentFormat(controldir.ControlComponentFormat):
1105
class BzrFormat(object):
1106
1106
"""Base class for all formats of things living in metadirs.
1107
1107
1108
1108
This class manages the format string that is stored in the 'format'
1113
1113
(i.e. different from .bzr/branch-format) derive from this class,
1114
1114
as well as the relevant base class for their kind
1115
1115
(BranchFormat, WorkingTreeFormat, RepositoryFormat).
1116
1117
Each format is identified by a "format" or "branch-format" file with a
1118
single line containing the base format name and then an optional list of
1119
feature flags.
1120
1121
Feature flags are supported as of bzr 2.5. Setting feature flags on formats
1122
will render them inaccessible to older versions of bzr.
1123
1124
:ivar features: Dictionary mapping feature names to their necessity
1116
1125
"""
1117
1126
1127
_present_features = set()
1128
1129
def __init__(self):
1130
self.features = {}
1131
1132
@classmethod
1133
def register_feature(cls, name):
1134
"""Register a feature as being present.
1135
1136
:param name: Name of the feature
1137
"""
1138
if " " in name:
1139
raise ValueError("spaces are not allowed in feature names")
1140
if name in cls._present_features:
1141
raise errors.FeatureAlreadyRegistered(name)
1142
cls._present_features.add(name)
1143
1144
@classmethod
1145
def unregister_feature(cls, name):
1146
"""Unregister a feature."""
1147
cls._present_features.remove(name)
1148
1149
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1150
basedir=None):
1151
for name, necessity in self.features.iteritems():
1152
if name in self._present_features:
1153
continue
1154
if necessity == "optional":
1155
mutter("ignoring optional missing feature %s", name)
1156
continue
1157
elif necessity == "required":
1158
raise errors.MissingFeature(name)
1159
else:
1160
mutter("treating unknown necessity as require for %s",
1161
name)
1162
raise errors.MissingFeature(name)
1163
1118
1164
@classmethod
1119
1165
def get_format_string(cls):
1120
1166
"""Return the ASCII format string that identifies this format."""
1121
1167
raise NotImplementedError(cls.get_format_string)
1122
1168
1123
1169
@classmethod
1124
def from_string(cls, format_string):
1125
if format_string != cls.get_format_string():
1126
raise ValueError("Invalid format header %r" % format_string)
1127
return cls()
1170
def from_string(cls, text):
1171
format_string = cls.get_format_string()
1172
if not text.startswith(format_string):
1173
raise AssertionError("Invalid format header %r for %r" % (text, cls))
1174
lines = text[len(format_string):].splitlines()
1175
ret = cls()
1176
for lineno, line in enumerate(lines):
1177
try:
1178
(necessity, feature) = line.split(" ", 1)
1179
except ValueError:
1180
raise errors.ParseFormatError(format=cls, lineno=lineno+2,
1181
line=line, text=text)
1182
ret.features[feature] = necessity
1183
return ret
1184
1185
def as_string(self):
1186
"""Return the string representation of this format.
1187
"""
1188
lines = [self.get_format_string()]
1189
lines.extend([("%s %s\n" % (item[1], item[0])) for item in
1190
self.features.iteritems()])
1191
return "".join(lines)
1128
1192
1129
1193
@classmethod
1130
1194
def _find_format(klass, registry, kind, format_string):
1131
1195
try:
1132
cls = registry.get(format_string)
1196
first_line = format_string[:format_string.index("\n")+1]
1197
except ValueError:
1198
first_line = format_string
1199
try:
1200
cls = registry.get(first_line)
1133
1201
except KeyError:
1134
raise errors.UnknownFormatError(format=format_string, kind=kind)
1135
return cls
1202
raise errors.UnknownFormatError(format=first_line, kind=kind)
1203
return cls.from_string(format_string)
1136
1204
1137
1205
def network_name(self):
1138
1206
"""A simple byte string uniquely identifying this format for RPC calls.
1139
1207
1140
1208
Metadir branch formats use their format string.
1141
1209
"""
1142
return self.get_format_string()
1210
return self.as_string()
1143
1211
1144
1212
def __eq__(self, other):
1145
return (self.__class__ is other.__class__)
1213
return (self.__class__ is other.__class__ and
1214
self.features == other.features)
1146
1215
1147
1216
1148
1217
class BzrProber(controldir.Prober):
1169
1238
except errors.NoSuchFile:
1170
1239
raise errors.NotBranchError(path=transport.base)
1171
1240
try:
1172
cls = klass.formats.get(format_string)
1241
first_line = format_string[:format_string.index("\n")+1]
1242
except ValueError:
1243
first_line = format_string
1244
try:
1245
cls = klass.formats.get(first_line)
1173
1246
except KeyError:
1174
raise errors.UnknownFormatError(format=format_string, kind='bzrdir')
1247
raise errors.UnknownFormatError(format=first_line, kind='bzrdir')
1175
1248
return cls.from_string(format_string)
1176
1249
1177
1250
@classmethod
1221
1294
return set([RemoteBzrDirFormat()])
1222
1295
1223
1296
1224
class BzrDirFormat(controldir.ControlDirFormat):
1297
class BzrDirFormat(BzrFormat, controldir.ControlDirFormat):
1225
1298
"""ControlDirFormat base class for .bzr/ directories.
1226
1299
1227
1300
Formats are placed in a dict by their format string for reference
1238
1311
# _lock_class must be set in subclasses to the lock type, typ.
1239
1312
# TransportLock or LockDir
1240
1313
1241
@classmethod
1242
def get_format_string(cls):
1243
"""Return the ASCII format string that identifies this format."""
1244
raise NotImplementedError(cls.get_format_string)
1245
1246
1314
def initialize_on_transport(self, transport):
1247
1315
"""Initialize a new bzrdir in the base directory of a Transport."""
1248
1316
try:
1433
1501
compatible with whatever sub formats are supported by self.
1434
1502
:return: None.
1435
1503
"""
1504
other_format.features = dict(self.features)
1436
1505
1437
1506
def supports_transport(self, transport):
1438
1507
# bzr formats can be opened over all known transports
1439
1508
return True
1440
1509
1510
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
1511
basedir=None):
1512
controldir.ControlDirFormat.check_support_status(self,
1513
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
1514
basedir=basedir)
1515
BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
1516
recommend_upgrade=recommend_upgrade, basedir=basedir)
1517
1441
1518
1442
1519
class BzrDirMetaFormat1(BzrDirFormat):
1443
1520
"""Bzr meta control format 1
1459
1536
colocated_branches = False
1460
1537
1461
1538
def __init__(self):
1539
BzrDirFormat.__init__(self)
1462
1540
self._workingtree_format = None
1463
1541
self._branch_format = None
1464
1542
self._repository_format = None
1470
1548
return False
1471
1549
if other.workingtree_format != self.workingtree_format:
1472
1550
return False
1551
if other.features != self.features:
1552
return False
1473
1553
return True
1474
1554
1475
1555
def __ne__(self, other):
1601
1681
"""See BzrDirFormat.get_format_description()."""
1602
1682
return "Meta directory format 1"
1603
1683
1604
@classmethod
1605
def from_string(cls, format_string):
1606
if format_string != cls.get_format_string():
1607
raise ValueError("Invalid format string %r" % format_string)
1608
return cls()
1609
1610
def network_name(self):
1611
return self.get_format_string()
1612
1613
1684
def _open(self, transport):
1614
1685
"""See BzrDirFormat._open."""
1615
1686
# Create a new format instance because otherwise initialisation of new
1644
1715
compatible with whatever sub formats are supported by self.
1645
1716
:return: None.
1646
1717
"""
1718
super(BzrDirMetaFormat1, self)._supply_sub_formats_to(other_format)
1647
1719
if getattr(self, '_repository_format', None) is not None:
1648
1720
other_format.repository_format = self.repository_format
1649
1721
if self._branch_format is not None:
1919
1991
:return: A repository, is_new_flag (True if the repository was
1920
1992
created).
1921
1993
"""
1922
raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)
1994
raise NotImplementedError(RepositoryAcquisitionPolicy.acquire_repository)
1923
1995
1924
1996
1925
1997
class CreateRepository(RepositoryAcquisitionPolicy):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1