← 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: 2011-05-04 12:10:51 UTC
  • mfrom: (5819.1.4 777007-developer-doc)
  • Revision ID: pqm@pqm.ubuntu.com-20110504121051-aovlsmqiivjmc4fc
(jelmer) Small fixes to developer documentation. (Jonathan Riddell)

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
 
21
21
import os
22
22
import pprint
23
23
 
24
 
import bzrlib.errors
25
 
from bzrlib.errors import (TestamentMismatch, BzrError, 
26
 
                           MalformedHeader, MalformedPatches, NotABundle)
27
 
from bzrlib.inventory import (Inventory, InventoryEntry,
28
 
                              InventoryDirectory, InventoryFile,
29
 
                              InventoryLink)
30
 
from bzrlib.osutils import sha_file, sha_string, pathjoin
 
24
from bzrlib import (
 
25
    osutils,
 
26
    timestamp,
 
27
    )
 
28
from bzrlib.bundle import apply_bundle
 
29
from bzrlib.errors import (
 
30
    TestamentMismatch,
 
31
    BzrError,
 
32
    )
 
33
from bzrlib.inventory import (
 
34
    Inventory,
 
35
    InventoryDirectory,
 
36
    InventoryFile,
 
37
    InventoryLink,
 
38
    )
 
39
from bzrlib.osutils import sha_string, pathjoin
31
40
from bzrlib.revision import Revision, NULL_REVISION
32
41
from bzrlib.testament import StrictTestament
33
42
from bzrlib.trace import mutter, warning
34
 
import bzrlib.transport
35
43
from bzrlib.tree import Tree
36
 
import bzrlib.urlutils
37
44
from bzrlib.xml5 import serializer_v5
38
45
 
39
46
 
72
79
        if self.properties:
73
80
            for property in self.properties:
74
81
                key_end = property.find(': ')
75
 
                assert key_end is not None
76
 
                key = property[:key_end].encode('utf-8')
77
 
                value = property[key_end+2:].encode('utf-8')
 
82
                if key_end == -1:
 
83
                    if not property.endswith(':'):
 
84
                        raise ValueError(property)
 
85
                    key = str(property[:-1])
 
86
                    value = ''
 
87
                else:
 
88
                    key = str(property[:key_end])
 
89
                    value = property[key_end+2:]
78
90
                rev.properties[key] = value
79
91
 
80
92
        return rev
81
93
 
 
94
    @staticmethod
 
95
    def from_revision(revision):
 
96
        revision_info = RevisionInfo(revision.revision_id)
 
97
        date = timestamp.format_highres_date(revision.timestamp,
 
98
                                             revision.timezone)
 
99
        revision_info.date = date
 
100
        revision_info.timezone = revision.timezone
 
101
        revision_info.timestamp = revision.timestamp
 
102
        revision_info.message = revision.message.split('\n')
 
103
        revision_info.properties = [': '.join(p) for p in
 
104
                                    revision.properties.iteritems()]
 
105
        return revision_info
 
106
 
82
107
 
83
108
class BundleInfo(object):
84
109
    """This contains the meta information. Stuff that allows you to
85
110
    recreate the revision or inventory XML.
86
111
    """
87
 
    def __init__(self):
 
112
    def __init__(self, bundle_format=None):
 
113
        self.bundle_format = None
88
114
        self.committer = None
89
115
        self.date = None
90
116
        self.message = None
101
127
        self.timestamp = None
102
128
        self.timezone = None
103
129
 
 
130
        # Have we checked the repository yet?
 
131
        self._validated_revisions_against_repo = False
 
132
 
104
133
    def __str__(self):
105
134
        return pprint.pformat(self.__dict__)
106
135
 
109
138
        split up, based on the assumptions that can be made
110
139
        when information is missing.
