appmesh 1.5.6__py3-none-any.whl → 1.5.8__py3-none-any.whl

appmesh/__init__.py

@@ -14,5 +14,7 @@ Example:
 from .app import App
 from .http_client import AppMeshClient
 from .tcp_client import AppMeshClientTCP
+from .http_server import AppMeshServer
+from .tcp_server import AppMeshServerTCP
 
-__all__ = ["App", "AppMeshClient", "AppMeshClientTCP"]
+__all__ = ["App", "AppMeshClient", "AppMeshClientTCP", "AppMeshServer", "AppMeshServerTCP"]

appmesh/http_client.py

@@ -34,10 +34,10 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         - Install the App Mesh Python package:
             python3 -m pip install --upgrade appmesh
         - Import the client module:
-            from appmesh import appmesh_client
+            from appmesh import AppMeshClient
 
     Example:
-        client = appmesh_client.AppMeshClient()
+        client = AppMeshClient()
         client.login("your-name", "your-password")
         response = client.app_view(app_name='ping')
 
@@ -152,7 +152,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
                 which may be necessary in environments requiring specific CA chains that differ from the default system CAs.
                 To use both a custom CA and the system's default CAs, create a combined CA bundle by concatenating them into a single file. (e.g., `cat custom_ca.pem /etc/ssl/certs/ca-certificates.crt > combined_ca.pem`).
 
-            ssl_client_cert (Union[str, Tuple[str, str]], optional): Path to the SSL client certificate and key. Can be:
+            rest_ssl_client_cert (Union[str, Tuple[str, str]], optional): Path to the SSL client certificate and key. Can be:
                 - `str`: A path to a single PEM file containing both the client certificate and private key.
                 - `tuple`: A pair of paths (`cert_file`, `key_file`), where `cert_file` is the client certificate file path and `key_file` is the private key file path.
 
@@ -1209,7 +1209,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         else:
             raise TypeError(f"Invalid timeout type: {str(timeout)}")
 
-    def run_task(self, app_name: str, data: str) -> str:
+    def run_task(self, app_name: str, data: str, timeout: int = 300) -> str:
         """Client send an invocation message to a running App Mesh application and wait for result.
 
         This method posts the provided `data` to the App Mesh service which will
@@ -1218,64 +1218,23 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         Args:
             app_name (str): Name of the target application (as registered in App Mesh).
             data (str): Payload to deliver to the application. Typically a string.
+            timeout (int): Maximum time in seconds to wait for a response from the application. Defaults to 60 seconds.
 
         Returns:
             str: The HTTP response body returned by the remote application/service.
         """
-        resp = self._request_http(AppMeshClient.Method.POST, path=f"/appmesh/app/{app_name}/task", body=data)
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-
-        return resp.text
-
-    def task_fetch(self) -> str:
-        """Fetch invocation data in the currently running App Mesh application process.
-
-        This helper is intended to be called by an application process running from App Mesh
-        to obtain the payload that a client pushed to it. It reads two required
-        environment variables set by the runtime:
-
-        - APP_MESH_PROCESS_ID: the process UUID for this invocation
-        - APP_MESH_APPLICATION_NAME: the application name
-
-        Returns:
-            str: The payload provided by the client as returned by the service.
-        """
-        process_uuid = os.environ["APP_MESH_PROCESS_ID"]
-        app_name = os.environ["APP_MESH_APPLICATION_NAME"]
-        while True:
-            resp = self._request_http(
-                AppMeshClient.Method.GET,
-                path=f"/appmesh/app/{app_name}/task",
-                query={"process_uuid": process_uuid},
-            )
-            if resp.status_code != HTTPStatus.OK:
-                time.sleep(0.1)
-                continue
-
-            return resp.text
-
-    def task_return(self, result: str) -> None:
-        """Return the result of a server-side invocation back to the original client.
-
-        The method posts the `result` associated with the current process UUID so
-        the invoking client can retrieve it. The same environment variables used by
-        `task_fetch` are required to identify the target process.
-
-        Args:
-            result (str): Result payload to be delivered back to the client.
-        """
-        process_uuid = os.environ["APP_MESH_PROCESS_ID"]
-        app_name = os.environ["APP_MESH_APPLICATION_NAME"]
+        path = f"/appmesh/app/{app_name}/task"
         resp = self._request_http(
-            AppMeshClient.Method.PUT,
-            path=f"/appmesh/app/{app_name}/task",
-            query={"process_uuid": process_uuid},
-            body=result,
+            AppMeshClient.Method.POST,
+            path=path,
+            body=data,
+            query={"timeout": str(timeout)},
         )
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
 
