appmesh 1.6.0__py3-none-any.whl → 1.6.2__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/client_http.py

@@ -107,7 +107,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 +141,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 +163,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 +176,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 +187,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 +207,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 +252,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 +278,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 +340,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 +396,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 +416,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 +437,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 +478,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 +533,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 +937,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)
@@ -1383,7 +1331,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:

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/tcp_transport.py

@@ -108,7 +108,7 @@ class TCPTransport:
             self._socket = ssl_socket
         except (socket.error, ssl.SSLError) as e:
             sock.close()
-            raise RuntimeError(f"Failed to connect to {self.tcp_address}: {e}")
+            raise RuntimeError(f"Failed to connect to {self.tcp_address}: {e}") from e
 
     def close(self) -> None:
         """Close socket connection"""
@@ -137,7 +137,7 @@ class TCPTransport:
                 self._socket.sendall(data)
         except (socket.error, ssl.SSLError) as e:
             self.close()
-            raise RuntimeError(f"Error sending message: {e}")
+            raise RuntimeError(f"Error sending message: {e}") from e
 
     def receive_message(self) -> Optional[bytearray]:
         """Receive a message with a prefixed header indicating its length and validate it"""
@@ -156,39 +156,46 @@ class TCPTransport:
             return None
         except (socket.error, ssl.SSLError) as e:
             self.close()
-            raise RuntimeError(f"Error receiving message: {e}")
+            raise RuntimeError(f"Error receiving message: {e}") from e
 
-    def _recvall(self, length: int) -> bytearray:
-        """socket recv data with fixed length
+    def _recvall(self, length: int) -> bytes:
+        """Receive exactly `length` bytes from the socket.
            https://stackoverflow.com/questions/64466530/using-a-custom-socket-recvall-function-works-only-if-thread-is-put-to-sleep
+
         Args:
-            length (int): data length to be received
+            length (int): Number of bytes to receive.
 
         Returns:
-            bytearray: Received data
+            bytes: Received data.
 
         Raises:
-            EOFError: If connection closes prematurely
-            ValueError: If length is invalid
+            EOFError: If connection closes before receiving all data.
+            ValueError: If length is not positive.
+            socket.timeout: If socket operation times out.
         """
         if length <= 0:
             raise ValueError(f"Invalid length: {length}")
 
-        # Pre-allocate buffer of exact size needed
+        # Pre-allocate buffer
         buffer = bytearray(length)
-        view = memoryview(buffer)
+        mv = memoryview(buffer)
         bytes_received = 0
 
         while bytes_received < length:
-            # Use recv_into to read directly into our buffer
             try:
-                chunk_size = self._socket.recv_into(view[bytes_received:], length - bytes_received)
+                # Receive directly into buffer
+                remaining = length - bytes_received
+                chunk_size = self._socket.recv_into(mv, remaining)
 
                 if chunk_size == 0:
                     raise EOFError("Connection closed by peer")
 
+                mv = mv[chunk_size:]  # advance memoryview
                 bytes_received += chunk_size
-            except socket.timeout:
-                raise socket.timeout(f"Socket operation timed out after receiving {bytes_received}/{length} bytes")
 
-        return buffer
+            except InterruptedError:
+                continue
+            except socket.timeout as e:
+                raise socket.timeout(f"Socket operation timed out after receiving {bytes_received}/{length} bytes") from e
+
+        return bytes(buffer)  # safer than bytearray

{appmesh-1.6.0.dist-info → appmesh-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appmesh
-Version: 1.6.0
+Version: 1.6.2
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi
@@ -42,6 +42,7 @@ Dynamic: summary
 
 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/whatis.gif" align=center /></div>
 <div align=center><img src="https://github.com/laoshanxi/picture/raw/master/appmesh/diagram.png" align=center /></div>
 
 ## Features
@@ -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.0.dist-info → appmesh-1.6.2.dist-info}/RECORD

@@ -1,15 +1,16 @@
-appmesh/__init__.py,sha256=_I-kLcLy7DM3gG2JJTRM_hUxBu3zvIPm2wCsz3NYes4,493
+appmesh/__init__.py,sha256=TY1y5B5cE57uhraEzCFOZRWuo9SY1R-fYNRan8hCZOM,1670
 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_http.py,sha256=rVmGAc_nWkntoZBL7BCaQZtH9QOZXUis38tW9OhT2ps,54707
+appmesh/client_http_oauth.py,sha256=1d51o0JX_xtB8d2bEuM7_XJHcwMnhcjkbIq7GE1Zxm8,6120
 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=3B0w8AHXnb-E49Odxm5bPNBve1P-YiMHNDxFO2YYYVE,8690
-appmesh-1.6.0.dist-info/METADATA,sha256=VKKRa3mUsX0oahVUosSDJCR4mlsqTX-ua51-JskhSwk,11847
-appmesh-1.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-appmesh-1.6.0.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
-appmesh-1.6.0.dist-info/RECORD,,
+appmesh/tcp_transport.py,sha256=f28zfZNH46tUHfT8F1PrCM1wUXiSBIW7R3ipMsXJqIU,8946
+appmesh-1.6.2.dist-info/METADATA,sha256=NljlBJBJxpevRRrgxFPyjNpxsYeu3FuUk7_klAhJCcs,11828
+appmesh-1.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+appmesh-1.6.2.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
+appmesh-1.6.2.dist-info/RECORD,,