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

appmesh/__init__.py

@@ -5,16 +5,14 @@ App Mesh SDK package initializer.
 This module exports the main client classes used to interact with the App Mesh API.
 
 Example:
-    from appmesh import AppMeshClient, AppMeshClientTCP
-
+    from appmesh import AppMeshClient
     client = AppMeshClient()
-    client_tcp = AppMeshClientTCP()
 """
 
 from .app import App
-from .http_client import AppMeshClient
-from .tcp_client import AppMeshClientTCP
-from .http_server import AppMeshServer
-from .tcp_server import AppMeshServerTCP
+from .client_http import AppMeshClient
+from .client_tcp import AppMeshClientTCP
+from .server_http import AppMeshServer
+from .server_tcp import AppMeshServerTCP
 
 __all__ = ["App", "AppMeshClient", "AppMeshClientTCP", "AppMeshServer", "AppMeshServerTCP"]

appmesh/app.py

@@ -1,3 +1,4 @@
+# app.py
 """Application definition"""
 
 import json
@@ -10,9 +11,9 @@ from enum import Enum, unique
 # pylint: disable=line-too-long
 
 
-class App(object):
+class App:
     """
-    Represents an application in App Mesh, including configuration, resource limitations, behaviors, and permissions.
+    An application in App Mesh, include all the process attributes, resource limitations, behaviors, and permissions.
     """
 
     @staticmethod
@@ -23,17 +24,24 @@ class App(object):
     @staticmethod
     def _get_int_item(data: dict, key: str) -> 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
+        if data and key in data and data[key] is not None:
+            if isinstance(data[key], int):
+                return data[key]
+            elif isinstance(data[key], str) and data[key].isdigit():
+                return int(data[key])
+        return None
 
     @staticmethod
     def _get_bool_item(data: dict, key: str) -> Optional[bool]:
         """Retrieve a boolean value from a dictionary by key, if it exists and is boolean-like."""
-        return bool(data[key]) if (data and key in data and data[key]) else None
+        if data and key in data and data[key] is not None:
+            return bool(data[key])
+        return None
 
     @staticmethod
     def _get_native_item(data: dict, key: str) -> 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
+        return copy.deepcopy(data[key]) if (data and key in data and data[key] is not None) else None
 
     @unique
     class Permission(Enum):
@@ -43,7 +51,7 @@ class App(object):
         READ = "2"
         WRITE = "3"
 
-    class Behavior(object):
+    class Behavior:
         """
         Manages application error handling behavior, including exit and control behaviors.
         """
@@ -67,15 +75,15 @@ class App(object):
             self.control = App._get_native_item(data, "control") or {}
             """Exit code specific behavior (e.g, --control 0:restart --control 1:standby), higher priority than default exit behavior"""
 
-        def set_exit_behavior(self, action: Action) -> None:
+        def set_exit_behavior(self, action: "App.Behavior.Action") -> None:
             """Set default behavior for application exit."""
             self.exit = action.value
 
-        def set_control_behavior(self, control_code: int, action: Action) -> None:
+        def set_control_behavior(self, control_code: int, action: "App.Behavior.Action") -> None:
             """Define behavior for specific exit codes."""
             self.control[str(control_code)] = action.value
 
-    class DailyLimitation(object):
+    class DailyLimitation:
         """
         Defines application availability within a daily time range.
         """
@@ -88,14 +96,14 @@ class App(object):
             """Start time for application availability (e.g., 09:00:00+08)."""
 
             self.daily_end = App._get_int_item(data, "daily_end")
-            """End time for application availability (e.g., 20:00:00+08)."""
+            """End time for application availability (e.g., 09:00:00+08)."""
 
         def set_daily_range(self, start: datetime, end: datetime) -> None:
             """Set the valid daily start and end times."""
             self.daily_start = int(start.timestamp())
             self.daily_end = int(end.timestamp())
 
-    class ResourceLimitation(object):
+    class ResourceLimitation:
         """
         Defines application resource limits, such as CPU and memory usage.
         """
@@ -217,7 +225,7 @@ class App(object):
             keys_to_delete = []
             for key, value in data.items():
                 if isinstance(value, dict) and key != "metadata":
-                    clean_empty(value)  # Recursive call (without check user metadata)
+                    clean_empty(value)  # Recursive call (without checking user metadata)
                 if data[key] in [None, "", {}]:
                     keys_to_delete.append(key)  # Mark keys for deletion
 

appmesh/app_output.py

@@ -1,3 +1,4 @@
+# app_output.py
 """Application output information"""
 
 from http import HTTPStatus
@@ -8,13 +9,13 @@ from typing import Optional
 
 class AppOutput(object):
     """
