← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/reconcile.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/reconcile.py
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
 
 
20
 
__all__ = ['reconcile', 'Reconciler', 'RepoReconciler', 'KnitReconciler']
21
 
 
22
 
 
23
 
from bzrlib import ui
 
19
from __future__ import absolute_import
 
20
 
 
21
__all__ = [
 
22
    'KnitReconciler',
 
23
    'PackReconciler',
 
24
    'reconcile',
 
25
    'Reconciler',
 
26
    'RepoReconciler',
 
27
    ]
 
28
 
 
29
 
 
30
from bzrlib import (
 
31
    cleanup,
 
32
    errors,
 
33
    revision as _mod_revision,
 
34
    ui,
 
35
    )
24
36
from bzrlib.trace import mutter
25
 
from bzrlib.tsort import TopoSorter
26
 
 
27
 
 
28
 
def reconcile(dir, other=None):
 
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):
29
43
    """Reconcile the data in dir.
30
44
 
31
45
    Currently this is limited to a inventory 'reweave'.
35
49
    Directly using Reconciler is recommended for library users that
36
50
    desire fine grained control or analysis of the found issues.
37
51
 
38
 
    :param other: another bzrdir to reconcile against.
 
52
    :param canonicalize_chks: Make sure CHKs are in canonical form.
39
53
    """
40
 
    reconciler = Reconciler(dir, other=other)
 
54
    reconciler = Reconciler(dir, canonicalize_chks=canonicalize_chks)
41
55
    reconciler.reconcile()
42
56
 
43
57
 
44
58
class Reconciler(object):
45
59
    """Reconcilers are used to reconcile existing data."""
46
60
 
47
 
    def __init__(self, dir, other=None):
 
61
    def __init__(self, dir, other=None, canonicalize_chks=False):
48
62
        """Create a Reconciler."""
49
63
        self.bzrdir = dir
 
64
        self.canonicalize_chks = canonicalize_chks
50
65
 
51
66
    def reconcile(self):
52
67
        """Perform reconciliation.
53
 
        
 
68
 
54
69
        After reconciliation the following attributes document found issues:
55
 
        inconsistent_parents: The number of revisions in the repository whose
56
 
                              ancestry was being reported incorrectly.
57
 
        garbage_inventories: The number of inventory objects without revisions
58
 
                             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.
59
78
        """
60
79
        self.pb = ui.ui_factory.nested_progress_bar()
61
80
        try:
65
84
 
66
85
    def _reconcile(self):
67
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):
68
102
        self.repo = self.bzrdir.find_repository()
69
 
        self.pb.note('Reconciling repository %s',
70
 
                     self.repo.bzrdir.root_transport.base)
71
 
        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)
72
115
        self.inconsistent_parents = repo_reconciler.inconsistent_parents
73
116
        self.garbage_inventories = repo_reconciler.garbage_inventories
74
 
        self.pb.note('Reconciliation complete.')
 
117
        if repo_reconciler.aborted:
 
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.'))
75
174
 
76
175
 
77
176
class RepoReconciler(object):
78
177
    """Reconciler that reconciles a repository.
79
178
 
 
179
    The goal of repository reconciliation is to make any derived data
 
180
    consistent with the core data committed by a user. This can involve
 
181
    reindexing, or removing unreferenced data if that can interfere with
 
182
    queries in a given repository.
 
183
 
80
184
    Currently this consists of an inventory reweave with revision cross-checks.
81
185
    """
82
186
 
89
193
        """
90
194
        self.garbage_inventories = 0
91
195
        self.inconsistent_parents = 0
 
196
        self.aborted = False
92
197
        self.repo = repo
93
198
        self.thorough = thorough
94
199
 
95
200
    def reconcile(self):
96
201
        """Perform reconciliation.
97
 
        
 
202
 
98
203
        After reconciliation the following attributes document found issues:
99
 
        inconsistent_parents: The number of revisions in the repository whose
