← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ssh.py

  • Committer: Andrew Bennetts
  • Date: 2010-04-14 06:47:18 UTC
  • mto: This revision was merged to the branch mainline in revision 5155.
  • Revision ID: andrew.bennetts@canonical.com-20100414064718-130ptdug4opfjj6b
Link to Python bug in comment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ssh.py
239
239
    def connect_ssh(self, username, password, host, port, command):
240
240
        """Make an SSH connection.
241
241
 
242
 
        :returns: an SSHConnection.
 
242
        :returns: something with a `close` method, and a `get_filelike_channels`
 
243
            method that returns a pair of (read, write) filelike objects.
243
244
        """
244
245
        raise NotImplementedError(self.connect_ssh)
245
246
 
268
269
register_ssh_vendor('loopback', LoopbackVendor())
269
270
 
270
271
 
 
272
class _ParamikoSSHConnection(object):
 
273
    def __init__(self, channel):
 
274
        self.channel = channel
 
275
 
 
276
    def get_filelike_channels(self):
 
277
        return self.channel.makefile('rb'), self.channel.makefile('wb')
 
278
 
 
279
    def close(self):
 
280
        return self.channel.close()
 
281
 
 
282
 
271
283
class ParamikoVendor(SSHVendor):
272
284
    """Vendor that uses paramiko."""
273
285
 
351
363
    """Abstract base class for vendors that use pipes to a subprocess."""
352
364
 
353
365
    def _connect(self, argv):
354
 
        # Attempt to make a socketpair to use as stdin/stdout for the SSH
355
 
        # subprocess.  We prefer sockets to pipes because they support
356
 
        # non-blocking short reads, allowing us to optimistically read 64k (or
357
 
        # whatever) chunks.
358
 
        try:
359
 
            my_sock, subproc_sock = socket.socketpair()
360
 
        except (AttributeError, socket.error):
361
 
            # This platform doesn't support socketpair(), so just use ordinary
362
 
            # pipes instead.
363
 
            stdin = stdout = subprocess.PIPE
364
 
            sock = None
365
 
        else:
366
 
            stdin = stdout = subproc_sock
367
 
            sock = my_sock
368
 
        proc = subprocess.Popen(argv, stdin=stdin, stdout=stdout,
 
366
        proc = subprocess.Popen(argv,
 
367
                                stdin=subprocess.PIPE,
 
368
                                stdout=subprocess.PIPE,
369
369
                                **os_specific_subprocess_params())
370
 
        return SSHSubprocessConnection(proc, sock=sock)
 
370
        return SSHSubprocess(proc)
371
371
 
372
372
    def connect_sftp(self, username, password, host, port):
373
373
        try:
652
652
            pass
653
653
 
654
654
 
655
 
class SSHConnection(object):
656
 
    """Abstract base class for SSH connections."""
657
 
 
658
 
    def get_sock_or_pipes(self):
659
 
        """Returns a (kind, io_object) pair.
660
 
 
661
 
        If kind == 'socket', then io_object is a socket.
662
 
 
663
 
        If kind == 'pipes', then io_object is a pair of file-like objects
664
 
        (read_from, write_to).
665
 
        """
666
 
        raise NotImplementedError(self.get_sock_or_pipes)
667
 
 
668
 
    def close(self):
669
 
        raise NotImplementedError(self.close)
670
 
 
671
 
 
672
 
class SSHSubprocessConnection(SSHConnection):
673
 
    """A connection to an ssh subprocess via pipes or a socket.
674
 
 
675
 
    This class is also socket-like enough to be used with
676
 
    SocketAsChannelAdapter (it has 'send' and 'recv' methods).
677
 
    """
678
 
 
679
 
    def __init__(self, proc, sock=None):
680
 
        """Constructor.
681
 
 
682
 
        :param proc: a subprocess.Popen
683
 
        :param sock: if proc.stdin/out is a socket from a socketpair, then sock
684
 
            should bzrlib's half of that socketpair.  If not passed, proc's
685
 
            stdin/out is assumed to be ordinary pipes.
686
 
        """
 
655
class SSHSubprocess(object):
 
656
    """A socket-like object that talks to an ssh subprocess via pipes."""
 
657
 
 
658
    def __init__(self, proc):
687
659
        self.proc = proc
688
 
        self._sock = sock
689
660
        # Add a weakref to proc that will attempt to do the same as self.close
690
661
        # to avoid leaving processes lingering indefinitely.
691
662
        def terminate(ref):
694
665
        _subproc_weakrefs.add(weakref.ref(self, terminate))
695
666
 
696
667
    def send(self, data):
697
 
        if self._sock is not None:
698
 
            return self._sock.send(data)
699
 
        else:
700
 
            return os.write(self.proc.stdin.fileno(), data)
 
668
        return os.write(self.proc.stdin.fileno(), data)
701
669
 
702
670
    def recv(self, count):
703
 
        if self._sock is not None:
704
 
            return self._sock.recv(count)
705
 
        else:
706
 
            return os.read(self.proc.stdout.fileno(), count)
 
671
        return os.read(self.proc.stdout.fileno(), count)
707
672
 
708
673
    def close(self):
709
674
        _close_ssh_proc(self.proc)
710
675
 
711
 
    def get_sock_or_pipes(self):
712
 
        if self._sock is not None:
713
 
            return 'socket', self._sock
714
 
        else:
715
 
            return 'pipes', (self.proc.stdout, self.proc.stdin)
716
 
 
717
 
 
718
 
class _ParamikoSSHConnection(SSHConnection):
719
 
    """An SSH connection via paramiko."""
720
 
 
721
 
    def __init__(self, channel):
722
 
        self.channel = channel
723
 
 
724
 
    def get_sock_or_pipes(self):
725
 
        return ('socket', self.channel)
726
 
 
727
 
    def close(self):
728
 
        return self.channel.close()
729
 
 
 
676
    def get_filelike_channels(self):
 
677
        return (self.proc.stdout, self.proc.stdin)
730
678