111
140
        """
112
 
        from bzrlib.bundle.serializer import unpack_highres_date
 
141
        from bzrlib.timestamp import unpack_highres_date
113
142
        # Put in all of the guessable information.
114
143
        if not self.timestamp and self.date:
115
144
            self.timestamp, self.timezone = unpack_highres_date(self.date)
132
161
    def get_base(self, revision):
133
162
        revision_info = self.get_revision_info(revision.revision_id)
134
163
        if revision_info.base_id is not None:
135
 
            if revision_info.base_id == NULL_REVISION:
136
 
                return None
137
 
            else:
138
 
                return revision_info.base_id
 
164
            return revision_info.base_id
139
165
        if len(revision.parent_ids) == 0:
140
166
            # There is no base listed, and
141
167
            # the lowest revision doesn't have a parent
142
168
            # so this is probably against the empty tree
143
 
            # and thus base truly is None
144
 
            return None
 
169
            # and thus base truly is NULL_REVISION
 
170
            return NULL_REVISION
145
171
        else:
146
172
            return revision.parent_ids[-1]
147
173
 
170
196
    def revision_tree(self, repository, revision_id, base=None):
171
197
        revision = self.get_revision(revision_id)
172
198
        base = self.get_base(revision)
173
 
        assert base != revision_id
174
 
        self._validate_references_from_repository(repository)
 
199
        if base == revision_id:
 
200
            raise AssertionError()
 
201
        if not self._validated_revisions_against_repo:
 
202
            self._validate_references_from_repository(repository)
175
203
        revision_info = self.get_revision_info(revision_id)
176
204
        inventory_revision_id = revision_id
177
 
        bundle_tree = BundleTree(repository.revision_tree(base), 
 
205
        bundle_tree = BundleTree(repository.revision_tree(base),
178
206
                                  inventory_revision_id)
179
207
        self._update_tree(bundle_tree, revision_id)
180
208
 
181
209
        inv = bundle_tree.inventory
182
210
        self._validate_inventory(inv, revision_id)
183
 
        self._validate_revision(inv, revision_id)
 
211
        self._validate_revision(bundle_tree, revision_id)
184
212
 
185
213
        return bundle_tree
186
214
 
213
241
        for rev_info in self.revisions:
214
242
            checked[rev_info.revision_id] = True
215
243
            add_sha(rev_to_sha, rev_info.revision_id, rev_info.sha1)
216
 
                
 
244
 
217
245
        for (rev, rev_info) in zip(self.real_revisions, self.revisions):
218
246
            add_sha(inv_to_sha, rev_info.revision_id, rev_info.inventory_sha1)
219
247
 
221
249
        missing = {}
222
250
        for revision_id, sha1 in rev_to_sha.iteritems():
223
251
            if repository.has_revision(revision_id):
224
 
                testament = StrictTestament.from_revision(repository, 
 
252
                testament = StrictTestament.from_revision(repository,
225
253
                                                          revision_id)
226
254
                local_sha1 = self._testament_sha1_from_revision(repository,
227
255
                                                                revision_id)
228
256
                if sha1 != local_sha1:
229
 
                    raise BzrError('sha1 mismatch. For revision id {%s}' 
 
257
                    raise BzrError('sha1 mismatch. For revision id {%s}'
230
258
                            'local: %s, bundle: %s' % (revision_id, local_sha1, sha1))
231
259
                else:
232
260
                    count += 1
233
261
            elif revision_id not in checked:
234
262
                missing[revision_id] = sha1
235
263
 
236
 
        for inv_id, sha1 in inv_to_sha.iteritems():
237
 
            if repository.has_revision(inv_id):
238
 
                # Note: branch.get_inventory_sha1() just returns the value that
239
 
                # is stored in the revision text, and that value may be out
240
 
                # of date. This is bogus, because that means we aren't
241
 
                # validating the actual text, just that we wrote and read the
242
 
                # string. But for now, what the hell.
243
 
                local_sha1 = repository.get_inventory_sha1(inv_id)
244
 
                if sha1 != local_sha1:
245
 
                    raise BzrError('sha1 mismatch. For inventory id {%s}' 
246
 
                                   'local: %s, bundle: %s' % 
247
 
                                   (inv_id, local_sha1, sha1))
248
 
                else:
249
 
                    count += 1
250
 
 
251
264
        if len(missing) > 0:
252
265
            # I don't know if this is an error yet
253
266
            warning('Not all revision hashes could be validated.'
254
267
                    ' Unable validate %d hashes' % len(missing))
255
268
        mutter('Verified %d sha hashes for the bundle.' % count)
 
269
        self._validated_revisions_against_repo = True
256
270
 
257
271
    def _validate_inventory(self, inv, revision_id):
258
272
        """At this point we should have generated the BundleTree,
