~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/pack_repo.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-11 23:23:53 UTC
  • Revision ID: mbp@sourcefrog.net-20050311232353-f5e33da490872c6a
Add .bzrignore file

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2010 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
import re
18
 
import sys
19
 
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
22
 
from itertools import izip
23
 
import time
24
 
 
25
 
from bzrlib import (
26
 
    chk_map,
27
 
    cleanup,
28
 
    debug,
29
 
    graph,
30
 
    osutils,
31
 
    pack,
32
 
    transactions,
33
 
    ui,
34
 
    xml5,
35
 
    xml6,
36
 
    xml7,
37
 
    )
38
 
from bzrlib.index import (
39
 
    CombinedGraphIndex,
40
 
    GraphIndexPrefixAdapter,
41
 
    )
42
 
from bzrlib.knit import (
43
 
    KnitPlainFactory,
44
 
    KnitVersionedFiles,
45
 
    _KnitGraphIndex,
46
 
    _DirectPackAccess,
47
 
    )
48
 
from bzrlib import tsort
49
 
""")
50
 
from bzrlib import (
51
 
    bzrdir,
52
 
    errors,
53
 
    lockable_files,
54
 
    lockdir,
55
 
    revision as _mod_revision,
56
 
    )
57
 
 
58
 
from bzrlib.decorators import needs_write_lock, only_raises
59
 
from bzrlib.btree_index import (
60
 
    BTreeGraphIndex,
61
 
    BTreeBuilder,
62
 
    )
63
 
from bzrlib.index import (
64
 
    GraphIndex,
65
 
    InMemoryGraphIndex,
66
 
    )
67
 
from bzrlib.lock import LogicalLockResult
68
 
from bzrlib.repofmt.knitrepo import KnitRepository
69
 
from bzrlib.repository import (
70
 
    CommitBuilder,
71
 
    MetaDirRepositoryFormat,
72
 
    RepositoryFormat,
73
 
    RepositoryWriteLockResult,
74
 
    RootCommitBuilder,
75
 
    StreamSource,
76
 
    )
77
 
from bzrlib.trace import (
78
 
    mutter,
79
 
    note,
80
 
    warning,
81
 
    )
82
 
 
83
 
 
84
 
class PackCommitBuilder(CommitBuilder):
85
 
    """A subclass of CommitBuilder to add texts with pack semantics.
86
 
 
87
 
    Specifically this uses one knit object rather than one knit object per
88
 
    added text, reducing memory and object pressure.
89
 
    """
90
 
 
91
 
    def __init__(self, repository, parents, config, timestamp=None,
92
 
                 timezone=None, committer=None, revprops=None,
93
 
                 revision_id=None):
94
 
        CommitBuilder.__init__(self, repository, parents, config,
95
 
            timestamp=timestamp, timezone=timezone, committer=committer,
96
 
            revprops=revprops, revision_id=revision_id)
97
 
        self._file_graph = graph.Graph(
98
 
            repository._pack_collection.text_index.combined_index)
99
 
 
100
 
    def _heads(self, file_id, revision_ids):
101
 
        keys = [(file_id, revision_id) for revision_id in revision_ids]
102
 
        return set([key[1] for key in self._file_graph.heads(keys)])
103
 
 
104
 
 
105
 
class PackRootCommitBuilder(RootCommitBuilder):
106
 
    """A subclass of RootCommitBuilder to add texts with pack semantics.
107
 
 
108
 
    Specifically this uses one knit object rather than one knit object per
109
 
    added text, reducing memory and object pressure.
110
 
    """
111
 
 
112
 
    def __init__(self, repository, parents, config, timestamp=None,
113
 
                 timezone=None, committer=None, revprops=None,
114
 
                 revision_id=None):
115
 
        CommitBuilder.__init__(self, repository, parents, config,
116
 
            timestamp=timestamp, timezone=timezone, committer=committer,
117
 
            revprops=revprops, revision_id=revision_id)
118
 
        self._file_graph = graph.Graph(
119
 
            repository._pack_collection.text_index.combined_index)
120
 
 
121
 
    def _heads(self, file_id, revision_ids):
122
 
        keys = [(file_id, revision_id) for revision_id in revision_ids]
123
 
        return set([key[1] for key in self._file_graph.heads(keys)])
124
 
 
125
 
 
126
 
class Pack(object):
127
 
    """An in memory proxy for a pack and its indices.
128
 
 
129
 
    This is a base class that is not directly used, instead the classes
130
 
    ExistingPack and NewPack are used.
131
 
    """
132
 
 
133
 
    # A map of index 'type' to the file extension and position in the
134
 
    # index_sizes array.
135
 
    index_definitions = {
136
 
        'chk': ('.cix', 4),
137
 
        'revision': ('.rix', 0),
138
 
        'inventory': ('.iix', 1),
139
 
        'text': ('.tix', 2),
140
 
        'signature': ('.six', 3),
141
 
        }
142
 
 
143
 
    def __init__(self, revision_index, inventory_index, text_index,
144
 
        signature_index, chk_index=None):
145
 
        """Create a pack instance.
146
 
 
147
 
        :param revision_index: A GraphIndex for determining what revisions are
148
 
            present in the Pack and accessing the locations of their texts.
149
 
        :param inventory_index: A GraphIndex for determining what inventories are
150
 
            present in the Pack and accessing the locations of their
151
 
            texts/deltas.
152
 
        :param text_index: A GraphIndex for determining what file texts
153
 
            are present in the pack and accessing the locations of their
154
 
            texts/deltas (via (fileid, revisionid) tuples).
155
 
        :param signature_index: A GraphIndex for determining what signatures are
156
 
            present in the Pack and accessing the locations of their texts.
157
 
        :param chk_index: A GraphIndex for accessing content by CHK, if the
158
 
            pack has one.
159
 
        """
160
 
        self.revision_index = revision_index
161
 
        self.inventory_index = inventory_index
162
 
        self.text_index = text_index
163
 
        self.signature_index = signature_index
164
 
        self.chk_index = chk_index
165
 
 
166
 
    def access_tuple(self):
167
 
        """Return a tuple (transport, name) for the pack content."""
168
 
        return self.pack_transport, self.file_name()
169
 
 
170
 
    def _check_references(self):
171
 
        """Make sure our external references are present.
172
 
 
173
 
        Packs are allowed to have deltas whose base is not in the pack, but it
174
 
        must be present somewhere in this collection.  It is not allowed to
175
 
        have deltas based on a fallback repository.
