ssh tunneling utils into IPython.external.ssh

IPython/external/ssh/forward.py

@@ -29,21 +29,11 b' connection to a destination reachable from the SSH server machine.'
 
 from __future__ import print_function
 
-import getpass
-import os
-import socket
+import logging
 import select
 import SocketServer
-import sys
-from optparse import OptionParser
-
-import paramiko
-
-SSH_PORT = 22
-DEFAULT_PORT = 4000
-
-g_verbose = False
 
+logger = logging.getLogger('ssh')
 
 class ForwardServer (SocketServer.ThreadingTCPServer):
     daemon_threads = True
@@ -58,16 +48,16 b' class Handler (SocketServer.BaseRequestHandler):'
                                                    (self.chain_host, self.chain_port),
                                                    self.request.getpeername())
         except Exception, e:
-            verbose('Incoming request to %s:%d failed: %s' % (self.chain_host,
+            logger.debug('Incoming request to %s:%d failed: %s' % (self.chain_host,
                                                               self.chain_port,
                                                               repr(e)))
             return
         if chan is None:
-            verbose('Incoming request to %s:%d was rejected by the SSH server.' %
+            logger.debug('Incoming request to %s:%d was rejected by the SSH server.' %
                     (self.chain_host, self.chain_port))
             return
 
-        verbose('Connected!  Tunnel open %r -> %r -> %r' % (self.request.getpeername(),
+        logger.debug('Connected!  Tunnel open %r -> %r -> %r' % (self.request.getpeername(),
                                                             chan.getpeername(), (self.chain_host, self.chain_port)))
         while True:
             r, w, x = select.select([self.request, chan], [], [])
@@ -83,7 +73,7 b' class Handler (SocketServer.BaseRequestHandler):'
                 self.request.send(data)
         chan.close()
         self.request.close()
-        verbose('Tunnel closed ')
+        logger.debug('Tunnel closed ')
 
 
 def forward_tunnel(local_port, remote_host, remote_port, transport):
@@ -97,87 +87,4 b' def forward_tunnel(local_port, remote_host, remote_port, transport):'
     ForwardServer(('127.0.0.1', local_port), SubHander).serve_forever()
 
 
-def verbose(s):
-    if g_verbose:
-        print (s)
-
-
-HELP = """\
-Set up a forward tunnel across an SSH server, using paramiko. A local port
-(given with -p) is forwarded across an SSH session to an address:port from
-the SSH server. This is similar to the openssh -L option.
-"""
-
-
-def get_host_port(spec, default_port):
-    "parse 'hostname:22' into a host and port, with the port optional"
-    args = (spec.split(':', 1) + [default_port])[:2]
-    args[1] = int(args[1])
-    return args[0], args[1]
-
-
-def parse_options():
-    global g_verbose
-    
-    parser = OptionParser(usage='usage: %prog [options] <ssh-server>[:<server-port>]',
-                          version='%prog 1.0', description=HELP)
-    parser.add_option('-q', '--quiet', action='store_false', dest='verbose', default=True,
-                      help='squelch all informational output')
-    parser.add_option('-p', '--local-port', action='store', type='int', dest='port',
-                      default=DEFAULT_PORT,
-                      help='local port to forward (default: %d)' % DEFAULT_PORT)
-    parser.add_option('-u', '--user', action='store', type='string', dest='user',
-                      default=getpass.getuser(),
-                      help='username for SSH authentication (default: %s)' % getpass.getuser())
-    parser.add_option('-K', '--key', action='store', type='string', dest='keyfile',
-                      default=None,
-                      help='private key file to use for SSH authentication')
-    parser.add_option('', '--no-key', action='store_false', dest='look_for_keys', default=True,
-                      help='don\'t look for or use a private key file')
-    parser.add_option('-P', '--password', action='store_true', dest='readpass', default=False,
-                      help='read password (for key or password auth) from stdin')
-    parser.add_option('-r', '--remote', action='store', type='string', dest='remote', default=None, metavar='host:port',
-                      help='remote host and port to forward to')
-    options, args = parser.parse_args()
-
-    if len(args) != 1:
-        parser.error('Incorrect number of arguments.')
-    if options.remote is None:
-        parser.error('Remote address required (-r).')
-    
-    g_verbose = options.verbose
-    server_host, server_port = get_host_port(args[0], SSH_PORT)
-    remote_host, remote_port = get_host_port(options.remote, SSH_PORT)
-    return options, (server_host, server_port), (remote_host, remote_port)
-
-
-def main():
-    options, server, remote = parse_options()
-    
-    password = None
-    if options.readpass:
-        password = getpass.getpass('Enter SSH password: ')
-    
-    client = paramiko.SSHClient()
-    client.load_system_host_keys()
-    client.set_missing_host_key_policy(paramiko.WarningPolicy())
-
-    verbose('Connecting to ssh host %s:%d ...' % (server[0], server[1]))
-    try:
-        client.connect(server[0], server[1], username=options.user, key_filename=options.keyfile,
-                       look_for_keys=options.look_for_keys, password=password)
-    except Exception as e:
-        print ('*** Failed to connect to %s:%d: %r' % (server[0], server[1], e))
-        sys.exit(1)
-
-    verbose('Now forwarding port %d to %s:%d ...' % (options.port, remote[0], remote[1]))
-
-    try:
-        forward_tunnel(options.port, remote[0], remote[1], client.get_transport())
-    except KeyboardInterrupt:
-        print ('C-c: Port forwarding stopped.')
-        sys.exit(0)
-
-
-if __name__ == '__main__':
-    main()
+__all__ = ['forward_tunnel']
  No newline at end of file

IPython/zmq/parallel/client.py

@@ -23,7 +23,7 b' from zmq.eventloop import ioloop, zmqstream'
 
 from IPython.utils.path import get_ipython_dir
 from IPython.external.decorator import decorator
-from IPython.zmq import tunnel
+from IPython.external.ssh import tunnel
 
 import streamsession as ss
 from clusterdir import ClusterDir, ClusterDirError
@@ -152,9 +152,10 b' class Client(object):'
     Parameters
     ----------
     
-    addr : bytes; zmq url, e.g. 'tcp://127.0.0.1:10101'
-        The address of the controller's registration socket.
-        [Default: 'tcp://127.0.0.1:10101']
+    url_or_file : bytes; zmq url or path to ipcontroller-client.json
+        Connection information for the Hub's registration.  If a json connector
+        file is given, then likely no further configuration is necessary.
+        [Default: None]
     context : zmq.Context
         Pass an existing zmq.Context instance, otherwise the client will create its own
     username : bytes
@@ -178,15 +179,18 b' class Client(object):'
     sshkey : str; path to public ssh key file
         This specifies a key to be used in ssh login, default None.
         Regular default ssh keys will be used without specifying this argument.
-    password : str; 
+    password : str 
         Your ssh password to sshserver. Note that if this is left None,
         you will be prompted for it if passwordless key based login is unavailable.
+    paramiko : bool
+        flag for whether to use paramiko instead of shell ssh for tunneling.
+        [default: True on win32, False else]
     
     #------- exec authentication args -------
     # If even localhost is untrusted, you can have some protection against
     # unauthorized execution by using a key.  Messages are still sent
     # as cleartext, so if someone can snoop your loopback traffic this will
-    # not help anything.
+    # not help against malicious attacks.
     
     exec_key : str
         an authentication key or file containing a key