← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/read_bundle.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-06-03 20:18:35 UTC
  • mfrom: (1185.82.137 w-changeset)
  • Revision ID: pqm@pqm.ubuntu.com-20060603201835-1c9a1725641ccd24
Implement bundles

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/read_bundle.py
1
 
# Copyright (C) 2006 by 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
 
"""Read in a bundle stream, and process it into a BundleReader object."""
 
1
#!/usr/bin/env python
 
2
"""\
 
3
Read in a bundle stream, and process it into a BundleReader object.
 
4
"""
18
5
 
19
6
import base64
20
7
from cStringIO import StringIO
21
8
import os
22
9
import pprint
23
10
 
24
 
import bzrlib.errors
25
11
from bzrlib.errors import (TestamentMismatch, BzrError, 
26
 
                           MalformedHeader, MalformedPatches, NotABundle)
 
12
                           MalformedHeader, MalformedPatches)
 
13
from bzrlib.bundle.common import get_header, header_str
27
14
from bzrlib.inventory import (Inventory, InventoryEntry,
28
15
                              InventoryDirectory, InventoryFile,
29
16
                              InventoryLink)
30
 
from bzrlib.osutils import sha_file, sha_string, pathjoin
 
17
from bzrlib.osutils import sha_file, sha_string
31
18
from bzrlib.revision import Revision, NULL_REVISION
32
19
from bzrlib.testament import StrictTestament
33
20
from bzrlib.trace import mutter, warning
34
 
import bzrlib.transport
35
21
from bzrlib.tree import Tree
36
 
import bzrlib.urlutils
37
22
from bzrlib.xml5 import serializer_v5
38
23
 
39
24
 
109
94
        split up, based on the assumptions that can be made
110
95
        when information is missing.
111
96
        """
112
 
        from bzrlib.bundle.serializer import unpack_highres_date
 
97
        from bzrlib.bundle.common import unpack_highres_date
113
98
        # Put in all of the guessable information.
114
99
        if not self.timestamp and self.date:
115
100
            self.timestamp, self.timezone = unpack_highres_date(self.date)
167
152
                return r
168
153
        raise KeyError(revision_id)
169
154
 
170
 
    def revision_tree(self, repository, revision_id, base=None):
171
 
        revision = self.get_revision(revision_id)
172
 
        base = self.get_base(revision)
173
 
        assert base != revision_id
174
 
        self._validate_references_from_repository(repository)
175
 
        revision_info = self.get_revision_info(revision_id)
176
 
        inventory_revision_id = revision_id
177
 
        bundle_tree = BundleTree(repository.revision_tree(base), 
178
 
                                  inventory_revision_id)
179
 
        self._update_tree(bundle_tree, revision_id)
180
 
 
181
 
        inv = bundle_tree.inventory
182
 
        self._validate_inventory(inv, revision_id)
183
 
        self._validate_revision(inv, revision_id)
184
 
 
185
 
        return bundle_tree
 
155
 
 
156
class BundleReader(object):
 
157
    """This class reads in a bundle from a file, and returns
 
158
    a Bundle object, which can then be applied against a tree.
 
159
    """
 
160
    def __init__(self, from_file):
 
161
        """Read in the bundle from the file.
 
162
 
 
163
        :param from_file: A file-like object (must have iterator support).
 
164
        """
 
165
        object.__init__(self)
 
166
        self.from_file = iter(from_file)
 
167
        self._next_line = None
 
168
        
 
169
        self.info = BundleInfo()
 
170
        # We put the actual inventory ids in the footer, so that the patch
 
171
        # is easier to read for humans.
 
172
        # Unfortunately, that means we need to read everything before we
 
173
        # can create a proper bundle.
 
174
        self._read()
 
175
        self._validate()
 
176
 
 
177
    def _read(self):
 
178
        self._read_header()
 
179
        while self._next_line is not None:
 
180
            self._read_revision_header()
 
181
            if self._next_line is None:
 
182
                break
 
183
            self._read_patches()
 
184
            self._read_footer()
 
185
 
 
186
    def _validate(self):
 
187
        """Make sure that the information read in makes sense
 
188
        and passes appropriate checksums.
 