176
 
        (See <https://bugs.launchpad.net/bzr/+bug/288751>)
177
 
        """
178
 
        missing_items = {}
179
 
        for (index_name, external_refs, index) in [
180
 
            ('texts',
181
 
                self._get_external_refs(self.text_index),
182
 
                self._pack_collection.text_index.combined_index),
183
 
            ('inventories',
184
 
                self._get_external_refs(self.inventory_index),
185
 
                self._pack_collection.inventory_index.combined_index),
186
 
            ]:
187
 
            missing = external_refs.difference(
188
 
                k for (idx, k, v, r) in
189
 
                index.iter_entries(external_refs))
190
 
            if missing:
191
 
                missing_items[index_name] = sorted(list(missing))
192
 
        if missing_items:
193
 
            from pprint import pformat
194
 
            raise errors.BzrCheckError(
195
 
                "Newly created pack file %r has delta references to "
196
 
                "items not in its repository:\n%s"
197
 
                % (self, pformat(missing_items)))
198
 
 
199
 
    def file_name(self):
200
 
        """Get the file name for the pack on disk."""
201
 
        return self.name + '.pack'
202
 
 
203
 
    def get_revision_count(self):
204
 
        return self.revision_index.key_count()
205
 
 
206
 
    def index_name(self, index_type, name):
207
 
        """Get the disk name of an index type for pack name 'name'."""
208
 
        return name + Pack.index_definitions[index_type][0]
209
 
 
210
 
    def index_offset(self, index_type):
211
 
        """Get the position in a index_size array for a given index type."""
212
 
        return Pack.index_definitions[index_type][1]
213
 
 
214
 
    def inventory_index_name(self, name):
215
 
        """The inv index is the name + .iix."""
216
 
        return self.index_name('inventory', name)
217
 
 
218
 
    def revision_index_name(self, name):
219
 
        """The revision index is the name + .rix."""
220
 
        return self.index_name('revision', name)
221
 
 
222
 
    def signature_index_name(self, name):
223
 
        """The signature index is the name + .six."""
224
 
        return self.index_name('signature', name)
225
 
 
226
 
    def text_index_name(self, name):
227
 
        """The text index is the name + .tix."""
228
 
        return self.index_name('text', name)
229
 
 
230
 
    def _replace_index_with_readonly(self, index_type):
231
 
        unlimited_cache = False
232
 
        if index_type == 'chk':
233
 
            unlimited_cache = True
234
 
        setattr(self, index_type + '_index',
235
 
            self.index_class(self.index_transport,
236
 
                self.index_name(index_type, self.name),
237
 
                self.index_sizes[self.index_offset(index_type)],
238
 
                unlimited_cache=unlimited_cache))
239
 
 
240
 
 
241
 
class ExistingPack(Pack):
242
 
    """An in memory proxy for an existing .pack and its disk indices."""
243
 
 
244
 
    def __init__(self, pack_transport, name, revision_index, inventory_index,
245
 
        text_index, signature_index, chk_index=None):
246
 
        """Create an ExistingPack object.
247
 
 
248
 
        :param pack_transport: The transport where the pack file resides.
249
 
        :param name: The name of the pack on disk in the pack_transport.
250
 
        """
251
 
        Pack.__init__(self, revision_index, inventory_index, text_index,
252
 
            signature_index, chk_index)
253
 
        self.name = name
254
 
        self.pack_transport = pack_transport
255
 
        if None in (revision_index, inventory_index, text_index,
256
 
                signature_index, name, pack_transport):
257
 
            raise AssertionError()
258
 
 
259
 
    def __eq__(self, other):
260
 
        return self.__dict__ == other.__dict__
261
 
 
262
 
    def __ne__(self, other):
263
 
        return not self.__eq__(other)
264
 
 
265
 
    def __repr__(self):
266
 
        return "<%s.%s object at 0x%x, %s, %s" % (
267
 
            self.__class__.__module__, self.__class__.__name__, id(self),
268
 
            self.pack_transport, self.name)
269
 
 
270
 
 
271
 
class ResumedPack(ExistingPack):
272
 
 
273
 
    def __init__(self, name, revision_index, inventory_index, text_index,
274
 
        signature_index, upload_transport, pack_transport, index_transport,
275
 
        pack_collection, chk_index=None):
276
 
        """Create a ResumedPack object."""
277
 
        ExistingPack.__init__(self, pack_transport, name, revision_index,
278
 
            inventory_index, text_index, signature_index,
279
 
            chk_index=chk_index)
280
 
        self.upload_transport = upload_transport
281
 
        self.index_transport = index_transport
282
 
        self.index_sizes = [None, None, None, None]
283
 
        indices = [
284
 
            ('revision', revision_index),
285
 
            ('inventory', inventory_index),
286
 
            ('text', text_index),
287
 
            ('signature', signature_index),
288
 
            ]
289
 
        if chk_index is not None:
290
 
            indices.append(('chk', chk_index))
291
 
            self.index_sizes.append(None)
292
 
        for index_type, index in indices:
293
 
            offset = self.index_offset(index_type)
294
 
            self.index_sizes[offset] = index._size
295
 
        self.index_class = pack_collection._index_class
296
 
        self._pack_collection = pack_collection
297
 
        self._state = 'resumed'
298
 
        # XXX: perhaps check that the .pack file exists?
299
 
 
300
 
    def access_tuple(self):
301
 
        if self._state == 'finished':
302
 
            return Pack.access_tuple(self)
303
 
        elif self._state == 'resumed':
304
 
            return self.upload_transport, self.file_name()
305
 
        else:
306
 
            raise AssertionError(self._state)
307
 
 
308
 
    def abort(self):
309
 
        self.upload_transport.delete(self.file_name())
310
 
        indices = [self.revision_index, self.inventory_index, self.text_index,
311
 
            self.signature_index]
312
 
        if self.chk_index is not None:
313
 
            indices.append(self.chk_index)
314
 
        for index in indices:
315
 
            index._transport.delete(index._name)
316
 
 
317
 
    def finish(self):
318
 
        self._check_references()
319
 
        index_types = ['revision', 'inventory', 'text', 'signature']
320
 
        if self.chk_index is not None:
321
 
            index_types.append('chk')
322
 
        for index_type in index_types:
323
 
            old_name = self.index_name(index_type, self.name)
324
 
            new_name = '../indices/' + old_name
325
 
            self.upload_transport.rename(old_name, new_name)
326
 
            self._replace_index_with_readonly(index_type)
327
 
        new_name = '../packs/' + self.file_name()
328
 
        self.upload_transport.rename(self.file_name(), new_name)
329
 
        self._state = 'finished'
330
 
 
331
 
    def _get_external_refs(self, index):
332
 
        """Return compression parents for this index that are not present.
333
 
 
334
 
        This returns any compression parents that are referenced by this index,
335
 
        which are not contained *in* this index. They may be present elsewhere.
336
 
        """
337
 
        return index.external_references(1)
338
 
 
339
 
 
340
 
class NewPack(Pack):
341
 
    """An in memory proxy for a pack which is being created."""
342
 
 
343
 
    def __init__(self, pack_collection, upload_suffix='', file_mode=None):
344
 
        """Create a NewPack instance.
345
 
 
346
 
        :param pack_collection: A PackCollection into which this is being inserted.
347
 
        :param upload_suffix: An optional suffix to be given to any temporary
348
 
            files created during the pack creation. e.g '.autopack'
349
 
        :param file_mode: Unix permissions for newly created file.
350
 
        """
351
 
        # The relative locations of the packs are constrained, but all are
352
 
        # passed in because the caller has them, so as to avoid object churn.
353
 
        index_builder_class = pack_collection._index_builder_class
354
 
        if pack_collection.chk_index is not None:
355
 
            chk_index = index_builder_class(reference_lists=0)
356
 
        else:
357
 
            chk_index = None
358
 
        Pack.__init__(self,
359
 
            # Revisions: parents list, no text compression.
360
 
            index_builder_class(reference_lists=1),
361
 
            # Inventory: We want to map compression only, but currently the
362
 
            # knit code hasn't been updated enough to understand that, so we
363
 
            # have a regular 2-list index giving parents and compression
364
 
            # source.
365
 
            index_builder_class(reference_lists=2),
366
 
            # Texts: compression and per file graph, for all fileids - so two
367
 
            # reference lists and two elements in the key tuple.
368
 
            index_builder_class(reference_lists=2, key_elements=2),
369
 
            # Signatures: Just blobs to store, no compression, no parents
370
 
            # listing.
371
 
            index_builder_class(reference_lists=0),
372
 
            # CHK based storage - just blobs, no compression or parents.
373
 
            chk_index=chk_index
374
 
            )
375
 
        self._pack_collection = pack_collection
376
 
        # When we make readonly indices, we need this.
377
 
        self.index_class = pack_collection._index_class
378
 
        # where should the new pack be opened
379
 
        self.upload_transport = pack_collection._upload_transport
380
 
        # where are indices written out to
381
 
        self.index_transport = pack_collection._index_transport
382
 
        # where is the pack renamed to when it is finished?
383
 
        self.pack_transport = pack_collection._pack_transport
384
 
        # What file mode to upload the pack and indices with.
385
 
        self._file_mode = file_mode
386
 
        # tracks the content written to the .pack file.
387
 
        self._hash = osutils.md5()
388
 
        # a tuple with the length in bytes of the indices, once the pack
389
 
        # is finalised. (rev, inv, text, sigs, chk_if_in_use)
390
 
        self.index_sizes = None
391
 
        # How much data to cache when writing packs. Note that this is not
392
 
        # synchronised with reads, because it's not in the transport layer, so
393
 
        # is not safe unless the client knows it won't be reading from the pack
394
 
        # under creation.
395
 
        self._cache_limit = 0
396
 
        # the temporary pack file name.
397
 
        self.random_name = osutils.rand_chars(20) + upload_suffix
398
 
        # when was this pack started ?
399
 
        self.start_time = time.time()
400
 
        # open an output stream for the data added to the pack.
401
 
        self.write_stream = self.upload_transport.open_write_stream(
402
 
            self.random_name, mode=self._file_mode)
403
 
        if 'pack' in debug.debug_flags:
404
 
            mutter('%s: create_pack: pack stream open: %s%s t+%6.3fs',
405
 
                time.ctime(), self.upload_transport.base, self.random_name,
406
 
                time.time() - self.start_time)
407
 
        # A list of byte sequences to be written to the new pack, and the
408
 
        # aggregate size of them.  Stored as a list rather than separate
409
 
        # variables so that the _write_data closure below can update them.
410
 
        self._buffer = [[], 0]
411
 
        # create a callable for adding data
412
 
        #
413
 
        # robertc says- this is a closure rather than a method on the object
414
 
        # so that the variables are locals, and faster than accessing object
415
 
        # members.
416
 
        def _write_data(bytes, flush=False, _buffer=self._buffer,
417
 
            _write=self.write_stream.write, _update=self._hash.update):
418
 
            _buffer[0].append(bytes)
419
 
            _buffer[1] += len(bytes)
420
 
            # buffer cap
421
 
            if _buffer[1] > self._cache_limit or flush:
422
 
                bytes = ''.join(_buffer[0])
423
 
                _write(bytes)
424
 
                _update(bytes)
425
 
                _buffer[:] = [[], 0]
426
 
        # expose this on self, for the occasion when clients want to add data.
427
 
        self._write_data = _write_data
428
 
        # a pack writer object to serialise pack records.
429
 
        self._writer = pack.ContainerWriter(self._write_data)
430
 
        self._writer.begin()
431
 
        # what state is the pack in? (open, finished, aborted)
432
 
        self._state = 'open'
433
 
        # no name until we finish writing the content
434
 
        self.name = None
435
 
 
436
 
    def abort(self):
437
 
        """Cancel creating this pack."""
438
 
        self._state = 'aborted'
439
 
        self.write_stream.close()
440
 
        # Remove the temporary pack file.
441
 
        self.upload_transport.delete(self.random_name)
442
 
        # The indices have no state on disk.
443
 
 
444
 
    def access_tuple(self):
445
 
        """Return a tuple (transport, name) for the pack content."""
446
 
        if self._state == 'finished':
447
 
            return Pack.access_tuple(self)
448
 
        elif self._state == 'open':
449
 
            return self.upload_transport, self.random_name
450
 
        else:
451
 
            raise AssertionError(self._state)
452
 
 
453
 
    def data_inserted(self):
454
 
        """True if data has been added to this pack."""
455
 
        return bool(self.get_revision_count() or
456
 
            self.inventory_index.key_count() or
457
 
            self.text_index.key_count() or
458
 
            self.signature_index.key_count() or
459
 
            (self.chk_index is not None and self.chk_index.key_count()))
460
 
 
461
 
    def finish_content(self):
462
 
        if self.name is not None:
463
 
            return
464
 
        self._writer.end()
465
 
        if self._buffer[1]:
466
 
            self._write_data('', flush=True)
467
 
        self.name = self._hash.hexdigest()
468
 
 
469
 
    def finish(self, suspend=False):
470
 
        """Finish the new pack.
471
 
 
472
 
        This:
473
 
         - finalises the content
474
 
         - assigns a name (the md5 of the content, currently)
475
 
         - writes out the associated indices
476
 
         - renames the pack into place.
477
 
         - stores the index size tuple for the pack in the index_sizes
478
 
           attribute.
479
 
        """
480
 
        self.finish_content()
481
 
        if not suspend:
482
 
            self._check_references()
483
 
        # write indices
484
 
        # XXX: It'd be better to write them all to temporary names, then
485
 
        # rename them all into place, so that the window when only some are
486
 
        # visible is smaller.  On the other hand none will be seen until
487
 
        # they're in the names list.
488
 
        self.index_sizes = [None, None, None, None]
489
 
        self._write_index('revision', self.revision_index, 'revision', suspend)
490
 
        self._write_index('inventory', self.inventory_index, 'inventory',
491
 
            suspend)
492
 
        self._write_index('text', self.text_index, 'file texts', suspend)
493
 
        self._write_index('signature', self.signature_index,
494
 
            'revision signatures', suspend)
495
 
        if self.chk_index is not None:
496
 
            self.index_sizes.append(None)
497
 
            self._write_index('chk', self.chk_index,
498
 
                'content hash bytes', suspend)
499
 
        self.write_stream.close()
500
 
        # Note that this will clobber an existing pack with the same name,
501
 
        # without checking for hash collisions. While this is undesirable this
502
 
        # is something that can be rectified in a subsequent release. One way
503
 
        # to rectify it may be to leave the pack at the original name, writing
504
 
        # its pack-names entry as something like 'HASH: index-sizes
505
 
        # temporary-name'. Allocate that and check for collisions, if it is
506
 
        # collision free then rename it into place. If clients know this scheme
507
 
        # they can handle missing-file errors by:
508
 
        #  - try for HASH.pack
509
 
        #  - try for temporary-name
510
 
        #  - refresh the pack-list to see if the pack is now absent
511
 
        new_name = self.name + '.pack'
512
 
        if not suspend:
513
 
            new_name = '../packs/' + new_name
514
 
        self.upload_transport.rename(self.random_name, new_name)
515
 
        self._state = 'finished'
516
 
        if 'pack' in debug.debug_flags:
517
 
            # XXX: size might be interesting?
518
 
            mutter('%s: create_pack: pack finished: %s%s->%s t+%6.3fs',
519
 
                time.ctime(), self.upload_transport.base, self.random_name,
520
 
                new_name, time.time() - self.start_time)
521
 
 
522
 
    def flush(self):
523
 
        """Flush any current data."""
524
 
        if self._buffer[1]:
525
 
            bytes = ''.join(self._buffer[0])
526
 
            self.write_stream.write(bytes)
527
 
            self._hash.update(bytes)
528
 
            self._buffer[:] = [[], 0]
529
 
 
530
 
    def _get_external_refs(self, index):
531
 
        return index._external_references()
532
 
 
533
 
    def set_write_cache_size(self, size):
534
 
        self._cache_limit = size
535
 
 
536
 
    def _write_index(self, index_type, index, label, suspend=False):
537
 
        """Write out an index.
538
 
 
539
 
        :param index_type: The type of index to write - e.g. 'revision'.
540
 
        :param index: The index object to serialise.
541
 
        :param label: What label to give the index e.g. 'revision'.
542
 
        """
543
 
        index_name = self.index_name(index_type, self.name)
544
 
        if suspend:
545
 
            transport = self.upload_transport
546
 
        else:
547
 
            transport = self.index_transport
548
 
        self.index_sizes[self.index_offset(index_type)] = transport.put_file(
549
 
            index_name, index.finish(), mode=self._file_mode)
550
 
        if 'pack' in debug.debug_flags:
551
 
            # XXX: size might be interesting?
552
 
            mutter('%s: create_pack: wrote %s index: %s%s t+%6.3fs',
553
 
                time.ctime(), label, self.upload_transport.base,
554
 
                self.random_name, time.time() - self.start_time)
555
 
        # Replace the writable index on this object with a readonly,
556
 
        # presently unloaded index. We should alter
557
 
        # the index layer to make its finish() error if add_node is
558
 
        # subsequently used. RBC
559
 
        self._replace_index_with_readonly(index_type)
560
 
 
561
 
 
562
 
class AggregateIndex(object):
563
 
    """An aggregated index for the RepositoryPackCollection.
564
 
 
565
 
    AggregateIndex is reponsible for managing the PackAccess object,
566
 
    Index-To-Pack mapping, and all indices list for a specific type of index
567
 
    such as 'revision index'.
568
 
 
569
 
    A CombinedIndex provides an index on a single key space built up
570
 
    from several on-disk indices.  The AggregateIndex builds on this
571
 
    to provide a knit access layer, and allows having up to one writable
572
 
    index within the collection.
573
 
    """
574
 
    # XXX: Probably 'can be written to' could/should be separated from 'acts
575
 
    # like a knit index' -- mbp 20071024
576
 
 
577
 
    def __init__(self, reload_func=None, flush_func=None):
578
 
        """Create an AggregateIndex.
579
 
 
580
 
        :param reload_func: A function to call if we find we are missing an
581
 
            index. Should have the form reload_func() => True if the list of
582
 
            active pack files has changed.
583
 
        """
584
 
        self._reload_func = reload_func
585
 
        self.index_to_pack = {}
586
 
        self.combined_index = CombinedGraphIndex([], reload_func=reload_func)
587
 
        self.data_access = _DirectPackAccess(self.index_to_pack,
588
 
                                             reload_func=reload_func,
589
 
                                             flush_func=flush_func)
590
 
        self.add_callback = None
591
 
 
592
 
    def add_index(self, index, pack):
593
 
        """Add index to the aggregate, which is an index for Pack pack.
594
 
 
595
 
        Future searches on the aggregate index will seach this new index
596
 
        before all previously inserted indices.
597
 
 
598
 
        :param index: An Index for the pack.
599
 
        :param pack: A Pack instance.
600
 
        """
601
 
        # expose it to the index map
602
 
        self.index_to_pack[index] = pack.access_tuple()
603
 
        # put it at the front of the linear index list
604
 
        self.combined_index.insert_index(0, index, pack.name)
605
 
 
606
 
    def add_writable_index(self, index, pack):
607
 
        """Add an index which is able to have data added to it.
608
 
 
609
 
        There can be at most one writable index at any time.  Any
610
 
        modifications made to the knit are put into this index.
611
 
 
612
 
        :param index: An index from the pack parameter.
613
 
        :param pack: A Pack instance.
614
 
        """
615
 
        if self.add_callback is not None:
616
 
            raise AssertionError(
617
 
                "%s already has a writable index through %s" % \
618
 
                (self, self.add_callback))
619
 
        # allow writing: queue writes to a new index
620
 
        self.add_index(index, pack)
621
 
        # Updates the index to packs mapping as a side effect,
622
 
        self.data_access.set_writer(pack._writer, index, pack.access_tuple())
623
 
        self.add_callback = index.add_nodes
624
 
 
625
 
    def clear(self):
626
 
        """Reset all the aggregate data to nothing."""
627
 
        self.data_access.set_writer(None, None, (None, None))
628
 
        self.index_to_pack.clear()
629
 
        del self.combined_index._indices[:]
630
 
        del self.combined_index._index_names[:]
631
 
        self.add_callback = None
632
 
 
633
 
    def remove_index(self, index):
634
 
        """Remove index from the indices used to answer queries.
635
 
 
636
 
        :param index: An index from the pack parameter.
637
 
        """
638
 
        del self.index_to_pack[index]
639
 
        pos = self.combined_index._indices.index(index)
640
 
        del self.combined_index._indices[pos]
641
 
        del self.combined_index._index_names[pos]
642
 
        if (self.add_callback is not None and
643
 
            getattr(index, 'add_nodes', None) == self.add_callback):
644
 
            self.add_callback = None
645
 
            self.data_access.set_writer(None, None, (None, None))
646
 
 
647
 
 
648
 
class Packer(object):
649
 
    """Create a pack from packs."""
650
 
 
651
 
    def __init__(self, pack_collection, packs, suffix, revision_ids=None,
652
 
                 reload_func=None):
653
 
        """Create a Packer.
654
 
 
655
 
        :param pack_collection: A RepositoryPackCollection object where the
656
 
            new pack is being written to.
657
 
        :param packs: The packs to combine.
658
 
        :param suffix: The suffix to use on the temporary files for the pack.
659
 
        :param revision_ids: Revision ids to limit the pack to.
660
 
        :param reload_func: A function to call if a pack file/index goes
661
 
            missing. The side effect of calling this function should be to
662
 
            update self.packs. See also AggregateIndex
663
 
        """
664
 
        self.packs = packs
665
 
        self.suffix = suffix
666
 
        self.revision_ids = revision_ids
667
 
        # The pack object we are creating.
668
 
        self.new_pack = None
669
 
        self._pack_collection = pack_collection
670
 
        self._reload_func = reload_func
671
 
        # The index layer keys for the revisions being copied. None for 'all
672
 
        # objects'.
673
 
        self._revision_keys = None
674
 
        # What text keys to copy. None for 'all texts'. This is set by
675
 
        # _copy_inventory_texts
676
 
        self._text_filter = None
677
 
        self._extra_init()
678
 
 
679
 
    def _extra_init(self):
680
 
        """A template hook to allow extending the constructor trivially."""
681
 
 
682
 
    def _pack_map_and_index_list(self, index_attribute):
683
 
        """Convert a list of packs to an index pack map and index list.
684
 
 
685
 
        :param index_attribute: The attribute that the desired index is found
686
 
            on.
687
 
        :return: A tuple (map, list) where map contains the dict from
688
 
            index:pack_tuple, and list contains the indices in the preferred
689
 
            access order.
690
 
        """
691
 
        indices = []
692
 
        pack_map = {}
693
 
        for pack_obj in self.packs:
694
 
            index = getattr(pack_obj, index_attribute)
695
 
            indices.append(index)
696
 
            pack_map[index] = pack_obj
697
 
        return pack_map, indices
698
 
 
699
 
    def _index_contents(self, indices, key_filter=None):
700
 
        """Get an iterable of the index contents from a pack_map.
701
 
 
702
 
        :param indices: The list of indices to query
703
 
        :param key_filter: An optional filter to limit the keys returned.
704
 
        """
705
 
        all_index = CombinedGraphIndex(indices)
706
 
        if key_filter is None:
707
 
            return all_index.iter_all_entries()
708
 
        else:
709
 
            return all_index.iter_entries(key_filter)
710
 
 
711
 
    def pack(self, pb=None):
712
 
        """Create a new pack by reading data from other packs.
713
 
 
714
 
        This does little more than a bulk copy of data. One key difference
715
 
        is that data with the same item key across multiple packs is elided
716
 
        from the output. The new pack is written into the current pack store
717
 
        along with its indices, and the name added to the pack names. The
718
 
        source packs are not altered and are not required to be in the current
719
 
        pack collection.
720
 
 
721
 
        :param pb: An optional progress bar to use. A nested bar is created if
722
 
            this is None.
723
 
        :return: A Pack object, or None if nothing was copied.
724
 
        """
725
 
        # open a pack - using the same name as the last temporary file
726
 
        # - which has already been flushed, so its safe.
727
 
        # XXX: - duplicate code warning with start_write_group; fix before
728
 
        #      considering 'done'.
729
 
        if self._pack_collection._new_pack is not None:
730
 
            raise errors.BzrError('call to %s.pack() while another pack is'
731
 
                                  ' being written.'
732
 
                                  % (self.__class__.__name__,))
733
 
        if self.revision_ids is not None:
734
 
            if len(self.revision_ids) == 0:
735
 
                # silly fetch request.
736
 
                return None
737
 
            else:
738
 
                self.revision_ids = frozenset(self.revision_ids)
739
 
                self.revision_keys = frozenset((revid,) for revid in
740
 
                    self.revision_ids)
741
 
        if pb is None:
742
 
            self.pb = ui.ui_factory.nested_progress_bar()
743
 
        else:
744
 
            self.pb = pb
745
 
        try:
746
 
            return self._create_pack_from_packs()
747
 
        finally:
748
 
            if pb is None:
749
 
                self.pb.finished()
750
 
 
751
 
    def open_pack(self):
752
 
        """Open a pack for the pack we are creating."""
753
 
        new_pack = self._pack_collection.pack_factory(self._pack_collection,
754
 
                upload_suffix=self.suffix,
755
 
                file_mode=self._pack_collection.repo.bzrdir._get_file_mode())
756
 
        # We know that we will process all nodes in order, and don't need to
757
 
        # query, so don't combine any indices spilled to disk until we are done
758
 
        new_pack.revision_index.set_optimize(combine_backing_indices=False)
759
 
        new_pack.inventory_index.set_optimize(combine_backing_indices=False)
760
 
        new_pack.text_index.set_optimize(combine_backing_indices=False)
761
 
        new_pack.signature_index.set_optimize(combine_backing_indices=False)
762
 
        return new_pack
763
 
 
764
 
    def _update_pack_order(self, entries, index_to_pack_map):
765
 
        """Determine how we want our packs to be ordered.
766
 
 
767
 
        This changes the sort order of the self.packs list so that packs unused
768
 
        by 'entries' will be at the end of the list, so that future requests
769
 
        can avoid probing them.  Used packs will be at the front of the
770
 
        self.packs list, in the order of their first use in 'entries'.
771
 
 
772
 
        :param entries: A list of (index, ...) tuples
773
 
        :param index_to_pack_map: A mapping from index objects to pack objects.
774
 
        """
775
 
        packs = []
776
 
        seen_indexes = set()
777
 
        for entry in entries:
778
 
            index = entry[0]
779
 
            if index not in seen_indexes:
780
 
                packs.append(index_to_pack_map[index])
781
 
                seen_indexes.add(index)
782
 
        if len(packs) == len(self.packs):
783
 
            if 'pack' in debug.debug_flags:
784
 
                mutter('Not changing pack list, all packs used.')
785
 
            return
786
 
        seen_packs = set(packs)
787
 
        for pack in self.packs:
788
 
            if pack not in seen_packs:
789
 
                packs.append(pack)
790
 
                seen_packs.add(pack)
791
 
        if 'pack' in debug.debug_flags:
792
 
            old_names = [p.access_tuple()[1] for p in self.packs]
793
 
            new_names = [p.access_tuple()[1] for p in packs]
794
 
            mutter('Reordering packs\nfrom: %s\n  to: %s',
795
 
                   old_names, new_names)
796
 
        self.packs = packs
797
 
 
798
 
    def _copy_revision_texts(self):
799
 
        """Copy revision data to the new pack."""
800
 
        # select revisions
801
 
        if self.revision_ids:
802
 
            revision_keys = [(revision_id,) for revision_id in self.revision_ids]
803
 
        else:
804
 
            revision_keys = None
805
 
        # select revision keys
806
 
        revision_index_map, revision_indices = self._pack_map_and_index_list(
807
 
            'revision_index')
808
 
        revision_nodes = self._index_contents(revision_indices, revision_keys)
809
 
        revision_nodes = list(revision_nodes)
810
 
        self._update_pack_order(revision_nodes, revision_index_map)
811
 
        # copy revision keys and adjust values
812
 
        self.pb.update("Copying revision texts", 1)
813
 
        total_items, readv_group_iter = self._revision_node_readv(revision_nodes)
814
 
        list(self._copy_nodes_graph(revision_index_map, self.new_pack._writer,
815
 
            self.new_pack.revision_index, readv_group_iter, total_items))
816
 
        if 'pack' in debug.debug_flags:
817
 
            mutter('%s: create_pack: revisions copied: %s%s %d items t+%6.3fs',
818
 
                time.ctime(), self._pack_collection._upload_transport.base,
819
 
                self.new_pack.random_name,
820
 
                self.new_pack.revision_index.key_count(),
821
 
                time.time() - self.new_pack.start_time)
822
 
        self._revision_keys = revision_keys
823
 
 
824
 
    def _copy_inventory_texts(self):
825
 
        """Copy the inventory texts to the new pack.
826
 
 
827
 
        self._revision_keys is used to determine what inventories to copy.
828
 
 
829
 
        Sets self._text_filter appropriately.
830
 
        """
831
 
        # select inventory keys
832
 
        inv_keys = self._revision_keys # currently the same keyspace, and note that
833
 
        # querying for keys here could introduce a bug where an inventory item
834
 
        # is missed, so do not change it to query separately without cross
835
 
        # checking like the text key check below.
836
 
        inventory_index_map, inventory_indices = self._pack_map_and_index_list(
837
 
            'inventory_index')
838
 
        inv_nodes = self._index_contents(inventory_indices, inv_keys)
839
 
        # copy inventory keys and adjust values
840
 
        # XXX: Should be a helper function to allow different inv representation
841
 
        # at this point.
842
 
        self.pb.update("Copying inventory texts", 2)
843
 
        total_items, readv_group_iter = self._least_readv_node_readv(inv_nodes)
844
 
        # Only grab the output lines if we will be processing them
845
 
        output_lines = bool(self.revision_ids)
846
 
        inv_lines = self._copy_nodes_graph(inventory_index_map,
847
 
            self.new_pack._writer, self.new_pack.inventory_index,
848
 
            readv_group_iter, total_items, output_lines=output_lines)
849
 
        if self.revision_ids:
850
 
            self._process_inventory_lines(inv_lines)
851
 
        else:
852
 
            # eat the iterator to cause it to execute.
853
 
            list(inv_lines)
854
 
            self._text_filter = None
855
 
        if 'pack' in debug.debug_flags:
856
 
            mutter('%s: create_pack: inventories copied: %s%s %d items t+%6.3fs',
857
 
                time.ctime(), self._pack_collection._upload_transport.base,
858
 
                self.new_pack.random_name,
859
 
                self.new_pack.inventory_index.key_count(),
860
 
                time.time() - self.new_pack.start_time)
861
 
 
862
 
    def _copy_text_texts(self):
863
 
        # select text keys
864
 
        text_index_map, text_nodes = self._get_text_nodes()
865
 
        if self._text_filter is not None:
866
 
            # We could return the keys copied as part of the return value from
867
 
            # _copy_nodes_graph but this doesn't work all that well with the
868
 
            # need to get line output too, so we check separately, and as we're
869
 
            # going to buffer everything anyway, we check beforehand, which
870
 
            # saves reading knit data over the wire when we know there are
871
 
            # mising records.
872
 
            text_nodes = set(text_nodes)
873
 
            present_text_keys = set(_node[1] for _node in text_nodes)
874
 
            missing_text_keys = set(self._text_filter) - present_text_keys
875
 
            if missing_text_keys:
876
 
                # TODO: raise a specific error that can handle many missing
877
 
                # keys.
878
 
                mutter("missing keys during fetch: %r", missing_text_keys)
879
 
                a_missing_key = missing_text_keys.pop()
880
 
                raise errors.RevisionNotPresent(a_missing_key[1],
881
 
                    a_missing_key[0])
882
 
        # copy text keys and adjust values
883
 
        self.pb.update("Copying content texts", 3)
884
 
        total_items, readv_group_iter = self._least_readv_node_readv(text_nodes)
885
 
        list(self._copy_nodes_graph(text_index_map, self.new_pack._writer,
886
 
            self.new_pack.text_index, readv_group_iter, total_items))
887
 
        self._log_copied_texts()
888
 
 
889
 
    def _create_pack_from_packs(self):
890
 
        self.pb.update("Opening pack", 0, 5)
891
 
        self.new_pack = self.open_pack()
892
 
        new_pack = self.new_pack
893
 
        # buffer data - we won't be reading-back during the pack creation and
894
 
        # this makes a significant difference on sftp pushes.
895
 
        new_pack.set_write_cache_size(1024*1024)
896
 
        if 'pack' in debug.debug_flags:
897
 
            plain_pack_list = ['%s%s' % (a_pack.pack_transport.base, a_pack.name)
898
 
                for a_pack in self.packs]
899
 
            if self.revision_ids is not None:
900
 
                rev_count = len(self.revision_ids)
901
 
            else:
902
 
                rev_count = 'all'
903
 
            mutter('%s: create_pack: creating pack from source packs: '
904
 
                '%s%s %s revisions wanted %s t=0',
905
 
                time.ctime(), self._pack_collection._upload_transport.base, new_pack.random_name,
906
 
                plain_pack_list, rev_count)
907
 
        self._copy_revision_texts()
908
 
        self._copy_inventory_texts()
909
 
        self._copy_text_texts()
910
 
        # select signature keys
911
 
        signature_filter = self._revision_keys # same keyspace
912
 
        signature_index_map, signature_indices = self._pack_map_and_index_list(
913
 
            'signature_index')
914
 
        signature_nodes = self._index_contents(signature_indices,
915
 
            signature_filter)
916
 
        # copy signature keys and adjust values
917
 
        self.pb.update("Copying signature texts", 4)
918
 
        self._copy_nodes(signature_nodes, signature_index_map, new_pack._writer,
919
 
            new_pack.signature_index)
920
 
        if 'pack' in debug.debug_flags:
921
 
            mutter('%s: create_pack: revision signatures copied: %s%s %d items t+%6.3fs',
922
 
                time.ctime(), self._pack_collection._upload_transport.base, new_pack.random_name,
923
 
                new_pack.signature_index.key_count(),
924
 
                time.time() - new_pack.start_time)
925
 
        # copy chk contents
926
 
        # NB XXX: how to check CHK references are present? perhaps by yielding
927
 
        # the items? How should that interact with stacked repos?
928
 
        if new_pack.chk_index is not None:
929
 
            self._copy_chks()
930
 
            if 'pack' in debug.debug_flags:
931
 
                mutter('%s: create_pack: chk content copied: %s%s %d items t+%6.3fs',
932
 
                    time.ctime(), self._pack_collection._upload_transport.base,
933
 
                    new_pack.random_name,
934
 
                    new_pack.chk_index.key_count(),
935
 
                    time.time() - new_pack.start_time)
936
 
        new_pack._check_references()
937
 
        if not self._use_pack(new_pack):
938
 
            new_pack.abort()
939
 
            return None
940
 
        self.pb.update("Finishing pack", 5)
941
 
        new_pack.finish()
942
 
        self._pack_collection.allocate(new_pack)
943
 
        return new_pack
944
 
 
945
 
    def _copy_chks(self, refs=None):
946
 
        # XXX: Todo, recursive follow-pointers facility when fetching some
947
 
        # revisions only.
948
 
        chk_index_map, chk_indices = self._pack_map_and_index_list(
949
 
            'chk_index')
950
 
        chk_nodes = self._index_contents(chk_indices, refs)
951
 
        new_refs = set()
952
 
        # TODO: This isn't strictly tasteful as we are accessing some private
953
 
        #       variables (_serializer). Perhaps a better way would be to have
954
 
        #       Repository._deserialise_chk_node()
955
 
        search_key_func = chk_map.search_key_registry.get(
956
 
            self._pack_collection.repo._serializer.search_key_name)
957
 
        def accumlate_refs(lines):
958
 
            # XXX: move to a generic location
959
 
            # Yay mismatch:
960
 
            bytes = ''.join(lines)
961
 
            node = chk_map._deserialise(bytes, ("unknown",), search_key_func)
962
 
            new_refs.update(node.refs())
963
 
        self._copy_nodes(chk_nodes, chk_index_map, self.new_pack._writer,
964
 
            self.new_pack.chk_index, output_lines=accumlate_refs)
965
 
        return new_refs
966
 
 
967
 
    def _copy_nodes(self, nodes, index_map, writer, write_index,
968
 
        output_lines=None):
969
 
        """Copy knit nodes between packs with no graph references.
970
 
 
971
 
        :param output_lines: Output full texts of copied items.
972
 
        """
973
 
        pb = ui.ui_factory.nested_progress_bar()
974
 
        try:
975
 
            return self._do_copy_nodes(nodes, index_map, writer,
976
 
                write_index, pb, output_lines=output_lines)
977
 
        finally:
978
 
            pb.finished()
979
 
 
980
 
    def _do_copy_nodes(self, nodes, index_map, writer, write_index, pb,
981
 
        output_lines=None):
982
 
        # for record verification
983
 
        knit = KnitVersionedFiles(None, None)
984
 
        # plan a readv on each source pack:
985
 
        # group by pack
986
 
        nodes = sorted(nodes)
987
 
        # how to map this into knit.py - or knit.py into this?
988
 
        # we don't want the typical knit logic, we want grouping by pack
989
 
        # at this point - perhaps a helper library for the following code
990
 
        # duplication points?
991
 
        request_groups = {}
992
 
        for index, key, value in nodes:
993
 
            if index not in request_groups:
994
 
                request_groups[index] = []
995
 
            request_groups[index].append((key, value))
996
 
        record_index = 0
997
 
        pb.update("Copied record", record_index, len(nodes))
998
 
        for index, items in request_groups.iteritems():
999
 
            pack_readv_requests = []
1000
 
            for key, value in items:
1001
 
                # ---- KnitGraphIndex.get_position
1002
 
                bits = value[1:].split(' ')
1003
 
                offset, length = int(bits[0]), int(bits[1])
1004
 
                pack_readv_requests.append((offset, length, (key, value[0])))
1005
 
            # linear scan up the pack
1006
 
            pack_readv_requests.sort()
1007
 
            # copy the data
1008
 
            pack_obj = index_map[index]
1009
 
            transport, path = pack_obj.access_tuple()
1010
 
            try:
1011
 
                reader = pack.make_readv_reader(transport, path,
1012
 
                    [offset[0:2] for offset in pack_readv_requests])
1013
 
            except errors.NoSuchFile:
1014
 
                if self._reload_func is not None:
1015
 
                    self._reload_func()
1016
 
                raise
1017
 
            for (names, read_func), (_1, _2, (key, eol_flag)) in \
1018
 
                izip(reader.iter_records(), pack_readv_requests):
1019
 
                raw_data = read_func(None)
1020
 
                # check the header only
1021
 
                if output_lines is not None:
1022
 
                    output_lines(knit._parse_record(key[-1], raw_data)[0])
1023
 
                else:
1024
 
                    df, _ = knit._parse_record_header(key, raw_data)
1025
 
                    df.close()
1026
 
                pos, size = writer.add_bytes_record(raw_data, names)
1027
 
                write_index.add_node(key, eol_flag + "%d %d" % (pos, size))
1028
 
                pb.update("Copied record", record_index)
1029
 
                record_index += 1
1030
 
 
1031
 
    def _copy_nodes_graph(self, index_map, writer, write_index,
1032
 
        readv_group_iter, total_items, output_lines=False):
1033
 
        """Copy knit nodes between packs.
1034
 
 
1035
 
        :param output_lines: Return lines present in the copied data as
1036
 
            an iterator of line,version_id.
1037
 
        """
1038
 
        pb = ui.ui_factory.nested_progress_bar()
1039
 
        try:
1040
 
            for result in self._do_copy_nodes_graph(index_map, writer,
1041
 
                write_index, output_lines, pb, readv_group_iter, total_items):
1042
 
                yield result
1043
 
        except Exception:
1044
 
            # Python 2.4 does not permit try:finally: in a generator.
1045
 
            pb.finished()
1046
 
            raise
1047
 
        else:
1048
 
            pb.finished()
1049
 
 
1050
 
    def _do_copy_nodes_graph(self, index_map, writer, write_index,
1051
 
        output_lines, pb, readv_group_iter, total_items):
1052
 
        # for record verification
1053
 
        knit = KnitVersionedFiles(None, None)
1054
 
        # for line extraction when requested (inventories only)
1055
 
        if output_lines:
1056
 
            factory = KnitPlainFactory()
1057
 
        record_index = 0
1058
 
        pb.update("Copied record", record_index, total_items)
1059
 
        for index, readv_vector, node_vector in readv_group_iter:
1060
 
            # copy the data
1061
 
            pack_obj = index_map[index]
1062
 
            transport, path = pack_obj.access_tuple()
1063
 
            try:
1064
 
                reader = pack.make_readv_reader(transport, path, readv_vector)
1065
 
            except errors.NoSuchFile:
1066
 
                if self._reload_func is not None:
1067
 
                    self._reload_func()
1068
 
                raise
1069
 
            for (names, read_func), (key, eol_flag, references) in \
1070
 
                izip(reader.iter_records(), node_vector):
1071
 
                raw_data = read_func(None)
1072
 
                if output_lines:
1073
 
                    # read the entire thing
1074
 
                    content, _ = knit._parse_record(key[-1], raw_data)
1075
 
                    if len(references[-1]) == 0:
1076
 
                        line_iterator = factory.get_fulltext_content(content)
1077
 
                    else:
1078
 
                        line_iterator = factory.get_linedelta_content(content)
1079
 
                    for line in line_iterator:
1080
 
                        yield line, key
1081
 
                else:
1082
 
                    # check the header only
1083
 
                    df, _ = knit._parse_record_header(key, raw_data)
1084
 
                    df.close()
1085
 
                pos, size = writer.add_bytes_record(raw_data, names)
1086
 
                write_index.add_node(key, eol_flag + "%d %d" % (pos, size), references)
1087
 
                pb.update("Copied record", record_index)
1088
 
                record_index += 1
1089
 
 
1090
 
    def _get_text_nodes(self):
1091
 
        text_index_map, text_indices = self._pack_map_and_index_list(
1092
 
            'text_index')
1093
 
        return text_index_map, self._index_contents(text_indices,
1094
 
            self._text_filter)
1095
 
 
1096
 
    def _least_readv_node_readv(self, nodes):
1097
 
        """Generate request groups for nodes using the least readv's.
1098
 
 
1099
 
        :param nodes: An iterable of graph index nodes.
1100
 
        :return: Total node count and an iterator of the data needed to perform
1101
 
            readvs to obtain the data for nodes. Each item yielded by the
1102
 
            iterator is a tuple with:
1103
 
            index, readv_vector, node_vector. readv_vector is a list ready to
1104
 
            hand to the transport readv method, and node_vector is a list of
1105
 
            (key, eol_flag, references) for the node retrieved by the
1106
 
            matching readv_vector.
1107
 
        """
1108
 
        # group by pack so we do one readv per pack
1109
 
        nodes = sorted(nodes)
1110
 
        total = len(nodes)
1111
 
        request_groups = {}
1112
 
        for index, key, value, references in nodes:
1113
 
            if index not in request_groups:
1114
 
                request_groups[index] = []
1115
 
            request_groups[index].append((key, value, references))
1116
 
        result = []
1117
 
        for index, items in request_groups.iteritems():
1118
 
            pack_readv_requests = []
1119
 
            for key, value, references in items:
1120
 
                # ---- KnitGraphIndex.get_position
1121
 
                bits = value[1:].split(' ')
1122
 
                offset, length = int(bits[0]), int(bits[1])
1123
 
                pack_readv_requests.append(
1124
 
                    ((offset, length), (key, value[0], references)))
1125
 
            # linear scan up the pack to maximum range combining.
1126
 
            pack_readv_requests.sort()
1127
 
            # split out the readv and the node data.
1128
 
            pack_readv = [readv for readv, node in pack_readv_requests]
1129
 
            node_vector = [node for readv, node in pack_readv_requests]
1130
 
            result.append((index, pack_readv, node_vector))
1131
 
        return total, result
1132
 
 
1133
 
    def _log_copied_texts(self):
1134
 
        if 'pack' in debug.debug_flags:
1135
 
            mutter('%s: create_pack: file texts copied: %s%s %d items t+%6.3fs',
1136
 
                time.ctime(), self._pack_collection._upload_transport.base,
1137
 
                self.new_pack.random_name,
1138
 
                self.new_pack.text_index.key_count(),
1139
 
                time.time() - self.new_pack.start_time)
1140
 
 
1141
 
    def _process_inventory_lines(self, inv_lines):
1142
 
        """Use up the inv_lines generator and setup a text key filter."""
1143
 
        repo = self._pack_collection.repo
1144
 
        fileid_revisions = repo._find_file_ids_from_xml_inventory_lines(
1145
 
            inv_lines, self.revision_keys)
1146
 
        text_filter = []
1147
 
        for fileid, file_revids in fileid_revisions.iteritems():
1148
 
            text_filter.extend([(fileid, file_revid) for file_revid in file_revids])
1149
 
        self._text_filter = text_filter
1150
 
 
1151
 
    def _revision_node_readv(self, revision_nodes):
1152
 
        """Return the total revisions and the readv's to issue.
1153
 
 
1154
 
        :param revision_nodes: The revision index contents for the packs being
1155
 
            incorporated into the new pack.
1156
 
        :return: As per _least_readv_node_readv.
1157
 
        """
1158
 
        return self._least_readv_node_readv(revision_nodes)
1159
 
 
1160
 
    def _use_pack(self, new_pack):
1161
 
        """Return True if new_pack should be used.
1162
 
 
1163
 
        :param new_pack: The pack that has just been created.
1164
 
        :return: True if the pack should be used.
1165
 
        """
1166
 
        return new_pack.data_inserted()
1167
 
 
1168
 
 
1169
 
class OptimisingPacker(Packer):
1170
 
    """A packer which spends more time to create better disk layouts."""
1171
 
 
1172
 
    def _revision_node_readv(self, revision_nodes):
1173
 
        """Return the total revisions and the readv's to issue.
1174
 
 
1175
 
        This sort places revisions in topological order with the ancestors
1176
 
        after the children.
1177
 
 
1178
 
        :param revision_nodes: The revision index contents for the packs being
1179
 
            incorporated into the new pack.
1180
 
        :return: As per _least_readv_node_readv.
1181
 
        """
1182
 
        # build an ancestors dict
1183
 
        ancestors = {}
1184
 
        by_key = {}
1185
 
        for index, key, value, references in revision_nodes:
1186
 
            ancestors[key] = references[0]
1187
 
            by_key[key] = (index, value, references)
1188
 
        order = tsort.topo_sort(ancestors)
1189
 
        total = len(order)
1190
 
        # Single IO is pathological, but it will work as a starting point.
1191
 
        requests = []
1192
 
        for key in reversed(order):
1193
 
            index, value, references = by_key[key]
1194
 
            # ---- KnitGraphIndex.get_position
1195
 
            bits = value[1:].split(' ')
1196
 
            offset, length = int(bits[0]), int(bits[1])
1197
 
            requests.append(
1198
 
                (index, [(offset, length)], [(key, value[0], references)]))
1199
 
        # TODO: combine requests in the same index that are in ascending order.
1200
 
        return total, requests
1201
 
 
1202
 
    def open_pack(self):
1203
 
        """Open a pack for the pack we are creating."""
1204
 
        new_pack = super(OptimisingPacker, self).open_pack()
1205
 
        # Turn on the optimization flags for all the index builders.
1206
 
        new_pack.revision_index.set_optimize(for_size=True)
1207
 
        new_pack.inventory_index.set_optimize(for_size=True)
1208
 
        new_pack.text_index.set_optimize(for_size=True)
1209
 
        new_pack.signature_index.set_optimize(for_size=True)
1210
 
        return new_pack
1211
 
 
1212
 
 
1213
 
class ReconcilePacker(Packer):
1214
 
    """A packer which regenerates indices etc as it copies.
1215
 
 
1216
 
    This is used by ``bzr reconcile`` to cause parent text pointers to be
1217
 
    regenerated.
1218
 
    """
1219
 
 
1220
 
    def _extra_init(self):
1221
 
        self._data_changed = False
1222
 
 
1223
 
    def _process_inventory_lines(self, inv_lines):
1224
 
        """Generate a text key reference map rather for reconciling with."""
1225
 
        repo = self._pack_collection.repo
1226
 
        refs = repo._find_text_key_references_from_xml_inventory_lines(
1227
 
            inv_lines)
1228
 
        self._text_refs = refs
1229
 
        # during reconcile we:
1230
 
        #  - convert unreferenced texts to full texts
1231
 
        #  - correct texts which reference a text not copied to be full texts
1232
 
        #  - copy all others as-is but with corrected parents.
1233
 
        #  - so at this point we don't know enough to decide what becomes a full
1234
 
        #    text.
1235
 
        self._text_filter = None
1236
 
 
1237
 
    def _copy_text_texts(self):
1238
 
        """generate what texts we should have and then copy."""
1239
 
        self.pb.update("Copying content texts", 3)
1240
 
        # we have three major tasks here:
1241
 
        # 1) generate the ideal index
1242
 
        repo = self._pack_collection.repo
1243
 
        ancestors = dict([(key[0], tuple(ref[0] for ref in refs[0])) for
1244
 
            _1, key, _2, refs in
1245
 
            self.new_pack.revision_index.iter_all_entries()])
1246
 
        ideal_index = repo._generate_text_key_index(self._text_refs, ancestors)
1247
 
        # 2) generate a text_nodes list that contains all the deltas that can
1248
 
        #    be used as-is, with corrected parents.
1249
 
        ok_nodes = []
1250
 
        bad_texts = []
1251
 
        discarded_nodes = []
1252
 
        NULL_REVISION = _mod_revision.NULL_REVISION
1253
 
        text_index_map, text_nodes = self._get_text_nodes()
1254
 
        for node in text_nodes:
1255
 
            # 0 - index
1256
 
            # 1 - key
1257
 
            # 2 - value
1258
 
            # 3 - refs
1259
 
            try:
1260
 
                ideal_parents = tuple(ideal_index[node[1]])
1261
 
            except KeyError:
1262
 
                discarded_nodes.append(node)
1263
 
                self._data_changed = True
1264
 
            else:
1265
 
                if ideal_parents == (NULL_REVISION,):
1266
 
                    ideal_parents = ()
1267
 
                if ideal_parents == node[3][0]:
1268
 
                    # no change needed.
1269
 
                    ok_nodes.append(node)
1270
 
                elif ideal_parents[0:1] == node[3][0][0:1]:
1271
 
                    # the left most parent is the same, or there are no parents
1272
 
                    # today. Either way, we can preserve the representation as
1273
 
                    # long as we change the refs to be inserted.
1274
 
                    self._data_changed = True
1275
 
                    ok_nodes.append((node[0], node[1], node[2],
1276
 
                        (ideal_parents, node[3][1])))
1277
 
                    self._data_changed = True
1278
 
                else:
1279
 
                    # Reinsert this text completely
1280
 
                    bad_texts.append((node[1], ideal_parents))
1281
 
                    self._data_changed = True
1282
 
        # we're finished with some data.
1283
 
        del ideal_index
1284
 
        del text_nodes
1285
 
        # 3) bulk copy the ok data
1286
 
        total_items, readv_group_iter = self._least_readv_node_readv(ok_nodes)
1287
 
        list(self._copy_nodes_graph(text_index_map, self.new_pack._writer,
1288
 
            self.new_pack.text_index, readv_group_iter, total_items))
1289
 
        # 4) adhoc copy all the other texts.
1290
 
        # We have to topologically insert all texts otherwise we can fail to
1291
 
        # reconcile when parts of a single delta chain are preserved intact,
1292
 
        # and other parts are not. E.g. Discarded->d1->d2->d3. d1 will be
1293
 
        # reinserted, and if d3 has incorrect parents it will also be
1294
 
        # reinserted. If we insert d3 first, d2 is present (as it was bulk
1295
 
        # copied), so we will try to delta, but d2 is not currently able to be
1296
 
        # extracted because it's basis d1 is not present. Topologically sorting
1297
 
        # addresses this. The following generates a sort for all the texts that
1298
 
        # are being inserted without having to reference the entire text key
1299
 
        # space (we only topo sort the revisions, which is smaller).
1300
 
        topo_order = tsort.topo_sort(ancestors)
1301
 
        rev_order = dict(zip(topo_order, range(len(topo_order))))
1302
 
        bad_texts.sort(key=lambda key:rev_order.get(key[0][1], 0))
1303
 
        transaction = repo.get_transaction()
1304
 
        file_id_index = GraphIndexPrefixAdapter(
1305
 
            self.new_pack.text_index,
1306
 
            ('blank', ), 1,
1307
 
            add_nodes_callback=self.new_pack.text_index.add_nodes)
1308
 
        data_access = _DirectPackAccess(
1309
 
                {self.new_pack.text_index:self.new_pack.access_tuple()})
1310
 
        data_access.set_writer(self.new_pack._writer, self.new_pack.text_index,
1311
 
            self.new_pack.access_tuple())
1312
 
        output_texts = KnitVersionedFiles(
1313
 
            _KnitGraphIndex(self.new_pack.text_index,
1314
 
                add_callback=self.new_pack.text_index.add_nodes,
1315
 
                deltas=True, parents=True, is_locked=repo.is_locked),
1316
 
            data_access=data_access, max_delta_chain=200)
1317
 
        for key, parent_keys in bad_texts:
1318
 
            # We refer to the new pack to delta data being output.
1319
 
            # A possible improvement would be to catch errors on short reads
1320
 
            # and only flush then.
1321
 
            self.new_pack.flush()
1322
 
            parents = []
1323
 
            for parent_key in parent_keys:
1324
 
                if parent_key[0] != key[0]:
1325
 
                    # Graph parents must match the fileid
1326
 
                    raise errors.BzrError('Mismatched key parent %r:%r' %
1327
 
                        (key, parent_keys))
1328
 
                parents.append(parent_key[1])
1329
 
            text_lines = osutils.split_lines(repo.texts.get_record_stream(
1330
 
                [key], 'unordered', True).next().get_bytes_as('fulltext'))
1331
 
            output_texts.add_lines(key, parent_keys, text_lines,
1332
 
                random_id=True, check_content=False)
1333
 
        # 5) check that nothing inserted has a reference outside the keyspace.
1334
 
        missing_text_keys = self.new_pack.text_index._external_references()
1335
 
        if missing_text_keys:
1336
 
            raise errors.BzrCheckError('Reference to missing compression parents %r'
1337
 
                % (missing_text_keys,))
1338
 
        self._log_copied_texts()
1339
 
 
1340
 
    def _use_pack(self, new_pack):
1341
 
        """Override _use_pack to check for reconcile having changed content."""
1342
 
        # XXX: we might be better checking this at the copy time.
1343
 
        original_inventory_keys = set()
1344
 
        inv_index = self._pack_collection.inventory_index.combined_index
1345
 
        for entry in inv_index.iter_all_entries():
1346
 
            original_inventory_keys.add(entry[1])
1347
 
        new_inventory_keys = set()
1348
 
        for entry in new_pack.inventory_index.iter_all_entries():
1349
 
            new_inventory_keys.add(entry[1])
1350
 
        if new_inventory_keys != original_inventory_keys:
1351
 
            self._data_changed = True
1352
 
        return new_pack.data_inserted() and self._data_changed
1353
 
 
1354
 
 
1355
 
class RepositoryPackCollection(object):
1356
 
    """Management of packs within a repository.
1357
 
 
1358
 
    :ivar _names: map of {pack_name: (index_size,)}
1359
 
    """
1360
 
 
1361
 
    pack_factory = NewPack
1362
 
    resumed_pack_factory = ResumedPack
1363
 
 
1364
 
    def __init__(self, repo, transport, index_transport, upload_transport,
1365
 
                 pack_transport, index_builder_class, index_class,
1366
 
                 use_chk_index):
1367
 
        """Create a new RepositoryPackCollection.
1368
 
 
1369
 
        :param transport: Addresses the repository base directory
1370
 
            (typically .bzr/repository/).
1371
 
        :param index_transport: Addresses the directory containing indices.
1372
 
        :param upload_transport: Addresses the directory into which packs are written
1373
 
            while they're being created.
1374
 
        :param pack_transport: Addresses the directory of existing complete packs.
1375
 
        :param index_builder_class: The index builder class to use.
1376
 
        :param index_class: The index class to use.
1377
 
        :param use_chk_index: Whether to setup and manage a CHK index.
1378
 
        """
1379
 
        # XXX: This should call self.reset()
1380
 
        self.repo = repo
1381
 
        self.transport = transport
1382
 
        self._index_transport = index_transport
1383
 
        self._upload_transport = upload_transport
1384
 
        self._pack_transport = pack_transport
1385
 
        self._index_builder_class = index_builder_class
1386
 
        self._index_class = index_class
1387
 
        self._suffix_offsets = {'.rix': 0, '.iix': 1, '.tix': 2, '.six': 3,
1388
 
            '.cix': 4}
1389
 
        self.packs = []
1390
 
        # name:Pack mapping
1391
 
        self._names = None
1392
 
        self._packs_by_name = {}
1393
 
        # the previous pack-names content
1394
 
        self._packs_at_load = None
1395
 
        # when a pack is being created by this object, the state of that pack.
1396
 
        self._new_pack = None
1397
 
        # aggregated revision index data
1398
 
        flush = self._flush_new_pack
1399
 
        self.revision_index = AggregateIndex(self.reload_pack_names, flush)
1400
 
        self.inventory_index = AggregateIndex(self.reload_pack_names, flush)
1401
 
        self.text_index = AggregateIndex(self.reload_pack_names, flush)
1402
 
        self.signature_index = AggregateIndex(self.reload_pack_names, flush)
1403
 
        all_indices = [self.revision_index, self.inventory_index,
1404
 
                self.text_index, self.signature_index]
1405
 
        if use_chk_index:
1406
 
            self.chk_index = AggregateIndex(self.reload_pack_names, flush)
1407
 
            all_indices.append(self.chk_index)
1408
 
        else:
1409
 
            # used to determine if we're using a chk_index elsewhere.
1410
 
            self.chk_index = None
1411
 
        # Tell all the CombinedGraphIndex objects about each other, so they can
1412
 
        # share hints about which pack names to search first.
1413
 
        all_combined = [agg_idx.combined_index for agg_idx in all_indices]
1414
 
        for combined_idx in all_combined:
1415
 
            combined_idx.set_sibling_indices(
1416
 
                set(all_combined).difference([combined_idx]))
1417
 
        # resumed packs
1418
 
        self._resumed_packs = []
1419
 
 
1420
 
    def __repr__(self):
1421
 
        return '%s(%r)' % (self.__class__.__name__, self.repo)
1422
 
 
1423
 
    def add_pack_to_memory(self, pack):
1424
 
        """Make a Pack object available to the repository to satisfy queries.
1425
 
 
1426
 
        :param pack: A Pack object.
1427
 
        """
1428
 
        if pack.name in self._packs_by_name:
1429
 
            raise AssertionError(
1430
 
                'pack %s already in _packs_by_name' % (pack.name,))
1431
 
        self.packs.append(pack)
1432
 
        self._packs_by_name[pack.name] = pack
1433
 
        self.revision_index.add_index(pack.revision_index, pack)
1434
 
        self.inventory_index.add_index(pack.inventory_index, pack)
1435
 
        self.text_index.add_index(pack.text_index, pack)
1436
 
        self.signature_index.add_index(pack.signature_index, pack)
1437
 
        if self.chk_index is not None:
1438
 
            self.chk_index.add_index(pack.chk_index, pack)
1439
 
 
1440
 
    def all_packs(self):
1441
 
        """Return a list of all the Pack objects this repository has.
1442
 
 
1443
 
        Note that an in-progress pack being created is not returned.
1444
 
 
1445
 
        :return: A list of Pack objects for all the packs in the repository.
1446
 
        """
1447
 
        result = []
1448
 
        for name in self.names():
1449
 
            result.append(self.get_pack_by_name(name))
1450
 
        return result
1451
 
 
1452
 
    def autopack(self):
1453
 
        """Pack the pack collection incrementally.
1454
 
 
1455
 
        This will not attempt global reorganisation or recompression,
1456
 
        rather it will just ensure that the total number of packs does
1457
 
        not grow without bound. It uses the _max_pack_count method to
1458
 
        determine if autopacking is needed, and the pack_distribution
1459
 
        method to determine the number of revisions in each pack.
1460
 
 
1461
 
        If autopacking takes place then the packs name collection will have
1462
 
        been flushed to disk - packing requires updating the name collection
1463
 
        in synchronisation with certain steps. Otherwise the names collection
1464
 
        is not flushed.
1465
 
 
1466
 
        :return: Something evaluating true if packing took place.
1467
 
        """
1468
 
        while True:
1469
 
            try:
1470
 
                return self._do_autopack()
1471
 
            except errors.RetryAutopack:
1472
 
                # If we get a RetryAutopack exception, we should abort the
1473
 
                # current action, and retry.
1474
 
                pass
1475
 
 
1476
 
    def _do_autopack(self):
1477
 
        # XXX: Should not be needed when the management of indices is sane.
1478
 
        total_revisions = self.revision_index.combined_index.key_count()
1479
 
        total_packs = len(self._names)
1480
 
        if self._max_pack_count(total_revisions) >= total_packs:
1481
 
            return None
1482
 
        # determine which packs need changing
1483
 
        pack_distribution = self.pack_distribution(total_revisions)
1484
 
        existing_packs = []
1485
 
        for pack in self.all_packs():
1486
 
            revision_count = pack.get_revision_count()
1487
 
            if revision_count == 0:
1488
 
                # revision less packs are not generated by normal operation,
1489
 
                # only by operations like sign-my-commits, and thus will not
1490
 
                # tend to grow rapdily or without bound like commit containing
1491
 
                # packs do - leave them alone as packing them really should
1492
 
                # group their data with the relevant commit, and that may
1493
 
                # involve rewriting ancient history - which autopack tries to
1494
 
                # avoid. Alternatively we could not group the data but treat
1495
 
                # each of these as having a single revision, and thus add
1496
 
                # one revision for each to the total revision count, to get
1497
 
                # a matching distribution.
1498
 
                continue
1499
 
            existing_packs.append((revision_count, pack))
1500
 
        pack_operations = self.plan_autopack_combinations(
1501
 
            existing_packs, pack_distribution)
1502
 
        num_new_packs = len(pack_operations)
1503
 
        num_old_packs = sum([len(po[1]) for po in pack_operations])
1504
 
        num_revs_affected = sum([po[0] for po in pack_operations])
1505
 
        mutter('Auto-packing repository %s, which has %d pack files, '
1506
 
            'containing %d revisions. Packing %d files into %d affecting %d'
1507
 
            ' revisions', self, total_packs, total_revisions, num_old_packs,
1508
 
            num_new_packs, num_revs_affected)
1509
 
        result = self._execute_pack_operations(pack_operations,
1510
 
                                      reload_func=self._restart_autopack)
1511
 
        mutter('Auto-packing repository %s completed', self)
1512
 
        return result
1513
 
 
1514
 
    def _execute_pack_operations(self, pack_operations, _packer_class=Packer,
1515
 
                                 reload_func=None):
1516
 
        """Execute a series of pack operations.
1517
 
 
1518
 
        :param pack_operations: A list of [revision_count, packs_to_combine].
1519
 
        :param _packer_class: The class of packer to use (default: Packer).
1520
 
        :return: The new pack names.
1521
 
        """
1522
 
        for revision_count, packs in pack_operations:
1523
 
            # we may have no-ops from the setup logic
1524
 
            if len(packs) == 0:
1525
 
                continue
1526
 
            packer = _packer_class(self, packs, '.autopack',
1527
 
                                   reload_func=reload_func)
1528
 
            try:
1529
 
                packer.pack()
1530
 
            except errors.RetryWithNewPacks:
1531
 
                # An exception is propagating out of this context, make sure
1532
 
                # this packer has cleaned up. Packer() doesn't set its new_pack
1533
 
                # state into the RepositoryPackCollection object, so we only
1534
 
                # have access to it directly here.
1535
 
                if packer.new_pack is not None:
1536
 
                    packer.new_pack.abort()
1537
 
                raise
1538
 
            for pack in packs:
1539
 
                self._remove_pack_from_memory(pack)
1540
 
        # record the newly available packs and stop advertising the old
1541
 
        # packs
1542
 
        to_be_obsoleted = []
1543
 
        for _, packs in pack_operations:
1544
 
            to_be_obsoleted.extend(packs)
1545
 
        result = self._save_pack_names(clear_obsolete_packs=True,
1546
 
                                       obsolete_packs=to_be_obsoleted)
1547
 
        return result
1548
 
 
1549
 
    def _flush_new_pack(self):
1550
 
        if self._new_pack is not None:
1551
 
            self._new_pack.flush()
1552
 
 
1553
 
    def lock_names(self):
1554
 
        """Acquire the mutex around the pack-names index.
1555
 
 
1556
 
        This cannot be used in the middle of a read-only transaction on the
1557
 
        repository.
1558
 
        """
1559
 
        self.repo.control_files.lock_write()
1560
 
 
1561
 
    def _already_packed(self):
1562
 
        """Is the collection already packed?"""
1563
 
        return not (self.repo._format.pack_compresses or (len(self._names) > 1))
1564
 
 
1565
 
    def pack(self, hint=None, clean_obsolete_packs=False):
1566
 
        """Pack the pack collection totally."""
1567
 
        self.ensure_loaded()
1568
 
        total_packs = len(self._names)
1569
 
        if self._already_packed():
1570
 
            return
1571
 
        total_revisions = self.revision_index.combined_index.key_count()
1572
 
        # XXX: the following may want to be a class, to pack with a given
1573
 
        # policy.
1574
 
        mutter('Packing repository %s, which has %d pack files, '
1575
 
            'containing %d revisions with hint %r.', self, total_packs,
1576
 
            total_revisions, hint)
1577
 
        # determine which packs need changing
1578
 
        pack_operations = [[0, []]]
1579
 
        for pack in self.all_packs():
1580
 
            if hint is None or pack.name in hint:
1581
 
                # Either no hint was provided (so we are packing everything),
1582
 
                # or this pack was included in the hint.
1583
 
                pack_operations[-1][0] += pack.get_revision_count()
1584
 
                pack_operations[-1][1].append(pack)
1585
 
        self._execute_pack_operations(pack_operations, OptimisingPacker)
1586
 
 
1587
 
        if clean_obsolete_packs:
1588
 
            self._clear_obsolete_packs()
1589
 
 
1590
 
    def plan_autopack_combinations(self, existing_packs, pack_distribution):
1591
 
        """Plan a pack operation.
1592
 
 
1593
 
        :param existing_packs: The packs to pack. (A list of (revcount, Pack)
1594
 
            tuples).
1595
 
        :param pack_distribution: A list with the number of revisions desired
1596
 
            in each pack.
1597
 
        """
1598
 
        if len(existing_packs) <= len(pack_distribution):
1599
 
            return []
1600
 
        existing_packs.sort(reverse=True)
1601
 
        pack_operations = [[0, []]]
1602
 
        # plan out what packs to keep, and what to reorganise
1603
 
        while len(existing_packs):
1604
 
            # take the largest pack, and if its less than the head of the
1605
 
            # distribution chart we will include its contents in the new pack
1606
 
            # for that position. If its larger, we remove its size from the
1607
 
            # distribution chart
1608
 
            next_pack_rev_count, next_pack = existing_packs.pop(0)
1609
 
            if next_pack_rev_count >= pack_distribution[0]:
1610
 
                # this is already packed 'better' than this, so we can
1611
 
                # not waste time packing it.
1612
 
                while next_pack_rev_count > 0:
1613
 
                    next_pack_rev_count -= pack_distribution[0]
1614
 
                    if next_pack_rev_count >= 0:
1615
 
                        # more to go
1616
 
                        del pack_distribution[0]
1617
 
                    else:
1618
 
                        # didn't use that entire bucket up
1619
 
                        pack_distribution[0] = -next_pack_rev_count
1620
 
            else:
1621
 
                # add the revisions we're going to add to the next output pack
1622
 
                pack_operations[-1][0] += next_pack_rev_count
1623
 
                # allocate this pack to the next pack sub operation
1624
 
                pack_operations[-1][1].append(next_pack)
1625
 
                if pack_operations[-1][0] >= pack_distribution[0]:
1626
 
                    # this pack is used up, shift left.
1627
 
                    del pack_distribution[0]
1628
 
                    pack_operations.append([0, []])
1629
 
        # Now that we know which pack files we want to move, shove them all
1630
 
        # into a single pack file.
1631
 
        final_rev_count = 0
1632
 
        final_pack_list = []
1633
 
        for num_revs, pack_files in pack_operations:
1634
 
            final_rev_count += num_revs
1635
 
            final_pack_list.extend(pack_files)
1636
 
        if len(final_pack_list) == 1:
1637
 
            raise AssertionError('We somehow generated an autopack with a'
1638
 
                ' single pack file being moved.')
1639
 
            return []
1640
 
        return [[final_rev_count, final_pack_list]]
1641
 
 
1642
 
    def ensure_loaded(self):
1643
 
        """Ensure we have read names from disk.
1644
 
 
1645
 
        :return: True if the disk names had not been previously read.
1646
 
        """
1647
 
        # NB: if you see an assertion error here, its probably access against
1648
 
        # an unlocked repo. Naughty.
1649
 
        if not self.repo.is_locked():
1650
 
            raise errors.ObjectNotLocked(self.repo)
1651
 
        if self._names is None:
1652
 
            self._names = {}
1653
 
            self._packs_at_load = set()
1654
 
            for index, key, value in self._iter_disk_pack_index():
1655
 
                name = key[0]
1656
 
                self._names[name] = self._parse_index_sizes(value)
1657
 
                self._packs_at_load.add((key, value))
1658
 
            result = True
1659
 
        else:
1660
 
            result = False
1661
 
        # populate all the metadata.
1662
 
        self.all_packs()
1663
 
        return result
1664
 
 
1665
 
    def _parse_index_sizes(self, value):
1666
 
        """Parse a string of index sizes."""
1667
 
        return tuple([int(digits) for digits in value.split(' ')])
1668
 
 
1669
 
    def get_pack_by_name(self, name):
1670
 
        """Get a Pack object by name.
1671
 
 
1672
 
        :param name: The name of the pack - e.g. '123456'
1673
 
        :return: A Pack object.
1674
 
        """
1675
 
        try:
1676
 
            return self._packs_by_name[name]
1677
 
        except KeyError:
1678
 
            rev_index = self._make_index(name, '.rix')
1679
 
            inv_index = self._make_index(name, '.iix')
1680
 
            txt_index = self._make_index(name, '.tix')
1681
 
            sig_index = self._make_index(name, '.six')
1682
 
            if self.chk_index is not None:
1683
 
                chk_index = self._make_index(name, '.cix', unlimited_cache=True)
1684
 
            else:
1685
 
                chk_index = None
1686
 
            result = ExistingPack(self._pack_transport, name, rev_index,
1687
 
                inv_index, txt_index, sig_index, chk_index)
1688
 
            self.add_pack_to_memory(result)
1689
 
            return result
1690
 
 
1691
 
    def _resume_pack(self, name):
1692
 
        """Get a suspended Pack object by name.
1693
 
 
1694
 
        :param name: The name of the pack - e.g. '123456'
1695
 
        :return: A Pack object.
1696
 
        """
1697
 
        if not re.match('[a-f0-9]{32}', name):
1698
 
            # Tokens should be md5sums of the suspended pack file, i.e. 32 hex
1699
 
            # digits.
1700
 
            raise errors.UnresumableWriteGroup(
1701
 
                self.repo, [name], 'Malformed write group token')
1702
 
        try:
1703
 
            rev_index = self._make_index(name, '.rix', resume=True)
1704
 
            inv_index = self._make_index(name, '.iix', resume=True)
1705
 
            txt_index = self._make_index(name, '.tix', resume=True)
1706
 
            sig_index = self._make_index(name, '.six', resume=True)
1707
 
            if self.chk_index is not None:
1708
 
                chk_index = self._make_index(name, '.cix', resume=True,
1709
 
                                             unlimited_cache=True)
1710
 
            else:
1711
 
                chk_index = None
1712
 
            result = self.resumed_pack_factory(name, rev_index, inv_index,
1713
 
                txt_index, sig_index, self._upload_transport,
1714
 
                self._pack_transport, self._index_transport, self,
1715
 
                chk_index=chk_index)
1716
 
        except errors.NoSuchFile, e:
1717
 
            raise errors.UnresumableWriteGroup(self.repo, [name], str(e))
1718
 
        self.add_pack_to_memory(result)
1719
 
        self._resumed_packs.append(result)
1720
 
        return result
1721
 
 
1722
 
    def allocate(self, a_new_pack):
1723
 
        """Allocate name in the list of packs.
1724
 
 
1725
 
        :param a_new_pack: A NewPack instance to be added to the collection of
1726
 
            packs for this repository.
1727
 
        """
1728
 
        self.ensure_loaded()
1729
 
        if a_new_pack.name in self._names:
1730
 
            raise errors.BzrError(
1731
 
                'Pack %r already exists in %s' % (a_new_pack.name, self))
1732
 
        self._names[a_new_pack.name] = tuple(a_new_pack.index_sizes)
1733
 
        self.add_pack_to_memory(a_new_pack)
1734
 
 
1735
 
    def _iter_disk_pack_index(self):
1736
 
        """Iterate over the contents of the pack-names index.
1737
 
 
1738
 
        This is used when loading the list from disk, and before writing to
1739
 
        detect updates from others during our write operation.
1740
 
        :return: An iterator of the index contents.
1741
 
        """
1742
 
        return self._index_class(self.transport, 'pack-names', None
1743
 
                ).iter_all_entries()
1744
 
 
1745
 
    def _make_index(self, name, suffix, resume=False, unlimited_cache=False):
1746
 
        size_offset = self._suffix_offsets[suffix]
1747
 
        index_name = name + suffix
1748
 
        if resume:
1749
 
            transport = self._upload_transport
1750
 
            index_size = transport.stat(index_name).st_size
1751
 
        else:
1752
 
            transport = self._index_transport
1753
 
            index_size = self._names[name][size_offset]
1754
 
        return self._index_class(transport, index_name, index_size,
1755
 
                                 unlimited_cache=unlimited_cache)
1756
 
 
1757
 
    def _max_pack_count(self, total_revisions):
1758
 
        """Return the maximum number of packs to use for total revisions.
1759
 
 
1760
 
        :param total_revisions: The total number of revisions in the
1761
 
            repository.
1762
 
        """
1763
 
        if not total_revisions:
1764
 
            return 1
1765
 
        digits = str(total_revisions)
1766
 
        result = 0
1767
 
        for digit in digits:
1768
 
            result += int(digit)
1769
 
        return result
1770
 
 
1771
 
    def names(self):
1772
 
        """Provide an order to the underlying names."""
1773
 
        return sorted(self._names.keys())
1774
 
 
1775
 
    def _obsolete_packs(self, packs):
1776
 
        """Move a number of packs which have been obsoleted out of the way.
1777
 
 
1778
 
        Each pack and its associated indices are moved out of the way.
1779
 
 
1780
 
        Note: for correctness this function should only be called after a new
1781
 
        pack names index has been written without these pack names, and with
1782
 
        the names of packs that contain the data previously available via these
1783
 
        packs.
1784
 
 
1785
 
        :param packs: The packs to obsolete.
1786
 
        :param return: None.
1787
 
        """
1788
 
        for pack in packs:
1789
 
            try:
1790
 
                pack.pack_transport.rename(pack.file_name(),
1791
 
                    '../obsolete_packs/' + pack.file_name())
1792
 
            except (errors.PathError, errors.TransportError), e:
1793
 
                # TODO: Should these be warnings or mutters?
1794
 
                mutter("couldn't rename obsolete pack, skipping it:\n%s"
1795
 
                       % (e,))
1796
 
            # TODO: Probably needs to know all possible indices for this pack
1797
 
            # - or maybe list the directory and move all indices matching this
1798
 
            # name whether we recognize it or not?
1799
 
            suffixes = ['.iix', '.six', '.tix', '.rix']
1800
 
            if self.chk_index is not None:
1801
 
                suffixes.append('.cix')
1802
 
            for suffix in suffixes:
1803
 
                try:
1804
 
                    self._index_transport.rename(pack.name + suffix,
1805
 
                        '../obsolete_packs/' + pack.name + suffix)
1806
 
                except (errors.PathError, errors.TransportError), e:
1807
 
                    mutter("couldn't rename obsolete index, skipping it:\n%s"
1808
 
                           % (e,))
1809
 
 
1810
 
    def pack_distribution(self, total_revisions):
1811
 
        """Generate a list of the number of revisions to put in each pack.
1812
 
 
1813
 
        :param total_revisions: The total number of revisions in the
1814
 
            repository.
1815
 
        """
1816
 
        if total_revisions == 0:
1817
 
            return [0]
1818
 
        digits = reversed(str(total_revisions))
1819
 
        result = []
1820
 
        for exponent, count in enumerate(digits):
1821
 
            size = 10 ** exponent
1822
 
            for pos in range(int(count)):
1823
 
                result.append(size)
1824
 
        return list(reversed(result))
1825
 
 
1826
 
    def _pack_tuple(self, name):
1827
 
        """Return a tuple with the transport and file name for a pack name."""
1828
 
        return self._pack_transport, name + '.pack'
1829
 
 
1830
 
    def _remove_pack_from_memory(self, pack):
1831
 
        """Remove pack from the packs accessed by this repository.
1832
 
 
1833
 
        Only affects memory state, until self._save_pack_names() is invoked.
1834
 
        """
1835
 
        self._names.pop(pack.name)
1836
 
        self._packs_by_name.pop(pack.name)
1837
 
        self._remove_pack_indices(pack)
1838
 
        self.packs.remove(pack)
1839
 
 
1840
 
    def _remove_pack_indices(self, pack, ignore_missing=False):
1841
 
        """Remove the indices for pack from the aggregated indices.
1842
 
        
1843
 
        :param ignore_missing: Suppress KeyErrors from calling remove_index.
1844
 
        """
1845
 
        for index_type in Pack.index_definitions.keys():
1846
 
            attr_name = index_type + '_index'
1847
 
            aggregate_index = getattr(self, attr_name)
1848
 
            if aggregate_index is not None:
1849
 
                pack_index = getattr(pack, attr_name)
1850
 
                try:
1851
 
                    aggregate_index.remove_index(pack_index)
1852
 
                except KeyError:
1853
 
                    if ignore_missing:
1854
 
                        continue
1855
 
                    raise
1856
 
 
1857
 
    def reset(self):
1858
 
        """Clear all cached data."""
1859
 
        # cached revision data
1860
 
        self.revision_index.clear()
1861
 
        # cached signature data
1862
 
        self.signature_index.clear()
1863
 
        # cached file text data
1864
 
        self.text_index.clear()
1865
 
        # cached inventory data
1866
 
        self.inventory_index.clear()
1867
 
        # cached chk data
1868
 
        if self.chk_index is not None:
1869
 
            self.chk_index.clear()
1870
 
        # remove the open pack
1871
 
        self._new_pack = None
1872
 
        # information about packs.
1873
 
        self._names = None
1874
 
        self.packs = []
1875
 
        self._packs_by_name = {}
1876
 
        self._packs_at_load = None
1877
 
 
1878
 
    def _unlock_names(self):
1879
 
        """Release the mutex around the pack-names index."""
1880
 
        self.repo.control_files.unlock()
1881
 
 
1882
 
    def _diff_pack_names(self):
1883
 
        """Read the pack names from disk, and compare it to the one in memory.
1884
 
 
1885
 
        :return: (disk_nodes, deleted_nodes, new_nodes)
1886
 
            disk_nodes    The final set of nodes that should be referenced
1887
 
            deleted_nodes Nodes which have been removed from when we started
1888
 
            new_nodes     Nodes that are newly introduced
1889
 
        """
1890
 
        # load the disk nodes across
1891
 
        disk_nodes = set()
1892
 
        for index, key, value in self._iter_disk_pack_index():
1893
 
            disk_nodes.add((key, value))
1894
 
        orig_disk_nodes = set(disk_nodes)
1895
 
 
1896
 
        # do a two-way diff against our original content
1897
 
        current_nodes = set()
1898
 
        for name, sizes in self._names.iteritems():
1899
 
            current_nodes.add(
1900
 
                ((name, ), ' '.join(str(size) for size in sizes)))
1901
 
 
1902
 
        # Packs no longer present in the repository, which were present when we
1903
 
        # locked the repository
1904
 
        deleted_nodes = self._packs_at_load - current_nodes
1905
 
        # Packs which this process is adding
1906
 
        new_nodes = current_nodes - self._packs_at_load
1907
 
 
1908
 
        # Update the disk_nodes set to include the ones we are adding, and
1909
 
        # remove the ones which were removed by someone else
1910
 
        disk_nodes.difference_update(deleted_nodes)
1911
 
        disk_nodes.update(new_nodes)
1912
 
 
1913
 
        return disk_nodes, deleted_nodes, new_nodes, orig_disk_nodes
1914
 
 
1915
 
    def _syncronize_pack_names_from_disk_nodes(self, disk_nodes):
1916
 
        """Given the correct set of pack files, update our saved info.
1917
 
 
1918
 
        :return: (removed, added, modified)
1919
 
            removed     pack names removed from self._names
1920
 
            added       pack names added to self._names
1921
 
            modified    pack names that had changed value
1922
 
        """
1923
 
        removed = []
1924
 
        added = []
1925
 
        modified = []
1926
 
        ## self._packs_at_load = disk_nodes
1927
 
        new_names = dict(disk_nodes)
1928
 
        # drop no longer present nodes
1929
 
        for pack in self.all_packs():
1930
 
            if (pack.name,) not in new_names:
1931
 
                removed.append(pack.name)
1932
 
                self._remove_pack_from_memory(pack)
1933
 
        # add new nodes/refresh existing ones
1934
 
        for key, value in disk_nodes:
1935
 
            name = key[0]
1936
 
            sizes = self._parse_index_sizes(value)
1937
 
            if name in self._names:
1938
 
                # existing
1939
 
                if sizes != self._names[name]:
1940
 
                    # the pack for name has had its indices replaced - rare but
1941
 
                    # important to handle. XXX: probably can never happen today
1942
 
                    # because the three-way merge code above does not handle it
1943
 
                    # - you may end up adding the same key twice to the new
1944
 
                    # disk index because the set values are the same, unless
1945
 
                    # the only index shows up as deleted by the set difference
1946
 
                    # - which it may. Until there is a specific test for this,
1947
 
                    # assume its broken. RBC 20071017.
1948
 
                    self._remove_pack_from_memory(self.get_pack_by_name(name))
1949
 
                    self._names[name] = sizes
1950
 
                    self.get_pack_by_name(name)
1951
 
                    modified.append(name)
1952
 
            else:
1953
 
                # new
1954
 
                self._names[name] = sizes
1955
 
                self.get_pack_by_name(name)
1956
 
                added.append(name)
1957
 
        return removed, added, modified
1958
 
 
1959
 
    def _save_pack_names(self, clear_obsolete_packs=False, obsolete_packs=None):
1960
 
        """Save the list of packs.
1961
 
 
1962
 
        This will take out the mutex around the pack names list for the
1963
 
        duration of the method call. If concurrent updates have been made, a
1964
 
        three-way merge between the current list and the current in memory list
1965
 
        is performed.
1966
 
 
1967
 
        :param clear_obsolete_packs: If True, clear out the contents of the
1968
 
            obsolete_packs directory.
1969
 
        :param obsolete_packs: Packs that are obsolete once the new pack-names
1970
 
            file has been written.
1971
 
        :return: A list of the names saved that were not previously on disk.
1972
 
        """
1973
 
        already_obsolete = []
1974
 
        self.lock_names()
1975
 
        try:
1976
 
            builder = self._index_builder_class()
1977
 
            (disk_nodes, deleted_nodes, new_nodes,
1978
 
             orig_disk_nodes) = self._diff_pack_names()
1979
 
            # TODO: handle same-name, index-size-changes here -
1980
 
            # e.g. use the value from disk, not ours, *unless* we're the one
1981
 
            # changing it.
1982
 
            for key, value in disk_nodes:
1983
 
                builder.add_node(key, value)
1984
 
            self.transport.put_file('pack-names', builder.finish(),
1985
 
                mode=self.repo.bzrdir._get_file_mode())
1986
 
            self._packs_at_load = disk_nodes
1987
 
            if clear_obsolete_packs:
1988
 
                to_preserve = None
1989
 
                if obsolete_packs:
1990
 
                    to_preserve = set([o.name for o in obsolete_packs])
1991
 
                already_obsolete = self._clear_obsolete_packs(to_preserve)
1992
 
        finally:
1993
 
            self._unlock_names()
1994
 
        # synchronise the memory packs list with what we just wrote:
1995
 
        self._syncronize_pack_names_from_disk_nodes(disk_nodes)
1996
 
        if obsolete_packs:
1997
 
            # TODO: We could add one more condition here. "if o.name not in
1998
 
            #       orig_disk_nodes and o != the new_pack we haven't written to
1999
 
            #       disk yet. However, the new pack object is not easily
2000
 
            #       accessible here (it would have to be passed through the
2001
 
            #       autopacking code, etc.)
2002
 
            obsolete_packs = [o for o in obsolete_packs
2003
 
                              if o.name not in already_obsolete]
2004
 
            self._obsolete_packs(obsolete_packs)
2005
 
        return [new_node[0][0] for new_node in new_nodes]
2006
 
 
2007
 
    def reload_pack_names(self):
2008
 
        """Sync our pack listing with what is present in the repository.
2009
 
 
2010
 
        This should be called when we find out that something we thought was
2011
 
        present is now missing. This happens when another process re-packs the
2012
 
        repository, etc.
2013
 
 
2014
 
        :return: True if the in-memory list of packs has been altered at all.
2015
 
        """
2016
 
        # The ensure_loaded call is to handle the case where the first call
2017
 
        # made involving the collection was to reload_pack_names, where we 
2018
 
        # don't have a view of disk contents. Its a bit of a bandaid, and
2019
 
        # causes two reads of pack-names, but its a rare corner case not struck
2020
 
        # with regular push/pull etc.
2021
 
        first_read = self.ensure_loaded()
2022
 
        if first_read:
2023
 
            return True
2024
 
        # out the new value.
2025
 
        (disk_nodes, deleted_nodes, new_nodes,
2026
 
         orig_disk_nodes) = self._diff_pack_names()
2027
 
        # _packs_at_load is meant to be the explicit list of names in
2028
 
        # 'pack-names' at then start. As such, it should not contain any
2029
 
        # pending names that haven't been written out yet.
2030
 
        self._packs_at_load = orig_disk_nodes
2031
 
        (removed, added,
2032
 
         modified) = self._syncronize_pack_names_from_disk_nodes(disk_nodes)
2033
 
        if removed or added or modified:
2034
 
            return True
2035
 
        return False
2036
 
 
2037
 
    def _restart_autopack(self):
2038
 
        """Reload the pack names list, and restart the autopack code."""
2039
 
        if not self.reload_pack_names():
2040
 
            # Re-raise the original exception, because something went missing
2041
 
            # and a restart didn't find it
2042
 
            raise
2043
 
        raise errors.RetryAutopack(self.repo, False, sys.exc_info())
2044
 
 
2045
 
    def _clear_obsolete_packs(self, preserve=None):
2046
 
        """Delete everything from the obsolete-packs directory.
2047
 
 
2048
 
        :return: A list of pack identifiers (the filename without '.pack') that
2049
 
            were found in obsolete_packs.
2050
 
        """
2051
 
        found = []
2052
 
        obsolete_pack_transport = self.transport.clone('obsolete_packs')
2053
 
        if preserve is None:
2054
 
            preserve = set()
2055
 
        for filename in obsolete_pack_transport.list_dir('.'):
2056
 
            name, ext = osutils.splitext(filename)
2057
 
            if ext == '.pack':
2058
 
                found.append(name)
2059
 
            if name in preserve:
2060
 
                continue
2061
 
            try:
2062
 
                obsolete_pack_transport.delete(filename)
2063
 
            except (errors.PathError, errors.TransportError), e:
2064
 
                warning("couldn't delete obsolete pack, skipping it:\n%s"
2065
 
                        % (e,))
2066
 
        return found
2067
 
 
2068
 
    def _start_write_group(self):
2069
 
        # Do not permit preparation for writing if we're not in a 'write lock'.
2070
 
        if not self.repo.is_write_locked():
2071
 
            raise errors.NotWriteLocked(self)
2072
 
        self._new_pack = self.pack_factory(self, upload_suffix='.pack',
2073
 
            file_mode=self.repo.bzrdir._get_file_mode())
2074
 
        # allow writing: queue writes to a new index
2075
 
        self.revision_index.add_writable_index(self._new_pack.revision_index,
2076
 
            self._new_pack)
2077
 
        self.inventory_index.add_writable_index(self._new_pack.inventory_index,
2078
 
            self._new_pack)
2079
 
        self.text_index.add_writable_index(self._new_pack.text_index,
2080
 
            self._new_pack)
2081
 
        self._new_pack.text_index.set_optimize(combine_backing_indices=False)
2082
 
        self.signature_index.add_writable_index(self._new_pack.signature_index,
2083
 
            self._new_pack)
2084
 
        if self.chk_index is not None:
2085
 
            self.chk_index.add_writable_index(self._new_pack.chk_index,
2086
 
                self._new_pack)
2087
 
            self.repo.chk_bytes._index._add_callback = self.chk_index.add_callback
2088
 
            self._new_pack.chk_index.set_optimize(combine_backing_indices=False)
2089
 
 
2090
 
        self.repo.inventories._index._add_callback = self.inventory_index.add_callback
2091
 
        self.repo.revisions._index._add_callback = self.revision_index.add_callback
2092
 
        self.repo.signatures._index._add_callback = self.signature_index.add_callback
2093
 
        self.repo.texts._index._add_callback = self.text_index.add_callback
2094
 
 
2095
 
    def _abort_write_group(self):
2096
 
        # FIXME: just drop the transient index.
2097
 
        # forget what names there are
2098
 
        if self._new_pack is not None:
2099
 
            operation = cleanup.OperationWithCleanups(self._new_pack.abort)
2100
 
            operation.add_cleanup(setattr, self, '_new_pack', None)
2101
 
            # If we aborted while in the middle of finishing the write
2102
 
            # group, _remove_pack_indices could fail because the indexes are
2103
 
            # already gone.  But they're not there we shouldn't fail in this
2104
 
            # case, so we pass ignore_missing=True.
2105
 
            operation.add_cleanup(self._remove_pack_indices, self._new_pack,
2106
 
                ignore_missing=True)
2107
 
            operation.run_simple()
2108
 
        for resumed_pack in self._resumed_packs:
2109
 
            operation = cleanup.OperationWithCleanups(resumed_pack.abort)
2110
 
            # See comment in previous finally block.
2111
 
            operation.add_cleanup(self._remove_pack_indices, resumed_pack,
2112
 
                ignore_missing=True)
2113
 
            operation.run_simple()
2114
 
        del self._resumed_packs[:]
2115
 
 
2116
 
    def _remove_resumed_pack_indices(self):
2117
 
        for resumed_pack in self._resumed_packs:
2118
 
            self._remove_pack_indices(resumed_pack)
2119
 
        del self._resumed_packs[:]
2120
 
 
2121
 
    def _check_new_inventories(self):
2122
 
        """Detect missing inventories in this write group.
2123
 
 
2124
 
        :returns: list of strs, summarising any problems found.  If the list is
2125
 
            empty no problems were found.
2126
 
        """
2127
 
        # The base implementation does no checks.  GCRepositoryPackCollection
2128
 
        # overrides this.
2129
 
        return []
2130
 
        
2131
 
    def _commit_write_group(self):
2132
 
        all_missing = set()
2133
 
        for prefix, versioned_file in (
2134
 
                ('revisions', self.repo.revisions),
2135
 
                ('inventories', self.repo.inventories),
2136
 
                ('texts', self.repo.texts),
2137
 
                ('signatures', self.repo.signatures),
2138
 
                ):
2139
 
            missing = versioned_file.get_missing_compression_parent_keys()
2140
 
            all_missing.update([(prefix,) + key for key in missing])
2141
 
        if all_missing:
2142
 
            raise errors.BzrCheckError(
2143
 
                "Repository %s has missing compression parent(s) %r "
2144
 
                 % (self.repo, sorted(all_missing)))
2145
 
        problems = self._check_new_inventories()
2146
 
        if problems:
2147
 
            problems_summary = '\n'.join(problems)
2148
 
            raise errors.BzrCheckError(
2149
 
                "Cannot add revision(s) to repository: " + problems_summary)
2150
 
        self._remove_pack_indices(self._new_pack)
2151
 
        any_new_content = False
2152
 
        if self._new_pack.data_inserted():
2153
 
            # get all the data to disk and read to use
2154
 
            self._new_pack.finish()
2155
 
            self.allocate(self._new_pack)
2156
 
            self._new_pack = None
2157
 
            any_new_content = True
2158
 
        else:
2159
 
            self._new_pack.abort()
2160
 
            self._new_pack = None
2161
 
        for resumed_pack in self._resumed_packs:
2162
 
            # XXX: this is a pretty ugly way to turn the resumed pack into a
2163
 
            # properly committed pack.
2164
 
            self._names[resumed_pack.name] = None
2165
 
            self._remove_pack_from_memory(resumed_pack)
2166
 
            resumed_pack.finish()
2167
 
            self.allocate(resumed_pack)
2168
 
            any_new_content = True
2169
 
        del self._resumed_packs[:]
2170
 
        if any_new_content:
2171
 
            result = self.autopack()
2172
 
            if not result:
2173
 
                # when autopack takes no steps, the names list is still
2174
 
                # unsaved.
2175
 
                return self._save_pack_names()
2176
 
            return result
2177
 
        return []
2178
 
 
2179
 
    def _suspend_write_group(self):
2180
 
        tokens = [pack.name for pack in self._resumed_packs]
2181
 
        self._remove_pack_indices(self._new_pack)
2182
 
        if self._new_pack.data_inserted():
2183
 
            # get all the data to disk and read to use
2184
 
            self._new_pack.finish(suspend=True)
2185
 
            tokens.append(self._new_pack.name)
2186
 
            self._new_pack = None
2187
 
        else:
2188
 
            self._new_pack.abort()
2189
 
            self._new_pack = None
2190
 
        self._remove_resumed_pack_indices()
2191
 
        return tokens
2192
 
 
2193
 
    def _resume_write_group(self, tokens):
2194
 
        for token in tokens:
2195
 
            self._resume_pack(token)
2196
 
 
2197
 
 
2198
 
class KnitPackRepository(KnitRepository):
2199
 
    """Repository with knit objects stored inside pack containers.
2200
 
 
2201
 
    The layering for a KnitPackRepository is:
2202
 
 
2203
 
    Graph        |  HPSS    | Repository public layer |
2204
 
    ===================================================
2205
 
    Tuple based apis below, string based, and key based apis above
2206
 
    ---------------------------------------------------
2207
 
    KnitVersionedFiles
2208
 
      Provides .texts, .revisions etc
2209
 
      This adapts the N-tuple keys to physical knit records which only have a
2210
 
      single string identifier (for historical reasons), which in older formats
2211
 
      was always the revision_id, and in the mapped code for packs is always
2212
 
      the last element of key tuples.
2213
 
    ---------------------------------------------------
2214
 
    GraphIndex
2215
 
      A separate GraphIndex is used for each of the
2216
 
      texts/inventories/revisions/signatures contained within each individual
2217
 
      pack file. The GraphIndex layer works in N-tuples and is unaware of any
2218
 
      semantic value.
2219
 
    ===================================================
2220
 
 
2221
 
    """
2222
 
 
2223
 
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
2224
 
        _serializer):
2225
 
        KnitRepository.__init__(self, _format, a_bzrdir, control_files,
2226
 
            _commit_builder_class, _serializer)
2227
 
        index_transport = self._transport.clone('indices')
2228
 
        self._pack_collection = RepositoryPackCollection(self, self._transport,
2229
 
            index_transport,
2230
 
            self._transport.clone('upload'),
2231
 
            self._transport.clone('packs'),
2232
 
            _format.index_builder_class,
2233
 
            _format.index_class,
2234
 
            use_chk_index=self._format.supports_chks,
2235
 
            )
2236
 
        self.inventories = KnitVersionedFiles(
2237
 
            _KnitGraphIndex(self._pack_collection.inventory_index.combined_index,
2238
 
                add_callback=self._pack_collection.inventory_index.add_callback,
2239
 
                deltas=True, parents=True, is_locked=self.is_locked),
2240
 
            data_access=self._pack_collection.inventory_index.data_access,
2241
 
            max_delta_chain=200)
2242
 
        self.revisions = KnitVersionedFiles(
2243
 
            _KnitGraphIndex(self._pack_collection.revision_index.combined_index,
2244
 
                add_callback=self._pack_collection.revision_index.add_callback,
2245
 
                deltas=False, parents=True, is_locked=self.is_locked,
2246
 
                track_external_parent_refs=True),
2247
 
            data_access=self._pack_collection.revision_index.data_access,
2248
 
            max_delta_chain=0)
2249
 
        self.signatures = KnitVersionedFiles(
2250
 
            _KnitGraphIndex(self._pack_collection.signature_index.combined_index,
2251
 
                add_callback=self._pack_collection.signature_index.add_callback,
2252
 
                deltas=False, parents=False, is_locked=self.is_locked),
2253
 
            data_access=self._pack_collection.signature_index.data_access,
2254
 
            max_delta_chain=0)
2255
 
        self.texts = KnitVersionedFiles(
2256
 
            _KnitGraphIndex(self._pack_collection.text_index.combined_index,
2257
 
                add_callback=self._pack_collection.text_index.add_callback,
2258
 
                deltas=True, parents=True, is_locked=self.is_locked),
2259
 
            data_access=self._pack_collection.text_index.data_access,
2260
 
            max_delta_chain=200)
2261
 
        if _format.supports_chks:
2262
 
            # No graph, no compression:- references from chks are between
2263
 
            # different objects not temporal versions of the same; and without
2264
 
            # some sort of temporal structure knit compression will just fail.
2265
 
            self.chk_bytes = KnitVersionedFiles(
2266
 
                _KnitGraphIndex(self._pack_collection.chk_index.combined_index,
2267
 
                    add_callback=self._pack_collection.chk_index.add_callback,
2268
 
                    deltas=False, parents=False, is_locked=self.is_locked),
2269
 
                data_access=self._pack_collection.chk_index.data_access,
2270
 
                max_delta_chain=0)
2271
 
        else:
2272
 
            self.chk_bytes = None
2273
 
        # True when the repository object is 'write locked' (as opposed to the
2274
 
        # physical lock only taken out around changes to the pack-names list.)
2275
 
        # Another way to represent this would be a decorator around the control
2276
 
        # files object that presents logical locks as physical ones - if this
2277
 
        # gets ugly consider that alternative design. RBC 20071011
2278
 
        self._write_lock_count = 0
2279
 
        self._transaction = None
2280
 
        # for tests
2281
 
        self._reconcile_does_inventory_gc = True
2282
 
        self._reconcile_fixes_text_parents = True
2283
 
        self._reconcile_backsup_inventory = False
2284
 
 
2285
 
    def _warn_if_deprecated(self, branch=None):
2286
 
        # This class isn't deprecated, but one sub-format is
2287
 
        if isinstance(self._format, RepositoryFormatKnitPack5RichRootBroken):
2288
 
            super(KnitPackRepository, self)._warn_if_deprecated(branch)
2289
 
 
2290
 
    def _abort_write_group(self):
2291
 
        self.revisions._index._key_dependencies.clear()
2292
 
        self._pack_collection._abort_write_group()
2293
 
 
2294
 
    def _get_source(self, to_format):
2295
 
        if to_format.network_name() == self._format.network_name():
2296
 
            return KnitPackStreamSource(self, to_format)
2297
 
        return super(KnitPackRepository, self)._get_source(to_format)
2298
 
 
2299
 
    def _make_parents_provider(self):
2300
 
        return graph.CachingParentsProvider(self)
2301
 
 
2302
 
    def _refresh_data(self):
2303
 
        if not self.is_locked():
2304
 
            return
2305
 
        self._pack_collection.reload_pack_names()
2306
 
 
2307
 
    def _start_write_group(self):
2308
 
        self._pack_collection._start_write_group()
2309
 
 
2310
 
    def _commit_write_group(self):
2311
 
        hint = self._pack_collection._commit_write_group()
2312
 
        self.revisions._index._key_dependencies.clear()
2313
 
        return hint
2314
 
 
2315
 
    def suspend_write_group(self):
2316
 
        # XXX check self._write_group is self.get_transaction()?
2317
 
        tokens = self._pack_collection._suspend_write_group()
2318
 
        self.revisions._index._key_dependencies.clear()
2319
 
        self._write_group = None
2320
 
        return tokens
2321
 
 
2322
 
    def _resume_write_group(self, tokens):
2323
 
        self._start_write_group()
2324
 
        try:
2325
 
            self._pack_collection._resume_write_group(tokens)
2326
 
        except errors.UnresumableWriteGroup:
2327
 
            self._abort_write_group()
2328
 
            raise
2329
 
        for pack in self._pack_collection._resumed_packs:
2330
 
            self.revisions._index.scan_unvalidated_index(pack.revision_index)
2331
 
 
2332
 
    def get_transaction(self):
2333
 
        if self._write_lock_count:
2334
 
            return self._transaction
2335
 
        else:
2336
 
            return self.control_files.get_transaction()
2337
 
 
2338
 
    def is_locked(self):
2339
 
        return self._write_lock_count or self.control_files.is_locked()
2340
 
 
2341
 
    def is_write_locked(self):
2342
 
        return self._write_lock_count
2343
 
 
2344
 
    def lock_write(self, token=None):
2345
 
        """Lock the repository for writes.
2346
 
 
2347
 
        :return: A bzrlib.repository.RepositoryWriteLockResult.
2348
 
        """
2349
 
        locked = self.is_locked()
2350
 
        if not self._write_lock_count and locked:
2351
 
            raise errors.ReadOnlyError(self)
2352
 
        self._write_lock_count += 1
2353
 
        if self._write_lock_count == 1:
2354
 
            self._transaction = transactions.WriteTransaction()
2355
 
        if not locked:
2356
 
            if 'relock' in debug.debug_flags and self._prev_lock == 'w':
2357
 
                note('%r was write locked again', self)
2358
 
            self._prev_lock = 'w'
2359
 
            for repo in self._fallback_repositories:
2360
 
                # Writes don't affect fallback repos
2361
 
                repo.lock_read()
2362
 
            self._refresh_data()
2363
 
        return RepositoryWriteLockResult(self.unlock, None)
2364
 
 
2365
 
    def lock_read(self):
2366
 
        """Lock the repository for reads.
2367
 
 
2368
 
        :return: A bzrlib.lock.LogicalLockResult.
2369
 
        """
2370
 
        locked = self.is_locked()
2371
 
        if self._write_lock_count:
2372
 
            self._write_lock_count += 1
2373
 
        else:
2374
 
            self.control_files.lock_read()
2375
 
        if not locked:
2376
 
            if 'relock' in debug.debug_flags and self._prev_lock == 'r':
2377
 
                note('%r was read locked again', self)
2378
 
            self._prev_lock = 'r'
2379
 
            for repo in self._fallback_repositories:
2380
 
                repo.lock_read()
2381
 
            self._refresh_data()
2382
 
        return LogicalLockResult(self.unlock)
2383
 
 
2384
 
    def leave_lock_in_place(self):
2385
 
        # not supported - raise an error
2386
 
        raise NotImplementedError(self.leave_lock_in_place)
2387
 
 
2388
 
    def dont_leave_lock_in_place(self):
2389
 
        # not supported - raise an error
2390
 
        raise NotImplementedError(self.dont_leave_lock_in_place)
2391
 
 
2392
 
    @needs_write_lock
2393
 
    def pack(self, hint=None, clean_obsolete_packs=False):
2394
 
        """Compress the data within the repository.
2395
 
 
2396
 
        This will pack all the data to a single pack. In future it may
2397
 
        recompress deltas or do other such expensive operations.
2398
 
        """
2399
 
        self._pack_collection.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
2400
 
 
2401
 
    @needs_write_lock
2402
 
    def reconcile(self, other=None, thorough=False):
2403
 
        """Reconcile this repository."""
2404
 
        from bzrlib.reconcile import PackReconciler
2405
 
        reconciler = PackReconciler(self, thorough=thorough)
2406
 
        reconciler.reconcile()
2407
 
        return reconciler
2408
 
 
2409
 
    def _reconcile_pack(self, collection, packs, extension, revs, pb):
2410
 
        packer = ReconcilePacker(collection, packs, extension, revs)
2411
 
        return packer.pack(pb)
2412
 
 
2413
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2414
 
    def unlock(self):
2415
 
        if self._write_lock_count == 1 and self._write_group is not None:
2416
 
            self.abort_write_group()
2417
 
            self._transaction = None
2418
 
            self._write_lock_count = 0
2419
 
            raise errors.BzrError(
2420
 
                'Must end write group before releasing write lock on %s'
2421
 
                % self)
2422
 
        if self._write_lock_count:
2423
 
            self._write_lock_count -= 1
2424
 
            if not self._write_lock_count:
2425
 
                transaction = self._transaction
2426
 
                self._transaction = None
2427
 
                transaction.finish()
2428
 
        else:
2429
 
            self.control_files.unlock()
2430
 
 
2431
 
        if not self.is_locked():
2432
 
            for repo in self._fallback_repositories:
2433
 
                repo.unlock()
2434
 
 
2435
 
 
2436
 
class KnitPackStreamSource(StreamSource):
2437
 
    """A StreamSource used to transfer data between same-format KnitPack repos.
2438
 
 
2439
 
    This source assumes:
2440
 
        1) Same serialization format for all objects
