1
=== modified file 'NEWS'
2
--- NEWS	2009-08-13 12:51:59 +0000
3
+++ NEWS	2009-08-13 03:29:52 +0000
4
@@ -158,6 +158,10 @@
5
158
  lots of backtraces about ``UnknownSmartMethod``, ``do_chunk`` or
158
  lots of backtraces about ``UnknownSmartMethod``, ``do_chunk`` or
6
159
  ``do_end``.  (Andrew Bennetts, #338561)
159
  ``do_end``.  (Andrew Bennetts, #338561)
7
160
  
160
  
8
161
* ``RemoteStreamSource.get_stream_for_missing_keys`` will fetch CHK
9
162
  inventory pages when appropriate (by falling back to the vfs stream
10
163
  source).  (Andrew Bennetts, #406686)
11
164
12
161
* Streaming from bzr servers where there is a chain of stacked branches
165
* Streaming from bzr servers where there is a chain of stacked branches
13
162
  (A stacked on B stacked on C) will now work. (Robert Collins, #406597)
166
  (A stacked on B stacked on C) will now work. (Robert Collins, #406597)
14
163
167
15
@@ -249,8 +253,10 @@
16
249
* ``CHKMap.apply_delta`` now raises ``InconsistentDelta`` if a delta adds
253
* ``CHKMap.apply_delta`` now raises ``InconsistentDelta`` if a delta adds
17
250
  as new a key which was already mapped. (Robert Collins)
254
  as new a key which was already mapped. (Robert Collins)
18
251
255
21
252
* InterDifferingSerializer has been removed.  The transformations it
256
* InterDifferingSerializer is now only used locally.  Other fetches that
22
253
  provided are now done automatically by StreamSource.  (Andrew Bennetts)
257
  would have used InterDifferingSerializer now use the more network
23
258
  friendly StreamSource, which now automatically does the same
24
259
  transformations as InterDifferingSerializer.  (Andrew Bennetts)
25
254
260
26
255
* Inventory delta application catches more cases of corruption and can
261
* Inventory delta application catches more cases of corruption and can
27
256
  prevent corrupt deltas from affecting consistency of data structures on
262
  prevent corrupt deltas from affecting consistency of data structures on
28
257
263
29
=== modified file 'bzrlib/fetch.py'
30
--- bzrlib/fetch.py	2009-07-29 07:08:54 +0000
31
+++ bzrlib/fetch.py	2009-08-07 04:27:02 +0000
32
@@ -260,6 +260,19 @@
33
260
260
34
261
def _new_root_data_stream(
261
def _new_root_data_stream(
35
262
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
262
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
36
263
    """Generate a texts substream of synthesised root entries.
37
264
38
265
    Used in fetches that do rich-root upgrades.
39
266
    
40
267
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
41
268
        the root entries to create.
42
269
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
43
270
        calculating the parents.  If a parent rev_id is not found here then it
44
271
        will be recalculated.
45
272
    :param parent_map: a parent map for all the revisions in
46
273
        root_keys_to_create.
47
274
    :param graph: a graph to use instead of repo.get_graph().
48
275
    """
49
263
    for root_key in root_keys_to_create:
276
    for root_key in root_keys_to_create:
50
264
        root_id, rev_id = root_key
277
        root_id, rev_id = root_key
51
265
        parent_keys = _parent_keys_for_root_version(
278
        parent_keys = _parent_keys_for_root_version(
52
@@ -270,7 +283,10 @@
53
270
283
54
271
def _parent_keys_for_root_version(
284
def _parent_keys_for_root_version(
55
272
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
285
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
57
273
    """Get the parent keys for a given root id."""
286
    """Get the parent keys for a given root id.
58
287
    
59
288
    A helper function for _new_root_data_stream.
60
289
    """
61
274
    # Include direct parents of the revision, but only if they used the same
290
    # Include direct parents of the revision, but only if they used the same
62
275
    # root_id and are heads.
291
    # root_id and are heads.
63
276
    rev_parents = parent_map[rev_id]
292
    rev_parents = parent_map[rev_id]
64
277
293
65
=== modified file 'bzrlib/inventory_delta.py'
66
--- bzrlib/inventory_delta.py	2009-08-05 02:30:11 +0000
67
+++ bzrlib/inventory_delta.py	2009-08-11 08:40:32 +0000
68
@@ -29,6 +29,25 @@
69
29
from bzrlib import inventory
29
from bzrlib import inventory
70
30
from bzrlib.revision import NULL_REVISION
30
from bzrlib.revision import NULL_REVISION
71
31
31
72
32
FORMAT_1 = 'bzr inventory delta v1 (bzr 1.14)'
73
33
74
34
75
35
class InventoryDeltaError(errors.BzrError):
76
36
    """An error when serializing or deserializing an inventory delta."""
77
37
    
78
38
    # Most errors when serializing and deserializing are due to bugs, although
79
39
    # damaged input (i.e. a bug in a different process) could cause
80
40
    # deserialization errors too.
81
41
    internal_error = True
82
42
83
43
84
44
class IncompatibleInventoryDelta(errors.BzrError):
85
45
    """The delta could not be deserialised because its contents conflict with
86
46
    the allow_versioned_root or allow_tree_references flags of the
87
47
    deserializer.
88
48
    """
89
49
    internal_error = False
90
50
91
32
51
92
33
def _directory_content(entry):
52
def _directory_content(entry):
93
34
    """Serialize the content component of entry which is a directory.
53
    """Serialize the content component of entry which is a directory.
94
@@ -49,7 +68,7 @@
95
49
        exec_bytes = ''
68
        exec_bytes = ''
96
50
    size_exec_sha = (entry.text_size, exec_bytes, entry.text_sha1)
69
    size_exec_sha = (entry.text_size, exec_bytes, entry.text_sha1)
97
51
    if None in size_exec_sha:
70
    if None in size_exec_sha:
99
52
        raise errors.BzrError('Missing size or sha for %s' % entry.file_id)
71
        raise InventoryDeltaError('Missing size or sha for %s' % entry.file_id)
100
53
    return "file\x00%d\x00%s\x00%s" % size_exec_sha
72
    return "file\x00%d\x00%s\x00%s" % size_exec_sha
101
54
73
102
55
74
103
@@ -60,7 +79,7 @@
104
60
    """
79
    """
105
61
    target = entry.symlink_target
80
    target = entry.symlink_target
106
62
    if target is None:
81
    if target is None:
108
63
        raise errors.BzrError('Missing target for %s' % entry.file_id)
82
        raise InventoryDeltaError('Missing target for %s' % entry.file_id)
109
64
    return "link\x00%s" % target.encode('utf8')
83
    return "link\x00%s" % target.encode('utf8')
110
65
84
111
66
85
112
@@ -71,7 +90,8 @@
113
71
    """
90
    """
114
72
    tree_revision = entry.reference_revision
91
    tree_revision = entry.reference_revision
115
73
    if tree_revision is None:
92
    if tree_revision is None:
117
74
        raise errors.BzrError('Missing reference revision for %s' % entry.file_id)
93
        raise InventoryDeltaError(
118
94
            'Missing reference revision for %s' % entry.file_id)
119
75
    return "tree\x00%s" % tree_revision
95
    return "tree\x00%s" % tree_revision
120
76
96
121
77
97
122
@@ -116,39 +136,22 @@
123
116
136
124
117
137
125
118
class InventoryDeltaSerializer(object):
138
class InventoryDeltaSerializer(object):
137
119
    """Serialize and deserialize inventory deltas."""
139
    """Serialize inventory deltas."""
138
120
140
139
121
    # XXX: really, the serializer and deserializer should be two separate
141
    def __init__(self, versioned_root, tree_references):
140
122
    # classes.
142
        """Create an InventoryDeltaSerializer.
141
123
143
142
124
    FORMAT_1 = 'bzr inventory delta v1 (bzr 1.14)'
144
        :param versioned_root: If True, any root entry that is seen is expected
143
125
145
            to be versioned, and root entries can have any fileid.
144
126
    def __init__(self):
146
        :param tree_references: If True support tree-reference entries.
145
127
        """Create an InventoryDeltaSerializer."""
147
        """
146
128
        self._versioned_root = None
148
        self._versioned_root = versioned_root
147
129
        self._tree_references = None
149
        self._tree_references = tree_references
148
130
        self._entry_to_content = {
150
        self._entry_to_content = {
149
131
            'directory': _directory_content,
151
            'directory': _directory_content,
150
132
            'file': _file_content,
152
            'file': _file_content,
151
133
            'symlink': _link_content,
153
            'symlink': _link_content,
152
134
        }
154
        }
153
135
154
136
    def require_flags(self, versioned_root=None, tree_references=None):
155
137
        """Set the versioned_root and/or tree_references flags for this
156
138
        (de)serializer.
157
139
158
140
        :param versioned_root: If True, any root entry that is seen is expected
159
141
            to be versioned, and root entries can have any fileid.
160
142
        :param tree_references: If True support tree-reference entries.
161
143
        """
162
144
        if versioned_root is not None and self._versioned_root is not None:
163
145
            raise AssertionError(
164
146
                "require_flags(versioned_root=...) already called.")
165
147
        if tree_references is not None and self._tree_references is not None:
166
148
            raise AssertionError(
167
149
                "require_flags(tree_references=...) already called.")
168
150
        self._versioned_root = versioned_root
169
151
        self._tree_references = tree_references
170
152
        if tree_references:
155
        if tree_references:
171
153
            self._entry_to_content['tree-reference'] = _reference_content
156
            self._entry_to_content['tree-reference'] = _reference_content
172
154
157
173
@@ -167,10 +170,6 @@
174
167
            takes.
170
            takes.
175
168
        :return: The serialized delta as lines.
171
        :return: The serialized delta as lines.
176
169
        """
172
        """
177
170
        if self._versioned_root is None or self._tree_references is None:
178
171
            raise AssertionError(
179
172
                "Cannot serialise unless versioned_root/tree_references flags "
180
173
                "are both set.")
181
174
        if type(old_name) is not str:
173
        if type(old_name) is not str:
182
175
            raise TypeError('old_name should be str, got %r' % (old_name,))
174
            raise TypeError('old_name should be str, got %r' % (old_name,))
183
176
        if type(new_name) is not str:
175
        if type(new_name) is not str:
184
@@ -180,11 +179,11 @@
185
180
        for delta_item in delta_to_new:
179
        for delta_item in delta_to_new:
186
181
            line = to_line(delta_item, new_name)
180
            line = to_line(delta_item, new_name)
187
182
            if line.__class__ != str:
181
            if line.__class__ != str:
189
183
                raise errors.BzrError(
182
                raise InventoryDeltaError(
190
184
                    'to_line generated non-str output %r' % lines[-1])
183
                    'to_line generated non-str output %r' % lines[-1])
191
185
            lines.append(line)
184
            lines.append(line)
192
186
        lines.sort()
185
        lines.sort()
194
187
        lines[0] = "format: %s\n" % InventoryDeltaSerializer.FORMAT_1
186
        lines[0] = "format: %s\n" % FORMAT_1
195
188
        lines[1] = "parent: %s\n" % old_name
187
        lines[1] = "parent: %s\n" % old_name
196
189
        lines[2] = "version: %s\n" % new_name
188
        lines[2] = "version: %s\n" % new_name
197
190
        lines[3] = "versioned_root: %s\n" % self._serialize_bool(
189
        lines[3] = "versioned_root: %s\n" % self._serialize_bool(
198
@@ -234,23 +233,37 @@
199
234
                # file-ids other than TREE_ROOT, e.g. repo formats that use the
233
                # file-ids other than TREE_ROOT, e.g. repo formats that use the
200
235
                # xml5 serializer.
234
                # xml5 serializer.
201
236
                if last_modified != new_version:
235
                if last_modified != new_version:
203
237
                    raise errors.BzrError(
236
                    raise InventoryDeltaError(
204
238
                        'Version present for / in %s (%s != %s)'
237
                        'Version present for / in %s (%s != %s)'
205
239
                        % (file_id, last_modified, new_version))
238
                        % (file_id, last_modified, new_version))
206
240
            if last_modified is None:
239
            if last_modified is None:
208
241
                raise errors.BzrError("no version for fileid %s" % file_id)
240
                raise InventoryDeltaError("no version for fileid %s" % file_id)
209
242
            content = self._entry_to_content[entry.kind](entry)
241
            content = self._entry_to_content[entry.kind](entry)
210
243
        return ("%s\x00%s\x00%s\x00%s\x00%s\x00%s\n" %
242
        return ("%s\x00%s\x00%s\x00%s\x00%s\x00%s\n" %
211
244
            (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
243
            (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
212
245
                content))
244
                content))
213
246
245
214
246
215
247
class InventoryDeltaDeserializer(object):
216
248
    """Deserialize inventory deltas."""
217
249
218
250
    def __init__(self, allow_versioned_root=True, allow_tree_references=True):
219
251
        """Create an InventoryDeltaDeserializer.
220
252
221
253
        :param versioned_root: If True, any root entry that is seen is expected
222
254
            to be versioned, and root entries can have any fileid.
223
255
        :param tree_references: If True support tree-reference entries.
224
256
        """
225
257
        self._allow_versioned_root = allow_versioned_root
226
258
        self._allow_tree_references = allow_tree_references
227
259
228
247
    def _deserialize_bool(self, value):
260
    def _deserialize_bool(self, value):
229
248
        if value == "true":
261
        if value == "true":
230
249
            return True
262
            return True
231
250
        elif value == "false":
263
        elif value == "false":
232
251
            return False
264
            return False
233
252
        else:
265
        else:
235
253
            raise errors.BzrError("value %r is not a bool" % (value,))
266
            raise InventoryDeltaError("value %r is not a bool" % (value,))
236
254
267
237
255
    def parse_text_bytes(self, bytes):
268
    def parse_text_bytes(self, bytes):
238
256
        """Parse the text bytes of a serialized inventory delta.
269
        """Parse the text bytes of a serialized inventory delta.
239
@@ -266,32 +279,24 @@
240
266
        """
279
        """
241
267
        if bytes[-1:] != '\n':
280
        if bytes[-1:] != '\n':
242
268
            last_line = bytes.rsplit('\n', 1)[-1]
281
            last_line = bytes.rsplit('\n', 1)[-1]
244
269
            raise errors.BzrError('last line not empty: %r' % (last_line,))
282
            raise InventoryDeltaError('last line not empty: %r' % (last_line,))
245
270
        lines = bytes.split('\n')[:-1] # discard the last empty line
283
        lines = bytes.split('\n')[:-1] # discard the last empty line
248
271
        if not lines or lines[0] != 'format: %s' % InventoryDeltaSerializer.FORMAT_1:
284
        if not lines or lines[0] != 'format: %s' % FORMAT_1:
249
272
            raise errors.BzrError('unknown format %r' % lines[0:1])
285
            raise InventoryDeltaError('unknown format %r' % lines[0:1])
250
273
        if len(lines) < 2 or not lines[1].startswith('parent: '):
286
        if len(lines) < 2 or not lines[1].startswith('parent: '):
252
274
            raise errors.BzrError('missing parent: marker')
287
            raise InventoryDeltaError('missing parent: marker')
253
275
        delta_parent_id = lines[1][8:]
288
        delta_parent_id = lines[1][8:]
254
276
        if len(lines) < 3 or not lines[2].startswith('version: '):
289
        if len(lines) < 3 or not lines[2].startswith('version: '):
256
277
            raise errors.BzrError('missing version: marker')
290
            raise InventoryDeltaError('missing version: marker')
257
278
        delta_version_id = lines[2][9:]
291
        delta_version_id = lines[2][9:]
258
279
        if len(lines) < 4 or not lines[3].startswith('versioned_root: '):
292
        if len(lines) < 4 or not lines[3].startswith('versioned_root: '):
260
280
            raise errors.BzrError('missing versioned_root: marker')
293
            raise InventoryDeltaError('missing versioned_root: marker')
261
281
        delta_versioned_root = self._deserialize_bool(lines[3][16:])
294
        delta_versioned_root = self._deserialize_bool(lines[3][16:])
262
282
        if len(lines) < 5 or not lines[4].startswith('tree_references: '):
295
        if len(lines) < 5 or not lines[4].startswith('tree_references: '):
264
283
            raise errors.BzrError('missing tree_references: marker')
296
            raise InventoryDeltaError('missing tree_references: marker')
265
284
        delta_tree_references = self._deserialize_bool(lines[4][17:])
297
        delta_tree_references = self._deserialize_bool(lines[4][17:])
276
285
        if (self._versioned_root is not None and
298
        if (not self._allow_versioned_root and delta_versioned_root):
277
286
            delta_versioned_root != self._versioned_root):
299
            raise IncompatibleInventoryDelta("versioned_root not allowed")
268
287
            raise errors.BzrError(
269
288
                "serialized versioned_root flag is wrong: %s" %
270
289
                (delta_versioned_root,))
271
290
        if (self._tree_references is not None
272
291
            and delta_tree_references != self._tree_references):
273
292
            raise errors.BzrError(
274
293
                "serialized tree_references flag is wrong: %s" %
275
294
                (delta_tree_references,))
278
295
        result = []
300
        result = []
279
296
        seen_ids = set()
301
        seen_ids = set()
280
297
        line_iter = iter(lines)
302
        line_iter = iter(lines)
281
@@ -302,24 +307,30 @@
282
302
                content) = line.split('\x00', 5)
307
                content) = line.split('\x00', 5)
283
303
            parent_id = parent_id or None
308
            parent_id = parent_id or None
284
304
            if file_id in seen_ids:
309
            if file_id in seen_ids:
286
305
                raise errors.BzrError(
310
                raise InventoryDeltaError(
287
306
                    "duplicate file id in inventory delta %r" % lines)
311
                    "duplicate file id in inventory delta %r" % lines)
288
307
            seen_ids.add(file_id)
312
            seen_ids.add(file_id)
289
308
            if (newpath_utf8 == '/' and not delta_versioned_root and
313
            if (newpath_utf8 == '/' and not delta_versioned_root and
290
309
                last_modified != delta_version_id):
314
                last_modified != delta_version_id):
294
310
                    # Delta claims to be not rich root, yet here's a root entry
315
                    # Delta claims to be not have a versioned root, yet here's
295
311
                    # with either non-default version, i.e. it's rich...
316
                    # a root entry with a non-default version.
296
312
                    raise errors.BzrError("Versioned root found: %r" % line)
317
                    raise InventoryDeltaError("Versioned root found: %r" % line)
297
313
            elif newpath_utf8 != 'None' and last_modified[-1] == ':':
318
            elif newpath_utf8 != 'None' and last_modified[-1] == ':':
298
314
                # Deletes have a last_modified of null:, but otherwise special
319
                # Deletes have a last_modified of null:, but otherwise special
299
315
                # revision ids should not occur.
320
                # revision ids should not occur.
303
316
                raise errors.BzrError('special revisionid found: %r' % line)
321
                raise InventoryDeltaError('special revisionid found: %r' % line)
304
317
            if delta_tree_references is False and content.startswith('tree\x00'):
322
            if content.startswith('tree\x00'):
305
318
                raise errors.BzrError("Tree reference found: %r" % line)
323
                if delta_tree_references is False:
306
324
                    raise InventoryDeltaError(
307
325
                            "Tree reference found (but header said "
308
326
                            "tree_references: false): %r" % line)
309
327
                elif not self._allow_tree_references:
310
328
                    raise IncompatibleInventoryDelta(
311
329
                        "Tree reference not allowed")
312
319
            if oldpath_utf8 == 'None':
330
            if oldpath_utf8 == 'None':
313
320
                oldpath = None
331
                oldpath = None
314
321
            elif oldpath_utf8[:1] != '/':
332
            elif oldpath_utf8[:1] != '/':
316
322
                raise errors.BzrError(
333
                raise InventoryDeltaError(
317
323
                    "oldpath invalid (does not start with /): %r"
334
                    "oldpath invalid (does not start with /): %r"
318
324
                    % (oldpath_utf8,))
335
                    % (oldpath_utf8,))
319
325
            else:
336
            else:
320
@@ -328,7 +339,7 @@
321
328
            if newpath_utf8 == 'None':
339
            if newpath_utf8 == 'None':
322
329
                newpath = None
340
                newpath = None
323
330
            elif newpath_utf8[:1] != '/':
341
            elif newpath_utf8[:1] != '/':
325
331
                raise errors.BzrError(
342
                raise InventoryDeltaError(
326
332
                    "newpath invalid (does not start with /): %r"
343
                    "newpath invalid (does not start with /): %r"
327
333
                    % (newpath_utf8,))
344
                    % (newpath_utf8,))
328
334
            else:
345
            else:
329
@@ -340,15 +351,14 @@
330
340
                entry = None
351
                entry = None
331
341
            else:
352
            else:
332
342
                entry = _parse_entry(
353
                entry = _parse_entry(
335
343
                    newpath_utf8, file_id, parent_id, last_modified,
354
                    newpath, file_id, parent_id, last_modified, content_tuple)
334
344
                    content_tuple)
336
345
            delta_item = (oldpath, newpath, file_id, entry)
355
            delta_item = (oldpath, newpath, file_id, entry)
337
346
            result.append(delta_item)
356
            result.append(delta_item)
338
347
        return (delta_parent_id, delta_version_id, delta_versioned_root,
357
        return (delta_parent_id, delta_version_id, delta_versioned_root,
339
348
                delta_tree_references, result)
358
                delta_tree_references, result)
340
349
359
341
350
360
343
351
def _parse_entry(utf8_path, file_id, parent_id, last_modified, content):
361
def _parse_entry(path, file_id, parent_id, last_modified, content):
344
352
    entry_factory = {
362
    entry_factory = {
345
353
        'dir': _dir_to_entry,
363
        'dir': _dir_to_entry,
346
354
        'file': _file_to_entry,
364
        'file': _file_to_entry,
347
@@ -356,10 +366,10 @@
348
356
        'tree': _tree_to_entry,
366
        'tree': _tree_to_entry,
349
357
    }
367
    }
350
358
    kind = content[0]
368
    kind = content[0]
352
359
    if utf8_path.startswith('/'):
369
    if path.startswith('/'):
353
360
        raise AssertionError
370
        raise AssertionError
354
361
    path = utf8_path.decode('utf8')
355
362
    name = basename(path)
371
    name = basename(path)
356
363
    return entry_factory[content[0]](
372
    return entry_factory[content[0]](
357
364
            content, name, parent_id, file_id, last_modified)
373
            content, name, parent_id, file_id, last_modified)
358
365
374
359
375
360
366
376
361
=== modified file 'bzrlib/remote.py'
362
--- bzrlib/remote.py	2009-08-13 12:51:59 +0000
363
+++ bzrlib/remote.py	2009-08-13 08:21:02 +0000
364
@@ -587,11 +587,6 @@
365
587
        self._ensure_real()
587
        self._ensure_real()
366
588
        return self._custom_format._serializer
588
        return self._custom_format._serializer
367
589
589
368
590
    @property
369
591
    def repository_class(self):
370
592
        self._ensure_real()
371
593
        return self._custom_format.repository_class
372
594
373
595
590
374
596
class RemoteRepository(_RpcHelper):
591
class RemoteRepository(_RpcHelper):
375
597
    """Repository accessed over rpc.
592
    """Repository accessed over rpc.
376
@@ -1684,9 +1679,6 @@
377
1684
1679
378
1685
class RemoteStreamSink(repository.StreamSink):
1680
class RemoteStreamSink(repository.StreamSink):
379
1686
1681
380
1687
    def __init__(self, target_repo):
381
1688
        repository.StreamSink.__init__(self, target_repo)
382
1689
383
1690
    def _insert_real(self, stream, src_format, resume_tokens):
1682
    def _insert_real(self, stream, src_format, resume_tokens):
384
1691
        self.target_repo._ensure_real()
1683
        self.target_repo._ensure_real()
385
1692
        sink = self.target_repo._real_repository._get_sink()
1684
        sink = self.target_repo._real_repository._get_sink()
386
@@ -1708,6 +1700,10 @@
387
1708
        client = target._client
1700
        client = target._client
388
1709
        medium = client._medium
1701
        medium = client._medium
389
1710
        path = target.bzrdir._path_for_remote_call(client)
1702
        path = target.bzrdir._path_for_remote_call(client)
390
1703
        # Probe for the verb to use with an empty stream before sending the
391
1704
        # real stream to it.  We do this both to avoid the risk of sending a
392
1705
        # large request that is then rejected, and because we don't want to
393
1706
        # implement a way to buffer, rewind, or restart the stream.
394
1711
        found_verb = False
1707
        found_verb = False
395
1712
        for verb, required_version in candidate_calls:
1708
        for verb, required_version in candidate_calls:
396
1713
            if medium._is_remote_before(required_version):
1709
            if medium._is_remote_before(required_version):
397
1714
1710
398
=== modified file 'bzrlib/repofmt/groupcompress_repo.py'
399
--- bzrlib/repofmt/groupcompress_repo.py	2009-08-13 12:51:59 +0000
400
+++ bzrlib/repofmt/groupcompress_repo.py	2009-08-13 08:20:28 +0000
401
@@ -484,6 +484,8 @@
402
484
            old_pack = self.packs[0]
484
            old_pack = self.packs[0]
403
485
            if old_pack.name == self.new_pack._hash.hexdigest():
485
            if old_pack.name == self.new_pack._hash.hexdigest():
404
486
                # The single old pack was already optimally packed.
486
                # The single old pack was already optimally packed.
405
487
                trace.mutter('single pack %s was already optimally packed',
406
488
                    old_pack.name)
407
487
                self.new_pack.abort()
489
                self.new_pack.abort()
408
488
                return None
490
                return None
409
489
        self.pb.update('finishing repack', 6, 7)
491
        self.pb.update('finishing repack', 6, 7)
410
@@ -600,7 +602,7 @@
411
600
            packer = GCCHKPacker(self, packs, '.autopack',
602
            packer = GCCHKPacker(self, packs, '.autopack',
412
601
                                 reload_func=reload_func)
603
                                 reload_func=reload_func)
413
602
            try:
604
            try:
415
603
                packer.pack()
605
                result = packer.pack()
416
604
            except errors.RetryWithNewPacks:
606
            except errors.RetryWithNewPacks:
417
605
                # An exception is propagating out of this context, make sure
607
                # An exception is propagating out of this context, make sure
418
606
                # this packer has cleaned up. Packer() doesn't set its new_pack
608
                # this packer has cleaned up. Packer() doesn't set its new_pack
419
@@ -609,6 +611,8 @@
420
609
                if packer.new_pack is not None:
611
                if packer.new_pack is not None:
421
610
                    packer.new_pack.abort()
612
                    packer.new_pack.abort()
422
611
                raise
613
                raise
423
614
            if result is None:
424
615
                return
425
612
            for pack in packs:
616
            for pack in packs:
426
613
                self._remove_pack_from_memory(pack)
617
                self._remove_pack_from_memory(pack)
427
614
        # record the newly available packs and stop advertising the old
618
        # record the newly available packs and stop advertising the old
428
@@ -792,6 +796,8 @@
429
792
796
430
793
    def _iter_inventories(self, revision_ids, ordering):
797
    def _iter_inventories(self, revision_ids, ordering):
431
794
        """Iterate over many inventory objects."""
798
        """Iterate over many inventory objects."""
432
799
        if ordering is None:
433
800
            ordering = 'unordered'
434
795
        keys = [(revision_id,) for revision_id in revision_ids]
801
        keys = [(revision_id,) for revision_id in revision_ids]
435
796
        stream = self.inventories.get_record_stream(keys, ordering, True)
802
        stream = self.inventories.get_record_stream(keys, ordering, True)
436
797
        texts = {}
803
        texts = {}
437
@@ -903,9 +909,7 @@
438
903
909
439
904
    def _get_source(self, to_format):
910
    def _get_source(self, to_format):
440
905
        """Return a source for streaming from this repository."""
911
        """Return a source for streaming from this repository."""
444
906
        if (to_format.supports_chks and
912
        if self._format._serializer == to_format._serializer:
442
907
            self._format.repository_class is to_format.repository_class and
443
908
            self._format._serializer == to_format._serializer):
445
909
            # We must be exactly the same format, otherwise stuff like the chk
913
            # We must be exactly the same format, otherwise stuff like the chk
446
910
            # page layout might be different.
914
            # page layout might be different.
447
911
            # Actually, this test is just slightly looser than exact so that
915
            # Actually, this test is just slightly looser than exact so that
448
912
916
449
=== modified file 'bzrlib/repofmt/pack_repo.py'
450
--- bzrlib/repofmt/pack_repo.py	2009-08-13 12:51:59 +0000
451
+++ bzrlib/repofmt/pack_repo.py	2009-08-13 07:26:29 +0000
452
@@ -1575,6 +1575,8 @@
453
1575
        pack_operations = [[0, []]]
1575
        pack_operations = [[0, []]]
454
1576
        for pack in self.all_packs():
1576
        for pack in self.all_packs():
455
1577
            if hint is None or pack.name in hint:
1577
            if hint is None or pack.name in hint:
456
1578
                # Either no hint was provided (so we are packing everything),
457
1579
                # or this pack was included in the hint.
458
1578
                pack_operations[-1][0] += pack.get_revision_count()
1580
                pack_operations[-1][0] += pack.get_revision_count()
459
1579
                pack_operations[-1][1].append(pack)
1581
                pack_operations[-1][1].append(pack)
460
1580
        self._execute_pack_operations(pack_operations, OptimisingPacker)
1582
        self._execute_pack_operations(pack_operations, OptimisingPacker)
461
1581
1583
462
=== modified file 'bzrlib/repository.py'
463
--- bzrlib/repository.py	2009-08-13 12:51:59 +0000
464
+++ bzrlib/repository.py	2009-08-13 08:56:51 +0000
465
@@ -1537,6 +1537,8 @@
466
1537
        """Commit the contents accrued within the current write group.
1537
        """Commit the contents accrued within the current write group.
467
1538
1538
468
1539
        :seealso: start_write_group.
1539
        :seealso: start_write_group.
469
1540
        
470
1541
        :return: it may return an opaque hint that can be passed to 'pack'.
471
1540
        """
1542
        """
472
1541
        if self._write_group is not self.get_transaction():
1543
        if self._write_group is not self.get_transaction():
473
1542
            # has an unlock or relock occured ?
1544
            # has an unlock or relock occured ?
474
@@ -2348,7 +2350,7 @@
475
2348
        """Get Inventory object by revision id."""
2350
        """Get Inventory object by revision id."""
476
2349
        return self.iter_inventories([revision_id]).next()
2351
        return self.iter_inventories([revision_id]).next()
477
2350
2352
479
2351
    def iter_inventories(self, revision_ids, ordering='unordered'):
2353
    def iter_inventories(self, revision_ids, ordering=None):
480
2352
        """Get many inventories by revision_ids.
2354
        """Get many inventories by revision_ids.
481
2353
2355
482
2354
        This will buffer some or all of the texts used in constructing the
2356
        This will buffer some or all of the texts used in constructing the
483
@@ -2356,7 +2358,9 @@
484
2356
        time.
2358
        time.
485
2357
2359
486
2358
        :param revision_ids: The expected revision ids of the inventories.
2360
        :param revision_ids: The expected revision ids of the inventories.
488
2359
        :param ordering: optional ordering, e.g. 'topological'.
2361
        :param ordering: optional ordering, e.g. 'topological'.  If not
489
2362
            specified, the order of revision_ids will be preserved (by
490
2363
            buffering if necessary).
491
2360
        :return: An iterator of inventories.
2364
        :return: An iterator of inventories.
492
2361
        """
2365
        """
493
2362
        if ((None in revision_ids)
2366
        if ((None in revision_ids)
494
@@ -2370,29 +2374,41 @@
495
2370
        for text, revision_id in inv_xmls:
2374
        for text, revision_id in inv_xmls:
496
2371
            yield self.deserialise_inventory(revision_id, text)
2375
            yield self.deserialise_inventory(revision_id, text)
497
2372
2376
499
2373
    def _iter_inventory_xmls(self, revision_ids, ordering='unordered'):
2377
    def _iter_inventory_xmls(self, revision_ids, ordering):
500
2378
        if ordering is None:
501
2379
            order_as_requested = True
502
2380
            ordering = 'unordered'
503
2381
        else:
504
2382
            order_as_requested = False
505
2374
        keys = [(revision_id,) for revision_id in revision_ids]
2383
        keys = [(revision_id,) for revision_id in revision_ids]
506
2375
        if not keys:
2384
        if not keys:
507
2376
            return
2385
            return
510
2377
        key_iter = iter(keys)
2386
        if order_as_requested:
511
2378
        next_key = key_iter.next()
2387
            key_iter = iter(keys)
512
2388
            next_key = key_iter.next()
513
2379
        stream = self.inventories.get_record_stream(keys, ordering, True)
2389
        stream = self.inventories.get_record_stream(keys, ordering, True)
514
2380
        text_chunks = {}
2390
        text_chunks = {}
515
2381
        for record in stream:
2391
        for record in stream:
516
2382
            if record.storage_kind != 'absent':
2392
            if record.storage_kind != 'absent':
518
2383
                text_chunks[record.key] = record.get_bytes_as('chunked')
2393
                chunks = record.get_bytes_as('chunked')
519
2394
                if order_as_requested:
520
2395
                    text_chunks[record.key] = chunks
521
2396
                else:
522
2397
                    yield ''.join(chunks), record.key[-1]
523
2384
            else:
2398
            else:
524
2385
                raise errors.NoSuchRevision(self, record.key)
2399
                raise errors.NoSuchRevision(self, record.key)
535
2386
            while next_key in text_chunks:
2400
            if order_as_requested:
536
2387
                chunks = text_chunks.pop(next_key)
2401
                # Yield as many results as we can while preserving order.
537
2388
                yield ''.join(chunks), next_key[-1]
2402
                while next_key in text_chunks:
538
2389
                try:
2403
                    chunks = text_chunks.pop(next_key)
539
2390
                    next_key = key_iter.next()
2404
                    yield ''.join(chunks), next_key[-1]
540
2391
                except StopIteration:
2405
                    try:
541
2392
                    # We still want to fully consume the get_record_stream,
2406
                        next_key = key_iter.next()
542
2393
                    # just in case it is not actually finished at this point
2407
                    except StopIteration:
543
2394
                    next_key = None
2408
                        # We still want to fully consume the get_record_stream,
544
2395
                    break
2409
                        # just in case it is not actually finished at this point
545
2410
                        next_key = None
546
2411
                        break
547
2396
2412
548
2397
    def deserialise_inventory(self, revision_id, xml):
2413
    def deserialise_inventory(self, revision_id, xml):
549
2398
        """Transform the xml into an inventory object.
2414
        """Transform the xml into an inventory object.
550
@@ -4224,20 +4240,14 @@
551
4224
        for record in substream:
4240
        for record in substream:
552
4225
            # Insert the delta directly
4241
            # Insert the delta directly
553
4226
            inventory_delta_bytes = record.get_bytes_as('fulltext')
4242
            inventory_delta_bytes = record.get_bytes_as('fulltext')
556
4227
            deserialiser = inventory_delta.InventoryDeltaSerializer()
4243
            deserialiser = inventory_delta.InventoryDeltaDeserializer()
557
4228
            parse_result = deserialiser.parse_text_bytes(inventory_delta_bytes)
4244
            try:
558
4245
                parse_result = deserialiser.parse_text_bytes(
559
4246
                    inventory_delta_bytes)
560
4247
            except inventory_delta.IncompatibleInventoryDelta, err:
561
4248
                trace.mutter("Incompatible delta: %s", err.msg)
562
4249
                raise errors.IncompatibleRevision(self.target_repo._format)
563
4229
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
4250
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
564
4230
            # Make sure the delta is compatible with the target
565
4231
            if rich_root and not target_rich_root:
566
4232
                raise errors.IncompatibleRevision(self.target_repo._format)
567
4233
            if tree_refs and not target_tree_refs:
568
4234
                # The source supports tree refs and the target doesn't.  Check
569
4235
                # the delta for tree refs; if it has any we can't insert it.
570
4236
                for delta_item in inv_delta:
571
4237
                    entry = delta_item[3]
572
4238
                    if entry.kind == 'tree-reference':
573
4239
                        raise errors.IncompatibleRevision(
574
4240
                            self.target_repo._format)
575
4241
            revision_id = new_id
4251
            revision_id = new_id
576
4242
            parents = [key[0] for key in record.parents]
4252
            parents = [key[0] for key in record.parents]
577
4243
            self.target_repo.add_inventory_by_delta(
4253
            self.target_repo.add_inventory_by_delta(
578
@@ -4404,10 +4414,6 @@
579
4404
                # Some missing keys are genuinely ghosts, filter those out.
4414
                # Some missing keys are genuinely ghosts, filter those out.
580
4405
                present = self.from_repository.inventories.get_parent_map(keys)
4415
                present = self.from_repository.inventories.get_parent_map(keys)
581
4406
                revs = [key[0] for key in present]
4416
                revs = [key[0] for key in present]
582
4407
                # As with the original stream, we may need to generate root
583
4408
                # texts for the inventories we're about to stream.
584
4409
                for _ in self._generate_root_texts(revs):
585
4410
                    yield _
586
4411
                # Get the inventory stream more-or-less as we do for the
4417
                # Get the inventory stream more-or-less as we do for the
587
4412
                # original stream; there's no reason to assume that records
4418
                # original stream; there's no reason to assume that records
588
4413
                # direct from the source will be suitable for the sink.  (Think
4419
                # direct from the source will be suitable for the sink.  (Think
589
@@ -4474,7 +4480,7 @@
590
4474
4480
591
4475
    def _get_convertable_inventory_stream(self, revision_ids,
4481
    def _get_convertable_inventory_stream(self, revision_ids,
592
4476
                                          delta_versus_null=False):
4482
                                          delta_versus_null=False):
594
4477
        # The source is using CHKs, but the target either doesn't or is has a
4483
        # The source is using CHKs, but the target either doesn't or it has a
595
4478
        # different serializer.  The StreamSink code expects to be able to
4484
        # different serializer.  The StreamSink code expects to be able to
596
4479
        # convert on the target, so we need to put bytes-on-the-wire that can
4485
        # convert on the target, so we need to put bytes-on-the-wire that can
597
4480
        # be converted.  That means inventory deltas (if the remote is <1.18,
4486
        # be converted.  That means inventory deltas (if the remote is <1.18,
598
@@ -4499,17 +4505,17 @@
599
4499
        # method...
4505
        # method...
600
4500
        inventories = self.from_repository.iter_inventories(
4506
        inventories = self.from_repository.iter_inventories(
601
4501
            revision_ids, 'topological')
4507
            revision_ids, 'topological')
602
4502
        # XXX: ideally these flags would be per-revision, not per-repo (e.g.
603
4503
        # streaming a non-rich-root revision out of a rich-root repo back into
604
4504
        # a non-rich-root repo ought to be allowed)
605
4505
        format = from_repo._format
4508
        format = from_repo._format
606
4506
        flags = (format.rich_root_data, format.supports_tree_reference)
607
4507
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
4509
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
608
4508
        inventory_cache = lru_cache.LRUCache(50)
4510
        inventory_cache = lru_cache.LRUCache(50)
609
4509
        null_inventory = from_repo.revision_tree(
4511
        null_inventory = from_repo.revision_tree(
610
4510
            _mod_revision.NULL_REVISION).inventory
4512
            _mod_revision.NULL_REVISION).inventory
613
4511
        serializer = inventory_delta.InventoryDeltaSerializer()
4513
        # XXX: ideally the rich-root/tree-refs flags would be per-revision, not
614
4512
        serializer.require_flags(*flags)
4514
        # per-repo (e.g.  streaming a non-rich-root revision out of a rich-root
615
4515
        # repo back into a non-rich-root repo ought to be allowed)
616
4516
        serializer = inventory_delta.InventoryDeltaSerializer(
617
4517
            versioned_root=format.rich_root_data,
618
4518
            tree_references=format.supports_tree_reference)
619
4513
        for inv in inventories:
4519
        for inv in inventories:
620
4514
            key = (inv.revision_id,)
4520
            key = (inv.revision_id,)
621
4515
            parent_keys = parent_map.get(key, ())
4521
            parent_keys = parent_map.get(key, ())
622
4516
4522
623
=== modified file 'bzrlib/smart/repository.py'
624
--- bzrlib/smart/repository.py	2009-08-04 00:51:24 +0000
625
+++ bzrlib/smart/repository.py	2009-08-13 08:20:53 +0000
626
@@ -424,18 +424,21 @@
627
424
        return None # Signal that we want a body.
424
        return None # Signal that we want a body.
628
425
425
629
426
    def _should_fake_unknown(self):
426
    def _should_fake_unknown(self):
642
427
        # This is a workaround for bugs in pre-1.18 clients that claim to
427
        """Return True if we should return UnknownMethod to the client.
643
428
        # support receiving streams of CHK repositories.  The pre-1.18 client
428
        
644
429
        # expects inventory records to be serialized in the format defined by
429
        This is a workaround for bugs in pre-1.18 clients that claim to
645
430
        # to_network_name, but in pre-1.18 (at least) that format definition
430
        support receiving streams of CHK repositories.  The pre-1.18 client
646
431
        # tries to use the xml5 serializer, which does not correctly handle
431
        expects inventory records to be serialized in the format defined by
647
432
        # rich-roots.  After 1.18 the client can also accept inventory-deltas
432
        to_network_name, but in pre-1.18 (at least) that format definition
648
433
        # (which avoids this issue), and those clients will use the
433
        tries to use the xml5 serializer, which does not correctly handle
649
434
        # Repository.get_stream_1.18 verb instead of this one.
434
        rich-roots.  After 1.18 the client can also accept inventory-deltas
650
435
        # So: if this repository is CHK, and the to_format doesn't match,
435
        (which avoids this issue), and those clients will use the
651
436
        # we should just fake an UnknownSmartMethod error so that the client
436
        Repository.get_stream_1.18 verb instead of this one.
652
437
        # will fallback to VFS, rather than sending it a stream we know it
437
        So: if this repository is CHK, and the to_format doesn't match,
653
438
        # cannot handle.
438
        we should just fake an UnknownSmartMethod error so that the client
654
439
        will fallback to VFS, rather than sending it a stream we know it
655
440
        cannot handle.
656
441
        """
657
439
        from_format = self._repository._format
442
        from_format = self._repository._format
658
440
        to_format = self._to_format
443
        to_format = self._to_format
659
441
        if not from_format.supports_chks:
444
        if not from_format.supports_chks:
660
@@ -489,8 +492,7 @@
661
489
class SmartServerRepositoryGetStream_1_18(SmartServerRepositoryGetStream):
492
class SmartServerRepositoryGetStream_1_18(SmartServerRepositoryGetStream):
662
490
493
663
491
    def _should_fake_unknown(self):
494
    def _should_fake_unknown(self):
666
492
        # The client is at least 1.18, so we don't need to work around any
495
        """Returns False; we don't need to workaround bugs in 1.18+ clients."""
665
493
        # bugs.
667
494
        return False
496
        return False
668
495
497
669
496
498
670
497
499
671
=== modified file 'bzrlib/tests/per_interrepository/__init__.py'
672
--- bzrlib/tests/per_interrepository/__init__.py	2009-08-13 12:51:59 +0000
673
+++ bzrlib/tests/per_interrepository/__init__.py	2009-08-13 03:30:41 +0000
674
@@ -46,12 +46,12 @@
675
46
    """Transform the input formats to a list of scenarios.
46
    """Transform the input formats to a list of scenarios.
676
47
47
677
48
    :param formats: A list of tuples:
48
    :param formats: A list of tuples:
679
49
        (interrepo_class, repository_format, repository_format_to).
49
        (label, repository_format, repository_format_to).
680
50
    """
50
    """
681
51
    result = []
51
    result = []
685
52
    for repository_format, repository_format_to in formats:
52
    for label, repository_format, repository_format_to in formats:
686
53
        id = '%s,%s' % (repository_format.__class__.__name__,
53
        id = '%s,%s,%s' % (label, repository_format.__class__.__name__,
687
54
                        repository_format_to.__class__.__name__)
54
                           repository_format_to.__class__.__name__)
688
55
        scenario = (id,
55
        scenario = (id,
689
56
            {"transport_server": transport_server,
56
            {"transport_server": transport_server,
690
57
             "transport_readonly_server": transport_readonly_server,
57
             "transport_readonly_server": transport_readonly_server,
691
@@ -71,8 +71,8 @@
692
71
        weaverepo,
71
        weaverepo,
693
72
        )
72
        )
694
73
    result = []
73
    result = []
697
74
    def add_combo(from_format, to_format):
74
    def add_combo(label, from_format, to_format):
698
75
        result.append((from_format, to_format))
75
        result.append((label, from_format, to_format))
699
76
    # test the default InterRepository between format 6 and the current
76
    # test the default InterRepository between format 6 and the current
700
77
    # default format.
77
    # default format.
701
78
    # XXX: robertc 20060220 reinstate this when there are two supported
78
    # XXX: robertc 20060220 reinstate this when there are two supported
702
@@ -83,32 +83,47 @@
703
83
    for optimiser_class in InterRepository._optimisers:
83
    for optimiser_class in InterRepository._optimisers:
704
84
        format_to_test = optimiser_class._get_repo_format_to_test()
84
        format_to_test = optimiser_class._get_repo_format_to_test()
705
85
        if format_to_test is not None:
85
        if format_to_test is not None:
707
86
            add_combo(format_to_test, format_to_test)
86
            add_combo(optimiser_class.__name__, format_to_test, format_to_test)
708
87
    # if there are specific combinations we want to use, we can add them
87
    # if there are specific combinations we want to use, we can add them
709
88
    # here. We want to test rich root upgrading.
88
    # here. We want to test rich root upgrading.
715
89
    add_combo(weaverepo.RepositoryFormat5(),
89
    # XXX: although we attach InterRepository class names to these scenarios,
716
90
              knitrepo.RepositoryFormatKnit3())
90
    # there's nothing asserting that these labels correspond to what it
717
91
    add_combo(knitrepo.RepositoryFormatKnit1(),
91
    # actually used.
718
92
              knitrepo.RepositoryFormatKnit3())
92
    add_combo('InterRepository',
719
93
    add_combo(knitrepo.RepositoryFormatKnit1(),
93
              weaverepo.RepositoryFormat5(),
720
94
              knitrepo.RepositoryFormatKnit3())
721
95
    add_combo('InterRepository',
722
96
              knitrepo.RepositoryFormatKnit1(),
723
97
              knitrepo.RepositoryFormatKnit3())
724
98
    add_combo('InterKnitRepo',
725
99
              knitrepo.RepositoryFormatKnit1(),
726
94
              pack_repo.RepositoryFormatKnitPack1())
100
              pack_repo.RepositoryFormatKnitPack1())
728
95
    add_combo(pack_repo.RepositoryFormatKnitPack1(),
101
    add_combo('InterKnitRepo',
729
102
              pack_repo.RepositoryFormatKnitPack1(),
730
96
              knitrepo.RepositoryFormatKnit1())
103
              knitrepo.RepositoryFormatKnit1())
732
97
    add_combo(knitrepo.RepositoryFormatKnit3(),
104
    add_combo('InterKnitRepo',
733
105
              knitrepo.RepositoryFormatKnit3(),
734
98
              pack_repo.RepositoryFormatKnitPack3())
106
              pack_repo.RepositoryFormatKnitPack3())
736
99
    add_combo(pack_repo.RepositoryFormatKnitPack3(),
107
    add_combo('InterKnitRepo',
737
108
              pack_repo.RepositoryFormatKnitPack3(),
738
100
              knitrepo.RepositoryFormatKnit3())
109
              knitrepo.RepositoryFormatKnit3())
740
101
    add_combo(pack_repo.RepositoryFormatKnitPack3(),
110
    add_combo('InterKnitRepo',
741
111
              pack_repo.RepositoryFormatKnitPack3(),
742
102
              pack_repo.RepositoryFormatKnitPack4())
112
              pack_repo.RepositoryFormatKnitPack4())
752
103
    add_combo(pack_repo.RepositoryFormatKnitPack1(),
113
    add_combo('InterDifferingSerializer',
753
104
              pack_repo.RepositoryFormatKnitPack6RichRoot())
114
              pack_repo.RepositoryFormatKnitPack1(),
754
105
    add_combo(pack_repo.RepositoryFormatKnitPack6RichRoot(),
115
              pack_repo.RepositoryFormatKnitPack6RichRoot())
755
106
              groupcompress_repo.RepositoryFormat2a())
116
    add_combo('InterDifferingSerializer',
756
107
    add_combo(groupcompress_repo.RepositoryFormat2a(),
117
              pack_repo.RepositoryFormatKnitPack6RichRoot(),
757
108
              pack_repo.RepositoryFormatKnitPack6RichRoot())
118
              groupcompress_repo.RepositoryFormat2a())
758
109
    add_combo(groupcompress_repo.RepositoryFormatCHK2(),
119
    add_combo('InterDifferingSerializer',
759
110
              groupcompress_repo.RepositoryFormat2a())
120
              groupcompress_repo.RepositoryFormat2a(),
760
111
    add_combo(groupcompress_repo.RepositoryFormatCHK1(),
121
              pack_repo.RepositoryFormatKnitPack6RichRoot())
761
122
    add_combo('InterRepository',
762
123
              groupcompress_repo.RepositoryFormatCHK2(),
763
124
              groupcompress_repo.RepositoryFormat2a())
764
125
    add_combo('InterDifferingSerializer',
765
126
              groupcompress_repo.RepositoryFormatCHK1(),
766
112
              groupcompress_repo.RepositoryFormat2a())
127
              groupcompress_repo.RepositoryFormat2a())
767
113
    return result
128
    return result
768
114
129
769
115
130
770
=== modified file 'bzrlib/tests/per_interrepository/test_fetch.py'
771
--- bzrlib/tests/per_interrepository/test_fetch.py	2009-08-13 12:51:59 +0000
772
+++ bzrlib/tests/per_interrepository/test_fetch.py	2009-08-13 08:55:59 +0000
773
@@ -191,8 +191,19 @@
774
191
            ['left', 'right'])
191
            ['left', 'right'])
775
192
        self.assertEqual(left_tree.inventory, stacked_left_tree.inventory)
192
        self.assertEqual(left_tree.inventory, stacked_left_tree.inventory)
776
193
        self.assertEqual(right_tree.inventory, stacked_right_tree.inventory)
193
        self.assertEqual(right_tree.inventory, stacked_right_tree.inventory)
778
194
        
194
779
195
        # Finally, it's not enough to see that the basis inventories are
780
196
        # present.  The texts introduced in merge (and only those) should be
781
197
        # present, and also generating a stream should succeed without blowing
782
198
        # up.
783
195
        self.assertTrue(unstacked_repo.has_revision('merge'))
199
        self.assertTrue(unstacked_repo.has_revision('merge'))
784
200
        expected_texts = set([('file-id', 'merge')])
785
201
        if stacked_branch.repository.texts.get_parent_map([('root-id',
786
202
            'merge')]):
787
203
            # If a (root-id,merge) text exists, it should be in the stacked
788
204
            # repo.
789
205
            expected_texts.add(('root-id', 'merge'))
790
206
        self.assertEqual(expected_texts, unstacked_repo.texts.keys())
791
196
        self.assertCanStreamRevision(unstacked_repo, 'merge')
207
        self.assertCanStreamRevision(unstacked_repo, 'merge')
792
197
208
793
198
    def assertCanStreamRevision(self, repo, revision_id):
209
    def assertCanStreamRevision(self, repo, revision_id):
794
@@ -241,6 +252,19 @@
795
241
        self.addCleanup(stacked_branch.unlock)
252
        self.addCleanup(stacked_branch.unlock)
796
242
        stacked_second_tree = stacked_branch.repository.revision_tree('second')
253
        stacked_second_tree = stacked_branch.repository.revision_tree('second')
797
243
        self.assertEqual(second_tree.inventory, stacked_second_tree.inventory)
254
        self.assertEqual(second_tree.inventory, stacked_second_tree.inventory)
798
255
        # Finally, it's not enough to see that the basis inventories are
799
256
        # present.  The texts introduced in merge (and only those) should be
800
257
        # present, and also generating a stream should succeed without blowing
801
258
        # up.
802
259
        self.assertTrue(unstacked_repo.has_revision('third'))
803
260
        expected_texts = set([('file-id', 'third')])
804
261
        if stacked_branch.repository.texts.get_parent_map([('root-id',
805
262
            'third')]):
806
263
            # If a (root-id,third) text exists, it should be in the stacked
807
264
            # repo.
808
265
            expected_texts.add(('root-id', 'third'))
809
266
        self.assertEqual(expected_texts, unstacked_repo.texts.keys())
810
267
        self.assertCanStreamRevision(unstacked_repo, 'third')
811
244
268
812
245
    def test_fetch_missing_basis_text(self):
269
    def test_fetch_missing_basis_text(self):
813
246
        """If fetching a delta, we should die if a basis is not present."""
270
        """If fetching a delta, we should die if a basis is not present."""
814
247
271
815
=== modified file 'bzrlib/tests/per_pack_repository.py'
816
--- bzrlib/tests/per_pack_repository.py	2009-08-12 22:28:28 +0000
817
+++ bzrlib/tests/per_pack_repository.py	2009-08-13 03:29:52 +0000
818
@@ -1051,8 +1051,8 @@
819
1051
        tree.branch.push(remote_branch)
1051
        tree.branch.push(remote_branch)
820
1052
        autopack_calls = len([call for call in self.hpss_calls if call ==
1052
        autopack_calls = len([call for call in self.hpss_calls if call ==
821
1053
            'PackRepository.autopack'])
1053
            'PackRepository.autopack'])
824
1054
        streaming_calls = len([call for call in self.hpss_calls if call ==
1054
        streaming_calls = len([call for call in self.hpss_calls if call in
825
1055
            'Repository.insert_stream'])
1055
            ('Repository.insert_stream', 'Repository.insert_stream_1.18')])
826
1056
        if autopack_calls:
1056
        if autopack_calls:
827
1057
            # Non streaming server
1057
            # Non streaming server
828
1058
            self.assertEqual(1, autopack_calls)
1058
            self.assertEqual(1, autopack_calls)
829
1059
1059
830
=== modified file 'bzrlib/tests/test_inventory_delta.py'
831
--- bzrlib/tests/test_inventory_delta.py	2009-08-05 02:30:11 +0000
832
+++ bzrlib/tests/test_inventory_delta.py	2009-08-11 06:52:07 +0000
833
@@ -26,6 +26,7 @@
834
26
    inventory,
26
    inventory,
835
27
    inventory_delta,
27
    inventory_delta,
836
28
    )
28
    )
837
29
from bzrlib.inventory_delta import InventoryDeltaError
838
29
from bzrlib.inventory import Inventory
30
from bzrlib.inventory import Inventory
839
30
from bzrlib.revision import NULL_REVISION
31
from bzrlib.revision import NULL_REVISION
840
31
from bzrlib.tests import TestCase
32
from bzrlib.tests import TestCase
841
@@ -93,34 +94,34 @@
842
93
    """Test InventoryDeltaSerializer.parse_text_bytes."""
94
    """Test InventoryDeltaSerializer.parse_text_bytes."""
843
94
95
844
95
    def test_parse_no_bytes(self):
96
    def test_parse_no_bytes(self):
846
96
        serializer = inventory_delta.InventoryDeltaSerializer()
97
        deserializer = inventory_delta.InventoryDeltaDeserializer()
847
97
        err = self.assertRaises(
98
        err = self.assertRaises(
849
98
            errors.BzrError, serializer.parse_text_bytes, '')
99
            InventoryDeltaError, deserializer.parse_text_bytes, '')
850
99
        self.assertContainsRe(str(err), 'last line not empty')
100
        self.assertContainsRe(str(err), 'last line not empty')
851
100
101
852
101
    def test_parse_bad_format(self):
102
    def test_parse_bad_format(self):
856
102
        serializer = inventory_delta.InventoryDeltaSerializer()
103
        deserializer = inventory_delta.InventoryDeltaDeserializer()
857
103
        err = self.assertRaises(errors.BzrError,
104
        err = self.assertRaises(InventoryDeltaError,
858
104
            serializer.parse_text_bytes, 'format: foo\n')
105
            deserializer.parse_text_bytes, 'format: foo\n')
859
105
        self.assertContainsRe(str(err), 'unknown format')
106
        self.assertContainsRe(str(err), 'unknown format')
860
106
107
861
107
    def test_parse_no_parent(self):
108
    def test_parse_no_parent(self):
865
108
        serializer = inventory_delta.InventoryDeltaSerializer()
109
        deserializer = inventory_delta.InventoryDeltaDeserializer()
866
109
        err = self.assertRaises(errors.BzrError,
110
        err = self.assertRaises(InventoryDeltaError,
867
110
            serializer.parse_text_bytes,
111
            deserializer.parse_text_bytes,
868
111
            'format: bzr inventory delta v1 (bzr 1.14)\n')
112
            'format: bzr inventory delta v1 (bzr 1.14)\n')
869
112
        self.assertContainsRe(str(err), 'missing parent: marker')
113
        self.assertContainsRe(str(err), 'missing parent: marker')
870
113
114
871
114
    def test_parse_no_version(self):
115
    def test_parse_no_version(self):
875
115
        serializer = inventory_delta.InventoryDeltaSerializer()
116
        deserializer = inventory_delta.InventoryDeltaDeserializer()
876
116
        err = self.assertRaises(errors.BzrError,
117
        err = self.assertRaises(InventoryDeltaError,
877
117
            serializer.parse_text_bytes,
118
            deserializer.parse_text_bytes,
878
118
            'format: bzr inventory delta v1 (bzr 1.14)\n'
119
            'format: bzr inventory delta v1 (bzr 1.14)\n'
879
119
            'parent: null:\n')
120
            'parent: null:\n')
880
120
        self.assertContainsRe(str(err), 'missing version: marker')
121
        self.assertContainsRe(str(err), 'missing version: marker')
881
121
            
122
            
882
122
    def test_parse_duplicate_key_errors(self):
123
    def test_parse_duplicate_key_errors(self):
884
123
        serializer = inventory_delta.InventoryDeltaSerializer()
124
        deserializer = inventory_delta.InventoryDeltaDeserializer()
885
124
        double_root_lines = \
125
        double_root_lines = \
886
125
"""format: bzr inventory delta v1 (bzr 1.14)
126
"""format: bzr inventory delta v1 (bzr 1.14)
887
126
parent: null:
127
parent: null:
888
@@ -130,14 +131,13 @@
889
130
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
131
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
890
131
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
132
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
891
132
"""
133
"""
894
133
        err = self.assertRaises(errors.BzrError,
134
        err = self.assertRaises(InventoryDeltaError,
895
134
            serializer.parse_text_bytes, double_root_lines)
135
            deserializer.parse_text_bytes, double_root_lines)
896
135
        self.assertContainsRe(str(err), 'duplicate file id')
136
        self.assertContainsRe(str(err), 'duplicate file id')
897
136
137
898
137
    def test_parse_versioned_root_only(self):
138
    def test_parse_versioned_root_only(self):
902
138
        serializer = inventory_delta.InventoryDeltaSerializer()
139
        deserializer = inventory_delta.InventoryDeltaDeserializer()
903
139
        serializer.require_flags(versioned_root=True, tree_references=True)
140
        parse_result = deserializer.parse_text_bytes(root_only_lines)
901
140
        parse_result = serializer.parse_text_bytes(root_only_lines)
904
141
        expected_entry = inventory.make_entry(
141
        expected_entry = inventory.make_entry(
905
142
            'directory', u'', None, 'an-id')
142
            'directory', u'', None, 'an-id')
906
143
        expected_entry.revision = 'a@e\xc3\xa5ample.com--2004'
143
        expected_entry.revision = 'a@e\xc3\xa5ample.com--2004'
907
@@ -147,8 +147,7 @@
908
147
            parse_result)
147
            parse_result)
909
148
148
910
149
    def test_parse_special_revid_not_valid_last_mod(self):
149
    def test_parse_special_revid_not_valid_last_mod(self):
913
150
        serializer = inventory_delta.InventoryDeltaSerializer()
150
        deserializer = inventory_delta.InventoryDeltaDeserializer()
912
151
        serializer.require_flags(versioned_root=False, tree_references=True)
914
152
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
151
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
915
153
parent: null:
152
parent: null:
916
154
version: null:
153
version: null:
917
@@ -156,13 +155,12 @@
918
156
tree_references: true
155
tree_references: true
919
157
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir\x00\x00
156
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir\x00\x00
920
158
"""
157
"""
923
159
        err = self.assertRaises(errors.BzrError,
158
        err = self.assertRaises(InventoryDeltaError,
924
160
            serializer.parse_text_bytes, root_only_lines)
159
            deserializer.parse_text_bytes, root_only_lines)
925
161
        self.assertContainsRe(str(err), 'special revisionid found')
160
        self.assertContainsRe(str(err), 'special revisionid found')
926
162
161
927
163
    def test_parse_versioned_root_versioned_disabled(self):
162
    def test_parse_versioned_root_versioned_disabled(self):
930
164
        serializer = inventory_delta.InventoryDeltaSerializer()
163
        deserializer = inventory_delta.InventoryDeltaDeserializer()
929
165
        serializer.require_flags(versioned_root=False, tree_references=True)
931
166
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
164
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
932
167
parent: null:
165
parent: null:
933
168
version: null:
166
version: null:
934
@@ -170,13 +168,12 @@
935
170
tree_references: true
168
tree_references: true
936
171
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
169
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
937
172
"""
170
"""
940
173
        err = self.assertRaises(errors.BzrError,
171
        err = self.assertRaises(InventoryDeltaError,
941
174
            serializer.parse_text_bytes, root_only_lines)
172
            deserializer.parse_text_bytes, root_only_lines)
942
175
        self.assertContainsRe(str(err), 'Versioned root found')
173
        self.assertContainsRe(str(err), 'Versioned root found')
943
176
174
944
177
    def test_parse_unique_root_id_root_versioned_disabled(self):
175
    def test_parse_unique_root_id_root_versioned_disabled(self):
947
178
        serializer = inventory_delta.InventoryDeltaSerializer()
176
        deserializer = inventory_delta.InventoryDeltaDeserializer()
946
179
        serializer.require_flags(versioned_root=False, tree_references=True)
948
180
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
177
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
949
181
parent: parent-id
178
parent: parent-id
950
182
version: a@e\xc3\xa5ample.com--2004
179
version: a@e\xc3\xa5ample.com--2004
951
@@ -184,29 +181,38 @@
952
184
tree_references: true
181
tree_references: true
953
185
None\x00/\x00an-id\x00\x00parent-id\x00dir\x00\x00
182
None\x00/\x00an-id\x00\x00parent-id\x00dir\x00\x00
954
186
"""
183
"""
957
187
        err = self.assertRaises(errors.BzrError,
184
        err = self.assertRaises(InventoryDeltaError,
958
188
            serializer.parse_text_bytes, root_only_lines)
185
            deserializer.parse_text_bytes, root_only_lines)
959
189
        self.assertContainsRe(str(err), 'Versioned root found')
186
        self.assertContainsRe(str(err), 'Versioned root found')
960
190
187
961
191
    def test_parse_unversioned_root_versioning_enabled(self):
188
    def test_parse_unversioned_root_versioning_enabled(self):
968
192
        serializer = inventory_delta.InventoryDeltaSerializer()
189
        deserializer = inventory_delta.InventoryDeltaDeserializer()
969
193
        serializer.require_flags(versioned_root=True, tree_references=True)
190
        parse_result = deserializer.parse_text_bytes(root_only_unversioned)
970
194
        err = self.assertRaises(errors.BzrError,
191
        expected_entry = inventory.make_entry(
971
195
            serializer.parse_text_bytes, root_only_unversioned)
192
            'directory', u'', None, 'TREE_ROOT')
972
196
        self.assertContainsRe(
193
        expected_entry.revision = 'entry-version'
973
197
            str(err), 'serialized versioned_root flag is wrong: False')
194
        self.assertEqual(
974
195
            ('null:', 'entry-version', False, False,
975
196
             [(None, u'', 'TREE_ROOT', expected_entry)]),
976
197
            parse_result)
977
198
978
199
    def test_parse_versioned_root_when_disabled(self):
979
200
        deserializer = inventory_delta.InventoryDeltaDeserializer(
980
201
            allow_versioned_root=False)
981
202
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
982
203
            deserializer.parse_text_bytes, root_only_lines)
983
204
        self.assertEquals("versioned_root not allowed", str(err))
984
198
205
985
199
    def test_parse_tree_when_disabled(self):
206
    def test_parse_tree_when_disabled(self):
992
200
        serializer = inventory_delta.InventoryDeltaSerializer()
207
        deserializer = inventory_delta.InventoryDeltaDeserializer(
993
201
        serializer.require_flags(versioned_root=True, tree_references=False)
208
            allow_tree_references=False)
994
202
        err = self.assertRaises(errors.BzrError,
209
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
995
203
            serializer.parse_text_bytes, reference_lines)
210
            deserializer.parse_text_bytes, reference_lines)
996
204
        self.assertContainsRe(
211
        self.assertEquals("Tree reference not allowed", str(err))
991
205
            str(err), 'serialized tree_references flag is wrong: True')
997
206
212
998
207
    def test_parse_tree_when_header_disallows(self):
213
    def test_parse_tree_when_header_disallows(self):
999
208
        # A deserializer that allows tree_references to be set or unset.
214
        # A deserializer that allows tree_references to be set or unset.
1001
209
        serializer = inventory_delta.InventoryDeltaSerializer()
215
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1002
210
        # A serialised inventory delta with a header saying no tree refs, but
216
        # A serialised inventory delta with a header saying no tree refs, but
1003
211
        # that has a tree ref in its content.
217
        # that has a tree ref in its content.
1004
212
        lines = """format: bzr inventory delta v1 (bzr 1.14)
218
        lines = """format: bzr inventory delta v1 (bzr 1.14)
1005
@@ -216,13 +222,13 @@
1006
216
tree_references: false
222
tree_references: false
1007
217
None\x00/foo\x00id\x00TREE_ROOT\x00changed\x00tree\x00subtree-version
223
None\x00/foo\x00id\x00TREE_ROOT\x00changed\x00tree\x00subtree-version
1008
218
"""
224
"""
1011
219
        err = self.assertRaises(errors.BzrError,
225
        err = self.assertRaises(InventoryDeltaError,
1012
220
            serializer.parse_text_bytes, lines)
226
            deserializer.parse_text_bytes, lines)
1013
221
        self.assertContainsRe(str(err), 'Tree reference found')
227
        self.assertContainsRe(str(err), 'Tree reference found')
1014
222
228
1015
223
    def test_parse_versioned_root_when_header_disallows(self):
229
    def test_parse_versioned_root_when_header_disallows(self):
1016
224
        # A deserializer that allows tree_references to be set or unset.
230
        # A deserializer that allows tree_references to be set or unset.
1018
225
        serializer = inventory_delta.InventoryDeltaSerializer()
231
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1019
226
        # A serialised inventory delta with a header saying no tree refs, but
232
        # A serialised inventory delta with a header saying no tree refs, but
1020
227
        # that has a tree ref in its content.
233
        # that has a tree ref in its content.
1021
228
        lines = """format: bzr inventory delta v1 (bzr 1.14)
234
        lines = """format: bzr inventory delta v1 (bzr 1.14)
1022
@@ -232,35 +238,35 @@
1023
232
tree_references: false
238
tree_references: false
1024
233
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir
239
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir
1025
234
"""
240
"""
1028
235
        err = self.assertRaises(errors.BzrError,
241
        err = self.assertRaises(InventoryDeltaError,
1029
236
            serializer.parse_text_bytes, lines)
242
            deserializer.parse_text_bytes, lines)
1030
237
        self.assertContainsRe(str(err), 'Versioned root found')
243
        self.assertContainsRe(str(err), 'Versioned root found')
1031
238
244
1032
239
    def test_parse_last_line_not_empty(self):
245
    def test_parse_last_line_not_empty(self):
1033
240
        """newpath must start with / if it is not None."""
246
        """newpath must start with / if it is not None."""
1034
241
        # Trim the trailing newline from a valid serialization
247
        # Trim the trailing newline from a valid serialization
1035
242
        lines = root_only_lines[:-1]
248
        lines = root_only_lines[:-1]
1039
243
        serializer = inventory_delta.InventoryDeltaSerializer()
249
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1040
244
        err = self.assertRaises(errors.BzrError,
250
        err = self.assertRaises(InventoryDeltaError,
1041
245
            serializer.parse_text_bytes, lines)
251
            deserializer.parse_text_bytes, lines)
1042
246
        self.assertContainsRe(str(err), 'last line not empty')
252
        self.assertContainsRe(str(err), 'last line not empty')
1043
247
253
1044
248
    def test_parse_invalid_newpath(self):
254
    def test_parse_invalid_newpath(self):
1045
249
        """newpath must start with / if it is not None."""
255
        """newpath must start with / if it is not None."""
1046
250
        lines = empty_lines
256
        lines = empty_lines
1047
251
        lines += "None\x00bad\x00TREE_ROOT\x00\x00version\x00dir\n"
257
        lines += "None\x00bad\x00TREE_ROOT\x00\x00version\x00dir\n"
1051
252
        serializer = inventory_delta.InventoryDeltaSerializer()
258
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1052
253
        err = self.assertRaises(errors.BzrError,
259
        err = self.assertRaises(InventoryDeltaError,
1053
254
            serializer.parse_text_bytes, lines)
260
            deserializer.parse_text_bytes, lines)
1054
255
        self.assertContainsRe(str(err), 'newpath invalid')
261
        self.assertContainsRe(str(err), 'newpath invalid')
1055
256
262
1056
257
    def test_parse_invalid_oldpath(self):
263
    def test_parse_invalid_oldpath(self):
1057
258
        """oldpath must start with / if it is not None."""
264
        """oldpath must start with / if it is not None."""
1058
259
        lines = root_only_lines
265
        lines = root_only_lines
1059
260
        lines += "bad\x00/new\x00file-id\x00\x00version\x00dir\n"
266
        lines += "bad\x00/new\x00file-id\x00\x00version\x00dir\n"
1063
261
        serializer = inventory_delta.InventoryDeltaSerializer()
267
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1064
262
        err = self.assertRaises(errors.BzrError,
268
        err = self.assertRaises(InventoryDeltaError,
1065
263
            serializer.parse_text_bytes, lines)
269
            deserializer.parse_text_bytes, lines)
1066
264
        self.assertContainsRe(str(err), 'oldpath invalid')
270
        self.assertContainsRe(str(err), 'oldpath invalid')
1067
265
    
271
    
1068
266
    def test_parse_new_file(self):
272
    def test_parse_new_file(self):
1069
@@ -270,8 +276,8 @@
1070
270
        lines += (
276
        lines += (
1071
271
            "None\x00/new\x00file-id\x00an-id\x00version\x00file\x00123\x00" +
277
            "None\x00/new\x00file-id\x00an-id\x00version\x00file\x00123\x00" +
1072
272
            "\x00" + fake_sha + "\n")
278
            "\x00" + fake_sha + "\n")
1075
273
        serializer = inventory_delta.InventoryDeltaSerializer()
279
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1076
274
        parse_result = serializer.parse_text_bytes(lines)
280
        parse_result = deserializer.parse_text_bytes(lines)
1077
275
        expected_entry = inventory.make_entry(
281
        expected_entry = inventory.make_entry(
1078
276
            'file', u'new', 'an-id', 'file-id')
282
            'file', u'new', 'an-id', 'file-id')
1079
277
        expected_entry.revision = 'version'
283
        expected_entry.revision = 'version'
1080
@@ -285,8 +291,8 @@
1081
285
        lines = root_only_lines
291
        lines = root_only_lines
1082
286
        lines += (
292
        lines += (
1083
287
            "/old-file\x00None\x00deleted-id\x00\x00null:\x00deleted\x00\x00\n")
293
            "/old-file\x00None\x00deleted-id\x00\x00null:\x00deleted\x00\x00\n")
1086
288
        serializer = inventory_delta.InventoryDeltaSerializer()
294
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1087
289
        parse_result = serializer.parse_text_bytes(lines)
295
        parse_result = deserializer.parse_text_bytes(lines)
1088
290
        delta = parse_result[4]
296
        delta = parse_result[4]
1089
291
        self.assertEqual(
297
        self.assertEqual(
1090
292
             (u'old-file', None, 'deleted-id', None), delta[-1])
298
             (u'old-file', None, 'deleted-id', None), delta[-1])
1091
@@ -299,8 +305,8 @@
1092
299
        old_inv = Inventory(None)
305
        old_inv = Inventory(None)
1093
300
        new_inv = Inventory(None)
306
        new_inv = Inventory(None)
1094
301
        delta = new_inv._make_delta(old_inv)
307
        delta = new_inv._make_delta(old_inv)
1097
302
        serializer = inventory_delta.InventoryDeltaSerializer()
308
        serializer = inventory_delta.InventoryDeltaSerializer(
1098
303
        serializer.require_flags(True, True)
309
            versioned_root=True, tree_references=True)
1099
304
        self.assertEqual(StringIO(empty_lines).readlines(),
310
        self.assertEqual(StringIO(empty_lines).readlines(),
1100
305
            serializer.delta_to_lines(NULL_REVISION, NULL_REVISION, delta))
311
            serializer.delta_to_lines(NULL_REVISION, NULL_REVISION, delta))
1101
306
312
1102
@@ -311,8 +317,8 @@
1103
311
        root.revision = 'a@e\xc3\xa5ample.com--2004'
317
        root.revision = 'a@e\xc3\xa5ample.com--2004'
1104
312
        new_inv.add(root)
318
        new_inv.add(root)
1105
313
        delta = new_inv._make_delta(old_inv)
319
        delta = new_inv._make_delta(old_inv)
1108
314
        serializer = inventory_delta.InventoryDeltaSerializer()
320
        serializer = inventory_delta.InventoryDeltaSerializer(
1109
315
        serializer.require_flags(versioned_root=True, tree_references=True)
321
            versioned_root=True, tree_references=True)
1110
316
        self.assertEqual(StringIO(root_only_lines).readlines(),
322
        self.assertEqual(StringIO(root_only_lines).readlines(),
1111
317
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
323
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
1112
318
324
1113
@@ -324,15 +330,16 @@
1114
324
        root.revision = 'entry-version'
330
        root.revision = 'entry-version'
1115
325
        new_inv.add(root)
331
        new_inv.add(root)
1116
326
        delta = new_inv._make_delta(old_inv)
332
        delta = new_inv._make_delta(old_inv)
1119
327
        serializer = inventory_delta.InventoryDeltaSerializer()
333
        serializer = inventory_delta.InventoryDeltaSerializer(
1120
328
        serializer.require_flags(False, False)
334
            versioned_root=False, tree_references=False)
1121
329
        serialized_lines = serializer.delta_to_lines(
335
        serialized_lines = serializer.delta_to_lines(
1122
330
            NULL_REVISION, 'entry-version', delta)
336
            NULL_REVISION, 'entry-version', delta)
1123
331
        self.assertEqual(StringIO(root_only_unversioned).readlines(),
337
        self.assertEqual(StringIO(root_only_unversioned).readlines(),
1124
332
            serialized_lines)
338
            serialized_lines)
1125
339
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1126
333
        self.assertEqual(
340
        self.assertEqual(
1127
334
            (NULL_REVISION, 'entry-version', False, False, delta),
341
            (NULL_REVISION, 'entry-version', False, False, delta),
1129
335
            serializer.parse_text_bytes(''.join(serialized_lines)))
342
            deserializer.parse_text_bytes(''.join(serialized_lines)))
1130
336
343
1131
337
    def test_unversioned_non_root_errors(self):
344
    def test_unversioned_non_root_errors(self):
1132
338
        old_inv = Inventory(None)
345
        old_inv = Inventory(None)
1133
@@ -343,9 +350,9 @@
1134
343
        non_root = new_inv.make_entry('directory', 'foo', root.file_id, 'id')
350
        non_root = new_inv.make_entry('directory', 'foo', root.file_id, 'id')
1135
344
        new_inv.add(non_root)
351
        new_inv.add(non_root)
1136
345
        delta = new_inv._make_delta(old_inv)
352
        delta = new_inv._make_delta(old_inv)
1140
346
        serializer = inventory_delta.InventoryDeltaSerializer()
353
        serializer = inventory_delta.InventoryDeltaSerializer(
1141
347
        serializer.require_flags(versioned_root=True, tree_references=True)
354
            versioned_root=True, tree_references=True)
1142
348
        err = self.assertRaises(errors.BzrError,
355
        err = self.assertRaises(InventoryDeltaError,
1143
349
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
356
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
1144
350
        self.assertEqual(str(err), 'no version for fileid id')
357
        self.assertEqual(str(err), 'no version for fileid id')
1145
351
358
1146
@@ -355,9 +362,9 @@
1147
355
        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
362
        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
1148
356
        new_inv.add(root)
363
        new_inv.add(root)
1149
357
        delta = new_inv._make_delta(old_inv)
364
        delta = new_inv._make_delta(old_inv)
1153
358
        serializer = inventory_delta.InventoryDeltaSerializer()
365
        serializer = inventory_delta.InventoryDeltaSerializer(
1154
359
        serializer.require_flags(versioned_root=True, tree_references=True)
366
            versioned_root=True, tree_references=True)
1155
360
        err = self.assertRaises(errors.BzrError,
367
        err = self.assertRaises(InventoryDeltaError,
1156
361
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
368
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
1157
362
        self.assertEqual(str(err), 'no version for fileid TREE_ROOT')
369
        self.assertEqual(str(err), 'no version for fileid TREE_ROOT')
1158
363
370
1159
@@ -368,9 +375,9 @@
1160
368
        root.revision = 'a@e\xc3\xa5ample.com--2004'
375
        root.revision = 'a@e\xc3\xa5ample.com--2004'
1161
369
        new_inv.add(root)
376
        new_inv.add(root)
1162
370
        delta = new_inv._make_delta(old_inv)
377
        delta = new_inv._make_delta(old_inv)
1166
371
        serializer = inventory_delta.InventoryDeltaSerializer()
378
        serializer = inventory_delta.InventoryDeltaSerializer(
1167
372
        serializer.require_flags(versioned_root=False, tree_references=True)
379
            versioned_root=False, tree_references=True)
1168
373
        err = self.assertRaises(errors.BzrError,
380
        err = self.assertRaises(InventoryDeltaError,
1169
374
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
381
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
1170
375
        self.assertStartsWith(str(err), 'Version present for / in TREE_ROOT')
382
        self.assertStartsWith(str(err), 'Version present for / in TREE_ROOT')
1171
376
383
1172
@@ -385,8 +392,8 @@
1173
385
        non_root.kind = 'strangelove'
392
        non_root.kind = 'strangelove'
1174
386
        new_inv.add(non_root)
393
        new_inv.add(non_root)
1175
387
        delta = new_inv._make_delta(old_inv)
394
        delta = new_inv._make_delta(old_inv)
1178
388
        serializer = inventory_delta.InventoryDeltaSerializer()
395
        serializer = inventory_delta.InventoryDeltaSerializer(
1179
389
        serializer.require_flags(True, True)
396
            versioned_root=True, tree_references=True)
1180
390
        # we expect keyerror because there is little value wrapping this.
397
        # we expect keyerror because there is little value wrapping this.
1181
391
        # This test aims to prove that it errors more than how it errors.
398
        # This test aims to prove that it errors more than how it errors.
1182
392
        err = self.assertRaises(KeyError,
399
        err = self.assertRaises(KeyError,
1183
@@ -405,8 +412,8 @@
1184
405
        non_root.reference_revision = 'subtree-version'
412
        non_root.reference_revision = 'subtree-version'
1185
406
        new_inv.add(non_root)
413
        new_inv.add(non_root)
1186
407
        delta = new_inv._make_delta(old_inv)
414
        delta = new_inv._make_delta(old_inv)
1189
408
        serializer = inventory_delta.InventoryDeltaSerializer()
415
        serializer = inventory_delta.InventoryDeltaSerializer(
1190
409
        serializer.require_flags(versioned_root=True, tree_references=False)
416
            versioned_root=True, tree_references=False)
1191
410
        # we expect keyerror because there is little value wrapping this.
417
        # we expect keyerror because there is little value wrapping this.
1192
411
        # This test aims to prove that it errors more than how it errors.
418
        # This test aims to prove that it errors more than how it errors.
1193
412
        err = self.assertRaises(KeyError,
419
        err = self.assertRaises(KeyError,
1194
@@ -425,8 +432,8 @@
1195
425
        non_root.reference_revision = 'subtree-version'
432
        non_root.reference_revision = 'subtree-version'
1196
426
        new_inv.add(non_root)
433
        new_inv.add(non_root)
1197
427
        delta = new_inv._make_delta(old_inv)
434
        delta = new_inv._make_delta(old_inv)
1200
428
        serializer = inventory_delta.InventoryDeltaSerializer()
435
        serializer = inventory_delta.InventoryDeltaSerializer(
1201
429
        serializer.require_flags(versioned_root=True, tree_references=True)
436
            versioned_root=True, tree_references=True)
1202
430
        self.assertEqual(StringIO(reference_lines).readlines(),
437
        self.assertEqual(StringIO(reference_lines).readlines(),
1203
431
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
438
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
1204
432
439
1205
@@ -434,19 +441,19 @@
1206
434
        root_entry = inventory.make_entry('directory', '', None, 'TREE_ROOT')
441
        root_entry = inventory.make_entry('directory', '', None, 'TREE_ROOT')
1207
435
        root_entry.revision = 'some-version'
442
        root_entry.revision = 'some-version'
1208
436
        delta = [(None, '', 'TREE_ROOT', root_entry)]
443
        delta = [(None, '', 'TREE_ROOT', root_entry)]
1211
437
        serializer = inventory_delta.InventoryDeltaSerializer()
444
        serializer = inventory_delta.InventoryDeltaSerializer(
1212
438
        serializer.require_flags(versioned_root=False, tree_references=True)
445
            versioned_root=False, tree_references=True)
1213
439
        self.assertRaises(
446
        self.assertRaises(
1215
440
            errors.BzrError, serializer.delta_to_lines, 'old-version',
447
            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
1216
441
            'new-version', delta)
448
            'new-version', delta)
1217
442
449
1218
443
    def test_to_inventory_root_id_not_versioned(self):
450
    def test_to_inventory_root_id_not_versioned(self):
1219
444
        delta = [(None, '', 'an-id', inventory.make_entry(
451
        delta = [(None, '', 'an-id', inventory.make_entry(
1220
445
            'directory', '', None, 'an-id'))]
452
            'directory', '', None, 'an-id'))]
1223
446
        serializer = inventory_delta.InventoryDeltaSerializer()
453
        serializer = inventory_delta.InventoryDeltaSerializer(
1224
447
        serializer.require_flags(versioned_root=True, tree_references=True)
454
            versioned_root=True, tree_references=True)
1225
448
        self.assertRaises(
455
        self.assertRaises(
1227
449
            errors.BzrError, serializer.delta_to_lines, 'old-version',
456
            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
1228
450
            'new-version', delta)
457
            'new-version', delta)
1229
451
458
1230
452
    def test_to_inventory_has_tree_not_meant_to(self):
459
    def test_to_inventory_has_tree_not_meant_to(self):
1231
@@ -459,9 +466,9 @@
1232
459
            (None, 'foo', 'ref-id', tree_ref)
466
            (None, 'foo', 'ref-id', tree_ref)
1233
460
            # a file that followed the root move
467
            # a file that followed the root move
1234
461
            ]
468
            ]
1238
462
        serializer = inventory_delta.InventoryDeltaSerializer()
469
        serializer = inventory_delta.InventoryDeltaSerializer(
1239
463
        serializer.require_flags(versioned_root=True, tree_references=True)
470
            versioned_root=True, tree_references=True)
1240
464
        self.assertRaises(errors.BzrError, serializer.delta_to_lines,
471
        self.assertRaises(InventoryDeltaError, serializer.delta_to_lines,
1241
465
            'old-version', 'new-version', delta)
472
            'old-version', 'new-version', delta)
1242
466
473
1243
467
    def test_to_inventory_torture(self):
474
    def test_to_inventory_torture(self):
1244
@@ -511,8 +518,8 @@
1245
511
                   executable=True, text_size=30, text_sha1='some-sha',
518
                   executable=True, text_size=30, text_sha1='some-sha',
1246
512
                   revision='old-rev')),
519
                   revision='old-rev')),
1247
513
            ]
520
            ]
1250
514
        serializer = inventory_delta.InventoryDeltaSerializer()
521
        serializer = inventory_delta.InventoryDeltaSerializer(
1251
515
        serializer.require_flags(versioned_root=True, tree_references=True)
522
            versioned_root=True, tree_references=True)
1252
516
        lines = serializer.delta_to_lines(NULL_REVISION, 'something', delta)
523
        lines = serializer.delta_to_lines(NULL_REVISION, 'something', delta)
1253
517
        expected = """format: bzr inventory delta v1 (bzr 1.14)
524
        expected = """format: bzr inventory delta v1 (bzr 1.14)
1254
518
parent: null:
525
parent: null:
1255
@@ -565,13 +572,13 @@
1256
565
    def test_file_without_size(self):
572
    def test_file_without_size(self):
1257
566
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
573
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
1258
567
        file_entry.text_sha1 = 'foo'
574
        file_entry.text_sha1 = 'foo'
1260
568
        self.assertRaises(errors.BzrError,
575
        self.assertRaises(InventoryDeltaError,
1261
569
            inventory_delta._file_content, file_entry)
576
            inventory_delta._file_content, file_entry)
1262
570
577
1263
571
    def test_file_without_sha1(self):
578
    def test_file_without_sha1(self):
1264
572
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
579
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
1265
573
        file_entry.text_size = 10
580
        file_entry.text_size = 10
1267
574
        self.assertRaises(errors.BzrError,
581
        self.assertRaises(InventoryDeltaError,
1268
575
            inventory_delta._file_content, file_entry)
582
            inventory_delta._file_content, file_entry)
1269
576
583
1270
577
    def test_link_empty_target(self):
584
    def test_link_empty_target(self):
1271
@@ -594,7 +601,7 @@
1272
594
601
1273
595
    def test_link_no_target(self):
602
    def test_link_no_target(self):
1274
596
        entry = inventory.make_entry('symlink', 'a link', None)
603
        entry = inventory.make_entry('symlink', 'a link', None)
1276
597
        self.assertRaises(errors.BzrError,
604
        self.assertRaises(InventoryDeltaError,
1277
598
            inventory_delta._link_content, entry)
605
            inventory_delta._link_content, entry)
1278
599
606
1279
600
    def test_reference_null(self):
607
    def test_reference_null(self):
1280
@@ -611,5 +618,5 @@
1281
611
618
1282
612
    def test_reference_no_reference(self):
619
    def test_reference_no_reference(self):
1283
613
        entry = inventory.make_entry('tree-reference', 'a tree', None)
620
        entry = inventory.make_entry('tree-reference', 'a tree', None)
1285
614
        self.assertRaises(errors.BzrError,
621
        self.assertRaises(InventoryDeltaError,
1286
615
            inventory_delta._reference_content, entry)
622
            inventory_delta._reference_content, entry)
1287
616
623
1288
=== modified file 'bzrlib/tests/test_remote.py'
1289
--- bzrlib/tests/test_remote.py	2009-08-13 12:51:59 +0000
1290
+++ bzrlib/tests/test_remote.py	2009-08-13 03:29:52 +0000
1291
@@ -2213,7 +2213,26 @@
1292
2213
        self.assertEqual([], client._calls)
2213
        self.assertEqual([], client._calls)
1293
2214
2214
1294
2215
2215
1296
2216
class TestRepositoryInsertStream(TestRemoteRepository):
2216
class TestRepositoryInsertStreamBase(TestRemoteRepository):
1297
2217
    """Base class for Repository.insert_stream and .insert_stream_1.18
1298
2218
    tests.
1299
2219
    """
1300
2220
    
1301
2221
    def checkInsertEmptyStream(self, repo, client):
1302
2222
        """Insert an empty stream, checking the result.
1303
2223
1304
2224
        This checks that there are no resume_tokens or missing_keys, and that
1305
2225
        the client is finished.
1306
2226
        """
1307
2227
        sink = repo._get_sink()
1308
2228
        fmt = repository.RepositoryFormat.get_default_format()
1309
2229
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
1310
2230
        self.assertEqual([], resume_tokens)
1311
2231
        self.assertEqual(set(), missing_keys)
1312
2232
        self.assertFinished(client)
1313
2233
1314
2234
1315
2235
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
1316
2217
    """Tests for using Repository.insert_stream verb when the _1.18 variant is
2236
    """Tests for using Repository.insert_stream verb when the _1.18 variant is
1317
2218
    not available.
2237
    not available.
1318
2219
2238
1319
@@ -2236,12 +2255,7 @@
1320
2236
        client.add_expected_call(
2255
        client.add_expected_call(
1321
2237
            'Repository.insert_stream', ('quack/', ''),
2256
            'Repository.insert_stream', ('quack/', ''),
1322
2238
            'success', ('ok',))
2257
            'success', ('ok',))
1329
2239
        sink = repo._get_sink()
2258
        self.checkInsertEmptyStream(repo, client)
1324
2240
        fmt = repository.RepositoryFormat.get_default_format()
1325
2241
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
1326
2242
        self.assertEqual([], resume_tokens)
1327
2243
        self.assertEqual(set(), missing_keys)
1328
2244
        self.assertFinished(client)
1330
2245
2259
1331
2246
    def test_locked_repo_with_no_lock_token(self):
2260
    def test_locked_repo_with_no_lock_token(self):
1332
2247
        transport_path = 'quack'
2261
        transport_path = 'quack'
1333
@@ -2259,12 +2273,7 @@
1334
2259
            'Repository.insert_stream', ('quack/', ''),
2273
            'Repository.insert_stream', ('quack/', ''),
1335
2260
            'success', ('ok',))
2274
            'success', ('ok',))
1336
2261
        repo.lock_write()
2275
        repo.lock_write()
1343
2262
        sink = repo._get_sink()
2276
        self.checkInsertEmptyStream(repo, client)
1338
2263
        fmt = repository.RepositoryFormat.get_default_format()
1339
2264
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
1340
2265
        self.assertEqual([], resume_tokens)
1341
2266
        self.assertEqual(set(), missing_keys)
1342
2267
        self.assertFinished(client)
1344
2268
2277
1345
2269
    def test_locked_repo_with_lock_token(self):
2278
    def test_locked_repo_with_lock_token(self):
1346
2270
        transport_path = 'quack'
2279
        transport_path = 'quack'
1347
@@ -2282,18 +2291,13 @@
1348
2282
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2291
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
1349
2283
            'success', ('ok',))
2292
            'success', ('ok',))
1350
2284
        repo.lock_write()
2293
        repo.lock_write()
1357
2285
        sink = repo._get_sink()
2294
        self.checkInsertEmptyStream(repo, client)
1352
2286
        fmt = repository.RepositoryFormat.get_default_format()
1353
2287
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
1354
2288
        self.assertEqual([], resume_tokens)
1355
2289
        self.assertEqual(set(), missing_keys)
1356
2290
        self.assertFinished(client)
1358
2291
2295
1359
2292
    def test_stream_with_inventory_deltas(self):
2296
    def test_stream_with_inventory_deltas(self):
1364
2293
        """'inventory-deltas' substreams can't be sent to the
2297
        """'inventory-deltas' substreams cannot be sent to the
1365
2294
        Repository.insert_stream verb.  So when one is encountered the
2298
        Repository.insert_stream verb, because not all servers that implement
1366
2295
        RemoteSink immediately stops using that verb and falls back to VFS
2299
        that verb will accept them.  So when one is encountered the RemoteSink
1367
2296
        insert_stream.
2300
        immediately stops using that verb and falls back to VFS insert_stream.
1368
2297
        """
2301
        """
1369
2298
        transport_path = 'quack'
2302
        transport_path = 'quack'
1370
2299
        repo, client = self.setup_fake_client_and_repository(transport_path)
2303
        repo, client = self.setup_fake_client_and_repository(transport_path)
1371
@@ -2368,8 +2372,8 @@
1372
2368
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
2372
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
1373
2369
            entry.revision = 'ghost'
2373
            entry.revision = 'ghost'
1374
2370
            delta = [(None, 'newdir', 'newdir-id', entry)]
2374
            delta = [(None, 'newdir', 'newdir-id', entry)]
1377
2371
            serializer = inventory_delta.InventoryDeltaSerializer()
2375
            serializer = inventory_delta.InventoryDeltaSerializer(
1378
2372
            serializer.require_flags(True, False)
2376
                versioned_root=True, tree_references=False)
1379
2373
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2377
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
1380
2374
            yield versionedfile.ChunkedContentFactory(
2378
            yield versionedfile.ChunkedContentFactory(
1381
2375
                ('rev2',), (('rev1',)), None, lines)
2379
                ('rev2',), (('rev1',)), None, lines)
1382
@@ -2380,7 +2384,7 @@
1383
2380
        return stream_with_inv_delta()
2384
        return stream_with_inv_delta()
1384
2381
2385
1385
2382
2386
1387
2383
class TestRepositoryInsertStream_1_18(TestRemoteRepository):
2387
class TestRepositoryInsertStream_1_18(TestRepositoryInsertStreamBase):
1388
2384
2388
1389
2385
    def test_unlocked_repo(self):
2389
    def test_unlocked_repo(self):
1390
2386
        transport_path = 'quack'
2390
        transport_path = 'quack'
1391
@@ -2391,12 +2395,7 @@
1392
2391
        client.add_expected_call(
2395
        client.add_expected_call(
1393
2392
            'Repository.insert_stream_1.18', ('quack/', ''),
2396
            'Repository.insert_stream_1.18', ('quack/', ''),
1394
2393
            'success', ('ok',))
2397
            'success', ('ok',))
1401
2394
        sink = repo._get_sink()
2398
        self.checkInsertEmptyStream(repo, client)
1396
2395
        fmt = repository.RepositoryFormat.get_default_format()
1397
2396
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
1398
2397
        self.assertEqual([], resume_tokens)
1399
2398
        self.assertEqual(set(), missing_keys)
1400
2399
        self.assertFinished(client)
1402
2400
2399
1403
2401
    def test_locked_repo_with_no_lock_token(self):
2400
    def test_locked_repo_with_no_lock_token(self):
1404
2402
        transport_path = 'quack'
2401
        transport_path = 'quack'
1405
@@ -2411,12 +2410,7 @@
1406
2411
            'Repository.insert_stream_1.18', ('quack/', ''),
2410
            'Repository.insert_stream_1.18', ('quack/', ''),
1407
2412
            'success', ('ok',))
2411
            'success', ('ok',))
1408
2413
        repo.lock_write()
2412
        repo.lock_write()
1415
2414
        sink = repo._get_sink()
2413
        self.checkInsertEmptyStream(repo, client)
1410
2415
        fmt = repository.RepositoryFormat.get_default_format()
1411
2416
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
1412
2417
        self.assertEqual([], resume_tokens)
1413
2418
        self.assertEqual(set(), missing_keys)
1414
2419
        self.assertFinished(client)
1416
2420
2414
1417
2421
    def test_locked_repo_with_lock_token(self):
2415
    def test_locked_repo_with_lock_token(self):
1418
2422
        transport_path = 'quack'
2416
        transport_path = 'quack'
1419
@@ -2431,12 +2425,7 @@
1420
2431
            'Repository.insert_stream_1.18', ('quack/', '', 'a token'),
2425
            'Repository.insert_stream_1.18', ('quack/', '', 'a token'),
1421
2432
            'success', ('ok',))
2426
            'success', ('ok',))
1422
2433
        repo.lock_write()
2427
        repo.lock_write()
1429
2434
        sink = repo._get_sink()
2428
        self.checkInsertEmptyStream(repo, client)
1424
2435
        fmt = repository.RepositoryFormat.get_default_format()
1425
2436
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
1426
2437
        self.assertEqual([], resume_tokens)
1427
2438
        self.assertEqual(set(), missing_keys)
1428
2439
        self.assertFinished(client)
1430
2440
2429
1431
2441
2430
1432
2442
class TestRepositoryTarball(TestRemoteRepository):
2431
class TestRepositoryTarball(TestRemoteRepository):
1433
2443
2432
1434
=== modified file 'bzrlib/tests/test_smart.py'
1435
--- bzrlib/tests/test_smart.py	2009-07-23 07:37:05 +0000
1436
+++ bzrlib/tests/test_smart.py	2009-08-07 02:26:45 +0000
1437
@@ -1242,6 +1242,7 @@
1438
1242
            SmartServerResponse(('history-incomplete', 2, r2)),
1242
            SmartServerResponse(('history-incomplete', 2, r2)),
1439
1243
            request.execute('stacked', 1, (3, r3)))
1243
            request.execute('stacked', 1, (3, r3)))
1440
1244
1244
1441
1245
1442
1245
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1246
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1443
1246
1247
1444
1247
    def make_two_commit_repo(self):
1248
    def make_two_commit_repo(self):
1
=== modified file 'NEWS'
2
--- NEWS	2009-08-13 22:32:23 +0000
3
+++ NEWS	2009-08-14 05:35:32 +0000
4
@@ -24,6 +24,15 @@
5
24
Bug Fixes
24
Bug Fixes
6
25
*********
25
*********
7
26
26
8
27
* Fetching from 2a branches from a version-2 bzr protocol would fail to
9
28
  copy the internal inventory pages from the CHK store. This cannot happen
10
29
  in normal use as all 2a compatible clients and servers support the
11
30
  version-3 protocol, but it does cause test suite failures when testing
12
31
  downlevel protocol behaviour. (Robert Collins)
13
32
14
33
* Fixed "Pack ... already exists" error when running ``bzr pack`` on a
15
34
  fully packed 2a repository.  (Andrew Bennetts, #382463)
16
35
17
27
* Further tweaks to handling of ``bzr add`` messages about ignored files.
36
* Further tweaks to handling of ``bzr add`` messages about ignored files.
18
28
  (Jason Spashett, #76616)
37
  (Jason Spashett, #76616)
19
29
38
20
@@ -32,15 +41,22 @@
21
32
  parent inventories incorrectly, and also not handling when one of the
41
  parent inventories incorrectly, and also not handling when one of the
22
33
  parents was a ghost. (John Arbash Meinel, #402778, #412198)
42
  parents was a ghost. (John Arbash Meinel, #402778, #412198)
23
34
43
29
35
* Fetching from 2a branches from a version-2 bzr protocol would fail to
44
* ``RemoteStreamSource.get_stream_for_missing_keys`` will fetch CHK
30
36
  copy the internal inventory pages from the CHK store. This cannot happen
45
  inventory pages when appropriate (by falling back to the vfs stream
31
37
  in normal use as all 2a compatible clients and servers support the
46
  source).  (Andrew Bennetts, #406686)
32
38
  version-3 protocol, but it does cause test suite failures when testing
47
33
39
  downlevel protocol behaviour. (Robert Collins)
48
* StreamSource generates rich roots from non-rich root sources correctly
34
49
  now.  (Andrew Bennetts, #368921)
35
40
50
36
41
Improvements
51
Improvements
37
42
************
52
************
38
43
53
39
54
* Cross-format fetches (such as between 1.9-rich-root and 2a) via the
40
55
  smart server are more efficient now.  They send inventory deltas rather
41
56
  than full inventories.  The smart server has two new requests,
42
57
  ``Repository.get_stream_1.19`` and ``Repository.insert_stream_1.19`` to
43
58
  support this.  (Andrew Bennetts, #374738, #385826)
44
59
45
44
Documentation
60
Documentation
46
45
*************
61
*************
47
46
62
48
@@ -50,6 +66,11 @@
49
50
Internals
66
Internals
50
51
*********
67
*********
51
52
68
52
69
* InterDifferingSerializer is now only used locally.  Other fetches that
53
70
  would have used InterDifferingSerializer now use the more network
54
71
  friendly StreamSource, which now automatically does the same
55
72
  transformations as InterDifferingSerializer.  (Andrew Bennetts)
56
73
57
53
* RemoteBranch.open now honours ignore_fallbacks correctly on bzr-v2
74
* RemoteBranch.open now honours ignore_fallbacks correctly on bzr-v2
58
54
  protocols. (Robert Collins)
75
  protocols. (Robert Collins)
59
55
76
60
56
77
61
=== modified file 'bzrlib/fetch.py'
62
--- bzrlib/fetch.py	2009-07-09 08:59:51 +0000
63
+++ bzrlib/fetch.py	2009-08-14 05:35:32 +0000
64
@@ -25,16 +25,21 @@
65
25
25
66
26
import operator
26
import operator
67
27
27
68
28
from bzrlib.lazy_import import lazy_import
69
29
lazy_import(globals(), """
70
30
from bzrlib import (
71
31
    tsort,
72
32
    versionedfile,
73
33
    )
74
34
""")
75
28
import bzrlib
35
import bzrlib
76
29
from bzrlib import (
36
from bzrlib import (
77
30
    errors,
37
    errors,
78
31
    symbol_versioning,
38
    symbol_versioning,
79
32
    )
39
    )
80
33
from bzrlib.revision import NULL_REVISION
40
from bzrlib.revision import NULL_REVISION
81
34
from bzrlib.tsort import topo_sort
82
35
from bzrlib.trace import mutter
41
from bzrlib.trace import mutter
83
36
import bzrlib.ui
42
import bzrlib.ui
84
37
from bzrlib.versionedfile import FulltextContentFactory
85
38
43
86
39
44
87
40
class RepoFetcher(object):
45
class RepoFetcher(object):
88
@@ -213,11 +218,9 @@
89
213
218
90
214
    def _find_root_ids(self, revs, parent_map, graph):
219
    def _find_root_ids(self, revs, parent_map, graph):
91
215
        revision_root = {}
220
        revision_root = {}
92
216
        planned_versions = {}
93
217
        for tree in self.iter_rev_trees(revs):
221
        for tree in self.iter_rev_trees(revs):
94
218
            revision_id = tree.inventory.root.revision
222
            revision_id = tree.inventory.root.revision
95
219
            root_id = tree.get_root_id()
223
            root_id = tree.get_root_id()
96
220
            planned_versions.setdefault(root_id, []).append(revision_id)
97
221
            revision_root[revision_id] = root_id
224
            revision_root[revision_id] = root_id
98
222
        # Find out which parents we don't already know root ids for
225
        # Find out which parents we don't already know root ids for
99
223
        parents = set()
226
        parents = set()
100
@@ -229,7 +232,7 @@
101
229
        for tree in self.iter_rev_trees(parents):
232
        for tree in self.iter_rev_trees(parents):
102
230
            root_id = tree.get_root_id()
233
            root_id = tree.get_root_id()
103
231
            revision_root[tree.get_revision_id()] = root_id
234
            revision_root[tree.get_revision_id()] = root_id
105
232
        return revision_root, planned_versions
235
        return revision_root
106
233
236
107
234
    def generate_root_texts(self, revs):
237
    def generate_root_texts(self, revs):
108
235
        """Generate VersionedFiles for all root ids.
238
        """Generate VersionedFiles for all root ids.
109
@@ -238,9 +241,8 @@
110
238
        """
241
        """
111
239
        graph = self.source.get_graph()
242
        graph = self.source.get_graph()
112
240
        parent_map = graph.get_parent_map(revs)
243
        parent_map = graph.get_parent_map(revs)
116
241
        rev_order = topo_sort(parent_map)
244
        rev_order = tsort.topo_sort(parent_map)
117
242
        rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
245
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
115
243
            revs, parent_map, graph)
118
244
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
246
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
119
245
            rev_order]
247
            rev_order]
120
246
        # Guaranteed stable, this groups all the file id operations together
248
        # Guaranteed stable, this groups all the file id operations together
121
@@ -249,20 +251,93 @@
122
249
        # yet, and are unlikely to in non-rich-root environments anyway.
251
        # yet, and are unlikely to in non-rich-root environments anyway.
123
250
        root_id_order.sort(key=operator.itemgetter(0))
252
        root_id_order.sort(key=operator.itemgetter(0))
124
251
        # Create a record stream containing the roots to create.
253
        # Create a record stream containing the roots to create.
142
252
        def yield_roots():
254
        from bzrlib.graph import FrozenHeadsCache
143
253
            for key in root_id_order:
255
        graph = FrozenHeadsCache(graph)
144
254
                root_id, rev_id = key
256
        new_roots_stream = _new_root_data_stream(
145
255
                rev_parents = parent_map[rev_id]
257
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
146
256
                # We drop revision parents with different file-ids, because
258
        return [('texts', new_roots_stream)]
147
257
                # that represents a rename of the root to a different location
259
148
258
                # - its not actually a parent for us. (We could look for that
260
149
259
                # file id in the revision tree at considerably more expense,
261
def _new_root_data_stream(
150
260
                # but for now this is sufficient (and reconcile will catch and
262
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
151
261
                # correct this anyway).
263
    """Generate a texts substream of synthesised root entries.
152
262
                # When a parent revision is a ghost, we guess that its root id
264
153
263
                # was unchanged (rather than trimming it from the parent list).
265
    Used in fetches that do rich-root upgrades.
154
264
                parent_keys = tuple((root_id, parent) for parent in rev_parents
266
    
155
265
                    if parent != NULL_REVISION and
267
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
156
266
                        rev_id_to_root_id.get(parent, root_id) == root_id)
268
        the root entries to create.
157
267
                yield FulltextContentFactory(key, parent_keys, None, '')
269
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
158
268
        return [('texts', yield_roots())]
270
        calculating the parents.  If a parent rev_id is not found here then it
159
271
        will be recalculated.
160
272
    :param parent_map: a parent map for all the revisions in
161
273
        root_keys_to_create.
162
274
    :param graph: a graph to use instead of repo.get_graph().
163
275
    """
164
276
    for root_key in root_keys_to_create:
165
277
        root_id, rev_id = root_key
166
278
        parent_keys = _parent_keys_for_root_version(
167
279
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
168
280
        yield versionedfile.FulltextContentFactory(
169
281
            root_key, parent_keys, None, '')
170
282
171
283
172
284
def _parent_keys_for_root_version(
173
285
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
174
286
    """Get the parent keys for a given root id.
175
287
    
176
288
    A helper function for _new_root_data_stream.
177
289
    """
178
290
    # Include direct parents of the revision, but only if they used the same
179
291
    # root_id and are heads.
180
292
    rev_parents = parent_map[rev_id]
181
293
    parent_ids = []
182
294
    for parent_id in rev_parents:
183
295
        if parent_id == NULL_REVISION:
184
296
            continue
185
297
        if parent_id not in rev_id_to_root_id_map:
186
298
            # We probably didn't read this revision, go spend the extra effort
187
299
            # to actually check
188
300
            try:
189
301
                tree = repo.revision_tree(parent_id)
190
302
            except errors.NoSuchRevision:
191
303
                # Ghost, fill out rev_id_to_root_id in case we encounter this
192
304
                # again.
193
305
                # But set parent_root_id to None since we don't really know
194
306
                parent_root_id = None
195
307
            else:
196
308
                parent_root_id = tree.get_root_id()
197
309
            rev_id_to_root_id_map[parent_id] = None
198
310
            # XXX: why not:
199
311
            #   rev_id_to_root_id_map[parent_id] = parent_root_id
200
312
            # memory consumption maybe?
201
313
        else:
202
314
            parent_root_id = rev_id_to_root_id_map[parent_id]
203
315
        if root_id == parent_root_id:
204
316
            # With stacking we _might_ want to refer to a non-local revision,
205
317
            # but this code path only applies when we have the full content
206
318
            # available, so ghosts really are ghosts, not just the edge of
207
319
            # local data.
208
320
            parent_ids.append(parent_id)
209
321
        else:
210
322
            # root_id may be in the parent anyway.
211
323
            try:
212
324
                tree = repo.revision_tree(parent_id)
213
325
            except errors.NoSuchRevision:
214
326
                # ghost, can't refer to it.
215
327
                pass
216
328
            else:
217
329
                try:
218
330
                    parent_ids.append(tree.inventory[root_id].revision)
219
331
                except errors.NoSuchId:
220
332
                    # not in the tree
221
333
                    pass
222
334
    # Drop non-head parents
223
335
    if graph is None:
224
336
        graph = repo.get_graph()
225
337
    heads = graph.heads(parent_ids)
226
338
    selected_ids = []
227
339
    for parent_id in parent_ids:
228
340
        if parent_id in heads and parent_id not in selected_ids:
229
341
            selected_ids.append(parent_id)
230
342
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
231
343
    return parent_keys
232
269
344
233
=== modified file 'bzrlib/help_topics/en/debug-flags.txt'
234
--- bzrlib/help_topics/en/debug-flags.txt	2009-08-04 04:36:34 +0000
235
+++ bzrlib/help_topics/en/debug-flags.txt	2009-08-14 05:35:32 +0000
236
@@ -12,6 +12,7 @@
237
12
                  operations.
12
                  operations.
238
13
-Dfetch           Trace history copying between repositories.
13
-Dfetch           Trace history copying between repositories.
239
14
-Dfilters         Emit information for debugging content filtering.
14
-Dfilters         Emit information for debugging content filtering.
240
15
-Dforceinvdeltas  Force use of inventory deltas during generic streaming fetch.
241
15
-Dgraph           Trace graph traversal.
16
-Dgraph           Trace graph traversal.
242
16
-Dhashcache       Log every time a working file is read to determine its hash.
17
-Dhashcache       Log every time a working file is read to determine its hash.
243
17
-Dhooks           Trace hook execution.
18
-Dhooks           Trace hook execution.
244
@@ -27,3 +28,7 @@
245
27
-Dunlock          Some errors during unlock are treated as warnings.
28
-Dunlock          Some errors during unlock are treated as warnings.
246
28
-Dpack            Emit information about pack operations.
29
-Dpack            Emit information about pack operations.
247
29
-Dsftp            Trace SFTP internals.
30
-Dsftp            Trace SFTP internals.
248
31
-Dstream          Trace fetch streams.
249
32
-DIDS_never       Never use InterDifferingSerializer when fetching.
250
33
-DIDS_always      Always use InterDifferingSerializer to fetch if appropriate
251
34
                  for the format, even for non-local fetches.
252
30
35
253
=== modified file 'bzrlib/inventory_delta.py'
254
--- bzrlib/inventory_delta.py	2009-04-02 05:53:12 +0000
255
+++ bzrlib/inventory_delta.py	2009-08-14 05:35:32 +0000
256
@@ -29,6 +29,25 @@
257
29
from bzrlib import inventory
29
from bzrlib import inventory
258
30
from bzrlib.revision import NULL_REVISION
30
from bzrlib.revision import NULL_REVISION
259
31
31
260
32
FORMAT_1 = 'bzr inventory delta v1 (bzr 1.14)'
261
33
262
34
263
35
class InventoryDeltaError(errors.BzrError):
264
36
    """An error when serializing or deserializing an inventory delta."""
265
37
    
266
38
    # Most errors when serializing and deserializing are due to bugs, although
267
39
    # damaged input (i.e. a bug in a different process) could cause
268
40
    # deserialization errors too.
269
41
    internal_error = True
270
42
271
43
272
44
class IncompatibleInventoryDelta(errors.BzrError):
273
45
    """The delta could not be deserialised because its contents conflict with
274
46
    the allow_versioned_root or allow_tree_references flags of the
275
47
    deserializer.
276
48
    """
277
49
    internal_error = False
278
50
279
32
51
280
33
def _directory_content(entry):
52
def _directory_content(entry):
281
34
    """Serialize the content component of entry which is a directory.
53
    """Serialize the content component of entry which is a directory.
282
@@ -49,7 +68,7 @@
283
49
        exec_bytes = ''
68
        exec_bytes = ''
284
50
    size_exec_sha = (entry.text_size, exec_bytes, entry.text_sha1)
69
    size_exec_sha = (entry.text_size, exec_bytes, entry.text_sha1)
285
51
    if None in size_exec_sha:
70
    if None in size_exec_sha:
287
52
        raise errors.BzrError('Missing size or sha for %s' % entry.file_id)
71
        raise InventoryDeltaError('Missing size or sha for %s' % entry.file_id)
288
53
    return "file\x00%d\x00%s\x00%s" % size_exec_sha
72
    return "file\x00%d\x00%s\x00%s" % size_exec_sha
289
54
73
290
55
74
291
@@ -60,7 +79,7 @@
292
60
    """
79
    """
293
61
    target = entry.symlink_target
80
    target = entry.symlink_target
294
62
    if target is None:
81
    if target is None:
296
63
        raise errors.BzrError('Missing target for %s' % entry.file_id)
82
        raise InventoryDeltaError('Missing target for %s' % entry.file_id)
297
64
    return "link\x00%s" % target.encode('utf8')
83
    return "link\x00%s" % target.encode('utf8')
298
65
84
299
66
85
300
@@ -71,7 +90,8 @@
301
71
    """
90
    """
302
72
    tree_revision = entry.reference_revision
91
    tree_revision = entry.reference_revision
303
73
    if tree_revision is None:
92
    if tree_revision is None:
305
74
        raise errors.BzrError('Missing reference revision for %s' % entry.file_id)
93
        raise InventoryDeltaError(
306
94
            'Missing reference revision for %s' % entry.file_id)
307
75
    return "tree\x00%s" % tree_revision
95
    return "tree\x00%s" % tree_revision
308
76
96
309
77
97
310
@@ -115,11 +135,8 @@
311
115
    return result
135
    return result
312
116
136
313
117
137
314
118
315
119
class InventoryDeltaSerializer(object):
138
class InventoryDeltaSerializer(object):
319
120
    """Serialize and deserialize inventory deltas."""
139
    """Serialize inventory deltas."""
317
121
318
122
    FORMAT_1 = 'bzr inventory delta v1 (bzr 1.14)'
320
123
140
321
124
    def __init__(self, versioned_root, tree_references):
141
    def __init__(self, versioned_root, tree_references):
322
125
        """Create an InventoryDeltaSerializer.
142
        """Create an InventoryDeltaSerializer.
323
@@ -141,6 +158,9 @@
324
141
    def delta_to_lines(self, old_name, new_name, delta_to_new):
158
    def delta_to_lines(self, old_name, new_name, delta_to_new):
325
142
        """Return a line sequence for delta_to_new.
159
        """Return a line sequence for delta_to_new.
326
143
160
327
161
        Both the versioned_root and tree_references flags must be set via
328
162
        require_flags before calling this.
329
163
330
144
        :param old_name: A UTF8 revision id for the old inventory.  May be
164
        :param old_name: A UTF8 revision id for the old inventory.  May be
331
145
            NULL_REVISION if there is no older inventory and delta_to_new
165
            NULL_REVISION if there is no older inventory and delta_to_new
332
146
            includes the entire inventory contents.
166
            includes the entire inventory contents.
333
@@ -150,15 +170,20 @@
334
150
            takes.
170
            takes.
335
151
        :return: The serialized delta as lines.
171
        :return: The serialized delta as lines.
336
152
        """
172
        """
337
173
        if type(old_name) is not str:
338
174
            raise TypeError('old_name should be str, got %r' % (old_name,))
339
175
        if type(new_name) is not str:
340
176
            raise TypeError('new_name should be str, got %r' % (new_name,))
341
153
        lines = ['', '', '', '', '']
177
        lines = ['', '', '', '', '']
342
154
        to_line = self._delta_item_to_line
178
        to_line = self._delta_item_to_line
343
155
        for delta_item in delta_to_new:
179
        for delta_item in delta_to_new:
347
156
            lines.append(to_line(delta_item))
180
            line = to_line(delta_item, new_name)
348
157
            if lines[-1].__class__ != str:
181
            if line.__class__ != str:
349
158
                raise errors.BzrError(
182
                raise InventoryDeltaError(
350
159
                    'to_line generated non-str output %r' % lines[-1])
183
                    'to_line generated non-str output %r' % lines[-1])
351
184
            lines.append(line)
352
160
        lines.sort()
185
        lines.sort()
354
161
        lines[0] = "format: %s\n" % InventoryDeltaSerializer.FORMAT_1
186
        lines[0] = "format: %s\n" % FORMAT_1
355
162
        lines[1] = "parent: %s\n" % old_name
187
        lines[1] = "parent: %s\n" % old_name
356
163
        lines[2] = "version: %s\n" % new_name
188
        lines[2] = "version: %s\n" % new_name
357
164
        lines[3] = "versioned_root: %s\n" % self._serialize_bool(
189
        lines[3] = "versioned_root: %s\n" % self._serialize_bool(
358
@@ -173,7 +198,7 @@
359
173
        else:
198
        else:
360
174
            return "false"
199
            return "false"
361
175
200
363
176
    def _delta_item_to_line(self, delta_item):
201
    def _delta_item_to_line(self, delta_item, new_version):
364
177
        """Convert delta_item to a line."""
202
        """Convert delta_item to a line."""
365
178
        oldpath, newpath, file_id, entry = delta_item
203
        oldpath, newpath, file_id, entry = delta_item
366
179
        if newpath is None:
204
        if newpath is None:
367
@@ -188,6 +213,10 @@
368
188
                oldpath_utf8 = 'None'
213
                oldpath_utf8 = 'None'
369
189
            else:
214
            else:
370
190
                oldpath_utf8 = '/' + oldpath.encode('utf8')
215
                oldpath_utf8 = '/' + oldpath.encode('utf8')
371
216
            if newpath == '/':
372
217
                raise AssertionError(
373
218
                    "Bad inventory delta: '/' is not a valid newpath "
374
219
                    "(should be '') in delta item %r" % (delta_item,))
375
191
            # TODO: Test real-world utf8 cache hit rate. It may be a win.
220
            # TODO: Test real-world utf8 cache hit rate. It may be a win.
376
192
            newpath_utf8 = '/' + newpath.encode('utf8')
221
            newpath_utf8 = '/' + newpath.encode('utf8')
377
193
            # Serialize None as ''
222
            # Serialize None as ''
378
@@ -196,58 +225,78 @@
379
196
            last_modified = entry.revision
225
            last_modified = entry.revision
380
197
            # special cases for /
226
            # special cases for /
381
198
            if newpath_utf8 == '/' and not self._versioned_root:
227
            if newpath_utf8 == '/' and not self._versioned_root:
389
199
                if file_id != 'TREE_ROOT':
228
                # This is an entry for the root, this inventory does not
390
200
                    raise errors.BzrError(
229
                # support versioned roots.  So this must be an unversioned
391
201
                        'file_id %s is not TREE_ROOT for /' % file_id)
230
                # root, i.e. last_modified == new revision.  Otherwise, this
392
202
                if last_modified is not None:
231
                # delta is invalid.
393
203
                    raise errors.BzrError(
232
                # Note: the non-rich-root repositories *can* have roots with
394
204
                        'Version present for / in %s' % file_id)
233
                # file-ids other than TREE_ROOT, e.g. repo formats that use the
395
205
                last_modified = NULL_REVISION
234
                # xml5 serializer.
396
235
                if last_modified != new_version:
397
236
                    raise InventoryDeltaError(
398
237
                        'Version present for / in %s (%s != %s)'
399
238
                        % (file_id, last_modified, new_version))
400
206
            if last_modified is None:
239
            if last_modified is None:
402
207
                raise errors.BzrError("no version for fileid %s" % file_id)
240
                raise InventoryDeltaError("no version for fileid %s" % file_id)
403
208
            content = self._entry_to_content[entry.kind](entry)
241
            content = self._entry_to_content[entry.kind](entry)
404
209
        return ("%s\x00%s\x00%s\x00%s\x00%s\x00%s\n" %
242
        return ("%s\x00%s\x00%s\x00%s\x00%s\x00%s\n" %
405
210
            (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
243
            (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
406
211
                content))
244
                content))
407
212
245
408
246
409
247
class InventoryDeltaDeserializer(object):
410
248
    """Deserialize inventory deltas."""
411
249
412
250
    def __init__(self, allow_versioned_root=True, allow_tree_references=True):
413
251
        """Create an InventoryDeltaDeserializer.
414
252
415
253
        :param versioned_root: If True, any root entry that is seen is expected
416
254
            to be versioned, and root entries can have any fileid.
417
255
        :param tree_references: If True support tree-reference entries.
418
256
        """
419
257
        self._allow_versioned_root = allow_versioned_root
420
258
        self._allow_tree_references = allow_tree_references
421
259
422
213
    def _deserialize_bool(self, value):
260
    def _deserialize_bool(self, value):
423
214
        if value == "true":
261
        if value == "true":
424
215
            return True
262
            return True
425
216
        elif value == "false":
263
        elif value == "false":
426
217
            return False
264
            return False
427
218
        else:
265
        else:
429
219
            raise errors.BzrError("value %r is not a bool" % (value,))
266
            raise InventoryDeltaError("value %r is not a bool" % (value,))
430
220
267
431
221
    def parse_text_bytes(self, bytes):
268
    def parse_text_bytes(self, bytes):
432
222
        """Parse the text bytes of a serialized inventory delta.
269
        """Parse the text bytes of a serialized inventory delta.
433
223
270
434
271
        If versioned_root and/or tree_references flags were set via
435
272
        require_flags, then the parsed flags must match or a BzrError will be
436
273
        raised.
437
274
438
224
        :param bytes: The bytes to parse. This can be obtained by calling
275
        :param bytes: The bytes to parse. This can be obtained by calling
439
225
            delta_to_lines and then doing ''.join(delta_lines).
276
            delta_to_lines and then doing ''.join(delta_lines).
441
226
        :return: (parent_id, new_id, inventory_delta)
277
        :return: (parent_id, new_id, versioned_root, tree_references,
442
278
            inventory_delta)
443
227
        """
279
        """
444
280
        if bytes[-1:] != '\n':
445
281
            last_line = bytes.rsplit('\n', 1)[-1]
446
282
            raise InventoryDeltaError('last line not empty: %r' % (last_line,))
447
228
        lines = bytes.split('\n')[:-1] # discard the last empty line
283
        lines = bytes.split('\n')[:-1] # discard the last empty line
450
229
        if not lines or lines[0] != 'format: %s' % InventoryDeltaSerializer.FORMAT_1:
284
        if not lines or lines[0] != 'format: %s' % FORMAT_1:
451
230
            raise errors.BzrError('unknown format %r' % lines[0:1])
285
            raise InventoryDeltaError('unknown format %r' % lines[0:1])
452
231
        if len(lines) < 2 or not lines[1].startswith('parent: '):
286
        if len(lines) < 2 or not lines[1].startswith('parent: '):
454
232
            raise errors.BzrError('missing parent: marker')
287
            raise InventoryDeltaError('missing parent: marker')
455
233
        delta_parent_id = lines[1][8:]
288
        delta_parent_id = lines[1][8:]
456
234
        if len(lines) < 3 or not lines[2].startswith('version: '):
289
        if len(lines) < 3 or not lines[2].startswith('version: '):
458
235
            raise errors.BzrError('missing version: marker')
290
            raise InventoryDeltaError('missing version: marker')
459
236
        delta_version_id = lines[2][9:]
291
        delta_version_id = lines[2][9:]
460
237
        if len(lines) < 4 or not lines[3].startswith('versioned_root: '):
292
        if len(lines) < 4 or not lines[3].startswith('versioned_root: '):
462
238
            raise errors.BzrError('missing versioned_root: marker')
293
            raise InventoryDeltaError('missing versioned_root: marker')
463
239
        delta_versioned_root = self._deserialize_bool(lines[3][16:])
294
        delta_versioned_root = self._deserialize_bool(lines[3][16:])
464
240
        if len(lines) < 5 or not lines[4].startswith('tree_references: '):
295
        if len(lines) < 5 or not lines[4].startswith('tree_references: '):
466
241
            raise errors.BzrError('missing tree_references: marker')
296
            raise InventoryDeltaError('missing tree_references: marker')
467
242
        delta_tree_references = self._deserialize_bool(lines[4][17:])
297
        delta_tree_references = self._deserialize_bool(lines[4][17:])
476
243
        if delta_versioned_root != self._versioned_root:
298
        if (not self._allow_versioned_root and delta_versioned_root):
477
244
            raise errors.BzrError(
299
            raise IncompatibleInventoryDelta("versioned_root not allowed")
470
245
                "serialized versioned_root flag is wrong: %s" %
471
246
                (delta_versioned_root,))
472
247
        if delta_tree_references != self._tree_references:
473
248
            raise errors.BzrError(
474
249
                "serialized tree_references flag is wrong: %s" %
475
250
                (delta_tree_references,))
478
251
        result = []
300
        result = []
479
252
        seen_ids = set()
301
        seen_ids = set()
480
253
        line_iter = iter(lines)
302
        line_iter = iter(lines)
481
@@ -258,33 +307,58 @@
482
258
                content) = line.split('\x00', 5)
307
                content) = line.split('\x00', 5)
483
259
            parent_id = parent_id or None
308
            parent_id = parent_id or None
484
260
            if file_id in seen_ids:
309
            if file_id in seen_ids:
486
261
                raise errors.BzrError(
310
                raise InventoryDeltaError(
487
262
                    "duplicate file id in inventory delta %r" % lines)
311
                    "duplicate file id in inventory delta %r" % lines)
488
263
            seen_ids.add(file_id)
312
            seen_ids.add(file_id)
499
264
            if newpath_utf8 == '/' and not delta_versioned_root and (
313
            if (newpath_utf8 == '/' and not delta_versioned_root and
500
265
                last_modified != 'null:' or file_id != 'TREE_ROOT'):
314
                last_modified != delta_version_id):
501
266
                    raise errors.BzrError("Versioned root found: %r" % line)
315
                    # Delta claims to be not have a versioned root, yet here's
502
267
            elif last_modified[-1] == ':':
316
                    # a root entry with a non-default version.
503
268
                    raise errors.BzrError('special revisionid found: %r' % line)
317
                    raise InventoryDeltaError("Versioned root found: %r" % line)
504
269
            if not delta_tree_references and content.startswith('tree\x00'):
318
            elif newpath_utf8 != 'None' and last_modified[-1] == ':':
505
270
                raise errors.BzrError("Tree reference found: %r" % line)
319
                # Deletes have a last_modified of null:, but otherwise special
506
271
            content_tuple = tuple(content.split('\x00'))
320
                # revision ids should not occur.
507
272
            entry = _parse_entry(
321
                raise InventoryDeltaError('special revisionid found: %r' % line)
508
273
                newpath_utf8, file_id, parent_id, last_modified, content_tuple)
322
            if content.startswith('tree\x00'):
509
323
                if delta_tree_references is False:
510
324
                    raise InventoryDeltaError(
511
325
                            "Tree reference found (but header said "
512
326
                            "tree_references: false): %r" % line)
513
327
                elif not self._allow_tree_references:
514
328
                    raise IncompatibleInventoryDelta(
515
329
                        "Tree reference not allowed")
516
274
            if oldpath_utf8 == 'None':
330
            if oldpath_utf8 == 'None':
517
275
                oldpath = None
331
                oldpath = None
518
332
            elif oldpath_utf8[:1] != '/':
519
333
                raise InventoryDeltaError(
520
334
                    "oldpath invalid (does not start with /): %r"
521
335
                    % (oldpath_utf8,))
522
276
            else:
336
            else:
523
337
                oldpath_utf8 = oldpath_utf8[1:]
524
277
                oldpath = oldpath_utf8.decode('utf8')
338
                oldpath = oldpath_utf8.decode('utf8')
525
278
            if newpath_utf8 == 'None':
339
            if newpath_utf8 == 'None':
526
279
                newpath = None
340
                newpath = None
527
341
            elif newpath_utf8[:1] != '/':
528
342
                raise InventoryDeltaError(
529
343
                    "newpath invalid (does not start with /): %r"
530
344
                    % (newpath_utf8,))
531
280
            else:
345
            else:
532
346
                # Trim leading slash
533
347
                newpath_utf8 = newpath_utf8[1:]
534
281
                newpath = newpath_utf8.decode('utf8')
348
                newpath = newpath_utf8.decode('utf8')
535
349
            content_tuple = tuple(content.split('\x00'))
536
350
            if content_tuple[0] == 'deleted':
537
351
                entry = None
538
352
            else:
539
353
                entry = _parse_entry(
540
354
                    newpath, file_id, parent_id, last_modified, content_tuple)
541
282
            delta_item = (oldpath, newpath, file_id, entry)
355
            delta_item = (oldpath, newpath, file_id, entry)
542
283
            result.append(delta_item)
356
            result.append(delta_item)
547
284
        return delta_parent_id, delta_version_id, result
357
        return (delta_parent_id, delta_version_id, delta_versioned_root,
548
285
358
                delta_tree_references, result)
549
286
359
550
287
def _parse_entry(utf8_path, file_id, parent_id, last_modified, content):
360
551
361
def _parse_entry(path, file_id, parent_id, last_modified, content):
552
288
    entry_factory = {
362
    entry_factory = {
553
289
        'dir': _dir_to_entry,
363
        'dir': _dir_to_entry,
554
290
        'file': _file_to_entry,
364
        'file': _file_to_entry,
555
@@ -292,8 +366,10 @@
556
292
        'tree': _tree_to_entry,
366
        'tree': _tree_to_entry,
557
293
    }
367
    }
558
294
    kind = content[0]
368
    kind = content[0]
560
295
    path = utf8_path[1:].decode('utf8')
369
    if path.startswith('/'):
561
370
        raise AssertionError
562
296
    name = basename(path)
371
    name = basename(path)
563
297
    return entry_factory[content[0]](
372
    return entry_factory[content[0]](
564
298
            content, name, parent_id, file_id, last_modified)
373
            content, name, parent_id, file_id, last_modified)
565
299
374
566
375
567
300
376
568
=== modified file 'bzrlib/remote.py'
569
--- bzrlib/remote.py	2009-08-13 22:32:23 +0000
570
+++ bzrlib/remote.py	2009-08-14 05:35:32 +0000
571
@@ -426,6 +426,7 @@
572
426
        self._custom_format = None
426
        self._custom_format = None
573
427
        self._network_name = None
427
        self._network_name = None
574
428
        self._creating_bzrdir = None
428
        self._creating_bzrdir = None
575
429
        self._supports_chks = None
576
429
        self._supports_external_lookups = None
430
        self._supports_external_lookups = None
577
430
        self._supports_tree_reference = None
431
        self._supports_tree_reference = None
578
431
        self._rich_root_data = None
432
        self._rich_root_data = None
579
@@ -443,6 +444,13 @@
580
443
        return self._rich_root_data
444
        return self._rich_root_data
581
444
445
582
445
    @property
446
    @property
583
447
    def supports_chks(self):
584
448
        if self._supports_chks is None:
585
449
            self._ensure_real()
586
450
            self._supports_chks = self._custom_format.supports_chks
587
451
        return self._supports_chks
588
452
589
453
    @property
590
446
    def supports_external_lookups(self):
454
    def supports_external_lookups(self):
591
447
        if self._supports_external_lookups is None:
455
        if self._supports_external_lookups is None:
592
448
            self._ensure_real()
456
            self._ensure_real()
593
@@ -1178,9 +1186,9 @@
594
1178
        self._ensure_real()
1186
        self._ensure_real()
595
1179
        return self._real_repository.get_inventory(revision_id)
1187
        return self._real_repository.get_inventory(revision_id)
596
1180
1188
598
1181
    def iter_inventories(self, revision_ids):
1189
    def iter_inventories(self, revision_ids, ordering=None):
599
1182
        self._ensure_real()
1190
        self._ensure_real()
601
1183
        return self._real_repository.iter_inventories(revision_ids)
1191
        return self._real_repository.iter_inventories(revision_ids, ordering)
602
1184
1192
603
1185
    @needs_read_lock
1193
    @needs_read_lock
604
1186
    def get_revision(self, revision_id):
1194
    def get_revision(self, revision_id):
605
@@ -1682,43 +1690,61 @@
606
1682
    def insert_stream(self, stream, src_format, resume_tokens):
1690
    def insert_stream(self, stream, src_format, resume_tokens):
607
1683
        target = self.target_repo
1691
        target = self.target_repo
608
1684
        target._unstacked_provider.missing_keys.clear()
1692
        target._unstacked_provider.missing_keys.clear()
609
1693
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
610
1685
        if target._lock_token:
1694
        if target._lock_token:
614
1686
            verb = 'Repository.insert_stream_locked'
1695
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
615
1687
            extra_args = (target._lock_token or '',)
1696
            lock_args = (target._lock_token or '',)
613
1688
            required_version = (1, 14)
616
1689
        else:
1697
        else:
620
1690
            verb = 'Repository.insert_stream'
1698
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
621
1691
            extra_args = ()
1699
            lock_args = ()
619
1692
            required_version = (1, 13)
622
1693
        client = target._client
1700
        client = target._client
623
1694
        medium = client._medium
1701
        medium = client._medium
624
1695
        if medium._is_remote_before(required_version):
625
1696
            # No possible way this can work.
626
1697
            return self._insert_real(stream, src_format, resume_tokens)
627
1698
        path = target.bzrdir._path_for_remote_call(client)
1702
        path = target.bzrdir._path_for_remote_call(client)
637
1699
        if not resume_tokens:
1703
        # Probe for the verb to use with an empty stream before sending the
638
1700
            # XXX: Ugly but important for correctness, *will* be fixed during
1704
        # real stream to it.  We do this both to avoid the risk of sending a
639
1701
            # 1.13 cycle. Pushing a stream that is interrupted results in a
1705
        # large request that is then rejected, and because we don't want to
640
1702
            # fallback to the _real_repositories sink *with a partial stream*.
1706
        # implement a way to buffer, rewind, or restart the stream.
641
1703
            # Thats bad because we insert less data than bzr expected. To avoid
1707
        found_verb = False
642
1704
            # this we do a trial push to make sure the verb is accessible, and
1708
        for verb, required_version in candidate_calls:
643
1705
            # do not fallback when actually pushing the stream. A cleanup patch
1709
            if medium._is_remote_before(required_version):
644
1706
            # is going to look at rewinding/restarting the stream/partial
1710
                continue
645
1707
            # buffering etc.
1711
            if resume_tokens:
646
1712
                # We've already done the probing (and set _is_remote_before) on
647
1713
                # a previous insert.
648
1714
                found_verb = True
649
1715
                break
650
1708
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1716
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
651
1709
            try:
1717
            try:
652
1710
                response = client.call_with_body_stream(
1718
                response = client.call_with_body_stream(
654
1711
                    (verb, path, '') + extra_args, byte_stream)
1719
                    (verb, path, '') + lock_args, byte_stream)
655
1712
            except errors.UnknownSmartMethod:
1720
            except errors.UnknownSmartMethod:
656
1713
                medium._remember_remote_is_before(required_version)
1721
                medium._remember_remote_is_before(required_version)
658
1714
                return self._insert_real(stream, src_format, resume_tokens)
1722
            else:
659
1723
                found_verb = True
660
1724
                break
661
1725
        if not found_verb:
662
1726
            # Have to use VFS.
663
1727
            return self._insert_real(stream, src_format, resume_tokens)
664
1728
        self._last_inv_record = None
665
1729
        self._last_substream = None
666
1730
        if required_version < (1, 19):
667
1731
            # Remote side doesn't support inventory deltas.  Wrap the stream to
668
1732
            # make sure we don't send any.  If the stream contains inventory
669
1733
            # deltas we'll interrupt the smart insert_stream request and
670
1734
            # fallback to VFS.
671
1735
            stream = self._stop_stream_if_inventory_delta(stream)
672
1715
        byte_stream = smart_repo._stream_to_byte_stream(
1736
        byte_stream = smart_repo._stream_to_byte_stream(
673
1716
            stream, src_format)
1737
            stream, src_format)
674
1717
        resume_tokens = ' '.join(resume_tokens)
1738
        resume_tokens = ' '.join(resume_tokens)
675
1718
        response = client.call_with_body_stream(
1739
        response = client.call_with_body_stream(
677
1719
            (verb, path, resume_tokens) + extra_args, byte_stream)
1740
            (verb, path, resume_tokens) + lock_args, byte_stream)
678
1720
        if response[0][0] not in ('ok', 'missing-basis'):
1741
        if response[0][0] not in ('ok', 'missing-basis'):
679
1721
            raise errors.UnexpectedSmartServerResponse(response)
1742
            raise errors.UnexpectedSmartServerResponse(response)
680
1743
        if self._last_substream is not None:
681
1744
            # The stream included an inventory-delta record, but the remote
682
1745
            # side isn't new enough to support them.  So we need to send the
683
1746
            # rest of the stream via VFS.
684
1747
            return self._resume_stream_with_vfs(response, src_format)
685
1722
        if response[0][0] == 'missing-basis':
1748
        if response[0][0] == 'missing-basis':
686
1723
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1749
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
687
1724
            resume_tokens = tokens
1750
            resume_tokens = tokens
688
@@ -1727,6 +1753,46 @@
689
1727
            self.target_repo.refresh_data()
1753
            self.target_repo.refresh_data()
690
1728
            return [], set()
1754
            return [], set()
691
1729
1755
692
1756
    def _resume_stream_with_vfs(self, response, src_format):
693
1757
        """Resume sending a stream via VFS, first resending the record and
694
1758
        substream that couldn't be sent via an insert_stream verb.
695
1759
        """
696
1760
        if response[0][0] == 'missing-basis':
697
1761
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
698
1762
            # Ignore missing_keys, we haven't finished inserting yet
699
1763
        else:
700
1764
            tokens = []
701
1765
        def resume_substream():
702
1766
            # Yield the substream that was interrupted.
703
1767
            for record in self._last_substream:
704
1768
                yield record
705
1769
            self._last_substream = None
706
1770
        def resume_stream():
707
1771
            # Finish sending the interrupted substream
708
1772
            yield ('inventory-deltas', resume_substream())
709
1773
            # Then simply continue sending the rest of the stream.
710
1774
            for substream_kind, substream in self._last_stream:
711
1775
                yield substream_kind, substream
712
1776
        return self._insert_real(resume_stream(), src_format, tokens)
713
1777
714
1778
    def _stop_stream_if_inventory_delta(self, stream):
715
1779
        """Normally this just lets the original stream pass-through unchanged.
716
1780
717
1781
        However if any 'inventory-deltas' substream occurs it will stop
718
1782
        streaming, and store the interrupted substream and stream in
719
1783
        self._last_substream and self._last_stream so that the stream can be
720
1784
        resumed by _resume_stream_with_vfs.
721
1785
        """
722
1786
                    
723
1787
        stream_iter = iter(stream)
724
1788
        for substream_kind, substream in stream_iter:
725
1789
            if substream_kind == 'inventory-deltas':
726
1790
                self._last_substream = substream
727
1791
                self._last_stream = stream_iter
728
1792
                return
729
1793
            else:
730
1794
                yield substream_kind, substream
731
1795
            
732
1730
1796
733
1731
class RemoteStreamSource(repository.StreamSource):
1797
class RemoteStreamSource(repository.StreamSource):
734
1732
    """Stream data from a remote server."""
1798
    """Stream data from a remote server."""
735
@@ -1747,6 +1813,12 @@
736
1747
            sources.append(repo)
1813
            sources.append(repo)
737
1748
        return self.missing_parents_chain(search, sources)
1814
        return self.missing_parents_chain(search, sources)
738
1749
1815
739
1816
    def get_stream_for_missing_keys(self, missing_keys):
740
1817
        self.from_repository._ensure_real()
741
1818
        real_repo = self.from_repository._real_repository
742
1819
        real_source = real_repo._get_source(self.to_format)
743
1820
        return real_source.get_stream_for_missing_keys(missing_keys)
744
1821
745
1750
    def _real_stream(self, repo, search):
1822
    def _real_stream(self, repo, search):
746
1751
        """Get a stream for search from repo.
1823
        """Get a stream for search from repo.
747
1752
        
1824
        
748
@@ -1782,18 +1854,26 @@
749
1782
            return self._real_stream(repo, search)
1854
            return self._real_stream(repo, search)
750
1783
        client = repo._client
1855
        client = repo._client
751
1784
        medium = client._medium
1856
        medium = client._medium
752
1785
        if medium._is_remote_before((1, 13)):
753
1786
            # streaming was added in 1.13
754
1787
            return self._real_stream(repo, search)
755
1788
        path = repo.bzrdir._path_for_remote_call(client)
1857
        path = repo.bzrdir._path_for_remote_call(client)
764
1789
        try:
1858
        search_bytes = repo._serialise_search_result(search)
765
1790
            search_bytes = repo._serialise_search_result(search)
1859
        args = (path, self.to_format.network_name())
766
1791
            response = repo._call_with_body_bytes_expecting_body(
1860
        candidate_verbs = [
767
1792
                'Repository.get_stream',
1861
            ('Repository.get_stream_1.19', (1, 19)),
768
1793
                (path, self.to_format.network_name()), search_bytes)
1862
            ('Repository.get_stream', (1, 13))]
769
1794
            response_tuple, response_handler = response
1863
        found_verb = False
770
1795
        except errors.UnknownSmartMethod:
1864
        for verb, version in candidate_verbs:
771
1796
            medium._remember_remote_is_before((1,13))
1865
            if medium._is_remote_before(version):
772
1866
                continue
773
1867
            try:
774
1868
                response = repo._call_with_body_bytes_expecting_body(
775
1869
                    verb, args, search_bytes)
776
1870
            except errors.UnknownSmartMethod:
777
1871
                medium._remember_remote_is_before(version)
778
1872
            else:
779
1873
                response_tuple, response_handler = response
780
1874
                found_verb = True
781
1875
                break
782
1876
        if not found_verb:
783
1797
            return self._real_stream(repo, search)
1877
            return self._real_stream(repo, search)
784
1798
        if response_tuple[0] != 'ok':
1878
        if response_tuple[0] != 'ok':
785
1799
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1879
            raise errors.UnexpectedSmartServerResponse(response_tuple)
786
1800
1880
787
=== modified file 'bzrlib/repofmt/groupcompress_repo.py'
788
--- bzrlib/repofmt/groupcompress_repo.py	2009-08-12 18:58:05 +0000
789
+++ bzrlib/repofmt/groupcompress_repo.py	2009-08-14 05:35:32 +0000
790
@@ -154,6 +154,8 @@
791
154
        self._writer.begin()
154
        self._writer.begin()
792
155
        # what state is the pack in? (open, finished, aborted)
155
        # what state is the pack in? (open, finished, aborted)
793
156
        self._state = 'open'
156
        self._state = 'open'
794
157
        # no name until we finish writing the content
795
158
        self.name = None
796
157
159
797
158
    def _check_references(self):
160
    def _check_references(self):
798
159
        """Make sure our external references are present.
161
        """Make sure our external references are present.
799
@@ -477,6 +479,15 @@
800
477
        if not self._use_pack(self.new_pack):
479
        if not self._use_pack(self.new_pack):
801
478
            self.new_pack.abort()
480
            self.new_pack.abort()
802
479
            return None
481
            return None
803
482
        self.new_pack.finish_content()
804
483
        if len(self.packs) == 1:
805
484
            old_pack = self.packs[0]
806
485
            if old_pack.name == self.new_pack._hash.hexdigest():
807
486
                # The single old pack was already optimally packed.
808
487
                trace.mutter('single pack %s was already optimally packed',
809
488
                    old_pack.name)
810
489
                self.new_pack.abort()
811
490
                return None
812
480
        self.pb.update('finishing repack', 6, 7)
491
        self.pb.update('finishing repack', 6, 7)
813
481
        self.new_pack.finish()
492
        self.new_pack.finish()
814
482
        self._pack_collection.allocate(self.new_pack)
493
        self._pack_collection.allocate(self.new_pack)
815
@@ -591,7 +602,7 @@
816
591
            packer = GCCHKPacker(self, packs, '.autopack',
602
            packer = GCCHKPacker(self, packs, '.autopack',
817
592
                                 reload_func=reload_func)
603
                                 reload_func=reload_func)
818
593
            try:
604
            try:
820
594
                packer.pack()
605
                result = packer.pack()
821
595
            except errors.RetryWithNewPacks:
606
            except errors.RetryWithNewPacks:
822
596
                # An exception is propagating out of this context, make sure
607
                # An exception is propagating out of this context, make sure
823
597
                # this packer has cleaned up. Packer() doesn't set its new_pack
608
                # this packer has cleaned up. Packer() doesn't set its new_pack
824
@@ -600,6 +611,8 @@
825
600
                if packer.new_pack is not None:
611
                if packer.new_pack is not None:
826
601
                    packer.new_pack.abort()
612
                    packer.new_pack.abort()
827
602
                raise
613
                raise
828
614
            if result is None:
829
615
                return
830
603
            for pack in packs:
616
            for pack in packs:
831
604
                self._remove_pack_from_memory(pack)
617
                self._remove_pack_from_memory(pack)
832
605
        # record the newly available packs and stop advertising the old
618
        # record the newly available packs and stop advertising the old
833
@@ -781,10 +794,12 @@
834
781
        return inventory.CHKInventory.deserialise(self.chk_bytes, bytes,
794
        return inventory.CHKInventory.deserialise(self.chk_bytes, bytes,
835
782
            (revision_id,))
795
            (revision_id,))
836
783
796
838
784
    def _iter_inventories(self, revision_ids):
797
    def _iter_inventories(self, revision_ids, ordering):
839
785
        """Iterate over many inventory objects."""
798
        """Iterate over many inventory objects."""
840
799
        if ordering is None:
841
800
            ordering = 'unordered'
842
786
        keys = [(revision_id,) for revision_id in revision_ids]
801
        keys = [(revision_id,) for revision_id in revision_ids]
844
787
        stream = self.inventories.get_record_stream(keys, 'unordered', True)
802
        stream = self.inventories.get_record_stream(keys, ordering, True)
845
788
        texts = {}
803
        texts = {}
846
789
        for record in stream:
804
        for record in stream:
847
790
            if record.storage_kind != 'absent':
805
            if record.storage_kind != 'absent':
848
@@ -794,7 +809,7 @@
849
794
        for key in keys:
809
        for key in keys:
850
795
            yield inventory.CHKInventory.deserialise(self.chk_bytes, texts[key], key)
810
            yield inventory.CHKInventory.deserialise(self.chk_bytes, texts[key], key)
851
796
811
853
797
    def _iter_inventory_xmls(self, revision_ids):
812
    def _iter_inventory_xmls(self, revision_ids, ordering):
854
798
        # Without a native 'xml' inventory, this method doesn't make sense, so
813
        # Without a native 'xml' inventory, this method doesn't make sense, so
855
799
        # make it raise to trap naughty direct users.
814
        # make it raise to trap naughty direct users.
856
800
        raise NotImplementedError(self._iter_inventory_xmls)
815
        raise NotImplementedError(self._iter_inventory_xmls)
857
@@ -894,14 +909,11 @@
858
894
909
859
895
    def _get_source(self, to_format):
910
    def _get_source(self, to_format):
860
896
        """Return a source for streaming from this repository."""
911
        """Return a source for streaming from this repository."""
867
897
        if isinstance(to_format, remote.RemoteRepositoryFormat):
912
        if self._format._serializer == to_format._serializer:
862
898
            # Can't just check attributes on to_format with the current code,
863
899
            # work around this:
864
900
            to_format._ensure_real()
865
901
            to_format = to_format._custom_format
866
902
        if to_format.__class__ is self._format.__class__:
868
903
            # We must be exactly the same format, otherwise stuff like the chk
913
            # We must be exactly the same format, otherwise stuff like the chk
870
904
            # page layout might be different
914
            # page layout might be different.
871
915
            # Actually, this test is just slightly looser than exact so that
872
916
            # CHK2 <-> 2a transfers will work.
873
905
            return GroupCHKStreamSource(self, to_format)
917
            return GroupCHKStreamSource(self, to_format)
874
906
        return super(CHKInventoryRepository, self)._get_source(to_format)
918
        return super(CHKInventoryRepository, self)._get_source(to_format)
875
907
919
876
908
920
877
=== modified file 'bzrlib/repofmt/pack_repo.py'
878
--- bzrlib/repofmt/pack_repo.py	2009-08-05 01:05:58 +0000
879
+++ bzrlib/repofmt/pack_repo.py	2009-08-14 05:35:32 +0000
880
@@ -422,6 +422,8 @@
881
422
        self._writer.begin()
422
        self._writer.begin()
882
423
        # what state is the pack in? (open, finished, aborted)
423
        # what state is the pack in? (open, finished, aborted)
883
424
        self._state = 'open'
424
        self._state = 'open'
884
425
        # no name until we finish writing the content
885
426
        self.name = None
886
425
427
887
426
    def abort(self):
428
    def abort(self):
888
427
        """Cancel creating this pack."""
429
        """Cancel creating this pack."""
889
@@ -448,6 +450,14 @@
890
448
            self.signature_index.key_count() or
450
            self.signature_index.key_count() or
891
449
            (self.chk_index is not None and self.chk_index.key_count()))
451
            (self.chk_index is not None and self.chk_index.key_count()))
892
450
452
893
453
    def finish_content(self):
894
454
        if self.name is not None:
895
455
            return
896
456
        self._writer.end()
897
457
        if self._buffer[1]:
898
458
            self._write_data('', flush=True)
899
459
        self.name = self._hash.hexdigest()
900
460
901
451
    def finish(self, suspend=False):
461
    def finish(self, suspend=False):
902
452
        """Finish the new pack.
462
        """Finish the new pack.
903
453
463
904
@@ -459,10 +469,7 @@
905
459
         - stores the index size tuple for the pack in the index_sizes
469
         - stores the index size tuple for the pack in the index_sizes
906
460
           attribute.
470
           attribute.
907
461
        """
471
        """
912
462
        self._writer.end()
472
        self.finish_content()
909
463
        if self._buffer[1]:
910
464
            self._write_data('', flush=True)
911
465
        self.name = self._hash.hexdigest()
913
466
        if not suspend:
473
        if not suspend:
914
467
            self._check_references()
474
            self._check_references()
915
468
        # write indices
475
        # write indices
916
@@ -1567,7 +1574,9 @@
917
1567
        # determine which packs need changing
1574
        # determine which packs need changing
918
1568
        pack_operations = [[0, []]]
1575
        pack_operations = [[0, []]]
919
1569
        for pack in self.all_packs():
1576
        for pack in self.all_packs():
921
1570
            if not hint or pack.name in hint:
1577
            if hint is None or pack.name in hint:
922
1578
                # Either no hint was provided (so we are packing everything),
923
1579
                # or this pack was included in the hint.
924
1571
                pack_operations[-1][0] += pack.get_revision_count()
1580
                pack_operations[-1][0] += pack.get_revision_count()
925
1572
                pack_operations[-1][1].append(pack)
1581
                pack_operations[-1][1].append(pack)
926
1573
        self._execute_pack_operations(pack_operations, OptimisingPacker)
1582
        self._execute_pack_operations(pack_operations, OptimisingPacker)
927
@@ -2093,6 +2102,7 @@
928
2093
                # when autopack takes no steps, the names list is still
2102
                # when autopack takes no steps, the names list is still
929
2094
                # unsaved.
2103
                # unsaved.
930
2095
                return self._save_pack_names()
2104
                return self._save_pack_names()
931
2105
        return []
932
2096
2106
933
2097
    def _suspend_write_group(self):
2107
    def _suspend_write_group(self):
934
2098
        tokens = [pack.name for pack in self._resumed_packs]
2108
        tokens = [pack.name for pack in self._resumed_packs]
935
2099
2109
936
=== modified file 'bzrlib/repository.py'
937
--- bzrlib/repository.py	2009-08-12 22:28:28 +0000
938
+++ bzrlib/repository.py	2009-08-14 05:35:32 +0000
939
@@ -31,6 +31,7 @@
940
31
    gpg,
31
    gpg,
941
32
    graph,
32
    graph,
942
33
    inventory,
33
    inventory,
943
34
    inventory_delta,
944
34
    lazy_regex,
35
    lazy_regex,
945
35
    lockable_files,
36
    lockable_files,
946
36
    lockdir,
37
    lockdir,
947
@@ -924,6 +925,11 @@
948
924
        """
925
        """
949
925
        if self._write_group is not self.get_transaction():
926
        if self._write_group is not self.get_transaction():
950
926
            # has an unlock or relock occured ?
927
            # has an unlock or relock occured ?
951
928
            if suppress_errors:
952
929
                mutter(
953
930
                '(suppressed) mismatched lock context and write group. %r, %r',
954
931
                self._write_group, self.get_transaction())
955
932
                return
956
927
            raise errors.BzrError(
933
            raise errors.BzrError(
957
928
                'mismatched lock context and write group. %r, %r' %
934
                'mismatched lock context and write group. %r, %r' %
958
929
                (self._write_group, self.get_transaction()))
935
                (self._write_group, self.get_transaction()))
959
@@ -1063,8 +1069,10 @@
960
1063
        check_content=True):
1069
        check_content=True):
961
1064
        """Store lines in inv_vf and return the sha1 of the inventory."""
1070
        """Store lines in inv_vf and return the sha1 of the inventory."""
962
1065
        parents = [(parent,) for parent in parents]
1071
        parents = [(parent,) for parent in parents]
964
1066
        return self.inventories.add_lines((revision_id,), parents, lines,
1072
        result = self.inventories.add_lines((revision_id,), parents, lines,
965
1067
            check_content=check_content)[0]
1073
            check_content=check_content)[0]
966
1074
        self.inventories._access.flush()
967
1075
        return result
968
1068
1076
969
1069
    def add_revision(self, revision_id, rev, inv=None, config=None):
1077
    def add_revision(self, revision_id, rev, inv=None, config=None):
970
1070
        """Add rev to the revision store as revision_id.
1078
        """Add rev to the revision store as revision_id.
971
@@ -1529,6 +1537,8 @@
972
1529
        """Commit the contents accrued within the current write group.
1537
        """Commit the contents accrued within the current write group.
973
1530
1538
974
1531
        :seealso: start_write_group.
1539
        :seealso: start_write_group.
975
1540
        
976
1541
        :return: it may return an opaque hint that can be passed to 'pack'.
977
1532
        """
1542
        """
978
1533
        if self._write_group is not self.get_transaction():
1543
        if self._write_group is not self.get_transaction():
979
1534
            # has an unlock or relock occured ?
1544
            # has an unlock or relock occured ?
980
@@ -2340,7 +2350,7 @@
981
2340
        """Get Inventory object by revision id."""
2350
        """Get Inventory object by revision id."""
982
2341
        return self.iter_inventories([revision_id]).next()
2351
        return self.iter_inventories([revision_id]).next()
983
2342
2352
985
2343
    def iter_inventories(self, revision_ids):
2353
    def iter_inventories(self, revision_ids, ordering=None):
986
2344
        """Get many inventories by revision_ids.
2354
        """Get many inventories by revision_ids.
987
2345
2355
988
2346
        This will buffer some or all of the texts used in constructing the
2356
        This will buffer some or all of the texts used in constructing the
989
@@ -2348,30 +2358,57 @@
990
2348
        time.
2358
        time.
991
2349
2359
992
2350
        :param revision_ids: The expected revision ids of the inventories.
2360
        :param revision_ids: The expected revision ids of the inventories.
993
2361
        :param ordering: optional ordering, e.g. 'topological'.  If not
994
2362
            specified, the order of revision_ids will be preserved (by
995
2363
            buffering if necessary).
996
2351
        :return: An iterator of inventories.
2364
        :return: An iterator of inventories.
997
2352
        """
2365
        """
998
2353
        if ((None in revision_ids)
2366
        if ((None in revision_ids)
999
2354
            or (_mod_revision.NULL_REVISION in revision_ids)):
2367
            or (_mod_revision.NULL_REVISION in revision_ids)):
1000
2355
            raise ValueError('cannot get null revision inventory')
2368
            raise ValueError('cannot get null revision inventory')
1002
2356
        return self._iter_inventories(revision_ids)
2369
        return self._iter_inventories(revision_ids, ordering)
1003
2357
2370
1005
2358
    def _iter_inventories(self, revision_ids):
2371
    def _iter_inventories(self, revision_ids, ordering):
1006
2359
        """single-document based inventory iteration."""
2372
        """single-document based inventory iteration."""
1008
2360
        for text, revision_id in self._iter_inventory_xmls(revision_ids):
2373
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
1009
2374
        for text, revision_id in inv_xmls:
1010
2361
            yield self.deserialise_inventory(revision_id, text)
2375
            yield self.deserialise_inventory(revision_id, text)
1011
2362
2376
1013
2363
    def _iter_inventory_xmls(self, revision_ids):
2377
    def _iter_inventory_xmls(self, revision_ids, ordering):
1014
2378
        if ordering is None:
1015
2379
            order_as_requested = True
1016
2380
            ordering = 'unordered'
1017
2381
        else:
1018
2382
            order_as_requested = False
1019
2364
        keys = [(revision_id,) for revision_id in revision_ids]
2383
        keys = [(revision_id,) for revision_id in revision_ids]
1021
2365
        stream = self.inventories.get_record_stream(keys, 'unordered', True)
2384
        if not keys:
1022
2385
            return
1023
2386
        if order_as_requested:
1024
2387
            key_iter = iter(keys)
1025
2388
            next_key = key_iter.next()
1026
2389
        stream = self.inventories.get_record_stream(keys, ordering, True)
1027
2366
        text_chunks = {}
2390
        text_chunks = {}
1028
2367
        for record in stream:
2391
        for record in stream:
1029
2368
            if record.storage_kind != 'absent':
2392
            if record.storage_kind != 'absent':
1031
2369
                text_chunks[record.key] = record.get_bytes_as('chunked')
2393
                chunks = record.get_bytes_as('chunked')
1032
2394
                if order_as_requested:
1033
2395
                    text_chunks[record.key] = chunks
1034
2396
                else:
1035
2397
                    yield ''.join(chunks), record.key[-1]
1036
2370
            else:
2398
            else:
1037
2371
                raise errors.NoSuchRevision(self, record.key)
2399
                raise errors.NoSuchRevision(self, record.key)
1041
2372
        for key in keys:
2400
            if order_as_requested:
1042
2373
            chunks = text_chunks.pop(key)
2401
                # Yield as many results as we can while preserving order.
1043
2374
            yield ''.join(chunks), key[-1]
2402
                while next_key in text_chunks:
1044
2403
                    chunks = text_chunks.pop(next_key)
1045
2404
                    yield ''.join(chunks), next_key[-1]
1046
2405
                    try:
1047
2406
                        next_key = key_iter.next()
1048
2407
                    except StopIteration:
1049
2408
                        # We still want to fully consume the get_record_stream,
1050
2409
                        # just in case it is not actually finished at this point
1051
2410
                        next_key = None
1052
2411
                        break
1053
2375
2412
1054
2376
    def deserialise_inventory(self, revision_id, xml):
2413
    def deserialise_inventory(self, revision_id, xml):
1055
2377
        """Transform the xml into an inventory object.
2414
        """Transform the xml into an inventory object.
1056
@@ -2398,7 +2435,7 @@
1057
2398
    @needs_read_lock
2435
    @needs_read_lock
1058
2399
    def get_inventory_xml(self, revision_id):
2436
    def get_inventory_xml(self, revision_id):
1059
2400
        """Get inventory XML as a file object."""
2437
        """Get inventory XML as a file object."""
1061
2401
        texts = self._iter_inventory_xmls([revision_id])
2438
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
1062
2402
        try:
2439
        try:
1063
2403
            text, revision_id = texts.next()
2440
            text, revision_id = texts.next()
1064
2404
        except StopIteration:
2441
        except StopIteration:
1065
@@ -3664,11 +3701,25 @@
1066
3664
        # This is redundant with format.check_conversion_target(), however that
3701
        # This is redundant with format.check_conversion_target(), however that
1067
3665
        # raises an exception, and we just want to say "False" as in we won't
3702
        # raises an exception, and we just want to say "False" as in we won't
1068
3666
        # support converting between these formats.
3703
        # support converting between these formats.
1069
3704
        if 'IDS_never' in debug.debug_flags:
1070
3705
            return False
1071
3667
        if source.supports_rich_root() and not target.supports_rich_root():
3706
        if source.supports_rich_root() and not target.supports_rich_root():
1072
3668
            return False
3707
            return False
1073
3669
        if (source._format.supports_tree_reference
3708
        if (source._format.supports_tree_reference
1074
3670
            and not target._format.supports_tree_reference):
3709
            and not target._format.supports_tree_reference):
1075
3671
            return False
3710
            return False
1076
3711
        if target._fallback_repositories and target._format.supports_chks:
1077
3712
            # IDS doesn't know how to copy CHKs for the parent inventories it
1078
3713
            # adds to stacked repos.
1079
3714
            return False
1080
3715
        if 'IDS_always' in debug.debug_flags:
1081
3716
            return True
1082
3717
        # Only use this code path for local source and target.  IDS does far
1083
3718
        # too much IO (both bandwidth and roundtrips) over a network.
1084
3719
        if not source.bzrdir.transport.base.startswith('file:///'):
1085
3720
            return False
1086
3721
        if not target.bzrdir.transport.base.startswith('file:///'):
1087
3722
            return False
1088
3672
        return True
3723
        return True
1089
3673
3724
1090
3674
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3725
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
1091
@@ -3690,63 +3741,6 @@
1092
3690
        deltas.sort()
3741
        deltas.sort()
1093
3691
        return deltas[0][1:]
3742
        return deltas[0][1:]
1094
3692
3743
1095
3693
    def _get_parent_keys(self, root_key, parent_map):
1096
3694
        """Get the parent keys for a given root id."""
1097
3695
        root_id, rev_id = root_key
1098
3696
        # Include direct parents of the revision, but only if they used
1099
3697
        # the same root_id and are heads.
1100
3698
        parent_keys = []
1101
3699
        for parent_id in parent_map[rev_id]:
1102
3700
            if parent_id == _mod_revision.NULL_REVISION:
1103
3701
                continue
1104
3702
            if parent_id not in self._revision_id_to_root_id:
1105
3703
                # We probably didn't read this revision, go spend the
1106
3704
                # extra effort to actually check
1107
3705
                try:
1108
3706
                    tree = self.source.revision_tree(parent_id)
1109
3707
                except errors.NoSuchRevision:
1110
3708
                    # Ghost, fill out _revision_id_to_root_id in case we
1111
3709
                    # encounter this again.
1112
3710
                    # But set parent_root_id to None since we don't really know
1113
3711
                    parent_root_id = None
1114
3712
                else:
1115
3713
                    parent_root_id = tree.get_root_id()
1116
3714
                self._revision_id_to_root_id[parent_id] = None
1117
3715
            else:
1118
3716
                parent_root_id = self._revision_id_to_root_id[parent_id]
1119
3717
            if root_id == parent_root_id:
1120
3718
                # With stacking we _might_ want to refer to a non-local
1121
3719
                # revision, but this code path only applies when we have the
1122
3720
                # full content available, so ghosts really are ghosts, not just
1123
3721
                # the edge of local data.
1124
3722
                parent_keys.append((parent_id,))
1125
3723
            else:
1126
3724
                # root_id may be in the parent anyway.
1127
3725
                try:
1128
3726
                    tree = self.source.revision_tree(parent_id)
1129
3727
                except errors.NoSuchRevision:
1130
3728
                    # ghost, can't refer to it.
1131
3729
                    pass
1132
3730
                else:
1133
3731
                    try:
1134
3732
                        parent_keys.append((tree.inventory[root_id].revision,))
1135
3733
                    except errors.NoSuchId:
1136
3734
                        # not in the tree
1137
3735
                        pass
1138
3736
        g = graph.Graph(self.source.revisions)
1139
3737
        heads = g.heads(parent_keys)
1140
3738
        selected_keys = []
1141
3739
        for key in parent_keys:
1142
3740
            if key in heads and key not in selected_keys:
1143
3741
                selected_keys.append(key)
1144
3742
        return tuple([(root_id,)+ key for key in selected_keys])
1145
3743
1146
3744
    def _new_root_data_stream(self, root_keys_to_create, parent_map):
1147
3745
        for root_key in root_keys_to_create:
1148
3746
            parent_keys = self._get_parent_keys(root_key, parent_map)
1149
3747
            yield versionedfile.FulltextContentFactory(root_key,
1150
3748
                parent_keys, None, '')
1151
3749
1152
3750
    def _fetch_batch(self, revision_ids, basis_id, cache):
3744
    def _fetch_batch(self, revision_ids, basis_id, cache):
1153
3751
        """Fetch across a few revisions.
3745
        """Fetch across a few revisions.
1154
3752
3746
1155
@@ -3798,8 +3792,10 @@
1156
3798
        from_texts = self.source.texts
3792
        from_texts = self.source.texts
1157
3799
        to_texts = self.target.texts
3793
        to_texts = self.target.texts
1158
3800
        if root_keys_to_create:
3794
        if root_keys_to_create:
1161
3801
            root_stream = self._new_root_data_stream(root_keys_to_create,
3795
            from bzrlib.fetch import _new_root_data_stream
1162
3802
                                                     parent_map)
3796
            root_stream = _new_root_data_stream(
1163
3797
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
1164
3798
                self.source)
1165
3803
            to_texts.insert_record_stream(root_stream)
3799
            to_texts.insert_record_stream(root_stream)
1166
3804
        to_texts.insert_record_stream(from_texts.get_record_stream(
3800
        to_texts.insert_record_stream(from_texts.get_record_stream(
1167
3805
            text_keys, self.target._format._fetch_order,
3801
            text_keys, self.target._format._fetch_order,
1168
@@ -3899,7 +3895,6 @@
1169
3899
        # Walk though all revisions; get inventory deltas, copy referenced
3895
        # Walk though all revisions; get inventory deltas, copy referenced
1170
3900
        # texts that delta references, insert the delta, revision and
3896
        # texts that delta references, insert the delta, revision and
1171
3901
        # signature.
3897
        # signature.
1172
3902
        first_rev = self.source.get_revision(revision_ids[0])
1173
3903
        if pb is None:
3898
        if pb is None:
1174
3904
            my_pb = ui.ui_factory.nested_progress_bar()
3899
            my_pb = ui.ui_factory.nested_progress_bar()
1175
3905
            pb = my_pb
3900
            pb = my_pb
1176
@@ -4071,9 +4066,6 @@
1177
4071
        self.file_ids = set([file_id for file_id, _ in
4066
        self.file_ids = set([file_id for file_id, _ in
1178
4072
            self.text_index.iterkeys()])
4067
            self.text_index.iterkeys()])
1179
4073
        # text keys is now grouped by file_id
4068
        # text keys is now grouped by file_id
1180
4074
        n_weaves = len(self.file_ids)
1181
4075
        files_in_revisions = {}
1182
4076
        revisions_of_files = {}
1183
4077
        n_versions = len(self.text_index)
4069
        n_versions = len(self.text_index)
1184
4078
        progress_bar.update('loading text store', 0, n_versions)
4070
        progress_bar.update('loading text store', 0, n_versions)
1185
4079
        parent_map = self.repository.texts.get_parent_map(self.text_index)
4071
        parent_map = self.repository.texts.get_parent_map(self.text_index)
1186
@@ -4172,6 +4164,8 @@
1187
4172
            else:
4164
            else:
1188
4173
                new_pack.set_write_cache_size(1024*1024)
4165
                new_pack.set_write_cache_size(1024*1024)
1189
4174
        for substream_type, substream in stream:
4166
        for substream_type, substream in stream:
1190
4167
            if 'stream' in debug.debug_flags:
1191
4168
                mutter('inserting substream: %s', substream_type)
1192
4175
            if substream_type == 'texts':
4169
            if substream_type == 'texts':
1193
4176
                self.target_repo.texts.insert_record_stream(substream)
4170
                self.target_repo.texts.insert_record_stream(substream)
1194
4177
            elif substream_type == 'inventories':
4171
            elif substream_type == 'inventories':
1195
@@ -4181,6 +4175,9 @@
1196
4181
                else:
4175
                else:
1197
4182
                    self._extract_and_insert_inventories(
4176
                    self._extract_and_insert_inventories(
1198
4183
                        substream, src_serializer)
4177
                        substream, src_serializer)
1199
4178
            elif substream_type == 'inventory-deltas':
1200
4179
                self._extract_and_insert_inventory_deltas(
1201
4180
                    substream, src_serializer)
1202
4184
            elif substream_type == 'chk_bytes':
4181
            elif substream_type == 'chk_bytes':
1203
4185
                # XXX: This doesn't support conversions, as it assumes the
4182
                # XXX: This doesn't support conversions, as it assumes the
1204
4186
                #      conversion was done in the fetch code.
4183
                #      conversion was done in the fetch code.
1205
@@ -4237,18 +4234,45 @@
1206
4237
            self.target_repo.pack(hint=hint)
4234
            self.target_repo.pack(hint=hint)
1207
4238
        return [], set()
4235
        return [], set()
1208
4239
4236
1210
4240
    def _extract_and_insert_inventories(self, substream, serializer):
4237
    def _extract_and_insert_inventory_deltas(self, substream, serializer):
1211
4238
        target_rich_root = self.target_repo._format.rich_root_data
1212
4239
        target_tree_refs = self.target_repo._format.supports_tree_reference
1213
4240
        for record in substream:
1214
4241
            # Insert the delta directly
1215
4242
            inventory_delta_bytes = record.get_bytes_as('fulltext')
1216
4243
            deserialiser = inventory_delta.InventoryDeltaDeserializer()
1217
4244
            try:
1218
4245
                parse_result = deserialiser.parse_text_bytes(
1219
4246
                    inventory_delta_bytes)
1220
4247
            except inventory_delta.IncompatibleInventoryDelta, err:
1221
4248
                trace.mutter("Incompatible delta: %s", err.msg)
1222
4249
                raise errors.IncompatibleRevision(self.target_repo._format)
1223
4250
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
1224
4251
            revision_id = new_id
1225
4252
            parents = [key[0] for key in record.parents]
1226
4253
            self.target_repo.add_inventory_by_delta(
1227
4254
                basis_id, inv_delta, revision_id, parents)
1228
4255
1229
4256
    def _extract_and_insert_inventories(self, substream, serializer,
1230
4257
            parse_delta=None):
1231
4241
        """Generate a new inventory versionedfile in target, converting data.
4258
        """Generate a new inventory versionedfile in target, converting data.
1232
4242
4259
1233
4243
        The inventory is retrieved from the source, (deserializing it), and
4260
        The inventory is retrieved from the source, (deserializing it), and
1234
4244
        stored in the target (reserializing it in a different format).
4261
        stored in the target (reserializing it in a different format).
1235
4245
        """
4262
        """
1236
4263
        target_rich_root = self.target_repo._format.rich_root_data
1237
4264
        target_tree_refs = self.target_repo._format.supports_tree_reference
1238
4246
        for record in substream:
4265
        for record in substream:
1239
4266
            # It's not a delta, so it must be a fulltext in the source
1240
4267
            # serializer's format.
1241
4247
            bytes = record.get_bytes_as('fulltext')
4268
            bytes = record.get_bytes_as('fulltext')
1242
4248
            revision_id = record.key[0]
4269
            revision_id = record.key[0]
1243
4249
            inv = serializer.read_inventory_from_string(bytes, revision_id)
4270
            inv = serializer.read_inventory_from_string(bytes, revision_id)
1244
4250
            parents = [key[0] for key in record.parents]
4271
            parents = [key[0] for key in record.parents]
1245
4251
            self.target_repo.add_inventory(revision_id, inv, parents)
4272
            self.target_repo.add_inventory(revision_id, inv, parents)
1246
4273
            # No need to keep holding this full inv in memory when the rest of
1247
4274
            # the substream is likely to be all deltas.
1248
4275
            del inv
1249
4252
4276
1250
4253
    def _extract_and_insert_revisions(self, substream, serializer):
4277
    def _extract_and_insert_revisions(self, substream, serializer):
1251
4254
        for record in substream:
4278
        for record in substream:
1252
@@ -4303,11 +4327,8 @@
1253
4303
        return [('signatures', signatures), ('revisions', revisions)]
4327
        return [('signatures', signatures), ('revisions', revisions)]
1254
4304
4328
1255
4305
    def _generate_root_texts(self, revs):
4329
    def _generate_root_texts(self, revs):
1257
4306
        """This will be called by __fetch between fetching weave texts and
4330
        """This will be called by get_stream between fetching weave texts and
1258
4307
        fetching the inventory weave.
4331
        fetching the inventory weave.
1259
4308
1260
4309
        Subclasses should override this if they need to generate root texts
1261
4310
        after fetching weave texts.
1262
4311
        """
4332
        """
1263
4312
        if self._rich_root_upgrade():
4333
        if self._rich_root_upgrade():
1264
4313
            import bzrlib.fetch
4334
            import bzrlib.fetch
1265
@@ -4345,9 +4366,6 @@
1266
4345
                # will be valid.
4366
                # will be valid.
1267
4346
                for _ in self._generate_root_texts(revs):
4367
                for _ in self._generate_root_texts(revs):
1268
4347
                    yield _
4368
                    yield _
1269
4348
                # NB: This currently reopens the inventory weave in source;
1270
4349
                # using a single stream interface instead would avoid this.
1271
4350
                from_weave = self.from_repository.inventories
1272
4351
                # we fetch only the referenced inventories because we do not
4369
                # we fetch only the referenced inventories because we do not
1273
4352
                # know for unselected inventories whether all their required
4370
                # know for unselected inventories whether all their required
1274
4353
                # texts are present in the other repository - it could be
4371
                # texts are present in the other repository - it could be
1275
@@ -4392,6 +4410,18 @@
1276
4392
            if not keys:
4410
            if not keys:
1277
4393
                # No need to stream something we don't have
4411
                # No need to stream something we don't have
1278
4394
                continue
4412
                continue
1279
4413
            if substream_kind == 'inventories':
1280
4414
                # Some missing keys are genuinely ghosts, filter those out.
1281
4415
                present = self.from_repository.inventories.get_parent_map(keys)
1282
4416
                revs = [key[0] for key in present]
1283
4417
                # Get the inventory stream more-or-less as we do for the
1284
4418
                # original stream; there's no reason to assume that records
1285
4419
                # direct from the source will be suitable for the sink.  (Think
1286
4420
                # e.g. 2a -> 1.9-rich-root).
1287
4421
                for info in self._get_inventory_stream(revs, missing=True):
1288
4422
                    yield info
1289
4423
                continue
1290
4424
1291
4395
            # Ask for full texts always so that we don't need more round trips
4425
            # Ask for full texts always so that we don't need more round trips
1292
4396
            # after this stream.
4426
            # after this stream.
1293
4397
            # Some of the missing keys are genuinely ghosts, so filter absent
4427
            # Some of the missing keys are genuinely ghosts, so filter absent
1294
@@ -4412,129 +4442,116 @@
1295
4412
        return (not self.from_repository._format.rich_root_data and
4442
        return (not self.from_repository._format.rich_root_data and
1296
4413
            self.to_format.rich_root_data)
4443
            self.to_format.rich_root_data)
1297
4414
4444
1299
4415
    def _get_inventory_stream(self, revision_ids):
4445
    def _get_inventory_stream(self, revision_ids, missing=False):
1300
4416
        from_format = self.from_repository._format
4446
        from_format = self.from_repository._format
1312
4417
        if (from_format.supports_chks and self.to_format.supports_chks
4447
        if (from_format.supports_chks and self.to_format.supports_chks and
1313
4418
            and (from_format._serializer == self.to_format._serializer)):
4448
            from_format.network_name() == self.to_format.network_name()):
1314
4419
            # Both sides support chks, and they use the same serializer, so it
4449
            raise AssertionError(
1315
4420
            # is safe to transmit the chk pages and inventory pages across
4450
                "this case should be handled by GroupCHKStreamSource")
1316
4421
            # as-is.
4451
        elif 'forceinvdeltas' in debug.debug_flags:
1317
4422
            return self._get_chk_inventory_stream(revision_ids)
4452
            return self._get_convertable_inventory_stream(revision_ids,
1318
4423
        elif (not from_format.supports_chks):
4453
                    delta_versus_null=missing)
1319
4424
            # Source repository doesn't support chks. So we can transmit the
4454
        elif from_format.network_name() == self.to_format.network_name():
1320
4425
            # inventories 'as-is' and either they are just accepted on the
4455
            # Same format.
1321
4426
            # target, or the Sink will properly convert it.
4456
            return self._get_simple_inventory_stream(revision_ids,
1322
4427
            return self._get_simple_inventory_stream(revision_ids)
4457
                    missing=missing)
1323
4458
        elif (not from_format.supports_chks and not self.to_format.supports_chks
1324
4459
                and from_format._serializer == self.to_format._serializer):
1325
4460
            # Essentially the same format.
1326
4461
            return self._get_simple_inventory_stream(revision_ids,
1327
4462
                    missing=missing)
1328
4428
        else:
4463
        else:
1336
4429
            # XXX: Hack to make not-chk->chk fetch: copy the inventories as
4464
            # Any time we switch serializations, we want to use an
1337
4430
            #      inventories. Note that this should probably be done somehow
4465
            # inventory-delta based approach.
1338
4431
            #      as part of bzrlib.repository.StreamSink. Except JAM couldn't
4466
            return self._get_convertable_inventory_stream(revision_ids,
1339
4432
            #      figure out how a non-chk repository could possibly handle
4467
                    delta_versus_null=missing)
1333
4433
            #      deserializing an inventory stream from a chk repo, as it
1334
4434
            #      doesn't have a way to understand individual pages.
1335
4435
            return self._get_convertable_inventory_stream(revision_ids)
1340
4436
4468
1342
4437
    def _get_simple_inventory_stream(self, revision_ids):
4469
    def _get_simple_inventory_stream(self, revision_ids, missing=False):
1343
4470
        # NB: This currently reopens the inventory weave in source;
1344
4471
        # using a single stream interface instead would avoid this.
1345
4438
        from_weave = self.from_repository.inventories
4472
        from_weave = self.from_repository.inventories
1346
4473
        if missing:
1347
4474
            delta_closure = True
1348
4475
        else:
1349
4476
            delta_closure = not self.delta_on_metadata()
1350
4439
        yield ('inventories', from_weave.get_record_stream(
4477
        yield ('inventories', from_weave.get_record_stream(
1351
4440
            [(rev_id,) for rev_id in revision_ids],
4478
            [(rev_id,) for rev_id in revision_ids],
1429
4441
            self.inventory_fetch_order(),
4479
            self.inventory_fetch_order(), delta_closure))
1430
4442
            not self.delta_on_metadata()))
4480
1431
4443
4481
    def _get_convertable_inventory_stream(self, revision_ids,
1432
4444
    def _get_chk_inventory_stream(self, revision_ids):
4482
                                          delta_versus_null=False):
1433
4445
        """Fetch the inventory texts, along with the associated chk maps."""
4483
        # The source is using CHKs, but the target either doesn't or it has a
1434
4446
        # We want an inventory outside of the search set, so that we can filter
4484
        # different serializer.  The StreamSink code expects to be able to
1435
4447
        # out uninteresting chk pages. For now we use
4485
        # convert on the target, so we need to put bytes-on-the-wire that can
1436
4448
        # _find_revision_outside_set, but if we had a Search with cut_revs, we
4486
        # be converted.  That means inventory deltas (if the remote is <1.19,
1437
4449
        # could use that instead.
4487
        # RemoteStreamSink will fallback to VFS to insert the deltas).
1438
4450
        start_rev_id = self.from_repository._find_revision_outside_set(
4488
        yield ('inventory-deltas',
1439
4451
                            revision_ids)
4489
           self._stream_invs_as_deltas(revision_ids,
1440
4452
        start_rev_key = (start_rev_id,)
4490
                                       delta_versus_null=delta_versus_null))
1441
4453
        inv_keys_to_fetch = [(rev_id,) for rev_id in revision_ids]
4491
1442
4454
        if start_rev_id != _mod_revision.NULL_REVISION:
4492
    def _stream_invs_as_deltas(self, revision_ids, delta_versus_null=False):
1443
4455
            inv_keys_to_fetch.append((start_rev_id,))
4493
        """Return a stream of inventory-deltas for the given rev ids.
1444
4456
        # Any repo that supports chk_bytes must also support out-of-order
4494
1445
4457
        # insertion. At least, that is how we expect it to work
4495
        :param revision_ids: The list of inventories to transmit
1446
4458
        # We use get_record_stream instead of iter_inventories because we want
4496
        :param delta_versus_null: Don't try to find a minimal delta for this
1447
4459
        # to be able to insert the stream as well. We could instead fetch
4497
            entry, instead compute the delta versus the NULL_REVISION. This
1448
4460
        # allowing deltas, and then iter_inventories, but we don't know whether
4498
            effectively streams a complete inventory. Used for stuff like
1449
4461
        # source or target is more 'local' anway.
4499
            filling in missing parents, etc.
1450
4462
        inv_stream = self.from_repository.inventories.get_record_stream(
4500
        """
1374
4463
            inv_keys_to_fetch, 'unordered',
1375
4464
            True) # We need them as full-texts so we can find their references
1376
4465
        uninteresting_chk_roots = set()
1377
4466
        interesting_chk_roots = set()
1378
4467
        def filter_inv_stream(inv_stream):
1379
4468
            for idx, record in enumerate(inv_stream):
1380
4469
                ### child_pb.update('fetch inv', idx, len(inv_keys_to_fetch))
1381
4470
                bytes = record.get_bytes_as('fulltext')
1382
4471
                chk_inv = inventory.CHKInventory.deserialise(
1383
4472
                    self.from_repository.chk_bytes, bytes, record.key)
1384
4473
                if record.key == start_rev_key:
1385
4474
                    uninteresting_chk_roots.add(chk_inv.id_to_entry.key())
1386
4475
                    p_id_map = chk_inv.parent_id_basename_to_file_id
1387
4476
                    if p_id_map is not None:
1388
4477
                        uninteresting_chk_roots.add(p_id_map.key())
1389
4478
                else:
1390
4479
                    yield record
1391
4480
                    interesting_chk_roots.add(chk_inv.id_to_entry.key())
1392
4481
                    p_id_map = chk_inv.parent_id_basename_to_file_id
1393
4482
                    if p_id_map is not None:
1394
4483
                        interesting_chk_roots.add(p_id_map.key())
1395
4484
        ### pb.update('fetch inventory', 0, 2)
1396
4485
        yield ('inventories', filter_inv_stream(inv_stream))
1397
4486
        # Now that we have worked out all of the interesting root nodes, grab
1398
4487
        # all of the interesting pages and insert them
1399
4488
        ### pb.update('fetch inventory', 1, 2)
1400
4489
        interesting = chk_map.iter_interesting_nodes(
1401
4490
            self.from_repository.chk_bytes, interesting_chk_roots,
1402
4491
            uninteresting_chk_roots)
1403
4492
        def to_stream_adapter():
1404
4493
            """Adapt the iter_interesting_nodes result to a single stream.
1405
4494
1406
4495
            iter_interesting_nodes returns records as it processes them, along
1407
4496
            with keys. However, we only want to return the records themselves.
1408
4497
            """
1409
4498
            for record, items in interesting:
1410
4499
                if record is not None:
1411
4500
                    yield record
1412
4501
        # XXX: We could instead call get_record_stream(records.keys())
1413
4502
        #      ATM, this will always insert the records as fulltexts, and
1414
4503
        #      requires that you can hang on to records once you have gone
1415
4504
        #      on to the next one. Further, it causes the target to
1416
4505
        #      recompress the data. Testing shows it to be faster than
1417
4506
        #      requesting the records again, though.
1418
4507
        yield ('chk_bytes', to_stream_adapter())
1419
4508
        ### pb.update('fetch inventory', 2, 2)
1420
4509
1421
4510
    def _get_convertable_inventory_stream(self, revision_ids):
1422
4511
        # XXX: One of source or target is using chks, and they don't have
1423
4512
        #      compatible serializations. The StreamSink code expects to be
1424
4513
        #      able to convert on the target, so we need to put
1425
4514
        #      bytes-on-the-wire that can be converted
1426
4515
        yield ('inventories', self._stream_invs_as_fulltexts(revision_ids))
1427
4516
1428
4517
    def _stream_invs_as_fulltexts(self, revision_ids):
1451
4518
        from_repo = self.from_repository
4501
        from_repo = self.from_repository
1452
4519
        from_serializer = from_repo._format._serializer
1453
4520
        revision_keys = [(rev_id,) for rev_id in revision_ids]
4502
        revision_keys = [(rev_id,) for rev_id in revision_ids]
1454
4521
        parent_map = from_repo.inventories.get_parent_map(revision_keys)
4503
        parent_map = from_repo.inventories.get_parent_map(revision_keys)
1467
4522
        for inv in self.from_repository.iter_inventories(revision_ids):
4504
        # XXX: possibly repos could implement a more efficient iter_inv_deltas
1468
4523
            # XXX: This is a bit hackish, but it works. Basically,
4505
        # method...
1469
4524
            #      CHKSerializer 'accidentally' supports
4506
        inventories = self.from_repository.iter_inventories(
1470
4525
            #      read/write_inventory_to_string, even though that is never
4507
            revision_ids, 'topological')
1471
4526
            #      the format that is stored on disk. It *does* give us a
4508
        format = from_repo._format
1472
4527
            #      single string representation for an inventory, so live with
4509
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
1473
4528
            #      it for now.
4510
        inventory_cache = lru_cache.LRUCache(50)
1474
4529
            #      This would be far better if we had a 'serialized inventory
4511
        null_inventory = from_repo.revision_tree(
1475
4530
            #      delta' form. Then we could use 'inventory._make_delta', and
4512
            _mod_revision.NULL_REVISION).inventory
1476
4531
            #      transmit that. This would both be faster to generate, and
4513
        # XXX: ideally the rich-root/tree-refs flags would be per-revision, not
1477
4532
            #      result in fewer bytes-on-the-wire.
4514
        # per-repo (e.g.  streaming a non-rich-root revision out of a rich-root
1478
4533
            as_bytes = from_serializer.write_inventory_to_string(inv)
4515
        # repo back into a non-rich-root repo ought to be allowed)
1479
4516
        serializer = inventory_delta.InventoryDeltaSerializer(
1480
4517
            versioned_root=format.rich_root_data,
1481
4518
            tree_references=format.supports_tree_reference)
1482
4519
        for inv in inventories:
1483
4534
            key = (inv.revision_id,)
4520
            key = (inv.revision_id,)
1484
4535
            parent_keys = parent_map.get(key, ())
4521
            parent_keys = parent_map.get(key, ())
1485
4522
            delta = None
1486
4523
            if not delta_versus_null and parent_keys:
1487
4524
                # The caller did not ask for complete inventories and we have
1488
4525
                # some parents that we can delta against.  Make a delta against
1489
4526
                # each parent so that we can find the smallest.
1490
4527
                parent_ids = [parent_key[0] for parent_key in parent_keys]
1491
4528
                for parent_id in parent_ids:
1492
4529
                    if parent_id not in invs_sent_so_far:
1493
4530
                        # We don't know that the remote side has this basis, so
1494
4531
                        # we can't use it.
1495
4532
                        continue
1496
4533
                    if parent_id == _mod_revision.NULL_REVISION:
1497
4534
                        parent_inv = null_inventory
1498
4535
                    else:
1499
4536
                        parent_inv = inventory_cache.get(parent_id, None)
1500
4537
                        if parent_inv is None:
1501
4538
                            parent_inv = from_repo.get_inventory(parent_id)
1502
4539
                    candidate_delta = inv._make_delta(parent_inv)
1503
4540
                    if (delta is None or
1504
4541
                        len(delta) > len(candidate_delta)):
1505
4542
                        delta = candidate_delta
1506
4543
                        basis_id = parent_id
1507
4544
            if delta is None:
1508
4545
                # Either none of the parents ended up being suitable, or we
1509
4546
                # were asked to delta against NULL
1510
4547
                basis_id = _mod_revision.NULL_REVISION
1511
4548
                delta = inv._make_delta(null_inventory)
1512
4549
            invs_sent_so_far.add(inv.revision_id)
1513
4550
            inventory_cache[inv.revision_id] = inv
1514
4551
            delta_serialized = ''.join(
1515
4552
                serializer.delta_to_lines(basis_id, key[-1], delta))
1516
4536
            yield versionedfile.FulltextContentFactory(
4553
            yield versionedfile.FulltextContentFactory(
1518
4537
                key, parent_keys, None, as_bytes)
4554
                key, parent_keys, None, delta_serialized)
1519
4538
4555
1520
4539
4556
1521
4540
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
4557
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
1522
4541
4558
1523
=== modified file 'bzrlib/smart/protocol.py'
1524
--- bzrlib/smart/protocol.py	2009-07-17 01:48:56 +0000
1525
+++ bzrlib/smart/protocol.py	2009-08-14 05:35:32 +0000
1526
@@ -1209,6 +1209,8 @@
1527
1209
        except (KeyboardInterrupt, SystemExit):
1209
        except (KeyboardInterrupt, SystemExit):
1528
1210
            raise
1210
            raise
1529
1211
        except Exception:
1211
        except Exception:
1530
1212
            mutter('_iter_with_errors caught error')
1531
1213
            log_exception_quietly()
1532
1212
            yield sys.exc_info(), None
1214
            yield sys.exc_info(), None
1533
1213
            return
1215
            return
1534
1214
1216
1535
1215
1217
1536
=== modified file 'bzrlib/smart/repository.py'
1537
--- bzrlib/smart/repository.py	2009-06-16 06:46:32 +0000
1538
+++ bzrlib/smart/repository.py	2009-08-14 05:35:32 +0000
1539
@@ -30,6 +30,7 @@
1540
30
    graph,
30
    graph,
1541
31
    osutils,
31
    osutils,
1542
32
    pack,
32
    pack,
1543
33
    versionedfile,
1544
33
    )
34
    )
1545
34
from bzrlib.bzrdir import BzrDir
35
from bzrlib.bzrdir import BzrDir
1546
35
from bzrlib.smart.request import (
36
from bzrlib.smart.request import (
1547
@@ -39,7 +40,10 @@
1548
39
    )
40
    )
1549
40
from bzrlib.repository import _strip_NULL_ghosts, network_format_registry
41
from bzrlib.repository import _strip_NULL_ghosts, network_format_registry
1550
41
from bzrlib import revision as _mod_revision
42
from bzrlib import revision as _mod_revision
1552
42
from bzrlib.versionedfile import NetworkRecordStream, record_to_fulltext_bytes
43
from bzrlib.versionedfile import (
1553
44
    NetworkRecordStream,
1554
45
    record_to_fulltext_bytes,
1555
46
    )
1556
43
47
1557
44
48
1558
45
class SmartServerRepositoryRequest(SmartServerRequest):
49
class SmartServerRepositoryRequest(SmartServerRequest):
1559
@@ -414,8 +418,42 @@
1560
414
            repository.
418
            repository.
1561
415
        """
419
        """
1562
416
        self._to_format = network_format_registry.get(to_network_name)
420
        self._to_format = network_format_registry.get(to_network_name)
1563
421
        if self._should_fake_unknown():
1564
422
            return FailedSmartServerResponse(
1565
423
                ('UnknownMethod', 'Repository.get_stream'))
1566
417
        return None # Signal that we want a body.
424
        return None # Signal that we want a body.
1567
418
425
1568
426
    def _should_fake_unknown(self):
1569
427
        """Return True if we should return UnknownMethod to the client.
1570
428
        
1571
429
        This is a workaround for bugs in pre-1.19 clients that claim to
1572
430
        support receiving streams of CHK repositories.  The pre-1.19 client
1573
431
        expects inventory records to be serialized in the format defined by
1574
432
        to_network_name, but in pre-1.19 (at least) that format definition
1575
433
        tries to use the xml5 serializer, which does not correctly handle
1576
434
        rich-roots.  After 1.19 the client can also accept inventory-deltas
1577
435
        (which avoids this issue), and those clients will use the
1578
436
        Repository.get_stream_1.19 verb instead of this one.
1579
437
        So: if this repository is CHK, and the to_format doesn't match,
1580
438
        we should just fake an UnknownSmartMethod error so that the client
1581
439
        will fallback to VFS, rather than sending it a stream we know it
1582
440
        cannot handle.
1583
441
        """
1584
442
        from_format = self._repository._format
1585
443
        to_format = self._to_format
1586
444
        if not from_format.supports_chks:
1587
445
            # Source not CHK: that's ok
1588
446
            return False
1589
447
        if (to_format.supports_chks and
1590
448
            from_format.repository_class is to_format.repository_class and
1591
449
            from_format._serializer == to_format._serializer):
1592
450
            # Source is CHK, but target matches: that's ok
1593
451
            # (e.g. 2a->2a, or CHK2->2a)
1594
452
            return False
1595
453
        # Source is CHK, and target is not CHK or incompatible CHK.  We can't
1596
454
        # generate a compatible stream.
1597
455
        return True
1598
456
1599
419
    def do_body(self, body_bytes):
457
    def do_body(self, body_bytes):
1600
420
        repository = self._repository
458
        repository = self._repository
1601
421
        repository.lock_read()
459
        repository.lock_read()
1602
@@ -451,6 +489,13 @@
1603
451
            repository.unlock()
489
            repository.unlock()
1604
452
490
1605
453
491
1606
492
class SmartServerRepositoryGetStream_1_19(SmartServerRepositoryGetStream):
1607
493
1608
494
    def _should_fake_unknown(self):
1609
495
        """Returns False; we don't need to workaround bugs in 1.19+ clients."""
1610
496
        return False
1611
497
1612
498
1613
454
def _stream_to_byte_stream(stream, src_format):
499
def _stream_to_byte_stream(stream, src_format):
1614
455
    """Convert a record stream to a self delimited byte stream."""
500
    """Convert a record stream to a self delimited byte stream."""
1615
456
    pack_writer = pack.ContainerSerialiser()
501
    pack_writer = pack.ContainerSerialiser()
1616
@@ -460,6 +505,8 @@
1617
460
        for record in substream:
505
        for record in substream:
1618
461
            if record.storage_kind in ('chunked', 'fulltext'):
506
            if record.storage_kind in ('chunked', 'fulltext'):
1619
462
                serialised = record_to_fulltext_bytes(record)
507
                serialised = record_to_fulltext_bytes(record)
1620
508
            elif record.storage_kind == 'inventory-delta':
1621
509
                serialised = record_to_inventory_delta_bytes(record)
1622
463
            elif record.storage_kind == 'absent':
510
            elif record.storage_kind == 'absent':
1623
464
                raise ValueError("Absent factory for %s" % (record.key,))
511
                raise ValueError("Absent factory for %s" % (record.key,))
1624
465
            else:
512
            else:
1625
@@ -650,6 +697,23 @@
1626
650
            return SuccessfulSmartServerResponse(('ok', ))
697
            return SuccessfulSmartServerResponse(('ok', ))
1627
651
698
1628
652
699
1629
700
class SmartServerRepositoryInsertStream_1_19(SmartServerRepositoryInsertStreamLocked):
1630
701
    """Insert a record stream from a RemoteSink into a repository.
1631
702
1632
703
    Same as SmartServerRepositoryInsertStreamLocked, except:
1633
704
     - the lock token argument is optional
1634
705
     - servers that implement this verb accept 'inventory-delta' records in the
1635
706
       stream.
1636
707
1637
708
    New in 1.19.
1638
709
    """
1639
710
1640
711
    def do_repository_request(self, repository, resume_tokens, lock_token=None):
1641
712
        """StreamSink.insert_stream for a remote repository."""
1642
713
        SmartServerRepositoryInsertStreamLocked.do_repository_request(
1643
714
            self, repository, resume_tokens, lock_token)
1644
715
1645
716
1646
653
class SmartServerRepositoryInsertStream(SmartServerRepositoryInsertStreamLocked):
717
class SmartServerRepositoryInsertStream(SmartServerRepositoryInsertStreamLocked):
1647
654
    """Insert a record stream from a RemoteSink into an unlocked repository.
718
    """Insert a record stream from a RemoteSink into an unlocked repository.
1648
655
719
1649
656
720
1650
=== modified file 'bzrlib/smart/request.py'
1651
--- bzrlib/smart/request.py	2009-07-27 02:06:05 +0000
1652
+++ bzrlib/smart/request.py	2009-08-14 05:35:32 +0000
1653
@@ -553,6 +553,8 @@
1654
553
request_handlers.register_lazy(
553
request_handlers.register_lazy(
1655
554
    'Repository.insert_stream', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream')
554
    'Repository.insert_stream', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream')
1656
555
request_handlers.register_lazy(
555
request_handlers.register_lazy(
1657
556
    'Repository.insert_stream_1.19', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream_1_19')
1658
557
request_handlers.register_lazy(
1659
556
    'Repository.insert_stream_locked', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStreamLocked')
558
    'Repository.insert_stream_locked', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStreamLocked')
1660
557
request_handlers.register_lazy(
559
request_handlers.register_lazy(
1661
558
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
560
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
1662
@@ -570,6 +572,9 @@
1663
570
    'Repository.get_stream', 'bzrlib.smart.repository',
572
    'Repository.get_stream', 'bzrlib.smart.repository',
1664
571
    'SmartServerRepositoryGetStream')
573
    'SmartServerRepositoryGetStream')
1665
572
request_handlers.register_lazy(
574
request_handlers.register_lazy(
1666
575
    'Repository.get_stream_1.19', 'bzrlib.smart.repository',
1667
576
    'SmartServerRepositoryGetStream_1_19')
1668
577
request_handlers.register_lazy(
1669
573
    'Repository.tarball', 'bzrlib.smart.repository',
578
    'Repository.tarball', 'bzrlib.smart.repository',
1670
574
    'SmartServerRepositoryTarball')
579
    'SmartServerRepositoryTarball')
1671
575
request_handlers.register_lazy(
580
request_handlers.register_lazy(
1672
576
581
1673
=== modified file 'bzrlib/tests/__init__.py'
1674
--- bzrlib/tests/__init__.py	2009-08-12 18:49:22 +0000
1675
+++ bzrlib/tests/__init__.py	2009-08-14 05:35:32 +0000
1676
@@ -1938,6 +1938,16 @@
1677
1938
        sio.encoding = output_encoding
1938
        sio.encoding = output_encoding
1678
1939
        return sio
1939
        return sio
1679
1940
1940
1680
1941
    def disable_verb(self, verb):
1681
1942
        """Disable a smart server verb for one test."""
1682
1943
        from bzrlib.smart import request
1683
1944
        request_handlers = request.request_handlers
1684
1945
        orig_method = request_handlers.get(verb)
1685
1946
        request_handlers.remove(verb)
1686
1947
        def restoreVerb():
1687
1948
            request_handlers.register(verb, orig_method)
1688
1949
        self.addCleanup(restoreVerb)
1689
1950
1690
1941
1951
1691
1942
class CapturedCall(object):
1952
class CapturedCall(object):
1692
1943
    """A helper for capturing smart server calls for easy debug analysis."""
1953
    """A helper for capturing smart server calls for easy debug analysis."""
1693
1944
1954
1694
=== modified file 'bzrlib/tests/per_branch/test_push.py'
1695
--- bzrlib/tests/per_branch/test_push.py	2009-08-05 02:30:59 +0000
1696
+++ bzrlib/tests/per_branch/test_push.py	2009-08-14 05:35:32 +0000
1697
@@ -261,14 +261,15 @@
1698
261
        self.assertFalse(local.is_locked())
261
        self.assertFalse(local.is_locked())
1699
262
        local.push(remote)
262
        local.push(remote)
1700
263
        hpss_call_names = [item.call.method for item in self.hpss_calls]
263
        hpss_call_names = [item.call.method for item in self.hpss_calls]
1703
264
        self.assertTrue('Repository.insert_stream' in hpss_call_names)
264
        self.assertTrue('Repository.insert_stream_1.19' in hpss_call_names)
1704
265
        insert_stream_idx = hpss_call_names.index('Repository.insert_stream')
265
        insert_stream_idx = hpss_call_names.index(
1705
266
            'Repository.insert_stream_1.19')
1706
266
        calls_after_insert_stream = hpss_call_names[insert_stream_idx:]
267
        calls_after_insert_stream = hpss_call_names[insert_stream_idx:]
1707
267
        # After inserting the stream the client has no reason to query the
268
        # After inserting the stream the client has no reason to query the
1708
268
        # remote graph any further.
269
        # remote graph any further.
1709
269
        self.assertEqual(
270
        self.assertEqual(
1712
270
            ['Repository.insert_stream', 'Repository.insert_stream', 'get',
271
            ['Repository.insert_stream_1.19', 'Repository.insert_stream_1.19',
1713
271
             'Branch.set_last_revision_info', 'Branch.unlock'],
272
             'get', 'Branch.set_last_revision_info', 'Branch.unlock'],
1714
272
            calls_after_insert_stream)
273
            calls_after_insert_stream)
1715
273
274
1716
274
    def disableOptimisticGetParentMap(self):
275
    def disableOptimisticGetParentMap(self):
1717
275
276
1718
=== modified file 'bzrlib/tests/per_interbranch/test_push.py'
1719
--- bzrlib/tests/per_interbranch/test_push.py	2009-08-05 02:30:59 +0000
1720
+++ bzrlib/tests/per_interbranch/test_push.py	2009-08-14 05:35:32 +0000
1721
@@ -267,14 +267,15 @@
1722
267
        self.assertFalse(local.is_locked())
267
        self.assertFalse(local.is_locked())
1723
268
        local.push(remote)
268
        local.push(remote)
1724
269
        hpss_call_names = [item.call.method for item in self.hpss_calls]
269
        hpss_call_names = [item.call.method for item in self.hpss_calls]
1727
270
        self.assertTrue('Repository.insert_stream' in hpss_call_names)
270
        self.assertTrue('Repository.insert_stream_1.19' in hpss_call_names)
1728
271
        insert_stream_idx = hpss_call_names.index('Repository.insert_stream')
271
        insert_stream_idx = hpss_call_names.index(
1729
272
            'Repository.insert_stream_1.19')
1730
272
        calls_after_insert_stream = hpss_call_names[insert_stream_idx:]
273
        calls_after_insert_stream = hpss_call_names[insert_stream_idx:]
1731
273
        # After inserting the stream the client has no reason to query the
274
        # After inserting the stream the client has no reason to query the
1732
274
        # remote graph any further.
275
        # remote graph any further.
1733
275
        self.assertEqual(
276
        self.assertEqual(
1736
276
            ['Repository.insert_stream', 'Repository.insert_stream', 'get',
277
            ['Repository.insert_stream_1.19', 'Repository.insert_stream_1.19',
1737
277
             'Branch.set_last_revision_info', 'Branch.unlock'],
278
             'get', 'Branch.set_last_revision_info', 'Branch.unlock'],
1738
278
            calls_after_insert_stream)
279
            calls_after_insert_stream)
1739
279
280
1740
280
    def disableOptimisticGetParentMap(self):
281
    def disableOptimisticGetParentMap(self):
1741
281
282
1742
=== modified file 'bzrlib/tests/per_interrepository/__init__.py'
1743
--- bzrlib/tests/per_interrepository/__init__.py	2009-08-11 21:02:46 +0000
1744
+++ bzrlib/tests/per_interrepository/__init__.py	2009-08-14 05:35:33 +0000
1745
@@ -32,8 +32,6 @@
1746
32
    )
32
    )
1747
33
33
1748
34
from bzrlib.repository import (
34
from bzrlib.repository import (
1749
35
    InterDifferingSerializer,
1750
36
    InterKnitRepo,
1751
37
    InterRepository,
35
    InterRepository,
1752
38
    )
36
    )
1753
39
from bzrlib.tests import (
37
from bzrlib.tests import (
1754
@@ -48,18 +46,16 @@
1755
48
    """Transform the input formats to a list of scenarios.
46
    """Transform the input formats to a list of scenarios.
1756
49
47
1757
50
    :param formats: A list of tuples:
48
    :param formats: A list of tuples:
1759
51
        (interrepo_class, repository_format, repository_format_to).
49
        (label, repository_format, repository_format_to).
1760
52
    """
50
    """
1761
53
    result = []
51
    result = []
1766
54
    for interrepo_class, repository_format, repository_format_to in formats:
52
    for label, repository_format, repository_format_to in formats:
1767
55
        id = '%s,%s,%s' % (interrepo_class.__name__,
53
        id = '%s,%s,%s' % (label, repository_format.__class__.__name__,
1768
56
                            repository_format.__class__.__name__,
54
                           repository_format_to.__class__.__name__)
1765
57
                            repository_format_to.__class__.__name__)
1769
58
        scenario = (id,
55
        scenario = (id,
1770
59
            {"transport_server": transport_server,
56
            {"transport_server": transport_server,
1771
60
             "transport_readonly_server": transport_readonly_server,
57
             "transport_readonly_server": transport_readonly_server,
1772
61
             "repository_format": repository_format,
58
             "repository_format": repository_format,
1773
62
             "interrepo_class": interrepo_class,
1774
63
             "repository_format_to": repository_format_to,
59
             "repository_format_to": repository_format_to,
1775
64
             })
60
             })
1776
65
        result.append(scenario)
61
        result.append(scenario)
1777
@@ -75,6 +71,8 @@
1778
75
        weaverepo,
71
        weaverepo,
1779
76
        )
72
        )
1780
77
    result = []
73
    result = []
1781
74
    def add_combo(label, from_format, to_format):
1782
75
        result.append((label, from_format, to_format))
1783
78
    # test the default InterRepository between format 6 and the current
76
    # test the default InterRepository between format 6 and the current
1784
79
    # default format.
77
    # default format.
1785
80
    # XXX: robertc 20060220 reinstate this when there are two supported
78
    # XXX: robertc 20060220 reinstate this when there are two supported
1786
@@ -85,40 +83,48 @@
1787
85
    for optimiser_class in InterRepository._optimisers:
83
    for optimiser_class in InterRepository._optimisers:
1788
86
        format_to_test = optimiser_class._get_repo_format_to_test()
84
        format_to_test = optimiser_class._get_repo_format_to_test()
1789
87
        if format_to_test is not None:
85
        if format_to_test is not None:
1792
88
            result.append((optimiser_class,
86
            add_combo(optimiser_class.__name__, format_to_test, format_to_test)
1791
89
                           format_to_test, format_to_test))
1793
90
    # if there are specific combinations we want to use, we can add them
87
    # if there are specific combinations we want to use, we can add them
1794
91
    # here. We want to test rich root upgrading.
88
    # here. We want to test rich root upgrading.
1825
92
    result.append((InterRepository,
89
    # XXX: although we attach InterRepository class names to these scenarios,
1826
93
                   weaverepo.RepositoryFormat5(),
90
    # there's nothing asserting that these labels correspond to what is
1827
94
                   knitrepo.RepositoryFormatKnit3()))
91
    # actually used.
1828
95
    result.append((InterRepository,
92
    add_combo('InterRepository',
1829
96
                   knitrepo.RepositoryFormatKnit1(),
93
              weaverepo.RepositoryFormat5(),
1830
97
                   knitrepo.RepositoryFormatKnit3()))
94
              knitrepo.RepositoryFormatKnit3())
1831
98
    result.append((InterRepository,
95
    add_combo('InterRepository',
1832
99
                   knitrepo.RepositoryFormatKnit1(),
96
              knitrepo.RepositoryFormatKnit1(),
1833
100
                   knitrepo.RepositoryFormatKnit3()))
97
              knitrepo.RepositoryFormatKnit3())
1834
101
    result.append((InterKnitRepo,
98
    add_combo('InterKnitRepo',
1835
102
                   knitrepo.RepositoryFormatKnit1(),
99
              knitrepo.RepositoryFormatKnit1(),
1836
103
                   pack_repo.RepositoryFormatKnitPack1()))
100
              pack_repo.RepositoryFormatKnitPack1())
1837
104
    result.append((InterKnitRepo,
101
    add_combo('InterKnitRepo',
1838
105
                   pack_repo.RepositoryFormatKnitPack1(),
102
              pack_repo.RepositoryFormatKnitPack1(),
1839
106
                   knitrepo.RepositoryFormatKnit1()))
103
              knitrepo.RepositoryFormatKnit1())
1840
107
    result.append((InterKnitRepo,
104
    add_combo('InterKnitRepo',
1841
108
                   knitrepo.RepositoryFormatKnit3(),
105
              knitrepo.RepositoryFormatKnit3(),
1842
109
                   pack_repo.RepositoryFormatKnitPack3()))
106
              pack_repo.RepositoryFormatKnitPack3())
1843
110
    result.append((InterKnitRepo,
107
    add_combo('InterKnitRepo',
1844
111
                   pack_repo.RepositoryFormatKnitPack3(),
108
              pack_repo.RepositoryFormatKnitPack3(),
1845
112
                   knitrepo.RepositoryFormatKnit3()))
109
              knitrepo.RepositoryFormatKnit3())
1846
113
    result.append((InterKnitRepo,
110
    add_combo('InterKnitRepo',
1847
114
                   pack_repo.RepositoryFormatKnitPack3(),
111
              pack_repo.RepositoryFormatKnitPack3(),
1848
115
                   pack_repo.RepositoryFormatKnitPack4()))
112
              pack_repo.RepositoryFormatKnitPack4())
1849
116
    result.append((InterDifferingSerializer,
113
    add_combo('InterDifferingSerializer',
1850
117
                   pack_repo.RepositoryFormatKnitPack1(),
114
              pack_repo.RepositoryFormatKnitPack1(),
1851
118
                   pack_repo.RepositoryFormatKnitPack6RichRoot()))
115
              pack_repo.RepositoryFormatKnitPack6RichRoot())
1852
119
    result.append((InterDifferingSerializer,
116
    add_combo('InterDifferingSerializer',
1853
120
                   pack_repo.RepositoryFormatKnitPack6RichRoot(),
117
              pack_repo.RepositoryFormatKnitPack6RichRoot(),
1854
121
                   groupcompress_repo.RepositoryFormat2a()))
118
              groupcompress_repo.RepositoryFormat2a())
1855
119
    add_combo('InterDifferingSerializer',
1856
120
              groupcompress_repo.RepositoryFormat2a(),
1857
121
              pack_repo.RepositoryFormatKnitPack6RichRoot())
1858
122
    add_combo('InterRepository',
1859
123
              groupcompress_repo.RepositoryFormatCHK2(),
1860
124
              groupcompress_repo.RepositoryFormat2a())
1861
125
    add_combo('InterDifferingSerializer',
1862
126
              groupcompress_repo.RepositoryFormatCHK1(),
1863
127
              groupcompress_repo.RepositoryFormat2a())
1864
122
    return result
128
    return result
1865
123
129
1866
124
130
1867
125
131
1868
=== modified file 'bzrlib/tests/per_interrepository/test_fetch.py'
1869
--- bzrlib/tests/per_interrepository/test_fetch.py	2009-08-12 02:21:06 +0000
1870
+++ bzrlib/tests/per_interrepository/test_fetch.py	2009-08-14 05:35:33 +0000
1871
@@ -28,6 +28,9 @@
1872
28
from bzrlib.errors import (
28
from bzrlib.errors import (
1873
29
    NoSuchRevision,
29
    NoSuchRevision,
1874
30
    )
30
    )
1875
31
from bzrlib.graph import (
1876
32
    SearchResult,
1877
33
    )
1878
31
from bzrlib.revision import (
34
from bzrlib.revision import (
1879
32
    NULL_REVISION,
35
    NULL_REVISION,
1880
33
    Revision,
36
    Revision,
1881
@@ -124,6 +127,15 @@
1882
124
            to_repo.texts.get_record_stream([('foo', revid)],
127
            to_repo.texts.get_record_stream([('foo', revid)],
1883
125
            'unordered', True).next().get_bytes_as('fulltext'))
128
            'unordered', True).next().get_bytes_as('fulltext'))
1884
126
129
1885
130
    def test_fetch_parent_inventories_at_stacking_boundary_smart(self):
1886
131
        self.setup_smart_server_with_call_log()
1887
132
        self.test_fetch_parent_inventories_at_stacking_boundary()
1888
133
1889
134
    def test_fetch_parent_inventories_at_stacking_boundary_smart_old(self):
1890
135
        self.setup_smart_server_with_call_log()
1891
136
        self.disable_verb('Repository.insert_stream_1.19')
1892
137
        self.test_fetch_parent_inventories_at_stacking_boundary()
1893
138
1894
127
    def test_fetch_parent_inventories_at_stacking_boundary(self):
139
    def test_fetch_parent_inventories_at_stacking_boundary(self):
1895
128
        """Fetch to a stacked branch copies inventories for parents of
140
        """Fetch to a stacked branch copies inventories for parents of
1896
129
        revisions at the stacking boundary.
141
        revisions at the stacking boundary.
1897
@@ -180,6 +192,28 @@
1898
180
        self.assertEqual(left_tree.inventory, stacked_left_tree.inventory)
192
        self.assertEqual(left_tree.inventory, stacked_left_tree.inventory)
1899
181
        self.assertEqual(right_tree.inventory, stacked_right_tree.inventory)
193
        self.assertEqual(right_tree.inventory, stacked_right_tree.inventory)
1900
182
194
1901
195
        # Finally, it's not enough to see that the basis inventories are
1902
196
        # present.  The texts introduced in merge (and only those) should be
1903
197
        # present, and also generating a stream should succeed without blowing
1904
198
        # up.
1905
199
        self.assertTrue(unstacked_repo.has_revision('merge'))
1906
200
        expected_texts = set([('file-id', 'merge')])
1907
201
        if stacked_branch.repository.texts.get_parent_map([('root-id',
1908
202
            'merge')]):
1909
203
            # If a (root-id,merge) text exists, it should be in the stacked
1910
204
            # repo.
1911
205
            expected_texts.add(('root-id', 'merge'))
1912
206
        self.assertEqual(expected_texts, unstacked_repo.texts.keys())
1913
207
        self.assertCanStreamRevision(unstacked_repo, 'merge')
1914
208
1915
209
    def assertCanStreamRevision(self, repo, revision_id):
1916
210
        exclude_keys = set(repo.all_revision_ids()) - set([revision_id])
1917
211
        search = SearchResult([revision_id], exclude_keys, 1, [revision_id])
1918
212
        source = repo._get_source(repo._format)
1919
213
        for substream_kind, substream in source.get_stream(search):
1920
214
            # Consume the substream
1921
215
            list(substream)
1922
216
1923
183
    def test_fetch_across_stacking_boundary_ignores_ghost(self):
217
    def test_fetch_across_stacking_boundary_ignores_ghost(self):
1924
184
        if not self.repository_format_to.supports_external_lookups:
218
        if not self.repository_format_to.supports_external_lookups:
1925
185
            raise TestNotApplicable("Need stacking support in the target.")
219
            raise TestNotApplicable("Need stacking support in the target.")
1926
@@ -218,6 +252,19 @@
1927
218
        self.addCleanup(stacked_branch.unlock)
252
        self.addCleanup(stacked_branch.unlock)
1928
219
        stacked_second_tree = stacked_branch.repository.revision_tree('second')
253
        stacked_second_tree = stacked_branch.repository.revision_tree('second')
1929
220
        self.assertEqual(second_tree.inventory, stacked_second_tree.inventory)
254
        self.assertEqual(second_tree.inventory, stacked_second_tree.inventory)
1930
255
        # Finally, it's not enough to see that the basis inventories are
1931
256
        # present.  The texts introduced in merge (and only those) should be
1932
257
        # present, and also generating a stream should succeed without blowing
1933
258
        # up.
1934
259
        self.assertTrue(unstacked_repo.has_revision('third'))
1935
260
        expected_texts = set([('file-id', 'third')])
1936
261
        if stacked_branch.repository.texts.get_parent_map([('root-id',
1937
262
            'third')]):
1938
263
            # If a (root-id,third) text exists, it should be in the stacked
1939
264
            # repo.
1940
265
            expected_texts.add(('root-id', 'third'))
1941
266
        self.assertEqual(expected_texts, unstacked_repo.texts.keys())
1942
267
        self.assertCanStreamRevision(unstacked_repo, 'third')
1943
221
268
1944
222
    def test_fetch_missing_basis_text(self):
269
    def test_fetch_missing_basis_text(self):
1945
223
        """If fetching a delta, we should die if a basis is not present."""
270
        """If fetching a delta, we should die if a basis is not present."""
1946
224
271
1947
=== modified file 'bzrlib/tests/per_pack_repository.py'
1948
--- bzrlib/tests/per_pack_repository.py	2009-08-12 22:28:28 +0000
1949
+++ bzrlib/tests/per_pack_repository.py	2009-08-14 05:35:32 +0000
1950
@@ -1051,8 +1051,8 @@
1951
1051
        tree.branch.push(remote_branch)
1051
        tree.branch.push(remote_branch)
1952
1052
        autopack_calls = len([call for call in self.hpss_calls if call ==
1052
        autopack_calls = len([call for call in self.hpss_calls if call ==
1953
1053
            'PackRepository.autopack'])
1053
            'PackRepository.autopack'])
1956
1054
        streaming_calls = len([call for call in self.hpss_calls if call ==
1054
        streaming_calls = len([call for call in self.hpss_calls if call in
1957
1055
            'Repository.insert_stream'])
1055
            ('Repository.insert_stream', 'Repository.insert_stream_1.19')])
1958
1056
        if autopack_calls:
1056
        if autopack_calls:
1959
1057
            # Non streaming server
1057
            # Non streaming server
1960
1058
            self.assertEqual(1, autopack_calls)
1058
            self.assertEqual(1, autopack_calls)
1961
1059
1059
1962
=== modified file 'bzrlib/tests/test_inventory_delta.py'
1963
--- bzrlib/tests/test_inventory_delta.py	2009-04-02 05:53:12 +0000
1964
+++ bzrlib/tests/test_inventory_delta.py	2009-08-14 05:35:32 +0000
1965
@@ -26,6 +26,7 @@
1966
26
    inventory,
26
    inventory,
1967
27
    inventory_delta,
27
    inventory_delta,
1968
28
    )
28
    )
1969
29
from bzrlib.inventory_delta import InventoryDeltaError
1970
29
from bzrlib.inventory import Inventory
30
from bzrlib.inventory import Inventory
1971
30
from bzrlib.revision import NULL_REVISION
31
from bzrlib.revision import NULL_REVISION
1972
31
from bzrlib.tests import TestCase
32
from bzrlib.tests import TestCase
1973
@@ -68,7 +69,7 @@
1974
68
version: entry-version
69
version: entry-version
1975
69
versioned_root: false
70
versioned_root: false
1976
70
tree_references: false
71
tree_references: false
1978
71
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir
72
None\x00/\x00TREE_ROOT\x00\x00entry-version\x00dir
1979
72
"""
73
"""
1980
73
74
1981
74
reference_lines = """format: bzr inventory delta v1 (bzr 1.14)
75
reference_lines = """format: bzr inventory delta v1 (bzr 1.14)
1982
@@ -93,39 +94,34 @@
1983
93
    """Test InventoryDeltaSerializer.parse_text_bytes."""
94
    """Test InventoryDeltaSerializer.parse_text_bytes."""
1984
94
95
1985
95
    def test_parse_no_bytes(self):
96
    def test_parse_no_bytes(self):
1988
96
        serializer = inventory_delta.InventoryDeltaSerializer(
97
        deserializer = inventory_delta.InventoryDeltaDeserializer()
1987
97
            versioned_root=True, tree_references=True)
1989
98
        err = self.assertRaises(
98
        err = self.assertRaises(
1992
99
            errors.BzrError, serializer.parse_text_bytes, '')
99
            InventoryDeltaError, deserializer.parse_text_bytes, '')
1993
100
        self.assertContainsRe(str(err), 'unknown format')
100
        self.assertContainsRe(str(err), 'last line not empty')
1994
101
101
1995
102
    def test_parse_bad_format(self):
102
    def test_parse_bad_format(self):
2000
103
        serializer = inventory_delta.InventoryDeltaSerializer(
103
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2001
104
            versioned_root=True, tree_references=True)
104
        err = self.assertRaises(InventoryDeltaError,
2002
105
        err = self.assertRaises(errors.BzrError,
105
            deserializer.parse_text_bytes, 'format: foo\n')
1999
106
            serializer.parse_text_bytes, 'format: foo\n')
2003
107
        self.assertContainsRe(str(err), 'unknown format')
106
        self.assertContainsRe(str(err), 'unknown format')
2004
108
107
2005
109
    def test_parse_no_parent(self):
108
    def test_parse_no_parent(self):
2010
110
        serializer = inventory_delta.InventoryDeltaSerializer(
109
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2011
111
            versioned_root=True, tree_references=True)
110
        err = self.assertRaises(InventoryDeltaError,
2012
112
        err = self.assertRaises(errors.BzrError,
111
            deserializer.parse_text_bytes,
2009
113
            serializer.parse_text_bytes,
2013
114
            'format: bzr inventory delta v1 (bzr 1.14)\n')
112
            'format: bzr inventory delta v1 (bzr 1.14)\n')
2014
115
        self.assertContainsRe(str(err), 'missing parent: marker')
113
        self.assertContainsRe(str(err), 'missing parent: marker')
2015
116
114
2016
117
    def test_parse_no_version(self):
115
    def test_parse_no_version(self):
2021
118
        serializer = inventory_delta.InventoryDeltaSerializer(
116
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2022
119
            versioned_root=True, tree_references=True)
117
        err = self.assertRaises(InventoryDeltaError,
2023
120
        err = self.assertRaises(errors.BzrError,
118
            deserializer.parse_text_bytes,
2020
121
            serializer.parse_text_bytes,
2024
122
            'format: bzr inventory delta v1 (bzr 1.14)\n'
119
            'format: bzr inventory delta v1 (bzr 1.14)\n'
2025
123
            'parent: null:\n')
120
            'parent: null:\n')
2026
124
        self.assertContainsRe(str(err), 'missing version: marker')
121
        self.assertContainsRe(str(err), 'missing version: marker')
2027
125
            
122
            
2028
126
    def test_parse_duplicate_key_errors(self):
123
    def test_parse_duplicate_key_errors(self):
2031
127
        serializer = inventory_delta.InventoryDeltaSerializer(
124
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2030
128
            versioned_root=True, tree_references=True)
2032
129
        double_root_lines = \
125
        double_root_lines = \
2033
130
"""format: bzr inventory delta v1 (bzr 1.14)
126
"""format: bzr inventory delta v1 (bzr 1.14)
2034
131
parent: null:
127
parent: null:
2035
@@ -135,24 +131,23 @@
2036
135
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
131
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
2037
136
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
132
None\x00/\x00an-id\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
2038
137
"""
133
"""
2041
138
        err = self.assertRaises(errors.BzrError,
134
        err = self.assertRaises(InventoryDeltaError,
2042
139
            serializer.parse_text_bytes, double_root_lines)
135
            deserializer.parse_text_bytes, double_root_lines)
2043
140
        self.assertContainsRe(str(err), 'duplicate file id')
136
        self.assertContainsRe(str(err), 'duplicate file id')
2044
141
137
2045
142
    def test_parse_versioned_root_only(self):
138
    def test_parse_versioned_root_only(self):
2049
143
        serializer = inventory_delta.InventoryDeltaSerializer(
139
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2050
144
            versioned_root=True, tree_references=True)
140
        parse_result = deserializer.parse_text_bytes(root_only_lines)
2048
145
        parse_result = serializer.parse_text_bytes(root_only_lines)
2051
146
        expected_entry = inventory.make_entry(
141
        expected_entry = inventory.make_entry(
2052
147
            'directory', u'', None, 'an-id')
142
            'directory', u'', None, 'an-id')
2053
148
        expected_entry.revision = 'a@e\xc3\xa5ample.com--2004'
143
        expected_entry.revision = 'a@e\xc3\xa5ample.com--2004'
2054
149
        self.assertEqual(
144
        self.assertEqual(
2056
150
            ('null:', 'entry-version', [(None, '/', 'an-id', expected_entry)]),
145
            ('null:', 'entry-version', True, True,
2057
146
             [(None, '', 'an-id', expected_entry)]),
2058
151
            parse_result)
147
            parse_result)
2059
152
148
2060
153
    def test_parse_special_revid_not_valid_last_mod(self):
149
    def test_parse_special_revid_not_valid_last_mod(self):
2063
154
        serializer = inventory_delta.InventoryDeltaSerializer(
150
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2062
155
            versioned_root=False, tree_references=True)
2064
156
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
151
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
2065
157
parent: null:
152
parent: null:
2066
158
version: null:
153
version: null:
2067
@@ -160,13 +155,12 @@
2068
160
tree_references: true
155
tree_references: true
2069
161
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir\x00\x00
156
None\x00/\x00TREE_ROOT\x00\x00null:\x00dir\x00\x00
2070
162
"""
157
"""
2073
163
        err = self.assertRaises(errors.BzrError,
158
        err = self.assertRaises(InventoryDeltaError,
2074
164
            serializer.parse_text_bytes, root_only_lines)
159
            deserializer.parse_text_bytes, root_only_lines)
2075
165
        self.assertContainsRe(str(err), 'special revisionid found')
160
        self.assertContainsRe(str(err), 'special revisionid found')
2076
166
161
2077
167
    def test_parse_versioned_root_versioned_disabled(self):
162
    def test_parse_versioned_root_versioned_disabled(self):
2080
168
        serializer = inventory_delta.InventoryDeltaSerializer(
163
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2079
169
            versioned_root=False, tree_references=True)
2081
170
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
164
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
2082
171
parent: null:
165
parent: null:
2083
172
version: null:
166
version: null:
2084
@@ -174,39 +168,134 @@
2085
174
tree_references: true
168
tree_references: true
2086
175
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
169
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir\x00\x00
2087
176
"""
170
"""
2090
177
        err = self.assertRaises(errors.BzrError,
171
        err = self.assertRaises(InventoryDeltaError,
2091
178
            serializer.parse_text_bytes, root_only_lines)
172
            deserializer.parse_text_bytes, root_only_lines)
2092
179
        self.assertContainsRe(str(err), 'Versioned root found')
173
        self.assertContainsRe(str(err), 'Versioned root found')
2093
180
174
2094
181
    def test_parse_unique_root_id_root_versioned_disabled(self):
175
    def test_parse_unique_root_id_root_versioned_disabled(self):
2097
182
        serializer = inventory_delta.InventoryDeltaSerializer(
176
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2096
183
            versioned_root=False, tree_references=True)
2098
184
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
177
        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
2101
185
parent: null:
178
parent: parent-id
2102
186
version: null:
179
version: a@e\xc3\xa5ample.com--2004
2103
187
versioned_root: false
180
versioned_root: false
2104
188
tree_references: true
181
tree_references: true
2106
189
None\x00/\x00an-id\x00\x00null:\x00dir\x00\x00
182
None\x00/\x00an-id\x00\x00parent-id\x00dir\x00\x00
2107
190
"""
183
"""
2110
191
        err = self.assertRaises(errors.BzrError,
184
        err = self.assertRaises(InventoryDeltaError,
2111
192
            serializer.parse_text_bytes, root_only_lines)
185
            deserializer.parse_text_bytes, root_only_lines)
2112
193
        self.assertContainsRe(str(err), 'Versioned root found')
186
        self.assertContainsRe(str(err), 'Versioned root found')
2113
194
187
2114
195
    def test_parse_unversioned_root_versioning_enabled(self):
188
    def test_parse_unversioned_root_versioning_enabled(self):
2121
196
        serializer = inventory_delta.InventoryDeltaSerializer(
189
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2122
197
            versioned_root=True, tree_references=True)
190
        parse_result = deserializer.parse_text_bytes(root_only_unversioned)
2123
198
        err = self.assertRaises(errors.BzrError,
191
        expected_entry = inventory.make_entry(
2124
199
            serializer.parse_text_bytes, root_only_unversioned)
192
            'directory', u'', None, 'TREE_ROOT')
2125
200
        self.assertContainsRe(
193
        expected_entry.revision = 'entry-version'
2126
201
            str(err), 'serialized versioned_root flag is wrong: False')
194
        self.assertEqual(
2127
195
            ('null:', 'entry-version', False, False,
2128
196
             [(None, u'', 'TREE_ROOT', expected_entry)]),
2129
197
            parse_result)
2130
198
2131
199
    def test_parse_versioned_root_when_disabled(self):
2132
200
        deserializer = inventory_delta.InventoryDeltaDeserializer(
2133
201
            allow_versioned_root=False)
2134
202
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
2135
203
            deserializer.parse_text_bytes, root_only_lines)
2136
204
        self.assertEquals("versioned_root not allowed", str(err))
2137
202
205
2138
203
    def test_parse_tree_when_disabled(self):
206
    def test_parse_tree_when_disabled(self):
2145
204
        serializer = inventory_delta.InventoryDeltaSerializer(
207
        deserializer = inventory_delta.InventoryDeltaDeserializer(
2146
205
            versioned_root=True, tree_references=False)
208
            allow_tree_references=False)
2147
206
        err = self.assertRaises(errors.BzrError,
209
        err = self.assertRaises(inventory_delta.IncompatibleInventoryDelta,
2148
207
            serializer.parse_text_bytes, reference_lines)
210
            deserializer.parse_text_bytes, reference_lines)
2149
208
        self.assertContainsRe(
211
        self.assertEquals("Tree reference not allowed", str(err))
2150
209
            str(err), 'serialized tree_references flag is wrong: True')
212
2151
213
    def test_parse_tree_when_header_disallows(self):
2152
214
        # A deserializer that allows tree_references to be set or unset.
2153
215
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2154
216
        # A serialised inventory delta with a header saying no tree refs, but
2155
217
        # that has a tree ref in its content.
2156
218
        lines = """format: bzr inventory delta v1 (bzr 1.14)
2157
219
parent: null:
2158
220
version: entry-version
2159
221
versioned_root: false
2160
222
tree_references: false
2161
223
None\x00/foo\x00id\x00TREE_ROOT\x00changed\x00tree\x00subtree-version
2162
224
"""
2163
225
        err = self.assertRaises(InventoryDeltaError,
2164
226
            deserializer.parse_text_bytes, lines)
2165
227
        self.assertContainsRe(str(err), 'Tree reference found')
2166
228
2167
229
    def test_parse_versioned_root_when_header_disallows(self):
2168
230
        # A deserializer that allows tree_references to be set or unset.
2169
231
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2170
232
        # A serialised inventory delta with a header saying no tree refs, but
2171
233
        # that has a tree ref in its content.
2172
234
        lines = """format: bzr inventory delta v1 (bzr 1.14)
2173
235
parent: null:
2174
236
version: entry-version
2175
237
versioned_root: false
2176
238
tree_references: false
2177
239
None\x00/\x00TREE_ROOT\x00\x00a@e\xc3\xa5ample.com--2004\x00dir
2178
240
"""
2179
241
        err = self.assertRaises(InventoryDeltaError,
2180
242
            deserializer.parse_text_bytes, lines)
2181
243
        self.assertContainsRe(str(err), 'Versioned root found')
2182
244
2183
245
    def test_parse_last_line_not_empty(self):
2184
246
        """newpath must start with / if it is not None."""
2185
247
        # Trim the trailing newline from a valid serialization
2186
248
        lines = root_only_lines[:-1]
2187
249
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2188
250
        err = self.assertRaises(InventoryDeltaError,
2189
251
            deserializer.parse_text_bytes, lines)
2190
252
        self.assertContainsRe(str(err), 'last line not empty')
2191
253
2192
254
    def test_parse_invalid_newpath(self):
2193
255
        """newpath must start with / if it is not None."""
2194
256
        lines = empty_lines
2195
257
        lines += "None\x00bad\x00TREE_ROOT\x00\x00version\x00dir\n"
2196
258
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2197
259
        err = self.assertRaises(InventoryDeltaError,
2198
260
            deserializer.parse_text_bytes, lines)
2199
261
        self.assertContainsRe(str(err), 'newpath invalid')
2200
262
2201
263
    def test_parse_invalid_oldpath(self):
2202
264
        """oldpath must start with / if it is not None."""
2203
265
        lines = root_only_lines
2204
266
        lines += "bad\x00/new\x00file-id\x00\x00version\x00dir\n"
2205
267
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2206
268
        err = self.assertRaises(InventoryDeltaError,
2207
269
            deserializer.parse_text_bytes, lines)
2208
270
        self.assertContainsRe(str(err), 'oldpath invalid')
2209
271
    
2210
272
    def test_parse_new_file(self):
2211
273
        """a new file is parsed correctly"""
2212
274
        lines = root_only_lines
2213
275
        fake_sha = "deadbeef" * 5
2214
276
        lines += (
2215
277
            "None\x00/new\x00file-id\x00an-id\x00version\x00file\x00123\x00" +
2216
278
            "\x00" + fake_sha + "\n")
2217
279
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2218
280
        parse_result = deserializer.parse_text_bytes(lines)
2219
281
        expected_entry = inventory.make_entry(
2220
282
            'file', u'new', 'an-id', 'file-id')
2221
283
        expected_entry.revision = 'version'
2222
284
        expected_entry.text_size = 123
2223
285
        expected_entry.text_sha1 = fake_sha
2224
286
        delta = parse_result[4]
2225
287
        self.assertEqual(
2226
288
             (None, u'new', 'file-id', expected_entry), delta[-1])
2227
289
2228
290
    def test_parse_delete(self):
2229
291
        lines = root_only_lines
2230
292
        lines += (
2231
293
            "/old-file\x00None\x00deleted-id\x00\x00null:\x00deleted\x00\x00\n")
2232
294
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2233
295
        parse_result = deserializer.parse_text_bytes(lines)
2234
296
        delta = parse_result[4]
2235
297
        self.assertEqual(
2236
298
             (u'old-file', None, 'deleted-id', None), delta[-1])
2237
210
299
2238
211
300
2239
212
class TestSerialization(TestCase):
301
class TestSerialization(TestCase):
2240
@@ -237,12 +326,20 @@
2241
237
        old_inv = Inventory(None)
326
        old_inv = Inventory(None)
2242
238
        new_inv = Inventory(None)
327
        new_inv = Inventory(None)
2243
239
        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
328
        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
2244
329
        # Implicit roots are considered modified in every revision.
2245
330
        root.revision = 'entry-version'
2246
240
        new_inv.add(root)
331
        new_inv.add(root)
2247
241
        delta = new_inv._make_delta(old_inv)
332
        delta = new_inv._make_delta(old_inv)
2248
242
        serializer = inventory_delta.InventoryDeltaSerializer(
333
        serializer = inventory_delta.InventoryDeltaSerializer(
2249
243
            versioned_root=False, tree_references=False)
334
            versioned_root=False, tree_references=False)
2250
335
        serialized_lines = serializer.delta_to_lines(
2251
336
            NULL_REVISION, 'entry-version', delta)
2252
244
        self.assertEqual(StringIO(root_only_unversioned).readlines(),
337
        self.assertEqual(StringIO(root_only_unversioned).readlines(),
2254
245
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
338
            serialized_lines)
2255
339
        deserializer = inventory_delta.InventoryDeltaDeserializer()
2256
340
        self.assertEqual(
2257
341
            (NULL_REVISION, 'entry-version', False, False, delta),
2258
342
            deserializer.parse_text_bytes(''.join(serialized_lines)))
2259
246
343
2260
247
    def test_unversioned_non_root_errors(self):
344
    def test_unversioned_non_root_errors(self):
2261
248
        old_inv = Inventory(None)
345
        old_inv = Inventory(None)
2262
@@ -255,7 +352,7 @@
2263
255
        delta = new_inv._make_delta(old_inv)
352
        delta = new_inv._make_delta(old_inv)
2264
256
        serializer = inventory_delta.InventoryDeltaSerializer(
353
        serializer = inventory_delta.InventoryDeltaSerializer(
2265
257
            versioned_root=True, tree_references=True)
354
            versioned_root=True, tree_references=True)
2267
258
        err = self.assertRaises(errors.BzrError,
355
        err = self.assertRaises(InventoryDeltaError,
2268
259
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
356
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
2269
260
        self.assertEqual(str(err), 'no version for fileid id')
357
        self.assertEqual(str(err), 'no version for fileid id')
2270
261
358
2271
@@ -267,7 +364,7 @@
2272
267
        delta = new_inv._make_delta(old_inv)
364
        delta = new_inv._make_delta(old_inv)
2273
268
        serializer = inventory_delta.InventoryDeltaSerializer(
365
        serializer = inventory_delta.InventoryDeltaSerializer(
2274
269
            versioned_root=True, tree_references=True)
366
            versioned_root=True, tree_references=True)
2276
270
        err = self.assertRaises(errors.BzrError,
367
        err = self.assertRaises(InventoryDeltaError,
2277
271
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
368
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
2278
272
        self.assertEqual(str(err), 'no version for fileid TREE_ROOT')
369
        self.assertEqual(str(err), 'no version for fileid TREE_ROOT')
2279
273
370
2280
@@ -280,22 +377,9 @@
2281
280
        delta = new_inv._make_delta(old_inv)
377
        delta = new_inv._make_delta(old_inv)
2282
281
        serializer = inventory_delta.InventoryDeltaSerializer(
378
        serializer = inventory_delta.InventoryDeltaSerializer(
2283
282
            versioned_root=False, tree_references=True)
379
            versioned_root=False, tree_references=True)
2300
283
        err = self.assertRaises(errors.BzrError,
380
        err = self.assertRaises(InventoryDeltaError,
2301
284
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
381
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
2302
285
        self.assertEqual(str(err), 'Version present for / in TREE_ROOT')
382
        self.assertStartsWith(str(err), 'Version present for / in TREE_ROOT')
2287
286
2288
287
    def test_nonrichroot_non_TREE_ROOT_id_errors(self):
2289
288
        old_inv = Inventory(None)
2290
289
        new_inv = Inventory(None)
2291
290
        root = new_inv.make_entry('directory', '', None, 'my-rich-root-id')
2292
291
        new_inv.add(root)
2293
292
        delta = new_inv._make_delta(old_inv)
2294
293
        serializer = inventory_delta.InventoryDeltaSerializer(
2295
294
            versioned_root=False, tree_references=True)
2296
295
        err = self.assertRaises(errors.BzrError,
2297
296
            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
2298
297
        self.assertEqual(
2299
298
            str(err), 'file_id my-rich-root-id is not TREE_ROOT for /')
2303
299
383
2304
300
    def test_unknown_kind_errors(self):
384
    def test_unknown_kind_errors(self):
2305
301
        old_inv = Inventory(None)
385
        old_inv = Inventory(None)
2306
@@ -354,19 +438,22 @@
2307
354
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
438
            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
2308
355
439
2309
356
    def test_to_inventory_root_id_versioned_not_permitted(self):
440
    def test_to_inventory_root_id_versioned_not_permitted(self):
2313
357
        delta = [(None, '/', 'TREE_ROOT', inventory.make_entry(
441
        root_entry = inventory.make_entry('directory', '', None, 'TREE_ROOT')
2314
358
            'directory', '', None, 'TREE_ROOT'))]
442
        root_entry.revision = 'some-version'
2315
359
        serializer = inventory_delta.InventoryDeltaSerializer(False, True)
443
        delta = [(None, '', 'TREE_ROOT', root_entry)]
2316
444
        serializer = inventory_delta.InventoryDeltaSerializer(
2317
445
            versioned_root=False, tree_references=True)
2318
360
        self.assertRaises(
446
        self.assertRaises(
2320
361
            errors.BzrError, serializer.delta_to_lines, 'old-version',
447
            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
2321
362
            'new-version', delta)
448
            'new-version', delta)
2322
363
449
2323
364
    def test_to_inventory_root_id_not_versioned(self):
450
    def test_to_inventory_root_id_not_versioned(self):
2325
365
        delta = [(None, '/', 'an-id', inventory.make_entry(
451
        delta = [(None, '', 'an-id', inventory.make_entry(
2326
366
            'directory', '', None, 'an-id'))]
452
            'directory', '', None, 'an-id'))]
2328
367
        serializer = inventory_delta.InventoryDeltaSerializer(True, True)
453
        serializer = inventory_delta.InventoryDeltaSerializer(
2329
454
            versioned_root=True, tree_references=True)
2330
368
        self.assertRaises(
455
        self.assertRaises(
2332
369
            errors.BzrError, serializer.delta_to_lines, 'old-version',
456
            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
2333
370
            'new-version', delta)
457
            'new-version', delta)
2334
371
458
2335
372
    def test_to_inventory_has_tree_not_meant_to(self):
459
    def test_to_inventory_has_tree_not_meant_to(self):
2336
@@ -374,13 +461,14 @@
2337
374
        tree_ref = make_entry('tree-reference', 'foo', 'changed-in', 'ref-id')
461
        tree_ref = make_entry('tree-reference', 'foo', 'changed-in', 'ref-id')
2338
375
        tree_ref.reference_revision = 'ref-revision'
462
        tree_ref.reference_revision = 'ref-revision'
2339
376
        delta = [
463
        delta = [
2341
377
            (None, '/', 'an-id',
464
            (None, '', 'an-id',
2342
378
             make_entry('directory', '', 'changed-in', 'an-id')),
465
             make_entry('directory', '', 'changed-in', 'an-id')),
2344
379
            (None, '/foo', 'ref-id', tree_ref)
466
            (None, 'foo', 'ref-id', tree_ref)
2345
380
            # a file that followed the root move
467
            # a file that followed the root move
2346
381
            ]
468
            ]
2349
382
        serializer = inventory_delta.InventoryDeltaSerializer(True, True)
469
        serializer = inventory_delta.InventoryDeltaSerializer(
2350
383
        self.assertRaises(errors.BzrError, serializer.delta_to_lines,
470
            versioned_root=True, tree_references=True)
2351
471
        self.assertRaises(InventoryDeltaError, serializer.delta_to_lines,
2352
384
            'old-version', 'new-version', delta)
472
            'old-version', 'new-version', delta)
2353
385
473
2354
386
    def test_to_inventory_torture(self):
474
    def test_to_inventory_torture(self):
2355
@@ -430,7 +518,8 @@
2356
430
                   executable=True, text_size=30, text_sha1='some-sha',
518
                   executable=True, text_size=30, text_sha1='some-sha',
2357
431
                   revision='old-rev')),
519
                   revision='old-rev')),
2358
432
            ]
520
            ]
2360
433
        serializer = inventory_delta.InventoryDeltaSerializer(True, True)
521
        serializer = inventory_delta.InventoryDeltaSerializer(
2361
522
            versioned_root=True, tree_references=True)
2362
434
        lines = serializer.delta_to_lines(NULL_REVISION, 'something', delta)
523
        lines = serializer.delta_to_lines(NULL_REVISION, 'something', delta)
2363
435
        expected = """format: bzr inventory delta v1 (bzr 1.14)
524
        expected = """format: bzr inventory delta v1 (bzr 1.14)
2364
436
parent: null:
525
parent: null:
2365
@@ -483,13 +572,13 @@
2366
483
    def test_file_without_size(self):
572
    def test_file_without_size(self):
2367
484
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
573
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
2368
485
        file_entry.text_sha1 = 'foo'
574
        file_entry.text_sha1 = 'foo'
2370
486
        self.assertRaises(errors.BzrError,
575
        self.assertRaises(InventoryDeltaError,
2371
487
            inventory_delta._file_content, file_entry)
576
            inventory_delta._file_content, file_entry)
2372
488
577
2373
489
    def test_file_without_sha1(self):
578
    def test_file_without_sha1(self):
2374
490
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
579
        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
2375
491
        file_entry.text_size = 10
580
        file_entry.text_size = 10
2377
492
        self.assertRaises(errors.BzrError,
581
        self.assertRaises(InventoryDeltaError,
2378
493
            inventory_delta._file_content, file_entry)
582
            inventory_delta._file_content, file_entry)
2379
494
583
2380
495
    def test_link_empty_target(self):
584
    def test_link_empty_target(self):
2381
@@ -512,7 +601,7 @@
2382
512
601
2383
513
    def test_link_no_target(self):
602
    def test_link_no_target(self):
2384
514
        entry = inventory.make_entry('symlink', 'a link', None)
603
        entry = inventory.make_entry('symlink', 'a link', None)
2386
515
        self.assertRaises(errors.BzrError,
604
        self.assertRaises(InventoryDeltaError,
2387
516
            inventory_delta._link_content, entry)
605
            inventory_delta._link_content, entry)
2388
517
606
2389
518
    def test_reference_null(self):
607
    def test_reference_null(self):
2390
@@ -529,5 +618,5 @@
2391
529
618
2392
530
    def test_reference_no_reference(self):
619
    def test_reference_no_reference(self):
2393
531
        entry = inventory.make_entry('tree-reference', 'a tree', None)
620
        entry = inventory.make_entry('tree-reference', 'a tree', None)
2395
532
        self.assertRaises(errors.BzrError,
621
        self.assertRaises(InventoryDeltaError,
2396
533
            inventory_delta._reference_content, entry)
622
            inventory_delta._reference_content, entry)
2397
534
623
2398
=== modified file 'bzrlib/tests/test_remote.py'
2399
--- bzrlib/tests/test_remote.py	2009-08-11 05:26:57 +0000
2400
+++ bzrlib/tests/test_remote.py	2009-08-14 05:35:32 +0000
2401
@@ -31,6 +31,8 @@
2402
31
    config,
31
    config,
2403
32
    errors,
32
    errors,
2404
33
    graph,
33
    graph,
2405
34
    inventory,
2406
35
    inventory_delta,
2407
34
    pack,
36
    pack,
2408
35
    remote,
37
    remote,
2409
36
    repository,
38
    repository,
2410
@@ -38,6 +40,7 @@
2411
38
    tests,
40
    tests,
2412
39
    treebuilder,
41
    treebuilder,
2413
40
    urlutils,
42
    urlutils,
2414
43
    versionedfile,
2415
41
    )
44
    )
2416
42
from bzrlib.branch import Branch
45
from bzrlib.branch import Branch
2417
43
from bzrlib.bzrdir import BzrDir, BzrDirFormat
46
from bzrlib.bzrdir import BzrDir, BzrDirFormat
2418
@@ -332,15 +335,6 @@
2419
332
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
335
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
2420
333
        return reference_bzrdir_format.repository_format
336
        return reference_bzrdir_format.repository_format
2421
334
337
2422
335
    def disable_verb(self, verb):
2423
336
        """Disable a verb for one test."""
2424
337
        request_handlers = smart.request.request_handlers
2425
338
        orig_method = request_handlers.get(verb)
2426
339
        request_handlers.remove(verb)
2427
340
        def restoreVerb():
2428
341
            request_handlers.register(verb, orig_method)
2429
342
        self.addCleanup(restoreVerb)
2430
343
2431
344
    def assertFinished(self, fake_client):
338
    def assertFinished(self, fake_client):
2432
345
        """Assert that all of a FakeClient's expected calls have occurred."""
339
        """Assert that all of a FakeClient's expected calls have occurred."""
2433
346
        fake_client.finished_test()
340
        fake_client.finished_test()
2434
@@ -2219,63 +2213,219 @@
2435
2219
        self.assertEqual([], client._calls)
2213
        self.assertEqual([], client._calls)
2436
2220
2214
2437
2221
2215
2495
2222
class TestRepositoryInsertStream(TestRemoteRepository):
2216
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2496
2223
2217
    """Base class for Repository.insert_stream and .insert_stream_1.19
2497
2224
    def test_unlocked_repo(self):
2218
    tests.
2498
2225
        transport_path = 'quack'
2219
    """
2499
2226
        repo, client = self.setup_fake_client_and_repository(transport_path)
2220
    
2500
2227
        client.add_expected_call(
2221
    def checkInsertEmptyStream(self, repo, client):
2501
2228
            'Repository.insert_stream', ('quack/', ''),
2222
        """Insert an empty stream, checking the result.
2502
2229
            'success', ('ok',))
2223
2503
2230
        client.add_expected_call(
2224
        This checks that there are no resume_tokens or missing_keys, and that
2504
2231
            'Repository.insert_stream', ('quack/', ''),
2225
        the client is finished.
2505
2232
            'success', ('ok',))
2226
        """
2506
2233
        sink = repo._get_sink()
2227
        sink = repo._get_sink()
2507
2234
        fmt = repository.RepositoryFormat.get_default_format()
2228
        fmt = repository.RepositoryFormat.get_default_format()
2508
2235
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2229
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2509
2236
        self.assertEqual([], resume_tokens)
2230
        self.assertEqual([], resume_tokens)
2510
2237
        self.assertEqual(set(), missing_keys)
2231
        self.assertEqual(set(), missing_keys)
2511
2238
        self.assertFinished(client)
2232
        self.assertFinished(client)
2512
2239
2233
2513
2240
    def test_locked_repo_with_no_lock_token(self):
2234
2514
2241
        transport_path = 'quack'
2235
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
2515
2242
        repo, client = self.setup_fake_client_and_repository(transport_path)
2236
    """Tests for using Repository.insert_stream verb when the _1.19 variant is
2516
2243
        client.add_expected_call(
2237
    not available.
2517
2244
            'Repository.lock_write', ('quack/', ''),
2238
2518
2245
            'success', ('ok', ''))
2239
    This test case is very similar to TestRepositoryInsertStream_1_19.
2519
2246
        client.add_expected_call(
2240
    """
2520
2247
            'Repository.insert_stream', ('quack/', ''),
2241
2521
2248
            'success', ('ok',))
2242
    def setUp(self):
2522
2249
        client.add_expected_call(
2243
        TestRemoteRepository.setUp(self)
2523
2250
            'Repository.insert_stream', ('quack/', ''),
2244
        self.disable_verb('Repository.insert_stream_1.19')
2524
2251
            'success', ('ok',))
2245
2525
2252
        repo.lock_write()
2246
    def test_unlocked_repo(self):
2526
2253
        sink = repo._get_sink()
2247
        transport_path = 'quack'
2527
2254
        fmt = repository.RepositoryFormat.get_default_format()
2248
        repo, client = self.setup_fake_client_and_repository(transport_path)
2528
2255
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2249
        client.add_expected_call(
2529
2256
        self.assertEqual([], resume_tokens)
2250
            'Repository.insert_stream_1.19', ('quack/', ''),
2530
2257
        self.assertEqual(set(), missing_keys)
2251
            'unknown', ('Repository.insert_stream_1.19',))
2531
2258
        self.assertFinished(client)
2252
        client.add_expected_call(
2532
2259
2253
            'Repository.insert_stream', ('quack/', ''),
2533
2260
    def test_locked_repo_with_lock_token(self):
2254
            'success', ('ok',))
2534
2261
        transport_path = 'quack'
2255
        client.add_expected_call(
2535
2262
        repo, client = self.setup_fake_client_and_repository(transport_path)
2256
            'Repository.insert_stream', ('quack/', ''),
2536
2263
        client.add_expected_call(
2257
            'success', ('ok',))
2537
2264
            'Repository.lock_write', ('quack/', ''),
2258
        self.checkInsertEmptyStream(repo, client)
2538
2265
            'success', ('ok', 'a token'))
2259
2539
2266
        client.add_expected_call(
2260
    def test_locked_repo_with_no_lock_token(self):
2540
2267
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2261
        transport_path = 'quack'
2541
2268
            'success', ('ok',))
2262
        repo, client = self.setup_fake_client_and_repository(transport_path)
2542
2269
        client.add_expected_call(
2263
        client.add_expected_call(
2543
2270
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2264
            'Repository.lock_write', ('quack/', ''),
2544
2271
            'success', ('ok',))
2265
            'success', ('ok', ''))
2545
2272
        repo.lock_write()
2266
        client.add_expected_call(
2546
2273
        sink = repo._get_sink()
2267
            'Repository.insert_stream_1.19', ('quack/', ''),
2547
2274
        fmt = repository.RepositoryFormat.get_default_format()
2268
            'unknown', ('Repository.insert_stream_1.19',))
2548
2275
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2269
        client.add_expected_call(
2549
2276
        self.assertEqual([], resume_tokens)
2270
            'Repository.insert_stream', ('quack/', ''),
2550
2277
        self.assertEqual(set(), missing_keys)
2271
            'success', ('ok',))
2551
2278
        self.assertFinished(client)
2272
        client.add_expected_call(
2552
2273
            'Repository.insert_stream', ('quack/', ''),
2553
2274
            'success', ('ok',))
2554
2275
        repo.lock_write()
2555
2276
        self.checkInsertEmptyStream(repo, client)
2556
2277
2557
2278
    def test_locked_repo_with_lock_token(self):
2558
2279
        transport_path = 'quack'
2559
2280
        repo, client = self.setup_fake_client_and_repository(transport_path)
2560
2281
        client.add_expected_call(
2561
2282
            'Repository.lock_write', ('quack/', ''),
2562
2283
            'success', ('ok', 'a token'))
2563
2284
        client.add_expected_call(
2564
2285
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2565
2286
            'unknown', ('Repository.insert_stream_1.19',))
2566
2287
        client.add_expected_call(
2567
2288
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2568
2289
            'success', ('ok',))
2569
2290
        client.add_expected_call(
2570
2291
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2571
2292
            'success', ('ok',))
2572
2293
        repo.lock_write()
2573
2294
        self.checkInsertEmptyStream(repo, client)
2574
2295
2575
2296
    def test_stream_with_inventory_deltas(self):
2576
2297
        """'inventory-deltas' substreams cannot be sent to the
2577
2298
        Repository.insert_stream verb, because not all servers that implement
2578
2299
        that verb will accept them.  So when one is encountered the RemoteSink
2579
2300
        immediately stops using that verb and falls back to VFS insert_stream.
2580
2301
        """
2581
2302
        transport_path = 'quack'
2582
2303
        repo, client = self.setup_fake_client_and_repository(transport_path)
2583
2304
        client.add_expected_call(
2584
2305
            'Repository.insert_stream_1.19', ('quack/', ''),
2585
2306
            'unknown', ('Repository.insert_stream_1.19',))
2586
2307
        client.add_expected_call(
2587
2308
            'Repository.insert_stream', ('quack/', ''),
2588
2309
            'success', ('ok',))
2589
2310
        client.add_expected_call(
2590
2311
            'Repository.insert_stream', ('quack/', ''),
2591
2312
            'success', ('ok',))
2592
2313
        # Create a fake real repository for insert_stream to fall back on, so
2593
2314
        # that we can directly see the records the RemoteSink passes to the
2594
2315
        # real sink.
2595
2316
        class FakeRealSink:
2596
2317
            def __init__(self):
2597
2318
                self.records = []
2598
2319
            def insert_stream(self, stream, src_format, resume_tokens):
2599
2320
                for substream_kind, substream in stream:
2600
2321
                    self.records.append(
2601
2322
                        (substream_kind, [record.key for record in substream]))
2602
2323
                return ['fake tokens'], ['fake missing keys']
2603
2324
        fake_real_sink = FakeRealSink()
2604
2325
        class FakeRealRepository:
2605
2326
            def _get_sink(self):
2606
2327
                return fake_real_sink
2607
2328
        repo._real_repository = FakeRealRepository()
2608
2329
        sink = repo._get_sink()
2609
2330
        fmt = repository.RepositoryFormat.get_default_format()
2610
2331
        stream = self.make_stream_with_inv_deltas(fmt)
2611
2332
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2612
2333
        # Every record from the first inventory delta should have been sent to
2613
2334
        # the VFS sink.
2614
2335
        expected_records = [
2615
2336
            ('inventory-deltas', [('rev2',), ('rev3',)]),
2616
2337
            ('texts', [('some-rev', 'some-file')])]
2617
2338
        self.assertEqual(expected_records, fake_real_sink.records)
2618
2339
        # The return values from the real sink's insert_stream are propagated
2619
2340
        # back to the original caller.
2620
2341
        self.assertEqual(['fake tokens'], resume_tokens)
2621
2342
        self.assertEqual(['fake missing keys'], missing_keys)
2622
2343
        self.assertFinished(client)
2623
2344
2624
2345
    def make_stream_with_inv_deltas(self, fmt):
2625
2346
        """Make a simple stream with an inventory delta followed by more
2626
2347
        records and more substreams to test that all records and substreams
2627
2348
        from that point on are used.
2628
2349
2629
2350
        This sends, in order:
2630
2351
           * inventories substream: rev1, rev2, rev3.  rev2 and rev3 are
2631
2352
             inventory-deltas.
2632
2353
           * texts substream: (some-rev, some-file)
2633
2354
        """
2634
2355
        # Define a stream using generators so that it isn't rewindable.
2635
2356
        inv = inventory.Inventory(revision_id='rev1')
2636
2357
        def stream_with_inv_delta():
2637
2358
            yield ('inventories', inventories_substream())
2638
2359
            yield ('inventory-deltas', inventory_delta_substream())
2639
2360
            yield ('texts', [
2640
2361
                versionedfile.FulltextContentFactory(
2641
2362
                    ('some-rev', 'some-file'), (), None, 'content')])
2642
2363
        def inventories_substream():
2643
2364
            # An empty inventory fulltext.  This will be streamed normally.
2644
2365
            text = fmt._serializer.write_inventory_to_string(inv)
2645
2366
            yield versionedfile.FulltextContentFactory(
2646
2367
                ('rev1',), (), None, text)
2647
2368
        def inventory_delta_substream():
2648
2369
            # An inventory delta.  This can't be streamed via this verb, so it
2649
2370
            # will trigger a fallback to VFS insert_stream.
2650
2371
            entry = inv.make_entry(
2651
2372
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
2652
2373
            entry.revision = 'ghost'
2653
2374
            delta = [(None, 'newdir', 'newdir-id', entry)]
2654
2375
            serializer = inventory_delta.InventoryDeltaSerializer(
2655
2376
                versioned_root=True, tree_references=False)
2656
2377
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2657
2378
            yield versionedfile.ChunkedContentFactory(
2658
2379
                ('rev2',), (('rev1',)), None, lines)
2659
2380
            # Another delta.
2660
2381
            lines = serializer.delta_to_lines('rev1', 'rev3', delta)
2661
2382
            yield versionedfile.ChunkedContentFactory(
2662
2383
                ('rev3',), (('rev1',)), None, lines)
2663
2384
        return stream_with_inv_delta()
2664
2385
2665
2386
2666
2387
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
2667
2388
2668
2389
    def test_unlocked_repo(self):
2669
2390
        transport_path = 'quack'
2670
2391
        repo, client = self.setup_fake_client_and_repository(transport_path)
2671
2392
        client.add_expected_call(
2672
2393
            'Repository.insert_stream_1.19', ('quack/', ''),
2673
2394
            'success', ('ok',))
2674
2395
        client.add_expected_call(
2675
2396
            'Repository.insert_stream_1.19', ('quack/', ''),
2676
2397
            'success', ('ok',))
2677
2398
        self.checkInsertEmptyStream(repo, client)
2678
2399
2679
2400
    def test_locked_repo_with_no_lock_token(self):
2680
2401
        transport_path = 'quack'
2681
2402
        repo, client = self.setup_fake_client_and_repository(transport_path)
2682
2403
        client.add_expected_call(
2683
2404
            'Repository.lock_write', ('quack/', ''),
2684
2405
            'success', ('ok', ''))
2685
2406
        client.add_expected_call(
2686
2407
            'Repository.insert_stream_1.19', ('quack/', ''),
2687
2408
            'success', ('ok',))
2688
2409
        client.add_expected_call(
2689
2410
            'Repository.insert_stream_1.19', ('quack/', ''),
2690
2411
            'success', ('ok',))
2691
2412
        repo.lock_write()
2692
2413
        self.checkInsertEmptyStream(repo, client)
2693
2414
2694
2415
    def test_locked_repo_with_lock_token(self):
2695
2416
        transport_path = 'quack'
2696
2417
        repo, client = self.setup_fake_client_and_repository(transport_path)
2697
2418
        client.add_expected_call(
2698
2419
            'Repository.lock_write', ('quack/', ''),
2699
2420
            'success', ('ok', 'a token'))
2700
2421
        client.add_expected_call(
2701
2422
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2702
2423
            'success', ('ok',))
2703
2424
        client.add_expected_call(
2704
2425
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2705
2426
            'success', ('ok',))
2706
2427
        repo.lock_write()
2707
2428
        self.checkInsertEmptyStream(repo, client)
2708
2279
2429
2709
2280
2430
2710
2281
class TestRepositoryTarball(TestRemoteRepository):
2431
class TestRepositoryTarball(TestRemoteRepository):
2711
2282
2432
2712
=== modified file 'bzrlib/tests/test_selftest.py'
2713
--- bzrlib/tests/test_selftest.py	2009-08-04 02:09:19 +0000
2714
+++ bzrlib/tests/test_selftest.py	2009-08-14 05:35:32 +0000
2715
@@ -124,7 +124,7 @@
2716
124
        self.assertEqual(sample_permutation,
124
        self.assertEqual(sample_permutation,
2717
125
                         get_transport_test_permutations(MockModule()))
125
                         get_transport_test_permutations(MockModule()))
2718
126
126
2720
127
    def test_scenarios_invlude_all_modules(self):
127
    def test_scenarios_include_all_modules(self):
2721
128
        # this checks that the scenario generator returns as many permutations
128
        # this checks that the scenario generator returns as many permutations
2722
129
        # as there are in all the registered transport modules - we assume if
129
        # as there are in all the registered transport modules - we assume if
2723
130
        # this matches its probably doing the right thing especially in
130
        # this matches its probably doing the right thing especially in
2724
@@ -293,18 +293,16 @@
2725
293
        from bzrlib.tests.per_interrepository import make_scenarios
293
        from bzrlib.tests.per_interrepository import make_scenarios
2726
294
        server1 = "a"
294
        server1 = "a"
2727
295
        server2 = "b"
295
        server2 = "b"
2729
296
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
296
        formats = [("C0", "C1", "C2"), ("D0", "D1", "D2")]
2730
297
        scenarios = make_scenarios(server1, server2, formats)
297
        scenarios = make_scenarios(server1, server2, formats)
2731
298
        self.assertEqual([
298
        self.assertEqual([
2735
299
            ('str,str,str',
299
            ('C0,str,str',
2736
300
             {'interrepo_class': str,
300
             {'repository_format': 'C1',
2734
301
              'repository_format': 'C1',
2737
302
              'repository_format_to': 'C2',
301
              'repository_format_to': 'C2',
2738
303
              'transport_readonly_server': 'b',
302
              'transport_readonly_server': 'b',
2739
304
              'transport_server': 'a'}),
303
              'transport_server': 'a'}),
2743
305
            ('int,str,str',
304
            ('D0,str,str',
2744
306
             {'interrepo_class': int,
305
             {'repository_format': 'D1',
2742
307
              'repository_format': 'D1',
2745
308
              'repository_format_to': 'D2',
306
              'repository_format_to': 'D2',
2746
309
              'transport_readonly_server': 'b',
307
              'transport_readonly_server': 'b',
2747
310
              'transport_server': 'a'})],
308
              'transport_server': 'a'})],
2748
311
309
2749
=== modified file 'bzrlib/tests/test_smart.py'
2750
--- bzrlib/tests/test_smart.py	2009-07-23 07:37:05 +0000
2751
+++ bzrlib/tests/test_smart.py	2009-08-14 05:35:32 +0000
2752
@@ -1242,6 +1242,7 @@
2753
1242
            SmartServerResponse(('history-incomplete', 2, r2)),
1242
            SmartServerResponse(('history-incomplete', 2, r2)),
2754
1243
            request.execute('stacked', 1, (3, r3)))
1243
            request.execute('stacked', 1, (3, r3)))
2755
1244
1244
2756
1245
2757
1245
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1246
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
2758
1246
1247
2759
1247
    def make_two_commit_repo(self):
1248
    def make_two_commit_repo(self):
2760
1248
1249
2761
=== modified file 'bzrlib/tests/test_xml.py'
2762
--- bzrlib/tests/test_xml.py	2009-04-03 21:50:40 +0000
2763
+++ bzrlib/tests/test_xml.py	2009-08-14 05:35:32 +0000
2764
@@ -19,6 +19,7 @@
2765
19
from bzrlib import (
19
from bzrlib import (
2766
20
    errors,
20
    errors,
2767
21
    inventory,
21
    inventory,
2768
22
    xml6,
2769
22
    xml7,
23
    xml7,
2770
23
    xml8,
24
    xml8,
2771
24
    serializer,
25
    serializer,
2772
@@ -139,6 +140,14 @@
2773
139
</inventory>
140
</inventory>
2774
140
"""
141
"""
2775
141
142
2776
143
_expected_inv_v6 = """<inventory format="6" revision_id="rev_outer">
2777
144
<directory file_id="tree-root-321" name="" revision="rev_outer" />
2778
145
<directory file_id="dir-id" name="dir" parent_id="tree-root-321" revision="rev_outer" />
2779
146
<file file_id="file-id" name="file" parent_id="tree-root-321" revision="rev_outer" text_sha1="A" text_size="1" />
2780
147
<symlink file_id="link-id" name="link" parent_id="tree-root-321" revision="rev_outer" symlink_target="a" />
2781
148
</inventory>
2782
149
"""
2783
150
2784
142
_expected_inv_v7 = """<inventory format="7" revision_id="rev_outer">
151
_expected_inv_v7 = """<inventory format="7" revision_id="rev_outer">
2785
143
<directory file_id="tree-root-321" name="" revision="rev_outer" />
152
<directory file_id="tree-root-321" name="" revision="rev_outer" />
2786
144
<directory file_id="dir-id" name="dir" parent_id="tree-root-321" revision="rev_outer" />
153
<directory file_id="dir-id" name="dir" parent_id="tree-root-321" revision="rev_outer" />
2787
@@ -377,6 +386,17 @@
2788
377
        for path, ie in inv.iter_entries():
386
        for path, ie in inv.iter_entries():
2789
378
            self.assertEqual(ie, inv2[ie.file_id])
387
            self.assertEqual(ie, inv2[ie.file_id])
2790
379
388
2791
389
    def test_roundtrip_inventory_v6(self):
2792
390
        inv = self.get_sample_inventory()
2793
391
        txt = xml6.serializer_v6.write_inventory_to_string(inv)
2794
392
        lines = xml6.serializer_v6.write_inventory_to_lines(inv)
2795
393
        self.assertEqual(bzrlib.osutils.split_lines(txt), lines)
2796
394
        self.assertEqualDiff(_expected_inv_v6, txt)
2797
395
        inv2 = xml6.serializer_v6.read_inventory_from_string(txt)
2798
396
        self.assertEqual(4, len(inv2))
2799
397
        for path, ie in inv.iter_entries():
2800
398
            self.assertEqual(ie, inv2[ie.file_id])
2801
399
2802
380
    def test_wrong_format_v7(self):
400
    def test_wrong_format_v7(self):
2803
381
        """Can't accidentally open a file with wrong serializer"""
401
        """Can't accidentally open a file with wrong serializer"""
2804
382
        s_v6 = bzrlib.xml6.serializer_v6
402
        s_v6 = bzrlib.xml6.serializer_v6
2805
383
403
2806
=== modified file 'bzrlib/versionedfile.py'
2807
--- bzrlib/versionedfile.py	2009-08-04 04:36:34 +0000
2808
+++ bzrlib/versionedfile.py	2009-08-14 05:35:32 +0000
2809
@@ -1571,13 +1571,14 @@
2810
1571
            record.get_bytes_as(record.storage_kind) call.
1571
            record.get_bytes_as(record.storage_kind) call.
2811
1572
        """
1572
        """
2812
1573
        self._bytes_iterator = bytes_iterator
1573
        self._bytes_iterator = bytes_iterator
2820
1574
        self._kind_factory = {'knit-ft-gz':knit.knit_network_to_record,
1574
        self._kind_factory = {
2821
1575
            'knit-delta-gz':knit.knit_network_to_record,
1575
            'fulltext': fulltext_network_to_record,
2822
1576
            'knit-annotated-ft-gz':knit.knit_network_to_record,
1576
            'groupcompress-block': groupcompress.network_block_to_records,
2823
1577
            'knit-annotated-delta-gz':knit.knit_network_to_record,
1577
            'knit-ft-gz': knit.knit_network_to_record,
2824
1578
            'knit-delta-closure':knit.knit_delta_closure_to_records,
1578
            'knit-delta-gz': knit.knit_network_to_record,
2825
1579
            'fulltext':fulltext_network_to_record,
1579
            'knit-annotated-ft-gz': knit.knit_network_to_record,
2826
1580
            'groupcompress-block':groupcompress.network_block_to_records,
1580
            'knit-annotated-delta-gz': knit.knit_network_to_record,
2827
1581
            'knit-delta-closure': knit.knit_delta_closure_to_records,
2828
1581
            }
1582
            }
2829
1582
1583
2830
1583
    def read(self):
1584
    def read(self):
2831
1584
1585
2832
=== modified file 'bzrlib/xml5.py'
2833
--- bzrlib/xml5.py	2009-04-04 02:50:01 +0000
2834
+++ bzrlib/xml5.py	2009-08-14 05:35:32 +0000
2835
@@ -39,8 +39,8 @@
2836
39
        format = elt.get('format')
39
        format = elt.get('format')
2837
40
        if format is not None:
40
        if format is not None:
2838
41
            if format != '5':
41
            if format != '5':
2841
42
                raise BzrError("invalid format version %r on inventory"
42
                raise errors.BzrError("invalid format version %r on inventory"
2842
43
                                % format)
43
                                      % format)
2843
44
        data_revision_id = elt.get('revision_id')
44
        data_revision_id = elt.get('revision_id')
2844
45
        if data_revision_id is not None:
45
        if data_revision_id is not None:
2845
46
            revision_id = cache_utf8.encode(data_revision_id)
46
            revision_id = cache_utf8.encode(data_revision_id)
Reviewer	Review Type	Date Requested	Status
John A Meinel		2009-08-05	Needs Fixing on 2009-08-06
Review via email: mp+9676@code.launchpad.net