100
 
                              ancestry was being reported incorrectly.
101
 
        garbage_inventories: The number of inventory objects without revisions
102
 
                             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.
103
209
        """
 
210
        operation = cleanup.OperationWithCleanups(self._reconcile)
 
211
        self.add_cleanup = operation.add_cleanup
 
212
        operation.run_simple()
 
213
 
 
214
    def _reconcile(self):
104
215
        self.repo.lock_write()
105
 
        try:
106
 
            self.pb = ui.ui_factory.nested_progress_bar()
107
 
            try:
108
 
                self._reconcile_steps()
109
 
            finally:
110
 
                self.pb.finished()
111
 
        finally:
112
 
            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()
113
220
 
114
221
    def _reconcile_steps(self):
115
222
        """Perform the steps to reconcile this repository."""
117
224
 
118
225
    def _reweave_inventory(self):
119
226
        """Regenerate the inventory weave for the repository from scratch.
120
 
        
121
 
        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
122
229
        will correct data issues. The self.thorough flag controls whether
123
230
        only data-loss causing issues (!self.thorough) or all issues
124
231
        (self.thorough) are treated as requiring the reweave.
125
232
        """
126
 
        # local because needing to know about WeaveFile is a wart we want to hide
127
 
        from bzrlib.weave import WeaveFile, Weave
128
233
        transaction = self.repo.get_transaction()
129
 
        self.pb.update('Reading inventory data.')
130
 
        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
131
237
        # the total set of revisions to process
132
 
        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()])
133
239
 
134
240
        # mapping from revision_id to parents
135
241
        self._rev_graph = {}
141
247
            # put a revision into the graph.
142
248
            self._graph_revision(rev_id)
143
249
        self._check_garbage_inventories()
144
 
        # if there are no inconsistent_parents and 
 
250
        # if there are no inconsistent_parents and
145
251
        # (no garbage inventories or we are not doing a thorough check)
146
 
        if (not self.inconsistent_parents and 
 
252
        if (not self.inconsistent_parents and
147
253
            (not self.garbage_inventories or not self.thorough)):
148
 
            self.pb.note('Inventory ok.')
 
254
            ui.ui_factory.note(gettext('Inventory ok.'))
149
255
            return
150
 
        self.pb.update('Backing up inventory...', 0, 0)
151
 
        self.repo.control_weaves.copy(self.inventory, 'inventory.backup', self.repo.get_transaction())
152
 
        self.pb.note('Backup Inventory created.')
153
 
        # asking for '' should never return a non-empty weave
154
 
        new_inventory_vf = self.repo.control_weaves.get_empty('inventory.new',
155
 
            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()
156
260
 
157
261
        # we have topological order of revisions and non ghost parents ready.
158
262
        self._setup_steps(len(self._rev_graph))
159
 
        for rev_id in TopoSorter(self._rev_graph.items()).iter_topo_order():
160
 
            parents = self._rev_graph[rev_id]
161
 
            # double check this really is in topological order.
162
 
            unavailable = [p for p in parents if p not in new_inventory_vf]
163
 
            assert len(unavailable) == 0
164
 
            # this entry has all the non ghost parents in the inventory
165
 
            # file already.
166
 
            self._reweave_step('adding inventories')
167
 
            if isinstance(new_inventory_vf, WeaveFile):
168
 
                # It's really a WeaveFile, but we call straight into the
169
 
                # Weave's add method to disable the auto-write-out behaviour.
170
 
                # This is done to avoid a revision_count * time-to-write additional overhead on 
171
 
                # reconcile.
172
 
                new_inventory_vf._check_write_ok()
173
 
                Weave._add_lines(new_inventory_vf, rev_id, parents,
174
 
                    self.inventory.get_lines(rev_id), None, None, None)
175
 
            else:
176
 
                new_inventory_vf.add_lines(rev_id, parents, self.inventory.get_lines(rev_id))
177
 
 
178
 
        if isinstance(new_inventory_vf, WeaveFile):
179
 
            new_inventory_vf._save()
180
 
        # 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
181
270
        # self.pending
182
 
        assert set(new_inventory_vf.versions()) == self.pending
183
 
        self.pb.update('Writing weave')
184
 
        self.repo.control_weaves.copy(new_inventory_vf, 'inventory', self.repo.get_transaction())
185
 
        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()
186
276
        self.inventory = None
187
 
        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')
188
298
 
189
299
    def _setup_steps(self, new_total):
190
300
        """Setup the markers we need to control the progress bar."""
197
307
        # analyse revision id rev_id and put it in the stack.
198
308
        self._reweave_step('loading revisions')
199
309
        rev = self.repo.get_revision_reconcile(rev_id)
200
 
        assert rev.revision_id == rev_id
201
310
        parents = []
202
311
        for parent in rev.parent_ids:
203
312
            if self._parent_is_available(parent):
204
313
                parents.append(parent)
205
314
            else:
206
315
                mutter('found ghost %s', parent)
207
 
        self._rev_graph[rev_id] = parents   
208
 
        if self._parents_are_inconsistent(rev_id, parents):
209
 
            self.inconsistent_parents += 1
210
 
            mutter('Inconsistent inventory parents: id {%s} '
211
 
                   'inventory claims %r, '
212
 
                   'available parents are %r, '
213
 
                   'unavailable parents are %r',
214
 
                   rev_id, 
215
 
                   set(self.inventory.get_parents(rev_id)),
216
 
                   set(parents),
217
 
                   set(rev.parent_ids).difference(set(parents)))
218
 
 
219
 
    def _parents_are_inconsistent(self, rev_id, parents):
220
 
        """Return True if the parents list of rev_id does not match the weave.
