← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
55
55
            return self._client.call(method, *args)
56
56
        except errors.ErrorFromSmartServer, err:
57
57
            self._translate_error(err, **err_context)
58
 
        
 
58
 
59
59
    def _call_expecting_body(self, method, *args, **err_context):
60
60
        try:
61
61
            return self._client.call_expecting_body(method, *args)
62
62
        except errors.ErrorFromSmartServer, err:
63
63
            self._translate_error(err, **err_context)
64
 
        
 
64
 
65
65
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
66
66
                                             **err_context):
67
67
        try:
69
69
                method, args, body_bytes)
70
70
        except errors.ErrorFromSmartServer, err:
71
71
            self._translate_error(err, **err_context)
72
 
        
 
72
 
73
73
# Note: RemoteBzrDirFormat is in bzrdir.py
74
74
 
75
75
class RemoteBzrDir(BzrDir, _RpcHelper):
184
184
            # a branch reference, use the existing BranchReference logic.
185
185
            format = BranchReferenceFormat()
186
186
            return format.open(self, _found=True, location=reference_url)
187
 
                
 
187
 
188
188
    def open_repository(self):
189
189
        path = self._path_for_remote_call(self._client)
190
190
        verb = 'BzrDir.find_repositoryV2'
272
272
    on a per instance basis, and are not set (and should not be) at
273
273
    the class level.
274
274
 
275
 
    :ivar _custom_format: If set, a specific concrete repository format that 
 
275
    :ivar _custom_format: If set, a specific concrete repository format that
276
276
        will be used when initializing a repository with this
277
277
        RemoteRepositoryFormat.
278
278
    :ivar _creating_repo: If set, the repository object that this
353
353
            remote_repo = RemoteRepository(a_bzrdir, format)
354
354
            format._creating_repo = remote_repo
355
355
            return remote_repo
356
 
    
 
356
 
357
357
    def open(self, a_bzrdir):
358
358
        if not isinstance(a_bzrdir, RemoteBzrDir):
359
359
            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
399
399
 
400
400
    def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
401
401
        """Create a RemoteRepository instance.
402
 
        
 
402
 
403
403
        :param remote_bzrdir: The bzrdir hosting this repository.
404
404
        :param format: The RemoteFormat object to use.
405
405
        :param real_repository: If not None, a local implementation of the
444
444
 
445
445
    def abort_write_group(self, suppress_errors=False):
446
446
        """Complete a write group on the decorated repository.
447
 
        
 
447
 
448
448
        Smart methods peform operations in a single step so this api
449
449
        is not really applicable except as a compatibility thunk
450
450
        for older plugins that don't use e.g. the CommitBuilder
458
458
 
459
459
    def commit_write_group(self):
460
460
        """Complete a write group on the decorated repository.
461
 
        
 
461
 
462
462
        Smart methods peform operations in a single step so this api
463
463
        is not really applicable except as a compatibility thunk
464
464
        for older plugins that don't use e.g. the CommitBuilder
540
540
        for line in lines:
541
541
            d = tuple(line.split())
542
542
            revision_graph[d[0]] = d[1:]
543
 
            
 
543
 
544
544
        return revision_graph
545
545
 
546
546
    def _get_sink(self):
731
731
 
732
732
    def start_write_group(self):
733
733
        """Start a write group on the decorated repository.
734
 
        
 
734
 
735
735
        Smart methods peform operations in a single step so this api
736
736
        is not really applicable except as a compatibility thunk
737
737
        for older plugins that don't use e.g. the CommitBuilder
786
786
 
787
787
    def _get_tarball(self, compression):
788
788
        """Return a TemporaryFile containing a repository tarball.
789
 
        
 
789
 
790
790
        Returns None if the server does not support sending tarballs.
791
791
        """
792
792
        import tempfile
838
838
 
839
839
    def add_fallback_repository(self, repository):
840
840
        """Add a repository to use for looking up data not held locally.
841
 
        
 
841
 
842
842
        :param repository: A repository.
843
843
        """
844
844
        # XXX: At the moment the RemoteRepository will allow fallbacks
913
913
    @needs_read_lock
914
914
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
915
915
        """Return the revision ids that other has that this does not.
916
 
        
 
916
 
917
917
        These are returned in topological order.
918
918
 
919
919
        revision_id: only return revision ids included by revision_id.
954
954
        self._ensure_real()
955
955
        return self._real_repository._get_versioned_file_checker(
956
956
            revisions, revision_versions_cache)
957
 
        
 
957
 
958
958
    def iter_files_bytes(self, desired_files):
959
959
        """See Repository.iter_file_bytes.
960
960
        """
1123
1123
    def reconcile(self, other=None, thorough=False):
1124
1124
        self._ensure_real()
1125
1125
        return self._real_repository.reconcile(other=other, thorough=thorough)
1126
 
        
 
1126
 
1127
1127
    def all_revision_ids(self):
1128
1128
        self._ensure_real()
1129
1129
        return self._real_repository.all_revision_ids()
1130
 
    
 
1130
 
1131
1131
    @needs_read_lock
1132
1132
    def get_deltas_for_revisions(self, revisions):
1133
1133
        self._ensure_real()
1400
1400
                if collection is not None:
1401
1401
                    collection.reload_pack_names()
1402
1402
            return []
1403
 
            
 
1403
 
1404
1404
    def _stream_to_byte_stream(self, stream, src_format):
1405
1405
        bytes = []
1406
1406
        pack_writer = pack.ContainerWriter(bytes.append)
1432
1432
 
1433
1433
class RemoteBranchLockableFiles(LockableFiles):
1434
1434
    """A 'LockableFiles' implementation that talks to a smart server.
1435
 
    
 
1435
 
1436
1436
    This is not a public interface class.
1437
1437
    """
1438
1438
 
1458
1458
        self._matchingbzrdir.set_branch_format(self)
1459
1459
 
1460
1460
    def __eq__(self, other):
1461
 
        return (isinstance(other, RemoteBranchFormat) and 
 
1461
        return (isinstance(other, RemoteBranchFormat) and
1462
1462
            self.__dict__ == other.__dict__)
1463
1463
 
1464
1464
    def get_format_description(self):
1619
1619
        too, in fact doing so might harm performance.
1620
1620
        """
1621
1621
        super(RemoteBranch, self)._clear_cached_state()
1622
 
        
 
1622
 
1623
1623
    @property
1624
1624
    def control_files(self):
1625
1625
        # Defer actually creating RemoteBranchLockableFiles until its needed,
1689
1689
            raise errors.UnexpectedSmartServerResponse(response)
1690
1690
        ok, branch_token, repo_token = response
1691
1691
        return branch_token, repo_token
1692
 
            
 
1692
 
1693
1693
    def lock_write(self, token=None):
1694
1694
        if not self._lock_mode:
1695
1695
            # Lock the branch and repo in one remote call.
1865
1865
        # Used by tests, when checking normalisation of given vs stored paths.
1866
1866
        self._ensure_real()
1867
1867
        return self._real_branch._get_parent_location()
1868
 
        
 
1868
 
1869
1869
    def set_parent(self, url):
1870
1870
        self._ensure_real()
1871
1871
        return self._real_branch.set_parent(url)
1877
1877
        else:
1878
1878
            self._ensure_real()
1879
1879
            return self._real_branch._set_parent_location(url)
1880
 
        
 
1880
 
1881
1881
    def set_stacked_on_url(self, stacked_location):
1882
1882
        """Set the URL this branch is stacked against.
1883
1883