← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/reconcile.py

(vila) Calling super() instead of mentioning the base class in setUp avoid
 mistakes. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/reconcile.py
1
 
# (C) 2005, 2006 Canonical Limited.
 
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']
21
 
 
22
 
 
23
 
import bzrlib.branch
24
 
import bzrlib.errors as errors
25
 
import bzrlib.progress
 
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
    )
26
36
from bzrlib.trace import mutter
27
 
from bzrlib.tsort import TopoSorter
28
 
import bzrlib.ui as ui
29
 
 
30
 
 
31
 
def reconcile(dir):
 
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):
32
43
    """Reconcile the data in dir.
33
44
 
34
45
    Currently this is limited to a inventory 'reweave'.
37
48
 
38
49
    Directly using Reconciler is recommended for library users that
39
50
    desire fine grained control or analysis of the found issues.
 
51
 
 
52
    :param canonicalize_chks: Make sure CHKs are in canonical form.
40
53
    """
41
 
    reconciler = Reconciler(dir)
 
54
    reconciler = Reconciler(dir, canonicalize_chks=canonicalize_chks)
42
55
    reconciler.reconcile()
43
56
 
44
57
 
45
58
class Reconciler(object):
46
59
    """Reconcilers are used to reconcile existing data."""
47
60
 
48
 
    def __init__(self, dir):
 
61
    def __init__(self, dir, other=None, canonicalize_chks=False):
 
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 = RepoReconciler(self.repo)
72
 
        repo_reconciler.reconcile()
 
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)
73
115
        self.inconsistent_parents = repo_reconciler.inconsistent_parents
74
116
        self.garbage_inventories = repo_reconciler.garbage_inventories
75
 
        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.'))
76
174
 
77
175
 
78
176
class RepoReconciler(object):
79
177
    """Reconciler that reconciles a repository.
80
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
 
81
184
    Currently this consists of an inventory reweave with revision cross-checks.
82
185
    """
83
186
 
84
 
    def __init__(self, repo):
 
187
    def __init__(self, repo, other=None, thorough=False):
 
188
        """Construct a RepoReconciler.
 
189
 
 
190
        :param thorough: perform a thorough check which may take longer but
 
191
                         will correct non-data loss issues such as incorrect
 
192
                         cached data.
 
193
        """
 
194
        self.garbage_inventories = 0
 
195
        self.inconsistent_parents = 0
 
196
        self.aborted = False
85
197
        self.repo = repo
 
198
        self.thorough = thorough
86
199
 
87
200
    def reconcile(self):
88
201
        """Perform reconciliation.
89
 
        
 
202
 
90
203
        After reconciliation the following attributes document found issues:
91
 
        inconsistent_parents: The number of revisions in the repository whose
92
 
                              ancestry was being reported incorrectly.
93
 
        garbage_inventories: The number of inventory objects without revisions
94
 
                             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.
95
209
        """
 
210
        operation = cleanup.OperationWithCleanups(self._reconcile)
 
211
        self.add_cleanup = operation.add_cleanup
 
212
        operation.run_simple()
 
213
 
 
214
    def _reconcile(self):
96
215
        self.repo.lock_write()
97
 
        try:
98
 
            self.pb = ui.ui_factory.nested_progress_bar()
99
 
            try:
100
 
                self._reconcile_steps()
101
 
            finally:
102
 
                self.pb.finished()
103
 
        finally:
104
 
            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()
105
220
 
106
221
    def _reconcile_steps(self):
107
222
        """Perform the steps to reconcile this repository."""
108
223
        self._reweave_inventory()
109
224
 
110
225
    def _reweave_inventory(self):
111
 
        """Regenerate the inventory weave for the repository from scratch."""
112
 
        # local because its really a wart we want to hide
113
 
        from bzrlib.weave import WeaveFile, Weave
 
226
        """Regenerate the inventory weave for the repository from scratch.
 
227
 
 
228
        This is a smart function: it will only do the reweave if doing it
 
229
        will correct data issues. The self.thorough flag controls whether
 
230
        only data-loss causing issues (!self.thorough) or all issues
 
231
        (self.thorough) are treated as requiring the reweave.
 
232
        """
