Exemplo n.º 1
0
 def connect_socket(s, url):
     url = util.disambiguate_url(url, self._config['location'])
     if self._ssh:
         return tunnel.tunnel_connection(s, url, sshserver,
                                         **ssh_kwargs)
     else:
         return s.connect(url)
Exemplo n.º 2
0
 def connect(s, url):
     url = disambiguate_url(url, self.location)
     if self.using_ssh:
         self.log.debug("Tunneling connection to %s via %s" % (url, self.sshserver))
         return tunnel.tunnel_connection(
             s, url, self.sshserver, keyfile=self.sshkey, paramiko=self.paramiko, password=password
         )
     else:
         return s.connect(url)
Exemplo n.º 3
0
 def connect(s, url):
     url = disambiguate_url(url, self.location)
     if self.using_ssh:
         self.log.debug("Tunneling connection to %s via %s", url, self.sshserver)
         return tunnel.tunnel_connection(s, url, self.sshserver,
                     keyfile=self.sshkey, paramiko=self.paramiko,
                     password=password,
         )
     else:
         return s.connect(url)
Exemplo n.º 4
0
 def connect_socket(s, url):
     url = util.disambiguate_url(url, self._config['location'])
     if self._ssh:
         return tunnel.tunnel_connection(s, url, sshserver, **ssh_kwargs)
     else:
         return s.connect(url)
Exemplo n.º 5
0
 def __init__(self, url_or_file=None, profile='default', cluster_dir=None, ipython_dir=None,
         context=None, username=None, debug=False, exec_key=None,
         sshserver=None, sshkey=None, password=None, paramiko=None,
         timeout=10
         ):
     super(Client, self).__init__(debug=debug, profile=profile)
     if context is None:
         context = zmq.Context.instance()
     self._context = context
         
     
     self._setup_cluster_dir(profile, cluster_dir, ipython_dir)
     if self._cd is not None:
         if url_or_file is None:
             url_or_file = pjoin(self._cd.security_dir, 'ipcontroller-client.json')
     assert url_or_file is not None, "I can't find enough information to connect to a hub!"\
         " Please specify at least one of url_or_file or profile."
     
     try:
         util.validate_url(url_or_file)
     except AssertionError:
         if not os.path.exists(url_or_file):
             if self._cd:
                 url_or_file = os.path.join(self._cd.security_dir, url_or_file)
             assert os.path.exists(url_or_file), "Not a valid connection file or url: %r"%url_or_file
         with open(url_or_file) as f:
             cfg = json.loads(f.read())
     else:
         cfg = {'url':url_or_file}
     
     # sync defaults from args, json:
     if sshserver:
         cfg['ssh'] = sshserver
     if exec_key:
         cfg['exec_key'] = exec_key
     exec_key = cfg['exec_key']
     sshserver=cfg['ssh']
     url = cfg['url']
     location = cfg.setdefault('location', None)
     cfg['url'] = util.disambiguate_url(cfg['url'], location)
     url = cfg['url']
     
     self._config = cfg
     
     self._ssh = bool(sshserver or sshkey or password)
     if self._ssh and sshserver is None:
         # default to ssh via localhost
         sshserver = url.split('://')[1].split(':')[0]
     if self._ssh and password is None:
         if tunnel.try_passwordless_ssh(sshserver, sshkey, paramiko):
             password=False
         else:
             password = getpass("SSH Password for %s: "%sshserver)
     ssh_kwargs = dict(keyfile=sshkey, password=password, paramiko=paramiko)
     if exec_key is not None and os.path.isfile(exec_key):
         arg = 'keyfile'
     else:
         arg = 'key'
     key_arg = {arg:exec_key}
     if username is None:
         self.session = ss.StreamSession(**key_arg)
     else:
         self.session = ss.StreamSession(username, **key_arg)
     self._query_socket = self._context.socket(zmq.XREQ)
     self._query_socket.setsockopt(zmq.IDENTITY, self.session.session)
     if self._ssh:
         tunnel.tunnel_connection(self._query_socket, url, sshserver, **ssh_kwargs)
     else:
         self._query_socket.connect(url)
     
     self.session.debug = self.debug
     
     self._notification_handlers = {'registration_notification' : self._register_engine,
                                 'unregistration_notification' : self._unregister_engine,
                                 'shutdown_notification' : lambda msg: self.close(),
                                 }
     self._queue_handlers = {'execute_reply' : self._handle_execute_reply,
                             'apply_reply' : self._handle_apply_reply}
     self._connect(sshserver, ssh_kwargs, timeout)
