← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/reconcile.py

  • Committer: Martin Pool
  • Date: 2007-10-24 02:33:14 UTC
  • mto: This revision was merged to the branch mainline in revision 2933.
  • Revision ID: mbp@sourcefrog.net-20071024023314-l9mscm8wsb1bvj1f
typo

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/reconcile.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Reconcilers are able to fix some potential data errors in a branch."""
18
18
 
27
27
 
28
28
 
29
29
from bzrlib import (
30
 
    cleanup,
31
30
    errors,
32
31
    ui,
 
32
    repository,
33
33
    )
34
 
from bzrlib.trace import mutter
35
 
from bzrlib.tsort import topo_sort
36
 
from bzrlib.versionedfile import AdapterFactory, FulltextContentFactory
 
34
from bzrlib.trace import mutter, note
 
35
from bzrlib.tsort import TopoSorter
37
36
 
38
37
 
39
38
def reconcile(dir, other=None):
61
60
 
62
61
    def reconcile(self):
63
62
        """Perform reconciliation.
64
 
 
 
63
        
65
64
        After reconciliation the following attributes document found issues:
66
65
        inconsistent_parents: The number of revisions in the repository whose
67
66
                              ancestry was being reported incorrectly.
68
67
        garbage_inventories: The number of inventory objects without revisions
69
68
                             that were garbage collected.
70
 
        fixed_branch_history: None if there was no branch, False if the branch
71
 
                              history was correct, True if the branch history
72
 
                              needed to be re-normalized.
73
69
        """
74
70
        self.pb = ui.ui_factory.nested_progress_bar()
75
71
        try:
79
75
 
80
76
    def _reconcile(self):
81
77
        """Helper function for performing reconciliation."""
82
 
        self._reconcile_branch()
83
 
        self._reconcile_repository()
84
 
 
85
 
    def _reconcile_branch(self):
86
 
        try:
87
 
            self.branch = self.bzrdir.open_branch()
88
 
        except errors.NotBranchError:
89
 
            # Nothing to check here
90
 
            self.fixed_branch_history = None
91
 
            return
92
 
        ui.ui_factory.note('Reconciling branch %s' % self.branch.base)
93
 
        branch_reconciler = self.branch.reconcile(thorough=True)
94
 
        self.fixed_branch_history = branch_reconciler.fixed_history
95
 
 
96
 
    def _reconcile_repository(self):
97
78
        self.repo = self.bzrdir.find_repository()
98
 
        ui.ui_factory.note('Reconciling repository %s' %
99
 
            self.repo.user_url)
100
 
        self.pb.update("Reconciling repository", 0, 1)
 
79
        self.pb.note('Reconciling repository %s',
 
80
                     self.repo.bzrdir.root_transport.base)
101
81
        repo_reconciler = self.repo.reconcile(thorough=True)
102
82
        self.inconsistent_parents = repo_reconciler.inconsistent_parents
103
83
        self.garbage_inventories = repo_reconciler.garbage_inventories
104
84
        if repo_reconciler.aborted:
105
 
            ui.ui_factory.note(
 
85
            self.pb.note(
106
86
                'Reconcile aborted: revision index has inconsistent parents.')
107
 
            ui.ui_factory.note(
 
87
            self.pb.note(
108
88
                'Run "bzr check" for more details.')
109
89
        else:
110
 
            ui.ui_factory.note('Reconciliation complete.')
111
 
 
112
 
 
113
 
class BranchReconciler(object):
114
 
    """Reconciler that works on a branch."""
115
 
 
116
 
    def __init__(self, a_branch, thorough=False):
117
 
        self.fixed_history = None
118
 
        self.thorough = thorough
119
 
        self.branch = a_branch
120
 
 
121
 
    def reconcile(self):
122
 
        operation = cleanup.OperationWithCleanups(self._reconcile)
123
 
        self.add_cleanup = operation.add_cleanup
124
 
        operation.run_simple()
125
 
 
126
 
    def _reconcile(self):
127
 
        self.branch.lock_write()
128
 
        self.add_cleanup(self.branch.unlock)
129
 
        self.pb = ui.ui_factory.nested_progress_bar()
130
 
        self.add_cleanup(self.pb.finished)
131
 
        self._reconcile_steps()
132
 
 
133
 
    def _reconcile_steps(self):
134
 
        self._reconcile_revision_history()
135
 
 
136
 
    def _reconcile_revision_history(self):
137
 
        repo = self.branch.repository
138
 
        last_revno, last_revision_id = self.branch.last_revision_info()
139
 
        real_history = []
140
 
        try:
141
 
            for revid in repo.iter_reverse_revision_history(
142
 
                    last_revision_id):
143
 
                real_history.append(revid)
144
 
        except errors.RevisionNotPresent:
145
 
            pass # Hit a ghost left hand parent
146
 
        real_history.reverse()
147
 
        if last_revno != len(real_history):
148
 
            self.fixed_history = True
149
 
            # Technically for Branch5 formats, it is more efficient to use
150
 
            # set_revision_history, as this will regenerate it again.
151
 
            # Not really worth a whole BranchReconciler class just for this,
152
 
            # though.
153
 
            ui.ui_factory.note('Fixing last revision info %s => %s' % (
154
 
                 last_revno, len(real_history)))
155
 
            self.branch.set_last_revision_info(len(real_history),
156
 
                                               last_revision_id)
157
 
        else:
158
 
            self.fixed_history = False
159
 
            ui.ui_factory.note('revision_history ok.')
 
90
            self.pb.note('Reconciliation complete.')
160
91
 
161
92
 
162
93
class RepoReconciler(object):
163
94
    """Reconciler that reconciles a repository.