189
        """
 
190
        # Fill in all the missing blanks for the revisions
 
191
        # and generate the real_revisions list.
 
192
        self.info.complete_info()
 
193
 
 
194
    def _validate_revision(self, inventory, revision_id):
 
195
        """Make sure all revision entries match their checksum."""
 
196
 
 
197
        # This is a mapping from each revision id to it's sha hash
 
198
        rev_to_sha1 = {}
 
199
        
 
200
        rev = self.info.get_revision(revision_id)
 
201
        rev_info = self.info.get_revision_info(revision_id)
 
202
        assert rev.revision_id == rev_info.revision_id
 
203
        assert rev.revision_id == revision_id
 
204
        sha1 = StrictTestament(rev, inventory).as_sha1()
 
205
        if sha1 != rev_info.sha1:
 
206
            raise TestamentMismatch(rev.revision_id, rev_info.sha1, sha1)
 
207
        if rev_to_sha1.has_key(rev.revision_id):
 
208
            raise BzrError('Revision {%s} given twice in the list'
 
209
                    % (rev.revision_id))
 
210
        rev_to_sha1[rev.revision_id] = sha1
186
211
 
187
212
    def _validate_references_from_repository(self, repository):
188
213
        """Now that we have a repository which should have some of the
210
235
        # All of the contained revisions were checked
211
236
        # in _validate_revisions
212
237
        checked = {}
213
 
        for rev_info in self.revisions:
 
238
        for rev_info in self.info.revisions:
214
239
            checked[rev_info.revision_id] = True
215
240
            add_sha(rev_to_sha, rev_info.revision_id, rev_info.sha1)
216
241
                
217
 
        for (rev, rev_info) in zip(self.real_revisions, self.revisions):
 
242
        for (rev, rev_info) in zip(self.info.real_revisions, self.info.revisions):
218
243
            add_sha(inv_to_sha, rev_info.revision_id, rev_info.inventory_sha1)
219
244
 
220
245
        count = 0
264
289
        s = serializer_v5.write_inventory_to_string(inv)
265
290
        sha1 = sha_string(s)
266
291
        # Target revision is the last entry in the real_revisions list
267
 
        rev = self.get_revision(revision_id)
 
292
        rev = self.info.get_revision(revision_id)
268
293
        assert rev.revision_id == revision_id
269
294
        if sha1 != rev.inventory_sha1:
270
295
            open(',,bogus-inv', 'wb').write(s)
271
296
            warning('Inventory sha hash mismatch for revision %s. %s'
272
297
                    ' != %s' % (revision_id, sha1, rev.inventory_sha1))
273
298
 
274
 
    def _validate_revision(self, inventory, revision_id):
275
 
        """Make sure all revision entries match their checksum."""
276
 
 
277
 
        # This is a mapping from each revision id to it's sha hash
278
 
        rev_to_sha1 = {}
279
 
        
280
 
        rev = self.get_revision(revision_id)
281
 
        rev_info = self.get_revision_info(revision_id)
282
 
        assert rev.revision_id == rev_info.revision_id
283
 
        assert rev.revision_id == revision_id
284
 
        sha1 = StrictTestament(rev, inventory).as_sha1()
285
 
        if sha1 != rev_info.sha1:
286
 
            raise TestamentMismatch(rev.revision_id, rev_info.sha1, sha1)
287
 
        if rev_to_sha1.has_key(rev.revision_id):
288
 
            raise BzrError('Revision {%s} given twice in the list'
289
 
                    % (rev.revision_id))
290
 
        rev_to_sha1[rev.revision_id] = sha1
 
299
    def get_bundle(self, repository):
 
300
        """Return the meta information, and a Bundle tree which can
 
301
        be used to populate the local stores and working tree, respectively.
 
302
        """
 
303
        return self.info, self.revision_tree(repository, self.info.target)
 
304
 
 
305
    def revision_tree(self, repository, revision_id, base=None):
 
306
        revision = self.info.get_revision(revision_id)
 
307
        base = self.info.get_base(revision)
 
308
        assert base != revision_id
 
309
        self._validate_references_from_repository(repository)
 
310
        revision_info = self.info.get_revision_info(revision_id)
 
311
        inventory_revision_id = revision_id
 
312
        bundle_tree = BundleTree(repository.revision_tree(base), 
 
313
                                  inventory_revision_id)
 
314
        self._update_tree(bundle_tree, revision_id)
 
315
 
 
316
        inv = bundle_tree.inventory
 