114
233
        transaction = self.repo.get_transaction()
115
 
        self.pb.update('Reading inventory data.')
116
 
        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
117
237
        # the total set of revisions to process
118
 
        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()])
119
239
 
120
240
        # mapping from revision_id to parents
121
241
        self._rev_graph = {}
127
247
            # put a revision into the graph.
128
248
            self._graph_revision(rev_id)
129
249
        self._check_garbage_inventories()
130
 
        if not self.inconsistent_parents and not self.garbage_inventories:
131
 
            self.pb.note('Inventory ok.')
 
250
        # if there are no inconsistent_parents and
 
251
        # (no garbage inventories or we are not doing a thorough check)
 
252
        if (not self.inconsistent_parents and
 
253
            (not self.garbage_inventories or not self.thorough)):
 
254
            ui.ui_factory.note(gettext('Inventory ok.'))
132
255
            return
133
 
        self.pb.update('Backing up inventory...', 0, 0)
134
 
        self.repo.control_weaves.copy(self.inventory, 'inventory.backup', self.repo.get_transaction())
135
 
        self.pb.note('Backup Inventory created.')
136
 
        # asking for '' should never return a non-empty weave
137
 
        new_inventory_vf = self.repo.control_weaves.get_empty('inventory.new',
138
 
            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()
139
260
 
140
261
        # we have topological order of revisions and non ghost parents ready.
141
262
        self._setup_steps(len(self._rev_graph))
142
 
        for rev_id in TopoSorter(self._rev_graph.items()).iter_topo_order():
143
 
            parents = self._rev_graph[rev_id]
144
 
            # double check this really is in topological order.
145
 
            unavailable = [p for p in parents if p not in new_inventory_vf]
146
 
            assert len(unavailable) == 0
147
 
            # this entry has all the non ghost parents in the inventory
148
 
            # file already.
149
 
            self._reweave_step('adding inventories')
150
 
            if isinstance(new_inventory_vf, WeaveFile):
151
 
                # It's really a WeaveFile, but we call straight into the
152
 
                # Weave's add method to disable the auto-write-out behaviour.
153
 
                # This is done to avoid a revision_count * time-to-write additional overhead on 
154
 
                # reconcile.
155
 
                new_inventory_vf._check_write_ok()
156
 
                Weave._add_lines(new_inventory_vf, rev_id, parents, self.inventory.get_lines(rev_id),
157
 
                                 None)
158
 
            else:
159
 
                new_inventory_vf.add_lines(rev_id, parents, self.inventory.get_lines(rev_id))
160
 
 
161
 
        if isinstance(new_inventory_vf, WeaveFile):
162
 
            new_inventory_vf._save()
163
 
        # 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
164
270
        # self.pending
165
 
        assert set(new_inventory_vf.versions()) == self.pending
166
 
        self.pb.update('Writing weave')
167
 
        self.repo.control_weaves.copy(new_inventory_vf, 'inventory', self.repo.get_transaction())
168
 
        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()
169
276
        self.inventory = None
170
 
        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')
171
298
 
172
299
    def _setup_steps(self, new_total):
173
300
        """Setup the markers we need to control the progress bar."""
180
307
        # analyse revision id rev_id and put it in the stack.
181
308
        self._reweave_step('loading revisions')
182
309
        rev = self.repo.get_revision_reconcile(rev_id)
183
 
        assert rev.revision_id == rev_id
184
310
        parents = []
185
311
        for parent in rev.parent_ids:
186
312
            if self._parent_is_available(parent):
187
313
                parents.append(parent)
188
314
            else:
189
315
                mutter('found ghost %s', parent)
190
 
        self._rev_graph[rev_id] = parents   
191
 
        if set(self.inventory.get_parents(rev_id)) != set(parents):
192
 
            self.inconsistent_parents += 1
193
 
            mutter('Inconsistent inventory parents: id {%s} '
194
 
                   'inventory claims %r, '
195
 
                   'available parents are %r, '
196
 
                   'unavailable parents are %r',
197
 
                   rev_id, 
198
 
                   set(self.inventory.get_parents(rev_id)),
199
 
                   set(parents),
200
 
                   set(rev.parent_ids).difference(set(parents)))
 
316
        self._rev_graph[rev_id] = parents
201
317
 
202
318
    def _check_garbage_inventories(self):
203
319
        """Check for garbage inventories which we cannot trust
205
321
        We cant trust them because their pre-requisite file data may not
206
322
        be present - all we know is that their revision was not installed.
207
323
        """
208
 
        inventories = set(self.inventory.versions())
209
 
        revisions = set(self._rev_graph.keys())
 
324
        if not self.thorough:
 
325
            return
 
326
        inventories = set(self.inventory.keys())
 
327
        revisions = set(self.revisions.keys())
210
328
        garbage = inventories.difference(revisions)
211
329
        self.garbage_inventories = len(garbage)
212
 
        for revision_id in garbage:
213
 
            mutter('Garbage inventory {%s} found.', revision_id)
 
330
        for revision_key in garbage:
 
331
            mutter('Garbage inventory {%s} found.', revision_key[-1])
214
332
 
215
333
    def _parent_is_available(self, parent):
216
334
        """True if parent is a fully available revision
218
336
        A fully available revision has a inventory and a revision object in the
219
337
        repository.
220
338
        """
221
 
        return (parent in self._rev_graph or 
222
 
                (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))
223
343
 
224
344
    def _reweave_step(self, message):
225
345
        """Mark a single step of regeneration complete."""
230
350
class KnitReconciler(RepoReconciler):
231
351
    """Reconciler that reconciles a knit format repository.
232
352
 
233
 
    This will detect garbage inventories and remove them.
234
 
 
235
 
    Inconsistent parentage is checked for in the revision weave.
 
353
    This will detect garbage inventories and remove them in thorough mode.
236
354
    """
237
355
 
238
356
    def _reconcile_steps(self):
239
357
        """Perform the steps to reconcile this repository."""
240
 
        self._load_indexes()
241
 
        # knits never suffer this
242
 
        self.inconsistent_parents = 0
243
 
        self._gc_inventory()
 
358
        if self.thorough:
 
359
            try:
 
360
                self._load_indexes()
 
361
            except errors.BzrCheckError:
 
362
                self.aborted = True
 
363
                return
 
364
            # knits never suffer this
 
365
            self._gc_inventory()
 
366
            self._fix_text_parents()
244
367
 
245
368
    def _load_indexes(self):
246
369
        """Load indexes for the reconciliation."""
247
370
        self.transaction = self.repo.get_transaction()
248
 
        self.pb.update('Reading indexes.', 0, 2)
249
 
        self.inventory = self.repo.get_inventory_weave()
250
 
        self.pb.update('Reading indexes.', 1, 2)
251
 
        self.revisions = self.repo._revision_store.get_revision_file(self.transaction)
252
 
        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)
