← 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: Florent Gallaire
  • Date: 2017-03-17 10:39:02 UTC
  • mto: This revision was merged to the branch mainline in revision 6622.
  • Revision ID: fgallaire@gmail.com-20170317103902-xsmafws9vn8rczx9
Fix for Windows and 32-bit platforms buggy gmtime().

Show diffs side-by-side

added added

removed removed

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