317
        self._validate_inventory(inv, revision_id)
 
318
        self._validate_revision(inv, revision_id)
 
319
 
 
320
        return bundle_tree
 
321
 
 
322
    def _next(self):
 
323
        """yield the next line, but secretly
 
324
        keep 1 extra line for peeking.
 
325
        """
 
326
        for line in self.from_file:
 
327
            last = self._next_line
 
328
            self._next_line = line
 
329
            if last is not None:
 
330
                #mutter('yielding line: %r' % last)
 
331
                yield last
 
332
        last = self._next_line
 
333
        self._next_line = None
 
334
        #mutter('yielding line: %r' % last)
 
335
        yield last
 
336
 
 
337
    def _read_header(self):
 
338
        """Read the bzr header"""
 
339
        header = get_header()
 
340
        found = False
 
341
        for line in self._next():
 
342
            if found:
 
343
                # not all mailers will keep trailing whitespace
 
344
                if line == '#\n':
 
345
                    line = '# \n'
 
346
                if (not line.startswith('# ') or not line.endswith('\n')
 
347
                        or line[2:-1].decode('utf-8') != header[0]):
 
348
                    raise MalformedHeader('Found a header, but it'
 
349
                        ' was improperly formatted')
 
350
                header.pop(0) # We read this line.
 
351
                if not header:
 
352
                    break # We found everything.
 
353
            elif (line.startswith('#') and line.endswith('\n')):
 
354
                line = line[1:-1].strip().decode('utf-8')
 
355
                if line[:len(header_str)] == header_str:
 
356
                    if line == header[0]:
 
357
                        found = True
 
358
                    else:
 
359
                        raise MalformedHeader('Found what looks like'
 
360
                                ' a header, but did not match')
 
361
                    header.pop(0)
 
362
        else:
 
363
            raise MalformedHeader('Did not find an opening header')
 
364
 
 
365
    def _read_revision_header(self):
 
366
        self.info.revisions.append(RevisionInfo(None))
 
367
        for line in self._next():
 
368
            # The bzr header is terminated with a blank line
 
369
            # which does not start with '#'
 
370
            if line is None or line == '\n':
 
371
                break
 
372
            self._handle_next(line)
 
373
 
 
374
    def _read_next_entry(self, line, indent=1):
 
375
        """Read in a key-value pair
 
376
        """
 
377
        if not line.startswith('#'):
 
378
            raise MalformedHeader('Bzr header did not start with #')
 
379
        line = line[1:-1].decode('utf-8') # Remove the '#' and '\n'
 
380
        if line[:indent] == ' '*indent:
 
381
            line = line[indent:]
 
382
        if not line:
 
383
            return None, None# Ignore blank lines
 
384
 
 
385
        loc = line.find(': ')
 
386
        if loc != -1:
 
387
            key = line[:loc]
 
388
            value = line[loc+2:]
 
389
            if not value:
 
390
                value = self._read_many(indent=indent+2)
 
391
        elif line[-1:] == ':':
 
392
            key = line[:-1]
 
393
            value = self._read_many(indent=indent+2)
 
394
        else:
 
395
            raise MalformedHeader('While looking for key: value pairs,'
 
396
                    ' did not find the colon %r' % (line))
 
397
 
 
398
        key = key.replace(' ', '_')
 
399
        #mutter('found %s: %s' % (key, value))
 
400
        return key, value
 
401
 
 
402
    def _handle_next(self, line):
 
403
        if line is None:
 
404
            return
 
405
        key, value = self._read_next_entry(line, indent=1)
 
406
        mutter('_handle_next %r => %r' % (key, value))
 
407
        if key is None:
 
408
            return
 
409
 
 
410
        revision_info = self.info.revisions[-1]
 
411
        if hasattr(revision_info, key):
 
412
            if getattr(revision_info, key) is None:
 
413
                setattr(revision_info, key, value)
 
414
            else:
 
415
                raise MalformedHeader('Duplicated Key: %s' % key)
 
416
        else:
 
417
            # What do we do with a key we don't recognize
 
418
            raise MalformedHeader('Unknown Key: "%s"' % key)
 
419
    
 
420
    def _read_many(self, indent):
 
421
        """If a line ends with no entry, that means that it should be
 
422
        followed with multiple lines of values.
 
423
 
 
424
        This detects the end of the list, because it will be a line that
 
425
        does not start properly indented.
 
426
        """
 
