← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/bundle_data.py

  • Committer: Alexander Belchenko
  • Date: 2008-02-07 07:53:19 UTC
  • mto: This revision was merged to the branch mainline in revision 3231.
  • Revision ID: bialix@ukr.net-20080207075319-d9jj7as8i5ztiff7
some cleanup in package_mf.py; mention about load_from_zip() deprecation in NEWS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/bundle_data.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Read in a bundle stream, and process it into a BundleReader object."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
import base64
22
20
from cStringIO import StringIO
23
21
import os
27
25
    osutils,
28
26
    timestamp,
29
27
    )
 
28
import bzrlib.errors
30
29
from bzrlib.bundle import apply_bundle
31
 
from bzrlib.errors import (
32
 
    TestamentMismatch,
33
 
    BzrError,
34
 
    )
35
 
from bzrlib.inventory import (
36
 
    Inventory,
37
 
    InventoryDirectory,
38
 
    InventoryFile,
39
 
    InventoryLink,
40
 
    )
41
 
from bzrlib.osutils import sha_string, pathjoin
 
30
from bzrlib.errors import (TestamentMismatch, BzrError, 
 
31
                           MalformedHeader, MalformedPatches, NotABundle)
 
32
from bzrlib.inventory import (Inventory, InventoryEntry,
 
33
                              InventoryDirectory, InventoryFile,
 
34
                              InventoryLink)
 
35
from bzrlib.osutils import sha_file, sha_string, pathjoin
42
36
from bzrlib.revision import Revision, NULL_REVISION
43
37
from bzrlib.testament import StrictTestament
44
38
from bzrlib.trace import mutter, warning
 
39
import bzrlib.transport
45
40
from bzrlib.tree import Tree
 
41
import bzrlib.urlutils
46
42
from bzrlib.xml5 import serializer_v5
47
43
 
48
44
 
82
78
            for property in self.properties:
83
79
                key_end = property.find(': ')
84
80
                if key_end == -1:
85
 
                    if not property.endswith(':'):
86
 
                        raise ValueError(property)
 
81
                    assert property.endswith(':')
87
82
                    key = str(property[:-1])
88
83
                    value = ''
89
84
                else:
163
158
    def get_base(self, revision):
164
159
        revision_info = self.get_revision_info(revision.revision_id)
165
160
        if revision_info.base_id is not None:
166
 
            return revision_info.base_id
 
161
            if revision_info.base_id == NULL_REVISION:
 
162
                return None
 
163
            else:
 
164
                return revision_info.base_id
167
165
        if len(revision.parent_ids) == 0:
168
166
            # There is no base listed, and
169
167
            # the lowest revision doesn't have a parent
170
168
            # so this is probably against the empty tree
171
 
            # and thus base truly is NULL_REVISION
172
 
            return NULL_REVISION
 
169
            # and thus base truly is None
 
170
            return None
173
171
        else:
174
172
            return revision.parent_ids[-1]
175
173
 
198
196
    def revision_tree(self, repository, revision_id, base=None):
199
197
        revision = self.get_revision(revision_id)
200
198
        base = self.get_base(revision)
201
 
        if base == revision_id:
202
 
            raise AssertionError()
 
199
        assert base != revision_id
203
200
        if not self._validated_revisions_against_repo:
204
201
            self._validate_references_from_repository(repository)
205
202
        revision_info = self.get_revision_info(revision_id)
206
203
        inventory_revision_id = revision_id