+        return resp.text
+
     def run_app_async(
         self,
         app: Union[App, str],
@@ -1369,7 +1328,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         Args:
             app (Union[App, str]): An App instance or a shell command string.
                 If a string, an App instance is created as:
-                `appmesh_client.App({"command": "<command_string>", "shell": True})`
+                `appmesh.App({"command": "<command_string>", "shell": True})`
             stdout_print (bool, optional): If True, prints the remote stdout locally. Defaults to True.
             max_time_seconds (Union[int, str], optional): Maximum runtime for the remote process.
                 Supports ISO 8601 duration format (e.g., 'P1Y2M3DT4H5M6S', 'P5W'). Defaults to DEFAULT_RUN_APP_TIMEOUT_SECONDS.

appmesh/http_server.py

@@ -0,0 +1,118 @@
+# TCP-based App Mesh Server
+# pylint: disable=line-too-long,broad-exception-raised,broad-exception-caught,import-outside-toplevel,protected-access
+
+import abc
+import logging
+import os
+import time
+from typing import Optional, Tuple
+from http import HTTPStatus
+from .http_client import AppMeshClient
+
+logger = logging.getLogger(__name__)
+
+
+class AppMeshServer(metaclass=abc.ABCMeta):
+    """
+    Server SDK for App Mesh application interacting with the local App Mesh REST service over HTTPS.
+
+    Build-in runtime environment variables required:
+      - APP_MESH_PROCESS_ID
+      - APP_MESH_APPLICATION_NAME
+
+    Methods:
+        - task_fetch(): fetch invocation payloads
+        - task_return(): return results to the invoking client
+
+    Example:
+        context = appmesh.AppMeshServer()
+        payload = context.task_fetch()
+        result = do_something_with(payload)
+        context.task_return(result)
+    """
+
+    def __init__(
+        self,
+        rest_url: str = "https://127.0.0.1:6060",
+        rest_ssl_verify=AppMeshClient.DEFAULT_SSL_CA_CERT_PATH if os.path.exists(AppMeshClient.DEFAULT_SSL_CA_CERT_PATH) else False,
+        rest_ssl_client_cert=(
+            (
+                AppMeshClient.DEFAULT_SSL_CLIENT_CERT_PATH,
+                AppMeshClient.DEFAULT_SSL_CLIENT_KEY_PATH,
+            )
+            if os.path.exists(AppMeshClient.DEFAULT_SSL_CLIENT_CERT_PATH)
+            else None
+        ),
+        rest_timeout: Tuple[float, float] = (60, 300),
+        *,
+        logger_: Optional[logging.Logger] = None,
+    ):
+        """Initialize an App Mesh HTTP client for interacting with the App Mesh server via secure HTTPS.
+
+        Args:
+            follows the same parameters as `AppMeshClient`.
+        """
+        self._client = AppMeshClient(rest_url, rest_ssl_verify, rest_ssl_client_cert, rest_timeout)
+        self._logger = logger_ or logger
+
+    @staticmethod
+    def _get_runtime_env() -> Tuple[str, str]:
+        """Read and validate required runtime environment variables."""
+        process_id = os.getenv("APP_MESH_PROCESS_ID")
+        app_name = os.getenv("APP_MESH_APPLICATION_NAME")
+        if not process_id:
+            raise Exception("Missing environment variable: APP_MESH_PROCESS_ID. This must be set by App Mesh service.")
+        if not app_name:
+            raise Exception("Missing environment variable: APP_MESH_APPLICATION_NAME. This must be set by App Mesh service.")
+        return process_id, app_name
+
+    def task_fetch(self) -> str:
+        """Fetch task data in the currently running App Mesh application process.
+
+        Used by App Mesh application process to obtain the payload from App Mesh service
+        that a client pushed to it.
+
+
+        Returns:
+            str: The payload provided by the client as returned by the service.
+        """
+        process_id, app_name = self._get_runtime_env()
+        path = f"/appmesh/app/{app_name}/task"
+
+        while True:
+            resp = self._client._request_http(
+                AppMeshClient.Method.GET,
+                path=path,
+                query={"process_uuid": process_id},
+            )
+
+            if resp.status_code != HTTPStatus.OK:
+                self._logger.warning(f"task_fetch failed with status {resp.status_code}: {resp.text}, retrying...")
+                time.sleep(0.1)
+                continue
+
+            return resp.text
+
+    def task_return(self, result: str) -> None:
+        """Return the result of a server-side invocation back to the original client.
+
+        Used by App Mesh application process to posts the `result` to App Mesh service
+        after processed payload data so the invoking client can retrieve it.
+
+        Args:
+            result (str): Result payload to be delivered back to the client.
+        """
+        process_id, app_name = self._get_runtime_env()
+        path = f"/appmesh/app/{app_name}/task"
+
+        resp = self._client._request_http(
+            AppMeshClient.Method.PUT,
+            path=path,
+            query={"process_uuid": process_id},
+            body=result,
+        )
+
+        if resp.status_code != HTTPStatus.OK:
+            msg = f"task_return failed with status {resp.status_code}: {resp.text}"
+            self._logger.error(msg)
+            raise Exception(msg)

appmesh/tcp_server.py

@@ -0,0 +1,35 @@
+# TCP-based App Mesh Server
+# pylint: disable=line-too-long,broad-exception-raised,broad-exception-caught,import-outside-toplevel,protected-access
+
+import os
+import logging
+from typing import Optional, Tuple
+from .http_client import AppMeshClient
+from .tcp_client import AppMeshClientTCP
+from .http_server import AppMeshServer
+
+logger = logging.getLogger(__name__)
+
+
+class AppMeshServerTCP(AppMeshServer):
+    """
+    Server SDK for interacting with the local App Mesh service over TCP (TLS).
+    """
+
+    def __init__(
+        self,
+        rest_ssl_verify=AppMeshClient.DEFAULT_SSL_CA_CERT_PATH if os.path.exists(AppMeshClient.DEFAULT_SSL_CA_CERT_PATH) else False,
+        rest_ssl_client_cert=None,
+        tcp_address: Tuple[str, int] = ("localhost", 6059),
+        *,
+        logger_: Optional[logging.Logger] = None,
+    ):
+        """Construct an App Mesh server TCP object to communicate securely with an App Mesh server over TLS.
+
+        Args:
+            follows the same parameters as `AppMeshClientTCP`.
+        """
+        # Deliberately avoid calling super().__init__ to inject a TCP client while keeping the same public API.
+        object.__init__(self)
+        self._client = AppMeshClientTCP(rest_ssl_verify=rest_ssl_verify, rest_ssl_client_cert=rest_ssl_client_cert, tcp_address=tcp_address)
+        self._logger = logger_ or logger

{appmesh-1.5.6.dist-info → appmesh-1.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appmesh
-Version: 1.5.6
+Version: 1.5.8
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi

{appmesh-1.5.6.dist-info → appmesh-1.5.8.dist-info}/RECORD

@@ -1,13 +1,15 @@
-appmesh/__init__.py,sha256=vgiSdMzlzDwgHxBMDoFaKWb77g2nJVciRf4z_ssAlwE,431
+appmesh/__init__.py,sha256=fQHuLWBaMZmbs5i5AV4KIXhv9YlIWkhYIv9WSLGNLm4,548
 appmesh/app.py,sha256=9Q-SOOej-MH13BU5Dv2iTa-p-sECCJQp6ZX9DjWWmwE,10526
 appmesh/app_output.py,sha256=JK_TMKgjvaw4n_ys_vmN5S4MyWVZpmD7NlKz_UyMIM8,1015
 appmesh/app_run.py,sha256=9ISKGZ3k3kkbQvSsPfRfkOLqD9xhbqNOM7ork9F4w9c,1712
 appmesh/appmesh_client.py,sha256=0ltkqHZUq094gKneYmC0bEZCP0X9kHTp9fccKdWFWP0,339
-appmesh/http_client.py,sha256=9PUGuo2YCv1KYVeDhYxFegeEGSBqoSim3UK9OJHEsnU,59143
+appmesh/http_client.py,sha256=j7OIHiRKeFs8o4zTT-tOcCwaYfeACzL86lmz1E2UP_M,57437
+appmesh/http_server.py,sha256=HOE6DMzmo6FR16aSUQjSDLua_Q8o8807MNhPaAt-abs,4264
 appmesh/tcp_client.py,sha256=yi0n2NpBBCA-JHYWQPPE_1euE7Oz6JHBe1op7lypTXY,10999
 appmesh/tcp_messages.py,sha256=w1Kehz_aX4X2CYAUsy9mFVJRhxnLQwwc6L58W4YkQqs,969
+appmesh/tcp_server.py,sha256=42YW3-hU82AwhE32DF4Gn6GucSg5qNJavP7xGSrpBVc,1353
 appmesh/tcp_transport.py,sha256=-XDTQbsKL3yCbguHeW2jNqXpYgnCyHsH4rwcaJ46AS8,8645
-appmesh-1.5.6.dist-info/METADATA,sha256=k241QBT0-fxg36SOh4Y3qHLkYwTkjUgXPRJxYHZ38oY,11768
-appmesh-1.5.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-appmesh-1.5.6.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
-appmesh-1.5.6.dist-info/RECORD,,
+appmesh-1.5.8.dist-info/METADATA,sha256=iSbvWio_TfOfwA-xXU4ZsSWENhl-FDoAUkJrSZRyaz4,11768
+appmesh-1.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+appmesh-1.5.8.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
+appmesh-1.5.8.dist-info/RECORD,,