/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/remote.py

  • Committer: Andrew Bennetts
  • Date: 2009-02-20 23:20:06 UTC
  • mfrom: (4028 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4036.
  • Revision ID: andrew.bennetts@canonical.com-20090220232006-07u7152q6fi5ul9d
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
26
26
    errors,
27
27
    graph,
28
28
    lockdir,
 
29
    pack,
29
30
    repository,
30
31
    revision,
31
32
    symbol_versioning,
42
43
from bzrlib.smart import client, vfs
43
44
from bzrlib.revision import ensure_null, NULL_REVISION
44
45
from bzrlib.trace import mutter, note, warning
 
46
from bzrlib.versionedfile import record_to_fulltext_bytes
45
47
 
46
48
 
47
49
class _RpcHelper(object):
377
379
        self._creating_repo._ensure_real()
378
380
        return self._creating_repo._real_repository._format.network_name()
379
381
 
 
382
    @property
 
383
    def _serializer(self):
 
384
        # We should only be getting asked for the serializer for
 
385
        # RemoteRepositoryFormat objects when the RemoteRepositoryFormat object
 
386
        # is a concrete instance for a RemoteRepository. In this case we know
 
387
        # the creating_repo and can use it to supply the serializer.
 
388
        self._creating_repo._ensure_real()
 
389
        return self._creating_repo._real_repository._format._serializer
 
390
 
380
391
 
381
392
class RemoteRepository(_RpcHelper):
382
393
    """Repository accessed over rpc.
531
542
            
532
543
        return revision_graph
533
544
 
 
545
    def _get_sink(self):
 
546
        """See Repository._get_sink()."""
 
547
        return RemoteStreamSink(self)
 
548
 
534
549
    def has_revision(self, revision_id):
535
550
        """See Repository.has_revision()."""
536
551
        if revision_id == NULL_REVISION:
1328
1343
            raise errors.UnexpectedSmartServerResponse(response)
1329
1344
 
1330
1345
 
 
1346
class RemoteStreamSink(repository.StreamSink):
 
1347
 
 
1348
    def _insert_real(self, stream, src_format):
 
1349
        self.target_repo._ensure_real()
 
1350
        sink = self.target_repo._real_repository._get_sink()
 
1351
        return sink.insert_stream(stream, src_format)
 
1352
 
 
1353
    def insert_stream(self, stream, src_format):
 
1354
        repo = self.target_repo
 
1355
        # Until we can handle deltas in stack repositories we can't hand all
 
1356
        # the processing off to a remote server.
 
1357
        if self.target_repo._fallback_repositories:
 
1358
            return self._insert_real(stream, src_format)
 
1359
        client = repo._client
 
1360
        path = repo.bzrdir._path_for_remote_call(client)
 
1361
        byte_stream = self._stream_to_byte_stream(stream, src_format)
 
1362
        try:
 
1363
            response = client.call_with_body_stream(
 
1364
                ('Repository.insert_stream', path), byte_stream)
 
1365
        except errors.UnknownSmartMethod:
 
1366
            return self._insert_real(stream, src_format)
 
1367
            
 
1368
    def _stream_to_byte_stream(self, stream, src_format):
 
1369
        bytes = []
 
1370
        pack_writer = pack.ContainerWriter(bytes.append)
 
1371
        pack_writer.begin()
 
1372
        pack_writer.add_bytes_record(src_format.network_name(), '')
 
1373
        adapters = {}
 
1374
        def get_adapter(adapter_key):
 
1375
            try:
 
1376
                return adapters[adapter_key]
 
1377
            except KeyError:
 
1378
                adapter_factory = adapter_registry.get(adapter_key)
 
1379
                adapter = adapter_factory(self)
 
1380
                adapters[adapter_key] = adapter
 
1381
                return adapter
 
1382
        for substream_type, substream in stream:
 
1383
            for record in substream:
 
1384
                if record.storage_kind in ('chunked', 'fulltext'):
 
1385
                    serialised = record_to_fulltext_bytes(record)
 
1386
                else:
 
1387
                    serialised = record.get_bytes_as(record.storage_kind)
 
1388
                pack_writer.add_bytes_record(serialised, [(substream_type,)])
 
1389
                for b in bytes:
 
1390
                    yield b
 
1391
                del bytes[:]
 
1392
        pack_writer.end()
 
1393
        for b in bytes:
 
1394
            yield b
 
1395
 
 
1396
 
1331
1397
class RemoteBranchLockableFiles(LockableFiles):
1332
1398
    """A 'LockableFiles' implementation that talks to a smart server.
1333
1399