mesh-sandbox 0.1.33__py3-none-any.whl → 1.0.1__py3-none-any.whl

mesh_sandbox/handlers/outbox.py

@@ -9,12 +9,13 @@ from fastapi import BackgroundTasks, Depends, HTTPException, Request
 from fastapi import status as http_status
 from fastapi.responses import JSONResponse
 
-from ..common import EnvConfig, constants, index_of, strtobool
+from ..common import constants, index_of, strtobool
 from ..common.exceptions import MessagingException
 from ..common.fernet import FernetHelper
 from ..common.handler_helpers import get_handler_uri
+from ..common.messaging import Messaging
 from ..common.mex_headers import MexHeaders
-from ..dependencies import get_env_config, get_fernet, get_logger, get_store
+from ..dependencies import get_fernet, get_logger, get_messaging
 from ..models.mailbox import Mailbox
 from ..models.message import (
     Message,
@@ -24,7 +25,6 @@ from ..models.message import (
     MessageStatus,
     MessageType,
 )
-from ..store.base import Store
 from ..views.outbox import (
     get_rich_outbox_view,
     send_message_response,
@@ -60,13 +60,11 @@ class OutboxHandler:
     # pylint: disable=too-many-arguments
     def __init__(
         self,
-        config: EnvConfig = Depends(get_env_config),
-        store: Store = Depends(get_store),
+        messaging: Messaging = Depends(get_messaging),
         fernet: FernetHelper = Depends(get_fernet),
         logger: logging.Logger = Depends(get_logger),
     ):
-        self.config = config
-        self.store = store
+        self.messaging = messaging
         self.fernet = fernet
         self.logger = logger
 
@@ -96,7 +94,7 @@ class OutboxHandler:
                 status_code=http_status.HTTP_417_EXPECTATION_FAILED, detail=constants.ERROR_INVALID_HEADER_CHUNKS
             )
 
-        recipient = await self.store.get_mailbox(mex_headers.mex_to)
+        recipient = await self.messaging.get_mailbox(mex_headers.mex_to)
         if not recipient:
             raise HTTPException(
                 status_code=http_status.HTTP_417_EXPECTATION_FAILED, detail=constants.ERROR_UNREGISTERED_RECIPIENT
@@ -137,7 +135,7 @@ class OutboxHandler:
                 partner_id=mex_headers.mex_partnerid,
                 checksum=mex_headers.mex_content_checksum,
                 encrypted=strtobool(mex_headers.mex_content_encrypted),
-                is_compressed=strtobool(mex_headers.mex_content_compressed),
+                compressed=strtobool(mex_headers.mex_content_compressed),
             ),
         )
 
@@ -145,7 +143,7 @@ class OutboxHandler:
         if len(body) == 0:
             raise HTTPException(status_code=http_status.HTTP_417_EXPECTATION_FAILED, detail="MissingDataFile")
 
-        await self.store.send_message(message, body, background_tasks)
+        await self.messaging.send_message(message=message, body=body, background_tasks=background_tasks)
 
         self.logger.info(
             (
@@ -184,7 +182,7 @@ class OutboxHandler:
                 detail=constants.ERROR_INVALID_HEADER_CHUNKS,
                 message_id=message_id,
             )
-        message: Optional[Message] = await self.store.get_message(message_id)
+        message: Optional[Message] = await self.messaging.get_message(message_id)
 
         if not message:
             raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
@@ -205,12 +203,18 @@ class OutboxHandler:
                 message_id=message_id,
             )
 
-        await self.store.receive_chunk(message, chunk_number, await request.body(), background_tasks)
+        chunk = await request.body()
+
+        await self.messaging.save_chunk(
+            message=message, chunk_number=chunk_number, chunk=chunk, background_tasks=background_tasks
+        )
 
         if chunk_number < message.total_chunks:
             return upload_chunk_response(message, chunk_number, accepts_api_version)
 
-        await self.store.accept_message(message, background_tasks)
+        file_size = await self.messaging.get_file_size(message)
+
+        await self.messaging.accept_message(message=message, file_size=file_size, background_tasks=background_tasks)
 
         return upload_chunk_response(message, chunk_number, accepts_api_version)
 
