/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/smart/repository.py

  • Committer: Vincent Ladeuil
  • Date: 2009-07-10 07:43:15 UTC
  • mto: (4529.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4530.
  • Revision ID: v.ladeuil+lp@free.fr-20090710074315-tfbke0r54hk2af6o
Fix TZ-dependent tests.

* bzrlib/tests/test_annotate.py:
(TestAnnotate.create_merged_trees,
TestAnnotate.create_deeply_merged_trees): Isolate from timezone.

* bzrlib/branchbuilder.py:
(BranchBuilder.build_snapshot): timezone is useful to build
TZ-independent tests .

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/repository.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
20
20
import os
21
21
import Queue
22
22
import sys
 
23
import tarfile
23
24
import tempfile
24
25
import threading
25
26
 
29
30
    graph,
30
31
    osutils,
31
32
    pack,
32
 
    ui,
33
 
    versionedfile,
34
33
    )
35
34
from bzrlib.bzrdir import BzrDir
36
35
from bzrlib.smart.request import (
40
39
    )
41
40
from bzrlib.repository import _strip_NULL_ghosts, network_format_registry
42
41
from bzrlib import revision as _mod_revision
43
 
from bzrlib.versionedfile import (
44
 
    NetworkRecordStream,
45
 
    record_to_fulltext_bytes,
46
 
    )
 
42
from bzrlib.versionedfile import NetworkRecordStream, record_to_fulltext_bytes
47
43
 
48
44
 
49
45
class SmartServerRepositoryRequest(SmartServerRequest):
418
414
            repository.
419
415
        """
420
416
        self._to_format = network_format_registry.get(to_network_name)
421
 
        if self._should_fake_unknown():
422
 
            return FailedSmartServerResponse(
423
 
                ('UnknownMethod', 'Repository.get_stream'))
424
417
        return None # Signal that we want a body.
425
418
 
426
 
    def _should_fake_unknown(self):
427
 
        """Return True if we should return UnknownMethod to the client.
428
 
        
429
 
        This is a workaround for bugs in pre-1.19 clients that claim to
430
 
        support receiving streams of CHK repositories.  The pre-1.19 client
431
 
        expects inventory records to be serialized in the format defined by
432
 
        to_network_name, but in pre-1.19 (at least) that format definition
433
 
        tries to use the xml5 serializer, which does not correctly handle
434
 
        rich-roots.  After 1.19 the client can also accept inventory-deltas
435
 
        (which avoids this issue), and those clients will use the
436
 
        Repository.get_stream_1.19 verb instead of this one.
437
 
        So: if this repository is CHK, and the to_format doesn't match,
438
 
        we should just fake an UnknownSmartMethod error so that the client
439
 
        will fallback to VFS, rather than sending it a stream we know it
440
 
        cannot handle.
441
 
        """
442
 
        from_format = self._repository._format
443
 
        to_format = self._to_format
444
 
        if not from_format.supports_chks:
445
 
            # Source not CHK: that's ok
446
 
            return False
447
 
        if (to_format.supports_chks and
448
 
            from_format.repository_class is to_format.repository_class and
449
 
            from_format._serializer == to_format._serializer):
450
 
            # Source is CHK, but target matches: that's ok
451
 
            # (e.g. 2a->2a, or CHK2->2a)
452
 
            return False
453
 
        # Source is CHK, and target is not CHK or incompatible CHK.  We can't
454
 
        # generate a compatible stream.
455
 
        return True
456
 
 
457
419
    def do_body(self, body_bytes):
458
420
        repository = self._repository
459
421
        repository.lock_read()
489
451
            repository.unlock()
490
452
 
491
453
 
492
 
class SmartServerRepositoryGetStream_1_19(SmartServerRepositoryGetStream):
493
 
 
494
 
    def _should_fake_unknown(self):
495
 
        """Returns False; we don't need to workaround bugs in 1.19+ clients."""
