appmesh 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

appmesh/appmesh_client.py

@@ -24,59 +24,48 @@ import requests
 DEFAULT_TOKEN_EXPIRE_SECONDS = "P1W"  # default 7 day(s)
 DEFAULT_RUN_APP_TIMEOUT_SECONDS = "P2D"  # 2 days
 DEFAULT_RUN_APP_LIFECYCLE_SECONDS = "P2DT12H"  # 2.5 days
+
 REST_TEXT_MESSAGE_JSON_KEY = "message"
 MESSAGE_ENCODING_UTF8 = "utf-8"
 TCP_MESSAGE_HEADER_LENGTH = 4
+
 _SSL_CA_PEM_FILE = "/opt/appmesh/ssl/ca.pem"
 _SSL_CLIENT_PEM_FILE = "/opt/appmesh/ssl/client.pem"
 _SSL_CLIENT_PEM_KEY_FILE = "/opt/appmesh/ssl/client-key.pem"
-HTTP_USER_AGENT_HEADER_NAME = "User-Agent"
+
 HTTP_USER_AGENT = "appmesh/python"
 HTTP_USER_AGENT_TCP = "appmesh/python/tcp"
+HTTP_HEADER_KEY_USER_AGENT = "User-Agent"
 HTTP_HEADER_KEY_X_SEND_FILE_SOCKET = "X-Send-File-Socket"
 HTTP_HEADER_KEY_X_RECV_FILE_SOCKET = "X-Recv-File-Socket"
 HTTP_HEADER_KEY_X_TARGET_HOST = "X-Target-Host"
 
 
-def _get_str_item(data: dict, key):
-    return data[key] if (data and key in data and data[key] and isinstance(data[key], str)) else None
-
-
-def _get_int_item(data: dict, key):
-    return int(data[key]) if (data and key in data and data[key] and isinstance(data[key], int)) else None
-
-
-def _get_bool_item(data: dict, key):
-    return bool(data[key]) if (data and key in data and data[key]) else None
-
-
-def _get_native_item(data: dict, key):
-    return copy.deepcopy(data[key]) if (data and key in data and data[key]) else None
-
-
-class AppOutput(object):
-    """App output object for app_output() method"""
-
-    def __init__(self, status_code: HTTPStatus, output: str, out_position: Optional[int], exit_code: Optional[int]) -> None:
-
-        self.status_code = status_code
-        """HTTP status code"""
-
-        self.output = output
-        """HTTP response text"""
-
-        self.out_position = out_position
-        """Current read position (int or None)"""
-
-        self.exit_code = exit_code
-        """Process exit code (int or None)"""
-
-
 class App(object):
     """
     App object present an application in App Mesh
     """
 
