entry_point.py
262 lines
| 8.7 KiB
| text/x-python
|
PythonLexer
epatters
|
r2778 | """ Defines helper functions for creating kernel entry points and process | ||
launchers. | ||||
""" | ||||
MinRK
|
r9346 | # Standard library imports | ||
MinRK
|
r5429 | import json | ||
Brian Granger
|
r2873 | import os | ||
epatters
|
r2778 | import socket | ||
epatters
|
r2944 | from subprocess import Popen, PIPE | ||
epatters
|
r2778 | import sys | ||
MinRK
|
r4958 | import tempfile | ||
epatters
|
r2778 | |||
MinRK
|
r4958 | # System library imports | ||
Fernando Perez
|
r5417 | |||
MinRK
|
r4958 | # IPython imports | ||
from IPython.utils.localinterfaces import LOCALHOST | ||||
MinRK
|
r4967 | from IPython.utils.py3compat import bytes_to_str | ||
epatters
|
r2778 | |||
MinRK
|
r9346 | # Local imports | ||
MinRK
|
r4958 | from parentpoller import ParentPollerWindows | ||
epatters
|
r2778 | |||
MinRK
|
r4958 | def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, hb_port=0, | ||
MinRK
|
r7321 | ip=LOCALHOST, key=b'', transport='tcp'): | ||
MinRK
|
r4958 | """Generates a JSON config file, including the selection of random ports. | ||
epatters
|
r2778 | Parameters | ||
---------- | ||||
MinRK
|
r4958 | |||
fname : unicode | ||||
The path to the file to write | ||||
epatters
|
r2778 | |||
MinRK
|
r3970 | shell_port : int, optional | ||
MinRK
|
r7538 | The port to use for ROUTER channel. | ||
epatters
|
r2778 | |||
MinRK
|
r3970 | iopub_port : int, optional | ||
epatters
|
r2778 | The port to use for the SUB channel. | ||
MinRK
|
r3970 | stdin_port : int, optional | ||
epatters
|
r2778 | The port to use for the REQ (raw input) channel. | ||
Brian Granger
|
r2910 | hb_port : int, optional | ||
The port to use for the hearbeat REP channel. | ||||
MinRK
|
r3970 | ip : str, optional | ||
The ip address the kernel will bind to. | ||||
MinRK
|
r4958 | key : str, optional | ||
The Session key used for HMAC authentication. | ||||
epatters
|
r3828 | |||
epatters
|
r2778 | """ | ||
MinRK
|
r4958 | # default to temporary connector file | ||
if not fname: | ||||
fname = tempfile.mktemp('.json') | ||||
epatters
|
r2778 | # Find open ports as necessary. | ||
MinRK
|
r7321 | |||
epatters
|
r2778 | ports = [] | ||
MinRK
|
r3970 | ports_needed = int(shell_port <= 0) + int(iopub_port <= 0) + \ | ||
int(stdin_port <= 0) + int(hb_port <= 0) | ||||
MinRK
|
r7321 | if transport == 'tcp': | ||
for i in range(ports_needed): | ||||
sock = socket.socket() | ||||
sock.bind(('', 0)) | ||||
ports.append(sock) | ||||
for i, sock in enumerate(ports): | ||||
port = sock.getsockname()[1] | ||||
sock.close() | ||||
ports[i] = port | ||||
else: | ||||
N = 1 | ||||
for i in range(ports_needed): | ||||
while os.path.exists("%s-%s" % (ip, str(N))): | ||||
N += 1 | ||||
ports.append(N) | ||||
N += 1 | ||||
MinRK
|
r3970 | if shell_port <= 0: | ||
shell_port = ports.pop(0) | ||||
if iopub_port <= 0: | ||||
iopub_port = ports.pop(0) | ||||
if stdin_port <= 0: | ||||
stdin_port = ports.pop(0) | ||||
Brian Granger
|
r2910 | if hb_port <= 0: | ||
hb_port = ports.pop(0) | ||||
MinRK
|
r4958 | |||
cfg = dict( shell_port=shell_port, | ||||
iopub_port=iopub_port, | ||||
stdin_port=stdin_port, | ||||
hb_port=hb_port, | ||||
) | ||||
cfg['ip'] = ip | ||||
MinRK
|
r4967 | cfg['key'] = bytes_to_str(key) | ||
MinRK
|
r7321 | cfg['transport'] = transport | ||
MinRK
|
r4958 | |||
MinRK
|
r5429 | with open(fname, 'w') as f: | ||
MinRK
|
r4958 | f.write(json.dumps(cfg, indent=2)) | ||
return fname, cfg | ||||
MinRK
|
r9350 | def make_ipkernel_cmd(code, executable=None, extra_arguments=[], **kw): | ||
"""Build Popen command list for launching an IPython kernel. | ||||
MinRK
|
r4958 | |||
Parameters | ||||
---------- | ||||
code : str, | ||||
A string of Python code that imports and executes a kernel entry point. | ||||
epatters
|
r2778 | |||
MinRK
|
r9346 | executable : str, optional (default sys.executable) | ||
The Python executable to use for the kernel process. | ||||
extra_arguments : list, optional | ||||
A list of extra arguments to pass when executing the launch code. | ||||
Returns | ||||
------- | ||||
A Popen command list | ||||
""" | ||||
# Build the kernel launch command. | ||||
if executable is None: | ||||
executable = sys.executable | ||||
arguments = [ executable, '-c', code, '-f', '{connection_file}' ] | ||||
arguments.extend(extra_arguments) | ||||
MinRK
|
r4958 | |||
MinRK
|
r9346 | # Spawn a kernel. | ||
if sys.platform == 'win32': | ||||
MinRK
|
r4958 | |||
MinRK
|
r9346 | # If the kernel is running on pythonw and stdout/stderr are not been | ||
# re-directed, it will crash when more than 4KB of data is written to | ||||
# stdout or stderr. This is a bug that has been with Python for a very | ||||
# long time; see http://bugs.python.org/issue706263. | ||||
# A cleaner solution to this problem would be to pass os.devnull to | ||||
# Popen directly. Unfortunately, that does not work. | ||||
if executable.endswith('pythonw.exe'): | ||||
arguments.append('--no-stdout') | ||||
arguments.append('--no-stderr') | ||||
MinRK
|
r4958 | |||
MinRK
|
r9346 | return arguments | ||
def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, | ||||
independent=False, | ||||
cwd=None, ipython_kernel=True, | ||||
**kw | ||||
): | ||||
""" Launches a localhost kernel, binding to the specified ports. | ||||
Parameters | ||||
---------- | ||||
cmd : Popen list, | ||||
A string of Python code that imports and executes a kernel entry point. | ||||
stdin, stdout, stderr : optional (default None) | ||||
Standards streams, as defined in subprocess.Popen. | ||||
MinRK
|
r4958 | |||
independent : bool, optional (default False) | ||||
If set, the kernel process is guaranteed to survive if this process | ||||
dies. If not set, an effort is made to ensure that the kernel is killed | ||||
when this process dies. Note that in this case it is still good practice | ||||
to kill kernels manually before exiting. | ||||
MinRK
|
r7557 | cwd : path, optional | ||
The working dir of the kernel process (default: cwd of this process). | ||||
MinRK
|
r4958 | |||
MinRK
|
r9346 | ipython_kernel : bool, optional | ||
Whether the kernel is an official IPython one, | ||||
and should get a bit of special treatment. | ||||
MinRK
|
r4958 | Returns | ||
------- | ||||
MinRK
|
r9346 | Popen instance for the kernel subprocess | ||
""" | ||||
epatters
|
r2778 | |||
epatters
|
r4635 | # Popen will fail (sometimes with a deadlock) if stdin, stdout, and stderr | ||
# are invalid. Unfortunately, there is in general no way to detect whether | ||||
# they are valid. The following two blocks redirect them to (temporary) | ||||
# pipes in certain important cases. | ||||
# If this process has been backgrounded, our stdin is invalid. Since there | ||||
# is no compelling reason for the kernel to inherit our stdin anyway, we'll | ||||
# place this one safe and always redirect. | ||||
redirect_in = True | ||||
_stdin = PIPE if stdin is None else stdin | ||||
# If this process in running on pythonw, we know that stdin, stdout, and | ||||
# stderr are all invalid. | ||||
redirect_out = sys.executable.endswith('pythonw.exe') | ||||
Bernardo B. Marques
|
r4872 | if redirect_out: | ||
epatters
|
r4635 | _stdout = PIPE if stdout is None else stdout | ||
_stderr = PIPE if stderr is None else stderr | ||||
else: | ||||
Bernardo B. Marques
|
r4872 | _stdout, _stderr = stdout, stderr | ||
epatters
|
r4635 | |||
epatters
|
r2778 | # Spawn a kernel. | ||
epatters
|
r2944 | if sys.platform == 'win32': | ||
MinRK
|
r9346 | |||
epatters
|
r3027 | # Create a Win32 event for interrupting the kernel. | ||
interrupt_event = ParentPollerWindows.create_interrupt_event() | ||||
MinRK
|
r9346 | if ipython_kernel: | ||
cmd += [ '--interrupt=%i' % interrupt_event ] | ||||
# If the kernel is running on pythonw and stdout/stderr are not been | ||||
# re-directed, it will crash when more than 4KB of data is written to | ||||
# stdout or stderr. This is a bug that has been with Python for a very | ||||
# long time; see http://bugs.python.org/issue706263. | ||||
# A cleaner solution to this problem would be to pass os.devnull to | ||||
# Popen directly. Unfortunately, that does not work. | ||||
if cmd[0].endswith('pythonw.exe'): | ||||
if stdout is None: | ||||
cmd.append('--no-stdout') | ||||
if stderr is None: | ||||
cmd.append('--no-stderr') | ||||
Evan Patterson
|
r3833 | |||
# Launch the kernel process. | ||||
epatters
|
r2944 | if independent: | ||
MinRK
|
r9346 | proc = Popen(cmd, | ||
epatters
|
r3027 | creationflags=512, # CREATE_NEW_PROCESS_GROUP | ||
epatters
|
r3828 | stdin=_stdin, stdout=_stdout, stderr=_stderr) | ||
epatters
|
r2778 | else: | ||
MinRK
|
r9346 | if ipython_kernel: | ||
try: | ||||
from _winapi import DuplicateHandle, GetCurrentProcess, \ | ||||
DUPLICATE_SAME_ACCESS | ||||
except: | ||||
from _subprocess import DuplicateHandle, GetCurrentProcess, \ | ||||
DUPLICATE_SAME_ACCESS | ||||
pid = GetCurrentProcess() | ||||
handle = DuplicateHandle(pid, pid, pid, 0, | ||||
True, # Inheritable by new processes. | ||||
DUPLICATE_SAME_ACCESS) | ||||
cmd +=[ '--parent=%i' % handle ] | ||||
proc = Popen(cmd, | ||||
stdin=_stdin, stdout=_stdout, stderr=_stderr, cwd=cwd) | ||||
epatters
|
r2980 | |||
epatters
|
r3027 | # Attach the interrupt event to the Popen objet so it can be used later. | ||
proc.win32_interrupt_event = interrupt_event | ||||
epatters
|
r2944 | else: | ||
if independent: | ||||
MinRK
|
r9346 | proc = Popen(cmd, preexec_fn=lambda: os.setsid(), | ||
MinRK
|
r7557 | stdin=_stdin, stdout=_stdout, stderr=_stderr, cwd=cwd) | ||
epatters
|
r2778 | else: | ||
MinRK
|
r9346 | if ipython_kernel: | ||
cmd += ['--parent=1'] | ||||
proc = Popen(cmd, | ||||
MinRK
|
r7557 | stdin=_stdin, stdout=_stdout, stderr=_stderr, cwd=cwd) | ||
epatters
|
r4635 | |||
# Clean up pipes created to work around Popen bug. | ||||
if redirect_in: | ||||
if stdin is None: | ||||
proc.stdin.close() | ||||
if redirect_out: | ||||
if stdout is None: | ||||
proc.stdout.close() | ||||
if stderr is None: | ||||
proc.stderr.close() | ||||
Bernardo B. Marques
|
r4872 | |||
MinRK
|
r4958 | return proc | ||