164
95
 
165
96
    The goal of repository reconciliation is to make any derived data
166
 
    consistent with the core data committed by a user. This can involve
 
97
    consistent with the core data committed by a user. This can involve 
167
98
    reindexing, or removing unreferenced data if that can interfere with
168
99
    queries in a given repository.
169
100
 
185
116
 
186
117
    def reconcile(self):
187
118
        """Perform reconciliation.
188
 
 
 
119
        
189
120
        After reconciliation the following attributes document found issues:
190
121
        inconsistent_parents: The number of revisions in the repository whose
191
122
                              ancestry was being reported incorrectly.
192
123
        garbage_inventories: The number of inventory objects without revisions
193
124
                             that were garbage collected.
194
125
        """
195
 
        operation = cleanup.OperationWithCleanups(self._reconcile)
196
 
        self.add_cleanup = operation.add_cleanup
197
 
        operation.run_simple()
198
 
 
199
 
    def _reconcile(self):
200
126
        self.repo.lock_write()
201
 
        self.add_cleanup(self.repo.unlock)
202
 
        self.pb = ui.ui_factory.nested_progress_bar()
203
 
        self.add_cleanup(self.pb.finished)
204
 
        self._reconcile_steps()
 
127
        try:
 
128
            self.pb = ui.ui_factory.nested_progress_bar()
 
129
            try:
 
130
                self._reconcile_steps()
 
131
            finally:
 
132
                self.pb.finished()
 
133
        finally:
 
134
            self.repo.unlock()
205
135
 
206
136
    def _reconcile_steps(self):
207
137
        """Perform the steps to reconcile this repository."""
209
139
 
210
140
    def _reweave_inventory(self):
