carta-controller 3.0.0-dev.20220301 → 3.0.0-rc.0

package/README.md

@@ -1,7 +1,7 @@
 # CARTA Controller
 
-[![carta version](https://img.shields.io/badge/CARTA%20Version-3.0.0--beta.2-brightgreen)](https://github.com/CARTAvis/carta-backend/releases/tag/v3.0.0-beta.2)
-[![npm version](https://img.shields.io/npm/v/carta-controller/beta.svg?style=flat)](https://npmjs.org/package/carta-controller "View this project on npm")
+[![carta version](https://img.shields.io/badge/CARTA%20Version-3.0.0--rc.0-brightgreen)](https://github.com/CARTAvis/carta-backend/releases/tag/v3.0.0-rc.0)
+[![npm version](https://img.shields.io/npm/v/carta-controller/rc.svg?style=flat)](https://npmjs.org/package/carta-controller "View this project on npm")
 ![last commit](https://img.shields.io/github/last-commit/CARTAvis/carta-controller)
 ![commit activity](https://img.shields.io/github/commit-activity/m/CARTAvis/carta-controller)
 

package/config/config_schema.json

@@ -427,20 +427,19 @@
         "serverAddress": {
             "description": "Public-facing server address. If this is specified, all requests will be redirected to this address, otherwise any address used will be preserved",
             "type": "string",
-            "format": "uri",
-            "pattern": "^https?://"
+            "format": "uri"
         },
         "dashboardAddress": {
-            "description": "Optional parameter for explicitly configuring a custom dashboard address",
+            "description": "Optional parameter for explicitly configuring the dashboard address. This can be absolute or relative. This is required if running the controller on a subdirectory",
             "type": "string",
-            "format": "uri",
-            "pattern": "^https?://"
+            "format": "uri-reference",
+            "examples": ["https://my-server.com/carta/dashboard", "/carta/dashboard", "/carta-versions/dev/dashboard"]
         },
         "apiAddress": {
-            "description": "Optional parameter for explicitly configuring a custom API base address",
+            "description": "Optional parameter for explicitly configuring a custom API base address. This can be absolute or relative. This is required if running the controller on a subdirectory",
             "type": "string",
-            "format": "uri",
-            "pattern": "^https?://"
+            "format": "uri-reference",
+            "examples": ["https://my-server.com/carta/api", "/carta/api", "/carta-versions/dev/api"]
         },
         "frontendPath": {
             "description": "Path to the built frontend folder. If no path is provided, the packaged version will be used",

package/config/example_config.json

@@ -13,7 +13,6 @@
     },
     "serverPort": 8000,
     "serverInterface": "localhost",
-    "serverAddress": "https://my-carta-server.com",
     "processCommand": "/usr/bin/carta_backend",
     "killCommand": "/usr/local/bin/carta-kill-script",
     "rootFolderTemplate": "/home/{username}",

package/docs/_build/html/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: cab4ab9f21bbbaa15a42a39a8e17d156
+config: f8a72c60066877ba32a024d4a3b93c68
 tags: 645f666f9bcd5a90fca523b33c5a78b7

package/docs/_build/html/_sources/centos8_instructions.rst.txt

@@ -0,0 +1,248 @@
+.. _centos8_instructions:
+
+Step-by-step instructions for CentOS 8
+======================================
+
+.. note::
+
+    These instructions should also work for RHEL 8, AlmaLinux, and Rocky Linux. Some changes may be necessary for RHEL 7 / CentOS 7.
+
+
+1. Install Node.js
+~~~~~~~~~~~~~~~~~~
+
+The CARTA controller uses `Node.js <https://nodejs.org/>`_ and supports v12, v14, and v16. Node.js can easily be installed from the CentOS 8 AppStream repository. Here we install v14, as well as the ``npm`` package manager.
+
+.. code-block:: shell
+
+    # Install Node.js v14:
+    sudo dnf module enable nodejs:14
+    sudo dnf install -y nodejs npm
+
+    # Check it is installed and working:
+    node --version
+    npm --version
+
+2. Install MongoDB
+~~~~~~~~~~~~~~~~~~
+
+The CARTA controller uses `MongoDB <https://www.mongodb.com/>`_ to store user preferences, etc.. MongoDB is not available through the default CentOS 8 repositories, but we can add a custom repository to install it more easily.
+
+.. code-block:: shell
+    
+    # Create a custom MongoDB repo file:
+    sudo cat <<EOT >> /etc/yum.repos.d/mongodb-org.repo
+    [mongodb-org-4.4]
+    name=MongoDB Repository
+    baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.4/x86_64/
+    gpgcheck=1
+    enabled=1
+    gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc
+    EOT
+
+    # Install MongoDB:
+    sudo dnf update
+    sudo dnf install -y mongodb-org
+    
+    # Start and enable MongoDB to run on startup:
+    sudo systemctl start mongod
+    sudo systemctl enable mongod
+
+    # Check that it is working
+    sudo systemctl status mongod
+
+.. note::
+
+    On RHEL7/CentOS7, MongoDB v14 can be installed as follows:
+    ``curl -fsSL https://rpm.nodesource.com/setup_14.x | bash - && yum install -y nodejs``
+
+
+3. Install the CARTA controller
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The easiest way to install the CARTA controller is using ``npm``. 
+
+.. code-block:: shell
+
+    sudo dnf install -y python3 make gcc-c++
+    sudo npm install -g --unsafe-perm carta-controller@beta
+
+.. note::
+
+    The CARTA controller executable will be installed at ``/usr/local/lib/node_modules/carta-controller``.
+    The CARTA frontend will be installed at ``/usr/local/lib/node_modules/carta-controller/node_modules/carta-frontend/build``.
+
+.. note::
+    
+    Do not pass the ``--unsafe-perm`` flag to ``npm`` if using a local install.
+
+.. note::
+    
+    On RHEL7/CentOS7 the CARTA controller package can not run with the default gcc version 4.8.5 (there would be an error due to ``node-linux-pam``). 
+    A work around is to install a newer GCC version from source in order to get a newer ``libstdc++.so.6``, then add the location of the newer 
+    ``libstdc++.so.6`` to the LD_LIBRARY_PATH. After that, the CARTA controller can run on RHEL7/CentOS7.
+
+
+
+4. Install the CARTA backend
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The easiest way may be to install the CARTA backend is from our cartavis RPM repository.
+
+.. code-block:: shell
+
+    # Install the CARTA backend
+    sudo curl https://packages.cartavis.org/cartavis-el8.repo --output /etc/yum.repos.d/cartavis.repo
+    sudo dnf -y install 'dnf-command(config-manager)'
+    sudo dnf -y install epel-release
+    sudo dnf -y config-manager --set-enabled powertools
+    sudo dnf -y install carta-backend-beta
+
+    # Check that the backend can run and matches the major version number of the controller
+    /usr/bin/carta_backend --version
+
+
+5. Install Nginx
+~~~~~~~~~~~~~~~~
+
+The CARTA controller requires a webserver. Here we use `NGINX <https://www.nginx.com/>`_, but Apache should work too.
+
+.. code-block:: shell
+
+    # Install nginx:
+    sudo dnf install -y nginx
+    sudo systemctl start nginx
+    sudo systemctl enable nginx
+    sudo setsebool -P httpd_can_network_connect 1
+    sudo firewall-cmd --permanent --zone=public --add-service=http
+    sudo firewall-cmd --permanent --zone=public --add-service=https
+    sudo firewall-cmd --reload
+
+    # Set up the nginx configuration file using our sample configuration file linked below:
+    sudo cd /etc/nginx/conf.d/
+    sudo vi /etc/nginx/conf.d/carta.conf
+    sudo systemctl restart nginx
+
+    # Check it is running:
+    sudo systemctl status nginx
+
+A :ref:`sample configuration file<example_nginx>` is provided in the configuration section. This should be adapted to your server configuration.
+
+.. note::
+    If there are problems, you can debug with ``journactl -xe`` and by checking log files in ``/var/log/nginx/``.
+
+
+6. Create the 'carta' user and modify sudoers
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For security, we recommend not to run the CARTA controller as the root user. Therefore we create a new user called ``carta``. 
+
+We will assign the group ``carta-users`` to every user account and enable them to run ``/usr/bin/carta_backend`` and the script to close the CARTA backend, ``/usr/local/bin/carta-kill-script``, by adding a custom entry to the ``sudoers`` file.
+
+.. code-block:: shell
+    
+    # Create the carta user:
+    sudo adduser carta
+    # Check everything is OK
+    id carta
+    # It should show 'uid=1000(carta) gid=1000(carta) groups=1000(carta)'
+
+    # So that log files can be written:
+    sudo mkdir -p /var/log/carta
+    sudo chown -R carta /var/log/carta
+
+    # Add the custom sudoers file entry using our sample linked below
+    sudo visudo -f /etc/sudoers.d/carta_controller
+    
+An :ref:`example sudoers configuration<example_sudoers>` is provided in the configuration section.
+
+.. note::
+    The only safe way to modify sudoers is using ``visudo``. Any syntax errors from directly editing sudoers could make your system unusable.
+
+.. note::
+    The ``carta`` user should not be in the ``carta-users`` group. ``carta-users`` should only be assigned to the normal user accounts.
+
+7. Set up the user authentication method
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This is the most difficult step and depends on how you authenticate users at your institute. In this step-by-step guide we use PAM local authentication and a local user, ``bob``, on the server running the CARTA controller. The user ``bob`` needs to be part of the ``carta-users`` group.
+
+With PAM authentication, the ``carta`` user that runs the CARTA controller requires access to the ``/etc/shadow`` file in order to authenticate other users. We can enable this by creating a new group called ``shadow`` and assigning the ``/etc/shadow`` file to that group.
+
+.. note::
+    Only PAM with local authentication requires ``/etc/shadow`` access. PAM using LDAP, and Google OAuth, do not require ``/etc/shadow`` access. 
+
+.. code-block:: shell
+
+    # Create the test user 'bob':
+    sudo useradd -G carta-users bob
+    sudo passwd bob
+
+    # A new group called 'shadow' needs to be assinged to the /etc/shadow file and user 'carta':
+    sudo groupadd shadow
+    sudo chgrp shadow /etc/shadow
+    sudo chmod g+r /etc/shadow
+    sudo usermod -a -G shadow carta
+    ls -l /etc/shadow
+    # It should show permissions as ----r-----. 1 root shadow
+    # It could be helpful to reboot the server at this point
+    sudo reboot 
+
+
+8. Configure the CARTA controller
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Create and fill in the ``config.json`` using our :ref:`sample configuration file<example_config>`. 
+Also generate private/public keys as they are used by the CARTA controller to sign/verify/refresh access tokens.
+
+.. code-block:: shell
+
+    sudo mkdir /etc/carta
+    sudo chown -R carta /etc/carta
+    vi /etc/carta/config.json
+    
+    # Generate private/public keys:
+    cd /etc/carta
+    sudo openssl genrsa -out carta_private.pem 4096
+    sudo openssl rsa -in carta_private.pem -outform PEM -pubout -out carta_public.pem
+
+Please check the `CARTA Configuration Schema <https://carta-controller.readthedocs.io/en/latest/schema.html#schema>`_ for all available options.
+
+
+9. Check everything is working
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Here we switch to the ``carta`` user and test the CARTA controller with our test user ``bob``:
+
+.. code-block:: shell
+
+    su - carta
+    carta-controller -verbose -test bob
+
+If the test is successful, the CARTA controller should be ready to deploy.
+
+
+10. Start the CARTA controller
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: shell
+
+    su - carta
+    carta-controller
+
+Now your users should be able to access your server's URL and log into CARTA.
+
+
+Optional: Set up the CARTA controller to run with pm2
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+`pm2 <https://pm2.keymetrics.io/>`_ is a very convenient tool to keep the CARTA controller service running in the background, and even start it up automatically after a reboot.
+
+.. code-block:: shell
+
+    sudo npm install -g pm2
+    su -carta
+    pm2 start carta-controller
+
+Please refer to the `pm2 documentation <https://pm2.keymetrics.io/docs/usage/startup/>`_ for detailed instructions.
+

package/docs/_build/html/_sources/configuration.rst.txt

@@ -8,7 +8,7 @@ Configuration
 System Configuration
 --------------------
 
-.. _config-backend:
+.. _config-backend-permissions:
 
 CARTA backend permissions
 ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -57,6 +57,8 @@ We strongly suggest serving over HTTPS and redirecting HTTP traffic to HTTPS, es
    :emphasize-lines: 7-15
    :name: example_nginx
 
+Please ensure that you include a trailing ``/`` when hosting the controller on a subdirectory (e.g. ``location /carta/``).
+
 You can also use other HTTP servers, such as Apache. Please ensure that they are set up to forward both standard HTTP requests and WebSocket traffic to the correct port.
 
 .. _config-dirs:
@@ -68,10 +70,10 @@ By default, the controller attempts to write log files to the ``/var/log/carta``
 
 .. _config-controller:
 
-Controller Configuration
+Controller configuration
 ------------------------
 
-Controller configuration is handled by a configuration file in JSONC (JSON with JavaScript style comments) format, adhering to the :ref:`CARTA configuration schema<schema>`. An `example configuration file <_static/config/example_config.json>`_ is provided:
+Controller configuration is handled by a configuration file in JSONC (JSON with JavaScript style comments) format, adhering to the :ref:`CARTA controller configuration schema<schema>`. An `example controller configuration file <_static/config/example_config.json>`_ is provided:
 
 .. literalinclude:: _static/config/example_config.json
    :language: json
@@ -79,7 +81,11 @@ Controller configuration is handled by a configuration file in JSONC (JSON with
 
 By default, the controller assumes the config file is located at ``/etc/carta/config.json``, but you can change this with the ``--config`` or ``-c`` command line argument when running the controller.
 
-The controller automatically executes the backend with the ``--no_http`` flag, to suppress the backend's built-in HTTP server. If the ``logFileTemplate`` configuration option is set, ``--no_log`` is also used to suppress user-level logs. ``--port`` is used to override the default port. ``--top_level_folder`` and a positional argument are used to set the top-level and starting data directories for the user, as specified in the ``rootFolderTemplate`` and ``baseFolderTemplate`` options, respectively. Additional backend flags may be specified with ``additionalArgs``.
+Configuration may also be added in separate files in a ``config.d`` directory in the same parent directory as the specified config file. Each file in this directory must be a valid configuration file. Any files found will be processed in alphabetical order, after the main configuration file.
+
+The controller automatically executes the backend with the ``--no_http`` flag, to suppress the backend's built-in HTTP server. If the ``logFileTemplate`` configuration option is set, ``--no_log`` is also used to suppress user-level logs. ``--port`` is used to override the default port. ``--top_level_folder`` and a positional argument are used to set the top-level and starting data directories for the user, as specified in the ``rootFolderTemplate`` and ``baseFolderTemplate`` options, respectively. 
+
+To specify additional backend flags, we recommend editing a :ref:`global backend preferences<config-backend>` file. Most commandline arguments to the backend are also recognised as configuration options. The ``additionalArgs`` field in the controller configuration file can be used for any debug options which are not, and to disable the local or global configuration files.
 
 If you use an external :ref:`authentication<authentication>` system, you may need to translate a unique ID (such as email or username) from the authenticated external user information to an internal system user. You can do this by providing a `user lookup table <_static/config/usertable.txt.stub>`_, which is watched by the controller and reloaded whenever it is updated:
 
@@ -87,3 +93,62 @@ If you use an external :ref:`authentication<authentication>` system, you may nee
    :language: cfg
 
 You can alter the controller's dashboard appearance by adjusting the ``dashboard`` field in the config file. You can change the banner image and background, and add login instructions or institutional notices.
+
+The ``httpOnly`` flag can be used to disable secure signing of authentication tokens. This should only be used during initial deployment and testing, or debugging.
+
+The controller assumes it is running at the root directory of your subdomain by default. If you would prefer to run on a subdirectory, you will need to specify the ``dashboardAddress`` and ``apiAddress`` values (relative to your subdomain) explicitly. For example, if you are hosting CARTA at ``https://subdomain.domain.com/carta/version/v3-beta/``, you would need to include the following in your config file:
+
+.. code-block:: json
+
+    {
+        "apiAddress": "/carta/version/v3-beta/api",
+        "dashboardAddress": "/carta/version/v3-beta/dashboard"
+    }
+
+.. _config-backend:
+
+Backend configuration
+---------------------
+
+The global configuration file for the CARTA backend is located at ``/etc/carta/backend.json``. A per-user configuration file can also be placed in each user's local CARTA preferences directory (typically ``.carta`` or ``.carta-beta`` in the user's home directory, depending on how the CARTA backend was installed). On a multi-user system, if users have write access to this location, you may wish to disable the use of per-user configuration files, to prevent users from bypassing the root directory configuration set by the controller. This must be done through the ``additionalArgs`` field in the :ref:`controller configuration<config-controller>`.
+
+The backend configuration file must adhere to the :ref:`CARTA backend configuration schema<schema_backend>`. An `example backend configuration file <_static/config/example_backend.json>`_ is provided:
+
+.. literalinclude:: _static/config/example_backend.json
+   :language: json
+   :name: example_backend
+   
+.. _test-config:
+
+Testing the configuration
+-------------------------
+
+To test the configuration of the controller, you can use the built-in test feature. Run ``carta-controller --verbose --test <username>`` as the ``carta`` user (or whichever user has the :ref:`added sudoers permissions<config-backend-permissions>`). ``<username>`` should be a user in the ``carta-users`` group. The expected output looks like this:
+
+.. code-block::
+
+    Checking config file /etc/carta/config.json
+    Adding additional config file config.d/pam.json
+    No top-level folder was specified. Reverting to default location
+    Testing configuration with user alice
+    Password for user alice: 
+    ✔ Checked PAM connection for user alice
+    ✔ Verified uid (1000) for user alice
+    ✔ Generated access token for user alice
+    ✔ Checked database connection
+    ✔ Checked log writing for user alice
+    ✔ Read frontend index.html from /custom/frontend/path/build
+    [
+    'running sudo --preserve-env=CARTA_AUTH_TOKEN -n -u alice /usr/bin/carta_backend --no_http --debug_no_auth --port 3499 --top_level_folder /usr/share/carta --no_log /usr/share/carta'
+    ]
+    [2021-11-30 12:28:48.207] [info] /usr/bin/carta_backend: Version 3.0.0-beta.3
+    [2021-11-30 12:28:48.209] [info] Listening on port 3499 with top level folder /usr/share/carta, starting folder /usr/share/carta. The number of OpenMP worker threads will be handled automatically.
+    ✔ Backend process started successfully
+    [2021-11-30 12:28:50.169] [info] Session 1 [127.0.0.1] Connected. Num sessions: 1
+    ✔ Backend process accepted connection
+    [ 'running sudo -u alice ./scripts/carta_kill_script.sh 54275' ]
+    ✔ Backend process killed correctly
+    Controller tests with user alice succeeded
+
+.. note::
+    If you run the controller from a source directory using ``npm``, use ``--`` to ensure that any commandline parameters are passed to the controller and not to ``npm``. For example: ``npm run start -- --verbose --test alice``.

package/docs/_build/html/_sources/index.rst.txt

@@ -10,7 +10,8 @@ CARTA Controller
 
 CARTA is the Cube Analysis and Rendering Tool for Astronomy. This document describes the installation and configuration process for the controller component.
 
-Detailed :ref:`step-by-step instructions<focal_instructions>` are provided for Ubuntu 20.04 (Focal Fossa).
+Detailed step-by-step instructions are provided for :ref:`Ubuntu 20.04 (Focal Fossa)<focal_instructions>` and :ref:`CentOS 8<centos8_instructions>`. 
+We officially support Ubuntu 18.04 and 20.04, and RHEL 7 and 8 (and their freely distributed binary-compatible alternatives, such as CentOS or AlmaLinux), with all available standard updates applied.
 
 .. toctree::
    :maxdepth: 2
@@ -20,13 +21,15 @@ Detailed :ref:`step-by-step instructions<focal_instructions>` are provided for U
    installation
    configuration
    ubuntu_focal_instructions
+   centos8_instructions   
    schema
+   schema_backend
 
-.. |backend-github| image:: https://img.shields.io/badge/CARTA%20Version-3.0.0--beta.1c-brightgreen
+.. |backend-github| image:: https://img.shields.io/badge/CARTA%20Version-3.0.0--rc.0-brightgreen
         :alt: View this backend version on GitHub
-        :target: https://github.com/CARTAvis/carta-backend/releases/tag/v3.0.0-beta.1c
+        :target: https://github.com/CARTAvis/carta-backend/releases/tag/v3.0.0-rc.0
 
-.. |npm-package| image:: https://img.shields.io/npm/v/carta-controller/dev.svg?style=flat
+.. |npm-package| image:: https://img.shields.io/npm/v/carta-controller/rc.svg?style=flat
         :alt: View this project on npm
         :target: https://npmjs.org/package/carta-controller
 

package/docs/_build/html/_sources/installation.rst.txt

@@ -8,7 +8,7 @@ Installation
 Installing the backend
 ----------------------
 
-We provide `binary Debian packages <https://launchpad.net/~cartavis-team/+archive/ubuntu/carta>`_ of the latest development and release versions of the CARTA backend for Ubuntu 20.04 (Focal Fossa) and Ubuntu 18.04 (Bionic Beaver). You can install the development version with all dependencies by adding our PPA to your system and running ``apt-get install carta-backend-beta``. Please refer to our :ref:`Ubuntu Focal instructions<focal_instructions>` for more details.
+We provide `binary Debian packages <https://launchpad.net/~cartavis-team/+archive/ubuntu/carta>`_ of the latest beta and release versions of the CARTA backend for Ubuntu 20.04 (Focal Fossa) and Ubuntu 18.04 (Bionic Beaver). You can install the beta version with all dependencies by adding our PPA to your system and running ``apt-get install carta-backend-beta``. Please refer to our :ref:`Ubuntu Focal instructions<focal_instructions>` for more details.
 
 .. note::
 
@@ -28,7 +28,7 @@ If you install the controller from NPM, the corresponding packaged version of th
 Installing the controller
 -------------------------
 
-You can install the development version of the CARTA controller from NPM by running ``npm install -g carta-controller@dev``, or from GitHub by cloning the `controller repository <https://github.com/CARTAvis/carta-controller/>`_ and running ``npm install``.
+You can install the beta version of the CARTA controller from NPM by running ``npm install -g carta-controller@beta``, or from GitHub by cloning the `controller repository <https://github.com/CARTAvis/carta-controller/>`_ and running ``npm install``.
 
 .. _run_controller:
 

package/docs/_build/html/_sources/introduction.rst.txt

@@ -10,7 +10,7 @@ The CARTA controller provides a simple dashboard which authenticates users and a
 Dependencies
 ------------
 
-To allow the controller to serve CARTA sessions, you must give it access to an executable CARTA backend, which can be either a compiled executable or a container. If you want to use a non-standard version of the CARTA frontend, you must also build it, and adjust the controller configuration to point to it. You should use the ``v3.0.0-beta.1c`` tag of `the CARTA backend <https://github.com/CARTAvis/carta-backend>`_.
+To allow the controller to serve CARTA sessions, you must give it access to an executable CARTA backend, which can be either a compiled executable or a container. If you want to use a non-standard version of the CARTA frontend, you must also build it, and adjust the controller configuration to point to it. You should use the ``v3.0.0-rc.0`` tag of `the CARTA backend <https://github.com/CARTAvis/carta-backend>`_.
 
 By default, the controller runs on port 8000. It should be run behind a proxy, so that it can be accessed via HTTP and HTTPS. 
 

package/docs/_build/html/_sources/schema_backend.rst.txt

@@ -0,0 +1,7 @@
+.. _schema_backend:
+
+.. jsonschema:: _static/config/preference_backend_schema_2.json
+    :lift_description:
+    :lift_definitions:
+    :auto_target:
+    :auto_reference:

package/docs/_build/html/_sources/ubuntu_focal_instructions.rst.txt

@@ -19,7 +19,7 @@ Install the CARTA backend and other required packages
     sudo add-apt-repository ppa:cartavis-team/carta
     sudo apt-get update
 
-    # Install the development backend package with all dependencies
+    # Install the beta backend package with all dependencies
     sudo apt-get install carta-backend-beta
     
     # Install additional packages
@@ -74,7 +74,7 @@ Install CARTA controller
     sudo apt-get install -y nodejs build-essential
 
     # Install carta-controller (includes frontend config)
-    sudo npm install -g --unsafe-perm carta-controller@dev
+    sudo npm install -g --unsafe-perm carta-controller@beta
     
     # Install PM2 node service
     sudo npm install -g pm2

package/docs/_build/html/_static/_sphinx_javascript_frameworks_compat.js

@@ -0,0 +1,134 @@
+/*
+ * _sphinx_javascript_frameworks_compat.js
+ * ~~~~~~~~~~
+ *
+ * Compatability shim for jQuery and underscores.js.
+ *
+ * WILL BE REMOVED IN Sphinx 6.0
+ * xref RemovedInSphinx60Warning
+ *
+ */
+
+/**
+ * select a different prefix for underscore
+ */
+$u = _.noConflict();
+
+
+/**
+ * small helper function to urldecode strings
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL
+ */
+jQuery.urldecode = function(x) {
+    if (!x) {
+        return x
+    }
+    return decodeURIComponent(x.replace(/\+/g, ' '));
+};
+
+/**
+ * small helper function to urlencode strings
+ */
+jQuery.urlencode = encodeURIComponent;
+
+/**
+ * This function returns the parsed url parameters of the
+ * current request. Multiple values per key are supported,
+ * it will always return arrays of strings for the value parts.
+ */
+jQuery.getQueryParameters = function(s) {
+    if (typeof s === 'undefined')
+        s = document.location.search;
+    var parts = s.substr(s.indexOf('?') + 1).split('&');
+    var result = {};
+    for (var i = 0; i < parts.length; i++) {
+        var tmp = parts[i].split('=', 2);
+        var key = jQuery.urldecode(tmp[0]);
+        var value = jQuery.urldecode(tmp[1]);
+        if (key in result)
+            result[key].push(value);
+        else
+            result[key] = [value];
+    }
+    return result;
+};
+
+/**
+ * highlight a given string on a jquery object by wrapping it in
+ * span elements with the given class name.
+ */
+jQuery.fn.highlightText = function(text, className) {
+    function highlight(node, addItems) {
+        if (node.nodeType === 3) {
+            var val = node.nodeValue;
+            var pos = val.toLowerCase().indexOf(text);
+            if (pos >= 0 &&
+                !jQuery(node.parentNode).hasClass(className) &&
+                !jQuery(node.parentNode).hasClass("nohighlight")) {
+                var span;
+                var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
+                if (isInSVG) {
+                    span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+                } else {
+                    span = document.createElement("span");
+                    span.className = className;
+                }
+                span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+                node.parentNode.insertBefore(span, node.parentNode.insertBefore(
+                    document.createTextNode(val.substr(pos + text.length)),
+                    node.nextSibling));
+                node.nodeValue = val.substr(0, pos);
+                if (isInSVG) {
+                    var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+                    var bbox = node.parentElement.getBBox();
+                    rect.x.baseVal.value = bbox.x;
+                    rect.y.baseVal.value = bbox.y;
+                    rect.width.baseVal.value = bbox.width;
+                    rect.height.baseVal.value = bbox.height;
+                    rect.setAttribute('class', className);
+                    addItems.push({
+                        "parent": node.parentNode,
+                        "target": rect});
+                }
+            }
+        }
+        else if (!jQuery(node).is("button, select, textarea")) {
+            jQuery.each(node.childNodes, function() {
+                highlight(this, addItems);
+            });
+        }
+    }
+    var addItems = [];
+    var result = this.each(function() {
+        highlight(this, addItems);
+    });
+    for (var i = 0; i < addItems.length; ++i) {
+        jQuery(addItems[i].parent).before(addItems[i].target);
+    }
+    return result;
+};
+
+/*
+ * backward compatibility for jQuery.browser
+ * This will be supported until firefox bug is fixed.
+ */
+if (!jQuery.browser) {
+    jQuery.uaMatch = function(ua) {
+        ua = ua.toLowerCase();
+
+        var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
+            /(webkit)[ \/]([\w.]+)/.exec(ua) ||
+            /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
+            /(msie) ([\w.]+)/.exec(ua) ||
+            ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
+            [];
+
+        return {
+            browser: match[ 1 ] || "",
+            version: match[ 2 ] || "0"
+        };
+    };
+    jQuery.browser = {};
+    jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
+}