2441
 
        2) Same root information
2442
 
        3) XML format inventories
2443
 
        4) Atomic inserts (so we can stream inventory texts before text
2444
 
           content)
2445
 
        5) No chk_bytes
2446
 
    """
2447
 
 
2448
 
    def __init__(self, from_repository, to_format):
2449
 
        super(KnitPackStreamSource, self).__init__(from_repository, to_format)
2450
 
        self._text_keys = None
2451
 
        self._text_fetch_order = 'unordered'
2452
 
 
2453
 
    def _get_filtered_inv_stream(self, revision_ids):
2454
 
        from_repo = self.from_repository
2455
 
        parent_ids = from_repo._find_parent_ids_of_revisions(revision_ids)
2456
 
        parent_keys = [(p,) for p in parent_ids]
2457
 
        find_text_keys = from_repo._find_text_key_references_from_xml_inventory_lines
2458
 
        parent_text_keys = set(find_text_keys(
2459
 
            from_repo._inventory_xml_lines_for_keys(parent_keys)))
2460
 
        content_text_keys = set()
2461
 
        knit = KnitVersionedFiles(None, None)
2462
 
        factory = KnitPlainFactory()
2463
 
        def find_text_keys_from_content(record):
2464
 
            if record.storage_kind not in ('knit-delta-gz', 'knit-ft-gz'):
2465
 
                raise ValueError("Unknown content storage kind for"
2466
 
                    " inventory text: %s" % (record.storage_kind,))
2467
 
            # It's a knit record, it has a _raw_record field (even if it was
2468
 
            # reconstituted from a network stream).
2469
 
            raw_data = record._raw_record
2470
 
            # read the entire thing
2471
 
            revision_id = record.key[-1]
2472
 
            content, _ = knit._parse_record(revision_id, raw_data)
2473
 
            if record.storage_kind == 'knit-delta-gz':
2474
 
                line_iterator = factory.get_linedelta_content(content)
2475
 
            elif record.storage_kind == 'knit-ft-gz':
2476
 
                line_iterator = factory.get_fulltext_content(content)
2477
 
            content_text_keys.update(find_text_keys(
2478
 
                [(line, revision_id) for line in line_iterator]))
2479
 
        revision_keys = [(r,) for r in revision_ids]
2480
 
        def _filtered_inv_stream():
2481
 
            source_vf = from_repo.inventories
2482
 
            stream = source_vf.get_record_stream(revision_keys,
2483
 
                                                 'unordered', False)
2484
 
            for record in stream:
2485
 
                if record.storage_kind == 'absent':
2486
 
                    raise errors.NoSuchRevision(from_repo, record.key)
2487
 
                find_text_keys_from_content(record)
2488
 
                yield record
2489
 
            self._text_keys = content_text_keys - parent_text_keys
2490
 
        return ('inventories', _filtered_inv_stream())
2491
 
 
2492
 
    def _get_text_stream(self):
2493
 
        # Note: We know we don't have to handle adding root keys, because both
2494
 
        # the source and target are the identical network name.
2495
 
        text_stream = self.from_repository.texts.get_record_stream(
2496
 
                        self._text_keys, self._text_fetch_order, False)
2497
 
        return ('texts', text_stream)
2498
 
 
2499
 
    def get_stream(self, search):
2500
 
        revision_ids = search.get_keys()
2501
 
        for stream_info in self._fetch_revision_texts(revision_ids):
2502
 
            yield stream_info
2503
 
        self._revision_keys = [(rev_id,) for rev_id in revision_ids]
2504
 
        yield self._get_filtered_inv_stream(revision_ids)
2505
 
        yield self._get_text_stream()
2506
 
 
2507
 
 
2508
 
 
2509
 
class RepositoryFormatPack(MetaDirRepositoryFormat):
2510
 
    """Format logic for pack structured repositories.