-    Represents the output information returned by the `app_output()` API, including the application's
-    stdout content, current read position, status code, and exit code.
+    Represents the output information returned by the `app_output()` API.
+    including the application's stdout , current read position, http status code, and process exit code.
     """
 
     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 from the `app_output()` API request, indicating the result status."""
+        """HTTP status code from the `app_output()` API request, indicating the http status."""
 
         self.output = output
         """Captured stdout content of the application as returned by the `app_output()` API."""

appmesh/app_run.py

@@ -1,11 +1,12 @@
-"""Application run object"""
+# app_run.py
+"""Application run object for remote application execution."""
 
 from contextlib import contextmanager
 
 # pylint: disable=line-too-long
 
 
-class AppRun(object):
+class AppRun:
     """
     Represents an application run object initiated by `run_async()` for monitoring and retrieving
     the result of a remote application run.
@@ -26,7 +27,14 @@ class AppRun(object):
 
     @contextmanager
     def forward_to(self):
-        """Context manager to override the `forward_to` for the duration of the run."""
+        """Context manager to temporarily override the client's `forward_to` setting.
+
+        This ensures that operations during this run use the correct target server,
+        then restores the original setting when done.
+
+        Yields:
+            None: Context for the overridden forward_to setting.
+        """
         original_value = self._client.forward_to
         self._client.forward_to = self._forward_to
         try:
@@ -38,11 +46,12 @@ class AppRun(object):
         """Wait for the asynchronous run to complete.
 
         Args:
-            stdout_print (bool, optional): If `True`, prints remote stdout to local. Defaults to `True`.
-            timeout (int, optional): Maximum time to wait in seconds. If `0`, waits until completion. Defaults to `0`.
+            stdout_print: If `True`, prints remote stdout to local console. Defaults to `True`.
+            timeout: Maximum time to wait in seconds. If `0`, waits indefinitely until completion.
+                    Defaults to `0`.
 
         Returns:
-            int: Exit code if the process finishes successfully. Returns `None` on timeout or exception.
+            Exit code if the process finishes successfully, or `None` on timeout or exception.
         """
         with self.forward_to():
             return self._client.wait_for_async_run(self, stdout_print, timeout)

appmesh/appmesh_client.py

@@ -3,6 +3,6 @@
 # Legacy Compatibility Layer
 # These imports provide backward compatibility for older code that relies on
 # AppMeshClient, App, and AppOutput classes. The updated implementation can be found
-# in http_client.py, where these classes are now primarily maintained.
+# in client_http.py, where these classes are now primarily maintained.
 
-from .http_client import AppMeshClient, App, AppOutput
+from .client_http import AppMeshClient, App, AppOutput

appmesh/{http_client.py → client_http.py}

@@ -1,10 +1,11 @@
-# HTTP-based App Mesh Client
+# client_http.py
 # pylint: disable=broad-exception-raised,line-too-long,broad-exception-caught,too-many-lines, import-outside-toplevel, protected-access
 import abc
 import base64
 import json
 import logging
 import os
+import time
 from datetime import datetime
 from enum import Enum, unique
 from http import HTTPStatus
@@ -14,7 +15,6 @@ from urllib import parse
 import aniso8601
 import jwt
 import requests
-import time
 from .app import App
 from .app_run import AppRun
 from .app_output import AppOutput
@@ -71,6 +71,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         - run_app_async()
         - wait_for_async_run()
         - run_app_sync()
+        - run_task()
 
         # System Management
         - forward_to
@@ -108,9 +109,11 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     DURATION_TWO_DAYS_HALF_ISO = "P2DT12H"
     TOKEN_REFRESH_INTERVAL = 60
 
-    DEFAULT_SSL_CA_CERT_PATH = "/opt/appmesh/ssl/ca.pem"
-    DEFAULT_SSL_CLIENT_CERT_PATH = "/opt/appmesh/ssl/client.pem"
-    DEFAULT_SSL_CLIENT_KEY_PATH = "/opt/appmesh/ssl/client-key.pem"
+    # Platform-aware default SSL paths
+    _DEFAULT_SSL_DIR = "c:/local/appmesh/ssl" if os.name == "nt" else "/opt/appmesh/ssl"
+    DEFAULT_SSL_CA_CERT_PATH = os.path.join(_DEFAULT_SSL_DIR, "ca.pem")
+    DEFAULT_SSL_CLIENT_CERT_PATH = os.path.join(_DEFAULT_SSL_DIR, "client.pem")
+    DEFAULT_SSL_CLIENT_KEY_PATH = os.path.join(_DEFAULT_SSL_DIR, "client-key.pem")
 
     DEFAULT_JWT_AUDIENCE = "appmesh-service"
 
@@ -322,7 +325,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         try:
             self.close()
         except Exception:
-            pass  # Avoid exceptions during garbage collection
+            pass  # Never raise in __del__
 
     @property
     def jwt_token(self) -> str:
@@ -1396,9 +1399,9 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         try:
             if method is AppMeshClient.Method.GET:
-                return self.session.get(url=rest_url, params=query, headers=header, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
+                resp = self.session.get(url=rest_url, params=query, headers=header, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
             elif method is AppMeshClient.Method.POST:
-                return self.session.post(
+                resp = self.session.post(
                     url=rest_url,
                     params=query,
                     headers=header,
@@ -1408,12 +1411,21 @@ class AppMeshClient(metaclass=abc.ABCMeta):
                     timeout=self.rest_timeout,
                 )
             elif method is AppMeshClient.Method.POST_STREAM:
-                return self.session.post(url=rest_url, params=query, headers=header, data=body, cert=self.ssl_client_cert, verify=self.ssl_verify, stream=True, timeout=self.rest_timeout)
+                resp = self.session.post(url=rest_url, params=query, headers=header, data=body, cert=self.ssl_client_cert, verify=self.ssl_verify, stream=True, timeout=self.rest_timeout)
             elif method is AppMeshClient.Method.DELETE:
-                return self.session.delete(url=rest_url, headers=header, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
+                resp = self.session.delete(url=rest_url, headers=header, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
             elif method is AppMeshClient.Method.PUT:
-                return self.session.put(url=rest_url, params=query, headers=header, data=body, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
+                resp = self.session.put(url=rest_url, params=query, headers=header, data=body, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
             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
         except requests.exceptions.RequestException as e:
             raise Exception(f"HTTP request failed: {str(e)}")

appmesh/{tcp_client.py → client_tcp.py}

@@ -1,4 +1,4 @@
-# TCP-based App Mesh Client
+# client_tcp.py
 # pylint: disable=line-too-long,broad-exception-raised,broad-exception-caught,import-outside-toplevel,protected-access
 
 import json
@@ -6,7 +6,7 @@ import os
 import socket
 import uuid
 import requests
-from .appmesh_client import AppMeshClient
+from .client_http import AppMeshClient
 from .tcp_transport import TCPTransport
 from .tcp_messages import RequestMessage, ResponseMessage
 
@@ -28,10 +28,10 @@ class AppMeshClientTCP(AppMeshClient):
 
     Usage:
         - Import the client module:
-            from appmesh import appmesh_client
+            from appmesh import AppMeshClientTCP
 
     Example:
-        client = appmesh_client.AppMeshClientTCP()
+        client = AppMeshClientTCP()
         client.login("your-name", "your-password")
         client.file_download("/tmp/os-release", "os-release")
 
@@ -83,20 +83,34 @@ class AppMeshClientTCP(AppMeshClient):
         self.tcp_transport = TCPTransport(address=tcp_address, ssl_verify=rest_ssl_verify, ssl_client_cert=rest_ssl_client_cert)
         super().__init__(rest_ssl_verify=rest_ssl_verify, rest_ssl_client_cert=rest_ssl_client_cert, jwt_token=jwt_token)
 
+    def close(self):
+        """Close the connection and release resources."""
+        if hasattr(self, "tcp_transport") and self.tcp_transport:
+            self.tcp_transport.close()
+            self.tcp_transport = None
+        return super().close()
+
+    def __del__(self):
+        """Ensure resources are properly released when the object is garbage collected."""
+        try:
+            self.close()
+        except Exception:
+            pass  # Never raise in __del__
+        super().__del__()
+
     def _request_http(self, method: AppMeshClient.Method, path: str, query: dict = None, header: dict = None, body=None) -> requests.Response:
-        """TCP API
+        """Send HTTP request over TCP transport.
 
         Args:
-            method (Method): AppMeshClient.Method.
-            path (str): URI patch str.
-            query (dict, optional): HTTP query parameters.
+            method (Method): HTTP method.
+            path (str): URI path.
+            query (dict, optional): Query parameters.
             header (dict, optional): HTTP headers.
-            body (_type_, optional): object to send in the body of the :class:`Request`.
+            body: Request body.
 
         Returns:
-            requests.Response: HTTP response
+            requests.Response: Simulated HTTP response.
         """