211
141
        """Regenerate the inventory weave for the repository from scratch.
212
 
 
213
 
        This is a smart function: it will only do the reweave if doing it
 
142
        
 
143
        This is a smart function: it will only do the reweave if doing it 
214
144
        will correct data issues. The self.thorough flag controls whether
215
145
        only data-loss causing issues (!self.thorough) or all issues
216
146
        (self.thorough) are treated as requiring the reweave.
218
148
        # local because needing to know about WeaveFile is a wart we want to hide
219
149
        from bzrlib.weave import WeaveFile, Weave
220
150
        transaction = self.repo.get_transaction()
221
 
        self.pb.update('Reading inventory data')
222
 
        self.inventory = self.repo.inventories
223
 
        self.revisions = self.repo.revisions
 
151
        self.pb.update('Reading inventory data.')
 
152
        self.inventory = self.repo.get_inventory_weave()
224
153
        # the total set of revisions to process
225
 
        self.pending = set([key[-1] for key in self.revisions.keys()])
 
154
        self.pending = set([rev_id for rev_id in self.repo._revision_store.all_revision_ids(transaction)])
226
155
 
227
156
        # mapping from revision_id to parents
228
157
        self._rev_graph = {}
234
163
            # put a revision into the graph.
235
164
            self._graph_revision(rev_id)
236
165
        self._check_garbage_inventories()
237
 
        # if there are no inconsistent_parents and
 
166
        # if there are no inconsistent_parents and 
238
167
        # (no garbage inventories or we are not doing a thorough check)
239
 
        if (not self.inconsistent_parents and
 
168
        if (not self.inconsistent_parents and 
240
169
            (not self.garbage_inventories or not self.thorough)):
241
 
            ui.ui_factory.note('Inventory ok.')
 
170
            self.pb.note('Inventory ok.')
242
171
            return
243
 
        self.pb.update('Backing up inventory', 0, 0)
244
 
        self.repo._backup_inventory()
245
 
        ui.ui_factory.note('Backup inventory created.')
246
 
        new_inventories = self.repo._temp_inventories()
 
172
        self.pb.update('Backing up inventory...', 0, 0)
 
173
        self.repo.control_weaves.copy(self.inventory, 'inventory.backup', self.repo.get_transaction())
 
174
        self.pb.note('Backup Inventory created.')
 
175
        # asking for '' should never return a non-empty weave
 
176
        new_inventory_vf = self.repo.control_weaves.get_empty('inventory.new',
 
177
            self.repo.get_transaction())
247
178
 
248
179
        # we have topological order of revisions and non ghost parents ready.
249
180
        self._setup_steps(len(self._rev_graph))
250
 
        revision_keys = [(rev_id,) for rev_id in topo_sort(self._rev_graph)]
251
 
        stream = self._change_inv_parents(
252
 
            self.inventory.get_record_stream(revision_keys, 'unordered', True),
253
 
            self._new_inv_parents,
254
 
            set(revision_keys))
255
 
        new_inventories.insert_record_stream(stream)
256
 
        # if this worked, the set of new_inventories.keys should equal
 
181
        for rev_id in TopoSorter(self._rev_graph.items()).iter_topo_order():
 
182
            parents = self._rev_graph[rev_id]
 
183
            # double check this really is in topological order.
 
184
            unavailable = [p for p in parents if p not in new_inventory_vf]
 
185
            assert len(unavailable) == 0
 
186
            # this entry has all the non ghost parents in the inventory
 
187
            # file already.
 
188
            self._reweave_step('adding inventories')
 
189
            if isinstance(new_inventory_vf, WeaveFile):
 
190
                # It's really a WeaveFile, but we call straight into the
 
191
                # Weave's add method to disable the auto-write-out behaviour.
 
192
                # This is done to avoid a revision_count * time-to-write additional overhead on 
 
193
                # reconcile.
 
194
                new_inventory_vf._check_write_ok()
 
195
                Weave._add_lines(new_inventory_vf, rev_id, parents,
 
196
                    self.inventory.get_lines(rev_id), None, None, None, False, True)
 
197
            else:
 
198
                new_inventory_vf.add_lines(rev_id, parents, self.inventory.get_lines(rev_id))
 
199
 
 
200
        if isinstance(new_inventory_vf, WeaveFile):
 
201
            new_inventory_vf._save()
 
202
        # if this worked, the set of new_inventory_vf.names should equal
257
203
        # self.pending
258
 
        if not (set(new_inventories.keys()) ==
259
 
            set([(revid,) for revid in self.pending])):
260
 
            raise AssertionError()
 
204
        assert set(new_inventory_vf.versions()) == self.pending
261
205
        self.pb.update('Writing weave')
262
 
        self.repo._activate_new_inventory()
 
206
        self.repo.control_weaves.copy(new_inventory_vf, 'inventory', self.repo.get_transaction())
 
207
        self.repo.control_weaves.delete('inventory.new', self.repo.get_transaction())
263
208
        self.inventory = None
264
 
        ui.ui_factory.note('Inventory regenerated.')
265
 
 
266
 
    def _new_inv_parents(self, revision_key):
267
 
        """Lookup ghost-filtered parents for revision_key."""
268
 
        # Use the filtered ghostless parents list:
269
 
        return tuple([(revid,) for revid in self._rev_graph[revision_key[-1]]])
270
 
 
271
 
    def _change_inv_parents(self, stream, get_parents, all_revision_keys):
272
 
        """Adapt a record stream to reconcile the parents."""
273
 
        for record in stream:
274
 
            wanted_parents = get_parents(record.key)
275
 
            if wanted_parents and wanted_parents[0] not in all_revision_keys:
276
 
                # The check for the left most parent only handles knit
277
 
                # compressors, but this code only applies to knit and weave
278
 
                # repositories anyway.
279
 
                bytes = record.get_bytes_as('fulltext')
280
 
                yield FulltextContentFactory(record.key, wanted_parents, record.sha1, bytes)
281
 
            else:
282
 
                adapted_record = AdapterFactory(record.key, wanted_parents, record)
283
 
                yield adapted_record
284
 
            self._reweave_step('adding inventories')
 
209
        self.pb.note('Inventory regenerated.')
285
210
 
286
211
    def _setup_steps(self, new_total):
287
212
        """Setup the markers we need to control the progress bar."""
294
219
        # analyse revision id rev_id and put it in the stack.
295
220
        self._reweave_step('loading revisions')
296
221
        rev = self.repo.get_revision_reconcile(rev_id)
 
222
        assert rev.revision_id == rev_id
297
223
        parents = []
298
224
        for parent in rev.parent_ids:
299
225
            if self._parent_is_available(parent):
300
226
                parents.append(parent)
301
227
            else:
302
228
                mutter('found ghost %s', parent)
303
 
        self._rev_graph[rev_id] = parents
 
229
        self._rev_graph[rev_id] = parents   
 
230
        if self._parents_are_inconsistent(rev_id, parents):
 
231
            self.inconsistent_parents += 1
 
232
            mutter('Inconsistent inventory parents: id {%s} '
 
233
                   'inventory claims %r, '
 
234
                   'available parents are %r, '
 
235
                   'unavailable parents are %r',
 
236
                   rev_id, 
 
237
                   set(self.inventory.get_parents(rev_id)),
 
238
                   set(parents),
 
239
                   set(rev.parent_ids).difference(set(parents)))
 
240
 
 
241
    def _parents_are_inconsistent(self, rev_id, parents):
 
242
        """Return True if the parents list of rev_id does not match the weave.
 
