~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/upgrade.py

Merged mailine

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Experiment in converting existing bzr branches to weaves."""
 
18
 
 
19
# To make this properly useful
 
20
#
 
21
# 1. assign text version ids, and put those text versions into
 
22
#    the inventory as they're converted.
 
23
#
 
24
# 2. keep track of the previous version of each file, rather than
 
25
#    just using the last one imported
 
26
#
 
27
# 3. assign entry versions when files are added, renamed or moved.
 
28
#
 
29
# 4. when merged-in versions are observed, walk down through them
 
30
#    to discover everything, then commit bottom-up
 
31
#
 
32
# 5. track ancestry as things are merged in, and commit that in each
 
33
#    revision
 
34
#
 
35
# Perhaps it's best to first walk the whole graph and make a plan for
 
36
# what should be imported in what order?  Need a kind of topological
 
37
# sort of all revisions.  (Or do we, can we just before doing a revision
 
38
# see that all its parents have either been converted or abandoned?)
 
39
 
 
40
 
 
41
# Cannot import a revision until all its parents have been
 
42
# imported.  in other words, we can only import revisions whose
 
43
# parents have all been imported.  the first step must be to
 
44
# import a revision with no parents, of which there must be at
 
45
# least one.  (So perhaps it's useful to store forward pointers
 
46
# from a list of parents to their children?)
 
47
#
 
48
# Another (equivalent?) approach is to build up the ordered
 
49
# ancestry list for the last revision, and walk through that.  We
 
50
# are going to need that.
 
51
#
 
52
# We don't want to have to recurse all the way back down the list.
 
53
#
 
54
# Suppose we keep a queue of the revisions able to be processed at
 
55
# any point.  This starts out with all the revisions having no
 
56
# parents.
 
57
#
 
58
# This seems like a generally useful algorithm...
 
59
#
 
60
# The current algorithm is dumb (O(n**2)?) but will do the job, and
 
61
# takes less than a second on the bzr.dev branch.
 
62
 
 
63
# This currently does a kind of lazy conversion of file texts, where a
 
64
# new text is written in every version.  That's unnecessary but for
 
65
# the moment saves us having to worry about when files need new
 
66
# versions.
 
67
 
 
68
 
 
69
import os
 
70
import tempfile
 
71
import sys
 
72
import shutil
 
73
 
 
74
from bzrlib.branch import Branch, find_branch
 
75
from bzrlib.branch import BZR_BRANCH_FORMAT_5, BZR_BRANCH_FORMAT_6
 
76
import bzrlib.hashcache as hashcache
 
77
from bzrlib.weave import Weave
 
78
from bzrlib.weavefile import read_weave, write_weave
 
79
from bzrlib.ui import ui_factory
 
80
from bzrlib.atomicfile import AtomicFile
 
81
from bzrlib.xml4 import serializer_v4
 
82
from bzrlib.xml5 import serializer_v5
 
83
from bzrlib.trace import mutter, note, warning
 
84
from bzrlib.osutils import sha_strings, sha_string, pathjoin, abspath
 
85
 
 
86
 
 
87
# TODO: jam 20060108 Create a new branch format, and as part of upgrade
 
88
#       make sure that ancestry.weave is deleted (it is never used, but
 
89
#       used to be created)
 
90
 
 
91
 
 
92
class Convert(object):
 
93
    def __init__(self, base_dir):
 
94
        self.base = base_dir
 
95
        self.converted_revs = set()
 
96
        self.absent_revisions = set()
 
97
        self.text_count = 0
 
98
        self.revisions = {}
 
99
        self.convert()
 
100
 
 
101
 
 
102
    def convert(self):
 
103
        if not self._open_branch():
 
104
            return
 
105
        note('starting upgrade of %s', os.path.abspath(self.base))
 
106
        self._backup_control_dir()
 
107
        self.pb = ui_factory.progress_bar()
 
108
        if self.old_format == 4:
 
109
            note('starting upgrade from format 4 to 5')
 
110
            self._convert_to_weaves()
 
111
            self._open_branch()
 
112
        if self.old_format == 5:
 
113
            note('starting upgrade from format 5 to 6')
 
114
            self._convert_to_prefixed()
 
115
            self._open_branch()
 
116
        cache = hashcache.HashCache(abspath(self.base))
 
117
        cache.clear()
 
118
        cache.write()
 
119
        note("finished")
 
120
 
 
121
 
 
122
    def _convert_to_prefixed(self):
 
123
        from bzrlib.store import hash_prefix
 
124
        for store_name in ["weaves", "revision-store"]:
 
125
            note("adding prefixes to %s" % store_name) 
 
126
            store_dir = pathjoin(self.base, ".bzr", store_name)
 
127
            for filename in os.listdir(store_dir):
 
128
                if filename.endswith(".weave") or filename.endswith(".gz"):
 
129
                    file_id = os.path.splitext(filename)[0]
 
130
                else:
 
131
                    file_id = filename
 
132
                prefix_dir = pathjoin(store_dir, hash_prefix(file_id))
 
133
                if not os.path.isdir(prefix_dir):
 
134
                    os.mkdir(prefix_dir)
 
135
                os.rename(pathjoin(store_dir, filename),
 
136
                          pathjoin(prefix_dir, filename))
 
137
        self._set_new_format(BZR_BRANCH_FORMAT_6)
 
138
 
 
139
 
 
140
    def _convert_to_weaves(self):
 
141
        note('note: upgrade may be faster if all store files are ungzipped first')
 
142
        if not os.path.isdir(self.base + '/.bzr/weaves'):
 
143
            os.mkdir(self.base + '/.bzr/weaves')
 
144
        self.inv_weave = Weave('inventory')
 
145
        # holds in-memory weaves for all files
 
146
        self.text_weaves = {}
 
147
        os.remove(self.branch.controlfilename('branch-format'))
 
148
        self._convert_working_inv()
 
149
        rev_history = self.branch.revision_history()
 
150
        # to_read is a stack holding the revisions we still need to process;
 
151
        # appending to it adds new highest-priority revisions
 
152
        self.known_revisions = set(rev_history)
 
153
        self.to_read = rev_history[-1:]
 
154
        while self.to_read:
 
155
            rev_id = self.to_read.pop()
 
156
            if (rev_id not in self.revisions
 
157
                and rev_id not in self.absent_revisions):
 
158
                self._load_one_rev(rev_id)
 
159
        self.pb.clear()
 
160
        to_import = self._make_order()
 
161
        for i, rev_id in enumerate(to_import):
 
162
            self.pb.update('converting revision', i, len(to_import))
 
163
            self._convert_one_rev(rev_id)
 
164
        self.pb.clear()
 
165
        note('upgraded to weaves:')
 
166
        note('  %6d revisions and inventories' % len(self.revisions))
 
167
        note('  %6d revisions not present' % len(self.absent_revisions))
 
168
        note('  %6d texts' % self.text_count)
 
169
        self._write_all_weaves()
 
170
        self._write_all_revs()
 
171
        self._cleanup_spare_files()
 
172
        self._set_new_format(BZR_BRANCH_FORMAT_5)
 
173
 
 
174
 
 
175
    def _open_branch(self):
 
176
        self.branch = Branch.open_downlevel(self.base)
 
177
        self.old_format = self.branch._branch_format
 
178
        if self.old_format == 6:
 
179
            note('this branch is in the most current format')
 
180
            return False
 
181
        if self.old_format not in (4, 5):
 
182
            raise BzrError("cannot upgrade from branch format %r" %
 
183
                           self.branch._branch_format)
 
184
        return True
 
185
 
 
186
 
 
187
    def _set_new_format(self, format):
 
188
        self.branch.put_controlfile('branch-format', format)
 
189
 
 
190
 
 
191
    def _cleanup_spare_files(self):
 
192
        for n in 'merged-patches', 'pending-merged-patches':
 
193
            p = self.branch.controlfilename(n)
 
194
            if not os.path.exists(p):
 
195
                continue
 
196
            ## assert os.path.getsize(p) == 0
 
197
            os.remove(p)
 
198
        shutil.rmtree(self.base + '/.bzr/inventory-store')
 
199
        shutil.rmtree(self.base + '/.bzr/text-store')
 
200
 
 
201
 
 
202
    def _backup_control_dir(self):
 
203
        orig = self.base + '/.bzr'
 
204
        backup = orig + '.backup'
 
205
        note('making backup of tree history')
 
206
        shutil.copytree(orig, backup)
 
207
        note('%s has been backed up to %s', orig, backup)
 
208
        note('if conversion fails, you can move this directory back to .bzr')
 
209
        note('if it succeeds, you can remove this directory if you wish')
 
210
 
 
211
 
 
212
    def _convert_working_inv(self):
 
213
        branch = self.branch
 
214
        inv = serializer_v4.read_inventory(branch.controlfile('inventory', 'rb'))
 
215
        new_inv_xml = serializer_v5.write_inventory_to_string(inv)
 
216
        branch.put_controlfile('inventory', new_inv_xml)
 
217
 
 
218
 
 
219
 
 
220
    def _write_all_weaves(self):
 
221
        write_a_weave(self.inv_weave, self.base + '/.bzr/inventory.weave')
 
222
        i = 0
 
223
        try:
 
224
            for file_id, file_weave in self.text_weaves.items():
 
225
                self.pb.update('writing weave', i, len(self.text_weaves))
 
226
                write_a_weave(file_weave, self.base + '/.bzr/weaves/%s.weave' % file_id)
 
227
                i += 1
 
228
        finally:
 
229
            self.pb.clear()
 
230
 
 
231
 
 
232
    def _write_all_revs(self):
 
233
        """Write all revisions out in new form."""
 
234
        shutil.rmtree(self.base + '/.bzr/revision-store')
 
235
        os.mkdir(self.base + '/.bzr/revision-store')
 
236
        try:
 
237
            for i, rev_id in enumerate(self.converted_revs):
 
238
                self.pb.update('write revision', i, len(self.converted_revs))
 
239
                f = file(self.base + '/.bzr/revision-store/%s' % rev_id, 'wb')
 
240
                try:
 
241
                    serializer_v5.write_revision(self.revisions[rev_id], f)
 
242
                finally:
 
243
                    f.close()
 
244
        finally:
 
245
            self.pb.clear()
 
246
 
 
247
            
 
248
    def _load_one_rev(self, rev_id):
 
249
        """Load a revision object into memory.
 
