~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/smart.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-10-10 07:23:07 UTC
  • mfrom: (2067.1.1 urandom-56883)
  • Revision ID: pqm@pqm.ubuntu.com-20061010072307-037a6f63da8a1bdd
(John Arbash Meinel) Handle exceptions while opening /dev/urandom

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
"""RemoteTransport client for the smart-server.
18
 
 
19
 
This module shouldn't be accessed directly.  The classes defined here should be
20
 
imported from bzrlib.smart.
 
17
"""Smart-server protocol, client and server.
 
18
 
 
19
Requests are sent as a command and list of arguments, followed by optional
 
20
bulk body data.  Responses are similarly a response and list of arguments,
 
21
followed by bulk body data. ::
 
22
 
 
23
  SEP := '\001'
 
24
    Fields are separated by Ctrl-A.
 
25
  BULK_DATA := CHUNK+ TRAILER
 
26
    Chunks can be repeated as many times as necessary.
 
27
  CHUNK := CHUNK_LEN CHUNK_BODY
 
28
  CHUNK_LEN := DIGIT+ NEWLINE
 
29
    Gives the number of bytes in the following chunk.
 
30
  CHUNK_BODY := BYTE[chunk_len]
 
31
  TRAILER := SUCCESS_TRAILER | ERROR_TRAILER
 
32
  SUCCESS_TRAILER := 'done' NEWLINE
 
33
  ERROR_TRAILER := 
 
34
 
 
35
Paths are passed across the network.  The client needs to see a namespace that
 
36
includes any repository that might need to be referenced, and the client needs
 
37
to know about a root directory beyond which it cannot ascend.
 
38
 
 
39
Servers run over ssh will typically want to be able to access any path the user 
 
40
can access.  Public servers on the other hand (which might be over http, ssh
 
41
or tcp) will typically want to restrict access to only a particular directory 
 
42
and its children, so will want to do a software virtual root at that level.
 
43
In other words they'll want to rewrite incoming paths to be under that level
 
44
(and prevent escaping using ../ tricks.)
 
45
 
 
46
URLs that include ~ should probably be passed across to the server verbatim
 
47
and the server can expand them.  This will proably not be meaningful when 
 
48
limited to a directory?
21
49
"""
22
50
 
23
 
__all__ = ['RemoteTransport', 'RemoteTCPTransport', 'RemoteSSHTransport']
 
51
 
 
52
# TODO: _translate_error should be on the client, not the transport because
 
53
#     error coding is wire protocol specific.
 
54
 
 
55
# TODO: A plain integer from query_version is too simple; should give some
 
56
# capabilities too?
 
57
 
 
58
# TODO: Server should probably catch exceptions within itself and send them
 
59
# back across the network.  (But shouldn't catch KeyboardInterrupt etc)
 
60
# Also needs to somehow report protocol errors like bad requests.  Need to
 
61
# consider how we'll handle error reporting, e.g. if we get halfway through a
 
62
# bulk transfer and then something goes wrong.
 
63
 
 
64
# TODO: Standard marker at start of request/response lines?
 
65
 
 
66
# TODO: Make each request and response self-validatable, e.g. with checksums.
 
67
#
 
68
# TODO: get/put objects could be changed to gradually read back the data as it
 
69
# comes across the network
 
70
#
 
71
# TODO: What should the server do if it hits an error and has to terminate?
 
72
#
 
73
# TODO: is it useful to allow multiple chunks in the bulk data?
 
74
#
 
75
# TODO: If we get an exception during transmission of bulk data we can't just
 
76
# emit the exception because it won't be seen.
 
77
#   John proposes:  I think it would be worthwhile to have a header on each
 
78
#   chunk, that indicates it is another chunk. Then you can send an 'error'
 
79
#   chunk as long as you finish the previous chunk.
 
80
#
 
81
# TODO: Clone method on Transport; should work up towards parent directory;
 
82
# unclear how this should be stored or communicated to the server... maybe
 
83
# just pass it on all relevant requests?
 
84
#
 
85
# TODO: Better name than clone() for changing between directories.  How about
 
86
# open_dir or change_dir or chdir?
 
87
#
 
88
# TODO: Is it really good to have the notion of current directory within the
 
89
# connection?  Perhaps all Transports should factor out a common connection
 
90
# from the thing that has the directory context?
 
91
#
 
92
# TODO: Pull more things common to sftp and ssh to a higher level.
 
93
#
 
94
# TODO: The server that manages a connection should be quite small and retain
 
95
# minimum state because each of the requests are supposed to be stateless.
 
96
# Then we can write another implementation that maps to http.
 
97
#
 
98
# TODO: What to do when a client connection is garbage collected?  Maybe just
 
99
# abruptly drop the connection?
 
100
#
 
101
# TODO: Server in some cases will need to restrict access to files outside of
 
102
# a particular root directory.  LocalTransport doesn't do anything to stop you
 
103
# ascending above the base directory, so we need to prevent paths
 
104
# containing '..' in either the server or transport layers.  (Also need to
 
105
# consider what happens if someone creates a symlink pointing outside the 
 
106
# directory tree...)
 
107
#
 
108
# TODO: Server should rebase absolute paths coming across the network to put
 
109
# them under the virtual root, if one is in use.  LocalTransport currently
 
110
# doesn't do that; if you give it an absolute path it just uses it.
 
111
 
112
# XXX: Arguments can't contain newlines or ascii; possibly we should e.g.
 
113
# urlescape them instead.  Indeed possibly this should just literally be
 
114
# http-over-ssh.
 
115
#
 
116
# FIXME: This transport, with several others, has imperfect handling of paths
 
117
# within urls.  It'd probably be better for ".." from a root to raise an error
 
118
# rather than return the same directory as we do at present.
 
119
#
 
120
# TODO: Rather than working at the Transport layer we want a Branch,
 
121
# Repository or BzrDir objects that talk to a server.
 
122
#
 
123
# TODO: Probably want some way for server commands to gradually produce body
 
124
# data rather than passing it as a string; they could perhaps pass an
 
125
# iterator-like callback that will gradually yield data; it probably needs a
 
126
# close() method that will always be closed to do any necessary cleanup.
 
127
#
 
128
# TODO: Split the actual smart server from the ssh encoding of it.
 
129
#
 
130
# TODO: Perhaps support file-level readwrite operations over the transport
 
131
# too.
 
132
#
 
133
# TODO: SmartBzrDir class, proxying all Branch etc methods across to another
 
134
# branch doing file-level operations.
 
135
#
 
136
# TODO: jam 20060915 _decode_tuple is acting directly on input over
 
137
#       the socket, and it assumes everything is UTF8 sections separated
 
138
#       by \001. Which means a request like '\002' Will abort the connection
 
139
#       because of a UnicodeDecodeError. It does look like invalid data will
 
140
#       kill the SmartStreamServer, but only with an abort + exception, and 
 
141
#       the overall server shouldn't die.
24
142
 
25
143
from cStringIO import StringIO
 
144
import errno
 
145
import os
 
146
import socket
 
147
import sys
 
148
import tempfile
 
149
import threading
26
150
import urllib
27
151
import urlparse
28
152
 
29
153
from bzrlib import (
 
154
    bzrdir,
30
155
    errors,
 
156
    revision,
31
157
    transport,
 
158
    trace,
32
159
    urlutils,
33
160
    )
34
 
from bzrlib.smart import client, medium, protocol
 
161
from bzrlib.bundle.serializer import write_bundle
 
162
from bzrlib.trace import mutter
 
163
from bzrlib.transport import local
35
164
 
36
165
# must do this otherwise urllib can't parse the urls properly :(
37
 
for scheme in ['ssh', 'bzr', 'bzr+loopback', 'bzr+ssh', 'bzr+http']:
 
166
for scheme in ['ssh', 'bzr', 'bzr+loopback', 'bzr+ssh']:
38
167
    transport.register_urlparse_netloc_protocol(scheme)
39
168
del scheme
40
169
 
41
170
 
42
 
# Port 4155 is the default port for bzr://, registered with IANA.
43
 
BZR_DEFAULT_INTERFACE = '0.0.0.0'
44
 
BZR_DEFAULT_PORT = 4155
45
 
 
46
 
 
47
 
class _SmartStat(object):
 
171
def _recv_tuple(from_file):
 
172
    req_line = from_file.readline()
 
173
    return _decode_tuple(req_line)
 
174
 
 
175
 
 
176
def _decode_tuple(req_line):
 
177
    if req_line == None or req_line == '':
 
178
        return None
 
179
    if req_line[-1] != '\n':
 
180
        raise errors.SmartProtocolError("request %r not terminated" % req_line)
 
181
    return tuple((a.decode('utf-8') for a in req_line[:-1].split('\x01')))
 
182
 
 
183
 
 
184
def _encode_tuple(args):
 
185
    """Encode the tuple args to a bytestream."""
 
186
    return '\x01'.join((a.encode('utf-8') for a in args)) + '\n'
 
187
 
 
188
 
 
189
class SmartProtocolBase(object):
 
190
    """Methods common to client and server"""
 
191
 
 
192
    def _send_bulk_data(self, body):
 
193
        """Send chunked body data"""
 
194
        assert isinstance(body, str)
 
195
        bytes = ''.join(('%d\n' % len(body), body, 'done\n'))
 
196
        self._write_and_flush(bytes)
 
197
 
 
198
    # TODO: this only actually accomodates a single block; possibly should support
 
199
    # multiple chunks?
 
200
    def _recv_bulk(self):
 
201
        chunk_len = self._in.readline()
 
202
        try:
 
203
            chunk_len = int(chunk_len)
 
204
        except ValueError:
 
205
            raise errors.SmartProtocolError("bad chunk length line %r" % chunk_len)
 
206
        bulk = self._in.read(chunk_len)
 
207
        if len(bulk) != chunk_len:
 
208
            raise errors.SmartProtocolError("short read fetching bulk data chunk")
 
209
        self._recv_trailer()
 
210
        return bulk
 
211
 
 
212
    def _recv_tuple(self):
 
213
        return _recv_tuple(self._in)
 
214
 
 
215
    def _recv_trailer(self):
 
216
        resp = self._recv_tuple()
 
217
        if resp == ('done', ):
 
218
            return
 
219
        else:
 
220
            self._translate_error(resp)
 
221
 
 
222
    def _serialise_offsets(self, offsets):
 
223
        """Serialise a readv offset list."""
 
224
        txt = []
 
225
        for start, length in offsets:
 
226
            txt.append('%d,%d' % (start, length))
 
227
        return '\n'.join(txt)
 
228
 
 
229
    def _write_and_flush(self, bytes):
 
230
        """Write bytes to self._out and flush it."""
 
231
        # XXX: this will be inefficient.  Just ask Robert.
 
232
        self._out.write(bytes)
 
233
        self._out.flush()
 
234
 
 
235
 
 
236
class SmartStreamServer(SmartProtocolBase):
 
237
    """Handles smart commands coming over a stream.
 