2511
 
 
2512
 
    This repository format has:
2513
 
     - a list of packs in pack-names
2514
 
     - packs in packs/NAME.pack
2515
 
     - indices in indices/NAME.{iix,six,tix,rix}
2516
 
     - knit deltas in the packs, knit indices mapped to the indices.
2517
 
     - thunk objects to support the knits programming API.
2518
 
     - a format marker of its own
2519
 
     - an optional 'shared-storage' flag
2520
 
     - an optional 'no-working-trees' flag
2521
 
     - a LockDir lock
2522
 
    """
2523
 
 
2524
 
    # Set this attribute in derived classes to control the repository class
2525
 
    # created by open and initialize.
2526
 
    repository_class = None
2527
 
    # Set this attribute in derived classes to control the
2528
 
    # _commit_builder_class that the repository objects will have passed to
2529
 
    # their constructor.
2530
 
    _commit_builder_class = None
2531
 
    # Set this attribute in derived clases to control the _serializer that the
2532
 
    # repository objects will have passed to their constructor.
2533
 
    _serializer = None
2534
 
    # Packs are not confused by ghosts.
2535
 
    supports_ghosts = True
2536
 
    # External references are not supported in pack repositories yet.
2537
 
    supports_external_lookups = False
2538
 
    # Most pack formats do not use chk lookups.
2539
 
    supports_chks = False
2540
 
    # What index classes to use
2541
 
    index_builder_class = None
2542
 
    index_class = None
2543
 
    _fetch_uses_deltas = True
2544
 
    fast_deltas = False
2545
 
 
2546
 
    def initialize(self, a_bzrdir, shared=False):
2547
 
        """Create a pack based repository.