243
 
 
244
        This detects inconsistencies based on the self.thorough value:
 
245
        if thorough is on, the first parent value is checked as well as ghost
 
246
        differences.
 
247
        Otherwise only the ghost differences are evaluated.
 
248
        """
 
249
        weave_parents = self.inventory.get_parents(rev_id)
 
250
        weave_missing_old_ghosts = set(weave_parents) != set(parents)
 
251
        first_parent_is_wrong = (
 
252
            len(weave_parents) and len(parents) and
 
253
            parents[0] != weave_parents[0])
 
254
        if self.thorough:
 
255
            return weave_missing_old_ghosts or first_parent_is_wrong
 
256
        else:
 
257
            return weave_missing_old_ghosts
304
258
 
305
259
    def _check_garbage_inventories(self):
306
260
        """Check for garbage inventories which we cannot trust
310
264
        """
311
265
        if not self.thorough:
312
266
            return
313
 
        inventories = set(self.inventory.keys())
314
 
        revisions = set(self.revisions.keys())
 
267
        inventories = set(self.inventory.versions())
 
268
        revisions = set(self._rev_graph.keys())
315
269
        garbage = inventories.difference(revisions)
316
270
        self.garbage_inventories = len(garbage)
317
 
        for revision_key in garbage:
318
 
            mutter('Garbage inventory {%s} found.', revision_key[-1])
 
271
        for revision_id in garbage:
 
272
            mutter('Garbage inventory {%s} found.', revision_id)
319
273
 
320
274
    def _parent_is_available(self, parent):
321
275
        """True if parent is a fully available revision
323
277
        A fully available revision has a inventory and a revision object in the
324
278
        repository.
