← 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: Canonical.com Patch Queue Manager
  • Date: 2008-09-02 06:24:16 UTC
  • mfrom: (3635.1.3 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080902062416-dxdxccqki90bcynl
(robertc) Fix repack operations on SMB connections. (Robert Collins,
        bug 255656).

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
 
163
159
    def get_base(self, revision):
164
160
        revision_info = self.get_revision_info(revision.revision_id)
165
161
        if revision_info.base_id is not None:
166
 
            return revision_info.base_id
 
162
            if revision_info.base_id == NULL_REVISION:
 
163
                return None
 
164
            else:
 
165
                return revision_info.base_id
167
166
        if len(revision.parent_ids) == 0:
168
167
            # There is no base listed, and
169
168
            # the lowest revision doesn't have a parent
170
169
            # so this is probably against the empty tree
171
 
            # and thus base truly is NULL_REVISION
172
 
            return NULL_REVISION
 
170
            # and thus base truly is None
 
171
            return None
173
172
        else:
174
173
            return revision.parent_ids[-1]
175
174
 
204
203
            self._validate_references_from_repository(repository)
205
204
        revision_info = self.get_revision_info(revision_id)
206
205
        inventory_revision_id = revision_id
207
 
        bundle_tree = BundleTree(repository.revision_tree(base),
 
206
        bundle_tree = BundleTree(repository.revision_tree(base), 
208
207
                                  inventory_revision_id)
209
208
        self._update_tree(bundle_tree, revision_id)
210
209
 
211
210
        inv = bundle_tree.inventory
212
211
        self._validate_inventory(inv, revision_id)
213
 
        self._validate_revision(bundle_tree, revision_id)
 
212
        self._validate_revision(inv, revision_id)
214
213
 
215
214
        return bundle_tree
216
215
 
243
242
        for rev_info in self.revisions:
244
243
            checked[rev_info.revision_id] = True
245
244
            add_sha(rev_to_sha, rev_info.revision_id, rev_info.sha1)
246
 
 
 
245
                
247
246
        for (rev, rev_info) in zip(self.real_revisions, self.revisions):
248
247
            add_sha(inv_to_sha, rev_info.revision_id, rev_info.inventory_sha1)
249
248
 
251
250
        missing = {}
252
251
        for revision_id, sha1 in rev_to_sha.iteritems():
253
252
            if repository.has_revision(revision_id):
254
 
                testament = StrictTestament.from_revision(repository,
 
253
                testament = StrictTestament.from_revision(repository, 
255
254
                                                          revision_id)
256
255
                local_sha1 = self._testament_sha1_from_revision(repository,
257
256
                                                                revision_id)
258
257
                if sha1 != local_sha1:
259
 
                    raise BzrError('sha1 mismatch. For revision id {%s}'
 
258
                    raise BzrError('sha1 mismatch. For revision id {%s}' 
260
259
                            'local: %s, bundle: %s' % (revision_id, local_sha1, sha1))
261
260
                else:
262
261
                    count += 1
282
281
        if rev.revision_id != revision_id:
283
282
            raise AssertionError()
284
283
        if sha1 != rev.inventory_sha1:
285
 
            f = open(',,bogus-inv', 'wb')
286
 
            try:
287
 
                f.write(s)
288
 
            finally:
289
 
                f.close()
 
284
            open(',,bogus-inv', 'wb').write(s)
290
285
            warning('Inventory sha hash mismatch for revision %s. %s'
291
286
                    ' != %s' % (revision_id, sha1, rev.inventory_sha1))
292
287
 
293
 
    def _validate_revision(self, tree, revision_id):
 
288
    def _validate_revision(self, inventory, revision_id):
294
289
        """Make sure all revision entries match their checksum."""
295
290
 
296
 
        # This is a mapping from each revision id to its sha hash
 
291
        # This is a mapping from each revision id to it's sha hash
297
292
        rev_to_sha1 = {}
298
 
 
 
293
        
299
294
        rev = self.get_revision(revision_id)
300
295
        rev_info = self.get_revision_info(revision_id)
301
296
        if not (rev.revision_id == rev_info.revision_id):
302
297
            raise AssertionError()
303
298
        if not (rev.revision_id == revision_id):
304
299
            raise AssertionError()
305
 
        sha1 = self._testament_sha1(rev, tree)
 
300
        sha1 = self._testament_sha1(rev, inventory)
306
301
        if sha1 != rev_info.sha1:
307
302
            raise TestamentMismatch(rev.revision_id, rev_info.sha1, sha1)
308
303
        if rev.revision_id in rev_to_sha1:
335
330
                try:
336
331
                    name, value = info_item.split(':', 1)
337
332
                except ValueError:
338
 
                    raise ValueError('Value %r has no colon' % info_item)
 
333
                    raise 'Value %r has no colon' % info_item
339
334
                if name == 'last-changed':
340
335
                    last_changed = value
341
336
                elif name == 'executable':
419
414
            revision = get_rev_id(last_modified, path, kind)
420
415
            if lines:
421
416
                do_patch(path, lines, encoding)
422
 
 
 
417
            
423
418
        valid_actions = {
424
419
            'renamed':renamed,
425
420
            'removed':removed,
466
461
 
467
462
 
468
463
class BundleTree(Tree):
469
 
 
470
464
    def __init__(self, base_tree, revision_id):
471
465
        self.base_tree = base_tree
472
466
        self._renamed = {} # Mapping from old_path => new_path
548
542
        #renamed_r
549
543
        if old_path in self._renamed_r:
550
544
            return None
551
 
        return old_path
 
545
        return old_path 
552
546
 
553
547
    def new_path(self, old_path):
554
548
        """Get the new_path (path in the target_tree) for the file at old_path
574
568
        #renamed_r
575
569
        if new_path in self._renamed:
576
570
            return None
577
 
        return new_path
578
 
 
579
 
    def get_root_id(self):
580
 
        return self.path2id('')
 
571
        return new_path 
581
572
 
582
573
    def path2id(self, path):
583
574
        """Return the id of the file present at path in the target tree."""
589
580
            return None
590
581
        if old_path in self.deleted:
591
582
            return None
592
 
        return self.base_tree.path2id(old_path)
 
583
        if getattr(self.base_tree, 'path2id', None) is not None:
 
584
            return self.base_tree.path2id(old_path)
 
585
        else:
 
586
            return self.base_tree.inventory.path2id(old_path)
593
587
 
594
588
    def id2path(self, file_id):
595
589
        """Return the new path in the target tree of the file with id file_id"""
614
608
                return None
615
609
        new_path = self.id2path(file_id)
616
610
        return self.base_tree.path2id(new_path)
617
 
 
 
611
        
618
612
    def get_file(self, file_id):
619
613
        """Return a file-like object containing the new contents of the
620
614
        file given by file_id.
625
619
        """
626
620
        base_id = self.old_contents_id(file_id)
627
621
        if (base_id is not None and
628
 
            base_id != self.base_tree.get_root_id()):
 
622
            base_id != self.base_tree.inventory.root.file_id):
629
623
            patch_original = self.base_tree.get_file(base_id)
630
624
        else:
631
625
            patch_original = None
632
626
        file_patch = self.patches.get(self.id2path(file_id))
633
627
        if file_patch is None:
634
 
            if (patch_original is None and
635
 
                self.kind(file_id) == 'directory'):
 
628
            if (patch_original is None and 
 
629
                self.get_kind(file_id) == 'directory'):
636
630
                return StringIO()
637
631
            if patch_original is None:
638
632
                raise AssertionError("None: %s" % file_id)
643
637
                'Malformed patch for %s, %r' % (file_id, file_patch))
644
638
        return patched_file(file_patch, patch_original)
645
639
 
646
 
    def get_symlink_target(self, file_id, path=None):
647
 
        if path is None:
648
 
            path = self.id2path(file_id)
 
640
    def get_symlink_target(self, file_id):
 
641
        new_path = self.id2path(file_id)
649
642
        try:
650
 
            return self._targets[path]
 
643
            return self._targets[new_path]
651
644
        except KeyError:
652
645
            return self.base_tree.get_symlink_target(file_id)
653
646
 
654
 
    def kind(self, file_id):
 
647
    def get_kind(self, file_id):
655
648
        if file_id in self._kinds:
656
649
            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)
 
650
        return self.base_tree.inventory[file_id].kind
665
651
 
666
652
    def is_executable(self, file_id):
667
653
        path = self.id2path(file_id)
668
654
        if path in self._executable:
669
655
            return self._executable[path]
670
656
        else:
671
 
            return self.base_tree.is_executable(file_id)
 
657
            return self.base_tree.inventory[file_id].executable
672
658
 
673
659
    def get_last_changed(self, file_id):
674
660
        path = self.id2path(file_id)
675
661
        if path in self._last_changed:
676
662
            return self._last_changed[path]
677
 
        return self.base_tree.get_file_revision(file_id)
 
663
        return self.base_tree.inventory[file_id].revision
678
664
 
679
665
    def get_size_and_sha1(self, file_id):
680
666
        """Return the size and sha1 hash of the given file id.
687
673
        if new_path not in self.patches:
688
674
            # If the entry does not have a patch, then the
689
675
            # 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
 
676
            ie = self.base_tree.inventory[file_id]
 
677
            if ie.text_size is None:
 
678
                return ie.text_size, ie.text_sha1
 
679
            return int(ie.text_size), ie.text_sha1
693
680
        fileobj = self.get_file(file_id)
694
681
        content = fileobj.read()
695
682
        return len(content), sha_string(content)
700
687
        This need to be called before ever accessing self.inventory
701
688
        """
702
689
        from os.path import dirname, basename
 
690
        base_inv = self.base_tree.inventory
703
691
        inv = Inventory(None, self.revision_id)
704
692
 
705
693
        def add_entry(file_id):
712
700
                parent_path = dirname(path)
713
701
                parent_id = self.path2id(parent_path)
714
702
 
715
 
            kind = self.kind(file_id)
 
703
            kind = self.get_kind(file_id)
716
704
            revision_id = self.get_last_changed(file_id)
717
705
 
718
706
            name = basename(path)
723
711
                ie.executable = self.is_executable(file_id)
724
712
            elif kind == 'symlink':
725
713
                ie = InventoryLink(file_id, name, parent_id)
726
 
                ie.symlink_target = self.get_symlink_target(file_id, path)
 
714
                ie.symlink_target = self.get_symlink_target(file_id)
727
715
            ie.revision = revision_id
728
716
 
729
 
            if kind == 'file':
 
717
            if kind in ('directory', 'symlink'):
 
718
                ie.text_size, ie.text_sha1 = None, None
 
719
            else:
730
720
                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)
 
721
            if (ie.text_size is None) and (kind == 'file'):
 
722
                raise BzrError('Got a text_size of None for file_id %r' % file_id)
734
723
            inv.add(ie)
735
724
 
736
725
        sorted_entries = self.sorted_path_id()
746
735
    # at that instant
747
736
    inventory = property(_get_inventory)
748
737
 
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
 
738
    def __iter__(self):
 
739
        for path, entry in self.inventory.iter_entries():
 
740
            yield entry.file_id
771
741
 
772
742
    def sorted_path_id(self):
773
743
        paths = []
774
744
        for result in self._new_id.iteritems():
775
745
            paths.append(result)
776
 
        for id in self.base_tree.all_file_ids():
 
746
        for id in self.base_tree:
777
747
            path = self.id2path(id)
778
748
            if path is None:
779
749
                continue