221
 
 
222
 
        This detects inconsistencies based on the self.thorough value:
223
 
        if thorough is on, the first parent value is checked as well as ghost
224
 
        differences.
225
 
        Otherwise only the ghost differences are evaluated.
226
 
        """
227
 
        weave_parents = self.inventory.get_parents(rev_id)
228
 
        weave_missing_old_ghosts = set(weave_parents) != set(parents)
229
 
        first_parent_is_wrong = (
230
 
            len(weave_parents) and len(parents) and
231
 
            parents[0] != weave_parents[0])
232
 
        if self.thorough:
233
 
            return weave_missing_old_ghosts or first_parent_is_wrong
234
 
        else:
235
 
            return weave_missing_old_ghosts
 
316
        self._rev_graph[rev_id] = parents
236
317
 
237
318
    def _check_garbage_inventories(self):
238
319
        """Check for garbage inventories which we cannot trust
242
323
        """
243
324
        if not self.thorough:
244
325
            return
245
 
        inventories = set(self.inventory.versions())
246
 
        revisions = set(self._rev_graph.keys())
 
326
        inventories = set(self.inventory.keys())
 
327
        revisions = set(self.revisions.keys())
247
328
        garbage = inventories.difference(revisions)
248
329
        self.garbage_inventories = len(garbage)
249
 
        for revision_id in garbage:
250
 
            mutter('Garbage inventory {%s} found.', revision_id)
 
330
        for revision_key in garbage:
 
331
            mutter('Garbage inventory {%s} found.', revision_key[-1])
251
332
 
252
333
    def _parent_is_available(self, parent):
253
334
        """True if parent is a fully available revision
255
336
        A fully available revision has a inventory and a revision object in the
256
337
        repository.
257
338
        """
258
 
        return (parent in self._rev_graph or 
259
 
                (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))
260
343
 
261
344
    def _reweave_step(self, message):
262
345
        """Mark a single step of regeneration complete."""
267
350
class KnitReconciler(RepoReconciler):
268
351
    """Reconciler that reconciles a knit format repository.
269
352
 