325
279
        """
326
 
        if parent in self._rev_graph:
327
 
            return True
328
 
        inv_present = (1 == len(self.inventory.get_parent_map([(parent,)])))
329
 
        return (inv_present and self.repo.has_revision(parent))
 
280
        return (parent in self._rev_graph or 
 
281
                (parent in self.inventory and self.repo.has_revision(parent)))
330
282
 
331
283
    def _reweave_step(self, message):
332
284
        """Mark a single step of regeneration complete."""
355
307
    def _load_indexes(self):
356
308
        """Load indexes for the reconciliation."""
357
309
        self.transaction = self.repo.get_transaction()
358
 
        self.pb.update('Reading indexes', 0, 2)
359
 
        self.inventory = self.repo.inventories
360
 
        self.pb.update('Reading indexes', 1, 2)
 
310
        self.pb.update('Reading indexes.', 0, 2)
 
311
        self.inventory = self.repo.get_inventory_weave()
 
312
        self.pb.update('Reading indexes.', 1, 2)
361
313
        self.repo._check_for_inconsistent_revision_parents()
362
 
        self.revisions = self.repo.revisions
363
 
        self.pb.update('Reading indexes', 2, 2)
 
314
        self.revisions = self.repo._revision_store.get_revision_file(self.transaction)
 
315
        self.pb.update('Reading indexes.', 2, 2)
364
316
 
365
317
    def _gc_inventory(self):
366
318
        """Remove inventories that are not referenced from the revision store."""
367
 
        self.pb.update('Checking unused inventories', 0, 1)
 
319
        self.pb.update('Checking unused inventories.', 0, 1)
368
320
        self._check_garbage_inventories()
369
 
        self.pb.update('Checking unused inventories', 1, 3)
 
321
        self.pb.update('Checking unused inventories.', 1, 3)
370
322
        if not self.garbage_inventories:
371
 
            ui.ui_factory.note('Inventory ok.')
 
323
            self.pb.note('Inventory ok.')
372
324
            return
373
 
        self.pb.update('Backing up inventory', 0, 0)
374
 
        self.repo._backup_inventory()
375
 
        ui.ui_factory.note('Backup Inventory created')
 
325
        self.pb.update('Backing up inventory...', 0, 0)
 
326
        self.repo.control_weaves.copy(self.inventory, 'inventory.backup', self.transaction)
 
327
        self.pb.note('Backup Inventory created.')
376
328
        # asking for '' should never return a non-empty weave
377
 
        new_inventories = self.repo._temp_inventories()
 
329
        new_inventory_vf = self.repo.control_weaves.get_empty('inventory.new',
 
330
            self.transaction)
 
331
 
378
332
        # we have topological order of revisions and non ghost parents ready.
379
 
        graph = self.revisions.get_parent_map(self.revisions.keys())
380
 
        revision_keys = topo_sort(graph)
381
 
        revision_ids = [key[-1] for key in revision_keys]
382
 
        self._setup_steps(len(revision_keys))
383
 
        stream = self._change_inv_parents(
384
 
            self.inventory.get_record_stream(revision_keys, 'unordered', True),
385
 
            graph.__getitem__,
386
 
            set(revision_keys))
387
 
        new_inventories.insert_record_stream(stream)
 
333
        self._setup_steps(len(self.revisions))
 
334
        for rev_id in TopoSorter(self.revisions.get_graph().items()).iter_topo_order():
 
335
            parents = self.revisions.get_parents(rev_id)
 
336
            # double check this really is in topological order.
 
337
            unavailable = [p for p in parents if p not in new_inventory_vf]
 
338
            assert len(unavailable) == 0
 
339
            # this entry has all the non ghost parents in the inventory
 
340
            # file already.
 
341
            self._reweave_step('adding inventories')
 
342
            # ugly but needed, weaves are just way tooooo slow else.
 
343
            new_inventory_vf.add_lines(rev_id, parents, self.inventory.get_lines(rev_id))
 
344
 
388
345
        # if this worked, the set of new_inventory_vf.names should equal
389
 
        # the revisionds list
390
 
        if not(set(new_inventories.keys()) == set(revision_keys)):
391
 
            raise AssertionError()
 
346
        # self.pending
 
347
        assert set(new_inventory_vf.versions()) == set(self.revisions.versions())
392
348
        self.pb.update('Writing weave')
393
 
        self.repo._activate_new_inventory()
 
349
        self.repo.control_weaves.copy(new_inventory_vf, 'inventory', self.transaction)
 
350
        self.repo.control_weaves.delete('inventory.new', self.transaction)
394
351
        self.inventory = None
395
 
        ui.ui_factory.note('Inventory regenerated.')
 
352
        self.pb.note('Inventory regenerated.')
 
353
 
 
354
    def _check_garbage_inventories(self):
 
355
        """Check for garbage inventories which we cannot trust
 
356
 
 
357
        We cant trust them because their pre-requisite file data may not
 
358
        be present - all we know is that their revision was not installed.
 
