← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-07-22 18:09:04 UTC
  • mfrom: (2485.8.63 bzr.connection.sharing)
  • Revision ID: pqm@pqm.ubuntu.com-20070722180904-wy7y7oyi32wbghgf
Transport connection sharing

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
19
19
 
20
20
from cStringIO import StringIO
21
21
 
22
 
from bzrlib import branch, errors, lockdir, repository
 
22
from bzrlib import (
 
23
    branch,
 
24
    errors,
 
25
    lockdir,
 
26
    repository,
 
27
)
23
28
from bzrlib.branch import Branch, BranchReferenceFormat
24
29
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
25
30
from bzrlib.config import BranchConfig, TreeConfig
47
52
        self._real_bzrdir = None
48
53
 
49
54
        if _client is None:
50
 
            self._medium = transport.get_smart_client()
51
 
            self._client = client._SmartClient(self._medium)
 
55
            self._shared_medium = transport.get_shared_medium()
 
56
            self._client = client._SmartClient(self._shared_medium)
52
57
        else:
53
58
            self._client = _client
54
 
            self._medium = None
 
59
            self._shared_medium = None
55
60
            return
56
61
 
57
62
        path = self._path_for_remote_call(self._client)
105
110
        elif response == ('nobranch',):
106
111
            raise errors.NotBranchError(path=self.root_transport.base)
107
112
        else:
108
 
            assert False, 'unexpected response code %r' % (response,)
 
113
            raise errors.UnexpectedSmartServerResponse(response)
109
114
 
110
115
    def open_branch(self, _unsupported=False):
111
116
        assert _unsupported == False, 'unsupported flag support not implemented yet.'
235
240
            self._real_repository = None
236
241
        self.bzrdir = remote_bzrdir
237
242
        if _client is None:
238
 
            self._client = client._SmartClient(self.bzrdir._medium)
 
243
            self._client = client._SmartClient(self.bzrdir._shared_medium)
239
244
        else:
240
245
            self._client = _client
241
246
        self._format = format
294
299
        assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
295
300
        return response[0] == 'yes'
296
301
 
 
302
    def get_graph(self, other_repository=None):
 
303
        """Return the graph for this repository format"""
 
304
        return self._real_repository.get_graph(other_repository)
 
305
 
297
306
    def gather_stats(self, revid=None, committers=None):
298
307
        """See Repository.gather_stats()."""
299
308
        path = self.bzrdir._path_for_remote_call(self._client)
358
367
        elif response[0] == 'UnlockableTransport':
359
368
            raise errors.UnlockableTransport(self.bzrdir.root_transport)
360
369
        else:
361
 
            assert False, 'unexpected response code %s' % (response,)
 
370
            raise errors.UnexpectedSmartServerResponse(response)
362
371
 
363
372
    def lock_write(self, token=None):
364
373
        if not self._lock_mode:
407
416
        elif response[0] == 'TokenMismatch':
408
417
            raise errors.TokenMismatch(token, '(remote token)')
409
418
        else:
410
 
            assert False, 'unexpected response code %s' % (response,)
 
419
            raise errors.UnexpectedSmartServerResponse(response)
411
420
 
412
421
    def unlock(self):
413
422
        self._lock_count -= 1
461
470
        self._ensure_real()
462
471
        return self._real_repository.revision_tree(revision_id)
463
472
 
 
473
    def get_serializer_format(self):
 
474
        self._ensure_real()
 
475
        return self._real_repository.get_serializer_format()
 
476
 
464
477
    def get_commit_builder(self, branch, parents, config, timestamp=None,
465
478
                           timezone=None, committer=None, revprops=None,
466
479
                           revision_id=None):
518
531
        return self._real_repository.fetch(
519
532
            source, revision_id=revision_id, pb=pb)
520
533
 
 
534
    def create_bundle(self, target, base, fileobj, format=None):
 
535
        self._ensure_real()
 
536
        self._real_repository.create_bundle(target, base, fileobj, format)
 
537
 
521
538
    @property
522
539
    def control_weaves(self):
523
540
        self._ensure_real()
524
541
        return self._real_repository.control_weaves
525
542
 
526
543
    @needs_read_lock
527
 
    def get_ancestry(self, revision_id):
 
544
    def get_ancestry(self, revision_id, topo_sorted=True):
528
545
        self._ensure_real()
529
 
        return self._real_repository.get_ancestry(revision_id)
 
546
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
530
547
 
531
548
    @needs_read_lock
532
549
    def get_inventory_weave(self):
624
641
        # TODO: Suggestion from john: using external tar is much faster than
625
642
        # python's tarfile library, but it may not work on windows.
626
643
 
 
644
    @needs_write_lock
 
645
    def pack(self):
 
646
        """Compress the data within the repository.
 
647
 
 
648
        This is not currently implemented within the smart server.
 
649
        """
 
650
        self._ensure_real()
 
651
        return self._real_repository.pack()
 
652
 
627
653
    def set_make_working_trees(self, new_value):
628
654
        raise NotImplementedError(self.set_make_working_trees)
629
655
 
741
767
        if _client is not None:
742
768
            self._client = _client
743
769
        else:
744
 
            self._client = client._SmartClient(self.bzrdir._medium)
 
770
            self._client = client._SmartClient(self.bzrdir._shared_medium)
745
771
        self.repository = remote_repository
746
772
        if real_branch is not None:
747
773
            self._real_branch = real_branch
840
866
        elif response[0] == 'ReadOnlyError':
841
867
            raise errors.ReadOnlyError(self)
842
868
        else:
843
 
            assert False, 'unexpected response code %r' % (response,)
 
869
            raise errors.UnexpectedSmartServerResponse(response)
844
870
            
845
871
    def lock_write(self, token=None):
846
872
        if not self._lock_mode:
890
916
            raise errors.TokenMismatch(
891
917
                str((branch_token, repo_token)), '(remote tokens)')
892
918
        else:
893
 
            assert False, 'unexpected response code %s' % (response,)
 
919
            raise errors.UnexpectedSmartServerResponse(response)
894
920
 
895
921
    def unlock(self):
896
922
        self._lock_count -= 1