2548
 
 
2549
 
        :param a_bzrdir: bzrdir to contain the new repository; must already
2550
 
            be initialized.
2551
 
        :param shared: If true the repository will be initialized as a shared
2552
 
                       repository.
2553
 
        """
2554
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
2555
 
        dirs = ['indices', 'obsolete_packs', 'packs', 'upload']
2556
 
        builder = self.index_builder_class()
2557
 
        files = [('pack-names', builder.finish())]
2558
 
        utf8_files = [('format', self.get_format_string())]
2559
 
 
2560
 
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
2561
 
        repository = self.open(a_bzrdir=a_bzrdir, _found=True)
2562
 
        self._run_post_repo_init_hooks(repository, a_bzrdir, shared)
2563
 
        return repository
2564
 
 
2565
 
    def open(self, a_bzrdir, _found=False, _override_transport=None):
2566
 
        """See RepositoryFormat.open().
2567
 
 
2568
 
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
2569
 
                                    repository at a slightly different url
2570
 
                                    than normal. I.e. during 'upgrade'.
2571
 
        """
2572
 
        if not _found:
2573
 
            format = RepositoryFormat.find_format(a_bzrdir)
2574
 
        if _override_transport is not None:
2575
 
            repo_transport = _override_transport
2576
 
        else:
2577
 
            repo_transport = a_bzrdir.get_repository_transport(None)
2578
 
        control_files = lockable_files.LockableFiles(repo_transport,
2579
 
                                'lock', lockdir.LockDir)
2580
 
        return self.repository_class(_format=self,
2581
 
                              a_bzrdir=a_bzrdir,
2582
 
                              control_files=control_files,
2583
 
                              _commit_builder_class=self._commit_builder_class,
2584
 
                              _serializer=self._serializer)
2585
 
 
2586
 
 
2587
 
class RepositoryFormatKnitPack1(RepositoryFormatPack):
2588
 
    """A no-subtrees parameterized Pack repository.
