appmesh 1.6.1__py3-none-any.whl → 1.6.3__py3-none-any.whl

appmesh/__init__.py

@@ -9,10 +9,40 @@ Example:
     client = AppMeshClient()
 """
 
-from .app import App
-from .client_http import AppMeshClient
-from .client_tcp import AppMeshClientTCP
-from .server_http import AppMeshServer
-from .server_tcp import AppMeshServerTCP
+import sys
+from types import ModuleType
 
-__all__ = ["App", "AppMeshClient", "AppMeshClientTCP", "AppMeshServer", "AppMeshServerTCP"]
+__all__ = ["App", "AppMeshClient", "AppMeshClientTCP", "AppMeshClientOAuth", "AppMeshServer", "AppMeshServerTCP"]
+
+_LAZY_IMPORTS = {
+    "App": ("app", "App"),  # from .app import App
+    "AppMeshClient": ("client_http", "AppMeshClient"),  # from .client_http import AppMeshClient
+    "AppMeshClientTCP": ("client_tcp", "AppMeshClientTCP"),  # from .client_tcp import AppMeshClientTCP
+    "AppMeshClientOAuth": ("client_http_oauth", "AppMeshClientOAuth"),  # from .client_http_oauth import AppMeshClientOAuth
+    "AppMeshServer": ("server_http", "AppMeshServer"),  # from .server_http import AppMeshServer
+    "AppMeshServerTCP": ("server_tcp", "AppMeshServerTCP"),  # from .server_tcp import AppMeshServerTCP
+}
+
+
+def _lazy_import(name):
+    """Helper function for lazy importing."""
+    if name in _LAZY_IMPORTS:
+        module_name, attr_name = _LAZY_IMPORTS[name]
+        module = __import__(f"{__name__}.{module_name}", fromlist=[attr_name])
+        return getattr(module, attr_name)
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+if sys.version_info >= (3, 7):
+
+    def __getattr__(name):
+        return _lazy_import(name)
+
+else:
+    # Python 3.6 compatibility
+    class _LazyModule(ModuleType):
+        def __getattr__(self, name):
+            return _lazy_import(name)
+
+    sys.modules[__name__] = _LazyModule(__name__)
+    sys.modules[__name__].__dict__.update(globals())

appmesh/app.py

@@ -5,7 +5,7 @@ import json
 import copy
 
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Any
 from enum import Enum, unique
 
 # pylint: disable=line-too-long
@@ -39,7 +39,7 @@ class App:
         return None
 
     @staticmethod
-    def _get_native_item(data: dict, key: str) -> Optional[object]:
+    def _get_native_item(data: dict, key: str) -> Optional[Any]:
         """Retrieve a deep copy of a value from a dictionary by key, if it exists."""
         return copy.deepcopy(data[key]) if (data and key in data and data[key] is not None) else None
 

appmesh/app_run.py

@@ -2,6 +2,7 @@
 """Application run object for remote application execution."""
 
 from contextlib import contextmanager
+from typing import Optional
 
 # pylint: disable=line-too-long
 
@@ -42,7 +43,7 @@ class AppRun:
         finally:
             self._client.forward_to = original_value
 
-    def wait(self, stdout_print: bool = True, timeout: int = 0) -> int:
+    def wait(self, stdout_print: bool = True, timeout: int = 0) -> Optional[int]:
         """Wait for the asynchronous run to complete.
 
         Args:

appmesh/appmesh_client.py

@@ -5,4 +5,6 @@
 # AppMeshClient, App, and AppOutput classes. The updated implementation can be found
 # in client_http.py, where these classes are now primarily maintained.
 
-from .client_http import AppMeshClient, App, AppOutput
+from .client_http import AppMeshClient
+from .app import App
+from .app_output import AppOutput

appmesh/client_http.py

@@ -3,8 +3,10 @@
 import abc
 import base64
 import json
+import locale
 import logging
 import os
+import sys
 import time
 from datetime import datetime
 from enum import Enum, unique
@@ -20,6 +22,64 @@ from .app_run import AppRun
 from .app_output import AppOutput
 
 