270
 
    This will detect garbage inventories and remove them.
271
 
 
272
 
    Inconsistent parentage is checked for in the revision weave.
 
353
    This will detect garbage inventories and remove them in thorough mode.
273
354
    """
274
355
 
275
356
    def _reconcile_steps(self):
276
357
        """Perform the steps to reconcile this repository."""
277
358
        if self.thorough:
278
 
            self._load_indexes()
 
359
            try:
 
360
                self._load_indexes()
 
361
            except errors.BzrCheckError:
 
362
                self.aborted = True
 
363
                return
279
364
            # knits never suffer this
280
365
            self._gc_inventory()
 
366
            self._fix_text_parents()
281
367
 
282
368
    def _load_indexes(self):
283
369
        """Load indexes for the reconciliation."""
284
370
        self.transaction = self.repo.get_transaction()
285
 
        self.pb.update('Reading indexes.', 0, 2)
286
 
        self.inventory = self.repo.get_inventory_weave()
287
 
        self.pb.update('Reading indexes.', 1, 2)
288
 
        self.revisions = self.repo._revision_store.get_revision_file(self.transaction)
289
 
        self.pb.update('Reading indexes.', 2, 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)
 
374
        self.repo._check_for_inconsistent_revision_parents()
 
375
        self.revisions = self.repo.revisions
 
376
        self.pb.update(gettext('Reading indexes'), 2, 2)
290
377
 
291
378
    def _gc_inventory(self):
292
379
        """Remove inventories that are not referenced from the revision store."""
293
 
        self.pb.update('Checking unused inventories.', 0, 1)
 
380
        self.pb.update(gettext('Checking unused inventories'), 0, 1)
294
381
        self._check_garbage_inventories()
295
 
        self.pb.update('Checking unused inventories.', 1, 3)
 
382
        self.pb.update(gettext('Checking unused inventories'), 1, 3)
296
383
        if not self.garbage_inventories:
297
 
            self.pb.note('Inventory ok.')
 
384
            ui.ui_factory.note(gettext('Inventory ok.'))
298
385
            return
299
 
        self.pb.update('Backing up inventory...', 0, 0)
300
 
        self.repo.control_weaves.copy(self.inventory, 'inventory.backup', self.transaction)
301
 
        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'))
302
389
        # asking for '' should never return a non-empty weave
303
 
        new_inventory_vf = self.repo.control_weaves.get_empty('inventory.new',
304
 
            self.transaction)
305
 
 
 
390
        new_inventories = self.repo._temp_inventories()
306
391
        # we have topological order of revisions and non ghost parents ready.
307
 
        self._setup_steps(len(self.revisions))
308
 
        for rev_id in TopoSorter(self.revisions.get_graph().items()).iter_topo_order():
309
 
            parents = self.revisions.get_parents(rev_id)
310
 
            # double check this really is in topological order.
311
 
            unavailable = [p for p in parents if p not in new_inventory_vf]
312
 
            assert len(unavailable) == 0
313
 
            # this entry has all the non ghost parents in the inventory
314
 
            # file already.
315
 
            self._reweave_step('adding inventories')
316
 
            # ugly but needed, weaves are just way tooooo slow else.
317
 
            new_inventory_vf.add_lines(rev_id, parents, self.inventory.get_lines(rev_id))
318
 
 
 
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)
319
401
        # if this worked, the set of new_inventory_vf.names should equal
320
 
        # self.pending
321
 
        assert set(new_inventory_vf.versions()) == set(self.revisions.versions())
322
 
        self.pb.update('Writing weave')
323
 
        self.repo.control_weaves.copy(new_inventory_vf, 'inventory', self.transaction)
324
 
        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()
325
407
        self.inventory = None
326
 
        self.pb.note('Inventory regenerated.')
327
 
 
328
 
    def _check_garbage_inventories(self):
329
 
        """Check for garbage inventories which we cannot trust
