##// END OF EJS Templates
resubmitted tasks are now wholly separate (new msg_ids)...
resubmitted tasks are now wholly separate (new msg_ids) This removes much of the fragility due to trying to cram a resubmit into the original ID. The `resubmit` record is now the resubmitted task ID, rather than the timestamp.

File last commit:

r5620:5e833cd7
r6817:fa181ff0
Show More
kernel.py
315 lines | 10.5 KiB | text/x-python | PythonLexer
MinRK
add IPython.lib.kernel...
r4970 """Utilities for connecting to kernels
Authors:
* Min Ragan-Kelley
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2011 The IPython Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 import glob
MinRK
add IPython.lib.kernel...
r4970 import json
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 import os
MinRK
add IPython.lib.kernel...
r4970 import sys
MinRK
split QtConsole.init_ssh into generic tunnel_to_kernel...
r4971 from getpass import getpass
MinRK
add IPython.lib.kernel...
r4970 from subprocess import Popen, PIPE
MinRK
split QtConsole.init_ssh into generic tunnel_to_kernel...
r4971 # external imports
from IPython.external.ssh import tunnel
# IPython imports
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 from IPython.core.profiledir import ProfileDir
from IPython.utils.path import filefind, get_ipython_dir
MinRK
add IPython.lib.kernel...
r4970 from IPython.utils.py3compat import str_to_bytes
#-----------------------------------------------------------------------------
# Functions
#-----------------------------------------------------------------------------
def get_connection_file(app=None):
"""Return the path to the connection file of an app
Parameters
----------
app : KernelApp instance [optional]
If unspecified, the currently running app will be used
"""
if app is None:
from IPython.zmq.kernelapp import KernelApp
if not KernelApp.initialized():
raise RuntimeError("app not specified, and not in a running Kernel")
app = KernelApp.instance()
return filefind(app.connection_file, ['.', app.profile_dir.security_dir])
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972
def find_connection_file(filename, profile=None):
"""find a connection file, and return its absolute path.
The current working directory and the profile's security
directory will be searched for the file if it is not given by
absolute path.
If profile is unspecified, then the current running application's
profile will be used, or 'default', if not run from IPython.
If the argument does not match an existing file, it will be interpreted as a
fileglob, and the matching file in the profile's security dir with
the latest access time will be used.
Parameters
----------
filename : str
The connection file or fileglob to search for.
profile : str [optional]
The name of the profile to use when searching for the connection file,
if different from the current IPython session or 'default'.
Returns
-------
str : The absolute path of the connection file.
"""
from IPython.core.application import BaseIPythonApplication as IPApp
try:
# quick check for absolute path, before going through logic
return filefind(filename)
except IOError:
pass
if profile is None:
# profile unspecified, check if running from an IPython app
if IPApp.initialized():
app = IPApp.instance()
profile_dir = app.profile_dir
else:
# not running in IPython, use default profile
profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default')
else:
# find profiledir by profile name:
profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
security_dir = profile_dir.security_dir
try:
# first, try explicit name
return filefind(filename, ['.', security_dir])
except IOError:
pass
# not found by full name
if '*' in filename:
# given as a glob already
pat = filename
else:
# accept any substring match
pat = '*%s*' % filename
matches = glob.glob( os.path.join(security_dir, pat) )
if not matches:
raise IOError("Could not find %r in %r" % (filename, security_dir))
elif len(matches) == 1:
return matches[0]
else:
# get most recent match, by access time:
return sorted(matches, key=lambda f: os.stat(f).st_atime)[-1]
def get_connection_info(connection_file=None, unpack=False, profile=None):
MinRK
add IPython.lib.kernel...
r4970 """Return the connection information for the current Kernel.
Parameters
----------
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 connection_file : str [optional]
The connection file to be used. Can be given by absolute path, or
IPython will search in the security directory of a given profile.
If run from IPython,
If unspecified, the connection file for the currently running
IPython Kernel will be used, which is only allowed from inside a kernel.
MinRK
add IPython.lib.kernel...
r4970 unpack : bool [default: False]
if True, return the unpacked dict, otherwise just the string contents
of the file.
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 profile : str [optional]
The name of the profile to use when searching for the connection file,
if different from the current IPython session or 'default'.
MinRK
add IPython.lib.kernel...
r4970
Returns
-------
The connection dictionary of the current kernel, as string or dict,
depending on `unpack`.
"""
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 if connection_file is None:
# get connection file from current kernel
cf = get_connection_file()
else:
# connection file specified, allow shortnames:
cf = find_connection_file(connection_file, profile=profile)
MinRK
add IPython.lib.kernel...
r4970 with open(cf) as f:
info = f.read()
if unpack:
info = json.loads(info)
# ensure key is bytes:
info['key'] = str_to_bytes(info.get('key', ''))
return info
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 def connect_qtconsole(connection_file=None, argv=None, profile=None):
MinRK
add IPython.lib.kernel...
r4970 """Connect a qtconsole to the current kernel.
This is useful for connecting a second qtconsole to a kernel, or to a
local notebook.
Parameters
----------
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 connection_file : str [optional]
The connection file to be used. Can be given by absolute path, or
IPython will search in the security directory of a given profile.
If run from IPython,
If unspecified, the connection file for the currently running
IPython Kernel will be used, which is only allowed from inside a kernel.
MinRK
add IPython.lib.kernel...
r4970 argv : list [optional]
Any extra args to be passed to the console.
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 profile : str [optional]
The name of the profile to use when searching for the connection file,
if different from the current IPython session or 'default'.
MinRK
add IPython.lib.kernel...
r4970
Returns
-------
subprocess.Popen instance running the qtconsole frontend
"""
argv = [] if argv is None else argv
MinRK
split qtconsole's connection-file search into lib.kernel...
r4972 if connection_file is None:
# get connection file from current kernel
cf = get_connection_file()
else:
cf = find_connection_file(connection_file, profile=profile)
MinRK
add IPython.lib.kernel...
r4970
cmd = ';'.join([
"from IPython.frontend.qt.console import qtconsoleapp",
"qtconsoleapp.main()"
])
return Popen([sys.executable, '-c', cmd, '--existing', cf] + argv, stdout=PIPE, stderr=PIPE)
MinRK
split QtConsole.init_ssh into generic tunnel_to_kernel...
r4971 def tunnel_to_kernel(connection_info, sshserver, sshkey=None):
"""tunnel connections to a kernel via ssh
This will open four SSH tunnels from localhost on this machine to the
ports associated with the kernel. They can be either direct
localhost-localhost tunnels, or if an intermediate server is necessary,
the kernel must be listening on a public IP.
Parameters
----------
connection_info : dict or str (path)
Either a connection dict, or the path to a JSON connection file
sshserver : str
The ssh sever to use to tunnel to the kernel. Can be a full
`user@server:port` string. ssh config aliases are respected.
sshkey : str [optional]
Path to file containing ssh key to use for authentication.
Only necessary if your ssh config does not already associate
a keyfile with the host.
Returns
-------
(shell, iopub, stdin, hb) : ints
The four ports on localhost that have been forwarded to the kernel.
"""
if isinstance(connection_info, basestring):
# it's a path, unpack it
with open(connection_info) as f:
connection_info = json.loads(f.read())
cf = connection_info
lports = tunnel.select_random_ports(4)
rports = cf['shell_port'], cf['iopub_port'], cf['stdin_port'], cf['hb_port']
remote_ip = cf['ip']
if tunnel.try_passwordless_ssh(sshserver, sshkey):
password=False
else:
password = getpass("SSH Password for %s: "%sshserver)
for lp,rp in zip(lports, rports):
tunnel.ssh_tunnel(lp, rp, sshserver, remote_ip, sshkey, password)
return tuple(lports)
MinRK
add IPython.lib.kernel...
r4970
MinRK
Split swallow_argv into standalone function in lib.kernel...
r5620 def swallow_argv(argv, aliases=None, flags=None):
"""strip frontend-specific aliases and flags from an argument list
For use primarily in frontend apps that want to pass a subset of command-line
arguments through to a subprocess, where frontend-specific flags and aliases
should be removed from the list.
Parameters
----------
argv : list(str)
The starting argv, to be filtered
aliases : container of aliases (dict, list, set, etc.)
The frontend-specific aliases to be removed
flags : container of flags (dict, list, set, etc.)
The frontend-specific flags to be removed
Returns
-------
argv : list(str)
The argv list, excluding flags and aliases that have been stripped
"""
if aliases is None:
aliases = set()
if flags is None:
flags = set()
stripped = list(argv) # copy
swallow_next = False
was_flag = False
for a in argv:
if swallow_next:
swallow_next = False
# last arg was an alias, remove the next one
# *unless* the last alias has a no-arg flag version, in which
# case, don't swallow the next arg if it's also a flag:
if not (was_flag and a.startswith('-')):
stripped.remove(a)
continue
if a.startswith('-'):
split = a.lstrip('-').split('=')
alias = split[0]
if alias in aliases:
stripped.remove(a)
if len(split) == 1:
# alias passed with arg via space
swallow_next = True
# could have been a flag that matches an alias, e.g. `existing`
# in which case, we might not swallow the next arg
was_flag = alias in flags
elif alias in flags and len(split) == 1:
# strip flag, but don't swallow next, as flags don't take args
stripped.remove(a)
# return shortened list
return stripped