Exemplo n.º 6
0
    def __init__(self,
                 url_or_file=None,
                 profile='default',
                 cluster_dir=None,
                 ipython_dir=None,
                 context=None,
                 username=None,
                 debug=False,
                 exec_key=None,
                 sshserver=None,
                 sshkey=None,
                 password=None,
                 paramiko=None,
                 timeout=10):
        super(Client, self).__init__(debug=debug, profile=profile)
        if context is None:
            context = zmq.Context.instance()
        self._context = context

        self._setup_cluster_dir(profile, cluster_dir, ipython_dir)
        if self._cd is not None:
            if url_or_file is None:
                url_or_file = pjoin(self._cd.security_dir,
                                    'ipcontroller-client.json')
        assert url_or_file is not None, "I can't find enough information to connect to a hub!"\
            " Please specify at least one of url_or_file or profile."

        try:
            util.validate_url(url_or_file)
        except AssertionError:
            if not os.path.exists(url_or_file):
                if self._cd:
                    url_or_file = os.path.join(self._cd.security_dir,
                                               url_or_file)
                assert os.path.exists(
                    url_or_file
                ), "Not a valid connection file or url: %r" % url_or_file
            with open(url_or_file) as f:
                cfg = json.loads(f.read())
        else:
            cfg = {'url': url_or_file}

        # sync defaults from args, json:
        if sshserver:
            cfg['ssh'] = sshserver
        if exec_key:
            cfg['exec_key'] = exec_key
        exec_key = cfg['exec_key']
        sshserver = cfg['ssh']
        url = cfg['url']
        location = cfg.setdefault('location', None)
        cfg['url'] = util.disambiguate_url(cfg['url'], location)
        url = cfg['url']

        self._config = cfg

        self._ssh = bool(sshserver or sshkey or password)
        if self._ssh and sshserver is None:
            # default to ssh via localhost
            sshserver = url.split('://')[1].split(':')[0]
        if self._ssh and password is None:
            if tunnel.try_passwordless_ssh(sshserver, sshkey, paramiko):
                password = False
            else:
                password = getpass("SSH Password for %s: " % sshserver)
        ssh_kwargs = dict(keyfile=sshkey, password=password, paramiko=paramiko)
        if exec_key is not None and os.path.isfile(exec_key):
            arg = 'keyfile'
        else:
            arg = 'key'
        key_arg = {arg: exec_key}
        if username is None:
            self.session = ss.StreamSession(**key_arg)
        else:
            self.session = ss.StreamSession(username, **key_arg)
        self._query_socket = self._context.socket(zmq.XREQ)
        self._query_socket.setsockopt(zmq.IDENTITY, self.session.session)
        if self._ssh:
            tunnel.tunnel_connection(self._query_socket, url, sshserver,
                                     **ssh_kwargs)
        else:
            self._query_socket.connect(url)

        self.session.debug = self.debug

        self._notification_handlers = {
            'registration_notification': self._register_engine,
            'unregistration_notification': self._unregister_engine,
            'shutdown_notification': lambda msg: self.close(),
        }
        self._queue_handlers = {
            'execute_reply': self._handle_execute_reply,
            'apply_reply': self._handle_apply_reply
        }
        self._connect(sshserver, ssh_kwargs, timeout)