← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/remote.py

  • Committer: John Arbash Meinel
  • Date: 2008-05-28 21:53:46 UTC
  • mfrom: (3453 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3458.
  • Revision ID: john@arbash-meinel.com-20080528215346-l8plys9h9ps624pn
merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/remote.py
23
23
__all__ = ['RemoteTransport', 'RemoteTCPTransport', 'RemoteSSHTransport']
24
24
 
25
25
from cStringIO import StringIO
26
 
import urllib
27
 
import urlparse
28
26
 
29
27
from bzrlib import (
30
28
    config,
34
32
    transport,
35
33
    urlutils,
36
34
    )
37
 
from bzrlib.smart import client, medium, protocol
 
35
from bzrlib.smart import client, medium
38
36
from bzrlib.symbol_versioning import (deprecated_method, one_four)
39
37
 
40
38
 
79
77
            one is being cloned from.  Attributes such as the medium will
80
78
            be reused.
81
79
 
82
 
        :param medium: The medium to use for this RemoteTransport. This must be
83
 
            supplied if _from_transport is None.
 
80
        :param medium: The medium to use for this RemoteTransport.  If None,
 
81
            the medium from the _from_transport is shared.  If both this
 
82
            and _from_transport are None, a new medium will be built.
 
83
            _from_transport and medium cannot both be specified.
84
84
 
85
85
        :param _client: Override the _SmartClient used by this transport.  This
86
86
            should only be used for testing purposes; normally this is
105
105
            self._shared_connection = transport._SharedConnection(medium,
106
106
                                                                  credentials,
107
107
                                                                  self.base)
 
108
        elif medium is None:
 
109
            # No medium was specified, so share the medium from the
 
110
            # _from_transport.
 
111
            medium = self._shared_connection.connection
108
112
        else:
109
 
            if medium is None:
110
 
                # No medium was specified, so share the medium from the
111
 
                # _from_transport.
112
 
                medium = self._shared_connection.connection
 
113
            raise AssertionError(
 
114
                "Both _from_transport (%r) and medium (%r) passed to "
 
115
                "RemoteTransport.__init__, but these parameters are mutally "
 
116
                "exclusive." % (_from_transport, medium))
113
117
 
114
118
        if _client is None:
115
 
            self._client = client._SmartClient(medium, self.base)
 
119
            self._client = client._SmartClient(medium)
116
120
        else:
117
121
            self._client = _client
118
122
 
157
161
        return self._combine_paths(self._path, relpath)
158
162
 
159
163
    def _call(self, method, *args):
160
 
        resp = self._call2(method, *args)
 
164
        try:
 
165
            resp = self._call2(method, *args)
 
166
        except errors.ErrorFromSmartServer, err:
 
167
            self._translate_error(err.error_tuple)
161
168
        self._translate_error(resp)
162
169
 
163
170
    def _call2(self, method, *args):
164
171
        """Call a method on the remote server."""
165
 
        return self._client.call(method, *args)
 
172
        try:
 
173
            return self._client.call(method, *args)
 
174
        except errors.ErrorFromSmartServer, err:
 
175
            self._translate_error(err.error_tuple)
166
176
 
167
177
    def _call_with_body_bytes(self, method, args, body):
168
178
        """Call a method on the remote server with body bytes."""
169
 
        return self._client.call_with_body_bytes(method, args, body)
 
179
        try:
 
180
            return self._client.call_with_body_bytes(method, args, body)
 
181
        except errors.ErrorFromSmartServer, err:
 
182
            self._translate_error(err.error_tuple)
170
183
 
171
184
    def has(self, relpath):
172
185
        """Indicate whether a remote file of the given name exists or not.
190
203
 
191
204
    def get_bytes(self, relpath):
192
205
        remote = self._remote_path(relpath)
193
 
        request = self.get_smart_medium().get_request()
194
 
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
195
 
        smart_protocol.call('get', remote)
196
 
        resp = smart_protocol.read_response_tuple(True)
 
206
        try:
 
207
            resp, response_handler = self._client.call_expecting_body('get', remote)
 
208
        except errors.ErrorFromSmartServer, err:
 
209
            self._translate_error(err.error_tuple, relpath)
197
210
        if resp != ('ok', ):
198
 
            smart_protocol.cancel_read_body()
199
 
            self._translate_error(resp, relpath)
200
 
        return smart_protocol.read_body_bytes()
 
211
            response_handler.cancel_read_body()
 
212
            raise errors.UnexpectedSmartServerResponse(resp)
 
213
        return response_handler.read_body_bytes()
201
214
 
202
215
    def _serialise_optional_mode(self, mode):
203
216
        if mode is None:
306
319
                               limit=self._max_readv_combine,
307
320
                               fudge_factor=self._bytes_to_read_before_seek))
308
321
 
309
 
        request = self.get_smart_medium().get_request()
310
 
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
311
 
        smart_protocol.call_with_body_readv_array(
312
 
            ('readv', self._remote_path(relpath)),
313
 
            [(c.start, c.length) for c in coalesced])
314
 
        resp = smart_protocol.read_response_tuple(True)
 
322
        try:
 
323
            result = self._client.call_with_body_readv_array(
 
324
                ('readv', self._remote_path(relpath),),
 
325
                [(c.start, c.length) for c in coalesced])
 
326
            resp, response_handler = result
 
327
        except errors.ErrorFromSmartServer, err:
 
328
            self._translate_error(err.error_tuple)
315
329
 
316
330
        if resp[0] != 'readv':
317
331
            # This should raise an exception
318
 
            smart_protocol.cancel_read_body()
319
 
            self._translate_error(resp)
320
 
            return
 
332
            response_handler.cancel_read_body()
 
333
            raise errors.UnexpectedSmartServerResponse(resp)
321
334
 
322
335
        # FIXME: this should know how many bytes are needed, for clarity.
323
 
        data = smart_protocol.read_body_bytes()
 
336
        data = response_handler.read_body_bytes()
324
337
        # Cache the results, but only until they have been fulfilled
325
338
        data_map = {}
326
339
        for c_offset in coalesced:
457
470
    """
458
471
 
459
472
    def _build_medium(self):
460
 
        return medium.SmartTCPClientMedium(self._host, self._port), None
 
473
        client_medium = medium.SmartTCPClientMedium(
 
474
            self._host, self._port, self.base)
 
475
        return client_medium, None
461
476
 
462
477
 
463
478
class RemoteSSHTransport(RemoteTransport):
473
488
        # stored.
474
489
        location_config = config.LocationConfig(self.base)
475
490
        bzr_remote_path = location_config.get_bzr_remote_path()
476
 
        return medium.SmartSSHClientMedium(self._host, self._port,
477
 
            self._user, self._password, bzr_remote_path=bzr_remote_path), None
 
491
        client_medium = medium.SmartSSHClientMedium(self._host, self._port,
 
492
            self._user, self._password, self.base,
 
493
            bzr_remote_path=bzr_remote_path)
 
494
        return client_medium, None
478
495
 
479
496
 
480
497
class RemoteHTTPTransport(RemoteTransport):