~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/reconcile.py

  • Committer: Vincent Ladeuil
  • Date: 2013-07-13 19:05:24 UTC
  • mto: This revision was merged to the branch mainline in revision 6580.
  • Revision ID: v.ladeuil+lp@free.fr-20130713190524-3bclzq4hpwkd6hkw
Urgh. pqm still runs python 2.6 so we have to maintain compatibility to land the fix 8-(

Show diffs side-by-side

added added

removed removed

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