238
 
 
239
    The stream may be a pipe connected to sshd, or a tcp socket, or an
 
240
    in-process fifo for testing.
 
241
 
 
242
    One instance is created for each connected client; it can serve multiple
 
243
    requests in the lifetime of the connection.
 
244
 
 
245
    The server passes requests through to an underlying backing transport, 
 
246
    which will typically be a LocalTransport looking at the server's filesystem.
 
247
    """
 
248
 
 
249
    def __init__(self, in_file, out_file, backing_transport):
 
250
        """Construct new server.
 
251
 
 
252
        :param in_file: Python file from which requests can be read.
 
253
        :param out_file: Python file to write responses.
 
254
        :param backing_transport: Transport for the directory served.
 
255
        """
 
256
        self._in = in_file
 
257
        self._out = out_file
 
258
        self.smart_server = SmartServer(backing_transport)
 
259
        # server can call back to us to get bulk data - this is not really
 
260
        # ideal, they should get it per request instead
 
261
        self.smart_server._recv_body = self._recv_bulk
 
262
 
 
263
    def _recv_tuple(self):
 
264
        """Read a request from the client and return as a tuple.
 
265
        
 
266
        Returns None at end of file (if the client closed the connection.)
 
267
        """
 
268
        return _recv_tuple(self._in)
 
269
 
 
270
    def _send_tuple(self, args):
 
271
        """Send response header"""
 
272
        return self._write_and_flush(_encode_tuple(args))
 
273
 
 
274
    def _send_error_and_disconnect(self, exception):
 
275
        self._send_tuple(('error', str(exception)))
 
276
        ## self._out.close()
 
277
        ## self._in.close()
 
278
 
 
279
    def _serve_one_request(self):
 
280
        """Read one request from input, process, send back a response.
 
281
        
 
282
        :return: False if the server should terminate, otherwise None.
 