@@ -228,7 +232,7 @@ class OutboxHandler:
         if continue_from:
             last_key = self.fernet.decode_dict(continue_from)
 
-        messages: list[Message] = cast(list[Message], await self.store.get_outbox(mailbox.mailbox_id))
+        messages: list[Message] = cast(list[Message], await self.messaging.get_outbox(mailbox.mailbox_id))
 
         def message_filter(message: Message) -> bool:
             return message.created_timestamp > from_date

mesh_sandbox/handlers/tracking.py

@@ -4,22 +4,21 @@ from fastapi import Depends, HTTPException
 from fastapi import status as http_status
 from starlette.responses import JSONResponse
 
-from ..common import MESH_MEDIA_TYPES, EnvConfig, exclude_none_json_encoder
-from ..dependencies import get_env_config, get_store
+from ..common import MESH_MEDIA_TYPES, exclude_none_json_encoder
+from ..common.messaging import Messaging
+from ..dependencies import get_messaging
 from ..models.mailbox import Mailbox
 from ..models.message import Message
-from ..store.base import Store
 from ..views.tracking import create_tracking_response
 
 
 class TrackingHandler:
-    def __init__(self, config: EnvConfig = Depends(get_env_config), store: Store = Depends(get_store)):
-        self.config = config
-        self.store = store
+    def __init__(self, messaging: Messaging = Depends(get_messaging)):
+        self.messaging = messaging
 
     async def tracking_by_message_id(self, sender_mailbox: Mailbox, message_id: str, accepts_api_version: int = 1):
 
-        message: Optional[Message] = await self.store.get_message(message_id)
+        message: Optional[Message] = await self.messaging.get_message(message_id)
 
         if not message:
             raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
@@ -28,7 +27,7 @@ class TrackingHandler:
             # intentionally not a 403 (matching spine)
             raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
 
-        sender_outbox = await self.store.get_outbox(sender_mailbox.mailbox_id)
+        sender_outbox = await self.messaging.get_outbox(sender_mailbox.mailbox_id)
         if message.message_id not in [message.message_id for message in sender_outbox]:
             raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
 
@@ -37,7 +36,7 @@ class TrackingHandler:
 
     async def tracking_by_local_id(self, sender_mailbox: Mailbox, local_id: str):
 
-        messages: list[Message] = await self.store.get_by_local_id(sender_mailbox.mailbox_id, local_id)
+        messages: list[Message] = await self.messaging.get_by_local_id(sender_mailbox.mailbox_id, local_id)
 
         if len(messages) == 0:
             raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
@@ -47,7 +46,7 @@ class TrackingHandler:
 
         message = messages[0]
 
-        sender_outbox = await self.store.get_outbox(sender_mailbox.mailbox_id)
+        sender_outbox = await self.messaging.get_outbox(sender_mailbox.mailbox_id)
         if message.message_id not in [message.message_id for message in sender_outbox]:
             raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
 

mesh_sandbox/models/message.py

@@ -40,7 +40,7 @@ class MessageMetadata:
     partner_id: Optional[str] = field(default=None)
     checksum: Optional[str] = field(default=None)
     encrypted: Optional[bool] = field(default=None)
-    is_compressed: Optional[bool] = field(default=None)
+    compressed: Optional[bool] = field(default=None)
     etag: Optional[str] = field(default=None)
     last_modified: Optional[str] = field(default=None)
 

mesh_sandbox/routers/admin.py

@@ -1,8 +1,13 @@
-from fastapi import APIRouter, BackgroundTasks, Depends, status
+from fastapi import APIRouter, BackgroundTasks, Depends, Response, status
 
-from ..dependencies import EnvConfig, get_env_config, normalise_mailbox_id_path
+from ..dependencies import (
+    EnvConfig,
+    get_env_config,
+    normalise_mailbox_id_path,
+    normalise_message_id_path,
+)
 from ..handlers.admin import AdminHandler
