← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/repository.py

  • Committer: Martin Pool
  • Date: 2010-04-21 11:27:04 UTC
  • mto: This revision was merged to the branch mainline in revision 5189.
  • Revision ID: mbp@canonical.com-20100421112704-zijso22b6pdevrxy
Simplify various code to use user_url

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/repository.py
39
39
    SuccessfulSmartServerResponse,
40
40
    )
41
41
from bzrlib.repository import _strip_NULL_ghosts, network_format_registry
42
 
from bzrlib.recordcounter import RecordCounter
43
42
from bzrlib import revision as _mod_revision
44
43
from bzrlib.versionedfile import (
45
44
    NetworkRecordStream,
393
392
        if token == '':
394
393
            token = None
395
394
        try:
396
 
            token = repository.lock_write(token=token).repository_token
 
395
            token = repository.lock_write(token=token)
397
396
        except errors.LockContention, e:
398
397
            return FailedSmartServerResponse(('LockContention',))
399
398
        except errors.UnlockableTransport:
545
544
    :ivar first_bytes: The first bytes to give the next NetworkRecordStream.
546
545
    """
547
546
 
548
 
    def __init__(self, byte_stream, record_counter):
 
547
    def __init__(self, byte_stream):
549
548
        """Create a _ByteStreamDecoder."""
550
549
        self.stream_decoder = pack.ContainerPushParser()
551
550
        self.current_type = None
552
551
        self.first_bytes = None
553
552
        self.byte_stream = byte_stream
554
 
        self._record_counter = record_counter
555
 
        self.key_count = 0
556
553
 
557
554
    def iter_stream_decoder(self):
558
555
        """Iterate the contents of the pack from stream_decoder."""
583
580
 
584
581
    def record_stream(self):
585
582
        """Yield substream_type, substream from the byte stream."""
586
 
        def wrap_and_count(pb, rc, substream):
587
 
            """Yield records from stream while showing progress."""
588
 
            counter = 0
589
 
            if rc:
590
 
                if self.current_type != 'revisions' and self.key_count != 0:
591
 
                    # As we know the number of revisions now (in self.key_count)
592
 
                    # we can setup and use record_counter (rc).
593
 
                    if not rc.is_initialized():
594
 
                        rc.setup(self.key_count, self.key_count)
595
 
            for record in substream.read():
596
 
                if rc:
597
 
                    if rc.is_initialized() and counter == rc.STEP:
598
 
                        rc.increment(counter)
599
 
                        pb.update('Estimate', rc.current, rc.max)
600
 
                        counter = 0
601
 
                    if self.current_type == 'revisions':
602
 
                        # Total records is proportional to number of revs
603
 
                        # to fetch. With remote, we used self.key_count to
604
 
                        # track the number of revs. Once we have the revs
605
 
                        # counts in self.key_count, the progress bar changes
606
 
                        # from 'Estimating..' to 'Estimate' above.
607
 
                        self.key_count += 1
608
 
                        if counter == rc.STEP:
609
 
                            pb.update('Estimating..', self.key_count)
610
 
                            counter = 0
611
 
                counter += 1
612
 
                yield record
613
 
 
614
583
        self.seed_state()
615
 
        pb = ui.ui_factory.nested_progress_bar()
616
 
        rc = self._record_counter
617
584
        # Make and consume sub generators, one per substream type:
618
585
        while self.first_bytes is not None:
619
586
            substream = NetworkRecordStream(self.iter_substream_bytes())
620
587
            # after substream is fully consumed, self.current_type is set to
621
588
            # the next type, and self.first_bytes is set to the matching bytes.
622
 
            yield self.current_type, wrap_and_count(pb, rc, substream)
623
 
        if rc:
624
 
            pb.update('Done', rc.max, rc.max)
625
 
        pb.finished()
 
589
            yield self.current_type, substream.read()
626
590
 
627
591
    def seed_state(self):
628
592
        """Prepare the _ByteStreamDecoder to decode from the pack stream."""
633
597
        list(self.iter_substream_bytes())
634
598
 
635
599
 
636
 
def _byte_stream_to_stream(byte_stream, record_counter=None):
 
600
def _byte_stream_to_stream(byte_stream):
637
601
    """Convert a byte stream into a format and a stream.
638
602
 
639
603
    :param byte_stream: A bytes iterator, as output by _stream_to_byte_stream.
640
604
    :return: (RepositoryFormat, stream_generator)
641
605
    """
642
 
    decoder = _ByteStreamDecoder(byte_stream, record_counter)
 
606
    decoder = _ByteStreamDecoder(byte_stream)
643
607
    for bytes in byte_stream:
644
608
        decoder.stream_decoder.accept_bytes(bytes)
645
609
        for record in decoder.stream_decoder.read_pending_records(max=1):