496
 
        return False
497
 
 
498
 
 
499
454
def _stream_to_byte_stream(stream, src_format):
500
455
    """Convert a record stream to a self delimited byte stream."""
501
456
    pack_writer = pack.ContainerSerialiser()
505
460
        for record in substream:
506
461
            if record.storage_kind in ('chunked', 'fulltext'):
507
462
                serialised = record_to_fulltext_bytes(record)
508
 
            elif record.storage_kind == 'inventory-delta':
509
 
                serialised = record_to_inventory_delta_bytes(record)
510
463
            elif record.storage_kind == 'absent':
511
464
                raise ValueError("Absent factory for %s" % (record.key,))
512
465
            else:
519
472
    yield pack_writer.end()
520
473
 
521
474
 
522
 
class _ByteStreamDecoder(object):
523
 
    """Helper for _byte_stream_to_stream.
524
 
 
525
 
    The expected usage of this class is via the function _byte_stream_to_stream
526
 
    which creates a _ByteStreamDecoder, pops off the stream format and then
527
 
    yields the output of record_stream(), the main entry point to
528
 
    _ByteStreamDecoder.
529
 
 
530
 
    Broadly this class has to unwrap two layers of iterators:
531
 
    (type, substream)
532
 
    (substream details)
533
 
 
534
 
    This is complicated by wishing to return type, iterator_for_type, but
535
 
    getting the data for iterator_for_type when we find out type: we can't
536
 
    simply pass a generator down to the NetworkRecordStream parser, instead
537
 
    we have a little local state to seed each NetworkRecordStream instance,
538
 
    and gather the type that we'll be yielding.
539
 
 
540
 
    :ivar byte_stream: The byte stream being decoded.
541
 
    :ivar stream_decoder: A pack parser used to decode the bytestream
542
 
    :ivar current_type: The current type, used to join adjacent records of the
543
 
        same type into a single stream.
544
 
    :ivar first_bytes: The first bytes to give the next NetworkRecordStream.
545
 
    """
546
 
 
547
 
    def __init__(self, byte_stream):
548
 
        """Create a _ByteStreamDecoder."""
549
 
        self.stream_decoder = pack.ContainerPushParser()
550
 
        self.current_type = None
551
 
        self.first_bytes = None
552
 
        self.byte_stream = byte_stream
553
 
 
554
 
    def iter_stream_decoder(self):
555
 
        """Iterate the contents of the pack from stream_decoder."""
556
 
        # dequeue pending items
557
 
        for record in self.stream_decoder.read_pending_records():
558
 
            yield record
559
 
        # Pull bytes of the wire, decode them to records, yield those records.
560
 
        for bytes in self.byte_stream:
561
 
            self.stream_decoder.accept_bytes(bytes)
562
 
            for record in self.stream_decoder.read_pending_records():
563
 
                yield record
564
 
 
565
 
    def iter_substream_bytes(self):
566
 
        if self.first_bytes is not None:
567
 
            yield self.first_bytes
568
 
            # If we run out of pack records, single the outer layer to stop.
569
 
            self.first_bytes = None
570
 
        for record in self.iter_pack_records:
571
 
            record_names, record_bytes = record
572
 
            record_name, = record_names
573
 
            substream_type = record_name[0]
574
 
            if substream_type != self.current_type:
575
 
                # end of a substream, seed the next substream.
576
 
                self.current_type = substream_type
577
 
                self.first_bytes = record_bytes
578
 
                return
579
 
            yield record_bytes
580
 
 
581
 
    def record_stream(self):
582
 
        """Yield substream_type, substream from the byte stream."""
583
 
        self.seed_state()
584
 
        # Make and consume sub generators, one per substream type:
585
 
        while self.first_bytes is not None:
586
 
            substream = NetworkRecordStream(self.iter_substream_bytes())
587
 
            # after substream is fully consumed, self.current_type is set to