+class EncodingResponse:
+    """Wrapper for requests.Response that handles encoding conversion on Windows."""
+
+    def __init__(self, response: requests.Response):
+        self._response = response
+        self._converted_text = None
+        self._should_convert = False
+
+        # Check if we need to convert encoding on Windows
+        if sys.platform == "win32":
+            content_type = response.headers.get("Content-Type", "").lower()
+            if response.status_code == HTTPStatus.OK and "text/plain" in content_type and "utf-8" in content_type:
+                try:
+                    local_encoding = locale.getpreferredencoding()
+
+                    if local_encoding.lower() not in ["utf-8", "utf8"]:
+                        # Ensure response is decoded as UTF-8 first
+                        response.encoding = "utf-8"
+                        utf8_text = response.text  # This gives us proper Unicode string
+
+                        # Convert Unicode to local encoding, then back to Unicode
+                        # This simulates how text would appear in local encoding
+                        try:
+                            local_bytes = utf8_text.encode(local_encoding, errors="replace")
+                            self._converted_text = local_bytes.decode(local_encoding)
+                            self._should_convert = True
+                        except (UnicodeEncodeError, LookupError):
+                            # If local encoding can't handle the characters, fall back to UTF-8
+                            self._converted_text = utf8_text
+                            self._should_convert = True
+
+                except (UnicodeError, LookupError):
+                    # If any conversion fails, keep original UTF-8
+                    response.encoding = "utf-8"
+
+    @property
+    def text(self):
+        """Return converted text if needed, otherwise original text."""
+        if self._should_convert and self._converted_text is not None:
+            return self._converted_text
+        # return the original text from _response without modification
+        return self._response.text
+
+    def __getattr__(self, name):
+        """Dynamically delegate attribute access to the original response"""
+        return getattr(self._response, name)
+
+    def __dir__(self):
+        """Optional: allow dir() to show attributes of both wrapper and response"""
+        return list(set(dir(self._response) + list(self.__dict__.keys())))
+
+    @property
+    def __class__(self):
+        """Optional: allow isinstance checks for requests.Response"""
+        # Pretend to be a requests.Response for isinstance checks
+        return requests.Response
+
+
 class AppMeshClient(metaclass=abc.ABCMeta):
     """
     Client SDK for interacting with the App Mesh service via REST API.
@@ -107,7 +167,8 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     DURATION_ONE_WEEK_ISO = "P1W"
     DURATION_TWO_DAYS_ISO = "P2D"
     DURATION_TWO_DAYS_HALF_ISO = "P2DT12H"
-    TOKEN_REFRESH_INTERVAL = 60
+    TOKEN_REFRESH_INTERVAL = 300  # 5 min to refresh token
+    TOKEN_REFRESH_OFFSET = 30  # 30s before token expire to refresh token
 
     # Platform-aware default SSL paths
     _DEFAULT_SSL_DIR = "c:/local/appmesh/ssl" if os.name == "nt" else "/opt/appmesh/ssl"
@@ -140,7 +201,6 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         rest_ssl_client_cert=(DEFAULT_SSL_CLIENT_CERT_PATH, DEFAULT_SSL_CLIENT_KEY_PATH) if os.path.exists(DEFAULT_SSL_CLIENT_CERT_PATH) else None,
         rest_timeout=(60, 300),
         jwt_token=None,
-        oauth2=None,
         auto_refresh_token=False,
     ):
         """Initialize an App Mesh HTTP client for interacting with the App Mesh server via secure HTTPS.
@@ -163,15 +223,6 @@ class AppMeshClient(metaclass=abc.ABCMeta):
                 The default is `(60, 300)`, where `60` seconds is the maximum time to establish a connection and `300` seconds for the maximum read duration.
 
             jwt_token (str, optional): JWT token for API authentication, used in headers to authorize requests where required.
-
-            oauth2 (Dict[str, Any], optional): Keycloak configuration for oauth2 authentication:
-                - server_url: Keycloak server URL (e.g. "https://keycloak.example.com/auth/")
-                - realm: Keycloak realm
-                - client_id: Keycloak client ID
-                - client_secret: Keycloak client secret (optional)
-                Using this parameter enables Keycloak integration for authentication. The 'python-keycloak' package
-                will be imported on-demand only when this parameter is, make sure package is installed (pip3 install python-keycloak).
-
             auto_refresh_token (bool, optional): Enable automatic token refresh before expiration.
                 When enabled, a background timer will monitor token expiration and attempt to refresh
                 the token before it expires. This works with both native App Mesh tokens and Keycloak tokens.
@@ -185,29 +236,10 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         self.rest_timeout = rest_timeout
         self._forward_to = None
 