2589
 
 
2590
 
    This format was introduced in 0.92.
2591
 
    """
2592
 
 
2593
 
    repository_class = KnitPackRepository
2594
 
    _commit_builder_class = PackCommitBuilder
2595
 
    @property
2596
 
    def _serializer(self):
2597
 
        return xml5.serializer_v5
2598
 
    # What index classes to use
2599
 
    index_builder_class = InMemoryGraphIndex
2600
 
    index_class = GraphIndex
2601
 
 
2602
 
    def _get_matching_bzrdir(self):
2603
 
        return bzrdir.format_registry.make_bzrdir('pack-0.92')
2604
 
 
2605
 
    def _ignore_setting_bzrdir(self, format):
2606
 
        pass
2607
 
 
2608
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2609
 
 
2610
 
    def get_format_string(self):
2611
 
        """See RepositoryFormat.get_format_string()."""
2612
 
        return "Bazaar pack repository format 1 (needs bzr 0.92)\n"
2613
 
 
2614
 
    def get_format_description(self):
2615
 
        """See RepositoryFormat.get_format_description()."""
2616
 
        return "Packs containing knits without subtree support"
2617
 
 
2618
 
 
2619
 
class RepositoryFormatKnitPack3(RepositoryFormatPack):
2620
 
    """A subtrees parameterized Pack repository.