330
 
 
331
 
        We cant trust them because their pre-requisite file data may not
332
 
        be present - all we know is that their revision was not installed.
333
 
        """
334
 
        inventories = set(self.inventory.versions())
335
 
        revisions = set(self.revisions.versions())
336
 
        garbage = inventories.difference(revisions)
337
 
        self.garbage_inventories = len(garbage)
338
 
        for revision_id in garbage:
339
 
            mutter('Garbage inventory {%s} found.', revision_id)
 
408
        ui.ui_factory.note(gettext('Inventory regenerated.'))
 
409
 
 
410
    def _fix_text_parents(self):
 
411
        """Fix bad versionedfile parent entries.
 
412
 
 
413
        It is possible for the parents entry in a versionedfile entry to be
 
414
        inconsistent with the values in the revision and inventory.
 
415
 
 
416
        This method finds entries with such inconsistencies, corrects their
 
417
        parent lists, and replaces the versionedfile with a corrected version.
 
418
        """
 
419
        transaction = self.repo.get_transaction()
 
420
        versions = [key[-1] for key in self.revisions.keys()]
 
421
        mutter('Prepopulating revision text cache with %d revisions',
 
422
                len(versions))
 
423
        vf_checker = self.repo._get_versioned_file_checker()
 
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)
 
459
 
 
460
    def _fix_text_parent(self, file_id, versions_with_bad_parents,
 
461
            unused_versions, all_versions):
 
462
        """Fix bad versionedfile entries in a single versioned file."""
 
463
        mutter('fixing text parent: %r (%d versions)', file_id,
 
464
                len(versions_with_bad_parents))
 
465
        mutter('(%d are unused)', len(unused_versions))
 
466
        new_file_id = 'temp:%s' % file_id
 
467
        new_parents = {}
 
468
        needed_keys = set()
 
469
        for version in all_versions:
 
470
            if version in unused_versions:
 
471
                continue
 
472
            elif version in versions_with_bad_parents:
 
473
                parents = versions_with_bad_parents[version][1]
 
474
            else:
 
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)
 
492
 
 
493
 
 
494
class PackReconciler(RepoReconciler):
 
495
    """Reconciler that reconciles a pack based repository.
 
496
 
 
497
    Garbage inventories do not affect ancestry queries, and removal is
 
498
    considerably more expensive as there is no separate versioned file for
 
499
    them, so they are not cleaned. In short it is currently a no-op.
 
500
 
 
501
    In future this may be a good place to hook in annotation cache checking,
 
502
    index recreation etc.
 
503
    """
 
504
 
 
505
    # XXX: The index corruption that _fix_text_parents performs is needed for
 
506
    # packs, but not yet implemented. The basic approach is to:
 
507
    #  - lock the names list
 
508
    #  - perform a customised pack() that regenerates data as needed
 
509
    #  - unlock the names list
 
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
 
517
 
 
518
    def _reconcile_steps(self):
 
519
        """Perform the steps to reconcile this repository."""
 
520
        if not self.thorough:
 
521
            return
 
522
        collection = self.repo._pack_collection
 
523
        collection.ensure_loaded()
 
524
        collection.lock_names()
 
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
 
533
            else:
 
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:
 
538
                self._discard_and_save(packs)
 
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()))
 
544
 
 
545
    def _discard_and_save(self, packs):
 
546
        """Discard some packs from the repository.
 
547
 
 
548
        This removes them from the memory index, saves the in-memory index
 
549
        which makes the newly reconciled pack visible and hides the packs to be
 
550
        discarded, and finally renames the packs being discarded into the
 
551
        obsolete packs directory.
 
552
 
 
553
        :param packs: The packs to discard.
 
554
        """
 
555
        for pack in packs:
 
556
            self.repo._pack_collection._remove_pack_from_memory(pack)
 
557
        self.repo._pack_collection._save_pack_names()
 
558
        self.repo._pack_collection._obsolete_packs(packs)