-
         if not self.tcp_transport.connected():
             self.tcp_transport.connect()
 
@@ -110,8 +124,9 @@ class AppMeshClientTCP(AppMeshClient):
         appmesh_request.http_method = method.value
         appmesh_request.request_uri = path
         appmesh_request.client_addr = socket.gethostname()
+
         if body:
-            if isinstance(body, dict) or isinstance(body, list):
+            if isinstance(body, (dict, list)):
                 appmesh_request.body = bytes(json.dumps(body, indent=2), self.ENCODING_UTF8)
             elif isinstance(body, str):
                 appmesh_request.body = bytes(body, self.ENCODING_UTF8)
@@ -119,20 +134,23 @@ class AppMeshClientTCP(AppMeshClient):
                 appmesh_request.body = body
             else:
                 raise Exception(f"UnSupported body type: {type(body)}")
+
         if header:
             for k, v in header.items():
                 appmesh_request.headers[k] = v
         if query:
             for k, v in query.items():
                 appmesh_request.querys[k] = v
+
         data = appmesh_request.serialize()
         self.tcp_transport.send_message(data)
 
         resp_data = self.tcp_transport.receive_message()
-        if resp_data is None or len(resp_data) == 0:
+        if not resp_data:  # Covers None and empty bytes
             self.tcp_transport.close()
             raise Exception("socket connection broken")
-        appmesh_resp = ResponseMessage().desirialize(resp_data)
+
+        appmesh_resp = ResponseMessage().deserialize(resp_data)
         response = requests.Response()
         response.status_code = appmesh_resp.http_status
         response.encoding = self.ENCODING_UTF8
@@ -140,24 +158,27 @@ class AppMeshClientTCP(AppMeshClient):
         response.headers = appmesh_resp.headers
         if appmesh_resp.body_msg_type:
             response.headers["Content-Type"] = appmesh_resp.body_msg_type
+
         return response
 
     ########################################
     # File management
     ########################################
     def download_file(self, remote_file: str, local_file: str, apply_file_attributes: bool = True) -> None:
-        """Copy a remote file to local, the local file will have the same permission as the remote file
+        """Copy a remote file to local, preserving file attributes if requested.
 
         Args:
-            remote_file (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.
+            remote_file (str): Remote file path.
+            local_file (str): Local destination path.
+            apply_file_attributes (bool): Apply remote file permissions/ownership locally.
         """
-        header = {AppMeshClient.HTTP_HEADER_KEY_X_FILE_PATH: remote_file}
-        header[self.HTTP_HEADER_KEY_X_RECV_FILE_SOCKET] = "true"
+        header = {
+            AppMeshClient.HTTP_HEADER_KEY_X_FILE_PATH: remote_file,
+            self.HTTP_HEADER_KEY_X_RECV_FILE_SOCKET: "true",
+        }
         resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/file/download", header=header)
-
         resp.raise_for_status()
+
         if self.HTTP_HEADER_KEY_X_RECV_FILE_SOCKET not in resp.headers:
             raise ValueError(f"Server did not respond with socket transfer option: {self.HTTP_HEADER_KEY_X_RECV_FILE_SOCKET}")
 
@@ -180,23 +201,22 @@ class AppMeshClientTCP(AppMeshClient):
                     print(f"Warning: Unable to change owner/group of {local_file}. Operation requires elevated privileges.")
 
     def upload_file(self, local_file: str, remote_file: str, apply_file_attributes: bool = True) -> None:
-        """Upload a local file to the remote server, the remote file will have the same permission as the local file
-
-        Dependency:
-            sudo apt install python3-pip
-            pip3 install requests_toolbelt
+        """Upload a local file to remote server, preserving file attributes if requested.
 
         Args:
-            local_file (str): the local file path.
-            remote_file (str): the target remote file to be uploaded.
-            apply_file_attributes (bool): whether to upload file attributes (permissions, owner, group) along with the file.
+            local_file (str): Local file path.
+            remote_file (str): Remote destination path.
+            apply_file_attributes (bool): Upload file permissions/ownership metadata.
         """
         if not os.path.exists(local_file):
             raise FileNotFoundError(f"Local file not found: {local_file}")
 
         with open(file=local_file, mode="rb") as fp:
-            header = {AppMeshClient.HTTP_HEADER_KEY_X_FILE_PATH: remote_file, "Content-Type": "text/plain"}
-            header[self.HTTP_HEADER_KEY_X_SEND_FILE_SOCKET] = "true"
+            header = {
+                AppMeshClient.HTTP_HEADER_KEY_X_FILE_PATH: remote_file,
+                "Content-Type": "text/plain",
+                self.HTTP_HEADER_KEY_X_SEND_FILE_SOCKET: "true",
+            }
 
             if apply_file_attributes:
                 file_stat = os.stat(local_file)
@@ -205,8 +225,8 @@ class AppMeshClientTCP(AppMeshClient):
                 header["X-File-Group"] = str(file_stat.st_gid)
 
             resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/file/upload", header=header)
-
             resp.raise_for_status()
+
             if self.HTTP_HEADER_KEY_X_SEND_FILE_SOCKET not in resp.headers:
                 raise ValueError(f"Server did not respond with socket transfer option: {self.HTTP_HEADER_KEY_X_SEND_FILE_SOCKET}")
 
@@ -214,6 +234,6 @@ class AppMeshClientTCP(AppMeshClient):
             while True:
                 chunk_data = fp.read(chunk_size)
                 if not chunk_data:
-                    self.tcp_transport.send_message([])
+                    self.tcp_transport.send_message([])  # EOF signal
                     break
                 self.tcp_transport.send_message(chunk_data)

appmesh/{http_server.py → server_http.py}

@@ -1,4 +1,4 @@
-# TCP-based App Mesh Server
+# server_http.py
 # pylint: disable=line-too-long,broad-exception-raised,broad-exception-caught,import-outside-toplevel,protected-access
 
 import abc
@@ -7,7 +7,7 @@ import os
 import time
 from typing import Optional, Tuple
 from http import HTTPStatus
-from .http_client import AppMeshClient
+from .client_http import AppMeshClient
 
 logger = logging.getLogger(__name__)
 

appmesh/{tcp_server.py → server_tcp.py}

@@ -1,12 +1,12 @@
-# TCP-based App Mesh Server
+# server_tcp.py
 # pylint: disable=line-too-long,broad-exception-raised,broad-exception-caught,import-outside-toplevel,protected-access
 
 import os
 import logging
 from typing import Optional, Tuple
-from .http_client import AppMeshClient
-from .tcp_client import AppMeshClientTCP
-from .http_server import AppMeshServer
+from .client_http import AppMeshClient
+from .client_tcp import AppMeshClientTCP
+from .server_http import AppMeshServer
 
 logger = logging.getLogger(__name__)
 
@@ -31,5 +31,6 @@ class AppMeshServerTCP(AppMeshServer):
         """
         # Deliberately avoid calling super().__init__ to inject a TCP client while keeping the same public API.
         object.__init__(self)
+        # super().__init__(rest_ssl_verify=rest_ssl_verify, rest_ssl_client_cert=rest_ssl_client_cert)
         self._client = AppMeshClientTCP(rest_ssl_verify=rest_ssl_verify, rest_ssl_client_cert=rest_ssl_client_cert, tcp_address=tcp_address)
         self._logger = logger_ or logger

appmesh/tcp_messages.py

@@ -4,7 +4,7 @@ import msgpack
 
 
 class RequestMessage:
-    """HTTP request message"""
+    """TCP request message for HTTP-like communication"""
 
     uuid: str = ""
     request_uri: str = ""
@@ -24,7 +24,7 @@ class RequestMessage:
 
 
 class ResponseMessage:
-    """HTTP response message"""
+    """TCP response message for HTTP-like communication"""
 
     uuid: str = ""
     request_uri: str = ""
@@ -33,7 +33,7 @@ class ResponseMessage:
     body: str = ""
     headers: dict = {}
 
-    def desirialize(self, buf: bytes):
+    def deserialize(self, buf: bytes):
         """Deserialize response message"""
         dic = msgpack.unpackb(buf)
         for k, v in dic.items():

appmesh/tcp_transport.py

@@ -67,6 +67,7 @@ class TCPTransport:
             context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
         # Configure SSL verification
         if not self.ssl_verify:
+            context.check_hostname = False
             context.verify_mode = ssl.CERT_NONE
         else:
             context.verify_mode = ssl.CERT_REQUIRED  # Require certificate verification
@@ -94,7 +95,7 @@ class TCPTransport:
         # Create a TCP socket
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.setblocking(True)
-        sock.settimeout(30)  # Connection timeout set to 30 seconds
+        # sock.settimeout(30)  # Connection timeout set to 30 seconds
         try:
             # Wrap the socket with SSL/TLS
             ssl_socket = context.wrap_socket(sock, server_hostname=self.tcp_address[0])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appmesh
-Version: 1.5.8
+Version: 1.6.0
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi
@@ -102,7 +102,7 @@ Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Instal
 | GUI               | √        | √          |
 | Virtual Network   |          | √          |
 | Monitor tools     | √        | √          |
-| [Remote API call](https://app-mesh.readthedocs.io/en/latest/RemoteTask.html)   | √        |            |
+| [Remote task](https://app-mesh.readthedocs.io/en/latest/RemoteTask.html)   | √        |            |
 
 ---
 
@@ -126,6 +126,7 @@ Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Instal
 - [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)
 - [JWT service with REST and UI](https://github.com/laoshanxi/app-mesh/blob/main/script/docker-compose-auth-service.yaml)
+- [Remote task execute](https://app-mesh.readthedocs.io/en/latest/RemoteTask.html)
 
 ---
 

appmesh-1.6.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+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=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-1.5.8.dist-info/RECORD

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