+    @staticmethod
+    def _get_str_item(data: dict, key) -> Optional[str]:
+        """Retrieve a string value from a dictionary by key, if it exists and is a valid string."""
+        return data[key] if (data and key in data and data[key] and isinstance(data[key], str)) else None
+
+    @staticmethod
+    def _get_int_item(data: dict, key) -> Optional[int]:
+        """Retrieve an integer value from a dictionary by key, if it exists and is a valid integer."""
+        return int(data[key]) if (data and key in data and data[key] and isinstance(data[key], int)) else None
+
+    @staticmethod
+    def _get_bool_item(data: dict, key) -> Optional[bool]:
+        """Retrieve a boolean value from a dictionary by key, if it exists."""
+        return bool(data[key]) if (data and key in data and data[key]) else None
+
+    @staticmethod
+    def _get_native_item(data: dict, key) -> Optional[object]:
+        """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]) else None
+
     @unique
     class Permission(Enum):
         """Application permission definition"""
@@ -103,10 +92,10 @@ class App(object):
             if isinstance(data, (str, bytes, bytearray)):
                 data = json.loads(data)
 
-            self.exit = _get_str_item(data, "exit")
+            self.exit = App._get_str_item(data, "exit")
             """default exit behavior [restart,standby,keepalive,remove]"""
 
-            self.control = _get_native_item(data, "control") if _get_native_item(data, "control") else dict()
+            self.control = App._get_native_item(data, "control") if App._get_native_item(data, "control") else dict()
             """exit code behavior (e.g, --control 0:restart --control 1:standby), higher priority than default exit behavior"""
 
         def set_exit_behavior(self, a: Action) -> None:
@@ -126,10 +115,10 @@ class App(object):
             if isinstance(data, (str, bytes, bytearray)):
                 data = json.loads(data)
 
-            self.daily_start = _get_int_item(data, "daily_start")
+            self.daily_start = App._get_int_item(data, "daily_start")
             """daily start time (e.g., '09:00:00+08')"""
 
-            self.daily_end = _get_int_item(data, "daily_end")
+            self.daily_end = App._get_int_item(data, "daily_end")
             """daily end time (e.g., '20:00:00+08')"""
 
         def set_daily_range(self, start: datetime, end: datetime) -> None:
@@ -146,13 +135,13 @@ class App(object):
             if isinstance(data, (str, bytes, bytearray)):
                 data = json.loads(data)
 
-            self.cpu_shares = _get_int_item(data, "cpu_shares")
+            self.cpu_shares = App._get_int_item(data, "cpu_shares")
             """CPU shares (relative weight)"""
 
-            self.memory_mb = _get_int_item(data, "memory_mb")
+            self.memory_mb = App._get_int_item(data, "memory_mb")
             """physical memory limit in MByte"""
 
-            self.memory_virt_mb = _get_int_item(data, "memory_virt_mb")
+            self.memory_virt_mb = App._get_int_item(data, "memory_virt_mb")
             """virtual memory limit in MByte"""
 
     def __init__(self, data=None):
@@ -165,59 +154,59 @@ class App(object):
         if isinstance(data, (str, bytes, bytearray)):
             data = json.loads(data)
 
-        self.name = _get_str_item(data, "name")
+        self.name = App._get_str_item(data, "name")
         """application name (unique)"""
 
-        self.command = _get_str_item(data, "command")
+        self.command = App._get_str_item(data, "command")
         """full command line with arguments"""
 
-        self.shell = _get_bool_item(data, "shell")
+        self.shell = App._get_bool_item(data, "shell")
         """use shell mode, cmd can be more shell commands with string format"""
 
-        self.session_login = _get_bool_item(data, "session_login")
+        self.session_login = App._get_bool_item(data, "session_login")
         """app run in session login mode"""
 
-        self.description = _get_str_item(data, "description")
+        self.description = App._get_str_item(data, "description")
         """application description string"""
 
-        self.metadata = _get_native_item(data, "metadata")
+        self.metadata = App._get_native_item(data, "metadata")
         """metadata string/JSON (input for application, pass to process stdin)"""
 
-        self.working_dir = _get_str_item(data, "working_dir")
+        self.working_dir = App._get_str_item(data, "working_dir")
         """working directory"""
 
-        self.status = _get_int_item(data, "status")
+        self.status = App._get_int_item(data, "status")
         """initial application status (true is enable, false is disabled)"""
 
-        self.docker_image = _get_str_item(data, "docker_image")
+        self.docker_image = App._get_str_item(data, "docker_image")
         """docker image which used to run command line (for docker container application)"""
 
-        self.stdout_cache_num = _get_int_item(data, "stdout_cache_num")
+        self.stdout_cache_num = App._get_int_item(data, "stdout_cache_num")
         """stdout file cache number"""
 
-        self.start_time = _get_int_item(data, "start_time")
+        self.start_time = App._get_int_item(data, "start_time")
         """start date time for app (ISO8601 time format, e.g., '2020-10-11T09:22:05')"""
 
-        self.end_time = _get_int_item(data, "end_time")
+        self.end_time = App._get_int_item(data, "end_time")
         """end date time for app (ISO8601 time format, e.g., '2020-10-11T10:22:05')"""
 
-        self.interval = _get_int_item(data, "interval")
+        self.interval = App._get_int_item(data, "interval")
         """start interval seconds for short running app, support ISO 8601 durations and cron expression (e.g., 'P1Y2M3DT4H5M6S' 'P5W' '* */5 * * * *')"""
 
-        self.cron = _get_bool_item(data, "cron")
+        self.cron = App._get_bool_item(data, "cron")
         """indicate interval parameter use cron expression or not"""
 
-        self.daily_limitation = App.DailyLimitation(_get_native_item(data, "daily_limitation"))
+        self.daily_limitation = App.DailyLimitation(App._get_native_item(data, "daily_limitation"))
 
-        self.retention = _get_str_item(data, "retention")
+        self.retention = App._get_str_item(data, "retention")
         """extra timeout seconds for stopping current process, support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P5W')."""
 
