canvas 0.13.0__py3-none-any.whl → 0.13.2__py3-none-any.whl

{canvas-0.13.0.dist-info → canvas-0.13.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: canvas
-Version: 0.13.0
+Version: 0.13.2
 Summary: SDK to customize event-driven actions in your Canvas instance
 License: MIT
 Author: Canvas Team
@@ -10,6 +10,8 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: boto3 (>=1.35.88,<2.0.0)
+Requires-Dist: boto3-stubs[s3] (>=1.35.88,<2.0.0)
 Requires-Dist: cookiecutter
 Requires-Dist: cron-converter (>=1.2.1,<2.0.0)
 Requires-Dist: deprecation (>=2.1.0,<3.0.0)

{canvas-0.13.0.dist-info → canvas-0.13.2.dist-info}/RECORD

@@ -232,8 +232,10 @@ logger/__init__.py,sha256=9o2iRCjzFEhfULgXvrrECRFK-4IslWJTqKKjTCEUbq8,61
 logger/logger.py,sha256=axf7UffBJtETjwDCtmi1IaaJKsvcFj8zaLfouGsq68A,1847
 plugin_runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plugin_runner/authentication.py,sha256=SDPso2AogtLAV_H0LuMDp99IMZuF3oTq-Q_AXAvJ8uc,1116
+plugin_runner/exceptions.py,sha256=YnRZiQVzbU3HrVlmEXLje_np99009YnhTRVHHyBCtqc,433
+plugin_runner/plugin_installer.py,sha256=Ah3A1j6vO8wi4HPRYVlxF1w-GqbuTvLmDCQvLQK3Oy8,7020
 plugin_runner/plugin_runner.py,sha256=at5BTolHnVWQci-GTUbvJsI-hsjeR9lDCnSz9OhIJ34,15296
-plugin_runner/plugin_synchronizer.py,sha256=t3zzfDw-bDK_hvUDQ434qaQuKLGgBGndzaCRAnSpuTU,2554
+plugin_runner/plugin_synchronizer.py,sha256=EwBpKopmArjXxsE9hWpvHRSaVjCq4mg8kXxK3hQMeCk,2684
 plugin_runner/sandbox.py,sha256=JUbphdu1iY0rPU6DdMEjFA32BBsZXHUz1KguCYpmrug,9384
 plugin_runner/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plugin_runner/tests/data/plugins/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -267,12 +269,13 @@ plugin_runner/tests/fixtures/plugins/test_module_imports_plugin/other_module/bas
 plugin_runner/tests/fixtures/plugins/test_module_imports_plugin/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plugin_runner/tests/fixtures/plugins/test_module_imports_plugin/protocols/my_protocol.py,sha256=V_6DPXsJaD12zGyKqGjYY2JFtKEk4E0eIAgBWax_MGc,629
 plugin_runner/tests/test_application.py,sha256=ZirW14UGorfkQ_VSbnoKtmTvx6lHFS2EqndYNczIQfo,2391
+plugin_runner/tests/test_plugin_installer.py,sha256=BETY7stpf_DZdSBLSSBc_NeAWcLU0m_cptG8C8_rk1Q,3937
 plugin_runner/tests/test_plugin_runner.py,sha256=pj9C3-GNsTyUYNIkOiihmxAO67FQE1GU5BoM727SnxA,7539
 plugin_runner/tests/test_sandbox.py,sha256=6Jw2Akcl1KQpXb01FxDvI_ZToJzOcpABwFkXK3fl8BU,3434
 pubsub/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pubsub/pubsub.py,sha256=pyTW0JU8mtaqiAV6g6xjZwel1CVy2EonPMU-_vkmhUM,1044
-settings.py,sha256=6YTybI0eNeuDamnXdRrEUOBICf9bM1uW1lCwj4IR9sU,2081
-canvas-0.13.0.dist-info/METADATA,sha256=DQc9FKPwqLuUlsFahpNTTT8BPJ5X58Mmuo7EU4FgRKo,4703
-canvas-0.13.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-canvas-0.13.0.dist-info/entry_points.txt,sha256=VSmSo1IZ3aEfL7enmLmlWSraS_IIkoXNVeyXzgRxFiY,46
-canvas-0.13.0.dist-info/RECORD,,
+settings.py,sha256=UG0jV2Sht7ftEJjqEyLKn9fld0jAtblqO7oJdfjNYvA,2144
+canvas-0.13.2.dist-info/METADATA,sha256=JikPMsbC7-iYOeMXZv-pSWyq06V0H3D1Des1-IFnfro,4793
+canvas-0.13.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+canvas-0.13.2.dist-info/entry_points.txt,sha256=VSmSo1IZ3aEfL7enmLmlWSraS_IIkoXNVeyXzgRxFiY,46
+canvas-0.13.2.dist-info/RECORD,,

plugin_runner/exceptions.py

@@ -0,0 +1,14 @@
+class PluginError(Exception):
+    """An exception raised for plugin-related errors."""
+
+
+class PluginValidationError(PluginError):
+    """An exception raised when a plugin package is not valid."""
+
+
+class InvalidPluginFormat(PluginValidationError):
+    """An exception raised when the plugin file format is not supported."""
+
+
+class PluginInstallationError(PluginError):
+    """An exception raised when a plugin fails to install."""

plugin_runner/plugin_installer.py

@@ -0,0 +1,208 @@
+import json
+import os
+import shutil
+import tarfile
+import tempfile
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, TypedDict
+from urllib import parse
+
+import boto3
+import psycopg
+from psycopg import Connection
+from psycopg.rows import dict_row
+
+import settings
+from plugin_runner.exceptions import InvalidPluginFormat, PluginInstallationError
+
+# Plugin "packages" include this prefix in the database record for the plugin and the S3 bucket key.
+UPLOAD_TO_PREFIX = "plugins"
+
+
+def get_database_dict_from_url() -> dict[str, Any]:
+    """Creates a psycopg ready dictionary from the home-app database URL."""
+    parsed_url = parse.urlparse(os.getenv("DATABASE_URL"))
+    db_name = parsed_url.path[1:]
+    return {
+        "dbname": db_name,
+        "user": parsed_url.username,
+        "password": parsed_url.password,
+        "host": parsed_url.hostname,
+        "port": parsed_url.port,
+    }
+
+
+def get_database_dict_from_env() -> dict[str, Any]:
+    """Creates a psycopg ready dictionary from the environment variables."""
+    APP_NAME = os.getenv("APP_NAME")
+
+    return {
+        "dbname": APP_NAME,
+        "user": os.getenv("DB_USERNAME", "app"),
+        "password": os.getenv("DB_PASSWORD", "app"),
+        "host": os.getenv("DB_HOST", f"{APP_NAME}-db"),
+        "port": os.getenv("DB_PORT", "5432"),
+    }
+
+
+def open_database_connection() -> Connection:
+    """Opens a psycopg connection to the home-app database."""
+    # When running within Aptible, use the database URL, otherwise pull from the environment variables.
+    if os.getenv("DATABASE_URL"):
+        database_dict = get_database_dict_from_url()
+    else:
+        database_dict = get_database_dict_from_env()
+    conn = psycopg.connect(**database_dict)
+    return conn
+
+
+class PluginAttributes(TypedDict):
+    """Attributes of a plugin."""
+
+    version: str
+    package: str
+    secrets: dict[str, str]
+
+
+def enabled_plugins() -> dict[str, PluginAttributes]:
+    """Returns a dictionary of enabled plugins and their attributes."""
+    conn = open_database_connection()
+
+    with conn.cursor(row_factory=dict_row) as cursor:
+        cursor.execute(
+            "select name, package, version, key, value from plugin_io_plugin p "
+            "left join plugin_io_pluginsecret s on p.id = s.plugin_id where is_enabled"
+        )
+        rows = cursor.fetchall()
+        plugins = _extract_rows_to_dict(rows)
+
+    return plugins
+
+
+def _extract_rows_to_dict(rows: list) -> dict[str, PluginAttributes]:
+    plugins = {}
+    for row in rows:
+        if row["name"] not in plugins:
+            plugins[row["name"]] = PluginAttributes(
+                version=row["version"],
+                package=row["package"],
+                secrets={row["key"]: row["value"]} if row["key"] else {},
+            )
+        else:
+            plugins[row["name"]]["secrets"][row["key"]] = row["value"]
+    return plugins
+
+
+@contextmanager
+def download_plugin(plugin_package: str) -> Generator:
+    """Download the plugin package from the S3 bucket."""
+    s3 = boto3.client("s3")
+    with tempfile.TemporaryDirectory() as temp_dir:
+        prefix_dir = Path(temp_dir) / UPLOAD_TO_PREFIX
+        prefix_dir.mkdir()  # create an intermediate directory reflecting the prefix
+        download_path = Path(temp_dir) / plugin_package
+        with open(download_path, "wb") as download_file:
+            s3.download_fileobj(
+                "canvas-client-media",
+                f"{settings.CUSTOMER_IDENTIFIER}/{plugin_package}",
+                download_file,
+            )
+        yield download_path
+
+
+def install_plugin(plugin_name: str, attributes: PluginAttributes) -> None:
+    """Install the given Plugin's package into the runtime."""
+    try:
+        print(f"Installing plugin '{plugin_name}'")
+
+        plugin_installation_path = Path(settings.PLUGIN_DIRECTORY) / plugin_name
+
+        # if plugin exists, first uninstall it
+        if plugin_installation_path.exists():
+            uninstall_plugin(plugin_name)
+
+        with download_plugin(attributes["package"]) as plugin_file_path:
+            extract_plugin(plugin_file_path, plugin_installation_path)
+
+        install_plugin_secrets(plugin_name=plugin_name, secrets=attributes["secrets"])
+    except Exception as ex:
+        print(f"Failed to install plugin '{plugin_name}', version {attributes['version']}")
+        raise PluginInstallationError() from ex
+
+
+def extract_plugin(plugin_file_path: Path, plugin_installation_path: Path) -> None:
+    """Extract plugin in `file` to the given `path`."""
+    archive: tarfile.TarFile | None = None
+
+    try:
+        if tarfile.is_tarfile(plugin_file_path):
+            try:
+                with open(plugin_file_path, "rb") as file:
+                    archive = tarfile.TarFile.open(fileobj=file)
+                    archive.extractall(plugin_installation_path, filter="data")
+            except tarfile.ReadError as ex:
+                print(f"Unreadable tar archive: '{plugin_file_path}'")
+                raise InvalidPluginFormat from ex
+        else:
+            print(f"Unsupported file format: '{plugin_file_path}'")
+            raise InvalidPluginFormat
+    finally:
+        if archive:
+            archive.close()
+
+
+def install_plugin_secrets(plugin_name: str, secrets: dict[str, str]) -> None:
+    """Write the plugin's secrets to disk in the package's directory."""
+    print(f"Writing plugin secrets for '{plugin_name}'")
+
+    secrets_path = Path(settings.PLUGIN_DIRECTORY) / plugin_name / settings.SECRETS_FILE_NAME
+
+    # Did the plugin ship a secrets.json? TOO BAD, IT'S GONE NOW.
+    if Path(secrets_path).exists():
+        os.remove(secrets_path)
+
+    with open(str(secrets_path), "w") as f:
+        json.dump(secrets, f)
+
+
+def disable_plugin(plugin_name: str) -> None:
+    """Disable the given plugin."""
+    conn = open_database_connection()
+    conn.cursor().execute(
+        "update plugin_io_plugin set is_enabled = false where name = %s", (plugin_name,)
+    )
+    conn.commit()
+    conn.close()
+
+    uninstall_plugin(plugin_name)
+
+
+def uninstall_plugin(plugin_name: str) -> None:
+    """Remove the plugin from the filesystem."""
+    plugin_path = Path(settings.PLUGIN_DIRECTORY) / plugin_name
+
+    if plugin_path.exists():
+        shutil.rmtree(plugin_path)
+
+
+def install_plugins() -> None:
+    """Install all enabled plugins."""
+    if Path(settings.PLUGIN_DIRECTORY).exists():
+        shutil.rmtree(settings.PLUGIN_DIRECTORY)
+
+    os.mkdir(settings.PLUGIN_DIRECTORY)
+
+    for plugin_name, attributes in enabled_plugins().items():
+        try:
+            print(f"Installing plugin '{plugin_name}', version {attributes['version']}")
+            install_plugin(plugin_name, attributes)
+        except PluginInstallationError:
+            disable_plugin(plugin_name)
+            print(
+                f"Installation failed for plugin '{plugin_name}', version {attributes['version']}. The plugin has been disabled"
+            )
+            continue
+
+    return None

plugin_runner/plugin_synchronizer.py

@@ -7,6 +7,8 @@ from subprocess import STDOUT, CalledProcessError, check_output
 
 import redis
 
+from plugin_runner.plugin_installer import install_plugins
+
 APP_NAME = os.getenv("APP_NAME")
 
 CUSTOMER_IDENTIFIER = os.getenv("CUSTOMER_IDENTIFIER")
@@ -43,6 +45,11 @@ def publish_message(message: dict) -> None:
 def main() -> None:
     """Listen for messages on the pubsub channel and restart the plugin-runner."""
     print("plugin-synchronizer: starting")
+    try:
+        print("plugin-synchronizer: installing plugins after web container start")
+        install_plugins()
+    except CalledProcessError as e:
+        print("plugin-synchronizer: `install_plugins` failed:", e)
 
     _, pubsub = get_client()
 
@@ -62,17 +69,13 @@ def main() -> None:
         if "action" not in data or "client_id" not in data:
             return
 
-        # Don't respond to our own messages
-        if data["client_id"] == CLIENT_ID:
-            return
-
         if data["action"] == "restart":
             # Run the plugin installer process
             try:
-                print("plugin-synchronizer: installing plugins")
-                check_output(["./manage.py", "install_plugins_v2"], cwd="/app", stderr=STDOUT)
+                print("plugin-synchronizer: installing plugins after receiving restart message")
+                install_plugins()
             except CalledProcessError as e:
-                print("plugin-synchronizer: `./manage.py install_plugins_v2` failed:", e)
+                print("plugin-synchronizer: `install_plugins` failed:", e)
 
             try:
                 print("plugin-synchronizer: sending SIGHUP to plugin-runner")

plugin_runner/tests/test_plugin_installer.py

@@ -0,0 +1,118 @@
+import json
+import tarfile
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from pytest_mock import MockerFixture
+
+import settings
+from plugin_runner.plugin_installer import (
+    PluginAttributes,
+    _extract_rows_to_dict,
+    download_plugin,
+    install_plugins,
+    uninstall_plugin,
+)
+
+
+def _create_tarball(name: str) -> Path:
+    # Create a temporary tarball file
+    temp_dir = tempfile.mkdtemp()
+    tarball_path = Path(temp_dir) / f"{name}.tar.gz"
+
+    # Add some files to the tarball
+    with tarfile.open(tarball_path, "w:gz") as tar:
+        for i in range(3):
+            file_path = Path(temp_dir) / f"file{i}.txt"
+            file_path.write_text(f"Content of file {i}")
+            tar.add(file_path, arcname=f"file{i}.txt")
+
+    # Return a Path handle to the tarball
+    return tarball_path
+
+
+def test_extract_rows_to_dict() -> None:
+    """Test that database rows can be extracted to a dictionary with secrets appropriately attributed to plugin."""
+    rows = [
+        {
+            "name": "plugin1",
+            "version": "1.0",
+            "package": "package1",
+            "key": "key1",
+            "value": "value1",
+        },
+        {
+            "name": "plugin1",
+            "version": "1.0",
+            "package": "package1",
+            "key": "key2",
+            "value": "value2",
+        },
+        {"name": "plugin2", "version": "2.0", "package": "package2", "key": None, "value": None},
+    ]
+
+    expected_output = {
+        "plugin1": {
+            "version": "1.0",
+            "package": "package1",
+            "secrets": {"key1": "value1", "key2": "value2"},
+        },
+        "plugin2": {
+            "version": "2.0",
+            "package": "package2",
+            "secrets": {},
+        },
+    }
+
+    result = _extract_rows_to_dict(rows)
+    assert result == expected_output
+
+
+def test_plugin_installation_from_tarball(mocker: MockerFixture) -> None:
+    """Test that plugins can be installed from tarballs."""
+    mock_plugins = {
+        "plugin1": PluginAttributes(
+            version="1.0", package="plugins/plugin1.tar.gz", secrets={"key1": "value1"}
+        ),
+        "plugin2": PluginAttributes(
+            version="1.0", package="plugins/plugin2.tar", secrets={"key2": "value2"}
+        ),
+    }
+
+    tarball_1 = _create_tarball("plugin1")
+    tarball_2 = _create_tarball("plugin2")
+
+    mocker.patch("plugin_runner.plugin_installer.enabled_plugins", return_value=mock_plugins)
+    mocker.patch(
+        "plugin_runner.plugin_installer.download_plugin", side_effect=[tarball_1, tarball_2]
+    )
+
+    install_plugins()
+    assert Path("plugin_runner/tests/data/plugins/plugin1").exists()
+    assert Path("plugin_runner/tests/data/plugins/plugin1/SECRETS.json").exists()
+    with open("plugin_runner/tests/data/plugins/plugin1/SECRETS.json") as f:
+        assert json.load(f) == mock_plugins["plugin1"]["secrets"]
+    assert Path("plugin_runner/tests/data/plugins/plugin2").exists()
+    assert Path("plugin_runner/tests/data/plugins/plugin2/SECRETS.json").exists()
+    with open("plugin_runner/tests/data/plugins/plugin2/SECRETS.json") as f:
+        assert json.load(f) == mock_plugins["plugin2"]["secrets"]
+
+    uninstall_plugin("plugin1")
+    uninstall_plugin("plugin2")
+    assert not Path("plugin_runner/tests/data/plugins/plugin1").exists()
+    assert not Path("plugin_runner/tests/data/plugins/plugin2").exists()
+
+
+def test_download(mocker: MockerFixture) -> None:
+    """Test that the plugin package can be written to disk, mocking out S3."""
+    mock_s3_client = MagicMock()
+    mocker.patch("boto3.client", return_value=mock_s3_client)
+
+    plugin_package = "plugins/plugin1.tar.gz"
+    with download_plugin(plugin_package) as plugin_path:
+        assert plugin_path.exists()
+
+    mock_s3_client.download_fileobj.assert_called_once_with(
+        "canvas-client-media", f"{settings.CUSTOMER_IDENTIFIER}/{plugin_package}", mocker.ANY
+    )

settings.py

@@ -11,7 +11,7 @@ load_dotenv()
 ENV = os.getenv("ENV", "development")
 IS_PRODUCTION = ENV == "production"
 IS_TESTING = env_to_bool("IS_TESTING", "pytest" in sys.argv[0] or sys.argv[0] == "-c")
-
+CUSTOMER_IDENTIFIER = os.getenv("CUSTOMER_IDENTIFIER", "local")
 
 INTEGRATION_TEST_URL = os.getenv("INTEGRATION_TEST_URL")
 INTEGRATION_TEST_CLIENT_ID = os.getenv("INTEGRATION_TEST_CLIENT_ID")