259
273
        so build up an inventory, and make sure the hashes match.
260
274
        """
261
 
 
262
 
        assert inv is not None
263
 
 
264
275
        # Now we should have a complete inventory entry.
265
276
        s = serializer_v5.write_inventory_to_string(inv)
266
277
        sha1 = sha_string(s)
267
278
        # Target revision is the last entry in the real_revisions list
268
279
        rev = self.get_revision(revision_id)
269
 
        assert rev.revision_id == revision_id
 
280
        if rev.revision_id != revision_id:
 
281
            raise AssertionError()
270
282
        if sha1 != rev.inventory_sha1:
271
 
            open(',,bogus-inv', 'wb').write(s)
 
283
            f = open(',,bogus-inv', 'wb')
 
284
            try:
 
285
                f.write(s)
 
286
            finally:
 
287
                f.close()
272
288
            warning('Inventory sha hash mismatch for revision %s. %s'
273
289
                    ' != %s' % (revision_id, sha1, rev.inventory_sha1))
274
290
 
275
 
    def _validate_revision(self, inventory, revision_id):
 
291
    def _validate_revision(self, tree, revision_id):
276
292
        """Make sure all revision entries match their checksum."""
277
293
 
278
 
        # This is a mapping from each revision id to it's sha hash
 
294
        # This is a mapping from each revision id to its sha hash
279
295
        rev_to_sha1 = {}
280
 
        
 
296
 
281
297
        rev = self.get_revision(revision_id)
282
298
        rev_info = self.get_revision_info(revision_id)
283
 
        assert rev.revision_id == rev_info.revision_id
284
 
        assert rev.revision_id == revision_id
285
 
        sha1 = self._testament_sha1(rev, inventory)
 
299
        if not (rev.revision_id == rev_info.revision_id):
 
300
            raise AssertionError()
 
301
        if not (rev.revision_id == revision_id):
 
302
            raise AssertionError()
 
303
        sha1 = self._testament_sha1(rev, tree)
286
304
        if sha1 != rev_info.sha1:
287
305
            raise TestamentMismatch(rev.revision_id, rev_info.sha1, sha1)
288
306
        if rev.revision_id in rev_to_sha1:
299
317
 
300
318
        def get_rev_id(last_changed, path, kind):
301
319
            if last_changed is not None:
302
 
                changed_revision_id = last_changed.decode('utf-8')
 
320
                # last_changed will be a Unicode string because of how it was
 
321
                # read. Convert it back to utf8.
 
322
                changed_revision_id = osutils.safe_revision_id(last_changed,
 
323
                                                               warn=False)
303
324
            else:
304
325
                changed_revision_id = revision_id
305
326
            bundle_tree.note_last_changed(path, changed_revision_id)
312
333
                try:
313
334
                    name, value = info_item.split(':', 1)
314
335
                except ValueError:
315
 
                    raise 'Value %r has no colon' % info_item
 
336
                    raise ValueError('Value %r has no colon' % info_item)
316
337
                if name == 'last-changed':
317
338
                    last_changed = value
318
339
                elif name == 'executable':
319
 
                    assert value in ('yes', 'no'), value
320
340
                    val = (value == 'yes')
321
341
                    bundle_tree.note_executable(new_path, val)
322
342
                elif name == 'target':
326
346
            return last_changed, encoding
327
347
 
328
348
        def do_patch(path, lines, encoding):
329
 
            if encoding is not None:
330
 
                assert encoding == 'base64'
 
349
            if encoding == 'base64':
331
350
                patch = base64.decodestring(''.join(lines))
332
 
            else:
 
351
            elif encoding is None:
333
352
                patch =  ''.join(lines)
 
353
            else:
 
354
                raise ValueError(encoding)
334
355
            bundle_tree.note_patch(path, patch)
335
356
 
336
357
        def renamed(kind, extra, lines):
372
393
            if not info[1].startswith('file-id:'):
373
394
                raise BzrError('The file-id should follow the path for an add'
374
395
                        ': %r' % extra)
375
 
            file_id = info[1][8:]
 
396
            # This will be Unicode because of how the stream is read. Turn it
 
397
            # back into a utf8 file_id
 
398
            file_id = osutils.safe_file_id(info[1][8:], warn=False)
376
399
 
377
400
            bundle_tree.note_id(file_id, path, kind)
378
401
            # this will be overridden in extra_info if executable is specified.
394
417
            revision = get_rev_id(last_modified, path, kind)
395
418
            if lines:
396
419
                do_patch(path, lines, encoding)
397
 
            
 
420
 
398
421
        valid_actions = {
399
422
            'renamed':renamed,
400
423
            'removed':removed,
423
446
                        ' (unrecognized action): %r' % action_line)
424
447
            valid_actions[action](kind, extra, lines)
425
448
 
 
449
    def install_revisions(self, target_repo, stream_input=True):
 
450
        """Install revisions and return the target revision
 