359
        """
 
360
        inventories = set(self.inventory.versions())
 
361
        revisions = set(self.revisions.versions())
 
362
        garbage = inventories.difference(revisions)
 
363
        self.garbage_inventories = len(garbage)
 
364
        for revision_id in garbage:
 
365
            mutter('Garbage inventory {%s} found.', revision_id)
396
366
 
397
367
    def _fix_text_parents(self):
398
368
        """Fix bad versionedfile parent entries.
404
374
        parent lists, and replaces the versionedfile with a corrected version.
405
375
        """
406
376
        transaction = self.repo.get_transaction()
407
 
        versions = [key[-1] for key in self.revisions.keys()]
408
 
        mutter('Prepopulating revision text cache with %d revisions',
409
 
                len(versions))
410
 
        vf_checker = self.repo._get_versioned_file_checker()
411
 
        bad_parents, unused_versions = vf_checker.check_file_version_parents(
412
 
            self.repo.texts, self.pb)
413
 
        text_index = vf_checker.text_index
414
 
        per_id_bad_parents = {}
415
 
        for key in unused_versions:
416
 
            # Ensure that every file with unused versions gets rewritten.
417
 
            # NB: This is really not needed, reconcile != pack.
418
 
            per_id_bad_parents[key[0]] = {}
419
 
        # Generate per-knit/weave data.
420
 
        for key, details in bad_parents.iteritems():
421
 
            file_id = key[0]
422
 
            rev_id = key[1]
423
 
            knit_parents = tuple([parent[-1] for parent in details[0]])
424
 
            correct_parents = tuple([parent[-1] for parent in details[1]])
425
 
            file_details = per_id_bad_parents.setdefault(file_id, {})
426
 
            file_details[rev_id] = (knit_parents, correct_parents)
427
 
        file_id_versions = {}
428
 
        for text_key in text_index:
429
 
            versions_list = file_id_versions.setdefault(text_key[0], [])
430
 
            versions_list.append(text_key[1])
431
 
        # Do the reconcile of individual weaves.
432
 
        for num, file_id in enumerate(per_id_bad_parents):
 
377
        revision_versions = repository._RevisionTextVersionCache(self.repo)
 
378
        versions = self.revisions.versions()
 
379
        revision_versions.prepopulate_revs(versions)
 
380
        for num, file_id in enumerate(self.repo.weave_store):
433
381
            self.pb.update('Fixing text parents', num,
434
 
                           len(per_id_bad_parents))
435
 
            versions_with_bad_parents = per_id_bad_parents[file_id]
436
 
            id_unused_versions = set(key[-1] for key in unused_versions
437
 
                if key[0] == file_id)
438
 
            if file_id in file_id_versions:
439
 
                file_versions = file_id_versions[file_id]
440
 
            else:
441
 
                # This id was present in the disk store but is not referenced
442
 
                # by any revision at all.
443
 
                file_versions = []
444
 
            self._fix_text_parent(file_id, versions_with_bad_parents,
445
 
                 id_unused_versions, file_versions)
 
382
                           len(self.repo.weave_store))
 
383
            vf = self.repo.weave_store.get_weave(file_id, transaction)
 
384
            vf_checker = self.repo.get_versioned_file_checker(
 
385
                versions, revision_versions)
 
386
            versions_with_bad_parents = vf_checker.check_file_version_parents(
 
387
                vf, file_id)
 
388
            if len(versions_with_bad_parents) == 0:
 
389
                continue
 
390
            self._fix_text_parent(file_id, vf, versions_with_bad_parents)
446
391
 
447
 
    def _fix_text_parent(self, file_id, versions_with_bad_parents,
448
 
            unused_versions, all_versions):
 
392
    def _fix_text_parent(self, file_id, vf, versions_with_bad_parents):
449
393
        """Fix bad versionedfile entries in a single versioned file."""
450
 
        mutter('fixing text parent: %r (%d versions)', file_id,
451
 
                len(versions_with_bad_parents))
452
 
        mutter('(%d are unused)', len(unused_versions))
453
 
        new_file_id = 'temp:%s' % file_id
 
394
        new_vf = self.repo.weave_store.get_empty('temp:%s' % file_id,
 
395
            self.transaction)
454
396
        new_parents = {}
455
 
        needed_keys = set()
456
 
        for version in all_versions:
457
 
            if version in unused_versions:
458
 
                continue
459
 
            elif version in versions_with_bad_parents:
 
397
        for version in vf.versions():
 
398
            if version in versions_with_bad_parents:
460
399
                parents = versions_with_bad_parents[version][1]
461
400
            else:
462
 
                pmap = self.repo.texts.get_parent_map([(file_id, version)])
463
 
                parents = [key[-1] for key in pmap[(file_id, version)]]
464
 
            new_parents[(new_file_id, version)] = [
465
 
                (new_file_id, parent) for parent in parents]
466
 
            needed_keys.add((file_id, version))
467
 
        def fix_parents(stream):
468
 
            for record in stream:
469
 
                bytes = record.get_bytes_as('fulltext')
470
 
                new_key = (new_file_id, record.key[-1])
471
 
                parents = new_parents[new_key]
472
 
                yield FulltextContentFactory(new_key, parents, record.sha1, bytes)
473
 
        stream = self.repo.texts.get_record_stream(needed_keys, 'topological', True)
474
 
        self.repo._remove_file_id(new_file_id)
475
 
        self.repo.texts.insert_record_stream(fix_parents(stream))
476
 
        self.repo._remove_file_id(file_id)
477
 
        if len(new_parents):
478
 
            self.repo._move_file_id(new_file_id, file_id)
 
401
                parents = vf.get_parents(version)
 
402
            new_parents[version] = parents
 
403
        for version in TopoSorter(new_parents.items()).iter_topo_order():
 
404
            new_vf.add_lines(version, new_parents[version],
 
405
                             vf.get_lines(version))
 
406
        self.repo.weave_store.copy(new_vf, file_id, self.transaction)
 
407
        self.repo.weave_store.delete('temp:%s' % file_id, self.transaction)
479
408
 
480
409
 
481
410
class PackReconciler(RepoReconciler):
487
416
 
488
417
    In future this may be a good place to hook in annotation cache checking,
489
418
    index recreation etc.
 
419
 
 
420
    XXX: The index corruption that _fix_text_parents performs is needed for
 
421
    packs, but not yet implemented. The basic approach is to:
 
422
     - lock the names list
 
423
     - perform a customised pack() that regenerates data as needed
 
424
     - unlock the names list
490
425
    """