-from ..views.admin import PutReportRequest
+from ..views.admin import AddMessageEventRequest, CreateReportRequest
 from .request_logging import RequestLoggingRoute
 
 router = APIRouter(
@@ -75,10 +80,32 @@ async def reset_mailbox(
     status_code=status.HTTP_200_OK,
     response_model_exclude_none=True,
 )
-async def put_report(
-    request: PutReportRequest,
+async def create_report(
+    new_report: CreateReportRequest,
     background_tasks: BackgroundTasks,
     handler: AdminHandler = Depends(AdminHandler),
 ):
-    message = await handler.put_report(request, background_tasks)
+    message = await handler.create_report(new_report, background_tasks)
     return {"message_id": message.message_id}
+
+
+@router.post(
+    "/admin/message/{message_id}/event",
+    summary=f"appends a status event to a given message, if exists. {TESTING_ONLY}",
+    status_code=status.HTTP_200_OK,
+    response_model_exclude_none=True,
+)
+@router.post(
+    "/messageexchange/message/{message_id}/event",
+    summary=f"appends a status event to a given message, if exists. {TESTING_ONLY}",
+    status_code=status.HTTP_200_OK,
+    response_model_exclude_none=True,
+)
+async def add_message_event(
+    new_event: AddMessageEventRequest,
+    background_tasks: BackgroundTasks,
+    message_id: str = Depends(normalise_message_id_path),
+    handler: AdminHandler = Depends(AdminHandler),
+):
+    await handler.add_message_event(message_id, new_event, background_tasks)
+    return Response()

mesh_sandbox/store/base.py

@@ -1,173 +1,59 @@
 import logging
 from abc import ABC, abstractmethod
-from typing import Callable, NamedTuple, Optional
+from typing import Callable, Optional
 
-from fastapi import BackgroundTasks, HTTPException, status
-
-from ..common import EnvConfig, constants, generate_cipher_text
+from ..common import EnvConfig
 from ..models.mailbox import Mailbox
-from ..models.message import Message, MessageStatus
-
-
-class AuthoriseHeaderParts(NamedTuple):
-    scheme: str
-    mailbox_id: str
-    nonce: str
-    nonce_count: str
-    timestamp: str
-    cipher_text: str
-    parts: int
-
-    def get_reasons_invalid(self) -> list[str]:
-        reasons = []
-        if self.parts != 5:
-            reasons.append(f"invalid num header parts: {self.parts}")
-
-        if not self.nonce_count.isdigit():
-            reasons.append("nonce count is not digits")
-
-        if self.scheme not in (MESH_AUTH_SCHEME, ""):
-            reasons.append("invalid auth scheme or mailbox_id contains a space")
-
-        if " " in self.mailbox_id:
-            reasons.append("mailbox_id contains a space")
-
-        return reasons
-
-
-_DEFAULT_PARTS_IF_MISSING = ["" for _ in range(5)]
-MESH_AUTH_SCHEME = "NHSMESH"
-
-
-def try_parse_authorisation_token(auth_token: str) -> Optional[AuthoriseHeaderParts]:
-
-    if not auth_token:
-        return None
-
-    auth_token = auth_token.strip()
-
-    scheme = MESH_AUTH_SCHEME if auth_token.upper().startswith(MESH_AUTH_SCHEME) else ""
-
-    if scheme:
-        auth_token = auth_token[len(MESH_AUTH_SCHEME) + 1 :]
-
-    auth_token_parts = auth_token.split(":")
-
-    num_parts = len(auth_token_parts)
-    auth_token_parts = auth_token_parts + _DEFAULT_PARTS_IF_MISSING
-
-    header_parts = AuthoriseHeaderParts(
-        scheme=scheme,
-        mailbox_id=auth_token_parts[0],
-        nonce=auth_token_parts[1],
-        nonce_count=auth_token_parts[2],
-        timestamp=auth_token_parts[3],
-        cipher_text=auth_token_parts[4],
-        parts=num_parts,
-    )
-
-    return header_parts
+from ..models.message import Message
 
 
 class Store(ABC):
 
-    supports_reset = False
+    readonly = True
 
     def __init__(self, config: EnvConfig, logger: logging.Logger):
         self.config = config
         self.logger = logger
 
-    def get_mailboxes_data_dir(self) -> str:
-        raise NotImplementedError()
-
-    async def reset(self):
-        raise NotImplementedError()
-
-    async def reset_mailbox(self, mailbox_id: str):
-        raise NotImplementedError()
-
     @abstractmethod
     async def get_mailbox(self, mailbox_id: str, accessed: bool = False) -> Optional[Mailbox]:
         pass
 
-    async def _validate_auth_token(self, mailbox_id: str, authorization: str) -> Optional[Mailbox]:
-
-        if self.config.auth_mode == "none":
-            return await self.get_mailbox(mailbox_id, accessed=True)
-
-        authorization = (authorization or "").strip()
-        if not authorization:
-            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_READING_AUTH_HEADER)
-
-        header_parts = try_parse_authorisation_token(authorization)
-        if not header_parts:
-            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_READING_AUTH_HEADER)
-
-        if header_parts.mailbox_id != mailbox_id:
-            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_MAILBOX_TOKEN_MISMATCH)
-
-        if self.config.auth_mode == "canned":
-
-            if header_parts.nonce.upper() != "VALID":
-                raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_INVALID_AUTH_TOKEN)
-            return await self.get_mailbox(mailbox_id, accessed=True)
-
-        if header_parts.get_reasons_invalid():
-            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_READING_AUTH_HEADER)
-
-        mailbox = await self.get_mailbox(mailbox_id, accessed=True)
-
-        if not mailbox:
-            return None
-
-        cypher_text = generate_cipher_text(
-            self.config.shared_key,
-            header_parts.mailbox_id,
-            mailbox.password,
-            header_parts.timestamp,
-            header_parts.nonce,
-            header_parts.nonce_count,
-        )
-
-        if header_parts.cipher_text != cypher_text:
-            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_INVALID_AUTH_TOKEN)
-
-        return mailbox
-
-    async def authorise_mailbox(self, mailbox_id: str, authorization: str) -> Optional[Mailbox]:
-
-        mailbox = await self._validate_auth_token(mailbox_id, authorization)
-
-        if not mailbox:
-            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_NO_MAILBOX_MATCHES)
+    @abstractmethod
+    async def get_message(self, message_id: str) -> Optional[Message]:
+        pass
 