250
 
 
251
        Any parents not either loaded or abandoned get queued to be
 
252
        loaded."""
 
253
        self.pb.update('loading revision',
 
254
                       len(self.revisions),
 
255
                       len(self.known_revisions))
 
256
        if not self.branch.revision_store.has_id(rev_id):
 
257
            self.pb.clear()
 
258
            note('revision {%s} not present in branch; '
 
259
                 'will be converted as a ghost',
 
260
                 rev_id)
 
261
            self.absent_revisions.add(rev_id)
 
262
        else:
 
263
            rev_xml = self.branch.revision_store.get(rev_id).read()
 
264
            rev = serializer_v4.read_revision_from_string(rev_xml)
 
265
            for parent_id in rev.parent_ids:
 
266
                self.known_revisions.add(parent_id)
 
267
                self.to_read.append(parent_id)
 
268
            self.revisions[rev_id] = rev
 
269
 
 
270
 
 
271
    def _load_old_inventory(self, rev_id):
 
272
        assert rev_id not in self.converted_revs
 
273
        old_inv_xml = self.branch.inventory_store.get(rev_id).read()
 
274
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
 
275
        rev = self.revisions[rev_id]
 
276
        if rev.inventory_sha1:
 
277
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
 
278
                'inventory sha mismatch for {%s}' % rev_id
 
279
        return inv
 
280
        
 
281
 
 
282
    def _load_updated_inventory(self, rev_id):
 
283
        assert rev_id in self.converted_revs
 
284
        inv_xml = self.inv_weave.get_text(rev_id)
 
285
        inv = serializer_v5.read_inventory_from_string(inv_xml)
 
286
        return inv
 
287
 
 
288
 
 
289
    def _convert_one_rev(self, rev_id):
 
290
        """Convert revision and all referenced objects to new format."""
 
291
        rev = self.revisions[rev_id]
 
292
        inv = self._load_old_inventory(rev_id)
 
293
        present_parents = [p for p in rev.parent_ids
 
294
                           if p not in self.absent_revisions]
 
295
        self._convert_revision_contents(rev, inv, present_parents)
 
296
        self._store_new_weave(rev, inv, present_parents)
 
297
        self.converted_revs.add(rev_id)
 
298
 
 
299
 
 
300
    def _store_new_weave(self, rev, inv, present_parents):
 
301
        # the XML is now updated with text versions
 
302
        if __debug__:
 
303
            for file_id in inv:
 
304
                ie = inv[file_id]
 
305
                if ie.kind == 'root_directory':
 
306
                    continue
 
307
                assert hasattr(ie, 'revision'), \
 
308
                    'no revision on {%s} in {%s}' % \
 
309
                    (file_id, rev.revision_id)
 
310
        new_inv_xml = serializer_v5.write_inventory_to_string(inv)
 
311
        new_inv_sha1 = sha_string(new_inv_xml)
 
312
        self.inv_weave.add(rev.revision_id, 
 
313
                           present_parents,
 
314
                           new_inv_xml.splitlines(True),
 
315
                           new_inv_sha1)
 
316
        rev.inventory_sha1 = new_inv_sha1
 
317
 
 
318
    def _convert_revision_contents(self, rev, inv, present_parents):
 
319
        """Convert all the files within a revision.
 