283
        """
 
284
        req_args = self._recv_tuple()
 
285
        if req_args == None:
 
286
            # client closed connection
 
287
            return False  # shutdown server
 
288
        try:
 
289
            response = self.smart_server.dispatch_command(req_args[0], req_args[1:])
 
290
            self._send_tuple(response.args)
 
291
            if response.body is not None:
 
292
                self._send_bulk_data(response.body)
 
293
        except KeyboardInterrupt:
 
294
            raise
 
295
        except Exception, e:
 
296
            # everything else: pass to client, flush, and quit
 
297
            self._send_error_and_disconnect(e)
 
298
            return False
 
299
 
 
300
    def serve(self):
 
301
        """Serve requests until the client disconnects."""
 
302
        # Keep a reference to stderr because the sys module's globals get set to
 
303
        # None during interpreter shutdown.
 
304
        from sys import stderr
 
305
        try:
 
306
            while self._serve_one_request() != False:
 
307
                pass
 
308
        except Exception, e:
 
309
            stderr.write("%s terminating on exception %s\n" % (self, e))
 
310
            raise
 
311
 
 
312
 
 
313
class SmartServerResponse(object):
 
314
    """Response generated by SmartServer."""
 
315
 
 
316
    def __init__(self, args, body=None):
 
317
        self.args = args
 
318
        self.body = body
 
319
 
 
320
# XXX: TODO: Create a SmartServerRequest which will take the responsibility
 
321
# for delivering the data for a request. This could be done with as the
 
322
# StreamServer, though that would create conflation between request and response
 
323
# which may be undesirable.
 
324
 
 
325
 
 
326
class SmartServer(object):
 
327
    """Protocol logic for smart server.
 
328
    
 
329
    This doesn't handle serialization at all, it just processes requests and
 
330
    creates responses.
 
331
    """
 
332
 
 
333
    # IMPORTANT FOR IMPLEMENTORS: It is important that SmartServer not contain
 
334
    # encoding or decoding logic to allow the wire protocol to vary from the
 
335
    # object protocol: we will want to tweak the wire protocol separate from
 
336
    # the object model, and ideally we will be able to do that without having
 
337
    # a SmartServer subclass for each wire protocol, rather just a Protocol
 
338
    # subclass.
 
339
 
 
340
    # TODO: Better way of representing the body for commands that take it,
 
341
    # and allow it to be streamed into the server.
 
342
    
 
343
    def __init__(self, backing_transport):
 
344
        self._backing_transport = backing_transport
 
345
        
 
346
    def do_hello(self):
 
347
        """Answer a version request with my version."""
 
348
        return SmartServerResponse(('ok', '1'))
 
349
 
 
350
    def do_has(self, relpath):
 
351
        r = self._backing_transport.has(relpath) and 'yes' or 'no'
 
352
        return SmartServerResponse((r,))
 
353
 
 
354
    def do_get(self, relpath):
 
355
        backing_bytes = self._backing_transport.get_bytes(relpath)
 
356
        return SmartServerResponse(('ok',), backing_bytes)
 
357
 
 
358
    def _deserialise_optional_mode(self, mode):
 
359
        # XXX: FIXME this should be on the protocol object.
 
360
        if mode == '':
 
361
            return None
 
362
        else:
 
363
            return int(mode)
 
364
 
 
365
    def do_append(self, relpath, mode):
 
366
        old_length = self._backing_transport.append_bytes(
 
367
            relpath, self._recv_body(), self._deserialise_optional_mode(mode))
 
368
        return SmartServerResponse(('appended', '%d' % old_length))
 
369
 
 
370
    def do_delete(self, relpath):
 
371
        self._backing_transport.delete(relpath)
 
372
 
 
373
    def do_iter_files_recursive(self, abspath):
 
374
        # XXX: the path handling needs some thought.
 
375
        #relpath = self._backing_transport.relpath(abspath)
 
376
        transport = self._backing_transport.clone(abspath)
 
377
        filenames = transport.iter_files_recursive()
 
378
        return SmartServerResponse(('names',) + tuple(filenames))
 
379
 
 
380
    def do_list_dir(self, relpath):
 
381
        filenames = self._backing_transport.list_dir(relpath)
 
382
        return SmartServerResponse(('names',) + tuple(filenames))
 
383
 
 
384
    def do_mkdir(self, relpath, mode):
 
385
        self._backing_transport.mkdir(relpath,
 
386
                                      self._deserialise_optional_mode(mode))
 
387
 
 
388
    def do_move(self, rel_from, rel_to):
 
389
        self._backing_transport.move(rel_from, rel_to)
 
390
 
 
391
    def do_put(self, relpath, mode):
 
392
        self._backing_transport.put_bytes(relpath,
 
393
                self._recv_body(),
 
394
                self._deserialise_optional_mode(mode))
 
395
 
 
396
    def _deserialise_offsets(self, text):
 
397
        # XXX: FIXME this should be on the protocol object.
 
398
        offsets = []
 
399
        for line in text.split('\n'):
 
400
            if not line:
 
401
                continue
 
402
            start, length = line.split(',')
 
403
            offsets.append((int(start), int(length)))
 
404
        return offsets
 
405
 
 
406
    def do_put_non_atomic(self, relpath, mode, create_parent, dir_mode):
 
407
        create_parent_dir = (create_parent == 'T')
 
408
        self._backing_transport.put_bytes_non_atomic(relpath,
 
409
                self._recv_body(),
 
410
                mode=self._deserialise_optional_mode(mode),
 
411
                create_parent_dir=create_parent_dir,
 
412
                dir_mode=self._deserialise_optional_mode(dir_mode))
 
413
 
 
414
    def do_readv(self, relpath):
 
415
        offsets = self._deserialise_offsets(self._recv_body())
 
416
        backing_bytes = ''.join(bytes for offset, bytes in
 
417
                             self._backing_transport.readv(relpath, offsets))
 
418
        return SmartServerResponse(('readv',), backing_bytes)
 
419
        
 
420
    def do_rename(self, rel_from, rel_to):
 
421
        self._backing_transport.rename(rel_from, rel_to)
 
422
 
 
423
    def do_rmdir(self, relpath):
 
424
        self._backing_transport.rmdir(relpath)
 
425
 
 
426
    def do_stat(self, relpath):
 
427
        stat = self._backing_transport.stat(relpath)
 
428
        return SmartServerResponse(('stat', str(stat.st_size), oct(stat.st_mode)))
 
429
        
 
430
    def do_get_bundle(self, path, revision_id):
 
431
        # open transport relative to our base
 
432
        t = self._backing_transport.clone(path)
 
433
        control, extra_path = bzrdir.BzrDir.open_containing_from_transport(t)
 
434
        repo = control.open_repository()
 
435
        tmpf = tempfile.TemporaryFile()
 
436
        base_revision = revision.NULL_REVISION
 
437
        write_bundle(repo, revision_id, base_revision, tmpf)
 
438
        tmpf.seek(0)
 
439
        return SmartServerResponse((), tmpf.read())
 
440
 
 
441
    def dispatch_command(self, cmd, args):
 
442
        func = getattr(self, 'do_' + cmd, None)
 
443
        if func is None:
 
444
            raise errors.SmartProtocolError("bad request %r" % (cmd,))
 
445
        try:
 
446
            result = func(*args)
 
447
            if result is None: 
 
448
                result = SmartServerResponse(('ok',))
 
449
            return result
 
450
        except errors.NoSuchFile, e:
 
451
            return SmartServerResponse(('NoSuchFile', e.path))
 
452
        except errors.FileExists, e:
 
453
            return SmartServerResponse(('FileExists', e.path))
 
454
        except errors.DirectoryNotEmpty, e:
 
455
            return SmartServerResponse(('DirectoryNotEmpty', e.path))
 
456
        except errors.ShortReadvError, e:
 
457
            return SmartServerResponse(('ShortReadvError',
 
458
                e.path, str(e.offset), str(e.length), str(e.actual)))
 
459
        except UnicodeError, e:
 
460
            # If it is a DecodeError, than most likely we are starting
 
461
            # with a plain string
 
462
            str_or_unicode = e.object
 
463
            if isinstance(str_or_unicode, unicode):
 
464
                val = u'u:' + str_or_unicode
 
465
            else:
 
466
                val = u's:' + str_or_unicode.encode('base64')
 
467
            # This handles UnicodeEncodeError or UnicodeDecodeError
 
468
            return SmartServerResponse((e.__class__.__name__,
 
469
                    e.encoding, val, str(e.start), str(e.end), e.reason))
 
470
        except errors.TransportNotPossible, e:
 
471
            if e.msg == "readonly transport":
 
472
                return SmartServerResponse(('ReadOnlyError', ))
 
473
            else:
 
474
                raise
 
475
 
 
476
 
 
477
class SmartTCPServer(object):
 
478
    """Listens on a TCP socket and accepts connections from smart clients"""
 
479
 
 
480
    def __init__(self, backing_transport=None, host='127.0.0.1', port=0):
 
481
        """Construct a new server.
 