-        return mailbox
+    @abstractmethod
+    async def save_message(self, message: Message):
+        pass
 
     @abstractmethod
-    async def send_message(self, message: Message, body: bytes, background_tasks: BackgroundTasks):
+    async def get_chunk(self, message: Message, chunk_number: int) -> Optional[bytes]:
         pass
 
     @abstractmethod
-    async def receive_chunk(self, message: Message, chunk_number: int, chunk: bytes, background_tasks: BackgroundTasks):
+    async def save_chunk(self, message: Message, chunk_number: int, chunk: bytes):
         pass
 
     @abstractmethod
-    async def accept_message(self, message: Message, background_tasks: BackgroundTasks):
+    async def add_to_outbox(self, message: Message):
         pass
 
     @abstractmethod
-    async def acknowledge_message(self, message: Message, background_tasks: BackgroundTasks):
+    async def add_to_inbox(self, message: Message):
         pass
 
     @abstractmethod
-    async def get_message(self, message_id: str) -> Optional[Message]:
+    async def get_file_size(self, message: Message) -> int:
         pass
 
-    async def get_accepted_inbox_messages(self, mailbox_id: str) -> list[Message]:
-        def accepted_messages(msg: Message) -> bool:
-            return msg.status == MessageStatus.ACCEPTED
+    @abstractmethod
+    async def reset(self):
+        pass
 