253
377
 
254
378
    def _gc_inventory(self):
255
379
        """Remove inventories that are not referenced from the revision store."""
256
 
        self.pb.update('Checking unused inventories.', 0, 1)
 
380
        self.pb.update(gettext('Checking unused inventories'), 0, 1)
257
381
        self._check_garbage_inventories()
258
 
        self.pb.update('Checking unused inventories.', 1, 3)
 
382
        self.pb.update(gettext('Checking unused inventories'), 1, 3)
259
383
        if not self.garbage_inventories:
260
 
            self.pb.note('Inventory ok.')
 
384
            ui.ui_factory.note(gettext('Inventory ok.'))
261
385
            return
262
 
        self.pb.update('Backing up inventory...', 0, 0)
263
 
        self.repo.control_weaves.copy(self.inventory, 'inventory.backup', self.transaction)
264
 
        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'))
265
389
        # asking for '' should never return a non-empty weave
266
 
        new_inventory_vf = self.repo.control_weaves.get_empty('inventory.new',
267
 
            self.transaction)
268
 
 
 
390
        new_inventories = self.repo._temp_inventories()
269
391
        # we have topological order of revisions and non ghost parents ready.
270
 
        self._setup_steps(len(self.revisions))
271
 
        for rev_id in TopoSorter(self.revisions.get_graph().items()).iter_topo_order():