482
 
 
483
        To actually start it running, call either start_background_thread or
 
484
        serve.
 
485
 
 
486
        :param host: Name of the interface to listen on.
 
487
        :param port: TCP port to listen on, or 0 to allocate a transient port.
 
488
        """
 
489
        if backing_transport is None:
 
490
            backing_transport = memory.MemoryTransport()
 
491
        self._server_socket = socket.socket()
 
492
        self._server_socket.bind((host, port))
 
493
        self.port = self._server_socket.getsockname()[1]
 
494
        self._server_socket.listen(1)
 
495
        self._server_socket.settimeout(1)
 
496
        self.backing_transport = backing_transport
 
497
 
 
498
    def serve(self):
 
499
        # let connections timeout so that we get a chance to terminate
 
500
        # Keep a reference to the exceptions we want to catch because the socket
 
501
        # module's globals get set to None during interpreter shutdown.
 
502
        from socket import timeout as socket_timeout
 
503
        from socket import error as socket_error
 
504
        self._should_terminate = False
 
505
        while not self._should_terminate:
 
506
            try:
 
507
                self.accept_and_serve()
 
508
            except socket_timeout:
 
509
                # just check if we're asked to stop
 
510
                pass
 
511
            except socket_error, e:
 
512
                trace.warning("client disconnected: %s", e)
 
513
                pass
 
514
 
 
515
    def get_url(self):
 
516
        """Return the url of the server"""
 
517
        return "bzr://%s:%d/" % self._server_socket.getsockname()
 
518
 
 
519
    def accept_and_serve(self):
 
520
        conn, client_addr = self._server_socket.accept()
 
521
        # For WIN32, where the timeout value from the listening socket
 
522
        # propogates to the newly accepted socket.
 
523
        conn.setblocking(True)
 
524
        conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
 
525
        from_client = conn.makefile('r')
 
526
        to_client = conn.makefile('w')
 
527
        handler = SmartStreamServer(from_client, to_client,
 
528
                self.backing_transport)
 
529
        connection_thread = threading.Thread(None, handler.serve, name='smart-server-child')
 
530
        connection_thread.setDaemon(True)
 
531
        connection_thread.start()
 
532
 
 
533
    def start_background_thread(self):
 
534
        self._server_thread = threading.Thread(None,
 
535
                self.serve,
 
536
                name='server-' + self.get_url())
 
537
        self._server_thread.setDaemon(True)
 
538
        self._server_thread.start()
 
539
 
 
540
    def stop_background_thread(self):
 
541
        self._should_terminate = True
 
542
        # self._server_socket.close()
 
543
        # we used to join the thread, but it's not really necessary; it will
 
544
        # terminate in time
 
545
        ## self._server_thread.join()
 
546
 
 
547
 
 
548
class SmartTCPServer_for_testing(SmartTCPServer):
 
549
    """Server suitable for use by transport tests.
 
550
    
 
551
    This server is backed by the process's cwd.
 
552
    """
 
553
 
 
554
    def __init__(self):
 
555
        self._homedir = urlutils.local_path_to_url(os.getcwd())[7:]
 
556
        # The server is set up by default like for ssh access: the client
 
557
        # passes filesystem-absolute paths; therefore the server must look
 
558
        # them up relative to the root directory.  it might be better to act
 
559
        # a public server and have the server rewrite paths into the test
 
560
        # directory.
 
561
        SmartTCPServer.__init__(self,
 
562
            transport.get_transport(urlutils.local_path_to_url('/')))
 
563
        
 
564
    def setUp(self):
 
565
        """Set up server for testing"""
 
566
        self.start_background_thread()
 
567
 
 
568
    def tearDown(self):
 
569
        self.stop_background_thread()
 
570
 
 
571
    def get_url(self):
 
572
        """Return the url of the server"""
 
573
        host, port = self._server_socket.getsockname()
 
574
        return "bzr://%s:%d%s" % (host, port, urlutils.escape(self._homedir))
 
575
 
 
576
    def get_bogus_url(self):
 
577
        """Return a URL which will fail to connect"""
 
578
        return 'bzr://127.0.0.1:1/'
 
579
 
 
580
 
 
581
class SmartStat(object):
48
582
 
49
583
    def __init__(self, size, mode):
50
584
        self.st_size = size
51
585
        self.st_mode = mode
52
586
 
53
587
 
54
 
class RemoteTransport(transport.ConnectedTransport):
 
588
class SmartTransport(transport.Transport):
55
589
    """Connection to a smart server.
56
590
 
57
 
    The connection holds references to the medium that can be used to send
58
 
    requests to the server.
 
591
    The connection holds references to pipes that can be used to send requests
 
592
    to the server.
59
593
 
60
594
    The connection has a notion of the current directory to which it's
