appmesh 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

appmesh/appmesh_client.py

@@ -3,6 +3,7 @@
 import abc
 import aniso8601
 import base64
+import copy
 import json
 import os
 import socket
@@ -16,15 +17,173 @@ from datetime import datetime
 import requests
 
 
-DEFAULT_TOKEN_EXPIRE_SECONDS = "P1W"          # 7 days
-DEFAULT_RUN_APP_TIMEOUT_SECONDS = "PT1H"      # 1 hour
-DEFAULT_RUN_APP_LIFECYCLE_SECONDS = "PT10H"   # 10 hours
+DEFAULT_TOKEN_EXPIRE_SECONDS = "P1W"  # 7 days
+DEFAULT_RUN_APP_TIMEOUT_SECONDS = "PT1H"  # 1 hour
+DEFAULT_RUN_APP_LIFECYCLE_SECONDS = "PT10H"  # 10 hours
 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"
 
 
+def _get_str_item(data, key):
+    return str(data[key]) if (data and key in data and data[key]) else None
+
+
+def _get_int_item(data, key):
+    return int(data[key]) if (data and key in data and data[key]) else None
+
+
+def _get_bool_item(data, key):
+    return bool(data[key]) if (data and key in data and data[key]) else None
+
+
+def _get_dict_item(data, key):
+    return data[key] if (data and key in data and data[key]) else None
+
+
+class App(object):
+    """
+    App object present an application in App Mesh
+    """
+
+    class Behavior(object):
+        """
+        Application error handling behavior definition object
+        """
+
+        def __init__(self, data=None) -> None:
+            if isinstance(data, (str, bytes, bytearray)):
+                data = json.loads(data)
+            self.exit = _get_str_item(data, "exit")
+            self.control = copy.deepcopy(data)
+
+    class DailyLimitation(object):
+        """
+        Application avialable day time definition object
+        """
+
+        def __init__(self, data=None) -> None:
+            if isinstance(data, (str, bytes, bytearray)):
+                data = json.loads(data)
+            self.daily_start = _get_int_item(data, "daily_start")
+            self.daily_end = _get_int_item(data, "daily_end")
+
+    class ResourceLimitation(object):
+        """
+        Application cgroup limitation definition object
+        """
+
+        def __init__(self, data=None) -> None:
+            if isinstance(data, (str, bytes, bytearray)):
+                data = json.loads(data)
+            self.cpu_shares = _get_int_item(data, "cpu_shares")
+            self.memory_mb = _get_int_item(data, "memory_mb")
+            self.memory_virt_mb = _get_int_item(data, "memory_virt_mb")
+
+    def __init__(self, data=None):
+        """Construct an App Mesh Application object
+
+        Args:
+            data (str | dict | json, optional): application definition data
+        """
+
+        if isinstance(data, (str, bytes, bytearray)):
+            data = json.loads(data)
+
+        # mandatory parameters
+        self.name = _get_str_item(data, "name")
+        self.command = _get_str_item(data, "command")
+
+        self.shell = _get_bool_item(data, "shell")
+        self.description = _get_str_item(data, "description")
+        self.metadata = _get_str_item(data, "metadata")
+        self.working_dir = _get_str_item(data, "working_dir")
+        self.status = _get_int_item(data, "status")
+        self.docker_image = _get_str_item(data, "docker_image")
+        self.stdout_cache_num = _get_int_item(data, "stdout_cache_num")
+
+        self.start_time = _get_int_item(data, "start_time")
+        self.end_time = _get_int_item(data, "end_time")
+        self.interval = _get_int_item(data, "interval")
+        self.cron = _get_bool_item(data, "cron")
+        self.daily_limitation = App.DailyLimitation(_get_dict_item(data, "daily_limitation"))
+
+        self.retention = _get_str_item(data, "retention")
+        self.extra_time = _get_str_item(data, "extra_time")
+
+        self.health_check_cmd = _get_str_item(data, "health_check_cmd")
+        self.permission = _get_int_item(data, "permission")
+        self.behavior = App.Behavior(_get_dict_item(data, "behavior"))
+
+        self.env = dict()
+        if data and "env" in data:
+            for k, v in data["env"].items():
+                self.env[k] = v
+        self.sec_env = dict()
+        if data and "sec_env" in data:
+            for k, v in data["sec_env"].items():
+                self.sec_env[k] = v
+        self.pid = _get_int_item(data, "pid")
+        self.resource_limit = App.ResourceLimitation(_get_dict_item(data, "resource_limit"))
+
+        # readonly attributes
+        self.owner = _get_str_item(data, "owner")
+        self.pstree = _get_str_item(data, "pstree")
+        self.container_id = _get_str_item(data, "container_id")
+        self.memory = _get_int_item(data, "memory")
+        self.cpu = _get_int_item(data, "cpu")
+        self.fd = _get_int_item(data, "fd")
+        self.last_start_time = _get_int_item(data, "last_start_time")
+        self.last_exit_time = _get_int_item(data, "last_exit_time")
+        self.health = _get_int_item(data, "health")
+        self.version = _get_int_item(data, "version")
+        self.return_code = _get_int_item(data, "return_code")
+
+    def __str__(self) -> str:
+        output = copy.deepcopy(self.__dict__)
+        output["behavior"] = copy.deepcopy(self.behavior.__dict__)
+        output["daily_limitation"] = copy.deepcopy(self.daily_limitation.__dict__)
+        output["resource_limit"] = copy.deepcopy(self.resource_limit.__dict__)
+
+        def clean_empty_item(data, key) -> None:
+            value = data[key]
+            if not value:
+                del data[key]
+            elif isinstance(value, dict):
+                for k in list(value):
+                    clean_empty_item(value, k)
+
+        for k in list(output):
+            clean_empty_item(output, k)
+        for k in list(output):
+            clean_empty_item(output, k)
+        return json.dumps(output, indent=2)
+
+
+class Run(object):
+    """
+    Application run object indicate to a remote run from run_async()
+    """
+
+    def __init__(self, client, app_name: str, process_id: str):
+        self.app_name = app_name
+        self.proc_uid = process_id
+        self.__client = client
+
+    def wait(self, stdout_print: bool = True, timeout: int = 0) -> int:
+        """Wait for an async run to be finished
+
+        Args:
+            run (Run): asyncrized run result from run_async().
+            stdout_print (bool, optional): print remote stdout to local or not.
+            timeout (int, optional): wait max timeout seconds and return if not finished, 0 means wait until finished
+
+        Returns:
+            int: return exit code if process finished, return None for timeout or exception.
+        """
+        return self.__client.run_async_wait(self, stdout_print, timeout)
+
 
 class AppMeshClient(metaclass=abc.ABCMeta):
     """
@@ -36,17 +195,17 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     class Method(Enum):
         """REST methods"""
+
         GET = "GET"
         PUT = "PUT"
         POST = "POST"
         DELETE = "DELETE"
         POST_STREAM = "POST_STREAM"
 
-
     def __init__(
         self,
-        auth_enable: bool=True,
-        rest_url: str="https://127.0.0.1:6060",
+        auth_enable: bool = True,
+        rest_url: str = "https://127.0.0.1:6060",
         rest_ssl_verify=_SSL_CA_PEM_FILE,
         rest_timeout=(60, 300),
         jwt_token=None,
@@ -62,7 +221,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         """
         self.server_url = rest_url
         self.jwt_auth_enable = auth_enable