272
 
            parents = self.revisions.get_parents(rev_id)
273
 
            # double check this really is in topological order.
274
 
            unavailable = [p for p in parents if p not in new_inventory_vf]
275
 
            assert len(unavailable) == 0
276
 
            # this entry has all the non ghost parents in the inventory
277
 
            # file already.
278
 
            self._reweave_step('adding inventories')
279
 
            # ugly but needed, weaves are just way tooooo slow else.
280
 
            new_inventory_vf.add_lines(rev_id, parents, self.inventory.get_lines(rev_id))
281
 
 
 
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)
282
401
        # if this worked, the set of new_inventory_vf.names should equal
283
 
        # self.pending
284
 
        assert set(new_inventory_vf.versions()) == set(self.revisions.versions())
285
 
        self.pb.update('Writing weave')
286
 
        self.repo.control_weaves.copy(new_inventory_vf, 'inventory', self.transaction)
287
 
        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()
288
407
        self.inventory = None
289
 
        self.pb.note('Inventory regenerated.')
290
 
 
291
 
    def _reinsert_revisions(self):
292
 
        """Correct the revision history for revisions in the revision knit."""
293
 
        # the total set of revisions to process
294
 
        self.pending = set(self.revisions.versions())
295
 
 
296
 
        # mapping from revision_id to parents
297
 
        self._rev_graph = {}
298
 
        # errors that we detect
299
 
        self.inconsistent_parents = 0
300
 
        # we need the revision id of each revision and its available parents list
301
 
        self._setup_steps(len(self.pending))
302
 
        for rev_id in self.pending:
303
 
            # put a revision into the graph.
304
 
            self._graph_revision(rev_id)
305
 
 
306
 
        if not self.inconsistent_parents:
307
 
            self.pb.note('Revision history accurate.')
 
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:
308
521
            return
309
 
        self._setup_steps(len(self._rev_graph))
310
 
        for rev_id, parents in self._rev_graph.items():
311
 
            if parents != self.revisions.get_parents(rev_id):
312
 
                self.revisions.fix_parents(rev_id, parents)
313
 
            self._reweave_step('Fixing parents')
314
 
        self.pb.note('Ancestry corrected.')
315
 
 
316
 
    def _graph_revision(self, rev_id):
317
 
        """Load a revision into the revision graph."""
318
 
        # pick a random revision
319
 
        # analyse revision id rev_id and put it in the stack.
320
 
        self._reweave_step('loading revisions')
321
 
        rev = self.repo._revision_store.get_revision(rev_id, self.transaction)
322
 
        assert rev.revision_id == rev_id
323
 
        parents = []
324
 
        for parent in rev.parent_ids:
325
 
            if self.revisions.has_version(parent):
326
 
                parents.append(parent)
 
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
327
533
            else:
328
 
                mutter('found ghost %s', parent)
329
 
        self._rev_graph[rev_id] = parents   
330
 
        if set(self.inventory.get_parents(rev_id)) != set(parents):
331
 
            self.inconsistent_parents += 1
332
 
            mutter('Inconsistent inventory parents: id {%s} '
333
 
                   'inventory claims %r, '
334
 
                   'available parents are %r, '
335
 
                   'unavailable parents are %r',
336
 
                   rev_id, 
337
 
                   set(self.inventory.get_parents(rev_id)),
338
 
                   set(parents),
339
 
                   set(rev.parent_ids).difference(set(parents)))
340
 
 
341
 
    def _check_garbage_inventories(self):
342
 
        """Check for garbage inventories which we cannot trust
343
 
 
344
 
        We cant trust them because their pre-requisite file data may not
345
 
        be present - all we know is that their revision was not installed.
 
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.
346
554
        """
347
 
        inventories = set(self.inventory.versions())
348
 
        revisions = set(self.revisions.versions())
349
 
        garbage = inventories.difference(revisions)
350
 
        self.garbage_inventories = len(garbage)
351
 
        for revision_id in garbage:
352
 
            mutter('Garbage inventory {%s} found.', revision_id)
 
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)