61
595
    connected; this is incorporated in filenames passed to the server.
63
597
    This supports some higher-level RPC operations and can also be treated 
64
598
    like a Transport to do file-like operations.
65
599
 
66
 
    The connection can be made over a tcp socket, an ssh pipe or a series of
67
 
    http requests.  There are concrete subclasses for each type:
68
 
    RemoteTCPTransport, etc.
 
600
    The connection can be made over a tcp socket, or (in future) an ssh pipe
 
601
    or a series of http requests.  There are concrete subclasses for each
 
602
    type: SmartTCPTransport, etc.
69
603
    """
70
604
 
71
 
    # IMPORTANT FOR IMPLEMENTORS: RemoteTransport MUST NOT be given encoding
 
605
    # IMPORTANT FOR IMPLEMENTORS: SmartTransport MUST NOT be given encoding
72
606
    # responsibilities: Put those on SmartClient or similar. This is vital for
73
607
    # the ability to support multiple versions of the smart protocol over time:
74
 
    # RemoteTransport is an adapter from the Transport object model to the 
 
608
    # SmartTransport is an adapter from the Transport object model to the 
75
609
    # SmartClient model, not an encoder.
76
610
 
77
 
    # FIXME: the medium parameter should be private, only the tests requires
78
 
    # it. It may be even clearer to define a TestRemoteTransport that handles
79
 
    # the specific cases of providing a _client and/or a _medium, and leave
80
 
    # RemoteTransport as an abstract class.
81
 
    def __init__(self, url, from_transport=None, medium=None, _client=None):
 
611
    def __init__(self, url, clone_from=None, client=None):
82
612
        """Constructor.
83
613
 
84
 
        :param from_transport: Another RemoteTransport instance that this
85
 
            one is being cloned from.  Attributes such as the medium will
86
 
            be reused.
87
 
 
88
 
        :param medium: The medium to use for this RemoteTransport. This must be
89
 
            supplied if from_transport is None.
90
 
 
91
 
        :param _client: Override the _SmartClient used by this transport.  This
92
 
            should only be used for testing purposes; normally this is
93
 
            determined from the medium.
94
 
        """
95
 
        super(RemoteTransport, self).__init__(url, from_transport)
96
 
 
97
 
        # The medium is the connection, except when we need to share it with
98
 
        # other objects (RemoteBzrDir, RemoteRepository etc). In these cases
99
 
        # what we want to share is really the shared connection.
100
 
 
101
 
        if from_transport is None:
102
 
            # If no from_transport is specified, we need to intialize the
103
 
            # shared medium.
104
 
            credentials = None
105
 
            if medium is None:
106
 
                medium, credentials = self._build_medium()
107
 
            self._shared_connection= transport._SharedConnection(medium,
108
 
                                                                 credentials)
109
 
 
110
 
        if _client is None:
111
 
            self._client = client._SmartClient(self.get_shared_medium())
112
 
        else:
113
 
            self._client = _client
114
 
 
115
 
    def _build_medium(self):
116
 
        """Create the medium if from_transport does not provide one.
117
 
 
118
 
        The medium is analogous to the connection for ConnectedTransport: it
119
 
        allows connection sharing.
120
 
        """
121
 
        # No credentials
122
 
        return None, None
 
614
        :param client: ignored when clone_from is not None.
 
615
        """
 
616
        ### Technically super() here is faulty because Transport's __init__
 
617
        ### fails to take 2 parameters, and if super were to choose a silly
 
618
        ### initialisation order things would blow up. 
 
619
        if not url.endswith('/'):
 
620
            url += '/'
 
621
        super(SmartTransport, self).__init__(url)
 
622
        self._scheme, self._username, self._password, self._host, self._port, self._path = \
 
623
                transport.split_url(url)
 
624
        if clone_from is None:
 
625
            if client is None:
 
626
                self._client = SmartStreamClient(self._connect_to_server)
 
627
            else:
 
628
                self._client = client
 
629
        else:
 
630
            # credentials may be stripped from the base in some circumstances
 
631
            # as yet to be clearly defined or documented, so copy them.
 
632
            self._username = clone_from._username
 
633
            # reuse same connection
 
634
            self._client = clone_from._client
 
635
 
 
636
    def abspath(self, relpath):
 
637
        """Return the full url to the given relative path.
 
638
        
 
639
        @param relpath: the relative path or path components
 
640
        @type relpath: str or list
 
641
        """
 
642
        return self._unparse_url(self._remote_path(relpath))
 
643
    
 
644
    def clone(self, relative_url):
 
645
        """Make a new SmartTransport related to me, sharing the same connection.
 
646
 
 
647
        This essentially opens a handle on a different remote directory.
 
648
        """
 
649
        if relative_url is None:
 
650
            return self.__class__(self.base, self)
 
651
        else:
 
652
            return self.__class__(self.abspath(relative_url), self)
123
653
 
124
654
    def is_readonly(self):
125
655
        """Smart server transport can do read/write file operations."""
126
 
        resp = self._call2('Transport.is_readonly')
127
 
        if resp == ('yes', ):
128
 
            return True
129
 
        elif resp == ('no', ):
130
 
            return False
131
 
        elif (resp == ('error', "Generic bzr smart protocol error: "
132
 
                                "bad request 'Transport.is_readonly'") or
133
 
              resp == ('error', "Generic bzr smart protocol error: "
134
 
                                "bad request u'Transport.is_readonly'")):
135
 
            # XXX: nasty hack: servers before 0.16 don't have a
136
 
            # 'Transport.is_readonly' verb, so we do what clients before 0.16
137
 
            # did: assume False.
138
 
            return False
139
 
        else:
140
 
            self._translate_error(resp)
141
 
        raise errors.UnexpectedSmartServerResponse(resp)
142
 
 
 
656
        return False
 
657
                                                   
143
658
    def get_smart_client(self):
144
 
        return self._get_connection()
145
 
 
146
 
    def get_smart_medium(self):
147
 
        return self._get_connection()
148
 
 
149
 
    def get_shared_medium(self):
150
 
        return self._get_shared_connection()
 
659
        return self._client
 
660
                                                   
 
661
    def _unparse_url(self, path):
 
662
        """Return URL for a path.
 
663
 
 
664
        :see: SFTPUrlHandling._unparse_url
 
665
        """
 
666
        # TODO: Eventually it should be possible to unify this with
 
667
        # SFTPUrlHandling._unparse_url?
 
668
        if path == '':
 
669
            path = '/'
 
670
        path = urllib.quote(path)
 
671
        netloc = urllib.quote(self._host)
 
672
        if self._username is not None:
 
673
            netloc = '%s@%s' % (urllib.quote(self._username), netloc)
 