2621
 
 
2622
 
    This repository format uses the xml7 serializer to get:
2623
 
     - support for recording full info about the tree root
2624
 
     - support for recording tree-references
2625
 
 
2626
 
    This format was introduced in 0.92.
2627
 
    """
2628
 
 
2629
 
    repository_class = KnitPackRepository
2630
 
    _commit_builder_class = PackRootCommitBuilder
2631
 
    rich_root_data = True
2632
 
    experimental = True
2633
 
    supports_tree_reference = True
2634
 
    @property
2635
 
    def _serializer(self):
2636
 
        return xml7.serializer_v7
2637
 
    # What index classes to use
2638
 
    index_builder_class = InMemoryGraphIndex
2639
 
    index_class = GraphIndex
2640
 
 
2641
 
    def _get_matching_bzrdir(self):
2642
 
        return bzrdir.format_registry.make_bzrdir(
2643
 
            'pack-0.92-subtree')
2644
 
 
2645
 
    def _ignore_setting_bzrdir(self, format):
2646
 
        pass
2647
 
 
2648
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2649
 
 
2650
 
    def get_format_string(self):
2651
 
        """See RepositoryFormat.get_format_string()."""
2652
 
        return "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n"
2653
 
 
2654
 
    def get_format_description(self):
2655
 
        """See RepositoryFormat.get_format_description()."""
2656
 
        return "Packs containing knits with subtree support\n"
2657
 
 
2658
 
 
2659
 
class RepositoryFormatKnitPack4(RepositoryFormatPack):
2660
 
    """A rich-root, no subtrees parameterized Pack repository.
