--- /srv/rebuilderd/tmp/rebuilderdgW8SBC/inputs/jupyterhub_5.2.1+ds1-4_all.deb +++ /srv/rebuilderd/tmp/rebuilderdgW8SBC/out/jupyterhub_5.2.1+ds1-4_all.deb ├── file list │ @@ -1,3 +1,3 @@ │ -rw-r--r-- 0 0 0 4 2025-05-28 09:40:25.000000 debian-binary │ --rw-r--r-- 0 0 0 59496 2025-05-28 09:40:25.000000 control.tar.xz │ --rw-r--r-- 0 0 0 1962752 2025-05-28 09:40:25.000000 data.tar.xz │ +-rw-r--r-- 0 0 0 59480 2025-05-28 09:40:25.000000 control.tar.xz │ +-rw-r--r-- 0 0 0 1962320 2025-05-28 09:40:25.000000 data.tar.xz ├── control.tar.xz │ ├── control.tar │ │ ├── ./md5sums │ │ │ ├── ./md5sums │ │ │ │┄ Files differ ├── data.tar.xz │ ├── data.tar │ │ ├── file list │ │ │ @@ -146,15 +146,15 @@ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/doc/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/doc/jupyterhub/ │ │ │ -rw-r--r-- 0 root (0) root (0) 1679 2025-05-28 09:40:25.000000 ./usr/share/doc/jupyterhub/README.Debian.md │ │ │ -rw-r--r-- 0 root (0) root (0) 3837 2024-10-21 09:35:53.000000 ./usr/share/doc/jupyterhub/README.md.gz │ │ │ -rw-r--r-- 0 root (0) root (0) 1363 2025-05-28 09:40:25.000000 ./usr/share/doc/jupyterhub/changelog.Debian.gz │ │ │ -rw-r--r-- 0 root (0) root (0) 2121 2025-05-28 09:40:25.000000 ./usr/share/doc/jupyterhub/copyright │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/ │ │ │ --rw-r--r-- 0 root (0) root (0) 98384 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/jupyterhub_config.py │ │ │ +-rw-r--r-- 0 root (0) root (0) 98386 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/jupyterhub_config.py │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/static/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/static/components/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/static/components/@fortawesome/ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/static/components/@fortawesome/fontawesome-free/ │ │ │ -rw-r--r-- 0 root (0) root (0) 7427 2024-10-21 09:36:01.000000 ./usr/share/jupyterhub/static/components/@fortawesome/fontawesome-free/LICENSE.txt │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2025-05-28 09:40:25.000000 ./usr/share/jupyterhub/static/components/@fortawesome/fontawesome-free/css/ │ │ │ -rw-r--r-- 0 root (0) root (0) 132658 2024-10-21 09:36:00.000000 ./usr/share/jupyterhub/static/components/@fortawesome/fontawesome-free/css/all.css │ │ ├── ./usr/share/jupyterhub/jupyterhub_config.py │ │ │ @@ -997,842 +997,14 @@ │ │ │ # │ │ │ # It should return the new URL to redirect to, or None to preserve current │ │ │ # behavior. │ │ │ # Default: None │ │ │ # c.JupyterHub.user_redirect_hook = None │ │ │ │ │ │ #------------------------------------------------------------------------------ │ │ │ -# Spawner(LoggingConfigurable) configuration │ │ │ -#------------------------------------------------------------------------------ │ │ │ -## Base class for spawning single-user notebook servers. │ │ │ -# │ │ │ -# Subclass this, and override the following methods: │ │ │ -# │ │ │ -# - load_state - get_state - start - stop - poll │ │ │ -# │ │ │ -# As JupyterHub supports multiple users, an instance of the Spawner subclass is │ │ │ -# created for each user. If there are 20 JupyterHub users, there will be 20 │ │ │ -# instances of the subclass. │ │ │ - │ │ │ -## Extra arguments to be passed to the single-user server. │ │ │ -# │ │ │ -# Some spawners allow shell-style expansion here, allowing you to use │ │ │ -# environment variables here. Most, including the default, do not. Consult the │ │ │ -# documentation for your spawner to verify! │ │ │ -# Default: [] │ │ │ -# c.Spawner.args = [] │ │ │ - │ │ │ -## An optional hook function that you can implement to pass `auth_state` to the │ │ │ -# spawner after it has been initialized but before it starts. The `auth_state` │ │ │ -# dictionary may be set by the `.authenticate()` method of the authenticator. │ │ │ -# This hook enables you to pass some or all of that information to your spawner. │ │ │ -# │ │ │ -# Example:: │ │ │ -# │ │ │ -# def userdata_hook(spawner, auth_state): │ │ │ -# spawner.userdata = auth_state["userdata"] │ │ │ -# │ │ │ -# c.Spawner.auth_state_hook = userdata_hook │ │ │ -# Default: None │ │ │ -# c.Spawner.auth_state_hook = None │ │ │ - │ │ │ -## The command used for starting the single-user server. │ │ │ -# │ │ │ -# Provide either a string or a list containing the path to the startup script │ │ │ -# command. Extra arguments, other than this path, should be provided via `args`. │ │ │ -# │ │ │ -# This is usually set if you want to start the single-user server in a different │ │ │ -# python environment (with virtualenv/conda) than JupyterHub itself. │ │ │ -# │ │ │ -# Some spawners allow shell-style expansion here, allowing you to use │ │ │ -# environment variables. Most, including the default, do not. Consult the │ │ │ -# documentation for your spawner to verify! │ │ │ -# Default: ['jupyterhub-singleuser'] │ │ │ -# c.Spawner.cmd = ['jupyterhub-singleuser'] │ │ │ - │ │ │ -## Maximum number of consecutive failures to allow before shutting down │ │ │ -# JupyterHub. │ │ │ -# │ │ │ -# This helps JupyterHub recover from a certain class of problem preventing │ │ │ -# launch in contexts where the Hub is automatically restarted (e.g. systemd, │ │ │ -# docker, kubernetes). │ │ │ -# │ │ │ -# A limit of 0 means no limit and consecutive failures will not be tracked. │ │ │ -# Default: 0 │ │ │ -# c.Spawner.consecutive_failure_limit = 0 │ │ │ - │ │ │ -## Minimum number of cpu-cores a single-user notebook server is guaranteed to │ │ │ -# have available. │ │ │ -# │ │ │ -# If this value is set to 0.5, allows use of 50% of one CPU. If this value is │ │ │ -# set to 2, allows use of up to 2 CPUs. │ │ │ -# │ │ │ -# **This is a configuration setting. Your spawner must implement support for the │ │ │ -# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ -# implement this support. A custom spawner **must** add support for this setting │ │ │ -# for it to be enforced. │ │ │ -# Default: None │ │ │ -# c.Spawner.cpu_guarantee = None │ │ │ - │ │ │ -## Maximum number of cpu-cores a single-user notebook server is allowed to use. │ │ │ -# │ │ │ -# If this value is set to 0.5, allows use of 50% of one CPU. If this value is │ │ │ -# set to 2, allows use of up to 2 CPUs. │ │ │ -# │ │ │ -# The single-user notebook server will never be scheduled by the kernel to use │ │ │ -# more cpu-cores than this. There is no guarantee that it can access this many │ │ │ -# cpu-cores. │ │ │ -# │ │ │ -# **This is a configuration setting. Your spawner must implement support for the │ │ │ -# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ -# implement this support. A custom spawner **must** add support for this setting │ │ │ -# for it to be enforced. │ │ │ -# Default: None │ │ │ -# c.Spawner.cpu_limit = None │ │ │ - │ │ │ -## Enable debug-logging of the single-user server │ │ │ -# Default: False │ │ │ -# c.Spawner.debug = False │ │ │ - │ │ │ -## The URL the single-user server should start in. │ │ │ -# │ │ │ -# `{username}` will be expanded to the user's username │ │ │ -# │ │ │ -# Example uses: │ │ │ -# │ │ │ -# - You can set `notebook_dir` to `/` and `default_url` to `/tree/home/{username}` to allow people to │ │ │ -# navigate the whole filesystem from their notebook server, but still start in their home directory. │ │ │ -# - Start with `/notebooks` instead of `/tree` if `default_url` points to a notebook instead of a directory. │ │ │ -# - You can set this to `/lab` to have JupyterLab start by default, rather than Jupyter Notebook. │ │ │ -# Default: '' │ │ │ -# c.Spawner.default_url = '' │ │ │ - │ │ │ -## Disable per-user configuration of single-user servers. │ │ │ -# │ │ │ -# When starting the user's single-user server, any config file found in the │ │ │ -# user's $HOME directory will be ignored. │ │ │ -# │ │ │ -# Note: a user could circumvent this if the user modifies their Python │ │ │ -# environment, such as when they have their own conda environments / virtualenvs │ │ │ -# / containers. │ │ │ -# Default: False │ │ │ -# c.Spawner.disable_user_config = False │ │ │ - │ │ │ -## List of environment variables for the single-user server to inherit from the │ │ │ -# JupyterHub process. │ │ │ -# │ │ │ -# This list is used to ensure that sensitive information in the JupyterHub │ │ │ -# process's environment (such as `CONFIGPROXY_AUTH_TOKEN`) is not passed to the │ │ │ -# single-user server's process. │ │ │ -# Default: ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ -# c.Spawner.env_keep = ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ - │ │ │ -## Extra environment variables to set for the single-user server's process. │ │ │ -# │ │ │ -# Environment variables that end up in the single-user server's process come from 3 sources: │ │ │ -# - This `environment` configurable │ │ │ -# - The JupyterHub process' environment variables that are listed in `env_keep` │ │ │ -# - Variables to establish contact between the single-user notebook and the hub (such as JUPYTERHUB_API_TOKEN) │ │ │ -# │ │ │ -# The `environment` configurable should be set by JupyterHub administrators to │ │ │ -# add installation specific environment variables. It is a dict where the key is │ │ │ -# the name of the environment variable, and the value can be a string or a │ │ │ -# callable. If it is a callable, it will be called with one parameter (the │ │ │ -# spawner instance), and should return a string fairly quickly (no blocking │ │ │ -# operations please!). │ │ │ -# │ │ │ -# Note that the spawner class' interface is not guaranteed to be exactly same │ │ │ -# across upgrades, so if you are using the callable take care to verify it │ │ │ -# continues to work after upgrades! │ │ │ -# │ │ │ -# .. versionchanged:: 1.2 │ │ │ -# environment from this configuration has highest priority, │ │ │ -# allowing override of 'default' env variables, │ │ │ -# such as JUPYTERHUB_API_URL. │ │ │ -# Default: {} │ │ │ -# c.Spawner.environment = {} │ │ │ - │ │ │ -## Override specific traitlets based on group membership of the user. │ │ │ -# │ │ │ -# This can be a dict, or a callable that returns a dict. The keys of the dict │ │ │ -# are *only* used for lexicographical sorting, to guarantee consistent ordering │ │ │ -# of the overrides. If it is a callable, it may be async, and will be passed one │ │ │ -# parameter - the spawner instance. It should return a dictionary. │ │ │ -# │ │ │ -# The values of the dict are dicts with the following keys: │ │ │ -# │ │ │ -# - `"groups"` - If the user belongs to *any* of these groups, these overrides are │ │ │ -# applied to their server before spawning. │ │ │ -# - `"spawner_override"` - a dictionary with overrides to apply to the Spawner │ │ │ -# settings. Each value can be either the final value to change or a callable that │ │ │ -# take the `Spawner` instance as parameter and returns the final value. │ │ │ -# If the traitlet being overriden is a *dictionary*, the dictionary │ │ │ -# will be *recursively updated*, rather than overriden. If you want to │ │ │ -# remove a key, set its value to `None`. │ │ │ -# │ │ │ -# Example: │ │ │ -# │ │ │ -# The following example config will: │ │ │ -# │ │ │ -# 1. Add the environment variable "AM_I_GROUP_ALPHA" to everyone in the "group-alpha" group │ │ │ -# 2. Add the environment variable "AM_I_GROUP_BETA" to everyone in the "group-beta" group. │ │ │ -# If a user is part of both "group-beta" and "group-alpha", they will get *both* these env │ │ │ -# vars, due to the dictionary merging functionality. │ │ │ -# 3. Add a higher memory limit for everyone in the "group-beta" group. │ │ │ -# │ │ │ -# :: │ │ │ -# │ │ │ -# c.Spawner.group_overrides = { │ │ │ -# "01-group-alpha-env-add": { │ │ │ -# "groups": ["group-alpha"], │ │ │ -# "spawner_override": {"environment": {"AM_I_GROUP_ALPHA": "yes"}}, │ │ │ -# }, │ │ │ -# "02-group-beta-env-add": { │ │ │ -# "groups": ["group-beta"], │ │ │ -# "spawner_override": {"environment": {"AM_I_GROUP_BETA": "yes"}}, │ │ │ -# }, │ │ │ -# "03-group-beta-mem-limit": { │ │ │ -# "groups": ["group-beta"], │ │ │ -# "spawner_override": {"mem_limit": "2G"} │ │ │ -# } │ │ │ -# } │ │ │ -# Default: traitlets.Undefined │ │ │ -# c.Spawner.group_overrides = traitlets.Undefined │ │ │ - │ │ │ -## Timeout (in seconds) before giving up on a spawned HTTP server │ │ │ -# │ │ │ -# Once a server has successfully been spawned, this is the amount of time we │ │ │ -# wait before assuming that the server is unable to accept connections. │ │ │ -# Default: 30 │ │ │ -# c.Spawner.http_timeout = 30 │ │ │ - │ │ │ -## The URL the single-user server should connect to the Hub. │ │ │ -# │ │ │ -# If the Hub URL set in your JupyterHub config is not reachable from spawned │ │ │ -# notebooks, you can set differnt URL by this config. │ │ │ -# │ │ │ -# Is None if you don't need to change the URL. │ │ │ -# Default: None │ │ │ -# c.Spawner.hub_connect_url = None │ │ │ - │ │ │ -## The IP address (or hostname) the single-user server should listen on. │ │ │ -# │ │ │ -# Usually either '127.0.0.1' (default) or '0.0.0.0'. │ │ │ -# │ │ │ -# The JupyterHub proxy implementation should be able to send packets to this │ │ │ -# interface. │ │ │ -# │ │ │ -# Subclasses which launch remotely or in containers should override the default │ │ │ -# to '0.0.0.0'. │ │ │ -# │ │ │ -# .. versionchanged:: 2.0 │ │ │ -# Default changed to '127.0.0.1', from ''. │ │ │ -# In most cases, this does not result in a change in behavior, │ │ │ -# as '' was interpreted as 'unspecified', │ │ │ -# which used the subprocesses' own default, itself usually '127.0.0.1'. │ │ │ -# Default: '127.0.0.1' │ │ │ -# c.Spawner.ip = '127.0.0.1' │ │ │ - │ │ │ -## Minimum number of bytes a single-user notebook server is guaranteed to have │ │ │ -# available. │ │ │ -# │ │ │ -# Allows the following suffixes: │ │ │ -# - K -> Kilobytes │ │ │ -# - M -> Megabytes │ │ │ -# - G -> Gigabytes │ │ │ -# - T -> Terabytes │ │ │ -# │ │ │ -# **This is a configuration setting. Your spawner must implement support for the │ │ │ -# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ -# implement this support. A custom spawner **must** add support for this setting │ │ │ -# for it to be enforced. │ │ │ -# Default: None │ │ │ -# c.Spawner.mem_guarantee = None │ │ │ - │ │ │ -## Maximum number of bytes a single-user notebook server is allowed to use. │ │ │ -# │ │ │ -# Allows the following suffixes: │ │ │ -# - K -> Kilobytes │ │ │ -# - M -> Megabytes │ │ │ -# - G -> Gigabytes │ │ │ -# - T -> Terabytes │ │ │ -# │ │ │ -# If the single user server tries to allocate more memory than this, it will │ │ │ -# fail. There is no guarantee that the single-user notebook server will be able │ │ │ -# to allocate this much memory - only that it can not allocate more than this. │ │ │ -# │ │ │ -# **This is a configuration setting. Your spawner must implement support for the │ │ │ -# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ -# implement this support. A custom spawner **must** add support for this setting │ │ │ -# for it to be enforced. │ │ │ -# Default: None │ │ │ -# c.Spawner.mem_limit = None │ │ │ - │ │ │ -## Path to the notebook directory for the single-user server. │ │ │ -# │ │ │ -# The user sees a file listing of this directory when the notebook interface is │ │ │ -# started. The current interface does not easily allow browsing beyond the │ │ │ -# subdirectories in this directory's tree. │ │ │ -# │ │ │ -# `~` will be expanded to the home directory of the user, and {username} will be │ │ │ -# replaced with the name of the user. │ │ │ -# │ │ │ -# Note that this does *not* prevent users from accessing files outside of this │ │ │ -# path! They can do so with many other means. │ │ │ -# Default: '' │ │ │ -# c.Spawner.notebook_dir = '' │ │ │ - │ │ │ -## Allowed scopes for oauth tokens issued by this server's oauth client. │ │ │ -# │ │ │ -# This sets the maximum and default scopes │ │ │ -# assigned to oauth tokens issued by a single-user server's │ │ │ -# oauth client (i.e. tokens stored in browsers after authenticating with the server), │ │ │ -# defining what actions the server can take on behalf of logged-in users. │ │ │ -# │ │ │ -# Default is an empty list, meaning minimal permissions to identify users, │ │ │ -# no actions can be taken on their behalf. │ │ │ -# │ │ │ -# If callable, will be called with the Spawner as a single argument. │ │ │ -# Callables may be async. │ │ │ -# Default: traitlets.Undefined │ │ │ -# c.Spawner.oauth_client_allowed_scopes = traitlets.Undefined │ │ │ - │ │ │ -## Allowed roles for oauth tokens. │ │ │ -# │ │ │ -# Deprecated in 3.0: use oauth_client_allowed_scopes │ │ │ -# │ │ │ -# This sets the maximum and default roles │ │ │ -# assigned to oauth tokens issued by a single-user server's │ │ │ -# oauth client (i.e. tokens stored in browsers after authenticating with the server), │ │ │ -# defining what actions the server can take on behalf of logged-in users. │ │ │ -# │ │ │ -# Default is an empty list, meaning minimal permissions to identify users, │ │ │ -# no actions can be taken on their behalf. │ │ │ -# Default: traitlets.Undefined │ │ │ -# c.Spawner.oauth_roles = traitlets.Undefined │ │ │ - │ │ │ -## An HTML form for options a user can specify on launching their server. │ │ │ -# │ │ │ -# The surrounding `
` element and the submit button are already provided. │ │ │ -# │ │ │ -# For example: │ │ │ -# │ │ │ -# .. code:: html │ │ │ -# │ │ │ -# Set your key: │ │ │ -# │ │ │ -#
│ │ │ -# Choose a letter: │ │ │ -# │ │ │ -# │ │ │ -# The data from this form submission will be passed on to your spawner in │ │ │ -# `self.user_options` │ │ │ -# │ │ │ -# Instead of a form snippet string, this could also be a callable that takes as │ │ │ -# one parameter the current spawner instance and returns a string. The callable │ │ │ -# will be called asynchronously if it returns a future, rather than a str. Note │ │ │ -# that the interface of the spawner class is not deemed stable across versions, │ │ │ -# so using this functionality might cause your JupyterHub upgrades to break. │ │ │ -# Default: traitlets.Undefined │ │ │ -# c.Spawner.options_form = traitlets.Undefined │ │ │ - │ │ │ -## Interpret HTTP form data │ │ │ -# │ │ │ -# Form data will always arrive as a dict of lists of strings. Override this │ │ │ -# function to understand single-values, numbers, etc. │ │ │ -# │ │ │ -# This should coerce form data into the structure expected by self.user_options, │ │ │ -# which must be a dict, and should be JSON-serializeable, though it can contain │ │ │ -# bytes in addition to standard JSON data types. │ │ │ -# │ │ │ -# This method should not have any side effects. Any handling of `user_options` │ │ │ -# should be done in `.start()` to ensure consistent behavior across servers │ │ │ -# spawned via the API and form submission page. │ │ │ -# │ │ │ -# Instances will receive this data on self.user_options, after passing through │ │ │ -# this function, prior to `Spawner.start`. │ │ │ -# │ │ │ -# .. versionchanged:: 1.0 │ │ │ -# user_options are persisted in the JupyterHub database to be reused │ │ │ -# on subsequent spawns if no options are given. │ │ │ -# user_options is serialized to JSON as part of this persistence │ │ │ -# (with additional support for bytes in case of uploaded file data), │ │ │ -# and any non-bytes non-jsonable values will be replaced with None │ │ │ -# if the user_options are re-used. │ │ │ -# Default: traitlets.Undefined │ │ │ -# c.Spawner.options_from_form = traitlets.Undefined │ │ │ - │ │ │ -## Interval (in seconds) on which to poll the spawner for single-user server's │ │ │ -# status. │ │ │ -# │ │ │ -# At every poll interval, each spawner's `.poll` method is called, which checks │ │ │ -# if the single-user server is still running. If it isn't running, then │ │ │ -# JupyterHub modifies its own state accordingly and removes appropriate routes │ │ │ -# from the configurable proxy. │ │ │ -# Default: 30 │ │ │ -# c.Spawner.poll_interval = 30 │ │ │ - │ │ │ -## Jitter fraction for poll_interval. │ │ │ -# │ │ │ -# Avoids alignment of poll calls for many Spawners, e.g. when restarting │ │ │ -# JupyterHub, which restarts all polls for running Spawners. │ │ │ -# │ │ │ -# `poll_jitter=0` means no jitter, 0.1 means 10%, etc. │ │ │ -# Default: 0.1 │ │ │ -# c.Spawner.poll_jitter = 0.1 │ │ │ - │ │ │ -## The port for single-user servers to listen on. │ │ │ -# │ │ │ -# Defaults to `0`, which uses a randomly allocated port number each time. │ │ │ -# │ │ │ -# If set to a non-zero value, all Spawners will use the same port, which only │ │ │ -# makes sense if each server is on a different address, e.g. in containers. │ │ │ -# │ │ │ -# New in version 0.7. │ │ │ -# Default: 0 │ │ │ -# c.Spawner.port = 0 │ │ │ - │ │ │ -## An optional hook function that you can implement to do work after the spawner │ │ │ -# stops. │ │ │ -# │ │ │ -# This can be set independent of any concrete spawner implementation. │ │ │ -# Default: None │ │ │ -# c.Spawner.post_stop_hook = None │ │ │ - │ │ │ -## An optional hook function that you can implement to do some bootstrapping work │ │ │ -# before the spawner starts. For example, create a directory for your user or │ │ │ -# load initial content. │ │ │ -# │ │ │ -# This can be set independent of any concrete spawner implementation. │ │ │ -# │ │ │ -# This maybe a coroutine. │ │ │ -# │ │ │ -# Example:: │ │ │ -# │ │ │ -# def my_hook(spawner): │ │ │ -# username = spawner.user.name │ │ │ -# spawner.environment["GREETING"] = f"Hello {username}" │ │ │ -# │ │ │ -# c.Spawner.pre_spawn_hook = my_hook │ │ │ -# Default: None │ │ │ -# c.Spawner.pre_spawn_hook = None │ │ │ - │ │ │ -## An optional hook function that you can implement to modify the ready event, │ │ │ -# which will be shown to the user on the spawn progress page when their server │ │ │ -# is ready. │ │ │ -# │ │ │ -# This can be set independent of any concrete spawner implementation. │ │ │ -# │ │ │ -# This maybe a coroutine. │ │ │ -# │ │ │ -# Example:: │ │ │ -# │ │ │ -# async def my_ready_hook(spawner, ready_event): │ │ │ -# ready_event["html_message"] = f"Server {spawner.name} is ready for {spawner.user.name}" │ │ │ -# return ready_event │ │ │ -# │ │ │ -# c.Spawner.progress_ready_hook = my_ready_hook │ │ │ -# Default: None │ │ │ -# c.Spawner.progress_ready_hook = None │ │ │ - │ │ │ -## The list of scopes to request for $JUPYTERHUB_API_TOKEN │ │ │ -# │ │ │ -# If not specified, the scopes in the `server` role will be used │ │ │ -# (unchanged from pre-4.0). │ │ │ -# │ │ │ -# If callable, will be called with the Spawner instance as its sole argument │ │ │ -# (JupyterHub user available as spawner.user). │ │ │ -# │ │ │ -# JUPYTERHUB_API_TOKEN will be assigned the _subset_ of these scopes │ │ │ -# that are held by the user (as in oauth_client_allowed_scopes). │ │ │ -# │ │ │ -# .. versionadded:: 4.0 │ │ │ -# Default: traitlets.Undefined │ │ │ -# c.Spawner.server_token_scopes = traitlets.Undefined │ │ │ - │ │ │ -## List of SSL alt names │ │ │ -# │ │ │ -# May be set in config if all spawners should have the same value(s), │ │ │ -# or set at runtime by Spawner that know their names. │ │ │ -# Default: [] │ │ │ -# c.Spawner.ssl_alt_names = [] │ │ │ - │ │ │ -## Whether to include `DNS:localhost`, `IP:127.0.0.1` in alt names │ │ │ -# Default: True │ │ │ -# c.Spawner.ssl_alt_names_include_local = True │ │ │ - │ │ │ -## Timeout (in seconds) before giving up on starting of single-user server. │ │ │ -# │ │ │ -# This is the timeout for start to return, not the timeout for the server to │ │ │ -# respond. Callers of spawner.start will assume that startup has failed if it │ │ │ -# takes longer than this. start should return when the server process is started │ │ │ -# and its location is known. │ │ │ -# Default: 60 │ │ │ -# c.Spawner.start_timeout = 60 │ │ │ - │ │ │ -#------------------------------------------------------------------------------ │ │ │ -# LocalProcessSpawner(Spawner) configuration │ │ │ -#------------------------------------------------------------------------------ │ │ │ -## A Spawner that uses `subprocess.Popen` to start single-user servers as local │ │ │ -# processes. │ │ │ -# │ │ │ -# Requires local UNIX users matching the authenticated users to exist. Does not │ │ │ -# work on Windows. │ │ │ -# │ │ │ -# This is the default spawner for JupyterHub. │ │ │ -# │ │ │ -# Note: This spawner does not implement CPU / memory guarantees and limits. │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.args │ │ │ -# c.LocalProcessSpawner.args = [] │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.auth_state_hook │ │ │ -# c.LocalProcessSpawner.auth_state_hook = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.cmd │ │ │ -# c.LocalProcessSpawner.cmd = ['jupyterhub-singleuser'] │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.consecutive_failure_limit │ │ │ -# c.LocalProcessSpawner.consecutive_failure_limit = 0 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.cpu_guarantee │ │ │ -# c.LocalProcessSpawner.cpu_guarantee = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.cpu_limit │ │ │ -# c.LocalProcessSpawner.cpu_limit = None │ │ │ - │ │ │ -## Enable debug-logging of the single-user server │ │ │ -# See also: Spawner.debug │ │ │ -# c.LocalProcessSpawner.debug = False │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.default_url │ │ │ -# c.LocalProcessSpawner.default_url = '' │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.disable_user_config │ │ │ -# c.LocalProcessSpawner.disable_user_config = False │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.env_keep │ │ │ -# c.LocalProcessSpawner.env_keep = ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.environment │ │ │ -# c.LocalProcessSpawner.environment = {} │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.group_overrides │ │ │ -# c.LocalProcessSpawner.group_overrides = traitlets.Undefined │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.http_timeout │ │ │ -# c.LocalProcessSpawner.http_timeout = 30 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.hub_connect_url │ │ │ -# c.LocalProcessSpawner.hub_connect_url = None │ │ │ - │ │ │ -## Seconds to wait for single-user server process to halt after SIGINT. │ │ │ -# │ │ │ -# If the process has not exited cleanly after this many seconds, a SIGTERM is │ │ │ -# sent. │ │ │ -# Default: 10 │ │ │ -# c.LocalProcessSpawner.interrupt_timeout = 10 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.ip │ │ │ -# c.LocalProcessSpawner.ip = '127.0.0.1' │ │ │ - │ │ │ -## Seconds to wait for process to halt after SIGKILL before giving up. │ │ │ -# │ │ │ -# If the process does not exit cleanly after this many seconds of SIGKILL, it │ │ │ -# becomes a zombie process. The hub process will log a warning and then give up. │ │ │ -# Default: 5 │ │ │ -# c.LocalProcessSpawner.kill_timeout = 5 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.mem_guarantee │ │ │ -# c.LocalProcessSpawner.mem_guarantee = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.mem_limit │ │ │ -# c.LocalProcessSpawner.mem_limit = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.notebook_dir │ │ │ -# c.LocalProcessSpawner.notebook_dir = '' │ │ │ - │ │ │ -## Allowed scopes for oauth tokens issued by this server's oauth client. │ │ │ -# See also: Spawner.oauth_client_allowed_scopes │ │ │ -# c.LocalProcessSpawner.oauth_client_allowed_scopes = traitlets.Undefined │ │ │ - │ │ │ -## Allowed roles for oauth tokens. │ │ │ -# See also: Spawner.oauth_roles │ │ │ -# c.LocalProcessSpawner.oauth_roles = traitlets.Undefined │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.options_form │ │ │ -# c.LocalProcessSpawner.options_form = traitlets.Undefined │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.options_from_form │ │ │ -# c.LocalProcessSpawner.options_from_form = traitlets.Undefined │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.poll_interval │ │ │ -# c.LocalProcessSpawner.poll_interval = 30 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.poll_jitter │ │ │ -# c.LocalProcessSpawner.poll_jitter = 0.1 │ │ │ - │ │ │ -## Extra keyword arguments to pass to Popen │ │ │ -# │ │ │ -# when spawning single-user servers. │ │ │ -# │ │ │ -# For example:: │ │ │ -# │ │ │ -# popen_kwargs = dict(shell=True) │ │ │ -# Default: {} │ │ │ -# c.LocalProcessSpawner.popen_kwargs = {} │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.port │ │ │ -# c.LocalProcessSpawner.port = 0 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.post_stop_hook │ │ │ -# c.LocalProcessSpawner.post_stop_hook = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.pre_spawn_hook │ │ │ -# c.LocalProcessSpawner.pre_spawn_hook = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.progress_ready_hook │ │ │ -# c.LocalProcessSpawner.progress_ready_hook = None │ │ │ - │ │ │ -## The list of scopes to request for $JUPYTERHUB_API_TOKEN │ │ │ -# See also: Spawner.server_token_scopes │ │ │ -# c.LocalProcessSpawner.server_token_scopes = traitlets.Undefined │ │ │ - │ │ │ -## Specify a shell command to launch. │ │ │ -# │ │ │ -# The single-user command will be appended to this list, │ │ │ -# so it sould end with `-c` (for bash) or equivalent. │ │ │ -# │ │ │ -# For example:: │ │ │ -# │ │ │ -# c.LocalProcessSpawner.shell_cmd = ['bash', '-l', '-c'] │ │ │ -# │ │ │ -# to launch with a bash login shell, which would set up the user's own │ │ │ -# complete environment. │ │ │ -# │ │ │ -# .. warning:: │ │ │ -# │ │ │ -# Using shell_cmd gives users control over PATH, etc., │ │ │ -# which could change what the jupyterhub-singleuser launch command does. │ │ │ -# Only use this for trusted users. │ │ │ -# Default: [] │ │ │ -# c.LocalProcessSpawner.shell_cmd = [] │ │ │ - │ │ │ -## List of SSL alt names │ │ │ -# See also: Spawner.ssl_alt_names │ │ │ -# c.LocalProcessSpawner.ssl_alt_names = [] │ │ │ - │ │ │ -## Whether to include `DNS:localhost`, `IP:127.0.0.1` in alt names │ │ │ -# See also: Spawner.ssl_alt_names_include_local │ │ │ -# c.LocalProcessSpawner.ssl_alt_names_include_local = True │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.start_timeout │ │ │ -# c.LocalProcessSpawner.start_timeout = 60 │ │ │ - │ │ │ -## Seconds to wait for single-user server process to halt after SIGTERM. │ │ │ -# │ │ │ -# If the process does not exit cleanly after this many seconds of SIGTERM, a │ │ │ -# SIGKILL is sent. │ │ │ -# Default: 5 │ │ │ -# c.LocalProcessSpawner.term_timeout = 5 │ │ │ - │ │ │ -#------------------------------------------------------------------------------ │ │ │ -# SimpleLocalProcessSpawner(LocalProcessSpawner) configuration │ │ │ -#------------------------------------------------------------------------------ │ │ │ -## A version of LocalProcessSpawner that doesn't require users to exist on the │ │ │ -# system beforehand. │ │ │ -# │ │ │ -# Only use this for testing. │ │ │ -# │ │ │ -# Note: DO NOT USE THIS FOR PRODUCTION USE CASES! It is very insecure, and │ │ │ -# provides absolutely no isolation between different users! │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.args │ │ │ -# c.SimpleLocalProcessSpawner.args = [] │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.auth_state_hook │ │ │ -# c.SimpleLocalProcessSpawner.auth_state_hook = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.cmd │ │ │ -# c.SimpleLocalProcessSpawner.cmd = ['jupyterhub-singleuser'] │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.consecutive_failure_limit │ │ │ -# c.SimpleLocalProcessSpawner.consecutive_failure_limit = 0 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.cpu_guarantee │ │ │ -# c.SimpleLocalProcessSpawner.cpu_guarantee = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.cpu_limit │ │ │ -# c.SimpleLocalProcessSpawner.cpu_limit = None │ │ │ - │ │ │ -## Enable debug-logging of the single-user server │ │ │ -# See also: Spawner.debug │ │ │ -# c.SimpleLocalProcessSpawner.debug = False │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.default_url │ │ │ -# c.SimpleLocalProcessSpawner.default_url = '' │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.disable_user_config │ │ │ -# c.SimpleLocalProcessSpawner.disable_user_config = False │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.env_keep │ │ │ -# c.SimpleLocalProcessSpawner.env_keep = ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.environment │ │ │ -# c.SimpleLocalProcessSpawner.environment = {} │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.group_overrides │ │ │ -# c.SimpleLocalProcessSpawner.group_overrides = traitlets.Undefined │ │ │ - │ │ │ -## Template to expand to set the user home. {username} is expanded to the │ │ │ -# jupyterhub username. │ │ │ -# Default: '/tmp/{username}' │ │ │ -# c.SimpleLocalProcessSpawner.home_dir_template = '/tmp/{username}' │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.http_timeout │ │ │ -# c.SimpleLocalProcessSpawner.http_timeout = 30 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.hub_connect_url │ │ │ -# c.SimpleLocalProcessSpawner.hub_connect_url = None │ │ │ - │ │ │ -## │ │ │ -# See also: LocalProcessSpawner.interrupt_timeout │ │ │ -# c.SimpleLocalProcessSpawner.interrupt_timeout = 10 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.ip │ │ │ -# c.SimpleLocalProcessSpawner.ip = '127.0.0.1' │ │ │ - │ │ │ -## │ │ │ -# See also: LocalProcessSpawner.kill_timeout │ │ │ -# c.SimpleLocalProcessSpawner.kill_timeout = 5 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.mem_guarantee │ │ │ -# c.SimpleLocalProcessSpawner.mem_guarantee = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.mem_limit │ │ │ -# c.SimpleLocalProcessSpawner.mem_limit = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.notebook_dir │ │ │ -# c.SimpleLocalProcessSpawner.notebook_dir = '' │ │ │ - │ │ │ -## Allowed scopes for oauth tokens issued by this server's oauth client. │ │ │ -# See also: Spawner.oauth_client_allowed_scopes │ │ │ -# c.SimpleLocalProcessSpawner.oauth_client_allowed_scopes = traitlets.Undefined │ │ │ - │ │ │ -## Allowed roles for oauth tokens. │ │ │ -# See also: Spawner.oauth_roles │ │ │ -# c.SimpleLocalProcessSpawner.oauth_roles = traitlets.Undefined │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.options_form │ │ │ -# c.SimpleLocalProcessSpawner.options_form = traitlets.Undefined │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.options_from_form │ │ │ -# c.SimpleLocalProcessSpawner.options_from_form = traitlets.Undefined │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.poll_interval │ │ │ -# c.SimpleLocalProcessSpawner.poll_interval = 30 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.poll_jitter │ │ │ -# c.SimpleLocalProcessSpawner.poll_jitter = 0.1 │ │ │ - │ │ │ -## Extra keyword arguments to pass to Popen │ │ │ -# See also: LocalProcessSpawner.popen_kwargs │ │ │ -# c.SimpleLocalProcessSpawner.popen_kwargs = {} │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.port │ │ │ -# c.SimpleLocalProcessSpawner.port = 0 │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.post_stop_hook │ │ │ -# c.SimpleLocalProcessSpawner.post_stop_hook = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.pre_spawn_hook │ │ │ -# c.SimpleLocalProcessSpawner.pre_spawn_hook = None │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.progress_ready_hook │ │ │ -# c.SimpleLocalProcessSpawner.progress_ready_hook = None │ │ │ - │ │ │ -## The list of scopes to request for $JUPYTERHUB_API_TOKEN │ │ │ -# See also: Spawner.server_token_scopes │ │ │ -# c.SimpleLocalProcessSpawner.server_token_scopes = traitlets.Undefined │ │ │ - │ │ │ -## Specify a shell command to launch. │ │ │ -# See also: LocalProcessSpawner.shell_cmd │ │ │ -# c.SimpleLocalProcessSpawner.shell_cmd = [] │ │ │ - │ │ │ -## List of SSL alt names │ │ │ -# See also: Spawner.ssl_alt_names │ │ │ -# c.SimpleLocalProcessSpawner.ssl_alt_names = [] │ │ │ - │ │ │ -## Whether to include `DNS:localhost`, `IP:127.0.0.1` in alt names │ │ │ -# See also: Spawner.ssl_alt_names_include_local │ │ │ -# c.SimpleLocalProcessSpawner.ssl_alt_names_include_local = True │ │ │ - │ │ │ -## │ │ │ -# See also: Spawner.start_timeout │ │ │ -# c.SimpleLocalProcessSpawner.start_timeout = 60 │ │ │ - │ │ │ -## │ │ │ -# See also: LocalProcessSpawner.term_timeout │ │ │ -# c.SimpleLocalProcessSpawner.term_timeout = 5 │ │ │ - │ │ │ -#------------------------------------------------------------------------------ │ │ │ # Authenticator(LoggingConfigurable) configuration │ │ │ #------------------------------------------------------------------------------ │ │ │ ## Base class for implementing an authentication provider for JupyterHub │ │ │ │ │ │ ## Set of users that will be granted admin rights on this JupyterHub. │ │ │ # │ │ │ # Note: │ │ │ @@ -2178,118 +1350,14 @@ │ │ │ # c.Authenticator.username_pattern = '' │ │ │ │ │ │ ## Deprecated, use `Authenticator.allowed_users` │ │ │ # Default: set() │ │ │ # c.Authenticator.whitelist = set() │ │ │ │ │ │ #------------------------------------------------------------------------------ │ │ │ -# NullAuthenticator(Authenticator) configuration │ │ │ -#------------------------------------------------------------------------------ │ │ │ -## Null Authenticator for JupyterHub │ │ │ -# │ │ │ -# For cases where authentication should be disabled, e.g. only allowing access │ │ │ -# via API tokens. │ │ │ -# │ │ │ -# .. versionadded:: 2.0 │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.admin_users │ │ │ -# c.NullAuthenticator.admin_users = set() │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.allow_all │ │ │ -# c.NullAuthenticator.allow_all = False │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.allow_existing_users │ │ │ -# c.NullAuthenticator.allow_existing_users = False │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.allowed_users │ │ │ -# c.NullAuthenticator.allowed_users = set() │ │ │ - │ │ │ -## Is there any allow config? │ │ │ -# See also: Authenticator.any_allow_config │ │ │ -# c.NullAuthenticator.any_allow_config = False │ │ │ - │ │ │ -## The max age (in seconds) of authentication info │ │ │ -# See also: Authenticator.auth_refresh_age │ │ │ -# c.NullAuthenticator.auth_refresh_age = 300 │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.auto_login_oauth2_authorize │ │ │ -# c.NullAuthenticator.auto_login_oauth2_authorize = False │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.blocked_users │ │ │ -# c.NullAuthenticator.blocked_users = set() │ │ │ - │ │ │ -## Delete any users from the database that do not pass validation │ │ │ -# See also: Authenticator.delete_invalid_users │ │ │ -# c.NullAuthenticator.delete_invalid_users = False │ │ │ - │ │ │ -## Enable persisting auth_state (if available). │ │ │ -# See also: Authenticator.enable_auth_state │ │ │ -# c.NullAuthenticator.enable_auth_state = False │ │ │ - │ │ │ -## Let authenticator manage user groups │ │ │ -# See also: Authenticator.manage_groups │ │ │ -# c.NullAuthenticator.manage_groups = False │ │ │ - │ │ │ -## Let authenticator manage roles │ │ │ -# See also: Authenticator.manage_roles │ │ │ -# c.NullAuthenticator.manage_roles = False │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.otp_prompt │ │ │ -# c.NullAuthenticator.otp_prompt = 'OTP:' │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.post_auth_hook │ │ │ -# c.NullAuthenticator.post_auth_hook = None │ │ │ - │ │ │ -## Force refresh of auth prior to spawn. │ │ │ -# See also: Authenticator.refresh_pre_spawn │ │ │ -# c.NullAuthenticator.refresh_pre_spawn = False │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.request_otp │ │ │ -# c.NullAuthenticator.request_otp = False │ │ │ - │ │ │ -## Reset managed roles to result of `load_managed_roles()` on startup. │ │ │ -# See also: Authenticator.reset_managed_roles_on_startup │ │ │ -# c.NullAuthenticator.reset_managed_roles_on_startup = False │ │ │ - │ │ │ -## Dictionary mapping authenticator usernames to JupyterHub users. │ │ │ -# See also: Authenticator.username_map │ │ │ -# c.NullAuthenticator.username_map = {} │ │ │ - │ │ │ -## │ │ │ -# See also: Authenticator.username_pattern │ │ │ -# c.NullAuthenticator.username_pattern = '' │ │ │ - │ │ │ -## Deprecated, use `Authenticator.allowed_users` │ │ │ -# See also: Authenticator.whitelist │ │ │ -# c.NullAuthenticator.whitelist = set() │ │ │ - │ │ │ -#------------------------------------------------------------------------------ │ │ │ -# CryptKeeper(SingletonConfigurable) configuration │ │ │ -#------------------------------------------------------------------------------ │ │ │ -## Encapsulate encryption configuration │ │ │ -# │ │ │ -# Use via the encryption_config singleton below. │ │ │ - │ │ │ -# Default: [] │ │ │ -# c.CryptKeeper.keys = [] │ │ │ - │ │ │ -## The number of threads to allocate for encryption │ │ │ -# Default: 6 │ │ │ -# c.CryptKeeper.n_threads = 6 │ │ │ - │ │ │ -#------------------------------------------------------------------------------ │ │ │ # LocalAuthenticator(Authenticator) configuration │ │ │ #------------------------------------------------------------------------------ │ │ │ ## Base class for Authenticators that work with local Linux/UNIX users │ │ │ # │ │ │ # Checks for local users, and can attempt to create them if they exist. │ │ │ │ │ │ ## The command to use for creating users as a list of strings │ │ │ @@ -2593,14 +1661,486 @@ │ │ │ # c.PAMAuthenticator.username_pattern = '' │ │ │ │ │ │ ## Deprecated, use `Authenticator.allowed_users` │ │ │ # See also: Authenticator.whitelist │ │ │ # c.PAMAuthenticator.whitelist = set() │ │ │ │ │ │ #------------------------------------------------------------------------------ │ │ │ +# Spawner(LoggingConfigurable) configuration │ │ │ +#------------------------------------------------------------------------------ │ │ │ +## Base class for spawning single-user notebook servers. │ │ │ +# │ │ │ +# Subclass this, and override the following methods: │ │ │ +# │ │ │ +# - load_state - get_state - start - stop - poll │ │ │ +# │ │ │ +# As JupyterHub supports multiple users, an instance of the Spawner subclass is │ │ │ +# created for each user. If there are 20 JupyterHub users, there will be 20 │ │ │ +# instances of the subclass. │ │ │ + │ │ │ +## Extra arguments to be passed to the single-user server. │ │ │ +# │ │ │ +# Some spawners allow shell-style expansion here, allowing you to use │ │ │ +# environment variables here. Most, including the default, do not. Consult the │ │ │ +# documentation for your spawner to verify! │ │ │ +# Default: [] │ │ │ +# c.Spawner.args = [] │ │ │ + │ │ │ +## An optional hook function that you can implement to pass `auth_state` to the │ │ │ +# spawner after it has been initialized but before it starts. The `auth_state` │ │ │ +# dictionary may be set by the `.authenticate()` method of the authenticator. │ │ │ +# This hook enables you to pass some or all of that information to your spawner. │ │ │ +# │ │ │ +# Example:: │ │ │ +# │ │ │ +# def userdata_hook(spawner, auth_state): │ │ │ +# spawner.userdata = auth_state["userdata"] │ │ │ +# │ │ │ +# c.Spawner.auth_state_hook = userdata_hook │ │ │ +# Default: None │ │ │ +# c.Spawner.auth_state_hook = None │ │ │ + │ │ │ +## The command used for starting the single-user server. │ │ │ +# │ │ │ +# Provide either a string or a list containing the path to the startup script │ │ │ +# command. Extra arguments, other than this path, should be provided via `args`. │ │ │ +# │ │ │ +# This is usually set if you want to start the single-user server in a different │ │ │ +# python environment (with virtualenv/conda) than JupyterHub itself. │ │ │ +# │ │ │ +# Some spawners allow shell-style expansion here, allowing you to use │ │ │ +# environment variables. Most, including the default, do not. Consult the │ │ │ +# documentation for your spawner to verify! │ │ │ +# Default: ['jupyterhub-singleuser'] │ │ │ +# c.Spawner.cmd = ['jupyterhub-singleuser'] │ │ │ + │ │ │ +## Maximum number of consecutive failures to allow before shutting down │ │ │ +# JupyterHub. │ │ │ +# │ │ │ +# This helps JupyterHub recover from a certain class of problem preventing │ │ │ +# launch in contexts where the Hub is automatically restarted (e.g. systemd, │ │ │ +# docker, kubernetes). │ │ │ +# │ │ │ +# A limit of 0 means no limit and consecutive failures will not be tracked. │ │ │ +# Default: 0 │ │ │ +# c.Spawner.consecutive_failure_limit = 0 │ │ │ + │ │ │ +## Minimum number of cpu-cores a single-user notebook server is guaranteed to │ │ │ +# have available. │ │ │ +# │ │ │ +# If this value is set to 0.5, allows use of 50% of one CPU. If this value is │ │ │ +# set to 2, allows use of up to 2 CPUs. │ │ │ +# │ │ │ +# **This is a configuration setting. Your spawner must implement support for the │ │ │ +# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ +# implement this support. A custom spawner **must** add support for this setting │ │ │ +# for it to be enforced. │ │ │ +# Default: None │ │ │ +# c.Spawner.cpu_guarantee = None │ │ │ + │ │ │ +## Maximum number of cpu-cores a single-user notebook server is allowed to use. │ │ │ +# │ │ │ +# If this value is set to 0.5, allows use of 50% of one CPU. If this value is │ │ │ +# set to 2, allows use of up to 2 CPUs. │ │ │ +# │ │ │ +# The single-user notebook server will never be scheduled by the kernel to use │ │ │ +# more cpu-cores than this. There is no guarantee that it can access this many │ │ │ +# cpu-cores. │ │ │ +# │ │ │ +# **This is a configuration setting. Your spawner must implement support for the │ │ │ +# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ +# implement this support. A custom spawner **must** add support for this setting │ │ │ +# for it to be enforced. │ │ │ +# Default: None │ │ │ +# c.Spawner.cpu_limit = None │ │ │ + │ │ │ +## Enable debug-logging of the single-user server │ │ │ +# Default: False │ │ │ +# c.Spawner.debug = False │ │ │ + │ │ │ +## The URL the single-user server should start in. │ │ │ +# │ │ │ +# `{username}` will be expanded to the user's username │ │ │ +# │ │ │ +# Example uses: │ │ │ +# │ │ │ +# - You can set `notebook_dir` to `/` and `default_url` to `/tree/home/{username}` to allow people to │ │ │ +# navigate the whole filesystem from their notebook server, but still start in their home directory. │ │ │ +# - Start with `/notebooks` instead of `/tree` if `default_url` points to a notebook instead of a directory. │ │ │ +# - You can set this to `/lab` to have JupyterLab start by default, rather than Jupyter Notebook. │ │ │ +# Default: '' │ │ │ +# c.Spawner.default_url = '' │ │ │ + │ │ │ +## Disable per-user configuration of single-user servers. │ │ │ +# │ │ │ +# When starting the user's single-user server, any config file found in the │ │ │ +# user's $HOME directory will be ignored. │ │ │ +# │ │ │ +# Note: a user could circumvent this if the user modifies their Python │ │ │ +# environment, such as when they have their own conda environments / virtualenvs │ │ │ +# / containers. │ │ │ +# Default: False │ │ │ +# c.Spawner.disable_user_config = False │ │ │ + │ │ │ +## List of environment variables for the single-user server to inherit from the │ │ │ +# JupyterHub process. │ │ │ +# │ │ │ +# This list is used to ensure that sensitive information in the JupyterHub │ │ │ +# process's environment (such as `CONFIGPROXY_AUTH_TOKEN`) is not passed to the │ │ │ +# single-user server's process. │ │ │ +# Default: ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ +# c.Spawner.env_keep = ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ + │ │ │ +## Extra environment variables to set for the single-user server's process. │ │ │ +# │ │ │ +# Environment variables that end up in the single-user server's process come from 3 sources: │ │ │ +# - This `environment` configurable │ │ │ +# - The JupyterHub process' environment variables that are listed in `env_keep` │ │ │ +# - Variables to establish contact between the single-user notebook and the hub (such as JUPYTERHUB_API_TOKEN) │ │ │ +# │ │ │ +# The `environment` configurable should be set by JupyterHub administrators to │ │ │ +# add installation specific environment variables. It is a dict where the key is │ │ │ +# the name of the environment variable, and the value can be a string or a │ │ │ +# callable. If it is a callable, it will be called with one parameter (the │ │ │ +# spawner instance), and should return a string fairly quickly (no blocking │ │ │ +# operations please!). │ │ │ +# │ │ │ +# Note that the spawner class' interface is not guaranteed to be exactly same │ │ │ +# across upgrades, so if you are using the callable take care to verify it │ │ │ +# continues to work after upgrades! │ │ │ +# │ │ │ +# .. versionchanged:: 1.2 │ │ │ +# environment from this configuration has highest priority, │ │ │ +# allowing override of 'default' env variables, │ │ │ +# such as JUPYTERHUB_API_URL. │ │ │ +# Default: {} │ │ │ +# c.Spawner.environment = {} │ │ │ + │ │ │ +## Override specific traitlets based on group membership of the user. │ │ │ +# │ │ │ +# This can be a dict, or a callable that returns a dict. The keys of the dict │ │ │ +# are *only* used for lexicographical sorting, to guarantee consistent ordering │ │ │ +# of the overrides. If it is a callable, it may be async, and will be passed one │ │ │ +# parameter - the spawner instance. It should return a dictionary. │ │ │ +# │ │ │ +# The values of the dict are dicts with the following keys: │ │ │ +# │ │ │ +# - `"groups"` - If the user belongs to *any* of these groups, these overrides are │ │ │ +# applied to their server before spawning. │ │ │ +# - `"spawner_override"` - a dictionary with overrides to apply to the Spawner │ │ │ +# settings. Each value can be either the final value to change or a callable that │ │ │ +# take the `Spawner` instance as parameter and returns the final value. │ │ │ +# If the traitlet being overriden is a *dictionary*, the dictionary │ │ │ +# will be *recursively updated*, rather than overriden. If you want to │ │ │ +# remove a key, set its value to `None`. │ │ │ +# │ │ │ +# Example: │ │ │ +# │ │ │ +# The following example config will: │ │ │ +# │ │ │ +# 1. Add the environment variable "AM_I_GROUP_ALPHA" to everyone in the "group-alpha" group │ │ │ +# 2. Add the environment variable "AM_I_GROUP_BETA" to everyone in the "group-beta" group. │ │ │ +# If a user is part of both "group-beta" and "group-alpha", they will get *both* these env │ │ │ +# vars, due to the dictionary merging functionality. │ │ │ +# 3. Add a higher memory limit for everyone in the "group-beta" group. │ │ │ +# │ │ │ +# :: │ │ │ +# │ │ │ +# c.Spawner.group_overrides = { │ │ │ +# "01-group-alpha-env-add": { │ │ │ +# "groups": ["group-alpha"], │ │ │ +# "spawner_override": {"environment": {"AM_I_GROUP_ALPHA": "yes"}}, │ │ │ +# }, │ │ │ +# "02-group-beta-env-add": { │ │ │ +# "groups": ["group-beta"], │ │ │ +# "spawner_override": {"environment": {"AM_I_GROUP_BETA": "yes"}}, │ │ │ +# }, │ │ │ +# "03-group-beta-mem-limit": { │ │ │ +# "groups": ["group-beta"], │ │ │ +# "spawner_override": {"mem_limit": "2G"} │ │ │ +# } │ │ │ +# } │ │ │ +# Default: traitlets.Undefined │ │ │ +# c.Spawner.group_overrides = traitlets.Undefined │ │ │ + │ │ │ +## Timeout (in seconds) before giving up on a spawned HTTP server │ │ │ +# │ │ │ +# Once a server has successfully been spawned, this is the amount of time we │ │ │ +# wait before assuming that the server is unable to accept connections. │ │ │ +# Default: 30 │ │ │ +# c.Spawner.http_timeout = 30 │ │ │ + │ │ │ +## The URL the single-user server should connect to the Hub. │ │ │ +# │ │ │ +# If the Hub URL set in your JupyterHub config is not reachable from spawned │ │ │ +# notebooks, you can set differnt URL by this config. │ │ │ +# │ │ │ +# Is None if you don't need to change the URL. │ │ │ +# Default: None │ │ │ +# c.Spawner.hub_connect_url = None │ │ │ + │ │ │ +## The IP address (or hostname) the single-user server should listen on. │ │ │ +# │ │ │ +# Usually either '127.0.0.1' (default) or '0.0.0.0'. │ │ │ +# │ │ │ +# The JupyterHub proxy implementation should be able to send packets to this │ │ │ +# interface. │ │ │ +# │ │ │ +# Subclasses which launch remotely or in containers should override the default │ │ │ +# to '0.0.0.0'. │ │ │ +# │ │ │ +# .. versionchanged:: 2.0 │ │ │ +# Default changed to '127.0.0.1', from ''. │ │ │ +# In most cases, this does not result in a change in behavior, │ │ │ +# as '' was interpreted as 'unspecified', │ │ │ +# which used the subprocesses' own default, itself usually '127.0.0.1'. │ │ │ +# Default: '127.0.0.1' │ │ │ +# c.Spawner.ip = '127.0.0.1' │ │ │ + │ │ │ +## Minimum number of bytes a single-user notebook server is guaranteed to have │ │ │ +# available. │ │ │ +# │ │ │ +# Allows the following suffixes: │ │ │ +# - K -> Kilobytes │ │ │ +# - M -> Megabytes │ │ │ +# - G -> Gigabytes │ │ │ +# - T -> Terabytes │ │ │ +# │ │ │ +# **This is a configuration setting. Your spawner must implement support for the │ │ │ +# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ +# implement this support. A custom spawner **must** add support for this setting │ │ │ +# for it to be enforced. │ │ │ +# Default: None │ │ │ +# c.Spawner.mem_guarantee = None │ │ │ + │ │ │ +## Maximum number of bytes a single-user notebook server is allowed to use. │ │ │ +# │ │ │ +# Allows the following suffixes: │ │ │ +# - K -> Kilobytes │ │ │ +# - M -> Megabytes │ │ │ +# - G -> Gigabytes │ │ │ +# - T -> Terabytes │ │ │ +# │ │ │ +# If the single user server tries to allocate more memory than this, it will │ │ │ +# fail. There is no guarantee that the single-user notebook server will be able │ │ │ +# to allocate this much memory - only that it can not allocate more than this. │ │ │ +# │ │ │ +# **This is a configuration setting. Your spawner must implement support for the │ │ │ +# limit to work.** The default spawner, `LocalProcessSpawner`, does **not** │ │ │ +# implement this support. A custom spawner **must** add support for this setting │ │ │ +# for it to be enforced. │ │ │ +# Default: None │ │ │ +# c.Spawner.mem_limit = None │ │ │ + │ │ │ +## Path to the notebook directory for the single-user server. │ │ │ +# │ │ │ +# The user sees a file listing of this directory when the notebook interface is │ │ │ +# started. The current interface does not easily allow browsing beyond the │ │ │ +# subdirectories in this directory's tree. │ │ │ +# │ │ │ +# `~` will be expanded to the home directory of the user, and {username} will be │ │ │ +# replaced with the name of the user. │ │ │ +# │ │ │ +# Note that this does *not* prevent users from accessing files outside of this │ │ │ +# path! They can do so with many other means. │ │ │ +# Default: '' │ │ │ +# c.Spawner.notebook_dir = '' │ │ │ + │ │ │ +## Allowed scopes for oauth tokens issued by this server's oauth client. │ │ │ +# │ │ │ +# This sets the maximum and default scopes │ │ │ +# assigned to oauth tokens issued by a single-user server's │ │ │ +# oauth client (i.e. tokens stored in browsers after authenticating with the server), │ │ │ +# defining what actions the server can take on behalf of logged-in users. │ │ │ +# │ │ │ +# Default is an empty list, meaning minimal permissions to identify users, │ │ │ +# no actions can be taken on their behalf. │ │ │ +# │ │ │ +# If callable, will be called with the Spawner as a single argument. │ │ │ +# Callables may be async. │ │ │ +# Default: traitlets.Undefined │ │ │ +# c.Spawner.oauth_client_allowed_scopes = traitlets.Undefined │ │ │ + │ │ │ +## Allowed roles for oauth tokens. │ │ │ +# │ │ │ +# Deprecated in 3.0: use oauth_client_allowed_scopes │ │ │ +# │ │ │ +# This sets the maximum and default roles │ │ │ +# assigned to oauth tokens issued by a single-user server's │ │ │ +# oauth client (i.e. tokens stored in browsers after authenticating with the server), │ │ │ +# defining what actions the server can take on behalf of logged-in users. │ │ │ +# │ │ │ +# Default is an empty list, meaning minimal permissions to identify users, │ │ │ +# no actions can be taken on their behalf. │ │ │ +# Default: traitlets.Undefined │ │ │ +# c.Spawner.oauth_roles = traitlets.Undefined │ │ │ + │ │ │ +## An HTML form for options a user can specify on launching their server. │ │ │ +# │ │ │ +# The surrounding `` element and the submit button are already provided. │ │ │ +# │ │ │ +# For example: │ │ │ +# │ │ │ +# .. code:: html │ │ │ +# │ │ │ +# Set your key: │ │ │ +# │ │ │ +#
│ │ │ +# Choose a letter: │ │ │ +# │ │ │ +# │ │ │ +# The data from this form submission will be passed on to your spawner in │ │ │ +# `self.user_options` │ │ │ +# │ │ │ +# Instead of a form snippet string, this could also be a callable that takes as │ │ │ +# one parameter the current spawner instance and returns a string. The callable │ │ │ +# will be called asynchronously if it returns a future, rather than a str. Note │ │ │ +# that the interface of the spawner class is not deemed stable across versions, │ │ │ +# so using this functionality might cause your JupyterHub upgrades to break. │ │ │ +# Default: traitlets.Undefined │ │ │ +# c.Spawner.options_form = traitlets.Undefined │ │ │ + │ │ │ +## Interpret HTTP form data │ │ │ +# │ │ │ +# Form data will always arrive as a dict of lists of strings. Override this │ │ │ +# function to understand single-values, numbers, etc. │ │ │ +# │ │ │ +# This should coerce form data into the structure expected by self.user_options, │ │ │ +# which must be a dict, and should be JSON-serializeable, though it can contain │ │ │ +# bytes in addition to standard JSON data types. │ │ │ +# │ │ │ +# This method should not have any side effects. Any handling of `user_options` │ │ │ +# should be done in `.start()` to ensure consistent behavior across servers │ │ │ +# spawned via the API and form submission page. │ │ │ +# │ │ │ +# Instances will receive this data on self.user_options, after passing through │ │ │ +# this function, prior to `Spawner.start`. │ │ │ +# │ │ │ +# .. versionchanged:: 1.0 │ │ │ +# user_options are persisted in the JupyterHub database to be reused │ │ │ +# on subsequent spawns if no options are given. │ │ │ +# user_options is serialized to JSON as part of this persistence │ │ │ +# (with additional support for bytes in case of uploaded file data), │ │ │ +# and any non-bytes non-jsonable values will be replaced with None │ │ │ +# if the user_options are re-used. │ │ │ +# Default: traitlets.Undefined │ │ │ +# c.Spawner.options_from_form = traitlets.Undefined │ │ │ + │ │ │ +## Interval (in seconds) on which to poll the spawner for single-user server's │ │ │ +# status. │ │ │ +# │ │ │ +# At every poll interval, each spawner's `.poll` method is called, which checks │ │ │ +# if the single-user server is still running. If it isn't running, then │ │ │ +# JupyterHub modifies its own state accordingly and removes appropriate routes │ │ │ +# from the configurable proxy. │ │ │ +# Default: 30 │ │ │ +# c.Spawner.poll_interval = 30 │ │ │ + │ │ │ +## Jitter fraction for poll_interval. │ │ │ +# │ │ │ +# Avoids alignment of poll calls for many Spawners, e.g. when restarting │ │ │ +# JupyterHub, which restarts all polls for running Spawners. │ │ │ +# │ │ │ +# `poll_jitter=0` means no jitter, 0.1 means 10%, etc. │ │ │ +# Default: 0.1 │ │ │ +# c.Spawner.poll_jitter = 0.1 │ │ │ + │ │ │ +## The port for single-user servers to listen on. │ │ │ +# │ │ │ +# Defaults to `0`, which uses a randomly allocated port number each time. │ │ │ +# │ │ │ +# If set to a non-zero value, all Spawners will use the same port, which only │ │ │ +# makes sense if each server is on a different address, e.g. in containers. │ │ │ +# │ │ │ +# New in version 0.7. │ │ │ +# Default: 0 │ │ │ +# c.Spawner.port = 0 │ │ │ + │ │ │ +## An optional hook function that you can implement to do work after the spawner │ │ │ +# stops. │ │ │ +# │ │ │ +# This can be set independent of any concrete spawner implementation. │ │ │ +# Default: None │ │ │ +# c.Spawner.post_stop_hook = None │ │ │ + │ │ │ +## An optional hook function that you can implement to do some bootstrapping work │ │ │ +# before the spawner starts. For example, create a directory for your user or │ │ │ +# load initial content. │ │ │ +# │ │ │ +# This can be set independent of any concrete spawner implementation. │ │ │ +# │ │ │ +# This maybe a coroutine. │ │ │ +# │ │ │ +# Example:: │ │ │ +# │ │ │ +# def my_hook(spawner): │ │ │ +# username = spawner.user.name │ │ │ +# spawner.environment["GREETING"] = f"Hello {username}" │ │ │ +# │ │ │ +# c.Spawner.pre_spawn_hook = my_hook │ │ │ +# Default: None │ │ │ +# c.Spawner.pre_spawn_hook = None │ │ │ + │ │ │ +## An optional hook function that you can implement to modify the ready event, │ │ │ +# which will be shown to the user on the spawn progress page when their server │ │ │ +# is ready. │ │ │ +# │ │ │ +# This can be set independent of any concrete spawner implementation. │ │ │ +# │ │ │ +# This maybe a coroutine. │ │ │ +# │ │ │ +# Example:: │ │ │ +# │ │ │ +# async def my_ready_hook(spawner, ready_event): │ │ │ +# ready_event["html_message"] = f"Server {spawner.name} is ready for {spawner.user.name}" │ │ │ +# return ready_event │ │ │ +# │ │ │ +# c.Spawner.progress_ready_hook = my_ready_hook │ │ │ +# Default: None │ │ │ +# c.Spawner.progress_ready_hook = None │ │ │ + │ │ │ +## The list of scopes to request for $JUPYTERHUB_API_TOKEN │ │ │ +# │ │ │ +# If not specified, the scopes in the `server` role will be used │ │ │ +# (unchanged from pre-4.0). │ │ │ +# │ │ │ +# If callable, will be called with the Spawner instance as its sole argument │ │ │ +# (JupyterHub user available as spawner.user). │ │ │ +# │ │ │ +# JUPYTERHUB_API_TOKEN will be assigned the _subset_ of these scopes │ │ │ +# that are held by the user (as in oauth_client_allowed_scopes). │ │ │ +# │ │ │ +# .. versionadded:: 4.0 │ │ │ +# Default: traitlets.Undefined │ │ │ +# c.Spawner.server_token_scopes = traitlets.Undefined │ │ │ + │ │ │ +## List of SSL alt names │ │ │ +# │ │ │ +# May be set in config if all spawners should have the same value(s), │ │ │ +# or set at runtime by Spawner that know their names. │ │ │ +# Default: [] │ │ │ +# c.Spawner.ssl_alt_names = [] │ │ │ + │ │ │ +## Whether to include `DNS:localhost`, `IP:127.0.0.1` in alt names │ │ │ +# Default: True │ │ │ +# c.Spawner.ssl_alt_names_include_local = True │ │ │ + │ │ │ +## Timeout (in seconds) before giving up on starting of single-user server. │ │ │ +# │ │ │ +# This is the timeout for start to return, not the timeout for the server to │ │ │ +# respond. Callers of spawner.start will assume that startup has failed if it │ │ │ +# takes longer than this. start should return when the server process is started │ │ │ +# and its location is known. │ │ │ +# Default: 60 │ │ │ +# c.Spawner.start_timeout = 60 │ │ │ + │ │ │ +#------------------------------------------------------------------------------ │ │ │ # Proxy(LoggingConfigurable) configuration │ │ │ #------------------------------------------------------------------------------ │ │ │ ## Base class for configurable proxies that JupyterHub can use. │ │ │ # │ │ │ # A proxy implementation should subclass this and must define the following │ │ │ # methods: │ │ │ # │ │ │ @@ -2699,14 +2239,220 @@ │ │ │ # c.ConfigurableHTTPProxy.pid_file = 'jupyterhub-proxy.pid' │ │ │ │ │ │ ## Should the Hub start the proxy │ │ │ # See also: Proxy.should_start │ │ │ # c.ConfigurableHTTPProxy.should_start = True │ │ │ │ │ │ #------------------------------------------------------------------------------ │ │ │ +# CryptKeeper(SingletonConfigurable) configuration │ │ │ +#------------------------------------------------------------------------------ │ │ │ +## Encapsulate encryption configuration │ │ │ +# │ │ │ +# Use via the encryption_config singleton below. │ │ │ + │ │ │ +# Default: [] │ │ │ +# c.CryptKeeper.keys = [] │ │ │ + │ │ │ +## The number of threads to allocate for encryption │ │ │ +# Default: 16 │ │ │ +# c.CryptKeeper.n_threads = 16 │ │ │ + │ │ │ +#------------------------------------------------------------------------------ │ │ │ +# LocalProcessSpawner(Spawner) configuration │ │ │ +#------------------------------------------------------------------------------ │ │ │ +## A Spawner that uses `subprocess.Popen` to start single-user servers as local │ │ │ +# processes. │ │ │ +# │ │ │ +# Requires local UNIX users matching the authenticated users to exist. Does not │ │ │ +# work on Windows. │ │ │ +# │ │ │ +# This is the default spawner for JupyterHub. │ │ │ +# │ │ │ +# Note: This spawner does not implement CPU / memory guarantees and limits. │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.args │ │ │ +# c.LocalProcessSpawner.args = [] │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.auth_state_hook │ │ │ +# c.LocalProcessSpawner.auth_state_hook = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.cmd │ │ │ +# c.LocalProcessSpawner.cmd = ['jupyterhub-singleuser'] │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.consecutive_failure_limit │ │ │ +# c.LocalProcessSpawner.consecutive_failure_limit = 0 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.cpu_guarantee │ │ │ +# c.LocalProcessSpawner.cpu_guarantee = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.cpu_limit │ │ │ +# c.LocalProcessSpawner.cpu_limit = None │ │ │ + │ │ │ +## Enable debug-logging of the single-user server │ │ │ +# See also: Spawner.debug │ │ │ +# c.LocalProcessSpawner.debug = False │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.default_url │ │ │ +# c.LocalProcessSpawner.default_url = '' │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.disable_user_config │ │ │ +# c.LocalProcessSpawner.disable_user_config = False │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.env_keep │ │ │ +# c.LocalProcessSpawner.env_keep = ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.environment │ │ │ +# c.LocalProcessSpawner.environment = {} │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.group_overrides │ │ │ +# c.LocalProcessSpawner.group_overrides = traitlets.Undefined │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.http_timeout │ │ │ +# c.LocalProcessSpawner.http_timeout = 30 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.hub_connect_url │ │ │ +# c.LocalProcessSpawner.hub_connect_url = None │ │ │ + │ │ │ +## Seconds to wait for single-user server process to halt after SIGINT. │ │ │ +# │ │ │ +# If the process has not exited cleanly after this many seconds, a SIGTERM is │ │ │ +# sent. │ │ │ +# Default: 10 │ │ │ +# c.LocalProcessSpawner.interrupt_timeout = 10 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.ip │ │ │ +# c.LocalProcessSpawner.ip = '127.0.0.1' │ │ │ + │ │ │ +## Seconds to wait for process to halt after SIGKILL before giving up. │ │ │ +# │ │ │ +# If the process does not exit cleanly after this many seconds of SIGKILL, it │ │ │ +# becomes a zombie process. The hub process will log a warning and then give up. │ │ │ +# Default: 5 │ │ │ +# c.LocalProcessSpawner.kill_timeout = 5 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.mem_guarantee │ │ │ +# c.LocalProcessSpawner.mem_guarantee = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.mem_limit │ │ │ +# c.LocalProcessSpawner.mem_limit = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.notebook_dir │ │ │ +# c.LocalProcessSpawner.notebook_dir = '' │ │ │ + │ │ │ +## Allowed scopes for oauth tokens issued by this server's oauth client. │ │ │ +# See also: Spawner.oauth_client_allowed_scopes │ │ │ +# c.LocalProcessSpawner.oauth_client_allowed_scopes = traitlets.Undefined │ │ │ + │ │ │ +## Allowed roles for oauth tokens. │ │ │ +# See also: Spawner.oauth_roles │ │ │ +# c.LocalProcessSpawner.oauth_roles = traitlets.Undefined │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.options_form │ │ │ +# c.LocalProcessSpawner.options_form = traitlets.Undefined │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.options_from_form │ │ │ +# c.LocalProcessSpawner.options_from_form = traitlets.Undefined │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.poll_interval │ │ │ +# c.LocalProcessSpawner.poll_interval = 30 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.poll_jitter │ │ │ +# c.LocalProcessSpawner.poll_jitter = 0.1 │ │ │ + │ │ │ +## Extra keyword arguments to pass to Popen │ │ │ +# │ │ │ +# when spawning single-user servers. │ │ │ +# │ │ │ +# For example:: │ │ │ +# │ │ │ +# popen_kwargs = dict(shell=True) │ │ │ +# Default: {} │ │ │ +# c.LocalProcessSpawner.popen_kwargs = {} │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.port │ │ │ +# c.LocalProcessSpawner.port = 0 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.post_stop_hook │ │ │ +# c.LocalProcessSpawner.post_stop_hook = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.pre_spawn_hook │ │ │ +# c.LocalProcessSpawner.pre_spawn_hook = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.progress_ready_hook │ │ │ +# c.LocalProcessSpawner.progress_ready_hook = None │ │ │ + │ │ │ +## The list of scopes to request for $JUPYTERHUB_API_TOKEN │ │ │ +# See also: Spawner.server_token_scopes │ │ │ +# c.LocalProcessSpawner.server_token_scopes = traitlets.Undefined │ │ │ + │ │ │ +## Specify a shell command to launch. │ │ │ +# │ │ │ +# The single-user command will be appended to this list, │ │ │ +# so it sould end with `-c` (for bash) or equivalent. │ │ │ +# │ │ │ +# For example:: │ │ │ +# │ │ │ +# c.LocalProcessSpawner.shell_cmd = ['bash', '-l', '-c'] │ │ │ +# │ │ │ +# to launch with a bash login shell, which would set up the user's own │ │ │ +# complete environment. │ │ │ +# │ │ │ +# .. warning:: │ │ │ +# │ │ │ +# Using shell_cmd gives users control over PATH, etc., │ │ │ +# which could change what the jupyterhub-singleuser launch command does. │ │ │ +# Only use this for trusted users. │ │ │ +# Default: [] │ │ │ +# c.LocalProcessSpawner.shell_cmd = [] │ │ │ + │ │ │ +## List of SSL alt names │ │ │ +# See also: Spawner.ssl_alt_names │ │ │ +# c.LocalProcessSpawner.ssl_alt_names = [] │ │ │ + │ │ │ +## Whether to include `DNS:localhost`, `IP:127.0.0.1` in alt names │ │ │ +# See also: Spawner.ssl_alt_names_include_local │ │ │ +# c.LocalProcessSpawner.ssl_alt_names_include_local = True │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.start_timeout │ │ │ +# c.LocalProcessSpawner.start_timeout = 60 │ │ │ + │ │ │ +## Seconds to wait for single-user server process to halt after SIGTERM. │ │ │ +# │ │ │ +# If the process does not exit cleanly after this many seconds of SIGTERM, a │ │ │ +# SIGKILL is sent. │ │ │ +# Default: 5 │ │ │ +# c.LocalProcessSpawner.term_timeout = 5 │ │ │ + │ │ │ +#------------------------------------------------------------------------------ │ │ │ # DummyAuthenticator(Authenticator) configuration │ │ │ #------------------------------------------------------------------------------ │ │ │ ## Dummy Authenticator for testing │ │ │ # │ │ │ # By default, any username + password is allowed If a non-empty password is set, │ │ │ # any username will be allowed if it logs in with that password. │ │ │ # │ │ │ @@ -2801,7 +2547,261 @@ │ │ │ ## │ │ │ # See also: Authenticator.username_pattern │ │ │ # c.DummyAuthenticator.username_pattern = '' │ │ │ │ │ │ ## Deprecated, use `Authenticator.allowed_users` │ │ │ # See also: Authenticator.whitelist │ │ │ # c.DummyAuthenticator.whitelist = set() │ │ │ + │ │ │ +#------------------------------------------------------------------------------ │ │ │ +# NullAuthenticator(Authenticator) configuration │ │ │ +#------------------------------------------------------------------------------ │ │ │ +## Null Authenticator for JupyterHub │ │ │ +# │ │ │ +# For cases where authentication should be disabled, e.g. only allowing access │ │ │ +# via API tokens. │ │ │ +# │ │ │ +# .. versionadded:: 2.0 │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.admin_users │ │ │ +# c.NullAuthenticator.admin_users = set() │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.allow_all │ │ │ +# c.NullAuthenticator.allow_all = False │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.allow_existing_users │ │ │ +# c.NullAuthenticator.allow_existing_users = False │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.allowed_users │ │ │ +# c.NullAuthenticator.allowed_users = set() │ │ │ + │ │ │ +## Is there any allow config? │ │ │ +# See also: Authenticator.any_allow_config │ │ │ +# c.NullAuthenticator.any_allow_config = False │ │ │ + │ │ │ +## The max age (in seconds) of authentication info │ │ │ +# See also: Authenticator.auth_refresh_age │ │ │ +# c.NullAuthenticator.auth_refresh_age = 300 │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.auto_login_oauth2_authorize │ │ │ +# c.NullAuthenticator.auto_login_oauth2_authorize = False │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.blocked_users │ │ │ +# c.NullAuthenticator.blocked_users = set() │ │ │ + │ │ │ +## Delete any users from the database that do not pass validation │ │ │ +# See also: Authenticator.delete_invalid_users │ │ │ +# c.NullAuthenticator.delete_invalid_users = False │ │ │ + │ │ │ +## Enable persisting auth_state (if available). │ │ │ +# See also: Authenticator.enable_auth_state │ │ │ +# c.NullAuthenticator.enable_auth_state = False │ │ │ + │ │ │ +## Let authenticator manage user groups │ │ │ +# See also: Authenticator.manage_groups │ │ │ +# c.NullAuthenticator.manage_groups = False │ │ │ + │ │ │ +## Let authenticator manage roles │ │ │ +# See also: Authenticator.manage_roles │ │ │ +# c.NullAuthenticator.manage_roles = False │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.otp_prompt │ │ │ +# c.NullAuthenticator.otp_prompt = 'OTP:' │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.post_auth_hook │ │ │ +# c.NullAuthenticator.post_auth_hook = None │ │ │ + │ │ │ +## Force refresh of auth prior to spawn. │ │ │ +# See also: Authenticator.refresh_pre_spawn │ │ │ +# c.NullAuthenticator.refresh_pre_spawn = False │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.request_otp │ │ │ +# c.NullAuthenticator.request_otp = False │ │ │ + │ │ │ +## Reset managed roles to result of `load_managed_roles()` on startup. │ │ │ +# See also: Authenticator.reset_managed_roles_on_startup │ │ │ +# c.NullAuthenticator.reset_managed_roles_on_startup = False │ │ │ + │ │ │ +## Dictionary mapping authenticator usernames to JupyterHub users. │ │ │ +# See also: Authenticator.username_map │ │ │ +# c.NullAuthenticator.username_map = {} │ │ │ + │ │ │ +## │ │ │ +# See also: Authenticator.username_pattern │ │ │ +# c.NullAuthenticator.username_pattern = '' │ │ │ + │ │ │ +## Deprecated, use `Authenticator.allowed_users` │ │ │ +# See also: Authenticator.whitelist │ │ │ +# c.NullAuthenticator.whitelist = set() │ │ │ + │ │ │ +#------------------------------------------------------------------------------ │ │ │ +# SimpleLocalProcessSpawner(LocalProcessSpawner) configuration │ │ │ +#------------------------------------------------------------------------------ │ │ │ +## A version of LocalProcessSpawner that doesn't require users to exist on the │ │ │ +# system beforehand. │ │ │ +# │ │ │ +# Only use this for testing. │ │ │ +# │ │ │ +# Note: DO NOT USE THIS FOR PRODUCTION USE CASES! It is very insecure, and │ │ │ +# provides absolutely no isolation between different users! │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.args │ │ │ +# c.SimpleLocalProcessSpawner.args = [] │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.auth_state_hook │ │ │ +# c.SimpleLocalProcessSpawner.auth_state_hook = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.cmd │ │ │ +# c.SimpleLocalProcessSpawner.cmd = ['jupyterhub-singleuser'] │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.consecutive_failure_limit │ │ │ +# c.SimpleLocalProcessSpawner.consecutive_failure_limit = 0 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.cpu_guarantee │ │ │ +# c.SimpleLocalProcessSpawner.cpu_guarantee = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.cpu_limit │ │ │ +# c.SimpleLocalProcessSpawner.cpu_limit = None │ │ │ + │ │ │ +## Enable debug-logging of the single-user server │ │ │ +# See also: Spawner.debug │ │ │ +# c.SimpleLocalProcessSpawner.debug = False │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.default_url │ │ │ +# c.SimpleLocalProcessSpawner.default_url = '' │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.disable_user_config │ │ │ +# c.SimpleLocalProcessSpawner.disable_user_config = False │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.env_keep │ │ │ +# c.SimpleLocalProcessSpawner.env_keep = ['JUPYTERHUB_SINGLEUSER_APP'] │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.environment │ │ │ +# c.SimpleLocalProcessSpawner.environment = {} │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.group_overrides │ │ │ +# c.SimpleLocalProcessSpawner.group_overrides = traitlets.Undefined │ │ │ + │ │ │ +## Template to expand to set the user home. {username} is expanded to the │ │ │ +# jupyterhub username. │ │ │ +# Default: '/tmp/{username}' │ │ │ +# c.SimpleLocalProcessSpawner.home_dir_template = '/tmp/{username}' │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.http_timeout │ │ │ +# c.SimpleLocalProcessSpawner.http_timeout = 30 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.hub_connect_url │ │ │ +# c.SimpleLocalProcessSpawner.hub_connect_url = None │ │ │ + │ │ │ +## │ │ │ +# See also: LocalProcessSpawner.interrupt_timeout │ │ │ +# c.SimpleLocalProcessSpawner.interrupt_timeout = 10 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.ip │ │ │ +# c.SimpleLocalProcessSpawner.ip = '127.0.0.1' │ │ │ + │ │ │ +## │ │ │ +# See also: LocalProcessSpawner.kill_timeout │ │ │ +# c.SimpleLocalProcessSpawner.kill_timeout = 5 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.mem_guarantee │ │ │ +# c.SimpleLocalProcessSpawner.mem_guarantee = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.mem_limit │ │ │ +# c.SimpleLocalProcessSpawner.mem_limit = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.notebook_dir │ │ │ +# c.SimpleLocalProcessSpawner.notebook_dir = '' │ │ │ + │ │ │ +## Allowed scopes for oauth tokens issued by this server's oauth client. │ │ │ +# See also: Spawner.oauth_client_allowed_scopes │ │ │ +# c.SimpleLocalProcessSpawner.oauth_client_allowed_scopes = traitlets.Undefined │ │ │ + │ │ │ +## Allowed roles for oauth tokens. │ │ │ +# See also: Spawner.oauth_roles │ │ │ +# c.SimpleLocalProcessSpawner.oauth_roles = traitlets.Undefined │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.options_form │ │ │ +# c.SimpleLocalProcessSpawner.options_form = traitlets.Undefined │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.options_from_form │ │ │ +# c.SimpleLocalProcessSpawner.options_from_form = traitlets.Undefined │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.poll_interval │ │ │ +# c.SimpleLocalProcessSpawner.poll_interval = 30 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.poll_jitter │ │ │ +# c.SimpleLocalProcessSpawner.poll_jitter = 0.1 │ │ │ + │ │ │ +## Extra keyword arguments to pass to Popen │ │ │ +# See also: LocalProcessSpawner.popen_kwargs │ │ │ +# c.SimpleLocalProcessSpawner.popen_kwargs = {} │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.port │ │ │ +# c.SimpleLocalProcessSpawner.port = 0 │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.post_stop_hook │ │ │ +# c.SimpleLocalProcessSpawner.post_stop_hook = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.pre_spawn_hook │ │ │ +# c.SimpleLocalProcessSpawner.pre_spawn_hook = None │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.progress_ready_hook │ │ │ +# c.SimpleLocalProcessSpawner.progress_ready_hook = None │ │ │ + │ │ │ +## The list of scopes to request for $JUPYTERHUB_API_TOKEN │ │ │ +# See also: Spawner.server_token_scopes │ │ │ +# c.SimpleLocalProcessSpawner.server_token_scopes = traitlets.Undefined │ │ │ + │ │ │ +## Specify a shell command to launch. │ │ │ +# See also: LocalProcessSpawner.shell_cmd │ │ │ +# c.SimpleLocalProcessSpawner.shell_cmd = [] │ │ │ + │ │ │ +## List of SSL alt names │ │ │ +# See also: Spawner.ssl_alt_names │ │ │ +# c.SimpleLocalProcessSpawner.ssl_alt_names = [] │ │ │ + │ │ │ +## Whether to include `DNS:localhost`, `IP:127.0.0.1` in alt names │ │ │ +# See also: Spawner.ssl_alt_names_include_local │ │ │ +# c.SimpleLocalProcessSpawner.ssl_alt_names_include_local = True │ │ │ + │ │ │ +## │ │ │ +# See also: Spawner.start_timeout │ │ │ +# c.SimpleLocalProcessSpawner.start_timeout = 60 │ │ │ + │ │ │ +## │ │ │ +# See also: LocalProcessSpawner.term_timeout │ │ │ +# c.SimpleLocalProcessSpawner.term_timeout = 5