451
 
 
452
        :param target_repo: The repository to install into
 
453
        :param stream_input: Ignored by this implementation.
 
454
        """
 
455
        apply_bundle.install_bundle(target_repo, self)
 
456
        return self.target
 
457
 
 
458
    def get_merge_request(self, target_repo):
 
459
        """Provide data for performing a merge
 
460
 
 
461
        Returns suggested base, suggested target, and patch verification status
 
462
        """
 
463
        return None, self.target, 'inapplicable'
 
464
 
426
465
 
427
466
class BundleTree(Tree):
 
467
 
428
468
    def __init__(self, base_tree, revision_id):
429
469
        self.base_tree = base_tree
430
470
        self._renamed = {} # Mapping from old_path => new_path
446
486
 
447
487
    def note_rename(self, old_path, new_path):
448
488
        """A file/directory has been renamed from old_path => new_path"""
449
 
        assert new_path not in self._renamed
450
 
        assert old_path not in self._renamed_r
 
489
        if new_path in self._renamed:
 
490
            raise AssertionError(new_path)
 
491
        if old_path in self._renamed_r:
 
492
            raise AssertionError(old_path)
451
493
        self._renamed[new_path] = old_path
452
494
        self._renamed_r[old_path] = new_path
453
495
 
483
525
 
484
526
    def old_path(self, new_path):
485
527
        """Get the old_path (path in the base_tree) for the file at new_path"""
486
 
        assert new_path[:1] not in ('\\', '/')
 
528
        if new_path[:1] in ('\\', '/'):
 
529
            raise ValueError(new_path)
487
530
        old_path = self._renamed.get(new_path)
488
531
        if old_path is not None:
489
532
            return old_path
503
546
        #renamed_r
504
547
        if old_path in self._renamed_r:
505
548
            return None
506
 
        return old_path 
 
549
        return old_path
507
550
 
508
551
    def new_path(self, old_path):
509
552
        """Get the new_path (path in the target_tree) for the file at old_path
510
553
        in the base tree.