2661
 
 
2662
 
    This repository format uses the xml6 serializer to get:
2663
 
     - support for recording full info about the tree root
2664
 
 
2665
 
    This format was introduced in 1.0.
2666
 
    """
2667
 
 
2668
 
    repository_class = KnitPackRepository
2669
 
    _commit_builder_class = PackRootCommitBuilder
2670
 
    rich_root_data = True
2671
 
    supports_tree_reference = False
2672
 
    @property
2673
 
    def _serializer(self):
2674
 
        return xml6.serializer_v6
2675
 
    # What index classes to use
2676
 
    index_builder_class = InMemoryGraphIndex
2677
 
    index_class = GraphIndex
2678
 
 
2679
 
    def _get_matching_bzrdir(self):
2680
 
        return bzrdir.format_registry.make_bzrdir(
2681
 
            'rich-root-pack')
2682
 
 
2683
 
    def _ignore_setting_bzrdir(self, format):
2684
 
        pass
2685
 
 
2686
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2687
 
 
2688
 
    def get_format_string(self):
2689
 
        """See RepositoryFormat.get_format_string()."""
2690
 
        return ("Bazaar pack repository format 1 with rich root"
2691
 
                " (needs bzr 1.0)\n")
2692
 
 
2693
 
    def get_format_description(self):
2694
 
        """See RepositoryFormat.get_format_description()."""
2695
 
        return "Packs containing knits with rich root support\n"
2696
 
 
2697
 
 
2698
 
class RepositoryFormatKnitPack5(RepositoryFormatPack):
2699
 
    """Repository that supports external references to allow stacking.
2700
 
 
2701
 
    New in release 1.6.
2702
 
 
2703
 
    Supports external lookups, which results in non-truncated ghosts after
2704
 
    reconcile compared to pack-0.92 formats.
2705
 
    """
2706
 
 
2707
 
    repository_class = KnitPackRepository
2708
 
    _commit_builder_class = PackCommitBuilder
2709
 
    supports_external_lookups = True
2710
 
    # What index classes to use
2711
 
    index_builder_class = InMemoryGraphIndex
2712
 
    index_class = GraphIndex
2713
 
 
2714
 
    @property
2715
 
    def _serializer(self):
2716
 
        return xml5.serializer_v5
2717
 
 
2718
 
    def _get_matching_bzrdir(self):
2719
 
        return bzrdir.format_registry.make_bzrdir('1.6')
2720
 
 
2721
 
    def _ignore_setting_bzrdir(self, format):
2722
 
        pass
2723
 
 
2724
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2725
 
 
2726
 
    def get_format_string(self):
2727
 
        """See RepositoryFormat.get_format_string()."""
2728
 
        return "Bazaar RepositoryFormatKnitPack5 (bzr 1.6)\n"
2729
 
 
2730
 
    def get_format_description(self):
2731
 
        """See RepositoryFormat.get_format_description()."""
2732
 
        return "Packs 5 (adds stacking support, requires bzr 1.6)"
2733
 
 
2734
 
 
2735
 
class RepositoryFormatKnitPack5RichRoot(RepositoryFormatPack):
2736
 
    """A repository with rich roots and stacking.
2737
 
 
2738
 
    New in release 1.6.1.
2739
 
 
2740
 
    Supports stacking on other repositories, allowing data to be accessed
2741
 
    without being stored locally.
2742
 
    """
2743
 
 
2744
 
    repository_class = KnitPackRepository
2745
 
    _commit_builder_class = PackRootCommitBuilder
2746
 
    rich_root_data = True
2747
 
    supports_tree_reference = False # no subtrees
2748
 
    supports_external_lookups = True
2749
 
    # What index classes to use
2750
 
    index_builder_class = InMemoryGraphIndex
2751
 
    index_class = GraphIndex
2752
 
 
2753
 
    @property
2754
 
    def _serializer(self):
2755
 
        return xml6.serializer_v6
2756
 
 
2757
 
    def _get_matching_bzrdir(self):
2758
 
        return bzrdir.format_registry.make_bzrdir(
2759
 
            '1.6.1-rich-root')
2760
 
 
2761
 
    def _ignore_setting_bzrdir(self, format):
2762
 
        pass
2763
 
 
2764
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2765
 
 
2766
 
    def get_format_string(self):
2767
 
        """See RepositoryFormat.get_format_string()."""
2768
 
        return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n"
2769
 
 
2770
 
    def get_format_description(self):
2771
 
        return "Packs 5 rich-root (adds stacking support, requires bzr 1.6.1)"
2772
 
 
2773
 
 
2774
 
class RepositoryFormatKnitPack5RichRootBroken(RepositoryFormatPack):
2775
 
    """A repository with rich roots and external references.
2776
 
 
2777
 
    New in release 1.6.
2778
 
 
2779
 
    Supports external lookups, which results in non-truncated ghosts after
2780
 
    reconcile compared to pack-0.92 formats.
2781
 
 
2782
 
    This format was deprecated because the serializer it uses accidentally
2783
 
    supported subtrees, when the format was not intended to. This meant that
2784
 
    someone could accidentally fetch from an incorrect repository.
2785
 
    """
2786
 
 
2787
 
    repository_class = KnitPackRepository
2788
 
    _commit_builder_class = PackRootCommitBuilder
2789
 
    rich_root_data = True
2790
 
    supports_tree_reference = False # no subtrees
2791
 
 
2792
 
    supports_external_lookups = True
2793
 
    # What index classes to use
2794
 
    index_builder_class = InMemoryGraphIndex
2795
 
    index_class = GraphIndex
2796
 
 
2797
 
    @property
2798
 
    def _serializer(self):
2799
 
        return xml7.serializer_v7
2800
 
 
2801
 
    def _get_matching_bzrdir(self):
2802
 
        matching = bzrdir.format_registry.make_bzrdir(
2803
 
            '1.6.1-rich-root')
2804
 
        matching.repository_format = self
2805
 
        return matching
2806
 
 
2807
 
    def _ignore_setting_bzrdir(self, format):
2808
 
        pass
2809
 
 
2810
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2811
 
 
2812
 
    def get_format_string(self):
2813
 
        """See RepositoryFormat.get_format_string()."""
2814
 
        return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n"
2815
 
 
2816
 
    def get_format_description(self):
2817
 
        return ("Packs 5 rich-root (adds stacking support, requires bzr 1.6)"
2818
 
                " (deprecated)")
2819
 
 
2820
 
 
2821
 
class RepositoryFormatKnitPack6(RepositoryFormatPack):
2822
 
    """A repository with stacking and btree indexes,
2823
 
    without rich roots or subtrees.
2824
 
 
2825
 
    This is equivalent to pack-1.6 with B+Tree indices.
2826
 
    """
2827
 
 
2828
 
    repository_class = KnitPackRepository
2829
 
    _commit_builder_class = PackCommitBuilder
2830
 
    supports_external_lookups = True
2831
 
    # What index classes to use
2832
 
    index_builder_class = BTreeBuilder
2833
 
    index_class = BTreeGraphIndex
2834
 
 
2835
 
    @property
2836
 
    def _serializer(self):
2837
 
        return xml5.serializer_v5
2838
 
 
2839
 
    def _get_matching_bzrdir(self):
2840
 
        return bzrdir.format_registry.make_bzrdir('1.9')
2841
 
 
2842
 
    def _ignore_setting_bzrdir(self, format):
2843
 
        pass
2844
 
 
2845
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2846
 
 
2847
 
    def get_format_string(self):
2848
 
        """See RepositoryFormat.get_format_string()."""
2849
 
        return "Bazaar RepositoryFormatKnitPack6 (bzr 1.9)\n"
2850
 
 
2851
 
    def get_format_description(self):
2852
 
        """See RepositoryFormat.get_format_description()."""
2853
 
        return "Packs 6 (uses btree indexes, requires bzr 1.9)"
2854
 
 
2855
 
 
2856
 
class RepositoryFormatKnitPack6RichRoot(RepositoryFormatPack):
2857
 
    """A repository with rich roots, no subtrees, stacking and btree indexes.
2858
 
 
2859
 
    1.6-rich-root with B+Tree indices.
2860
 
    """
2861
 
 
2862
 
    repository_class = KnitPackRepository
2863
 
    _commit_builder_class = PackRootCommitBuilder
2864
 
    rich_root_data = True
2865
 
    supports_tree_reference = False # no subtrees
2866
 
    supports_external_lookups = True
2867
 
    # What index classes to use
2868
 
    index_builder_class = BTreeBuilder
2869
 
    index_class = BTreeGraphIndex
2870
 
 
2871
 
    @property
2872
 
    def _serializer(self):
2873
 
        return xml6.serializer_v6
2874
 
 
2875
 
    def _get_matching_bzrdir(self):
2876
 
        return bzrdir.format_registry.make_bzrdir(
2877
 
            '1.9-rich-root')
2878
 
 
2879
 
    def _ignore_setting_bzrdir(self, format):
2880
 
        pass
2881
 
 
2882
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2883
 
 
2884
 
    def get_format_string(self):
2885
 
        """See RepositoryFormat.get_format_string()."""
2886
 
        return "Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n"
2887
 
 
2888
 
    def get_format_description(self):
2889
 
        return "Packs 6 rich-root (uses btree indexes, requires bzr 1.9)"
2890
 
 
2891
 
 
2892
 
class RepositoryFormatPackDevelopment2Subtree(RepositoryFormatPack):
2893
 
    """A subtrees development repository.
2894
 
 
2895
 
    This format should be retained until the second release after bzr 1.7.
2896
 
 
2897
 
    1.6.1-subtree[as it might have been] with B+Tree indices.
2898
 
 
2899
 
    This is [now] retained until we have a CHK based subtree format in
2900
 
    development.
2901
 
    """
2902
 
 
2903
 
    repository_class = KnitPackRepository
2904
 
    _commit_builder_class = PackRootCommitBuilder
2905
 
    rich_root_data = True
2906
 
    experimental = True
2907
 
    supports_tree_reference = True
2908
 
    supports_external_lookups = True
2909
 
    # What index classes to use
2910
 
    index_builder_class = BTreeBuilder
2911
 
    index_class = BTreeGraphIndex
2912
 
 
2913
 
    @property
2914
 
    def _serializer(self):
2915
 
        return xml7.serializer_v7
2916
 
 
2917
 
    def _get_matching_bzrdir(self):
2918
 
        return bzrdir.format_registry.make_bzrdir(
2919
 
            'development-subtree')
2920
 
 
2921
 
    def _ignore_setting_bzrdir(self, format):
2922
 
        pass
2923
 
 
2924
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2925
 
 
2926
 
    def get_format_string(self):
2927
 
        """See RepositoryFormat.get_format_string()."""
2928
 
        return ("Bazaar development format 2 with subtree support "
2929
 
            "(needs bzr.dev from before 1.8)\n")
2930
 
 
2931
 
    def get_format_description(self):
2932
 
        """See RepositoryFormat.get_format_description()."""
2933
 
        return ("Development repository format, currently the same as "
2934
 
            "1.6.1-subtree with B+Tree indices.\n")
2935