appmesh 1.4.7__py3-none-any.whl → 1.4.8__py3-none-any.whl

appmesh/http_client.py

@@ -14,7 +14,6 @@ import requests
 from .app import App
 from .app_run import AppRun
 from .app_output import AppOutput
-from .keycloak import KeycloakClient
 
 
 class AppMeshClient(metaclass=abc.ABCMeta):
@@ -145,9 +144,9 @@ class AppMeshClient(metaclass=abc.ABCMeta):
                 - `str`: Path to a custom CA certificate or directory for verification. This option allows custom CA configuration,
                 which may be necessary in environments requiring specific CA chains that differ from the default system CAs.
 
-            rest_ssl_client_cert (Union[tuple, str], optional): Specifies a client certificate for mutual TLS authentication:
-                - If a `str`, provides the path to a PEM file with both client certificate and private key.
-                - If a `tuple`, contains two paths as (`cert`, `key`), where `cert` is the certificate file and `key` is the private key file.
+            ssl_client_cert (Union[str, Tuple[str, str]], optional): Path to the SSL client certificate and key. Can be:
+                - `str`: A path to a single PEM file containing both the client certificate and private key.
+                - `tuple`: A pair of paths (`cert_file`, `key_file`), where `cert_file` is the client certificate file path and `key_file` is the private key file path.
 
             rest_timeout (tuple, optional): HTTP connection timeouts for API requests, as `(connect_timeout, read_timeout)`.
                 The default is `(60, 300)`, where `60` seconds is the maximum time to establish a connection and `300` seconds for the maximum read duration.
@@ -155,14 +154,14 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             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_server_url: Keycloak server URL (e.g. "https://keycloak.example.com")
                 - realm: Keycloak realm
                 - client_id: Keycloak client ID
                 - client_secret: Keycloak client secret (optional)
         """
 
         self.session = requests.Session()
-        self.server_url = rest_url
+        self.auth_server_url = rest_url
         self._jwt_token = jwt_token
         self.ssl_verify = rest_ssl_verify
         self.ssl_client_cert = rest_ssl_client_cert
@@ -172,30 +171,41 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         # Keycloak integration
         self._keycloak_client = None
         if oauth2_config:
+            from .keycloak import KeycloakClient  # lazy import
+
             self._keycloak_client = KeycloakClient(
-                server_url=oauth2_config.get("server_url"),
+                auth_server_url=oauth2_config.get("auth_server_url"),
                 realm=oauth2_config.get("realm"),
                 client_id=oauth2_config.get("client_id"),
                 client_secret=oauth2_config.get("client_secret"),
                 ssl_verify=oauth2_config.get("ssl_verify", self.ssl_verify),
                 timeout=oauth2_config.get("timeout", (30, 60)),
             )
-            
+
     def close(self):
         """Close the session and release resources."""
-        if hasattr(self, 'session'):
+        if hasattr(self, "session") and self.session:
             self.session.close()
-        if self._keycloak_client and hasattr(self._keycloak_client, 'close'):
+            self.session = None
+        if self._keycloak_client and hasattr(self._keycloak_client, "close"):
             self._keycloak_client.close()
-            
+            self._keycloak_client = None
+
     def __enter__(self):
         """Support for context manager protocol."""
         return self
-        
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Support for context manager protocol, ensuring resources are released."""
         self.close()
 
+    def __del__(self):
+        """Ensure resources are properly released when the object is garbage collected."""
+        try:
+            self.close()
+        except Exception:
+            pass  # Avoid exceptions during garbage collection
+
     @property
     def jwt_token(self) -> str:
         """Get the current JWT (JSON Web Token) used for authentication.
@@ -1090,12 +1100,15 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             while len(run.proc_uid) > 0:
                 app_out = self.get_app_output(app_name=run.app_name, stdout_position=last_output_position, stdout_index=0, process_uuid=run.proc_uid, timeout=interval)
                 if app_out.output and stdout_print:
-                    print(app_out.output, end="")
+                    print(app_out.output, end="", flush=True)
                 if app_out.out_position is not None:
                     last_output_position = app_out.out_position
                 if app_out.exit_code is not None:
                     # success
-                    self.delete_app(run.app_name)
+                    try:
+                        self.delete_app(run.app_name)
+                    except Exception:
+                        pass
                     return app_out.exit_code
                 if app_out.status_code != HTTPStatus.OK:
                     # failed
@@ -1169,9 +1182,12 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         """
         # Try to refresh token via Keycloak if using Keycloak and token needs refreshing
         if self._keycloak_client and self.jwt_token and not self._keycloak_client.validate_token():