-        self.__jwt_token = token
+        self.__jwt_token = jwt_token
         self.ssl_verify = rest_ssl_verify
         self.rest_timeout = rest_timeout
 
@@ -87,7 +246,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     # Security
     ########################################
-    def login(self, user_name: str, user_pwd: str, timeout_seconds = DEFAULT_TOKEN_EXPIRE_SECONDS) -> str:
+    def login(self, user_name: str, user_pwd: str, timeout_seconds=DEFAULT_TOKEN_EXPIRE_SECONDS) -> str:
         """Login with user name and password
 
         Args:
@@ -133,7 +292,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         if self.jwt_auth_enable:
             self.jwt_token = token
             headers = {}
-            if permission is not None:
+            if permission:
                 headers["Auth-Permission"] = permission
             resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/auth", header=headers)
             if resp.status_code == HTTPStatus.OK:
@@ -147,28 +306,39 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     # Application view
     ########################################
-    def app_view(self, app_name: str):
-        """Get application information in JSON format
+    def app_view(self, app_name: str) -> App:
+        """Get one application information
 
         Args:
             app_name (str): the application name.
 
         Returns:
-            bool: success or failure.
-            dict: the application JSON both contain static configuration and runtime information.
+            App: the application object both contain static configuration and runtime information.
+
+        Exception:
+            failed request or no such application
         """
         resp = self._request_http(AppMeshClient.Method.GET, path=f"/appmesh/app/{app_name}")