674
        if self._port is not None:
 
675
            netloc = '%s:%d' % (netloc, self._port)
 
676
        return urlparse.urlunparse((self._scheme, netloc, path, '', '', ''))
151
677
 
152
678
    def _remote_path(self, relpath):
153
679
        """Returns the Unicode version of the absolute path for relpath."""
154
680
        return self._combine_paths(self._path, relpath)
155
681
 
156
 
    def _call(self, method, *args):
157
 
        resp = self._call2(method, *args)
158
 
        self._translate_error(resp)
159
 
 
160
 
    def _call2(self, method, *args):
161
 
        """Call a method on the remote server."""
162
 
        return self._client.call(method, *args)
163
 
 
164
 
    def _call_with_body_bytes(self, method, args, body):
165
 
        """Call a method on the remote server with body bytes."""
166
 
        return self._client.call_with_body_bytes(method, args, body)
167
 
 
168
682
    def has(self, relpath):
169
683
        """Indicate whether a remote file of the given name exists or not.
170
684
 
171
685
        :see: Transport.has()
172
686
        """
173
 
        resp = self._call2('has', self._remote_path(relpath))
 
687
        resp = self._client._call('has', self._remote_path(relpath))
174
688
        if resp == ('yes', ):
175
689
            return True
176
690
        elif resp == ('no', ):
183
697
        
184
698
        :see: Transport.get_bytes()/get_file()
185
699
        """
186
 
        return StringIO(self.get_bytes(relpath))
187
 
 
188
 
    def get_bytes(self, relpath):
189
700
        remote = self._remote_path(relpath)
190
 
        request = self.get_smart_medium().get_request()
191
 
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
192
 
        smart_protocol.call('get', remote)
193
 
        resp = smart_protocol.read_response_tuple(True)
 
701
        resp = self._client._call('get', remote)
194
702
        if resp != ('ok', ):
195
 
            smart_protocol.cancel_read_body()
196
703
            self._translate_error(resp, relpath)
197
 
        return smart_protocol.read_body_bytes()
 
704
        return StringIO(self._client._recv_bulk())
198
705
 
199
706
    def _serialise_optional_mode(self, mode):
200
707
        if mode is None:
203
710
            return '%d' % mode
204
711
 
205
712
    def mkdir(self, relpath, mode=None):
206
 
        resp = self._call2('mkdir', self._remote_path(relpath),
207
 
            self._serialise_optional_mode(mode))
 
713
        resp = self._client._call('mkdir', 
 
714
                                  self._remote_path(relpath), 
 
715
                                  self._serialise_optional_mode(mode))
208
716
        self._translate_error(resp)
209
717
 
210
718
    def put_bytes(self, relpath, upload_contents, mode=None):
211
719
        # FIXME: upload_file is probably not safe for non-ascii characters -
212
720
        # should probably just pass all parameters as length-delimited
213
721
        # strings?
214
 
        if type(upload_contents) is unicode:
215
 
            # Although not strictly correct, we raise UnicodeEncodeError to be
216
 
            # compatible with other transports.
217
 
            raise UnicodeEncodeError(
218
 
                'undefined', upload_contents, 0, 1,
219
 
                'put_bytes must be given bytes, not unicode.')
220
 
        resp = self._call_with_body_bytes('put',
 
722
        resp = self._client._call_with_upload(
 
723
            'put',
221
724
            (self._remote_path(relpath), self._serialise_optional_mode(mode)),
222
725
            upload_contents)
223
726
        self._translate_error(resp)
231
734
        if create_parent_dir:
232
735
            create_parent_str = 'T'
233
736
 
234
 
        resp = self._call_with_body_bytes(
 
737
        resp = self._client._call_with_upload(
235
738
            'put_non_atomic',
236
739
            (self._remote_path(relpath), self._serialise_optional_mode(mode),
237
740
             create_parent_str, self._serialise_optional_mode(dir_mode)),
260
763
        return self.append_bytes(relpath, from_file.read(), mode)
261
764
        
262
765
    def append_bytes(self, relpath, bytes, mode=None):
263
 
        resp = self._call_with_body_bytes(
 
766
        resp = self._client._call_with_upload(
264
767
            'append',
265
768
            (self._remote_path(relpath), self._serialise_optional_mode(mode)),
266
769
            bytes)
269
772
        self._translate_error(resp)
270
773
 
271
774
    def delete(self, relpath):
272
 
        resp = self._call2('delete', self._remote_path(relpath))
 
775
        resp = self._client._call('delete', self._remote_path(relpath))
273
776
        self._translate_error(resp)
274
777
 
275
778
    def readv(self, relpath, offsets):
286
789
                               limit=self._max_readv_combine,
287
790
                               fudge_factor=self._bytes_to_read_before_seek))
288
791
 
289
 
        request = self.get_smart_medium().get_request()
290
 
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
291
 
        smart_protocol.call_with_body_readv_array(
292
 
            ('readv', self._remote_path(relpath)),
293
 
            [(c.start, c.length) for c in coalesced])
294
 
        resp = smart_protocol.read_response_tuple(True)
 
792
 
 
793
        resp = self._client._call_with_upload(
 
794
            'readv',
 
795
            (self._remote_path(relpath),),
 
796
            self._client._serialise_offsets((c.start, c.length) for c in coalesced))
295
797
 
296
798
        if resp[0] != 'readv':
297
799
            # This should raise an exception
298
 
            smart_protocol.cancel_read_body()
299
800
            self._translate_error(resp)
300
801
            return
301
802
 
302
 
        # FIXME: this should know how many bytes are needed, for clarity.
303
 
        data = smart_protocol.read_body_bytes()
 
803
        data = self._client._recv_bulk()
304
804
        # Cache the results, but only until they have been fulfilled
305
805
        data_map = {}
306
806
        for c_offset in coalesced:
319
819
                cur_offset_and_size = offset_stack.next()
320
820
 
321
821
    def rename(self, rel_from, rel_to):
322
 
        self._call('rename',
 
822
        self._call('rename', 
323
823
                   self._remote_path(rel_from),
324
824
                   self._remote_path(rel_to))
325
825
 
326
826
    def move(self, rel_from, rel_to):
327
 
        self._call('move',
 
827
        self._call('move', 
328
828
                   self._remote_path(rel_from),
329
829
                   self._remote_path(rel_to))
330
830
 
331
831
    def rmdir(self, relpath):
332
832
        resp = self._call('rmdir', self._remote_path(relpath))
333
833
 
 
834
    def _call(self, method, *args):
 
835
        resp = self._client._call(method, *args)
 
836
        self._translate_error(resp)
 
837
 
334
838
    def _translate_error(self, resp, orig_path=None):
335
839
        """Raise an exception from a response"""
336
840
        if resp is None:
361
865
            end = int(resp[4])
362
866
            reason = str(resp[5]) # reason must always be a string
363
867
            if val.startswith('u:'):
364
 
                val = val[2:].decode('utf-8')
 
868
                val = val[2:]
365
869
            elif val.startswith('s:'):
366
870
                val = val[2:].decode('base64')
367
871
            if what == 'UnicodeDecodeError':
370
874
                raise UnicodeEncodeError(encoding, val, start, end, reason)
371
875
        elif what == "ReadOnlyError":
372
876
            raise errors.TransportNotPossible('readonly transport')
373
 
        elif what == "ReadError":
374
 
            if orig_path is not None:
375
 
                error_path = orig_path
376
 
            else:
377
 
                error_path = resp[1]
378
 
            raise errors.ReadError(error_path)
379
877
        else:
380
878
            raise errors.SmartProtocolError('unexpected smart server error: %r' % (resp,))
381
879
 
 
880
    def _send_tuple(self, args):
 
881
        self._client._send_tuple(args)
 
882
 
 
883
    def _recv_tuple(self):
 
884
        return self._client._recv_tuple()
 
885
 
382
886
    def disconnect(self):
383
 
        self.get_smart_medium().disconnect()
 
887
        self._client.disconnect()
384
888
 
385
889
    def delete_tree(self, relpath):
386
890
        raise errors.TransportNotPossible('readonly transport')
387
891
 
388
892
    def stat(self, relpath):
389
 
        resp = self._call2('stat', self._remote_path(relpath))
 
893
        resp = self._client._call('stat', self._remote_path(relpath))
390
894
        if resp[0] == 'stat':
391
 
            return _SmartStat(int(resp[1]), int(resp[2], 8))
 
895
            return SmartStat(int(resp[1]), int(resp[2], 8))
392
896
        else:
393
897
            self._translate_error(resp)
394
898
 
409
913
        return True
410
914
 
411
915
    def list_dir(self, relpath):
412
 
        resp = self._call2('list_dir', self._remote_path(relpath))
 
916
        resp = self._client._call('list_dir',
 
917
                                  self._remote_path(relpath))
413
918
        if resp[0] == 'names':
414
919
            return [name.encode('ascii') for name in resp[1:]]
415
920
        else:
416
921
            self._translate_error(resp)
417
922
 
418
923
    def iter_files_recursive(self):
419
 
        resp = self._call2('iter_files_recursive', self._remote_path(''))
 
924
        resp = self._client._call('iter_files_recursive',
 
925
                                  self._remote_path(''))
420
926
        if resp[0] == 'names':
421
927
            return resp[1:]
422
928
        else:
423
929
            self._translate_error(resp)
424
930
 
425
931
 
426
 
class RemoteTCPTransport(RemoteTransport):
427
 
    """Connection to smart server over plain tcp.