-            self.jwt_token = self._keycloak_client.get_active_token()
+            try:
+                self.jwt_token = self._keycloak_client.get_active_token()
+            except Exception as e:
+                print(f"Token refresh failed: {str(e)}")
 
-        rest_url = parse.urljoin(self.server_url, path)
+        rest_url = parse.urljoin(self.auth_server_url, path)
 
         header = {} if header is None else header
         if self.jwt_token:
@@ -1180,20 +1196,29 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             if ":" in self.forward_to:
                 header[self.HTTP_HEADER_KEY_X_TARGET_HOST] = self.forward_to
             else:
-                header[self.HTTP_HEADER_KEY_X_TARGET_HOST] = self.forward_to + ":" + str(parse.urlsplit(self.server_url).port)
+                header[self.HTTP_HEADER_KEY_X_TARGET_HOST] = self.forward_to + ":" + str(parse.urlsplit(self.auth_server_url).port)
         header[self.HTTP_HEADER_KEY_USER_AGENT] = self.HTTP_USER_AGENT
 
-        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)
-        elif method is AppMeshClient.Method.POST:
-            return self.session.post(
-                url=rest_url, params=query, headers=header, data=json.dumps(body) if type(body) in (dict, list) else body, cert=self.ssl_client_cert, verify=self.ssl_verify, 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)
-        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)
-        elif method is AppMeshClient.Method.PUT:
-            return self.session.put(url=rest_url, params=query, headers=header, json=body, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
-        else:
-            raise Exception("Invalid http method", method)
+        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)
+            elif method is AppMeshClient.Method.POST:
+                return self.session.post(
+                    url=rest_url,
+                    params=query,
+                    headers=header,
+                    data=json.dumps(body) if type(body) in (dict, list) else body,
+                    cert=self.ssl_client_cert,
+                    verify=self.ssl_verify,
+                    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)
+            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)
+            elif method is AppMeshClient.Method.PUT:
+                return self.session.put(url=rest_url, params=query, headers=header, json=body, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
+            else:
+                raise Exception("Invalid http method", method)
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"HTTP request failed: {str(e)}")

appmesh/keycloak.py