427
        values = []
 
428
        start = '#' + (' '*indent)
 
429
 
 
430
        if self._next_line is None or self._next_line[:len(start)] != start:
 
431
            return values
 
432
 
 
433
        for line in self._next():
 
434
            values.append(line[len(start):-1].decode('utf-8'))
 
435
            if self._next_line is None or self._next_line[:len(start)] != start:
 
436
                break
 
437
        return values
 
438
 
 
439
    def _read_one_patch(self):
 
440
        """Read in one patch, return the complete patch, along with
 
441
        the next line.
 
442
 
 
443
        :return: action, lines, do_continue
 
444
        """
 
445
        #mutter('_read_one_patch: %r' % self._next_line)
 
446
        # Peek and see if there are no patches
 
447
        if self._next_line is None or self._next_line.startswith('#'):
 
448
            return None, [], False
 
449
 
 
450
        first = True
 
451
        lines = []
 
452
        for line in self._next():
 
453
            if first:
 
454
                if not line.startswith('==='):
 
455
                    raise MalformedPatches('The first line of all patches'
 
456
                        ' should be a bzr meta line "==="'
 
457
                        ': %r' % line)
 
458
                action = line[4:-1].decode('utf-8')
 
459
            elif line.startswith('... '):
 
460
                action += line[len('... '):-1].decode('utf-8')
 
461
 
 
462
            if (self._next_line is not None and 
 
463
                self._next_line.startswith('===')):
 
464
                return action, lines, True
 
465
            elif self._next_line is None or self._next_line.startswith('#'):
 
466
                return action, lines, False
 
467
 
 
468
            if first:
 
469
                first = False
 
470
            elif not line.startswith('... '):
 
471
                lines.append(line)
 
472
 
 
473
        return action, lines, False
 
474
            
 
475
    def _read_patches(self):
 
476
        do_continue = True
 
477
        revision_actions = []
 
478
        while do_continue:
 
479
            action, lines, do_continue = self._read_one_patch()
 
480
            if action is not None:
 
481
                revision_actions.append((action, lines))
 
482
        assert self.info.revisions[-1].tree_actions is None
 
483
        self.info.revisions[-1].tree_actions = revision_actions
 
484
 
 
485
    def _read_footer(self):
 
486
        """Read the rest of the meta information.
 
487
 
 
488
        :param first_line:  The previous step iterates past what it
 
489
                            can handle. That extra line is given here.
 
490
        """
 
491
        for line in self._next():
 
492
            self._handle_next(line)
 
493
            if not self._next_line.startswith('#'):
 
494
                self._next().next()
 
495
                break
 
496
            if self._next_line is None:
 
497
                break
291
498
 
292
499
    def _update_tree(self, bundle_tree, revision_id):
293
500
        """This fills out a BundleTree based on the information
401
608
            'modified':modified
402
609
        }
403
610
        for action_line, lines in \
404
 
            self.get_revision_info(revision_id).tree_actions:
 
611
            self.info.get_revision_info(revision_id).tree_actions:
405
612
            first = action_line.find(' ')
406
613
            if first == -1:
407
614
                raise BzrError('Bogus action line'
495
702
            if old_dir is None:
496
703
                old_path = None
497
704
            else:
498
 
                old_path = pathjoin(old_dir, basename)
 
705
                old_path = os.path.join(old_dir, basename)
499
706
        else:
500
707
            old_path = new_path
501
708
        #If the new path wasn't in renamed, the old one shouldn't be in
520
727
            if new_dir is None:
521
728
                new_path = None
522
729
            else:
523
 
                new_path = pathjoin(new_dir, basename)
 
730
                new_path = os.path.join(new_dir, basename)
524
731
        else:
525
732
            new_path = old_path
526
733
        #If the old path wasn't in renamed, the new one shouldn't be in
723
930
    from bzrlib.iterablefile import IterableFile
724
931
    if file_patch == "":
725
932
        return IterableFile(())
726
 
    # string.splitlines(True) also splits on '\r', but the iter_patched code
727
 
    # only expects to iterate over '\n' style lines
728
 
    return IterableFile(iter_patched(original,
729
 
                StringIO(file_patch).readlines()))
 
933
    return IterableFile(iter_patched(original, file_patch.splitlines(True)))