-        self.health_check_cmd = _get_str_item(data, "health_check_cmd")
+        self.health_check_cmd = App._get_str_item(data, "health_check_cmd")
         """health check script command (e.g., sh -x 'curl host:port/health', return 0 is health)"""
 
-        self.permission = _get_int_item(data, "permission")
+        self.permission = App._get_int_item(data, "permission")
         """application user permission, value is 2 bit integer: [group & other], each bit can be deny:1, read:2, write: 3."""
-        self.behavior = App.Behavior(_get_native_item(data, "behavior"))
+        self.behavior = App.Behavior(App._get_native_item(data, "behavior"))
 
         self.env = dict()
         """environment variables (e.g., -e env1=value1 -e env2=value2, APP_DOCKER_OPTS is used to input docker run parameters)"""
@@ -231,32 +220,32 @@ class App(object):
             for k, v in data["sec_env"].items():
                 self.sec_env[k] = v
 
-        self.pid = _get_int_item(data, "pid")
+        self.pid = App._get_int_item(data, "pid")
         """process id used to attach to the running process"""
-        self.resource_limit = App.ResourceLimitation(_get_native_item(data, "resource_limit"))
+        self.resource_limit = App.ResourceLimitation(App._get_native_item(data, "resource_limit"))
 
         # readonly attributes
-        self.owner = _get_str_item(data, "owner")
+        self.owner = App._get_str_item(data, "owner")
         """owner name"""
-        self.pstree = _get_str_item(data, "pstree")
+        self.pstree = App._get_str_item(data, "pstree")
         """process tree"""
-        self.container_id = _get_str_item(data, "container_id")
+        self.container_id = App._get_str_item(data, "container_id")
         """container id"""
-        self.memory = _get_int_item(data, "memory")
+        self.memory = App._get_int_item(data, "memory")
         """memory usage"""
-        self.cpu = _get_int_item(data, "cpu")
+        self.cpu = App._get_int_item(data, "cpu")
         """cpu usage"""
-        self.fd = _get_int_item(data, "fd")
+        self.fd = App._get_int_item(data, "fd")
         """file descriptor usage"""
-        self.last_start_time = _get_int_item(data, "last_start_time")
+        self.last_start_time = App._get_int_item(data, "last_start_time")
         """last start time"""
-        self.last_exit_time = _get_int_item(data, "last_exit_time")
+        self.last_exit_time = App._get_int_item(data, "last_exit_time")
         """last exit time"""
-        self.health = _get_int_item(data, "health")
+        self.health = App._get_int_item(data, "health")
         """health status"""
-        self.version = _get_int_item(data, "version")
+        self.version = App._get_int_item(data, "version")
         """version number"""
-        self.return_code = _get_int_item(data, "return_code")
+        self.return_code = App._get_int_item(data, "return_code")
         """last exit code"""
 
     def set_valid_time(self, start: datetime, end: datetime) -> None:
@@ -300,6 +289,24 @@ class App(object):
         return output
 
 
