Show More
@@ -1,134 +1,131 b'' | |||||
1 | """A kernel manager relating notebooks and kernels |
|
1 | """A kernel manager relating notebooks and kernels | |
2 |
|
2 | |||
3 | Authors: |
|
3 | Authors: | |
4 |
|
4 | |||
5 | * Brian Granger |
|
5 | * Brian Granger | |
6 | """ |
|
6 | """ | |
7 |
|
7 | |||
8 | #----------------------------------------------------------------------------- |
|
8 | #----------------------------------------------------------------------------- | |
9 | # Copyright (C) 2013 The IPython Development Team |
|
9 | # Copyright (C) 2013 The IPython Development Team | |
10 | # |
|
10 | # | |
11 | # Distributed under the terms of the BSD License. The full license is in |
|
11 | # Distributed under the terms of the BSD License. The full license is in | |
12 | # the file COPYING, distributed as part of this software. |
|
12 | # the file COPYING, distributed as part of this software. | |
13 | #----------------------------------------------------------------------------- |
|
13 | #----------------------------------------------------------------------------- | |
14 |
|
14 | |||
15 | #----------------------------------------------------------------------------- |
|
15 | #----------------------------------------------------------------------------- | |
16 | # Imports |
|
16 | # Imports | |
17 | #----------------------------------------------------------------------------- |
|
17 | #----------------------------------------------------------------------------- | |
18 |
|
18 | |||
19 | from tornado import web |
|
19 | from tornado import web | |
20 |
|
20 | |||
21 | from IPython.kernel.multikernelmanager import MultiKernelManager |
|
21 | from IPython.kernel.multikernelmanager import MultiKernelManager | |
22 | from IPython.utils.traitlets import ( |
|
22 | from IPython.utils.traitlets import ( | |
23 |
Dict, List, Unicode, |
|
23 | Dict, List, Unicode, Integer, | |
24 | ) |
|
24 | ) | |
25 |
|
25 | |||
26 | #----------------------------------------------------------------------------- |
|
26 | #----------------------------------------------------------------------------- | |
27 | # Classes |
|
27 | # Classes | |
28 | #----------------------------------------------------------------------------- |
|
28 | #----------------------------------------------------------------------------- | |
29 |
|
29 | |||
30 |
|
30 | |||
31 | class MappingKernelManager(MultiKernelManager): |
|
31 | class MappingKernelManager(MultiKernelManager): | |
32 | """A KernelManager that handles notebok mapping and HTTP error handling""" |
|
32 | """A KernelManager that handles notebok mapping and HTTP error handling""" | |
33 |
|
33 | |||
34 | kernel_argv = List(Unicode) |
|
34 | kernel_argv = List(Unicode) | |
35 |
|
35 | |||
36 | time_to_dead = Float(3.0, config=True, help="""Kernel heartbeat interval in seconds.""") |
|
|||
37 | first_beat = Float(5.0, config=True, help="Delay (in seconds) before sending first heartbeat.") |
|
|||
38 |
|
||||
39 | max_msg_size = Integer(65536, config=True, help=""" |
|
36 | max_msg_size = Integer(65536, config=True, help=""" | |
40 | The max raw message size accepted from the browser |
|
37 | The max raw message size accepted from the browser | |
41 | over a WebSocket connection. |
|
38 | over a WebSocket connection. | |
42 | """) |
|
39 | """) | |
43 |
|
40 | |||
44 | _notebook_mapping = Dict() |
|
41 | _notebook_mapping = Dict() | |
45 |
|
42 | |||
46 | #------------------------------------------------------------------------- |
|
43 | #------------------------------------------------------------------------- | |
47 | # Methods for managing kernels and sessions |
|
44 | # Methods for managing kernels and sessions | |
48 | #------------------------------------------------------------------------- |
|
45 | #------------------------------------------------------------------------- | |
49 |
|
46 | |||
50 | def kernel_for_notebook(self, notebook_id): |
|
47 | def kernel_for_notebook(self, notebook_id): | |
51 | """Return the kernel_id for a notebook_id or None.""" |
|
48 | """Return the kernel_id for a notebook_id or None.""" | |
52 | return self._notebook_mapping.get(notebook_id) |
|
49 | return self._notebook_mapping.get(notebook_id) | |
53 |
|
50 | |||
54 | def set_kernel_for_notebook(self, notebook_id, kernel_id): |
|
51 | def set_kernel_for_notebook(self, notebook_id, kernel_id): | |
55 | """Associate a notebook with a kernel.""" |
|
52 | """Associate a notebook with a kernel.""" | |
56 | if notebook_id is not None: |
|
53 | if notebook_id is not None: | |
57 | self._notebook_mapping[notebook_id] = kernel_id |
|
54 | self._notebook_mapping[notebook_id] = kernel_id | |
58 |
|
55 | |||
59 | def notebook_for_kernel(self, kernel_id): |
|
56 | def notebook_for_kernel(self, kernel_id): | |
60 | """Return the notebook_id for a kernel_id or None.""" |
|
57 | """Return the notebook_id for a kernel_id or None.""" | |
61 | notebook_ids = [k for k, v in self._notebook_mapping.iteritems() if v == kernel_id] |
|
58 | notebook_ids = [k for k, v in self._notebook_mapping.iteritems() if v == kernel_id] | |
62 | if len(notebook_ids) == 1: |
|
59 | if len(notebook_ids) == 1: | |
63 | return notebook_ids[0] |
|
60 | return notebook_ids[0] | |
64 | else: |
|
61 | else: | |
65 | return None |
|
62 | return None | |
66 |
|
63 | |||
67 | def delete_mapping_for_kernel(self, kernel_id): |
|
64 | def delete_mapping_for_kernel(self, kernel_id): | |
68 | """Remove the kernel/notebook mapping for kernel_id.""" |
|
65 | """Remove the kernel/notebook mapping for kernel_id.""" | |
69 | notebook_id = self.notebook_for_kernel(kernel_id) |
|
66 | notebook_id = self.notebook_for_kernel(kernel_id) | |
70 | if notebook_id is not None: |
|
67 | if notebook_id is not None: | |
71 | del self._notebook_mapping[notebook_id] |
|
68 | del self._notebook_mapping[notebook_id] | |
72 |
|
69 | |||
73 | def start_kernel(self, notebook_id=None, **kwargs): |
|
70 | def start_kernel(self, notebook_id=None, **kwargs): | |
74 | """Start a kernel for a notebok an return its kernel_id. |
|
71 | """Start a kernel for a notebok an return its kernel_id. | |
75 |
|
72 | |||
76 | Parameters |
|
73 | Parameters | |
77 | ---------- |
|
74 | ---------- | |
78 | notebook_id : uuid |
|
75 | notebook_id : uuid | |
79 | The uuid of the notebook to associate the new kernel with. If this |
|
76 | The uuid of the notebook to associate the new kernel with. If this | |
80 | is not None, this kernel will be persistent whenever the notebook |
|
77 | is not None, this kernel will be persistent whenever the notebook | |
81 | requests a kernel. |
|
78 | requests a kernel. | |
82 | """ |
|
79 | """ | |
83 | kernel_id = self.kernel_for_notebook(notebook_id) |
|
80 | kernel_id = self.kernel_for_notebook(notebook_id) | |
84 | if kernel_id is None: |
|
81 | if kernel_id is None: | |
85 | kwargs['extra_arguments'] = self.kernel_argv |
|
82 | kwargs['extra_arguments'] = self.kernel_argv | |
86 | kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs) |
|
83 | kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs) | |
87 | self.set_kernel_for_notebook(notebook_id, kernel_id) |
|
84 | self.set_kernel_for_notebook(notebook_id, kernel_id) | |
88 | self.log.info("Kernel started: %s" % kernel_id) |
|
85 | self.log.info("Kernel started: %s" % kernel_id) | |
89 | self.log.debug("Kernel args: %r" % kwargs) |
|
86 | self.log.debug("Kernel args: %r" % kwargs) | |
90 | else: |
|
87 | else: | |
91 | self.log.info("Using existing kernel: %s" % kernel_id) |
|
88 | self.log.info("Using existing kernel: %s" % kernel_id) | |
92 | return kernel_id |
|
89 | return kernel_id | |
93 |
|
90 | |||
94 | def shutdown_kernel(self, kernel_id, now=False): |
|
91 | def shutdown_kernel(self, kernel_id, now=False): | |
95 | """Shutdown a kernel and remove its notebook association.""" |
|
92 | """Shutdown a kernel and remove its notebook association.""" | |
96 | self._check_kernel_id(kernel_id) |
|
93 | self._check_kernel_id(kernel_id) | |
97 | super(MappingKernelManager, self).shutdown_kernel( |
|
94 | super(MappingKernelManager, self).shutdown_kernel( | |
98 | kernel_id, now=now |
|
95 | kernel_id, now=now | |
99 | ) |
|
96 | ) | |
100 | self.delete_mapping_for_kernel(kernel_id) |
|
97 | self.delete_mapping_for_kernel(kernel_id) | |
101 | self.log.info("Kernel shutdown: %s" % kernel_id) |
|
98 | self.log.info("Kernel shutdown: %s" % kernel_id) | |
102 |
|
99 | |||
103 | def interrupt_kernel(self, kernel_id): |
|
100 | def interrupt_kernel(self, kernel_id): | |
104 | """Interrupt a kernel.""" |
|
101 | """Interrupt a kernel.""" | |
105 | self._check_kernel_id(kernel_id) |
|
102 | self._check_kernel_id(kernel_id) | |
106 | super(MappingKernelManager, self).interrupt_kernel(kernel_id) |
|
103 | super(MappingKernelManager, self).interrupt_kernel(kernel_id) | |
107 | self.log.info("Kernel interrupted: %s" % kernel_id) |
|
104 | self.log.info("Kernel interrupted: %s" % kernel_id) | |
108 |
|
105 | |||
109 | def restart_kernel(self, kernel_id): |
|
106 | def restart_kernel(self, kernel_id): | |
110 | """Restart a kernel while keeping clients connected.""" |
|
107 | """Restart a kernel while keeping clients connected.""" | |
111 | self._check_kernel_id(kernel_id) |
|
108 | self._check_kernel_id(kernel_id) | |
112 | super(MappingKernelManager, self).restart_kernel(kernel_id) |
|
109 | super(MappingKernelManager, self).restart_kernel(kernel_id) | |
113 | self.log.info("Kernel restarted: %s" % kernel_id) |
|
110 | self.log.info("Kernel restarted: %s" % kernel_id) | |
114 |
|
111 | |||
115 | def create_iopub_stream(self, kernel_id): |
|
112 | def create_iopub_stream(self, kernel_id): | |
116 | """Create a new iopub stream.""" |
|
113 | """Create a new iopub stream.""" | |
117 | self._check_kernel_id(kernel_id) |
|
114 | self._check_kernel_id(kernel_id) | |
118 | return super(MappingKernelManager, self).create_iopub_stream(kernel_id) |
|
115 | return super(MappingKernelManager, self).create_iopub_stream(kernel_id) | |
119 |
|
116 | |||
120 | def create_shell_stream(self, kernel_id): |
|
117 | def create_shell_stream(self, kernel_id): | |
121 | """Create a new shell stream.""" |
|
118 | """Create a new shell stream.""" | |
122 | self._check_kernel_id(kernel_id) |
|
119 | self._check_kernel_id(kernel_id) | |
123 | return super(MappingKernelManager, self).create_shell_stream(kernel_id) |
|
120 | return super(MappingKernelManager, self).create_shell_stream(kernel_id) | |
124 |
|
121 | |||
125 | def create_hb_stream(self, kernel_id): |
|
122 | def create_hb_stream(self, kernel_id): | |
126 | """Create a new hb stream.""" |
|
123 | """Create a new hb stream.""" | |
127 | self._check_kernel_id(kernel_id) |
|
124 | self._check_kernel_id(kernel_id) | |
128 | return super(MappingKernelManager, self).create_hb_stream(kernel_id) |
|
125 | return super(MappingKernelManager, self).create_hb_stream(kernel_id) | |
129 |
|
126 | |||
130 | def _check_kernel_id(self, kernel_id): |
|
127 | def _check_kernel_id(self, kernel_id): | |
131 | """Check a that a kernel_id exists and raise 404 if not.""" |
|
128 | """Check a that a kernel_id exists and raise 404 if not.""" | |
132 | if kernel_id not in self: |
|
129 | if kernel_id not in self: | |
133 | raise web.HTTPError(404, u'Kernel does not exist: %s' % kernel_id) |
|
130 | raise web.HTTPError(404, u'Kernel does not exist: %s' % kernel_id) | |
134 |
|
131 |
General Comments 0
You need to be logged in to leave comments.
Login now