428
 
    
429
 
    This is essentially just a factory to get 'RemoteTransport(url,
430
 
        SmartTCPClientMedium).
431
 
    """
432
 
 
433
 
    def __init__(self, base, from_transport=None):
434
 
        assert base.startswith('bzr://')
435
 
        super(RemoteTCPTransport, self).__init__(base, from_transport)
436
 
 
437
 
    def _build_medium(self):
438
 
        if self._port is None:
439
 
            self._port = BZR_DEFAULT_PORT
440
 
        return medium.SmartTCPClientMedium(self._host, self._port), None
441
 
 
442
 
 
443
 
class RemoteSSHTransport(RemoteTransport):
444
 
    """Connection to smart server over SSH.
445
 
 
446
 
    This is essentially just a factory to get 'RemoteTransport(url,
447
 
        SmartSSHClientMedium).
448
 
    """
449
 
 
450
 
    def _build_medium(self):
451
 
        assert self.base.startswith('bzr+ssh://')
452
 
        # ssh will prompt the user for a password if needed and if none is
453
 
        # provided but it will not give it back, so no credentials can be
454
 
        # stored.
455
 
        return medium.SmartSSHClientMedium(self._host, self._port,
456
 
                                           self._user, self._password), None
457
 
 
458
 
 
459
 
class RemoteHTTPTransport(RemoteTransport):
460
 
    """Just a way to connect between a bzr+http:// url and http://.
461
 
    
462
 
    This connection operates slightly differently than the RemoteSSHTransport.
463
 
    It uses a plain http:// transport underneath, which defines what remote
464
 
    .bzr/smart URL we are connected to. From there, all paths that are sent are
465
 
    sent as relative paths, this way, the remote side can properly
466
 
    de-reference them, since it is likely doing rewrite rules to translate an
467
 
    HTTP path into a local path.
468
 
    """
469
 
 
470
 
    def __init__(self, base, from_transport=None, http_transport=None):
471
 
        assert base.startswith('bzr+http://')
472
 
 
473
 
        if http_transport is None:
474
 
            # FIXME: the password may be lost here because it appears in the
475
 
            # url only for an intial construction (when the url came from the
476
 
            # command-line).
477
 
            http_url = base[len('bzr+'):]
478
 
            self._http_transport = transport.get_transport(http_url)
479
 
        else:
480
 
            self._http_transport = http_transport
481
 
        super(RemoteHTTPTransport, self).__init__(base, from_transport)
482
 
 
483
 
    def _build_medium(self):
484
 
        # We let http_transport take care of the credentials
485
 
        return self._http_transport.get_smart_medium(), None
486
 
 
487
 
    def _remote_path(self, relpath):
488
 
        """After connecting, HTTP Transport only deals in relative URLs."""
489
 
        # Adjust the relpath based on which URL this smart transport is
490
 
        # connected to.
491
 
        http_base = urlutils.normalize_url(self._http_transport.base)
492
 
        url = urlutils.join(self.base[len('bzr+'):], relpath)
493
 
        url = urlutils.normalize_url(url)
494
 
        return urlutils.relative_url(http_base, url)
495
 
 
496
 
    def clone(self, relative_url):
497
 
        """Make a new RemoteHTTPTransport related to me.
498
 
 
499
 
        This is re-implemented rather than using the default
500
 
        RemoteTransport.clone() because we must be careful about the underlying
501
 
        http transport.
502
 
 
503
 
        Also, the cloned smart transport will POST to the same .bzr/smart
504
 
        location as this transport (although obviously the relative paths in the
505
 
        smart requests may be different).  This is so that the server doesn't
506
 
        have to handle .bzr/smart requests at arbitrary places inside .bzr
507
 
        directories, just at the initial URL the user uses.
508
 
 
509
 
        The exception is parent paths (i.e. relative_url of "..").
 