-        # Keycloak integration
-        self._keycloak_openid = None
-        if oauth2:
-            try:
-                from keycloak import KeycloakOpenID
-
-                self._keycloak_openid = KeycloakOpenID(
-                    server_url=oauth2.get("auth_server_url"),
-                    client_id=oauth2.get("client_id"),
-                    realm_name=oauth2.get("realm"),
-                    client_secret_key=oauth2.get("client_secret"),
-                    verify=self.ssl_verify,
-                    timeout=rest_timeout,
-                )
-            except ImportError:
-                logging.error("Keycloak package not installed. Install with: pip install python-keycloak")
-                raise Exception("Keycloak integration requested but python-keycloak package is not installed")
-
         # Token auto-refresh
         self._token_refresh_timer = None
         self._auto_refresh_token = auto_refresh_token
-        if auto_refresh_token and jwt_token:
-            self._schedule_token_refresh()
+        self.jwt_token = jwt_token  # Set property last after all dependencies are initialized
 
     @staticmethod
     def _ensure_logging_configured():
@@ -215,6 +247,9 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         if not logging.root.handlers:
             logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
 
+    def _get_access_token(self) -> str:
+        return self.jwt_token
+
     def _check_and_refresh_token(self):
         """Check and refresh token if needed, then schedule next check.
 
@@ -232,12 +267,12 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         # Check token expiration directly from JWT
         try:
-            decoded_token = jwt.decode(self.jwt_token if isinstance(self.jwt_token, str) else self.jwt_token.get("access_token", ""), options={"verify_signature": False})
+            decoded_token = jwt.decode(self._get_access_token(), options={"verify_signature": False})
             expiry = decoded_token.get("exp", 0)
             current_time = time.time()
             time_to_expiry = expiry - current_time
             # Refresh if token expires within 5 minutes
-            needs_refresh = time_to_expiry < 300
+            needs_refresh = time_to_expiry < self.TOKEN_REFRESH_OFFSET
         except Exception as e:
             logging.debug("Failed to parse JWT token for expiration check: %s", str(e))
 
@@ -277,11 +312,11 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
             # Calculate more precise check time if expiry is known
             if time_to_expiry is not None:
-                if time_to_expiry <= 300:  # Expires within 5 minutes
+                if time_to_expiry <= self.TOKEN_REFRESH_OFFSET:  # Expires within 5 minutes
                     check_interval = 1  # Almost immediate refresh
                 else:
                     # Check at earlier of 5 minutes before expiry or regular interval
-                    check_interval = min(time_to_expiry - 300, self.TOKEN_REFRESH_INTERVAL)
+                    check_interval = min(time_to_expiry - self.TOKEN_REFRESH_OFFSET, self.TOKEN_REFRESH_INTERVAL)
 
             # Create timer to execute refresh check
             self._token_refresh_timer = threading.Timer(check_interval, self._check_and_refresh_token)
@@ -303,14 +338,9 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             self.session.close()
             self.session = None
 
-        # Logout from Keycloak if needed
-        if hasattr(self, "_keycloak_openid") and self._keycloak_openid and hasattr(self, "_jwt_token") and self._jwt_token and isinstance(self._jwt_token, dict) and "refresh_token" in self._jwt_token:
-            try:
-                self._keycloak_openid.logout(self._jwt_token.get("refresh_token"))
-            except Exception as e:
-                logging.warning("Failed to logout from Keycloak: %s", str(e))
-            finally:
-                self._keycloak_openid = None
+        # Clean token
+        if hasattr(self, "_jwt_token") and self._jwt_token:
+            self._jwt_token = None
 
     def __enter__(self):
         """Support for context manager protocol."""
@@ -370,6 +400,13 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         """
         self._jwt_token = token
 
+        # handle refresh
+        if self._jwt_token and self._auto_refresh_token:
+            self._schedule_token_refresh()
+        elif self._token_refresh_timer:
+            self._token_refresh_timer.cancel()
+            self._token_refresh_timer = None
+
     @property
     def forward_to(self) -> str:
         """Get the target host address for request forwarding in a cluster setup.
@@ -419,7 +456,14 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     # Security
     ########################################
-    def login(self, user_name: str, user_pwd: str, totp_code: Optional[str] = "", timeout_seconds: Union[str, int] = DURATION_ONE_WEEK_ISO, audience: Optional[str] = None) -> str:
+    def login(
+        self,
+        user_name: str,
+        user_pwd: str,
+        totp_code: Optional[str] = "",
+        timeout_seconds: Union[str, int] = DURATION_ONE_WEEK_ISO,
+        audience: Optional[str] = None,
+    ) -> str:
         """Login with user name and password
 
         Args:
@@ -432,20 +476,6 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         Returns:
             str: JWT token.
         """
-        # Keycloak authentication if configured
-        if self._keycloak_openid:
-            self.jwt_token = self._keycloak_openid.token(
-                username=user_name,
-                password=user_pwd,
-                totp=totp_code if totp_code else None,
-                grant_type="password",  # grant type for token request: "password" / "client_credentials" / "refresh_token"
-                scope="openid",  # what information to include in the token, such as "openid profile email"
-            )
-
-            if self._auto_refresh_token:
-                self._schedule_token_refresh()
-            return self.jwt_token
-
         # Standard App Mesh authentication
         self.jwt_token = None
         resp = self._request_http(
@@ -467,8 +497,6 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         else:
             raise Exception(resp.text)
 
-        if self._auto_refresh_token:
-            self._schedule_token_refresh()
         return self.jwt_token
 
     def validate_totp(self, username: str, challenge: str, code: str, timeout: Union[int, str] = DURATION_ONE_WEEK_ISO) -> str:
@@ -510,24 +538,12 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             bool: logoff success or failure.
         """
         result = False
-        # Handle Keycloak logout if configured
-        if self._keycloak_openid and self.jwt_token and isinstance(self.jwt_token, dict) and "refresh_token" in self.jwt_token:
-            refresh_token = self.jwt_token.get("refresh_token")
-            self._keycloak_openid.logout(refresh_token)
-            self.jwt_token = None
-            result = True
-
         # Standard App Mesh logout
         if self.jwt_token and isinstance(self.jwt_token, str):
             resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/self/logoff")
             self.jwt_token = None
             result = resp.status_code == HTTPStatus.OK
 
-        # Cancel token refresh timer
-        if self._token_refresh_timer:
-            self._token_refresh_timer.cancel()
-            self._token_refresh_timer = None
-
         return result
 
     def authentication(self, token: str, permission: Optional[str] = None, audience: Optional[str] = None) -> bool:
@@ -577,13 +593,8 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             raise Exception("No token to renew")
 
         try:
-            # Handle Keycloak token (dictionary format)
-            if self._keycloak_openid and isinstance(self.jwt_token, dict) and "refresh_token" in self.jwt_token:
-                new_token = self._keycloak_openid.refresh_token(self.jwt_token.get("refresh_token"))
-                self.jwt_token = new_token
-
             # Handle App Mesh token (string format)
