← 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: Canonical.com Patch Queue Manager
  • Date: 2009-08-27 02:27:19 UTC
  • mfrom: (4634.3.19 gc-batching)
  • Revision ID: pqm@pqm.ubuntu.com-20090827022719-bl2yoqhpj3fcfczu
(andrew) Fix #402657: 2a fetch over dumb transport reads one group at
        a time.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/serializer/v08.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2009 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
"""Serializer factory for reading and writing bundles.
18
18
"""
19
19
 
20
20
import os
21
21
 
22
 
from bzrlib import errors
 
22
from bzrlib import (
 
23
    errors,
 
24
    ui,
 
25
    )
23
26
from bzrlib.bundle.serializer import (BundleSerializer,
24
27
                                      _get_bundle_header,
25
28
                                     )
27
30
from bzrlib.bundle.bundle_data import (RevisionInfo, BundleInfo, BundleTree)
28
31
from bzrlib.diff import internal_diff
29
32
from bzrlib.osutils import pathjoin
30
 
from bzrlib.progress import DummyProgress
31
33
from bzrlib.revision import NULL_REVISION
32
 
import bzrlib.ui
33
34
from bzrlib.testament import StrictTestament
34
35
from bzrlib.timestamp import (
35
36
    format_highres_date,
119
120
        source.lock_read()
120
121
        try:
121
122
            self._write_main_header()
122
 
            pb = DummyProgress()
 
123
            pb = ui.ui_factory.nested_progress_bar()
123
124
            try:
124
125
                self._write_revisions(pb)
125
126
            finally:
126
 
                pass
127
 
                #pb.finished()
 
127
                pb.finished()
128
128
        finally:
129
129
            source.unlock()
130
130
 
183
183
 
184
184
        i_max = len(self.revision_ids)
185
185
        for i, rev_id in enumerate(self.revision_ids):
186
 
            pb.update("Generating revsion data", i, i_max)
 
186
            pb.update("Generating revision data", i, i_max)
187
187
            rev = self.source.get_revision(rev_id)
188
188
            if rev_id == last_rev_id:
189
189
                rev_tree = last_rev_tree
206
206
            else:
207
207
                base_tree = self.source.revision_tree(base_id)
208
208
            force_binary = (i != 0)
209
 
            self._write_revision(rev, rev_tree, base_id, base_tree, 
 
209
            self._write_revision(rev, rev_tree, base_id, base_tree,
210
210
                                 explicit_base, force_binary)
211
211
 
212
212
            last_rev_id = base_id
213
213
            last_rev_tree = base_tree
214
214
 
215
215
    def _testament_sha1(self, revision_id):
216
 
        return StrictTestament.from_revision(self.source, 
 
216
        return StrictTestament.from_revision(self.source,
217
217
                                             revision_id).as_sha1()
218
218
 
219
 
    def _write_revision(self, rev, rev_tree, base_rev, base_tree, 
 
219
    def _write_revision(self, rev, rev_tree, base_rev, base_tree,
220
220
                        explicit_base, force_binary):
221
221
        """Write out the information for a revision."""
222
222
        def w(key, value):
241
241
            for name, value in sorted(rev.properties.items()):
242
242
                self._write(name, value, indent=3,
243
243
                            trailing_space_when_empty=True)
244
 
        
 
244
 
245
245
        # Add an extra blank space at the end
246
246
        self.to_file.write('\n')
247
247
 
254
254
        self.to_file.write(' // '.join(p_texts).encode('utf-8'))
255
255
        self.to_file.write('\n')
256
256
 
257
 
    def _write_delta(self, new_tree, old_tree, default_revision_id, 
 
257
    def _write_delta(self, new_tree, old_tree, default_revision_id,
258
258
                     force_binary):
259
259
        """Write out the changes between the trees."""
260
260
        DEVNULL = '/dev/null'
277
277
                old_lines = tree_lines(old_tree, require_text=True)
278
278
                new_lines = tree_lines(new_tree, require_text=True)
279
279
                action.write(self.to_file)
280
 
                internal_diff(old_path, old_lines, new_path, new_lines, 
 
280
                internal_diff(old_path, old_lines, new_path, new_lines,
281
281
                              self.to_file)
282
282
            except errors.BinaryFile:
283
283
                old_lines = tree_lines(old_tree, require_text=False)
284
284
                new_lines = tree_lines(new_tree, require_text=False)
285
285
                action.add_property('encoding', 'base64')
286
286
                action.write(self.to_file)
287
 
                binary_diff(old_path, old_lines, new_path, new_lines, 
 
287
                binary_diff(old_path, old_lines, new_path, new_lines,
288
288
                            self.to_file)
289
289
 
290
290
        def finish_action(action, file_id, kind, meta_modified, text_modified,
308
308
 
309
309
        for path, file_id, kind in delta.added:
310
310
            action = Action('added', [kind, path], [('file-id', file_id)])
311
 
            meta_modified = (kind=='file' and 
 
311
            meta_modified = (kind=='file' and
312
312
                             new_tree.is_executable(file_id))
313
313
            finish_action(action, file_id, kind, meta_modified, True,
314
314
                          DEVNULL, path)
332
332
                continue
333
333
            old_rev = getattr(old_tree.inventory[ie.file_id], 'revision', None)
334
334
            if new_rev != old_rev:
335
 
                action = Action('modified', [ie.kind, 
 
335
                action = Action('modified', [ie.kind,
336
336
                                             new_tree.id2path(ie.file_id)])
337
337
                action.add_utf8_property('last-changed', ie.revision)
338
338
                action.write(self.to_file)
350
350
        object.__init__(self)
351
351
        self.from_file = iter(from_file)
352
352
        self._next_line = None
353
 
        
 
353
 
354
354
        self.info = self._get_info()
355
355
        # We put the actual inventory ids in the footer, so that the patch
356
356
        # is easier to read for humans.
461
461
        else:
462
462
            # What do we do with a key we don't recognize
463
463
            raise errors.MalformedHeader('Unknown Key: "%s"' % key)
464
 
    
 
464
 
465
465
    def _read_many(self, indent):
466
466
        """If a line ends with no entry, that means that it should be
467
467
        followed with multiple lines of values.
504
504
            elif line.startswith('... '):
505
505
                action += line[len('... '):-1].decode('utf-8')
506
506
 
507
 
            if (self._next_line is not None and 
 
507
            if (self._next_line is not None and
508
508
                self._next_line.startswith('===')):
509
509
                return action, lines, True
510
510
            elif self._next_line is None or self._next_line.startswith('#'):
516
516
                lines.append(line)
517
517
 
518
518
        return action, lines, False
519
 
            
 
519
 
520
520
    def _read_patches(self):
521
521
        do_continue = True
522
522
        revision_actions = []