932
class SmartStreamClient(SmartProtocolBase):
 
933
    """Connection to smart server over two streams"""
 
934
 
 
935
    def __init__(self, connect_func):
 
936
        self._connect_func = connect_func
 
937
        self._connected = False
 
938
 
 
939
    def __del__(self):
 
940
        self.disconnect()
 
941
 
 
942
    def _ensure_connection(self):
 
943
        if not self._connected:
 
944
            self._in, self._out = self._connect_func()
 
945
            self._connected = True
 
946
 
 
947
    def _send_tuple(self, args):
 
948
        self._ensure_connection()
 
949
        return self._write_and_flush(_encode_tuple(args))
 
950
 
 
951
    def _send_bulk_data(self, body):
 
952
        self._ensure_connection()
 
953
        SmartProtocolBase._send_bulk_data(self, body)
 
954
        
 
955
    def _recv_bulk(self):
 
956
        self._ensure_connection()
 
957
        return SmartProtocolBase._recv_bulk(self)
 
958
 
 
959
    def _recv_tuple(self):
 
960
        self._ensure_connection()
 
961
        return SmartProtocolBase._recv_tuple(self)
 
962
 
 
963
    def _recv_trailer(self):
 
964
        self._ensure_connection()
 
965
        return SmartProtocolBase._recv_trailer(self)
 
966
 
 
967
    def disconnect(self):
 
968
        """Close connection to the server"""
 
969
        if self._connected:
 
970
            self._out.close()
 
971
            self._in.close()
 
972
 
 
973
    def _call(self, *args):
 
974
        self._send_tuple(args)
 
975
        return self._recv_tuple()
 
976
 
 
977
    def _call_with_upload(self, method, args, body):
 
978
        """Call an rpc, supplying bulk upload data.
 
979
 
 
980
        :param method: method name to call
 
981
        :param args: parameter args tuple
 
982
        :param body: upload body as a byte string
510
983
        """
511
 
        if relative_url:
512
 
            abs_url = self.abspath(relative_url)
513
 
        else:
514
 
            abs_url = self.base
515
 
        # We either use the exact same http_transport (for child locations), or
516
 
        # a clone of the underlying http_transport (for parent locations).  This
517
 
        # means we share the connection.
518
 
        norm_base = urlutils.normalize_url(self.base)
519
 
        norm_abs_url = urlutils.normalize_url(abs_url)
520
 
        normalized_rel_url = urlutils.relative_url(norm_base, norm_abs_url)
521
 
        if normalized_rel_url == ".." or normalized_rel_url.startswith("../"):
522
 
            http_transport = self._http_transport.clone(normalized_rel_url)
523
 
        else:
524
 
            http_transport = self._http_transport
525
 
        return RemoteHTTPTransport(abs_url, self, http_transport=http_transport)
 
984
        self._send_tuple((method,) + args)
 
985
        self._send_bulk_data(body)
 
986
        return self._recv_tuple()
 
987
 
 
988
    def query_version(self):
 
989
        """Return protocol version number of the server."""
 
990
        # XXX: should make sure it's empty
 
991
        self._send_tuple(('hello',))
 
992
        resp = self._recv_tuple()
 
993
        if resp == ('ok', '1'):
 
994
            return 1
 
995
        else:
 
996
            raise errors.SmartProtocolError("bad response %r" % (resp,))
 
997
 
 
998
 
 
999
class SmartTCPTransport(SmartTransport):
 
1000
    """Connection to smart server over plain tcp"""
 
1001
 
 
1002
    def __init__(self, url, clone_from=None):
 
1003
        super(SmartTCPTransport, self).__init__(url, clone_from)
 
1004
        try:
 
1005
            self._port = int(self._port)
 
1006
        except (ValueError, TypeError), e:
 
1007
            raise errors.InvalidURL(path=url, extra="invalid port %s" % self._port)
 
1008
        self._socket = None
 
1009
 
 
1010
    def _connect_to_server(self):
 
1011
        self._socket = socket.socket()
 
1012
        self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
 
1013
        result = self._socket.connect_ex((self._host, int(self._port)))
 
1014
        if result:
 
1015
            raise errors.ConnectionError("failed to connect to %s:%d: %s" %
 
1016
                    (self._host, self._port, os.strerror(result)))
 
1017
        # TODO: May be more efficient to just treat them as sockets
 
1018
        # throughout?  But what about pipes to ssh?...
 
1019
        to_server = self._socket.makefile('w')
 
1020
        from_server = self._socket.makefile('r')
 
1021
        return from_server, to_server
 
1022
 
 
1023
    def disconnect(self):
 
1024
        super(SmartTCPTransport, self).disconnect()
 
1025
        # XXX: Is closing the socket as well as closing the files really
 
1026
        # necessary?
 
1027
        if self._socket is not None:
 
1028
            self._socket.close()
 
1029
 
 
1030
 
 
1031
class SmartSSHTransport(SmartTransport):
 
1032
    """Connection to smart server over SSH."""
 
1033
 
 
1034
    def __init__(self, url, clone_from=None):
 
1035
        # TODO: all this probably belongs in the parent class.
 
1036
        super(SmartSSHTransport, self).__init__(url, clone_from)
 
1037
        try:
 
1038
            if self._port is not None:
 
1039
                self._port = int(self._port)
 
1040
        except (ValueError, TypeError), e:
 
1041
            raise errors.InvalidURL(path=url, extra="invalid port %s" % self._port)
 
1042
 
 
1043
    def _connect_to_server(self):
 
1044
        from bzrlib.transport import ssh
 
1045
        executable = os.environ.get('BZR_REMOTE_PATH', 'bzr')
 
1046
        vendor = ssh._get_ssh_vendor()
 
1047
        self._ssh_connection = vendor.connect_ssh(self._username,
 
1048
                self._password, self._host, self._port,
 
1049
                command=[executable, 'serve', '--inet', '--directory=/',
 
1050
                         '--allow-writes'])
 
1051
        return self._ssh_connection.get_filelike_channels()
 
1052
 
 
1053
    def disconnect(self):
 
1054
        super(SmartSSHTransport, self).disconnect()
 
1055
        self._ssh_connection.close()
526
1056
 
527
1057
 
528
1058
def get_test_permutations():
529
 
    """Return (transport, server) permutations for testing."""
530
 
    ### We may need a little more test framework support to construct an
531
 
    ### appropriate RemoteTransport in the future.
532
 
    from bzrlib.smart import server
533
 
    return [(RemoteTCPTransport, server.SmartTCPServer_for_testing)]
 
1059
    """Return (transport, server) permutations for testing"""
 
1060
    return [(SmartTCPTransport, SmartTCPServer_for_testing)]