← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/serializer/v08.py

  • Committer: Robert Collins
  • Date: 2007-03-08 04:06:06 UTC
  • mfrom: (2323.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 2442.
  • Revision ID: robertc@robertcollins.net-20070308040606-84gsniv56huiyjt4
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/serializer/v08.py
1
 
# (C) 2005 Canonical Development Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
19
 
20
20
import os
21
21
 
22
 
from bzrlib.bundle.serializer import (BundleSerializer, 
23
 
                                      BUNDLE_HEADER, 
 
22
from bzrlib import errors
 
23
from bzrlib.bundle.serializer import (BundleSerializer,
 
24
                                      BUNDLE_HEADER,
24
25
                                      format_highres_date,
25
26
                                      unpack_highres_date,
26
27
                                     )
27
28
from bzrlib.bundle.serializer import binary_diff
28
 
from bzrlib.delta import compare_trees
 
29
from bzrlib.bundle.bundle_data import (RevisionInfo, BundleInfo, BundleTree)
29
30
from bzrlib.diff import internal_diff
30
 
import bzrlib.errors as errors
31
31
from bzrlib.osutils import pathjoin
32
32
from bzrlib.progress import DummyProgress
33
33
from bzrlib.revision import NULL_REVISION
35
35
import bzrlib.ui
36
36
from bzrlib.testament import StrictTestament
37
37
from bzrlib.textfile import text_file
 
38
from bzrlib.trace import mutter
38
39
 
39
40
bool_text = {True: 'yes', False: 'no'}
40
41
 
53
54
        else:
54
55
            self.properties = properties
55
56
 
 
57
    def add_utf8_property(self, name, value):
 
58
        """Add a property whose value is currently utf8 to the action."""
 
59
        self.properties.append((name, value.decode('utf8')))
 
60
 
56
61
    def add_property(self, name, value):
57
62
        """Add a property to the action"""
58
63
        self.properties.append((name, value))
84
89
        to_file.write(text_line+'\n')
85
90
 
86
91
 
87
 
class BundleSerializerV07(BundleSerializer):
 
92
class BundleSerializerV08(BundleSerializer):
88
93
    def read(self, f):
89
94
        """Read the rest of the bundles from the supplied file.
90
95
 
91
96
        :param f: The file to read from
92
97
        :return: A list of bundles
93
98
        """
94
 
        assert self.version == '0.7'
95
 
        # The first line of the header should have been read
96
 
        raise NotImplementedError
 
99
        return BundleReader(f).info
 
100
 
 
101
    def check_compatible(self):
 
102
        if self.source.supports_rich_root():
 
103
            raise errors.IncompatibleBundleFormat('0.8', repr(self.source))
97
104
 
98
105
    def write(self, source, revision_ids, forced_bases, f):
99
106
        """Write the bundless to the supplied files.
107
114
        self.revision_ids = revision_ids
108
115
        self.forced_bases = forced_bases
109
116
        self.to_file = f
 
117
        self.check_compatible()
110
118
        source.lock_read()
111
119
        try:
112
120
            self._write_main_header()
123
131
        """Write the header for the changes"""
124
132
        f = self.to_file
125
133
        f.write(BUNDLE_HEADER)
126
 
        f.write('0.7\n')
 
134
        f.write('0.8\n')
127
135
        f.write('#\n')
128
136
 
129
137
    def _write(self, key, value, indent=1):
134
142
        f.write(key.encode('utf-8'))
135
143
        if not value:
136
144
            f.write(':\n')
137
 
        elif isinstance(value, basestring):
 
145
        elif isinstance(value, str):
 
146
            f.write(': ')
 
147
            f.write(value)
 
148
            f.write('\n')
 
149
        elif isinstance(value, unicode):
138
150
            f.write(': ')
139
151
            f.write(value.encode('utf-8'))
140
152
            f.write('\n')
142
154
            f.write(':\n')
143
155
            for entry in value:
144
156
                f.write('#' + (' ' * (indent+2)))
145
 
                f.write(entry.encode('utf-8'))
 
157
                if isinstance(entry, str):
 
158
                    f.write(entry)
 
159
                else:
 
160
                    f.write(entry.encode('utf-8'))
146
161
                f.write('\n')
147
162
 
148
163
    def _write_revisions(self, pb):
152
167
        last_rev_id = None
153
168
        last_rev_tree = None
154
169
 
155
 
        i_max = len(self.revision_ids) 
 
170
        i_max = len(self.revision_ids)
156
171
        for i, rev_id in enumerate(self.revision_ids):
157
172
            pb.update("Generating revsion data", i, i_max)
158
173
            rev = self.source.get_revision(rev_id)
159
174
            if rev_id == last_rev_id:
160
175
                rev_tree = last_rev_tree
161
176
            else:
162
 
                base_tree = self.source.revision_tree(rev_id)
163
 
            rev_tree = self.source.revision_tree(rev_id)
 
177
                rev_tree = self.source.revision_tree(rev_id)
164
178
            if rev_id in self.forced_bases:
165
179
                explicit_base = True
166
180
                base_id = self.forced_bases[rev_id]
177
191
                base_tree = last_rev_tree
178
192
            else:
179
193
                base_tree = self.source.revision_tree(base_id)
180
 
 
 
194
            force_binary = (i != 0)
181
195
            self._write_revision(rev, rev_tree, base_id, base_tree, 
182
 
                                 explicit_base)
 
196
                                 explicit_base, force_binary)
183
197
 
184
198
            last_rev_id = base_id
185
199
            last_rev_tree = base_tree
186
200
 
 
201
    def _testament_sha1(self, revision_id):
 
202
        return StrictTestament.from_revision(self.source, 
 
203
                                             revision_id).as_sha1()
 
204
 
187
205
    def _write_revision(self, rev, rev_tree, base_rev, base_tree, 
188
 
                        explicit_base):
 
206
                        explicit_base, force_binary):
189
207
        """Write out the information for a revision."""
190
208
        def w(key, value):
191
209
            self._write(key, value, indent=1)
195
213
        w('date', format_highres_date(rev.timestamp, rev.timezone))
196
214
        self.to_file.write('\n')
197
215
 
198
 
        self._write_delta(rev_tree, base_tree, rev.revision_id)
 
216
        self._write_delta(rev_tree, base_tree, rev.revision_id, force_binary)
199
217
 
200
218
        w('revision id', rev.revision_id)
201
 
        w('sha1', StrictTestament.from_revision(self.source, 
202
 
                                                rev.revision_id).as_sha1())
 
219
        w('sha1', self._testament_sha1(rev.revision_id))
203
220
        w('inventory sha1', rev.inventory_sha1)
204
221
        if rev.parent_ids:
205
222
            w('parent ids', rev.parent_ids)
222
239
        self.to_file.write(' // '.join(p_texts).encode('utf-8'))
223
240
        self.to_file.write('\n')
224
241
 
225
 
    def _write_delta(self, new_tree, old_tree, default_revision_id):
 
242
    def _write_delta(self, new_tree, old_tree, default_revision_id, 
 
243
                     force_binary):
226
244
        """Write out the changes between the trees."""
227
245
        DEVNULL = '/dev/null'
228
246
        old_label = ''
229
247
        new_label = ''
230
248
 
231
 
        def do_diff(file_id, old_path, new_path, action):
 
249
        def do_diff(file_id, old_path, new_path, action, force_binary):
232
250
            def tree_lines(tree, require_text=False):
233
251
                if file_id in tree:
234
252
                    tree_file = tree.get_file(file_id)
239
257
                    return []
240
258
 
241
259
            try:
 
260
                if force_binary:
 
261
                    raise errors.BinaryFile()
242
262
                old_lines = tree_lines(old_tree, require_text=True)
243
263
                new_lines = tree_lines(new_tree, require_text=True)
244
264
                action.write(self.to_file)
256
276
                          old_path, new_path):
257
277
            entry = new_tree.inventory[file_id]
258
278
            if entry.revision != default_revision_id:
259
 
                action.add_property('last-changed', entry.revision)
 
279
                action.add_utf8_property('last-changed', entry.revision)
260
280
            if meta_modified:
261
281
                action.add_bool_property('executable', entry.executable)
262
282
            if text_modified and kind == "symlink":
263
283
                action.add_property('target', entry.symlink_target)
264
284
            if text_modified and kind == "file":
265
 
                do_diff(file_id, old_path, new_path, action)
 
285
                do_diff(file_id, old_path, new_path, action, force_binary)
266
286
            else:
267
287
                action.write(self.to_file)
268
288
 
269
 
        delta = compare_trees(old_tree, new_tree, want_unchanged=True)
 
289
        delta = new_tree.changes_from(old_tree, want_unchanged=True,
 
290
                                      include_root=True)
270
291
        for path, file_id, kind in delta.removed:
271
292
            action = Action('removed', [kind, path]).write(self.to_file)
272
293
 
298
319
            if new_rev != old_rev:
299
320
                action = Action('modified', [ie.kind, 
300
321
                                             new_tree.id2path(ie.file_id)])
301
 
                action.add_property('last-changed', ie.revision)
 
322
                action.add_utf8_property('last-changed', ie.revision)
302
323
                action.write(self.to_file)
 
324
 
 
325
 
 
326
class BundleReader(object):
 
327
    """This class reads in a bundle from a file, and returns
 
328
    a Bundle object, which can then be applied against a tree.
 
329
    """
 
330
    def __init__(self, from_file):
 
331
        """Read in the bundle from the file.
 
332
 
 
333
        :param from_file: A file-like object (must have iterator support).
 
334
        """
 
335
        object.__init__(self)
 
336
        self.from_file = iter(from_file)
 
337
        self._next_line = None
 
338
        
 
339
        self.info = self._get_info()
 
340
        # We put the actual inventory ids in the footer, so that the patch
 
341
        # is easier to read for humans.
 
342
        # Unfortunately, that means we need to read everything before we
 
343
        # can create a proper bundle.
 
344
        self._read()
 
345
        self._validate()
 
346
 
 
347
    def _get_info(self):
 
348
        return BundleInfo08()
 
349
 
 
350
    def _read(self):
 
351
        self._next().next()
 
352
        while self._next_line is not None:
 
353
            if not self._read_revision_header():
 
354
                break
 
355
            if self._next_line is None:
 
356
                break
 
357
            self._read_patches()
 
358
            self._read_footer()
 
359
 
 
360
    def _validate(self):
 
361
        """Make sure that the information read in makes sense
 
362
        and passes appropriate checksums.
 
363
        """
 
364
        # Fill in all the missing blanks for the revisions
 
365
        # and generate the real_revisions list.
 
366
        self.info.complete_info()
 
367
 
 
368
    def _next(self):
 
369
        """yield the next line, but secretly
 
370
        keep 1 extra line for peeking.
 
371
        """
 
372
        for line in self.from_file:
 
373
            last = self._next_line
 
374
            self._next_line = line
 
375
            if last is not None:
 
376
                #mutter('yielding line: %r' % last)
 
377
                yield last
 
378
        last = self._next_line
 
379
        self._next_line = None
 
380
        #mutter('yielding line: %r' % last)
 
381
        yield last
 
382
 
 
383
    def _read_revision_header(self):
 
384
        found_something = False
 
385
        self.info.revisions.append(RevisionInfo(None))
 
386
        for line in self._next():
 
387
            # The bzr header is terminated with a blank line
 
388
            # which does not start with '#'
 
389
            if line is None or line == '\n':
 
390
                break
 
391
            if not line.startswith('#'):
 
392
                continue
 
393
            found_something = True
 
394
            self._handle_next(line)
 
395
        if not found_something:
 
396
            # Nothing was there, so remove the added revision
 
397
            self.info.revisions.pop()
 
398
        return found_something
 
399
 
 
400
    def _read_next_entry(self, line, indent=1):
 
401
        """Read in a key-value pair
 
402
        """
 
403
        if not line.startswith('#'):
 
404
            raise errors.MalformedHeader('Bzr header did not start with #')
 
405
        line = line[1:-1].decode('utf-8') # Remove the '#' and '\n'
 
406
        if line[:indent] == ' '*indent:
 
407
            line = line[indent:]
 
408
        if not line:
 
409
            return None, None# Ignore blank lines
 
410
 
 
411
        loc = line.find(': ')
 
412
        if loc != -1:
 
413
            key = line[:loc]
 
414
            value = line[loc+2:]
 
415
            if not value:
 
416
                value = self._read_many(indent=indent+2)
 
417
        elif line[-1:] == ':':
 
418
            key = line[:-1]
 
419
            value = self._read_many(indent=indent+2)
 
420
        else:
 
421
            raise errors.MalformedHeader('While looking for key: value pairs,'
 
422
                    ' did not find the colon %r' % (line))
 
423
 
 
424
        key = key.replace(' ', '_')
 
425
        #mutter('found %s: %s' % (key, value))
 
426
        return key, value
 
427
 
 
428
    def _handle_next(self, line):
 
429
        if line is None:
 
430
            return
 
431
        key, value = self._read_next_entry(line, indent=1)
 
432
        mutter('_handle_next %r => %r' % (key, value))
 
433
        if key is None:
 
434
            return
 
435
 
 
436
        revision_info = self.info.revisions[-1]
 
437
        if key in revision_info.__dict__:
 
438
            if getattr(revision_info, key) is None:
 
439
                if key in ('file_id', 'revision_id', 'base_id'):
 
440
                    value = value.encode('utf8')
 
441
                elif key in ('parent_ids'):
 
442
                    value = [v.encode('utf8') for v in value]
 
443
                setattr(revision_info, key, value)
 
444
            else:
 
445
                raise errors.MalformedHeader('Duplicated Key: %s' % key)
 
446
        else:
 
447
            # What do we do with a key we don't recognize
 
448
            raise errors.MalformedHeader('Unknown Key: "%s"' % key)
 
449
    
 
450
    def _read_many(self, indent):
 
451
        """If a line ends with no entry, that means that it should be
 
452
        followed with multiple lines of values.
 
453
 
 
454
        This detects the end of the list, because it will be a line that
 
455
        does not start properly indented.
 
456
        """
 
457
        values = []
 
458
        start = '#' + (' '*indent)
 
459
 
 
460
        if self._next_line is None or self._next_line[:len(start)] != start:
 
461
            return values
 
462
 
 
463
        for line in self._next():
 
464
            values.append(line[len(start):-1].decode('utf-8'))
 
465
            if self._next_line is None or self._next_line[:len(start)] != start:
 
466
                break
 
467
        return values
 
468
 
 
469
    def _read_one_patch(self):
 
470
        """Read in one patch, return the complete patch, along with
 
471
        the next line.
 
472
 
 
473
        :return: action, lines, do_continue
 
474
        """
 
475
        #mutter('_read_one_patch: %r' % self._next_line)
 
476
        # Peek and see if there are no patches
 
477
        if self._next_line is None or self._next_line.startswith('#'):
 
478
            return None, [], False
 
479
 
 
480
        first = True
 
481
        lines = []
 
482
        for line in self._next():
 
483
            if first:
 
484
                if not line.startswith('==='):
 
485
                    raise errors.MalformedPatches('The first line of all patches'
 
486
                        ' should be a bzr meta line "==="'
 
487
                        ': %r' % line)
 
488
                action = line[4:-1].decode('utf-8')
 
489
            elif line.startswith('... '):
 
490
                action += line[len('... '):-1].decode('utf-8')
 
491
 
 
492
            if (self._next_line is not None and 
 
493
                self._next_line.startswith('===')):
 
494
                return action, lines, True
 
495
            elif self._next_line is None or self._next_line.startswith('#'):
 
496
                return action, lines, False
 
497
 
 
498
            if first:
 
499
                first = False
 
500
            elif not line.startswith('... '):
 
501
                lines.append(line)
 
502
 
 
503
        return action, lines, False
 
504
            
 
505
    def _read_patches(self):
 
506
        do_continue = True
 
507
        revision_actions = []
 
508
        while do_continue:
 
509
            action, lines, do_continue = self._read_one_patch()
 
510
            if action is not None:
 
511
                revision_actions.append((action, lines))
 
512
        assert self.info.revisions[-1].tree_actions is None
 
513
        self.info.revisions[-1].tree_actions = revision_actions
 
514
 
 
515
    def _read_footer(self):
 
516
        """Read the rest of the meta information.
 
517
 
 
518
        :param first_line:  The previous step iterates past what it
 
519
                            can handle. That extra line is given here.
 
520
        """
 
521
        for line in self._next():
 
522
            self._handle_next(line)
 
523
            if self._next_line is None:
 
524
                break
 
525
            if not self._next_line.startswith('#'):
 
526
                # Consume the trailing \n and stop processing
 
527
                self._next().next()
 
528
                break
 
529
 
 
530
 
 
531
class BundleInfo08(BundleInfo):
 
532
 
 
533
    def _update_tree(self, bundle_tree, revision_id):
 
534
        bundle_tree.note_last_changed('', revision_id)
 
535
        BundleInfo._update_tree(self, bundle_tree, revision_id)
 
536
 
 
537
    def _testament_sha1_from_revision(self, repository, revision_id):
 
538
        testament = StrictTestament.from_revision(repository, revision_id)
 
539
        return testament.as_sha1()
 
540
 
 
541
    def _testament_sha1(self, revision, inventory):
 
542
        return StrictTestament(revision, inventory).as_sha1()