File size: 7,711 Bytes
8247f19 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 | # Patch-overlapping Python context after the fix
## `jupyter_server/base/handlers.py` — `class:APIHandler` (lines 725-833)
```python
class APIHandler(JupyterHandler):
"""Base class for API handlers"""
async def prepare(self) -> None:
"""Prepare an API response."""
await super().prepare()
if not self.check_origin():
raise web.HTTPError(404)
def write_error(self, status_code: int, **kwargs: Any) -> None:
"""APIHandler errors are JSON, not human pages"""
self.set_header("Content-Type", "application/json")
message = responses.get(status_code, "Unknown HTTP Error")
reply: dict[str, Any] = {
"message": message,
}
exc_info = kwargs.get("exc_info")
if exc_info:
e = exc_info[1]
if isinstance(e, HTTPError):
reply["message"] = e.log_message or message
reply["reason"] = e.reason
else:
reply["message"] = "Unhandled error"
reply["reason"] = None
# backward-compatibility: traceback field is present,
# but always empty
reply["traceback"] = ""
self.log.warning("wrote error: %r", reply["message"], exc_info=True)
self.finish(json.dumps(reply))
def get_login_url(self) -> str:
"""Get the login url."""
# if get_login_url is invoked in an API handler,
# that means @web.authenticated is trying to trigger a redirect.
# instead of redirecting, raise 403 instead.
if not self.current_user:
raise web.HTTPError(403)
return super().get_login_url()
@property
def content_security_policy(self) -> str:
csp = "; ".join(
[
super().content_security_policy,
"default-src 'none'",
]
)
return csp
# set _track_activity = False on API handlers that shouldn't track activity
_track_activity = True
def update_api_activity(self) -> None:
"""Update last_activity of API requests"""
# record activity of authenticated requests
if (
self._track_activity
and getattr(self, "_jupyter_current_user", None)
and self.get_argument("no_track_activity", None) is None
):
self.settings["api_last_activity"] = utcnow()
def finish(self, *args: Any, **kwargs: Any) -> Future[Any]:
"""Finish an API response."""
self.update_api_activity()
# Allow caller to indicate content-type...
set_content_type = kwargs.pop("set_content_type", "application/json")
self.set_header("Content-Type", set_content_type)
return super().finish(*args, **kwargs)
def options(self, *args: Any, **kwargs: Any) -> None:
"""Get the options."""
if "Access-Control-Allow-Headers" in self.settings.get("headers", {}):
self.set_header(
"Access-Control-Allow-Headers",
self.settings["headers"]["Access-Control-Allow-Headers"],
)
else:
self.set_header(
"Access-Control-Allow-Headers",
"accept, content-type, authorization, x-xsrftoken",
)
self.set_header("Access-Control-Allow-Methods", "GET, PUT, POST, PATCH, DELETE, OPTIONS")
# if authorization header is requested,
# that means the request is token-authenticated.
# avoid browser-side rejection of the preflight request.
# only allow this exception if allow_origin has not been specified
# and Jupyter server authentication is enabled.
# If the token is not valid, the 'real' request will still be rejected.
requested_headers = self.request.headers.get("Access-Control-Request-Headers", "").split(
","
)
if (
requested_headers
and any(h.strip().lower() == "authorization" for h in requested_headers)
and (
# FIXME: it would be even better to check specifically for token-auth,
# but there is currently no API for this.
self.login_available
)
and (
self.allow_origin
or self.allow_origin_pat
or "Access-Control-Allow-Origin" in self.settings.get("headers", {})
)
):
self.set_header("Access-Control-Allow-Origin", self.request.headers.get("Origin", ""))
```
## `jupyter_server/base/handlers.py` — `function:APIHandler.write_error` (lines 734-754)
```python
def write_error(self, status_code: int, **kwargs: Any) -> None:
"""APIHandler errors are JSON, not human pages"""
self.set_header("Content-Type", "application/json")
message = responses.get(status_code, "Unknown HTTP Error")
reply: dict[str, Any] = {
"message": message,
}
exc_info = kwargs.get("exc_info")
if exc_info:
e = exc_info[1]
if isinstance(e, HTTPError):
reply["message"] = e.log_message or message
reply["reason"] = e.reason
else:
reply["message"] = "Unhandled error"
reply["reason"] = None
# backward-compatibility: traceback field is present,
# but always empty
reply["traceback"] = ""
self.log.warning("wrote error: %r", reply["message"], exc_info=True)
self.finish(json.dumps(reply))
```
## `jupyter_server/base/handlers.py` — `module:<module>@13` (lines 13-13)
```python
import types
```
## `jupyter_server/services/kernels/handlers.py` — `class:KernelActionHandler` (lines 87-109)
```python
class KernelActionHandler(KernelsAPIHandler):
"""A kernel action API handler."""
@web.authenticated
@authorized
async def post(self, kernel_id, action):
"""Interrupt or restart a kernel."""
km = self.kernel_manager
if action == "interrupt":
await ensure_async(km.interrupt_kernel(kernel_id)) # type:ignore[func-returns-value]
self.set_status(204)
if action == "restart":
try:
await km.restart_kernel(kernel_id)
except Exception as e:
message = "Exception restarting kernel"
self.log.error(message, exc_info=True)
self.write(json.dumps({"message": message, "traceback": ""}))
self.set_status(500)
else:
model = await ensure_async(km.kernel_model(kernel_id))
self.write(json.dumps(model, default=json_default))
self.finish()
```
## `jupyter_server/services/kernels/handlers.py` — `function:KernelActionHandler.post` (lines 90-109)
```python
async def post(self, kernel_id, action):
"""Interrupt or restart a kernel."""
km = self.kernel_manager
if action == "interrupt":
await ensure_async(km.interrupt_kernel(kernel_id)) # type:ignore[func-returns-value]
self.set_status(204)
if action == "restart":
try:
await km.restart_kernel(kernel_id)
except Exception as e:
message = "Exception restarting kernel"
self.log.error(message, exc_info=True)
self.write(json.dumps({"message": message, "traceback": ""}))
self.set_status(500)
else:
model = await ensure_async(km.kernel_model(kernel_id))
self.write(json.dumps(model, default=json_default))
self.finish()
```
|