207
 
        bundle_tree = BundleTree(repository.revision_tree(base),
 
204
        bundle_tree = BundleTree(repository.revision_tree(base), 
208
205
                                  inventory_revision_id)
209
206
        self._update_tree(bundle_tree, revision_id)
210
207
 
211
208
        inv = bundle_tree.inventory
212
209
        self._validate_inventory(inv, revision_id)
213
 
        self._validate_revision(bundle_tree, revision_id)
 
210
        self._validate_revision(inv, revision_id)
214
211
 
215
212
        return bundle_tree
216
213
 
243
240
        for rev_info in self.revisions:
244
241
            checked[rev_info.revision_id] = True
245
242
            add_sha(rev_to_sha, rev_info.revision_id, rev_info.sha1)
246
 
 
 
243
                
247
244
        for (rev, rev_info) in zip(self.real_revisions, self.revisions):
248
245
            add_sha(inv_to_sha, rev_info.revision_id, rev_info.inventory_sha1)
249
246
 
251
248
        missing = {}
252
249
        for revision_id, sha1 in rev_to_sha.iteritems():
253
250
            if repository.has_revision(revision_id):
254
 
                testament = StrictTestament.from_revision(repository,
 
251
                testament = StrictTestament.from_revision(repository, 
255
252
                                                          revision_id)
256
253
                local_sha1 = self._testament_sha1_from_revision(repository,
257
254
                                                                revision_id)
258
255
                if sha1 != local_sha1:
259
 
                    raise BzrError('sha1 mismatch. For revision id {%s}'
 
256
                    raise BzrError('sha1 mismatch. For revision id {%s}' 
260
257
                            'local: %s, bundle: %s' % (revision_id, local_sha1, sha1))
261
258
                else:
262
259
                    count += 1
263
260
            elif revision_id not in checked:
264
261
                missing[revision_id] = sha1
265
262
 
 
263
        for inv_id, sha1 in inv_to_sha.iteritems():
 
264
            if repository.has_revision(inv_id):
 
265
                # Note: branch.get_inventory_sha1() just returns the value that
 
266
                # is stored in the revision text, and that value may be out
 
267
                # of date. This is bogus, because that means we aren't
 
268
                # validating the actual text, just that we wrote and read the
 
269
                # string. But for now, what the hell.
 
270
                local_sha1 = repository.get_inventory_sha1(inv_id)
 
271
                if sha1 != local_sha1:
 
272
                    raise BzrError('sha1 mismatch. For inventory id {%s}' 
 
273
                                   'local: %s, bundle: %s' % 
 
274
                                   (inv_id, local_sha1, sha1))
 
275
                else:
 
276
                    count += 1
 
277
 
266
278
        if len(missing) > 0:
267
279
            # I don't know if this is an error yet
268
280
            warning('Not all revision hashes could be validated.'
274
286
        """At this point we should have generated the BundleTree,
275
287
        so build up an inventory, and make sure the hashes match.
276
288
        """
 
289
 
 
290
        assert inv is not None
 
291
 
277
292
        # Now we should have a complete inventory entry.
278
293
        s = serializer_v5.write_inventory_to_string(inv)
279
294
        sha1 = sha_string(s)
280
295
        # Target revision is the last entry in the real_revisions list
281
296
        rev = self.get_revision(revision_id)
282
 
        if rev.revision_id != revision_id:
283
 
            raise AssertionError()
 
297
        assert rev.revision_id == revision_id
284
298
        if sha1 != rev.inventory_sha1:
285
 
            f = open(',,bogus-inv', 'wb')
286
 
            try:
287
 
                f.write(s)
288
 
            finally:
289
 
                f.close()
 
299
            open(',,bogus-inv', 'wb').write(s)
290
300
            warning('Inventory sha hash mismatch for revision %s. %s'
291
301
                    ' != %s' % (revision_id, sha1, rev.inventory_sha1))
292
302
 
293
 
    def _validate_revision(self, tree, revision_id):
 
303
    def _validate_revision(self, inventory, revision_id):
294
304
        """Make sure all revision entries match their checksum."""
295
305
 
296
 
        # This is a mapping from each revision id to its sha hash
 
306
        # This is a mapping from each revision id to it's sha hash
297
307
        rev_to_sha1 = {}
298
 
 
 
308
        
299
309
        rev = self.get_revision(revision_id)
300
310
        rev_info = self.get_revision_info(revision_id)
301
 
        if not (rev.revision_id == rev_info.revision_id):
302
 
            raise AssertionError()
303
 
        if not (rev.revision_id == revision_id):
304
 
            raise AssertionError()
305
 
        sha1 = self._testament_sha1(rev, tree)
 
311
        assert rev.revision_id == rev_info.revision_id
 
312
        assert rev.revision_id == revision_id
 
313
        sha1 = self._testament_sha1(rev, inventory)
306
314
        if sha1 != rev_info.sha1:
307
315
            raise TestamentMismatch(rev.revision_id, rev_info.sha1, sha1)
308
316
        if rev.revision_id in rev_to_sha1:
335
343
                try:
336
344
                    name, value = info_item.split(':', 1)
337
345
                except ValueError:
338
 
                    raise ValueError('Value %r has no colon' % info_item)
 
346
                    raise 'Value %r has no colon' % info_item
339
347
                if name == 'last-changed':
340
348
                    last_changed = value
341
349
                elif name == 'executable':
 
350
                    assert value in ('yes', 'no'), value
342
351
                    val = (value == 'yes')
343
352
                    bundle_tree.note_executable(new_path, val)
344
353
                elif name == 'target':
348
357
            return last_changed, encoding
349
358
 
350
359
        def do_patch(path, lines, encoding):
351
 
            if encoding == 'base64':
 
360
            if encoding is not None:
 
361
                assert encoding == 'base64'
352
362
                patch = base64.decodestring(''.join(lines))
353
 
            elif encoding is None:
 
363
            else:
354
364
                patch =  ''.join(lines)
355
 
            else:
356
 
                raise ValueError(encoding)
357
365
            bundle_tree.note_patch(path, patch)
358
366
 
359
367
        def renamed(kind, extra, lines):
419
427
            revision = get_rev_id(last_modified, path, kind)
420
428
            if lines:
421
429
                do_patch(path, lines, encoding)
422
 
 
 
430
            
423
431
        valid_actions = {
424
432
            'renamed':renamed,
425
433
            'removed':removed,
466
474
 
467
475
 
468
476
class BundleTree(Tree):
469
 
 
470
477
    def __init__(self, base_tree, revision_id):
471
478
        self.base_tree = base_tree
472
479
        self._renamed = {} # Mapping from old_path => new_path
488
495
 
489
496
    def note_rename(self, old_path, new_path):
490
497
        """A file/directory has been renamed from old_path => new_path"""
491
 
        if new_path in self._renamed:
492
 
            raise AssertionError(new_path)
493
 
        if old_path in self._renamed_r:
494
 
            raise AssertionError(old_path)
 
498
        assert new_path not in self._renamed
 
499
        assert old_path not in self._renamed_r
495
500
        self._renamed[new_path] = old_path
496
501
        self._renamed_r[old_path] = new_path
497
502
 
527
532
 
528
533
    def old_path(self, new_path):
529
534
        """Get the old_path (path in the base_tree) for the file at new_path"""
530
 
        if new_path[:1] in ('\\', '/'):
531
 
            raise ValueError(new_path)
 
535
        assert new_path[:1] not in ('\\', '/')
532
536
        old_path = self._renamed.get(new_path)
533
537
        if old_path is not None:
534
538
            return old_path
548
552
        #renamed_r
549
553
        if old_path in self._renamed_r:
550
554
            return None
551
 
        return old_path
 
555
        return old_path 
552
556
 
553
557
    def new_path(self, old_path):
554
558
        """Get the new_path (path in the target_tree) for the file at old_path
555
559
        in the base tree.
556
560
        """
557
 
        if old_path[:1] in ('\\', '/'):
558
 
            raise ValueError(old_path)
 
561
        assert old_path[:1] not in ('\\', '/')
559
562
        new_path = self._renamed_r.get(old_path)
560
563
        if new_path is not None:
561
564
            return new_path
574
577
        #renamed_r
575
578
        if new_path in self._renamed:
576
579
            return None
577
 
        return new_path
578
 
 
579
 
    def get_root_id(self):
580
 
        return self.path2id('')
 
580
        return new_path 
581
581
 
582
582
    def path2id(self, path):
583
583
        """Return the id of the file present at path in the target tree."""
589
589
            return None
590
590
        if old_path in self.deleted:
591
591
            return None
592
 
        return self.base_tree.path2id(old_path)
 
592
        if getattr(self.base_tree, 'path2id', None) is not None:
 
593
            return self.base_tree.path2id(old_path)
 
594
        else:
 
595
            return self.base_tree.inventory.path2id(old_path)
593
596
 
594
597
    def id2path(self, file_id):
595
598
        """Return the new path in the target tree of the file with id file_id"""
614
617
                return None
615
618
        new_path = self.id2path(file_id)
616
619
        return self.base_tree.path2id(new_path)
617
 
 
 
620
        
618
621
    def get_file(self, file_id):
619
622
        """Return a file-like object containing the new contents of the
620
623
        file given by file_id.
625
628
        """
626
629
        base_id = self.old_contents_id(file_id)
627
630
        if (base_id is not None and
628
 
            base_id != self.base_tree.get_root_id()):
 
631
            base_id != self.base_tree.inventory.root.file_id):
629
632
            patch_original = self.base_tree.get_file(base_id)
630
633
        else:
631
634
            patch_original = None
632
635
        file_patch = self.patches.get(self.id2path(file_id))
633
636
        if file_patch is None:
634
 
            if (patch_original is None and
635
 
                self.kind(file_id) == 'directory'):
 
637
            if (patch_original is None and 
 
638
                self.get_kind(file_id) == 'directory'):
636
639
                return StringIO()
637
 
            if patch_original is None:
638
 
                raise AssertionError("None: %s" % file_id)
 
640
            assert patch_original is not None, "None: %s" % file_id
639
641
            return patch_original
640
642
 
641
 
        if file_patch.startswith('\\'):
642
 
            raise ValueError(
643
 
                'Malformed patch for %s, %r' % (file_id, file_patch))
 
643
        assert not file_patch.startswith('\\'), \
 
644
            'Malformed patch for %s, %r' % (file_id, file_patch)
644
645
        return patched_file(file_patch, patch_original)
645
646
 
646
 
    def get_symlink_target(self, file_id, path=None):
647
 
        if path is None:
648
 
            path = self.id2path(file_id)
 
647
    def get_symlink_target(self, file_id):
 
648
        new_path = self.id2path(file_id)
649
649
        try:
650
 
            return self._targets[path]
 
650
            return self._targets[new_path]
651
651
        except KeyError:
652
652
            return self.base_tree.get_symlink_target(file_id)
653
653
 
654
 
    def kind(self, file_id):
 
654
    def get_kind(self, file_id):
655
655
        if file_id in self._kinds:
656
656
            return self._kinds[file_id]
657
 
        return self.base_tree.kind(file_id)
658
 
 
659
 
    def get_file_revision(self, file_id):
660
 
        path = self.id2path(file_id)
661
 
        if path in self._last_changed:
662
 
            return self._last_changed[path]
663
 
        else:
664
 
            return self.base_tree.get_file_revision(file_id)
 
657
        return self.base_tree.inventory[file_id].kind
665
658
 
666
659
    def is_executable(self, file_id):
667
660
        path = self.id2path(file_id)
668
661
        if path in self._executable:
669
662
            return self._executable[path]
670
663
        else:
671
 
            return self.base_tree.is_executable(file_id)
 
664
            return self.base_tree.inventory[file_id].executable
672
665
 
673
666
    def get_last_changed(self, file_id):
674
667
        path = self.id2path(file_id)
675
668
        if path in self._last_changed:
676
669
            return self._last_changed[path]
677
 
        return self.base_tree.get_file_revision(file_id)
 
670
        return self.base_tree.inventory[file_id].revision
678
671
 
679
672
    def get_size_and_sha1(self, file_id):
680
673
        """Return the size and sha1 hash of the given file id.
687
680
        if new_path not in self.patches:
688
681
            # If the entry does not have a patch, then the
689
682
            # contents must be the same as in the base_tree
690
 
            text_size = self.base_tree.get_file_size(file_id)
691
 
            text_sha1 = self.base_tree.get_file_sha1(file_id)
692
 
            return text_size, text_sha1
 
683
            ie = self.base_tree.inventory[file_id]
 
684
            if ie.text_size is None:
 
685
                return ie.text_size, ie.text_sha1
 
686
            return int(ie.text_size), ie.text_sha1
693
687
        fileobj = self.get_file(file_id)
694
688
        content = fileobj.read()
695
689
        return len(content), sha_string(content)
700
694
        This need to be called before ever accessing self.inventory
701
695
        """
702
696
        from os.path import dirname, basename
 
697
 
 
698
        assert self.base_tree is not None
 
699
        base_inv = self.base_tree.inventory
703
700
        inv = Inventory(None, self.revision_id)
704
701
 
705
702
        def add_entry(file_id):
712
709
                parent_path = dirname(path)
713
710
                parent_id = self.path2id(parent_path)
714
711
 
715
 
            kind = self.kind(file_id)
 
712
            kind = self.get_kind(file_id)
716
713
            revision_id = self.get_last_changed(file_id)
717
714
 
718
715
            name = basename(path)
723
720
                ie.executable = self.is_executable(file_id)
724
721
            elif kind == 'symlink':
725
722
                ie = InventoryLink(file_id, name, parent_id)
726
 
                ie.symlink_target = self.get_symlink_target(file_id, path)
 
723
                ie.symlink_target = self.get_symlink_target(file_id)
727
724
            ie.revision = revision_id
728
725
 
729
 
            if kind == 'file':
 
726
            if kind in ('directory', 'symlink'):
 
727
                ie.text_size, ie.text_sha1 = None, None
 
728
            else:
730
729
                ie.text_size, ie.text_sha1 = self.get_size_and_sha1(file_id)
731
 
                if ie.text_size is None:
732
 
                    raise BzrError(
733
 
                        'Got a text_size of None for file_id %r' % file_id)
 
730
            if (ie.text_size is None) and (kind == 'file'):
 
731
                raise BzrError('Got a text_size of None for file_id %r' % file_id)
734
732
            inv.add(ie)
735
733
 
736
734
        sorted_entries = self.sorted_path_id()
746
744
    # at that instant
747
745
    inventory = property(_get_inventory)
748
746
 
749
 
    root_inventory = property(_get_inventory)
750
 
 
751
 
    def all_file_ids(self):
752
 
        return set(
753
 
            [entry.file_id for path, entry in self.inventory.iter_entries()])
754
 
 
755
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
756
 
        # The only files returned by this are those from the version
757
 
        inv = self.inventory
758
 
        if from_dir is None:
759
 
            from_dir_id = None
760
 
        else:
761
 
            from_dir_id = inv.path2id(from_dir)
762
 
            if from_dir_id is None:
763
 
                # Directory not versioned
764
 
                return
765
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
766
 
        if inv.root is not None and not include_root and from_dir is None:
767
 
            # skip the root for compatability with the current apis.
768
 
            entries.next()
769
 
        for path, entry in entries:
770
 
            yield path, 'V', entry.kind, entry.file_id, entry
 
747
    def __iter__(self):
 
748
        for path, entry in self.inventory.iter_entries():
 
749
            yield entry.file_id
771
750
 
772
751
    def sorted_path_id(self):
773
752
        paths = []
774
753
        for result in self._new_id.iteritems():
775
754
            paths.append(result)
776
 
        for id in self.base_tree.all_file_ids():
 
755
        for id in self.base_tree:
777
756
            path = self.id2path(id)
778
757
            if path is None:
779
758
                continue