@@ -19,7 +19,7 @@ class KeycloakClient:
 
     def __init__(
         self,
-        server_url: str,
+        auth_server_url: str,
         realm: str,
         client_id: str,
         client_secret: Optional[str] = None,
@@ -30,7 +30,7 @@ class KeycloakClient:
         """Initialize Keycloak client.
 
         Args:
-            server_url (str): Keycloak server URL (e.g. https://keycloak.example.com/auth)
+            auth_server_url (str): Keycloak server URL (e.g. https://keycloak.example.com/auth)
             realm (str): Keycloak realm name
             client_id (str): Client ID registered in Keycloak
             client_secret (Optional[str], optional): Client secret if using confidential client. Defaults to None.
@@ -38,7 +38,7 @@ class KeycloakClient:
             timeout (Tuple[int, int], optional): Connection and read timeouts. Defaults to (10, 60).
             token_refresh_threshold (int, optional): Seconds before token expiry to trigger refresh. Defaults to 30.
         """
-        self.server_url = server_url.rstrip("/")
+        self.auth_server_url = auth_server_url.rstrip("/")
         self.realm = realm
         self.client_id = client_id
         self.client_secret = client_secret
@@ -52,12 +52,27 @@ class KeycloakClient:
         self.token_expires_at = 0
 
         # Construct the token endpoint URL
-        self.token_endpoint = f"{self.server_url}/realms/{self.realm}/protocol/openid-connect/token"
-        self.userinfo_endpoint = f"{self.server_url}/realms/{self.realm}/protocol/openid-connect/userinfo"
-        
+        self.token_endpoint = f"{self.auth_server_url}/realms/{self.realm}/protocol/openid-connect/token"
+        self.userinfo_endpoint = f"{self.auth_server_url}/realms/{self.realm}/protocol/openid-connect/userinfo"
+
         # Create a session for connection pooling
         self.session = requests.Session()
 
+    def __enter__(self):
+        """Support for context manager protocol."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Clean up resources when exiting context."""
+        self.close()
+
+    def __del__(self):
+        """Ensure resources are properly released when the object is garbage collected."""
+        try:
+            self.close()
+        except Exception:
+            pass  # Avoid exceptions during garbage collection
+
     def authenticate(self, username: str, password: str) -> str:
         """Authenticate with username and password.
 
@@ -203,8 +218,9 @@ class KeycloakClient:
 
     def close(self) -> None:
         """Close the session and release resources."""
-        if hasattr(self, 'session'):
+        if hasattr(self, "session") and self.session:
             self.session.close()
+            self.session = None
 
     @staticmethod
     def decode_token(token: str) -> Dict[str, Any]:

appmesh/tcp_transport.py

@@ -31,9 +31,9 @@ class TCPTransport:
                 **Note**: Unlike HTTP requests, TCP connections cannot automatically retrieve intermediate or public CA certificates.
                 When `rest_ssl_verify` is a path, it explicitly identifies a CA issuer to ensure certificate validation.
 
-            ssl_client_cert (Union[str, Tuple[str, str]], optional): Path to the SSL client certificate and key. If a `str`,
-                it should be the path to a PEM file containing both the client certificate and private key. If a `tuple`, it should
-                be a pair of paths: (`cert`, `key`), where `cert` is the client certificate file and `key` is the private key file.
+            ssl_client_cert (Union[str, Tuple[str, str]], optional): Path to the SSL client certificate and key. Can be:
+                - `str`: A path to a single PEM file containing both the client certificate and private key.
+                - `tuple`: A pair of paths (`cert_file`, `key_file`), where `cert_file` is the client certificate file path and `key_file` is the private key file path.
 
             tcp_address (Tuple[str, int], optional): Address and port for establishing a TCP connection to the server.
                 Defaults to `("localhost", 6059)`.
@@ -83,21 +83,31 @@ class TCPTransport:
 
         if self.ssl_client_cert is not None:
             # Load client-side certificate and private key
-            context.load_cert_chain(certfile=self.ssl_client_cert[0], keyfile=self.ssl_client_cert[1])
+            if isinstance(self.ssl_client_cert, tuple) and len(self.ssl_client_cert) == 2:
+                context.load_cert_chain(certfile=self.ssl_client_cert[0], keyfile=self.ssl_client_cert[1])
+            elif isinstance(self.ssl_client_cert, str):
+                # Handle case where cert and key are in the same file
+                context.load_cert_chain(certfile=self.ssl_client_cert)
+            else:
+                raise ValueError("ssl_client_cert must be a string filepath or a tuple of (cert_file, key_file)")
 
         # 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
-        # Wrap the socket with SSL/TLS
-        ssl_socket = context.wrap_socket(sock, server_hostname=self.tcp_address[0])
-        # Connect to the server
-        ssl_socket.connect(self.tcp_address)
-        # Disable Nagle's algorithm
-        ssl_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        # After connecting, set separate timeout for recv/send
-        # ssl_socket.settimeout(20)  # 20 seconds for recv/send
-        self._socket = ssl_socket
+        try:
+            # Wrap the socket with SSL/TLS
+            ssl_socket = context.wrap_socket(sock, server_hostname=self.tcp_address[0])
+            # Connect to the server
+            ssl_socket.connect(self.tcp_address)
+            # Disable Nagle's algorithm
+            ssl_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            # After connecting, set separate timeout for recv/send
+            # ssl_socket.settimeout(20)  # 20 seconds for recv/send
+            self._socket = ssl_socket
+        except (socket.error, ssl.SSLError) as e:
+            sock.close()
+            raise RuntimeError(f"Failed to connect to {self.tcp_address}: {e}")
 
     def close(self) -> None:
         """Close socket connection"""
@@ -115,23 +125,37 @@ class TCPTransport:
 
     def send_message(self, data) -> None:
         """Send a message with a prefixed header indicating its length"""
-        length = len(data)
-        # Pack the header into 8 bytes using big-endian format
-        self._socket.sendall(struct.pack("!II", self.TCP_MESSAGE_MAGIC, length))
-        if length > 0:
-            self._socket.sendall(data)
+        if self._socket is None:
+            raise RuntimeError("Cannot send message: not connected")
+
+        try:
+            length = len(data)
+            # Pack the header into 8 bytes using big-endian format
+            self._socket.sendall(struct.pack("!II", self.TCP_MESSAGE_MAGIC, length))
+            if length > 0:
+                self._socket.sendall(data)
+        except (socket.error, ssl.SSLError) as e:
+            self.close()
+            raise RuntimeError(f"Error sending message: {e}")
 
     def receive_message(self) -> Optional[bytearray]:
         """Receive a message with a prefixed header indicating its length and validate it"""
-        # Unpack the data (big-endian format)
-        magic, length = struct.unpack("!II", self._recvall(self.TCP_MESSAGE_HEADER_LENGTH))
-        if magic != self.TCP_MESSAGE_MAGIC:
-            raise ValueError(f"Invalid message: incorrect magic number 0x{magic:X}.")
-        if length > self.TCP_MAX_BLOCK_SIZE:
-            raise ValueError(f"Message size {length} exceeds the maximum allowed size of {self.TCP_MAX_BLOCK_SIZE} bytes.")
-        if length > 0:
-            return self._recvall(length)
-        return None
+        if self._socket is None:
+            raise RuntimeError("Cannot receive message: not connected")
+
+        try:
+            # Unpack the data (big-endian format)
+            magic, length = struct.unpack("!II", self._recvall(self.TCP_MESSAGE_HEADER_LENGTH))
+            if magic != self.TCP_MESSAGE_MAGIC:
+                raise ValueError(f"Invalid message: incorrect magic number 0x{magic:X}.")
+            if length > self.TCP_MAX_BLOCK_SIZE:
+                raise ValueError(f"Message size {length} exceeds the maximum allowed size of {self.TCP_MAX_BLOCK_SIZE} bytes.")
+            if length > 0:
+                return self._recvall(length)
+            return None
+        except (socket.error, ssl.SSLError) as e:
+            self.close()
+            raise RuntimeError(f"Error receiving message: {e}")
 
     def _recvall(self, length: int) -> bytearray:
         """socket recv data with fixed length
@@ -156,11 +180,14 @@ class TCPTransport:
 
         while bytes_received < length:
             # Use recv_into to read directly into our buffer
-            chunk_size = self._socket.recv_into(view[bytes_received:], length - bytes_received)
+            try:
+                chunk_size = self._socket.recv_into(view[bytes_received:], length - bytes_received)
 
-            if chunk_size == 0:
-                raise EOFError("Connection closed by peer")
+                if chunk_size == 0:
+                    raise EOFError("Connection closed by peer")
 
-            bytes_received += chunk_size
+                bytes_received += chunk_size
+            except socket.timeout:
+                raise socket.timeout(f"Socket operation timed out after receiving {bytes_received}/{length} bytes")
 
         return buffer

{appmesh-1.4.7.dist-info → appmesh-1.4.8.dist-info}/METADATA

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

{appmesh-1.4.7.dist-info → appmesh-1.4.8.dist-info}/RECORD

@@ -3,12 +3,12 @@ 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=dtrZryrkJ-dmT_NQE5v0fZPE00-PCD9VB9xL1Wu8ORI,47403
-appmesh/keycloak.py,sha256=siyifDaH3EASIti8s0DzxBo477m8eCRmzKwK6dqGRDY,7497
+appmesh/http_client.py,sha256=S90Ldndx3wfUYE2Ln31fnKKBNXbDROQd3FAzFTEdZtA,48314
+appmesh/keycloak.py,sha256=BJZ35FPO0C2wDeDhCcd6cE4ba9BF4UZ-4o5QelmbGHg,8036
 appmesh/tcp_client.py,sha256=RkHl5s8jE333BJOgxJqJ_fvjbdRQza7ciV49vLT6YO4,10923
 appmesh/tcp_messages.py,sha256=w1Kehz_aX4X2CYAUsy9mFVJRhxnLQwwc6L58W4YkQqs,969
-appmesh/tcp_transport.py,sha256=UMGby2oKV4k7lyXZUMSOe2Je34fb1w7nTkxEpatKLKg,7256
-appmesh-1.4.7.dist-info/METADATA,sha256=Tinrv6mkVtpVQi-ZZm_rTpCWLu-NoTEUvL-dBAQVaZg,11663
-appmesh-1.4.7.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-appmesh-1.4.7.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
-appmesh-1.4.7.dist-info/RECORD,,
+appmesh/tcp_transport.py,sha256=-XDTQbsKL3yCbguHeW2jNqXpYgnCyHsH4rwcaJ46AS8,8645
+appmesh-1.4.8.dist-info/METADATA,sha256=_Lmle-Icw-PkTf5yUvx3wHgaH0usfqAcVD2eePzjYS8,11663
+appmesh-1.4.8.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+appmesh-1.4.8.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
+appmesh-1.4.8.dist-info/RECORD,,

{appmesh-1.4.7.dist-info → appmesh-1.4.8.dist-info}/WHEEL

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