+class AppOutput(object):
+    """App output information"""
+
+    def __init__(self, status_code: HTTPStatus, output: str, out_position: Optional[int], exit_code: Optional[int]) -> None:
+
+        self.status_code = status_code
+        """HTTP status code"""
+
+        self.output = output
+        """HTTP response text"""
+
+        self.out_position = out_position
+        """Current read position (int or None)"""
+
+        self.exit_code = exit_code
+        """Process exit code (int or None)"""
+
+
 class AppRun(object):
     """
     Application run object indicate to a remote run from run_async()
@@ -312,18 +319,18 @@ class AppRun(object):
         """process_uuid from run_async()"""
         self._client = client
         """AppMeshClient object"""
-        self._delegate_host = client.delegate_host
-        """delegate host indicates the target server for this app run"""
+        self._forwarding_host = client.forwarding_host
+        """forward host indicates the target server for this app run"""
 
     @contextmanager
-    def delegate_host(self):
-        """context manager for delegate host override to self._client"""
-        original_value = self._client.delegate_host
-        self._client.delegate_host = self._delegate_host
+    def forwarding_host(self):
+        """context manager for forward host override to self._client"""
+        original_value = self._client.forwarding_host
+        self._client.forwarding_host = self._forwarding_host
         try:
             yield
         finally:
-            self._client.delegate_host = original_value
+            self._client.forwarding_host = original_value
 
     def wait(self, stdout_print: bool = True, timeout: int = 0) -> int:
         """Wait for an async run to be finished
@@ -335,15 +342,86 @@ class AppRun(object):
         Returns:
             int: return exit code if process finished, return None for timeout or exception.
         """
-        with self.delegate_host():
+        with self.forwarding_host():
             return self._client.run_async_wait(self, stdout_print, timeout)
 
 
 class AppMeshClient(metaclass=abc.ABCMeta):
-    """App Mesh client object used to access App Mesh REST Service
-
-    - install pip package: python3 -m pip install --upgrade appmesh
-    - import module: from appmesh import appmesh_client
+    """
+    Client SDK for interacting with the App Mesh service via REST API.
+
+    The `AppMeshClient` class provides a comprehensive interface for managing and monitoring distributed applications
+    within the App Mesh ecosystem. It enables communication with the App Mesh REST API for operations such as
+    application lifecycle management, monitoring, and configuration.
+
+    This client is designed for direct usage in applications that require access to App Mesh services over HTTP-based REST.
+
+    Usage:
+        - Install the App Mesh Python package:
+            python3 -m pip install --upgrade appmesh
+        - Import the client module:
+            from appmesh import appmesh_client
+
+    Example:
+        client = appmesh_client.AppMeshClient()
+        client.login("your-name", "your-password")
+        response = client.app_view(app_name='ping')
+
+    Attributes:
+        - TLS (Transport Layer Security): Supports secure connections between the client and App Mesh service,
+          ensuring encrypted communication.
+        - JWT (JSON Web Token) and RBAC (Role-Based Access Control): Provides secure API access with
+          token-based authentication and authorization to enforce fine-grained permissions.
+
+    Methods:
+        - login()
+        - logoff()
+        - authentication()
+        - renew()
+        - totp_disable()
+        - totp_secret()
+        - totp_setup()
+
+        - app_add()
+        - app_delete()
+        - app_disable()
+        - app_enable()
+        - app_health()
+        - app_output()
+        - app_view()
+        - app_view_all()
+
+        - run_async()
+        - run_async_wait()
+        - run_sync()
+
+        - config_set()
+        - config_view()
+        - log_level_set()
+        - host_resource()
+        - forwarding_host
+        - metrics()
+
+        - tag_add()
+        - tag_delete()
+        - tag_view()
+
+        - file_download()
+        - file_upload()
+
+        - user_add()
+        - user_delete()
+        - user_lock()
+        - user_passwd_update()
+        - user_self()
+        - user_unlock()
+        - users_view()
+        - permissions_for_user()
+        - permissions_view()
+        - role_delete()
+        - role_update()
+        - roles_view()
+        - groups_view()
     """
 
     @unique
@@ -380,7 +458,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         self.ssl_verify = rest_ssl_verify
         self.ssl_client_cert = rest_ssl_client_cert
         self.rest_timeout = rest_timeout
-        self._delegate_host = None
+        self._forwarding_host = None
 
     @property
     def jwt_token(self) -> str:
@@ -401,22 +479,22 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         self._jwt_token = token
 
     @property
-    def delegate_host(self) -> str:
-        """property for delegate_host
+    def forwarding_host(self) -> str:
+        """property for forwarding_host
 
         Returns:
-            str: delegate request to target host (host:port)
+            str: forward request to target host (host:port)
         """
-        return self._delegate_host
+        return self._forwarding_host
 
-    @delegate_host.setter
-    def delegate_host(self, host: str) -> None:
-        """setter for delegate_host
+    @forwarding_host.setter
+    def forwarding_host(self, host: str) -> None:
+        """setter for forwarding_host
 
         Args:
-            host (str): delegate request to target host (host:port)
+            host (str): forward request to target host (host:port)
         """
-        self._delegate_host = host
+        self._forwarding_host = host
 
     ########################################
     # Security
@@ -475,6 +553,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/self/logoff")
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
+        self.jwt_token = None
         return resp.status_code == HTTPStatus.OK
 
     def authentication(self, token: str, permission=None) -> bool:
@@ -662,7 +741,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         return AppOutput(status_code=resp.status_code, output=resp.text, out_position=out_position, exit_code=exit_code)
 
     def app_health(self, app_name: str) -> bool:
-        """Get application health status, 0 is health.
+        """Get application health status
 
         Args:
             app_name (str): the application name.
@@ -1142,12 +1221,13 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     # File management
     ########################################
-    def file_download(self, file_path: str, local_file: str) -> bool:
-        """Copy a remote file to local, the local file will have the same permission as the remote file
+    def file_download(self, file_path: str, local_file: str, apply_file_attributes: bool = True) -> bool:
+        """Copy a remote file to local. Optionally, the local file will have the same permission as the remote file.
 
         Args:
             file_path (str): the remote file path.
             local_file (str): the local file path to be downloaded.
+            apply_file_attributes (bool): whether to apply file attributes (permissions, owner, group) to the local file.
 
         Returns:
             bool: success or failure.
@@ -1156,23 +1236,27 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
 
+        # Write the file content locally
         with open(local_file, "wb") as fp:
             for chunk in resp.iter_content(chunk_size=512):
                 if chunk:
                     fp.write(chunk)
-        if "File-Mode" in resp.headers:
-            os.chmod(path=local_file, mode=int(resp.headers["File-Mode"]))
-        if "File-User" in resp.headers and "File-Group" in resp.headers:
-            file_uid = int(resp.headers["File-User"])
-            file_gid = int(resp.headers["File-Group"])
-            try:
-                os.chown(path=local_file, uid=file_uid, gid=file_gid)
-            except Exception as ex:
-                print(ex)
+
+        # Apply file attributes (permissions, owner, group) if requested
+        if apply_file_attributes:
+            if "File-Mode" in resp.headers:
+                os.chmod(path=local_file, mode=int(resp.headers["File-Mode"]))
+            if "File-User" in resp.headers and "File-Group" in resp.headers:
+                file_uid = int(resp.headers["File-User"])
+                file_gid = int(resp.headers["File-Group"])
+                try:
+                    os.chown(path=local_file, uid=file_uid, gid=file_gid)
+                except Exception as ex:
+                    print(ex)
         return resp.status_code == HTTPStatus.OK
 
-    def file_upload(self, local_file: str, file_path: str) -> bool:
-        """Upload a local file to the remote server, the remote file will have the same permission as the local file
+    def file_upload(self, local_file: str, file_path: str, apply_file_attributes: bool = True) -> bool:
+        """Upload a local file to the remote server. Optionally, the remote file will have the same permission as the local file.
 
         Dependency:
             sudo apt install python3-pip
@@ -1181,6 +1265,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         Args:
             local_file (str): the local file path.
             file_path (str): the target remote file to be uploaded.
+            apply_file_attributes (bool): whether to upload file attributes (permissions, owner, group) along with the file.
 
         Returns:
             bool: success or failure.