-        return await self.get_inbox_messages(mailbox_id, accepted_messages)
+    @abstractmethod
+    async def reset_mailbox(self, mailbox_id: str):
+        pass
 
     @abstractmethod
     async def get_inbox_messages(
@@ -183,10 +69,6 @@ class Store(ABC):
     async def get_by_local_id(self, mailbox_id: str, local_id: str) -> list[Message]:
         pass
 
-    @abstractmethod
-    async def retrieve_chunk(self, message: Message, chunk_number: int) -> Optional[bytes]:
-        pass
-
     @abstractmethod
     async def lookup_by_ods_code_and_workflow_id(self, ods_code: str, workflow_id: str) -> list[Mailbox]:
         pass

mesh_sandbox/store/canned_store.py

@@ -1,8 +1,6 @@
-import asyncio
 import json
 import logging
 import os
-import threading
 from collections import defaultdict
 from datetime import datetime
 from json import JSONDecodeError
@@ -10,7 +8,6 @@ from typing import Callable, Optional, cast
 from weakref import WeakValueDictionary
 
 from dateutil.relativedelta import relativedelta
-from fastapi import BackgroundTasks
 
 from ..common import EnvConfig
 from ..models.mailbox import Mailbox
@@ -20,6 +17,10 @@ from .base import Store
 from .serialisation import deserialise_model
 
 
+def _accepted_messages(msg: Message) -> bool:
+    return msg.status == MessageStatus.ACCEPTED
+
+
 class CannedStore(Store):
     """
     pre canned messages or mailboxes not editable
@@ -31,8 +32,6 @@ class CannedStore(Store):
         self._config = config
         self._canned_data_dir = os.path.join(os.path.dirname(__file__), "data")
         self._mailboxes_data_dir = self.get_mailboxes_data_dir()
-        self._sync_lock = threading.Lock()
-        self._lock: Optional[asyncio.Lock] = None
         self._filter_expired = filter_expired
         super().__init__(self._config, logger)
 
@@ -54,18 +53,6 @@ class CannedStore(Store):
         self._fill_boxes()
         self.messages = cast(dict[str, Message], WeakValueDictionary(self.messages))
 
-    @property
-    def lock(self):
-
-        if self._lock is not None:
-            return self._lock
-
-        with self._sync_lock:
-            if self._lock is not None:
-                return self._lock
-            self._lock = asyncio.Lock()
-            return self._lock
-
     def _fill_boxes(self):
         for message in self.messages.values():
             if message.sender.mailbox_id and message.sender.mailbox_id in self.mailboxes:
@@ -205,25 +192,40 @@ class CannedStore(Store):
         if not mailbox:
             return None
 
-        mailbox.inbox_count = len(await self.get_accepted_inbox_messages(mailbox_id))
+        mailbox.inbox_count = len(await self.get_inbox_messages(mailbox_id, _accepted_messages))
         if accessed:
             mailbox.last_accessed = datetime.utcnow()
         return mailbox
 
-    async def send_message(self, message: Message, body: bytes, background_tasks: BackgroundTasks):
-        pass
+    async def get_message(self, message_id: str) -> Optional[Message]:
+        return self.messages.get(message_id)
 
-    async def accept_message(self, message: Message, background_tasks: BackgroundTasks):
-        pass
+    async def get_file_size(self, message: Message) -> int:
+        return sum(len(chunk or b"") for chunk in self.chunks.get(message.message_id, []))
 
-    async def acknowledge_message(self, message: Message, background_tasks: BackgroundTasks):
-        pass
+    async def add_to_outbox(self, message: Message):
+        """does nothing on this readonly store..."""
 
-    async def receive_chunk(self, message: Message, chunk_number: int, chunk: bytes, background_tasks: BackgroundTasks):
-        pass
+    async def add_to_inbox(self, message: Message):
+        """does nothing on this readonly store..."""
 
-    async def get_message(self, message_id: str) -> Optional[Message]:
-        return self.messages.get(message_id)
+    async def save_message(self, message: Message):
+        raise NotImplementedError()
+
+    async def get_chunk(self, message: Message, chunk_number: int) -> Optional[bytes]:
+        parts = self.chunks.get(message.message_id, [])
+        if not parts or len(parts) < chunk_number:
+            return None
+        return parts[chunk_number - 1]
+
+    async def save_chunk(self, message: Message, chunk_number: int, chunk: bytes):
+        raise NotImplementedError()
+
+    async def reset(self):
+        raise NotImplementedError()
+
+    async def reset_mailbox(self, mailbox_id: str):
+        raise NotImplementedError()
 
     async def get_inbox_messages(
         self, mailbox_id: str, predicate: Optional[Callable[[Message], bool]] = None
@@ -240,12 +242,6 @@ class CannedStore(Store):
     async def get_by_local_id(self, mailbox_id: str, local_id: str) -> list[Message]:
         return self.local_ids.get(mailbox_id, {}).get(local_id, [])
 
-    async def retrieve_chunk(self, message: Message, chunk_number: int) -> Optional[bytes]:
-        parts = self.chunks.get(message.message_id, [])
-        if not parts or len(parts) < chunk_number:
-            return None
-        return parts[chunk_number - 1]
-
     async def lookup_by_ods_code_and_workflow_id(self, ods_code: str, workflow_id: str) -> list[Mailbox]:
         return self.endpoints.get(f"{ods_code}/{workflow_id}", [])
 

mesh_sandbox/store/file_store.py

@@ -17,16 +17,17 @@ class FileStore(MemoryStore):
     def get_mailboxes_data_dir(self) -> str:
         return self._config.mailboxes_dir
 
-    async def _get_file_size(self, message: Message) -> int:
-        size = 0
-        if message.total_chunks < 1:
-            return 0
+    def message_path(self, message: Message) -> str:
+        return os.path.join(self._mailboxes_data_dir, message.recipient.mailbox_id, "in", message.message_id)
 
-        message_dir = self.message_path(message)
-        for chunk_no in range(message.total_chunks):
-            stat = os.stat(f"{message_dir}/{chunk_no+1}")
-            size += stat.st_size
-        return size
+    def chunk_path(self, message: Message, chunk_number: int) -> str:
+        return os.path.join(
+            self._mailboxes_data_dir, message.recipient.mailbox_id, "in", message.message_id, str(chunk_number)
+        )
+
+    def _load_chunks(self) -> dict[str, list[Optional[bytes]]]:
+        """overrides canned store default data load"""
+        return defaultdict(list)
 
     async def save_message(self, message: Message):
         await super().save_message(message)
@@ -35,18 +36,6 @@ class FileStore(MemoryStore):
         with open(message_json_path, "w+", encoding="utf-8") as f:
             json.dump(serialise_model(message), f)
 
-    def inbox_path(self, mailbox_id: str) -> str:
-        return os.path.join(self._mailboxes_data_dir, mailbox_id, "in")
-
-    def message_path(self, message: Message) -> str:
-        return os.path.join(self.inbox_path(message.recipient.mailbox_id), message.message_id)
-
-    def chunk_path(self, message: Message, chunk_number: int) -> str:
-        return os.path.join(self.message_path(message), str(chunk_number))
-
-    def _load_chunks(self) -> dict[str, list[Optional[bytes]]]:
-        return defaultdict(list)
-
     async def save_chunk(self, message: Message, chunk_number: int, chunk: Optional[bytes]):
         chunk_path = self.chunk_path(message, chunk_number)
         if chunk is None:
@@ -59,7 +48,7 @@ class FileStore(MemoryStore):
         with open(chunk_path, "wb+") as f:
             f.write(chunk)
 
-    async def retrieve_chunk(self, message: Message, chunk_number: int) -> Optional[bytes]:
+    async def get_chunk(self, message: Message, chunk_number: int) -> Optional[bytes]:
 
         chunk_path = self.chunk_path(message, chunk_number)
         if not os.path.exists(chunk_path):
@@ -67,3 +56,14 @@ class FileStore(MemoryStore):
 
         with open(chunk_path, "rb") as f:
             return f.read()
+
+    async def get_file_size(self, message: Message) -> int:
+        size = 0
+        if message.total_chunks < 1:
+            return 0
+
+        message_dir = self.message_path(message)
+        for chunk_no in range(message.total_chunks):
+            stat = os.stat(f"{message_dir}/{chunk_no+1}")
+            size += stat.st_size
+        return size