511
554
        """
512
 
        assert old_path[:1] not in ('\\', '/')
 
555
        if old_path[:1] in ('\\', '/'):
 
556
            raise ValueError(old_path)
513
557
        new_path = self._renamed_r.get(old_path)
514
558
        if new_path is not None:
515
559
            return new_path
528
572
        #renamed_r
529
573
        if new_path in self._renamed:
530
574
            return None
531
 
        return new_path 
 
575
        return new_path
532
576
 
533
577
    def path2id(self, path):
534
578
        """Return the id of the file present at path in the target tree."""
568
612
                return None
569
613
        new_path = self.id2path(file_id)
570
614
        return self.base_tree.path2id(new_path)
571
 
        
 
615
 
572
616
    def get_file(self, file_id):
573
617
        """Return a file-like object containing the new contents of the
574
618
        file given by file_id.
585
629
            patch_original = None
586
630
        file_patch = self.patches.get(self.id2path(file_id))
587
631
        if file_patch is None:
588
 
            if (patch_original is None and 
 
632
            if (patch_original is None and
589
633
                self.get_kind(file_id) == 'directory'):
590
634
                return StringIO()
591
 
            assert patch_original is not None, "None: %s" % file_id
 
635
            if patch_original is None:
 
636
                raise AssertionError("None: %s" % file_id)
592
637
            return patch_original
593
638
 
594
 
        assert not file_patch.startswith('\\'), \
595
 
            'Malformed patch for %s, %r' % (file_id, file_patch)
 
639
        if file_patch.startswith('\\'):
 
640
            raise ValueError(
 
641
                'Malformed patch for %s, %r' % (file_id, file_patch))
596
642
        return patched_file(file_patch, patch_original)
597
643
 
598
644
    def get_symlink_target(self, file_id):
618
664
        path = self.id2path(file_id)
619
665
        if path in self._last_changed:
620
666
            return self._last_changed[path]
621
 
        return self.base_tree.inventory[file_id].revision
 
667
        return self.base_tree.get_file_revision(file_id)
622
668
 
623
669
    def get_size_and_sha1(self, file_id):
624
670
        """Return the size and sha1 hash of the given file id.
645
691
        This need to be called before ever accessing self.inventory
646
692
        """
647
693
        from os.path import dirname, basename
648
 
 
649
 
        assert self.base_tree is not None
650
694
        base_inv = self.base_tree.inventory
651
695
        inv = Inventory(None, self.revision_id)
652
696
 
674
718
                ie.symlink_target = self.get_symlink_target(file_id)
675
719
            ie.revision = revision_id
676
720
 
677
 
            if kind in ('directory', 'symlink'):
678
 
                ie.text_size, ie.text_sha1 = None, None
679
 
            else:
 
721
            if kind == 'file':
680
722
                ie.text_size, ie.text_sha1 = self.get_size_and_sha1(file_id)
681
 
            if (ie.text_size is None) and (kind == 'file'):
682
 
                raise BzrError('Got a text_size of None for file_id %r' % file_id)
 
723
                if ie.text_size is None:
 
724
                    raise BzrError(
 
725
                        'Got a text_size of None for file_id %r' % file_id)
683
726
            inv.add(ie)
684
727
 
685
728
        sorted_entries = self.sorted_path_id()
699
742
        for path, entry in self.inventory.iter_entries():
700
743
            yield entry.file_id
701
744
 
 
745
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
746
        # The only files returned by this are those from the version
 
747
        inv = self.inventory
 
748
        if from_dir is None:
 
749
            from_dir_id = None
 
750
        else:
 
751
            from_dir_id = inv.path2id(from_dir)
 
752
            if from_dir_id is None:
 
753
                # Directory not versioned
 
754
                return
 
755
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
 
756
        if inv.root is not None and not include_root and from_dir is None:
 
757
            # skip the root for compatability with the current apis.
 
758
            entries.next()
 
759
        for path, entry in entries:
 
760
            yield path, 'V', entry.kind, entry.file_id, entry
 
761
 
702
762
    def sorted_path_id(self):
703
763
        paths = []
704
764
        for result in self._new_id.iteritems():