491
426
 
492
 
    # XXX: The index corruption that _fix_text_parents performs is needed for
493
 
    # packs, but not yet implemented. The basic approach is to:
494
 
    #  - lock the names list
495
 
    #  - perform a customised pack() that regenerates data as needed
496
 
    #  - unlock the names list
497
 
    # https://bugs.edge.launchpad.net/bzr/+bug/154173
498
 
 
499
427
    def _reconcile_steps(self):
500
428
        """Perform the steps to reconcile this repository."""
501
 
        if not self.thorough:
502
 
            return
503
 
        collection = self.repo._pack_collection
504
 
        collection.ensure_loaded()
505
 
        collection.lock_names()
506
 
        self.add_cleanup(collection._unlock_names)
507
 
        packs = collection.all_packs()
508
 
        all_revisions = self.repo.all_revision_ids()
509
 
        total_inventories = len(list(
510
 
            collection.inventory_index.combined_index.iter_all_entries()))
511
 
        if len(all_revisions):
512
 
            new_pack =  self.repo._reconcile_pack(collection, packs,
513
 
                ".reconcile", all_revisions, self.pb)
514
 
            if new_pack is not None:
515
 
                self._discard_and_save(packs)
516
 
        else:
517
 
            # only make a new pack when there is data to copy.
518
 
            self._discard_and_save(packs)
519
 
        self.garbage_inventories = total_inventories - len(list(
520
 
            collection.inventory_index.combined_index.iter_all_entries()))
521
 
 
522
 
    def _discard_and_save(self, packs):
523
 
        """Discard some packs from the repository.
524
 
 
525
 
        This removes them from the memory index, saves the in-memory index
526
 
        which makes the newly reconciled pack visible and hides the packs to be
527
 
        discarded, and finally renames the packs being discarded into the
528
 
        obsolete packs directory.
529
 
 
530
 
        :param packs: The packs to discard.
531
 
        """
532
 
        for pack in packs:
533
 
            self.repo._pack_collection._remove_pack_from_memory(pack)
534
 
        self.repo._pack_collection._save_pack_names()
535
 
        self.repo._pack_collection._obsolete_packs(packs)