canvas 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

plugin_runner/plugin_runner.py

@@ -1,23 +1,28 @@
-import asyncio
 import json
 import os
 import pathlib
 import pickle
 import pkgutil
 import sys
+import threading
 import traceback
 from collections import defaultdict
-from collections.abc import AsyncGenerator
+from collections.abc import Iterable
+from concurrent.futures import ThreadPoolExecutor
 from http import HTTPStatus
+from time import sleep
 from typing import Any, TypedDict
 
 import grpc
-import redis.asyncio as redis
+import redis
 import sentry_sdk
-from asgiref.sync import sync_to_async
-from django.db import connections
+from django.core.signals import request_finished, request_started
+from redis.backoff import ExponentialBackoff
+from redis.exceptions import ConnectionError, TimeoutError
+from redis.retry import Retry
 from sentry_sdk.integrations.logging import ignore_logger
 
+import settings
 from canvas_generated.messages.effects_pb2 import EffectType
 from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest, ReloadPluginsResponse
 from canvas_generated.services.plugin_runner_pb2_grpc import (
@@ -27,9 +32,10 @@ from canvas_generated.services.plugin_runner_pb2_grpc import (
 from canvas_sdk.effects import Effect
 from canvas_sdk.effects.simple_api import Response
 from canvas_sdk.events import Event, EventRequest, EventResponse, EventType
+from canvas_sdk.handlers.simple_api.websocket import DenyConnection
 from canvas_sdk.protocols import ClinicalQualityMeasure
 from canvas_sdk.utils import metrics
-from canvas_sdk.utils.metrics import measured, statsd_client
+from canvas_sdk.utils.metrics import measured
 from logger import log
 from plugin_runner.authentication import token_for_plugin
 from plugin_runner.installation import install_plugins
@@ -39,7 +45,6 @@ from settings import (
     CUSTOMER_IDENTIFIER,
     ENV,
     IS_PRODUCTION_CUSTOMER,
-    IS_TESTING,
     MANIFEST_FILE_NAME,
     PLUGIN_DIRECTORY,
     REDIS_ENDPOINT,
@@ -149,33 +154,12 @@ class PluginManifest(TypedDict):
     readme: str
 
 
-@sync_to_async
-def reconnect_if_needed() -> None:
-    """
-    Reconnect to the database if the connection has been closed.
-
-    NOTE: Django database functions are not async-safe and must be called
-    via e.g. sync_to_async. They will silently fail and block the handler
-    if called in an async context directly.
-    """
-    if IS_TESTING:
-        return
-
-    connection = connections["default"]
-
-    if not connection.is_usable():
-        log.debug("Connection was unusable, reconnecting...")
-        connection.connect()
-
-
 class PluginRunner(PluginRunnerServicer):
     """This process runs provided plugins that register interest in incoming events."""
 
     sandbox: Sandbox
 
-    async def HandleEvent(
-        self, request: EventRequest, context: Any
-    ) -> AsyncGenerator[EventResponse, None]:
+    def HandleEvent(self, request: EventRequest, context: Any) -> Iterable[EventResponse]:
         """This is invoked when an event comes in."""
         event = Event(request)
         with metrics.measure(
@@ -190,13 +174,18 @@ class PluginRunner(PluginRunnerServicer):
             sentry_sdk.set_tag("event-name", event_name)
 
             if relevant_plugins:
-                await reconnect_if_needed()
+                # Send the Django request_started signal
+                request_started.send(sender=self.__class__)
 
             if event_type in [EventType.PLUGIN_CREATED, EventType.PLUGIN_UPDATED]:
                 plugin_name = event.target.id
                 # filter only for the plugin(s) that were created/updated
                 relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
-            elif event_type in {EventType.SIMPLE_API_AUTHENTICATE, EventType.SIMPLE_API_REQUEST}:
+            elif event_type in {
+                EventType.SIMPLE_API_AUTHENTICATE,
+                EventType.SIMPLE_API_REQUEST,
+                EventType.SIMPLE_API_WEBSOCKET_AUTHENTICATE,
+            }:
                 # The target plugin's name will be part of the home-app URL path, so other plugins that
                 # respond to SimpleAPI request events are not relevant
                 plugin_name = event.context["plugin_name"]
@@ -238,7 +227,7 @@ class PluginRunner(PluginRunnerServicer):
                             "event": event_name,
                         },
                     ):
-                        _effects = await sync_to_async(handler.compute)()
+                        _effects = handler.compute()
                         effects = [
                             Effect(
                                 type=effect.type,
@@ -283,27 +272,42 @@ class PluginRunner(PluginRunnerServicer):
                         f" {event.context['path']}"
                     )
                     effect_list = [Response(status_code=HTTPStatus.INTERNAL_SERVER_ERROR).apply()]
+            if event.type == EventType.SIMPLE_API_WEBSOCKET_AUTHENTICATE:
+                if len(relevant_plugin_handlers) == 0:
+                    effect_list = [DenyConnection().apply()]
+                elif len(relevant_plugin_handlers) > 1:
+                    log.error(
+                        f"Multiple handlers responded to {EventType.Name(EventType.SIMPLE_API_WEBSOCKET_AUTHENTICATE)}"
+                        f" {event.context['channel']}"
+                    )
+                    effect_list = [DenyConnection().apply()]
 
             # Don't log anything if a plugin handler didn't actually run.
             if relevant_plugins:
+                # Send the Django request_finished signal
+                request_finished.send(sender=self.__class__)
+
                 log.info(f"Responded to Event {event_name}.")
 
             yield EventResponse(success=True, effects=effect_list)
 
-    async def ReloadPlugins(
+    def ReloadPlugins(
         self, request: ReloadPluginsRequest, context: Any
-    ) -> AsyncGenerator[ReloadPluginsResponse, None]:
+    ) -> Iterable[ReloadPluginsResponse]:
         """This is invoked when we need to reload plugins."""
         log.info("Reloading plugins...")
         try:
-            await publish_message(message={"action": "reload"})
+            publish_message(message={"action": "reload"})
         except ImportError:
             yield ReloadPluginsResponse(success=False)
         else:
             yield ReloadPluginsResponse(success=True)
 
 
-async def synchronize_plugins(run_once: bool = False) -> None:
+STOP_SYNCHRONIZER = threading.Event()
+
+
+def synchronize_plugins(run_once: bool = False) -> None:
     """
     Listen for messages on the pubsub channel that will indicate it is
     necessary to reinstall and reload plugins.
@@ -312,16 +316,10 @@ async def synchronize_plugins(run_once: bool = False) -> None:
 
     _, pubsub = get_client()
 
-    await pubsub.psubscribe(CHANNEL_NAME)
-
-    while True:
-        message = await pubsub.get_message(ignore_subscribe_messages=True, timeout=5.0)
+    pubsub.psubscribe(CHANNEL_NAME)
 
-        await pubsub.check_health()
-
-        if not pubsub.connection.is_connected:  # type: ignore
-            log.info("synchronize_plugins: reconnecting to Redis")
-            await pubsub.connection.connect()  # type: ignore
+    while not STOP_SYNCHRONIZER.is_set():
+        message = pubsub.get_message(ignore_subscribe_messages=True, timeout=5.0)
 
         if message is None:
             continue
@@ -357,21 +355,21 @@ async def synchronize_plugins(run_once: bool = False) -> None:
             break
 
 
-async def synchronize_plugins_and_report_errors() -> None:
+def synchronize_plugins_and_report_errors() -> None:
     """
     Run synchronize_plugins() in perpetuity and report any encountered errors.
     """
     log.info("synchronize_plugins: starting loop...")
 
-    while True:
+    while not STOP_SYNCHRONIZER.is_set():
         try:
-            await synchronize_plugins()
+            synchronize_plugins()
         except Exception as e:
             log.error(f"synchronize_plugins: error: {e}")
             sentry_sdk.capture_exception(e)
 
         # don't crush redis if we're retrying in a tight loop
-        await asyncio.sleep(0.5)
+        sleep(0.5)
 
 
 def validate_effects(effects: list[Effect]) -> list[Effect]:
@@ -434,17 +432,22 @@ def find_modules(base_path: pathlib.Path, prefix: str | None = None) -> list[str
     return modules
 
 
-async def publish_message(message: dict) -> None:
+def publish_message(message: dict) -> None:
     """Publish a message to the pubsub channel."""
     log.info(f'Publishing message to pubsub channel "{CHANNEL_NAME}"')
     client, _ = get_client()
 
-    await client.publish(CHANNEL_NAME, pickle.dumps(message))
+    client.publish(CHANNEL_NAME, pickle.dumps(message))
 
 
 def get_client() -> tuple[redis.Redis, redis.client.PubSub]:
-    """Return an async Redis client and pubsub object."""
-    client = redis.Redis.from_url(REDIS_ENDPOINT)
+    """Return a Redis client and pubsub object."""
+    client = redis.from_url(
+        REDIS_ENDPOINT,
+        retry=Retry(backoff=ExponentialBackoff(), retries=10),
+        retry_on_error=[ConnectionError, TimeoutError, ConnectionResetError],
+        health_check_interval=1,
+    )
     pubsub = client.pubsub()
 
     return client, pubsub
@@ -594,62 +597,41 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
 
     refresh_event_type_map()
 
-    for key in EventType.keys():  # noqa: SIM118
-        value = len(EVENT_HANDLER_MAP[key]) if key in EVENT_HANDLER_MAP else 0
-        statsd_client.gauge("plugins.event_handler_count", value, tags={"event": key})
 
-
-_cleanup_coroutines = []
-
-
-async def serve(specified_plugin_paths: list[str] | None = None) -> None:
-    """Run the server."""
+# NOTE: specified_plugin_paths powers the `canvas run-plugins` command
+def main(specified_plugin_paths: list[str] | None = None) -> None:
+    """Run the server and the synchronize_plugins loop."""
     port = "50051"
 
-    server = grpc.aio.server()
+    executor = ThreadPoolExecutor(max_workers=settings.PLUGIN_RUNNER_MAX_WORKERS)
+    server = grpc.server(thread_pool=executor)
     server.add_insecure_port("127.0.0.1:" + port)
 
     add_PluginRunnerServicer_to_server(PluginRunner(), server)
 
     log.info(f"Starting server, listening on port {port}")
 
-    # Only install plugins if the plugin runner was not started from the CLI
+    # Only install plugins and start the synchronizer thread if the plugin runner was not started
+    # from the CLI
+    synchronizer_thread = threading.Thread(target=synchronize_plugins_and_report_errors)
     if specified_plugin_paths is None:
         install_plugins()
+        STOP_SYNCHRONIZER.clear()
+        synchronizer_thread.start()
 
     load_plugins(specified_plugin_paths)
 
-    await server.start()
-
-    async def server_graceful_shutdown() -> None:
-        log.info("Starting graceful shutdown...")
-        await server.stop(5)
-
-    _cleanup_coroutines.append(server_graceful_shutdown())
-
-    await server.wait_for_termination()
-
-
-# NOTE: specified_plugin_paths powers the `canvas run-plugins` command
-def main(specified_plugin_paths: list[str] | None = None) -> None:
-    """Run the server and the synchronize_plugins loop."""
-    loop = asyncio.new_event_loop()
-
-    asyncio.set_event_loop(loop)
+    server.start()
 
     try:
-        coroutines = [serve(specified_plugin_paths)]
-
-        # Only start the synchronizer if the plugin runner was not started from the CLI
-        if specified_plugin_paths is None:
-            coroutines.append(synchronize_plugins_and_report_errors())
-
-        loop.run_until_complete(asyncio.gather(*coroutines))
+        server.wait_for_termination()
     except KeyboardInterrupt:
         pass
     finally:
-        loop.run_until_complete(*_cleanup_coroutines)
-        loop.close()
+        executor.shutdown(wait=True, cancel_futures=True)
+        if synchronizer_thread.is_alive():
+            STOP_SYNCHRONIZER.set()
+            synchronizer_thread.join()
 
 
 if __name__ == "__main__":

plugin_runner/sandbox.py

@@ -81,6 +81,7 @@ SAFE_EXTERNAL_DUNDER_READ_ATTRIBUTES = {
 }
 
 CANVAS_TOP_LEVEL_MODULES = (
+    "canvas_sdk.caching",
     "canvas_sdk.commands",
     "canvas_sdk.effects",
     "canvas_sdk.events",

protobufs/canvas_generated/messages/effects.proto

@@ -233,6 +233,8 @@ enum EffectType {
   COMMIT_ADJUST_PRESCRIPTION_COMMAND = 1303;
   ENTER_IN_ERROR_ADJUST_PRESCRIPTION_COMMAND = 1304;
 
+  ORIGINATE_CHART_SECTION_REVIEW_COMMAND = 1400;
+
   SHOW_ACTION_BUTTON = 1000;
 
   PATIENT_PORTAL__FORM_RESULT = 2000;
@@ -260,6 +262,9 @@ enum EffectType {
   LAUNCH_MODAL = 3000;
 
   SIMPLE_API_RESPONSE = 4000;
+  SIMPLE_API_WEBSOCKET_ACCEPT = 4001;
+  SIMPLE_API_WEBSOCKET_DENY = 4002;
+  SIMPLE_API_WEBSOCKET_BROADCAST = 4003;
 
   UPDATE_USER = 5000;
 
@@ -268,6 +273,7 @@ enum EffectType {
   CREATE_SCHEDULE_EVENT = 6002;
 
   CREATE_PATIENT = 6003;
+
 }
 
 message Effect {

protobufs/canvas_generated/messages/events.proto

@@ -244,18 +244,12 @@ enum EventType {
   CANCEL_PRESCRIPTION__SELECTED_PRESCRIPTION__PRE_SEARCH = 8012;
   CANCEL_PRESCRIPTION__SELECTED_PRESCRIPTION__POST_SEARCH = 8013;
 
-  // CHART_SECTION_REVIEW_COMMAND__PRE_ORIGINATE = 9000;
-  // CHART_SECTION_REVIEW_COMMAND__POST_ORIGINATE = 9001;
-  // CHART_SECTION_REVIEW_COMMAND__PRE_UPDATE = 9002;
-  // CHART_SECTION_REVIEW_COMMAND__POST_UPDATE = 9003;
-  // CHART_SECTION_REVIEW_COMMAND__PRE_COMMIT = 9004;
-  // CHART_SECTION_REVIEW_COMMAND__POST_COMMIT = 9005;
-  // CHART_SECTION_REVIEW_COMMAND__PRE_DELETE = 9006;
-  // CHART_SECTION_REVIEW_COMMAND__POST_DELETE = 9007;
-  // CHART_SECTION_REVIEW_COMMAND__PRE_ENTER_IN_ERROR = 9008;
-  // CHART_SECTION_REVIEW_COMMAND__POST_ENTER_IN_ERROR = 9009;
-  // CHART_SECTION_REVIEW_COMMAND__PRE_EXECUTE_ACTION = 9010;
-  // CHART_SECTION_REVIEW_COMMAND__POST_EXECUTE_ACTION = 9011;
+  CHART_SECTION_REVIEW_COMMAND__PRE_ORIGINATE = 9000;
+  CHART_SECTION_REVIEW_COMMAND__POST_ORIGINATE = 9001;
+  CHART_SECTION_REVIEW_COMMAND__PRE_ENTER_IN_ERROR = 9002;
+  CHART_SECTION_REVIEW_COMMAND__POST_ENTER_IN_ERROR = 9003;
+  CHART_SECTION_REVIEW_COMMAND__PRE_EXECUTE_ACTION = 9004;
+  CHART_SECTION_REVIEW_COMMAND__POST_EXECUTE_ACTION = 9005;
 
 
   CLIPBOARD_COMMAND__PRE_ORIGINATE = 53000;
@@ -1093,6 +1087,8 @@ enum EventType {
 
   SIMPLE_API_AUTHENTICATE = 130000;
   SIMPLE_API_REQUEST = 130001;
+  SIMPLE_API_WEBSOCKET_AUTHENTICATE = 130002;
+
 }
 
 message Event {

pubsub/pubsub.py

@@ -2,6 +2,9 @@ import os
 from typing import Any
 
 import redis
+from redis.backoff import ExponentialBackoff
+from redis.exceptions import ConnectionError, TimeoutError
+from redis.retry import Retry
 
 REDIS_ENDPOINT = os.getenv("REDIS_ENDPOINT")
 CUSTOMER_IDENTIFIER = os.getenv("CUSTOMER_IDENTIFIER")
@@ -24,7 +27,13 @@ class PubSubBase:
 
     def _create_client(self) -> redis.Redis | None:
         if self.redis_endpoint and self.channel:
-            return redis.Redis.from_url(self.redis_endpoint, decode_responses=True)
+            return redis.Redis.from_url(
+                self.redis_endpoint,
+                decode_responses=True,
+                retry=Retry(backoff=ExponentialBackoff(), retries=10),
+                retry_on_error=[ConnectionError, TimeoutError, ConnectionResetError],
+                health_check_interval=1,
+            )
 
         return None
 

settings.py

@@ -9,6 +9,7 @@ from env_tools import env_to_bool
 load_dotenv()
 
 BASE_DIR = Path(__file__).resolve().parent.resolve()
+FOURTEEN_DAYS = 60 * 60 * 24 * 14
 
 ENV = os.getenv("ENV", "development")
 IS_PRODUCTION = ENV == "production"
@@ -24,6 +25,10 @@ INTEGRATION_TEST_CLIENT_SECRET = os.getenv("INTEGRATION_TEST_CLIENT_SECRET")
 
 GRAPHQL_ENDPOINT = os.getenv("GRAPHQL_ENDPOINT", "http://localhost:8000/plugins-graphql")
 REDIS_ENDPOINT = os.getenv("REDIS_ENDPOINT", f"redis://{APP_NAME}-redis:6379")
+CANVAS_SDK_PLUGINS_CACHE_LOCATION = os.getenv(
+    "CANVAS_SDK_PLUGINS_CACHE_LOCATION", "plugin_io_plugins_cache"
+)
+CANVAS_SDK_CACHE_TIMEOUT_SECONDS = int(os.getenv("CANVAS_SDK_CACHE_TIMEOUT", FOURTEEN_DAYS))
 
 
 METRICS_ENABLED = env_to_bool("PLUGINS_METRICS_ENABLED", not IS_SCRIPT)
@@ -46,12 +51,15 @@ CANVAS_SDK_DB_PASSWORD = os.getenv("CANVAS_SDK_DB_PASSWORD", "app")
 CANVAS_SDK_DB_HOST = os.getenv("CANVAS_SDK_DB_HOST", "home-app-db")
 CANVAS_SDK_DB_PORT = os.getenv("CANVAS_SDK_DB_PORT", "5432")
 
+PLUGIN_RUNNER_MAX_WORKERS = int(os.getenv("PLUGIN_RUNNER_MAX_WORKERS", 5))
+
 if os.getenv("DATABASE_URL"):
     parsed_url = parse.urlparse(os.getenv("DATABASE_URL"))
 
     DATABASES = {
         "default": {
             "ENGINE": "django.db.backends.postgresql",
+            "OPTIONS": {"pool": {"min_size": 2, "max_size": PLUGIN_RUNNER_MAX_WORKERS}},
             "NAME": parsed_url.path[1:],
             "USER": os.getenv("CANVAS_SDK_DATABASE_ROLE"),
             "PASSWORD": os.getenv("CANVAS_SDK_DATABASE_ROLE_PASSWORD"),
@@ -63,6 +71,7 @@ else:
     DATABASES = {
         "default": {
             "ENGINE": "django.db.backends.postgresql",
+            "OPTIONS": {"pool": {"min_size": 2, "max_size": PLUGIN_RUNNER_MAX_WORKERS}},
             "NAME": CANVAS_SDK_DB_NAME,
             "USER": CANVAS_SDK_DB_USERNAME,
             "PASSWORD": CANVAS_SDK_DB_PASSWORD,
@@ -106,3 +115,26 @@ TEMPLATES = [
         "OPTIONS": {},
     },
 ]
+
+
+if IS_TESTING:
+    CACHES = {
+        "default": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        },
+        "plugins": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+            "KEY_PREFIX": CUSTOMER_IDENTIFIER,
+            "LOCATION": "plugins_cache",
+            "TIMEOUT": CANVAS_SDK_CACHE_TIMEOUT_SECONDS,
+        },
+    }
+else:
+    CACHES = {
+        "plugins": {
+            "BACKEND": "django.core.cache.backends.db.DatabaseCache",
+            "KEY_PREFIX": CUSTOMER_IDENTIFIER,
+            "LOCATION": CANVAS_SDK_PLUGINS_CACHE_LOCATION,
+            "TIMEOUT": CANVAS_SDK_CACHE_TIMEOUT_SECONDS,
+        }
+    }