-        return (resp.status_code == HTTPStatus.OK), resp.json()
+        if resp.status_code != HTTPStatus.OK:
+            raise Exception(resp.text)
+        return App(resp.json())
 
     def app_view_all(self):
-        """Get all applications in JSON format
+        """Get all applications
 
         Returns:
-            bool: success or failure.
-            dict: the application JSON both contain static configuration and runtime information, only return applications that the user has permissions.
+            list: the application object both contain static configuration and runtime information, only return applications that the user has permissions.
+
+        Exception:
+            failed request or no such application
         """
         resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/applications")
-        return (resp.status_code == HTTPStatus.OK), resp.json()
+        if resp.status_code != HTTPStatus.OK:
+            raise Exception(resp.text)
+        apps = []
+        for app in resp.json():
+            apps.append(App(app))
+        return apps
 
     def app_output(self, app_name: str, stdout_position: int = 0, stdout_index: int = 0, stdout_maxsize: int = 10240, process_uuid: str = "", timeout: int = 0):
         """Get application stdout/stderr
@@ -218,18 +388,22 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     # Application manage
     ########################################
-    def app_add(self, app_json: dict):
+    def app_add(self, app: App) -> App:
         """Register an application
 
         Args:
-            app_json (dict): the application definition.
+            app (App): the application definition.
 
         Returns:
-            bool: success or failure.
-            dict: resigtered application in JSON format.
+            App: resigtered application object.
+
+        Exception:
+            failed request
         """
-        resp = self._request_http(AppMeshClient.Method.PUT, path="/appmesh/app/{0}".format(app_json["name"]), body=app_json)
-        return (resp.status_code == HTTPStatus.OK), resp.json()
+        resp = self._request_http(AppMeshClient.Method.PUT, path="/appmesh/app/{0}".format(app.name), body=str(app))
+        if resp.status_code != HTTPStatus.OK:
+            raise Exception(resp.text)
+        return App(resp.json())
 
     def app_delete(self, app_name: str):
         """Remove an application.
@@ -414,7 +588,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         """
         resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/config", body={"LogLevel": level})
         if resp.status_code == HTTPStatus.OK:
-            return True,resp.json()["LogLevel"]
+            return True, resp.json()["LogLevel"]
         return (resp.status_code == HTTPStatus.OK), resp.json()
 
     ########################################
@@ -763,15 +937,15 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def run_async(
         self,
-        app_json: dict,
-        max_time_seconds = DEFAULT_RUN_APP_TIMEOUT_SECONDS,
-        life_cycle_seconds = DEFAULT_RUN_APP_LIFECYCLE_SECONDS,
+        app: App,
+        max_time_seconds=DEFAULT_RUN_APP_TIMEOUT_SECONDS,
+        life_cycle_seconds=DEFAULT_RUN_APP_LIFECYCLE_SECONDS,
     ):
         """Asyncrized run a command remotely, 'name' attribute in app_json dict used to run an existing application
         Asyncrized run will not block process
 
         Args:
-            app_json (dict): application JSON dict.
+            app (App): application object.
             max_time_seconds (int | str, optional): max run time for the remote process, support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P5W').
             life_cycle_seconds (int | str, optional): max lifecycle time for the remote process. support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P5W').
 
@@ -782,25 +956,19 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         path = "/appmesh/app/run"
         resp = self._request_http(
             AppMeshClient.Method.POST,
-            body=app_json,
+            body=str(app),
             path=path,
             query={"timeout": self._parse_duration(max_time_seconds), "lifecycle": self._parse_duration(life_cycle_seconds)},
         )
-        if resp.status_code == HTTPStatus.OK:
-            app_name = resp.json()["name"]
-            process_uuid = resp.json()["process_uuid"]
-            return (app_name, process_uuid)
-        else:
-            print(resp.text)
-        return None
+        if resp.status_code != HTTPStatus.OK:
+            raise Exception(resp.text)
+        return Run(self, resp.json()["name"], resp.json()["process_uuid"])
 
-    def run_async_wait(self, async_tuple: tuple, stdout_print: bool = True, timeout: int = 0) -> int:
+    def run_async_wait(self, run: Run, stdout_print: bool = True, timeout: int = 0) -> int:
         """Wait for an async run to be finished
 
         Args:
-            async_tuple (tuple): asyncrized run result from run_async().
-                async_tuple[0] app_name: application name from run_async
-                async_tuple[1] process_uuid: process uuid
+            run (Run): asyncrized run result from run_async().
             stdout_print (bool, optional): print remote stdout to local or not.
             timeout (int, optional): wait max timeout seconds and return if not finished, 0 means wait until finished
 
@@ -808,23 +976,21 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             int: return exit code if process finished, return None for timeout or exception.
         """
         exit_code = None
-        if async_tuple is not None:
-            app_name = async_tuple[0]
-            process_uuid = async_tuple[1]
+        if run:
             output_position = 0
             start = datetime.now()
             interval = 1 if self.__class__.__name__ == "AppMeshClient" else 1000
-            while len(process_uuid) > 0:
+            while len(run.proc_uid) > 0:
                 success, output, position, exit_code = self.app_output(
-                    app_name=app_name, stdout_position=output_position, stdout_index=0, process_uuid=process_uuid, timeout=interval
+                    app_name=run.app_name, stdout_position=output_position, stdout_index=0, process_uuid=run.proc_uid, timeout=interval
                 )
-                if output is not None and stdout_print:
+                if output and stdout_print:
                     print(output, end="")
                 if position is not None:
                     output_position = position
                 if exit_code is not None:
                     # success
-                    self.app_delete(app_name)
+                    self.app_delete(run.app_name)
                     break
                 if not success:
                     # failed
@@ -836,16 +1002,16 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def run_sync(
         self,
-        app_json: dict,
+        app: App,
         stdout_print: bool = True,
-        max_time_seconds = DEFAULT_RUN_APP_TIMEOUT_SECONDS,
-        life_cycle_seconds = DEFAULT_RUN_APP_LIFECYCLE_SECONDS,
+        max_time_seconds=DEFAULT_RUN_APP_TIMEOUT_SECONDS,
+        life_cycle_seconds=DEFAULT_RUN_APP_LIFECYCLE_SECONDS,
     ) -> int:
         """Block run a command remotely, 'name' attribute in app_json dict used to run an existing application
         The synchronized run will block the process until the remote run is finished then return the result from HTTP response
 
         Args:
-            app_json (dict): application JSON dict.
+            app (App): application object.
             stdout_print (bool, optional): whether print remote stdout to local or not. Defaults to True.
             max_time_seconds (int | str, optional): max run time for the remote process. support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P5W').
             life_cycle_seconds (int | str, optional): max lifecycle time for the remote process. support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P5W').
@@ -856,7 +1022,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         path = "/appmesh/app/syncrun"
         resp = self._request_http(
             AppMeshClient.Method.POST,
-            body=app_json,
+            body=str(app),
             path=path,
             query={"timeout": self._parse_duration(max_time_seconds), "lifecycle": self._parse_duration(life_cycle_seconds)},
         )
@@ -884,7 +1050,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             requests.Response: HTTP response
         """
         rest_url = parse.urljoin(self.server_url, path)
-        if self.jwt_token is not None:
+        if self.jwt_token:
             header["Authorization"] = "Bearer " + self.jwt_token
 
         if method is AppMeshClient.Method.GET:
@@ -969,10 +1135,10 @@ class AppMeshClientTCP(AppMeshClient):
         while length:
             chunk = self.__socket_client.recv(length)
             if not chunk:
-                raise EOFError('socket closed')
+                raise EOFError("socket closed")
             length -= len(chunk)
             fragments.append(chunk)
-        return b''.join(fragments)
+        return b"".join(fragments)
 
     def _request_http(self, method: AppMeshClient.Method, path: str, query: dict = {}, header: dict = {}, body=None) -> requests.Response:
         """TCP API