320
 
 
321
        Also upgrade the inventory to refer to the text revision ids."""
 
322
        rev_id = rev.revision_id
 
323
        mutter('converting texts of revision {%s}',
 
324
               rev_id)
 
325
        parent_invs = map(self._load_updated_inventory, present_parents)
 
326
        for file_id in inv:
 
327
            ie = inv[file_id]
 
328
            self._convert_file_version(rev, ie, parent_invs)
 
329
 
 
330
    def _convert_file_version(self, rev, ie, parent_invs):
 
331
        """Convert one version of one file.
 
332
 
 
333
        The file needs to be added into the weave if it is a merge
 
334
        of >=2 parents or if it's changed from its parent.
 
335
        """
 
336
        if ie.kind == 'root_directory':
 
337
            return
 
338
        file_id = ie.file_id
 
339
        rev_id = rev.revision_id
 
340
        w = self.text_weaves.get(file_id)
 
341
        if w is None:
 
342
            w = Weave(file_id)
 
343
            self.text_weaves[file_id] = w
 
344
        text_changed = False
 
345
        previous_entries = ie.find_previous_heads(parent_invs, w)
 
346
        for old_revision in previous_entries:
 
347
                # if this fails, its a ghost ?
 
348
                assert old_revision in self.converted_revs 
 
349
        self.snapshot_ie(previous_entries, ie, w, rev_id)
 
350
        del ie.text_id
 
351
        assert getattr(ie, 'revision', None) is not None
 
352
 
 
353
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
 
354
        # TODO: convert this logic, which is ~= snapshot to
 
355
        # a call to:. This needs the path figured out. rather than a work_tree
 
356
        # a v4 revision_tree can be given, or something that looks enough like
 
357
        # one to give the file content to the entry if it needs it.
 
358
        # and we need something that looks like a weave store for snapshot to 
 
359
        # save against.
 
360
        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))
 
361
        if len(previous_revisions) == 1:
 
362
            previous_ie = previous_revisions.values()[0]
 
363
            if ie._unchanged(previous_ie):
 
364
                ie.revision = previous_ie.revision
 
365
                return
 
366
        parent_indexes = map(w.lookup, previous_revisions)
 
367
        if ie.has_text():
 
368
            file_lines = self.branch.text_store.get(ie.text_id).readlines()
 
369
            assert sha_strings(file_lines) == ie.text_sha1
 
370
            assert sum(map(len, file_lines)) == ie.text_size
 
371
            w.add(rev_id, parent_indexes, file_lines, ie.text_sha1)
 
372
            self.text_count += 1
 
373
        else:
 
374
            w.add(rev_id, parent_indexes, [], None)
 
375
        ie.revision = rev_id
 
376
        ##mutter('import text {%s} of {%s}',
 
377
        ##       ie.text_id, file_id)
 
378
 
 
379
    def _make_order(self):
 
380
        """Return a suitable order for importing revisions.
 
381
 
 
382
        The order must be such that an revision is imported after all
 
383
        its (present) parents.
 
384
        """
 
385
        todo = set(self.revisions.keys())
 
386
        done = self.absent_revisions.copy()
 
387
        o = []
 
388
        while todo:
 
389
            # scan through looking for a revision whose parents
 
390
            # are all done
 
391
            for rev_id in sorted(list(todo)):
 
392
                rev = self.revisions[rev_id]
 
393
                parent_ids = set(rev.parent_ids)
 
394
                if parent_ids.issubset(done):
 
395
                    # can take this one now
 
396
                    o.append(rev_id)
 
397
                    todo.remove(rev_id)
 
398
                    done.add(rev_id)
 
399
        return o
 
400
 
 
401
 
 
402
def write_a_weave(weave, filename):
 
403
    inv_wf = file(filename, 'wb')
 
404
    try:
 
405
        write_weave(weave, inv_wf)
 
406
    finally:
 
407
        inv_wf.close()
 
408
 
 
409
 
 
410
def upgrade(base_dir):
 
411
    Convert(base_dir)