-            elif isinstance(self.jwt_token, str):
+            if isinstance(self.jwt_token, str):
                 resp = self._request_http(
                     AppMeshClient.Method.POST,
                     path="/appmesh/token/renew",
@@ -986,9 +997,6 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         Returns:
             dict: user definition.
         """
-        if self._keycloak_openid and isinstance(self.jwt_token, dict) and "access_token" in self.jwt_token:
-            return self._keycloak_openid.userinfo(self.jwt_token.get("access_token"))
-
         resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/user/self")
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -1238,6 +1246,22 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         return resp.text
 
+    def cancle_task(self, app_name: str) -> bool:
+        """Client cancle a running task to a App Mesh application.
+
+        Args:
+            app_name (str): Name of the target application (as registered in App Mesh).
+
+        Returns:
+            bool: Task exist and cancled status.
+        """
+        path = f"/appmesh/app/{app_name}/task"
+        resp = self._request_http(
+            AppMeshClient.Method.DELETE,
+            path=path,
+        )
+        return resp.status_code == HTTPStatus.OK
+
     def run_app_async(
         self,
         app: Union[App, str],
@@ -1383,7 +1407,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         # Prepare headers
         header = {} if header is None else header
         if self.jwt_token:
-            token = self.jwt_token["access_token"] if isinstance(self.jwt_token, dict) and "access_token" in self.jwt_token else self.jwt_token
+            token = self._get_access_token()
             header["Authorization"] = "Bearer " + token
         if self.forward_to and len(self.forward_to) > 0:
             if ":" in self.forward_to:
@@ -1419,13 +1443,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             else:
                 raise Exception("Invalid http method", method)
 
-            # Ensure response text decoding uses UTF-8 by default
-            try:
-                resp.encoding = "utf-8"
-            except Exception:
-                # If setting encoding fails for any reason, ignore and return the response as-is
-                pass
-
-            return resp
+            # Wrap the response for encoding handling
+            return EncodingResponse(resp)
         except requests.exceptions.RequestException as e:
             raise Exception(f"HTTP request failed: {str(e)}")

appmesh/client_http_oauth.py

@@ -0,0 +1,138 @@
+# client_http_oauth.py
+# pylint: disable=line-too-long,broad-exception-caught,too-many-lines, import-outside-toplevel, protected-access
+import os
+import logging
+from typing import Optional, Union
+from keycloak import KeycloakOpenID
+from .client_http import AppMeshClient
+
+
+class AppMeshClientOAuth(AppMeshClient):
+    """
+    AppMeshClient extended with Keycloak authentication support.
+
+    Managing tokens using Keycloak as the identity provider.
+    """
+
+    def __init__(
+        self,
+        oauth2: dict,  # Required for Keycloak
+        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=(60, 300),
+        jwt_token=None,  # Keycloak dict
+        auto_refresh_token: bool = True,  # Default to True for Keycloak
+    ):
+        """Initialize an App Mesh HTTP client with Keycloak support.
+        Args:
+            oauth2 (Dict[str, str]): Keycloak configuration for oauth2 authentication:
+                - auth_server_url: Keycloak server URL (e.g. "https://keycloak.example.com/auth/")
+                - realm: Keycloak realm
+                - client_id: Keycloak client ID
+                - client_secret: Keycloak client secret (optional)
+                Using this parameter enables Keycloak integration for authentication. The 'python-keycloak' package
+                will be imported on-demand only when this parameter is, make sure package is installed (pip3 install python-keycloak).
+        """
+        # Initialize base class, disabling its Keycloak and auto-refresh logic
+        super().__init__(
+            rest_url=rest_url,
+            rest_ssl_verify=rest_ssl_verify,
+            rest_ssl_client_cert=rest_ssl_client_cert,
+            rest_timeout=rest_timeout,
+            jwt_token=jwt_token,
+            auto_refresh_token=auto_refresh_token,
+        )
+
+        # Keycloak integration
+        self._keycloak_openid = KeycloakOpenID(
+            server_url=oauth2.get("auth_server_url"),
+            client_id=oauth2.get("client_id"),
+            realm_name=oauth2.get("realm"),
+            client_secret_key=oauth2.get("client_secret"),
+            verify=self.ssl_verify,
+            timeout=rest_timeout,
+        )
+
+    # @override, from typing import override avialable from python3.12
+    def _get_access_token(self) -> str:
+        return self.jwt_token.get("access_token", "") if self.jwt_token else None
+
+    def login(
+        self,
+        user_name: str,
+        user_pwd: str,
+        totp_code: Optional[str] = "",
+        timeout_seconds: Union[str, int] = AppMeshClient.DURATION_ONE_WEEK_ISO,
+    ) -> dict:
+        """Login with user name and password using Keycloak.
+        Args:
+            user_name (str): the name of the user.
+            user_pwd (str): the password of the user.
+            totp_code (str, optional): the TOTP code if enabled for the user.
+            timeout_seconds (int | str, optional): token expire timeout of seconds. support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P1W').
+
+        Returns:
+            dict: Keycloak token.
+        """
+        # Keycloak authentication
+        self.jwt_token = self._keycloak_openid.token(
+            username=user_name,
+            password=user_pwd,
+            totp=totp_code if totp_code else None,
+            grant_type="password",  # grant type for token request: "password" / "client_credentials" / "refresh_token"
+            scope="openid",  # what information to include in the token, such as "openid profile email"
+        )
+
+        return self.jwt_token
+
+    def logoff(self) -> bool:
+        """Log out of the current session from Keycloak and clean up."""
+        result = False
+        if self._keycloak_openid and self.jwt_token:
+            try:
+                self._keycloak_openid.logout(self.jwt_token.get("refresh_token"))
+                result = True
+            except Exception as e:
+                logging.warning("Failed to logout from Keycloak: %s", str(e))
+            finally:
+                self.jwt_token = None
+
+        # Call super to handle base class cleanup (timers, session)
+        super_result = super().logoff()
+
+        return result and super_result
+
+    def renew_token(self) -> dict:
+        """Renew the current Keycloak token."""
+        if not self.jwt_token or not isinstance(self.jwt_token, dict) or "refresh_token" not in self.jwt_token:
+            raise Exception("No Keycloak refresh token available to renew")
+
+        try:
+            # Handle Keycloak token (dictionary format)
+            new_token = self._keycloak_openid.refresh_token(self.jwt_token.get("refresh_token"))
+            self.jwt_token = new_token
+            return self.jwt_token
+        except Exception as e:
+            logging.error("Keycloak token renewal failed: %s", str(e))
+            raise Exception(f"Keycloak token renewal failed: {str(e)}") from e
+
+    def view_self(self) -> dict:
+        """Get information about the current user, using Keycloak userinfo if applicable.
+        Returns:
+            dict: user definition.
+        """
+        return self._keycloak_openid.userinfo(self._get_access_token())
+
+    def close(self):
+        """Close the session and release resources, including Keycloak logout."""
+        # Logout from Keycloak if needed
+        if hasattr(self, "_keycloak_openid") and self._keycloak_openid and hasattr(self, "_jwt_token") and self._jwt_token and isinstance(self._jwt_token, dict) and "refresh_token" in self._jwt_token:
+            try:
+                self._keycloak_openid.logout(self._jwt_token.get("refresh_token"))
+            except Exception as e:
+                logging.warning("Failed to logout from Keycloak: %s", str(e))
+            finally:
+                self._keycloak_openid = None
+        # Close the base class session and resources (timers, etc.)
+        super().close()

appmesh/client_tcp.py

@@ -6,7 +6,7 @@ import os
 import socket
 import uuid
 import requests
-from .client_http import AppMeshClient
+from .client_http import AppMeshClient, EncodingResponse
 from .tcp_transport import TCPTransport
 from .tcp_messages import RequestMessage, ResponseMessage
 
@@ -140,7 +140,7 @@ class AppMeshClientTCP(AppMeshClient):
                 appmesh_request.headers[k] = v
         if query:
             for k, v in query.items():
-                appmesh_request.querys[k] = v
+                appmesh_request.query[k] = v
 
         data = appmesh_request.serialize()
         self.tcp_transport.send_message(data)
@@ -153,13 +153,13 @@ class AppMeshClientTCP(AppMeshClient):
         appmesh_resp = ResponseMessage().deserialize(resp_data)
         response = requests.Response()
         response.status_code = appmesh_resp.http_status
-        response.encoding = self.ENCODING_UTF8
-        response._content = appmesh_resp.body.encode(self.ENCODING_UTF8)
+        # response.encoding = self.ENCODING_UTF8 # only need when charset not in appmesh_resp.body_msg_type
+        response._content = appmesh_resp.body if isinstance(appmesh_resp.body, bytes) else str(appmesh_resp.body).encode(self.ENCODING_UTF8)
         response.headers = appmesh_resp.headers
         if appmesh_resp.body_msg_type:
             response.headers["Content-Type"] = appmesh_resp.body_msg_type
 
-        return response
+        return EncodingResponse(response)
 
     ########################################
     # File management

appmesh/server_http.py

@@ -5,7 +5,7 @@ import abc
 import logging
 import os
 import time
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Union
 from http import HTTPStatus
 from .client_http import AppMeshClient
 
@@ -66,7 +66,7 @@ class AppMeshServer(metaclass=abc.ABCMeta):
             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:
+    def task_fetch(self) -> Union[str, bytes]:
         """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
@@ -74,7 +74,7 @@ class AppMeshServer(metaclass=abc.ABCMeta):
 
 
         Returns:
-            str: The payload provided by the client as returned by the service.
+            Union[str, bytes]: 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"
@@ -91,16 +91,16 @@ class AppMeshServer(metaclass=abc.ABCMeta):
                 time.sleep(0.1)
                 continue
 
-            return resp.text
+            return resp.content
 
-    def task_return(self, result: str) -> None:
+    def task_return(self, result: Union[str, bytes]) -> 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.
+            result (Union[str, bytes]): Result payload to be delivered back to the client.
         """
         process_id, app_name = self._get_runtime_env()
         path = f"/appmesh/app/{app_name}/task"

appmesh/tcp_messages.py

@@ -1,41 +1,69 @@
 # tcp_messages.py
 
+from typing import get_type_hints
 import msgpack
 
 
 class RequestMessage:
     """TCP request message for HTTP-like communication"""
 
-    uuid: str = ""
-    request_uri: str = ""
-    http_method: str = ""
-    client_addr: str = ""
-    body: bytes = b""
-    headers: dict = {}
-    querys: dict = {}
+    def __init__(self):
+        self.uuid: str = ""
+        self.request_uri: str = ""
+        self.http_method: str = ""
+        self.client_addr: str = ""
+        self.body: bytes = b""
+        self.headers: dict = {}
+        self.query: dict = {}
 
     def serialize(self) -> bytes:
         """Serialize request message to bytes"""
-        # http://www.cnitblog.com/luckydmz/archive/2019/11/20/91959.html
-        self_dict = vars(self)
-        self_dict["headers"] = self.headers
-        self_dict["querys"] = self.querys
-        return msgpack.dumps(self_dict)
+        return msgpack.dumps(vars(self), use_bin_type=True)
 
 
 class ResponseMessage:
     """TCP response message for HTTP-like communication"""
 
-    uuid: str = ""
-    request_uri: str = ""
-    http_status: int = 0
-    body_msg_type: str = ""
-    body: str = ""
-    headers: dict = {}
+    uuid: str
+    request_uri: str
+    http_status: int
+    body_msg_type: str
+    body: bytes
+    headers: dict
+
+    def __init__(self):
+        self.uuid = ""
+        self.request_uri = ""
+        self.http_status = 0
+        self.body_msg_type = ""
+        self.body = b""
+        self.headers = {}
 
     def deserialize(self, buf: bytes):
-        """Deserialize response message"""
-        dic = msgpack.unpackb(buf)
+        """Deserialize TCP msgpack buffer with proper type conversion."""
+        dic = msgpack.unpackb(buf, raw=False)
+        hints = get_type_hints(self.__class__)
+
         for k, v in dic.items():
+            if k not in hints:
+                continue  # Skip unknown fields
+
+            # handle all types (int, bytes, dict, str)
+            t = hints[k]
+            if t is str:
+                if isinstance(v, bytes):
+                    v = v.decode("utf-8", errors="replace")
+                elif v is None:
+                    v = ""
+                else:
+                    v = str(v)
+            elif t is bytes:
+                if isinstance(v, str):
+                    v = v.encode("utf-8")  # handle accidental str
+                elif v is None:
+                    v = b""
+            elif t is int:
+                v = int(v or 0)
             setattr(self, k, v)
+
         return self

{appmesh-1.6.1.dist-info → appmesh-1.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appmesh
-Version: 1.6.1
+Version: 1.6.3
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi
@@ -40,6 +40,7 @@ Dynamic: summary
 
 # App Mesh: Advanced Application Management Platform
 
+<div align=center><img src="https://github.com/laoshanxi/picture/raw/master/appmesh/whatis.gif" align=center /></div>
 App Mesh is an open-source, multi-tenant application management platform designed for cloud-native environments. It efficiently manages, schedules, and monitors both microservices and traditional applications, offering a lightweight alternative to Kubernetes. App Mesh bridges the gap between simple process managers and complex container orchestration systems, making it ideal for organizations seeking to modernize their infrastructure without adopting full container-native complexity. Supporting both containerized and native applications, it provides a versatile solution for diverse enterprise needs.
 
 <div align=center><img src="https://github.com/laoshanxi/picture/raw/master/appmesh/diagram.png" align=center /></div>
@@ -54,7 +55,7 @@ Cloud native | Schedule cloud-level applications to run on multiple hosts with r
 Micro service application | 🧱 [Consul micro-service cluster management](https://app-mesh.readthedocs.io/en/latest/CONSUL.html)
 Extra Features | Collect host/app resource usage <br> Remote shell command execution <br> File upload/download interface <br> Hot-update support `systemctl reload appmesh` <br> Bash completion <br> Reverse proxy <br> 🌐[Web GUI](https://github.com/laoshanxi/app-mesh-ui)
 Platform support | X86_64 <br> ARM32 <br> ARM64
-SDK | [Python](https://app-mesh.readthedocs.io/en/latest/api/appmesh_client.html) <br> [Golang](https://github.com/laoshanxi/app-mesh/blob/main/src/sdk/go/appmesh_client.go) <br> [JavaScript](https://www.npmjs.com/package/appmesh) <br> [Java](https://github.com/laoshanxi/app-mesh/packages/2227502) <br> [Swagger OpenAPI Specification](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/laoshanxi/app-mesh/main/src/daemon/rest/openapi.yaml)
+SDK | [Python](https://app-mesh.readthedocs.io/en/latest/api/appmesh.html#module-appmesh.client_http) <br> [Golang](https://github.com/laoshanxi/app-mesh/blob/main/src/sdk/go/client_http.go) <br> [JavaScript](https://www.npmjs.com/package/appmesh) <br> [Java](https://github.com/laoshanxi/app-mesh/packages/2227502) <br> [Swagger OpenAPI Specification](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/laoshanxi/app-mesh/main/src/daemon/rest/openapi.yaml)
 
 ## Getting started
 
@@ -116,7 +117,6 @@ Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Instal
 
 - [Build a powerful monitor system with Grafana/Prometheus/Loki](https://app-mesh.readthedocs.io/en/latest/success/build_powerful_monitor_system_with_Grafana_Prometheus_Loki.html)
 - [Customize application start behavior](https://app-mesh.readthedocs.io/en/latest/success/customize_app_startup_behavior.html)
-- [Manage cluster-level microservice applications](https://app-mesh.readthedocs.io/en/latest/success/manage_cluster_level_microservice_applications.html)
 - [Open service broker support local PV for Kubernetes](https://app-mesh.readthedocs.io/en/latest/success/open_service_broker_support_local_pv_for_K8S.html)
 - [Promote native application to microservice application](https://app-mesh.readthedocs.io/en/latest/success/promote_native_app_to_microservice_app.html)
 - [Secure REST file server](https://app-mesh.readthedocs.io/en/latest/success/secure_REST_file_server.html)

appmesh-1.6.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+appmesh/__init__.py,sha256=TY1y5B5cE57uhraEzCFOZRWuo9SY1R-fYNRan8hCZOM,1670
+appmesh/app.py,sha256=crD4DRFZJuHtZMfSsz7C-EwvjPmGZbFXYXvA_wCdvdI,10734
+appmesh/app_output.py,sha256=vfn322AyixblI8DbXds08h6L_ybObiaRSifsA1-Xcoo,1035
+appmesh/app_run.py,sha256=aYq852a29OThIi32Xtx5s0sTXZ97T0lHD5WXH8yfPoc,2018
+appmesh/appmesh_client.py,sha256=ywB2222PtJUffdfdxZcBfdhZs1KYyc7JvzMxwuK2qyI,378
+appmesh/client_http.py,sha256=WLdHmi2ryzCiXFyIIAbKH3arfcs__rxt4kwehpO_w6s,57711
+appmesh/client_http_oauth.py,sha256=1d51o0JX_xtB8d2bEuM7_XJHcwMnhcjkbIq7GE1Zxm8,6120
+appmesh/client_tcp.py,sha256=OrKmJ-SMSmCPXj5WVhWwBXiK8Z_WyCrDmTim0pe1pc0,11407
+appmesh/server_http.py,sha256=vf_Kh7ZIyEuBijZp8I2Rv-Fy9gxFdPFn5Pp2rUNCT1U,4319
+appmesh/server_tcp.py,sha256=biBFF5IGWFOw2ru831cfmzn1DVXcBm9e-W6CP2VkfzE,1444
+appmesh/tcp_messages.py,sha256=H9S_iCy0IuufY2v50_SUgRvcyQmJsySG65tBe_xb3Ko,1878
+appmesh/tcp_transport.py,sha256=f28zfZNH46tUHfT8F1PrCM1wUXiSBIW7R3ipMsXJqIU,8946
+appmesh-1.6.3.dist-info/METADATA,sha256=Hcymb5xi90fgxLHqHNWHzicT2KLZzGPo4DonII-IQBQ,11828
+appmesh-1.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+appmesh-1.6.3.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
+appmesh-1.6.3.dist-info/RECORD,,

appmesh-1.6.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-appmesh/__init__.py,sha256=_I-kLcLy7DM3gG2JJTRM_hUxBu3zvIPm2wCsz3NYes4,493
-appmesh/app.py,sha256=4lo66ob1ZFDgL8VYKxH4_sh-vbHcGkZNThURE0go-d4,10732
-appmesh/app_output.py,sha256=vfn322AyixblI8DbXds08h6L_ybObiaRSifsA1-Xcoo,1035
-appmesh/app_run.py,sha256=TJ9xVX8xqUN9-OOmr_8JlgXoyg3hTmDFNKvGf4w_oR4,1980
-appmesh/appmesh_client.py,sha256=7yy9c_ygJbqMekrUsHWmRObwHLK82qP65xQLXxfGd8U,339
-appmesh/client_http.py,sha256=jUIZJHrnu2-r6N6Cd9lQNPeQcZefB7ENl6DUn8Mugck,57896
-appmesh/client_tcp.py,sha256=hE0T_2Z0OQZdF5zi--iuvu2_-ka0DfSSQ4BP3oHlg44,11243
-appmesh/server_http.py,sha256=zr9sfS8g_mtP2kuAfmz-qU7rLSFTVt3srbFXaCbl8Y0,4253
-appmesh/server_tcp.py,sha256=biBFF5IGWFOw2ru831cfmzn1DVXcBm9e-W6CP2VkfzE,1444
-appmesh/tcp_messages.py,sha256=4XRv5lSm_8ElMg_37SuyIRrfxI7XFNNP_7SdO7us3PA,1023
-appmesh/tcp_transport.py,sha256=f28zfZNH46tUHfT8F1PrCM1wUXiSBIW7R3ipMsXJqIU,8946
-appmesh-1.6.1.dist-info/METADATA,sha256=DvJTf5922gT6fc-iOWizqodwljYIkIlCCI1SeTd0juM,11847
-appmesh-1.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-appmesh-1.6.1.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
-appmesh-1.6.1.dist-info/RECORD,,