@@ -988,12 +1154,13 @@ class AppMeshClientTCP(AppMeshClient):
             requests.Response: HTTP response
         """
         import msgpack
+
         class RequestMsg:
             uuid: str = ""
             request_uri: str = ""
             http_method: str = ""
             client_addr: str = ""
-            body: bytes = b''
+            body: bytes = b""
             headers: dict = {}
             querys: dict = {}
 
@@ -1009,17 +1176,16 @@ class AppMeshClientTCP(AppMeshClient):
             request_uri: str = ""
             http_status: int = 0
             body_msg_type: str = ""
-            body: bytes = b''
+            body: bytes = b""
             headers: dict = {}
 
             def desirialize(self, buf: bytes):
                 dic = msgpack.unpackb(buf)
-                for k,v in dic.items():
+                for k, v in dic.items():
                     setattr(self, k, v)
                 return self
 
-
-        if super().jwt_token is not None:
+        if super().jwt_token:
             header["Authorization"] = "Bearer " + super().jwt_token
         if self.__socket_client is None:
             self.__connect_socket()
@@ -1079,8 +1245,7 @@ class AppMeshClientTCP(AppMeshClient):
         Returns:
             bool: success or failure.
         """
-        resp = self._request_http(
-            AppMeshClient.Method.GET, path="/appmesh/file/download", header={"File-Path": file_path})
+        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/file/download", header={"File-Path": file_path})
         if resp.status_code == HTTPStatus.OK:
             with open(local_file, "wb") as fp:
                 chunk_data = bytes()
@@ -1130,7 +1295,7 @@ class AppMeshClientTCP(AppMeshClient):
             # https://stackoverflow.com/questions/22567306/python-requests-file-upload
             resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/file/upload", header=header)
             if resp.status_code == HTTPStatus.OK:
-                chunk_size = 1024*4  # 131072 bytes, default max ssl buffer size
+                chunk_size = 1024 * 4  # 131072 bytes, default max ssl buffer size
                 chunk_data = fp.read(chunk_size)
                 while chunk_data:
                     self.__socket_client.sendall(len(chunk_data).to_bytes(TCP_MESSAGE_HEADER_LENGTH, "big", signed=False))

{appmesh-0.2.2.dist-info → appmesh-0.2.4.dist-info}/METADATA

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

appmesh-0.2.4.dist-info/RECORD

@@ -0,0 +1,6 @@
+appmesh/__init__.py,sha256=xRdXeFHEieRauuJZElbEBASgXG0ZzU1a5_0isAhM7Gw,11
+appmesh/appmesh_client.py,sha256=8lR_gF4_BYzWgg63XBIaJuSGJeSE7jt066v1QLFq-pc,49634
+appmesh-0.2.4.dist-info/METADATA,sha256=LtKj7oblEzep3qW4RhcsWUt1oCgyUj5Nv_i-BWfE2uI,10620
+appmesh-0.2.4.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+appmesh-0.2.4.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
+appmesh-0.2.4.dist-info/RECORD,,

{appmesh-0.2.2.dist-info → appmesh-0.2.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.40.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

appmesh-0.2.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-appmesh/__init__.py,sha256=xRdXeFHEieRauuJZElbEBASgXG0ZzU1a5_0isAhM7Gw,11
-appmesh/appmesh_client.py,sha256=zt-lh9SoCM-ESoyPmymPKl0RLezy5cHLoIO3X43iC5c,43891
-appmesh-0.2.2.dist-info/METADATA,sha256=D4Qzb8cl-433r_8xJ2a1If7kCS79ZHQMc5YNofl7ydQ,10620
-appmesh-0.2.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-appmesh-0.2.2.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
-appmesh-0.2.2.dist-info/RECORD,,