588
 
            # the next type, and self.first_bytes is set to the matching bytes.
589
 
            yield self.current_type, substream.read()
590
 
 
591
 
    def seed_state(self):
592
 
        """Prepare the _ByteStreamDecoder to decode from the pack stream."""
593
 
        # Set a single generator we can use to get data from the pack stream.
594
 
        self.iter_pack_records = self.iter_stream_decoder()
595
 
        # Seed the very first subiterator with content; after this each one
596
 
        # seeds the next.
597
 
        list(self.iter_substream_bytes())
598
 
 
599
 
 
600
475
def _byte_stream_to_stream(byte_stream):
601
476
    """Convert a byte stream into a format and a stream.
602
477
 
603
478
    :param byte_stream: A bytes iterator, as output by _stream_to_byte_stream.
604
479
    :return: (RepositoryFormat, stream_generator)
605
480
    """
606
 
    decoder = _ByteStreamDecoder(byte_stream)
 
481
    stream_decoder = pack.ContainerPushParser()
 
482
    def record_stream():
 
483
        """Closure to return the substreams."""
 
484
        # May have fully parsed records already.
 
485
        for record in stream_decoder.read_pending_records():
 
486
            record_names, record_bytes = record
 
487
            record_name, = record_names
 
488
            substream_type = record_name[0]
 
489
            substream = NetworkRecordStream([record_bytes])
 
490
            yield substream_type, substream.read()
 
491
        for bytes in byte_stream:
 
492
            stream_decoder.accept_bytes(bytes)
 
493
            for record in stream_decoder.read_pending_records():
 
494
                record_names, record_bytes = record
 
495
                record_name, = record_names
 
496
                substream_type = record_name[0]
 
497
                substream = NetworkRecordStream([record_bytes])
 
498
                yield substream_type, substream.read()
607
499
    for bytes in byte_stream:
608
 
        decoder.stream_decoder.accept_bytes(bytes)
609
 
        for record in decoder.stream_decoder.read_pending_records(max=1):
 
500
        stream_decoder.accept_bytes(bytes)
 
501
        for record in stream_decoder.read_pending_records(max=1):
610
502
            record_names, src_format_name = record
611
503
            src_format = network_format_registry.get(src_format_name)
612
 
            return src_format, decoder.record_stream()
 
504
            return src_format, record_stream()
613
505
 
614
506
 
615
507
class SmartServerRepositoryUnlock(SmartServerRepositoryRequest):
675
567
            temp.close()
676
568
 
677
569
    def _tarball_of_dir(self, dirname, compression, ofile):
678
 
        import tarfile
679
570
        filename = os.path.basename(ofile.name)
680
571
        tarball = tarfile.open(fileobj=ofile, name=filename,
681
572
            mode='w|' + compression)
759
650
            return SuccessfulSmartServerResponse(('ok', ))
760
651
 
761
652
 
762
 
class SmartServerRepositoryInsertStream_1_19(SmartServerRepositoryInsertStreamLocked):
763
 
    """Insert a record stream from a RemoteSink into a repository.
764
 
 
765
 
    Same as SmartServerRepositoryInsertStreamLocked, except:
766
 
     - the lock token argument is optional
767
 
     - servers that implement this verb accept 'inventory-delta' records in the
768
 
       stream.
769
 
 
770
 
    New in 1.19.
771
 
    """
772
 
 
773
 
    def do_repository_request(self, repository, resume_tokens, lock_token=None):
774
 
        """StreamSink.insert_stream for a remote repository."""
775
 
        SmartServerRepositoryInsertStreamLocked.do_repository_request(
776
 
            self, repository, resume_tokens, lock_token)
777
 
 
778
 
 
779
653
class SmartServerRepositoryInsertStream(SmartServerRepositoryInsertStreamLocked):
780
654
    """Insert a record stream from a RemoteSink into an unlocked repository.
781
655