@@ -1189,13 +1274,16 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         with open(file=local_file, mode="rb") as fp:
             encoder = MultipartEncoder(fields={"filename": os.path.basename(file_path), "file": ("filename", fp, "application/octet-stream")})
-            file_stat = os.stat(local_file)
-            header = {}
-            header["File-Path"] = file_path
-            header["File-Mode"] = str(file_stat.st_mode)
-            header["File-User"] = str(file_stat.st_uid)
-            header["File-Group"] = str(file_stat.st_gid)
-            header["Content-Type"] = encoder.content_type
+            header = {"File-Path": file_path, "Content-Type": encoder.content_type}
+
+            # Include file attributes (permissions, owner, group) if requested
+            if apply_file_attributes:
+                file_stat = os.stat(local_file)
+                header["File-Mode"] = str(file_stat.st_mode)
+                header["File-User"] = str(file_stat.st_uid)
+                header["File-Group"] = str(file_stat.st_gid)
+
+            # Upload file with or without attributes
             # https://stackoverflow.com/questions/22567306/python-requests-file-upload
             resp = self._request_http(
                 AppMeshClient.Method.POST_STREAM,
@@ -1335,12 +1423,12 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         header = {} if header is None else header
         if self.jwt_token:
             header["Authorization"] = "Bearer " + self.jwt_token
-        if self.delegate_host and len(self.delegate_host) > 0:
-            if ":" in self.delegate_host:
-                header[HTTP_HEADER_KEY_X_TARGET_HOST] = self.delegate_host
+        if self.forwarding_host and len(self.forwarding_host) > 0:
+            if ":" in self.forwarding_host:
+                header[HTTP_HEADER_KEY_X_TARGET_HOST] = self.forwarding_host
             else:
-                header[HTTP_HEADER_KEY_X_TARGET_HOST] = self.delegate_host + ":" + str(parse.urlsplit(self.server_url).port)
-        header[HTTP_USER_AGENT_HEADER_NAME] = HTTP_USER_AGENT
+                header[HTTP_HEADER_KEY_X_TARGET_HOST] = self.forwarding_host + ":" + str(parse.urlsplit(self.server_url).port)
+        header[HTTP_HEADER_KEY_USER_AGENT] = HTTP_USER_AGENT
 
         if method is AppMeshClient.Method.GET:
             return requests.get(url=rest_url, params=query, headers=header, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
@@ -1359,10 +1447,37 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
 
 class AppMeshClientTCP(AppMeshClient):
-    """Client object used to access App Mesh REST Service over TCP (better performance than AppMeshClient)
+    """
+    Client SDK for interacting with the App Mesh service over TCP, with enhanced support for large file transfers.
+
+    The `AppMeshClientTCP` class extends the functionality of `AppMeshClient` by offering a TCP-based communication layer 
+    for the App Mesh REST API. It overrides the file download and upload methods to support large file transfers with 
+    improved performance, leveraging TCP for lower latency and higher throughput compared to HTTP.
+
+    This client is suitable for applications requiring efficient data transfers and high-throughput operations within the 
+    App Mesh ecosystem, while maintaining compatibility with all other attributes and methods from `AppMeshClient`.
 
     Dependency:
-        pip3 install msgpack
+        - Install the required package for message serialization:
+            pip3 install msgpack
+
+    Usage:
+        - Import the client module:
+            from appmesh import appmesh_client
+
+    Example:
+        client = appmesh_client.AppMeshClientTCP()
+        client.login("your-name", "your-password")
+        client.file_download("/tmp/os-release", "os-release")
+
+    Attributes:
+        - Inherits all attributes from `AppMeshClient`, including TLS secure connections and JWT-based authentication.
+        - Optimized for TCP-based communication to provide better performance for large file transfers.
+
+    Methods:
+        - file_download()
+        - file_upload()
+        - Inherits all other methods from `AppMeshClient`, providing a consistent interface for managing applications within App Mesh.
     """
 
     def __init__(
@@ -1503,9 +1618,9 @@ class AppMeshClientTCP(AppMeshClient):
         appmesh_requst = RequestMsg()
         if super().jwt_token:
             appmesh_requst.headers["Authorization"] = "Bearer " + super().jwt_token
-        if super().delegate_host and len(super().delegate_host) > 0:
-            raise Exception("Not support delegate request in TCP mode")
-        appmesh_requst.headers[HTTP_USER_AGENT_HEADER_NAME] = HTTP_USER_AGENT_TCP
+        if super().forwarding_host and len(super().forwarding_host) > 0:
+            raise Exception("Not support forward request in TCP mode")
+        appmesh_requst.headers[HTTP_HEADER_KEY_USER_AGENT] = HTTP_USER_AGENT_TCP
         appmesh_requst.uuid = str(uuid.uuid1())
         appmesh_requst.http_method = method.value
         appmesh_requst.request_uri = path

{appmesh-1.3.1.dist-info → appmesh-1.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: appmesh
-Version: 1.3.1
+Version: 1.3.3
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi
@@ -25,11 +25,9 @@ Requires-Dist: aniso8601
 </a>
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/laoshanxi/app-mesh/badge)](https://api.securityscorecards.dev/projects/github.com/laoshanxi/app-mesh)
 
-# App Mesh
+# App Mesh: Advanced Application Management Platform
 
-App Mesh is a `Multi-Tenant`, `Cloud Native`, `Micro Service` application management platform designed to manage, schedule, and monitor applications. Each app can be a specific microservice for service discovery or a standard app with replication. App Mesh ensures all defined applications run on time with the specified behavior and resource requests. The platform supports both standalone and cluster modes and provides REST APIs, a command-line interface, and a web UI.
-
-App Mesh is similar to Kubernetes but is much more lightweight, supporting both containerized and native applications.
+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>
 
@@ -87,7 +85,7 @@ Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Instal
 | Non-container app | √        |
 | Service expose    | √        | √          |
 | Scheduler         | √        | √          |
-| Definition file   | JSON     | YAML       |
+| Definition file   | YAML     | YAML       |
 | GUI               | √        | √          |
 | Virtual Network   |          | √          |
 | Monitor tools     | √        | √          |
@@ -112,6 +110,7 @@ Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Instal
 - [Kubernetes run none-container applications](https://app-mesh.readthedocs.io/en/latest/success/kubernetes_run_native_application.html)
 - [Remote execute](https://app-mesh.readthedocs.io/en/latest/success/remote_run_cli_and_python.html)
 - [Python parallel run](https://app-mesh.readthedocs.io/en/latest/success/python_parallel_run.html)
+- [Secure consul cluster](https://app-mesh.readthedocs.io/en/latest/success/secure_consul_cluster.html)
 
 ---
 

appmesh-1.3.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+appmesh/__init__.py,sha256=xRdXeFHEieRauuJZElbEBASgXG0ZzU1a5_0isAhM7Gw,11
+appmesh/appmesh_client.py,sha256=Hsp4at6YCLcAoz8eRx928amyCTqN4ZAIFnVHxEbzDrI,67720
+appmesh-1.3.3.dist-info/METADATA,sha256=73_wYNYMLoHLoew35YGTd2bGKWhfScEObKhr07yyHx0,11191
+appmesh-1.3.3.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+appmesh-1.3.3.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
+appmesh-1.3.3.dist-info/RECORD,,

{appmesh-1.3.1.dist-info → appmesh-1.3.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

appmesh-1.3.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-appmesh/__init__.py,sha256=xRdXeFHEieRauuJZElbEBASgXG0ZzU1a5_0isAhM7Gw,11
-appmesh/appmesh_client.py,sha256=BHgPST7m4vFbGCzHfg_kaqFZZyP9dW-h2M8mEurfyt0,62882
-appmesh-1.3.1.dist-info/METADATA,sha256=qtqT4-GC1-PwliFwBHf-7Ixbt-UjgHiZ5DxO2JGkGfQ,11031
-appmesh-1.3.1.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-appmesh-1.3.1.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
-appmesh-1.3.1.dist-info/RECORD,,