ansys-pyensight-core 0.8.9__py3-none-any.whl → 0.8.11__py3-none-any.whl

ansys/pyensight/core/__init__.py

@@ -12,7 +12,7 @@ __ansys_version__ = DEFAULT_ANSYS_VERSION
 __ansys_version_str__ = f"{2000+(int(__ansys_version__) // 10)} R{int(__ansys_version__) % 10}"
 
 from ansys.pyensight.core.dockerlauncher import DockerLauncher
-from ansys.pyensight.core.launch_ensight import launch_ensight
+from ansys.pyensight.core.launch_ensight import launch_ensight, launch_libuserd
 from ansys.pyensight.core.launcher import Launcher
 from ansys.pyensight.core.listobj import ensobjlist
 from ansys.pyensight.core.locallauncher import LocalLauncher

ansys/pyensight/core/common.py

@@ -0,0 +1,216 @@
+""" This module provides a list of common utilities shared between different PyEnSight modules."""
+
+import random
+import re
+import socket
+import time
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+
+from ansys.pyensight.core import enshell_grpc
+import urllib3
+
+try:
+    from simple_upload_server.client import Client
+
+    simple_upload_server_is_available = True  # pragma: no cover
+except Exception:
+    simple_upload_server_is_available = False
+
+if TYPE_CHECKING:
+    from docker import DockerClient
+
+
+def find_unused_ports(count: int, avoid: Optional[List[int]] = None) -> Optional[List[int]]:
+    """Find "count" unused ports on the host system
+
+    A port is considered unused if it does not respond to a "connect" attempt.  Walk
+    the ports from 'start' to 'end' looking for unused ports and avoiding any ports
+    in the 'avoid' list.  Stop once the desired number of ports have been
+    found.  If an insufficient number of ports were found, return None.
+
+    Parameters
+    ----------
+    count: int :
+        Number of unused ports to find
+    avoid: Optional[List[int]] :
+        An optional list of ports not to check
+
+    Returns
+    -------
+        The detected ports or None on failure
+
+    """
+    if avoid is None:
+        avoid = []
+    ports = list()
+
+    # pick a starting port number
+    start = random.randint(1024, 64000)
+    # We will scan for 65530 ports unless end is specified
+    port_mod = 65530
+    end = start + port_mod - 1
+    # walk the "virtual" port range
+    for base_port in range(start, end + 1):
+        # Map to physical port range
+        # There have been some issues with 65534+ so we stop at 65530
+        port = base_port % port_mod
+        # port 0 is special
+        if port == 0:  # pragma: no cover
+            continue  # pragma: no cover
+        # avoid admin ports
+        if port < 1024:  # pragma: no cover
+            continue  # pragma: no cover
+        # are we supposed to skip this one?
+        if port in avoid:  # pragma: no cover
+            continue  # pragma: no cover
+        # is anyone listening?
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        result = sock.connect_ex(("127.0.0.1", port))
+        if result != 0:
+            ports.append(port)
+        else:
+            sock.close()  # pragma: no cover
+        if len(ports) >= count:
+            return ports
+    # in case we failed...
+    if len(ports) < count:  # pragma: no cover
+        return None  # pragma: no cover
+    return ports  # pragma: no cover
+
+
+def get_host_port(uri: str) -> Tuple[str, int]:
+    """Get the host port for the input uri
+
+    Parameters
+    ----------
+
+    uri: str
+        The Uri to inspect
+
+    Returns
+    -------
+    (tuple):
+        A tuple containing the host and the port of the input uri
+    """
+    parse_results = urllib3.util.parse_url(uri)
+    port = (
+        parse_results.port
+        if parse_results.port
+        else (443 if re.search("^https|wss$", parse_results.scheme) else None)
+    )
+    return (parse_results.host, port)
+
+
+def get_file_service(pim_instance: Any) -> Optional[Any]:  # pragma: no cover
+    """Get the file service object for the input pim instance.
+
+    Parameters
+    ----------
+
+    pim_instance:
+        the PIM instance to get the service from.
+
+    Returns
+    -------
+
+    pim_file_service:
+        the PIM file service object
+    """
+    if simple_upload_server_is_available is False:
+        return None
+    if pim_instance is None:
+        return None
+
+    if "http-simple-upload-server" in pim_instance.services:
+        pim_file_service = Client(
+            token="token",
+            url=pim_instance.services["http-simple-upload-server"].uri,
+            headers=pim_instance.services["http-simple-upload-server"].headers,
+        )
+        return pim_file_service
+    return None
+
+
+def populate_service_host_port(  # pragma: no cover
+    pim_instance: Any, service_host_port: Dict[str, Tuple[str, int]], webui: bool = False
+) -> Dict[str, Tuple[str, int]]:
+    """Populate the service host port dictionary with the services available in the PIM instance.
+
+    Parameters
+    ----------
+    pim_instance:
+        the PIM instance to get the servicea from.
+    service_host_port: dict
+        the dictionary to be updated with the services from the PIM instance
+    webui: bool
+        if True retrieve also the webUI service
+
+    Returns
+    -------
+    service_host_port: dict
+        the dictionary updated with the services from the PIM instance
+    """
+    if not set(("grpc_private", "http", "ws")).issubset(pim_instance.services):
+        raise RuntimeError(
+            "If channel is specified, the PIM instance must have a list of length 3 "
+            + "containing the appropriate service URIs. It does not."
+        )
+    service_host_port["grpc_private"] = get_host_port(pim_instance.services["grpc_private"].uri)
+    service_host_port["http"] = get_host_port(pim_instance.services["http"].uri)
+    service_host_port["ws"] = get_host_port(pim_instance.services["ws"].uri)
+    service_host_port["grpc"] = ("127.0.0.1", -1)
+    if webui:
+        service_host_port["webui"] = get_host_port(pim_instance.services["webui"].uri)
+    return service_host_port
+
+
+def launch_enshell_interface(
+    enshell_grpc_channel: Any, grpc_port: int, timeout: float
+) -> enshell_grpc.EnShellGRPC:
+    """Launch the EnShell gRPC Interface.
+
+    Parameters
+    ----------
+    enshell_grpc_channel:
+        An eventual gRPC channel already available, like in the PIM case
+    grpc_port: int
+        the gRPC port to connect to
+    timeout: float
+        a timeout to wait for the gRPC connection
+
+    Returns
+    -------
+    enshell: enshell_grpc.EnShellGRPC
+        the enshell gRPC interface
+    """
+    if enshell_grpc_channel:  # pragma: no cover
+        enshell = enshell_grpc.EnShellGRPC()  # pragma: no cover
+        enshell.connect_existing_channel(enshell_grpc_channel)  # pragma: no cover
+    else:
+        enshell = enshell_grpc.EnShellGRPC(port=grpc_port)
+        time_start = time.time()
+        while time.time() - time_start < timeout:  # pragma: no cover
+            if enshell.is_connected():
+                break
+            try:
+                enshell.connect(timeout=timeout)
+            except OSError:  # pragma: no cover
+                pass  # pragma: no cover
+    return enshell
+
+
+def pull_image(docker_client: "DockerClient", image_name: str) -> None:
+    """Pull the input docker image using the input Docker Client
+
+    Parameters
+    ----------
+    docker_client: DockerClient
+        the current DockerClient to pull the image with
+    image_name: str
+        the image to pull
+    """
+    try:
+        if docker_client is not None:  # pragma: no cover
+            docker_client.images.pull(image_name)
+    except Exception:
+        raise RuntimeError(f"Can't pull Docker image: {image_name}")

ansys/pyensight/core/dockerlauncher.py

@@ -16,14 +16,10 @@ Examples:
 """
 import logging
 import os.path
-import re
 import subprocess
-import time
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 import uuid
 
-import urllib3
-
 try:
     import grpc
 except ModuleNotFoundError:  # pragma: no cover
@@ -31,24 +27,27 @@ except ModuleNotFoundError:  # pragma: no cover
 except Exception:  # pragma: no cover
     raise RuntimeError("Cannot initialize grpc")
 
-from ansys.pyensight.core.launcher import Launcher
-import ansys.pyensight.core.session
-from ansys.pyensight.core.session import Session
-
 try:
-    from ansys.pyensight.core import enshell_grpc
+    import docker
 except ModuleNotFoundError:  # pragma: no cover
-    raise RuntimeError("The enshell_grpc must be installed for DockerLauncher")
+    raise RuntimeError("The docker module must be installed for DockerLauncher")
 except Exception:  # pragma: no cover
-    raise RuntimeError("Cannot initialize enshell_grpc")
-
-
-try:
-    from simple_upload_server.client import Client
+    raise RuntimeError("Cannot initialize Docker")
+
+from ansys.pyensight.core.common import (
+    find_unused_ports,
+    get_file_service,
+    launch_enshell_interface,
+    populate_service_host_port,
+    pull_image,
+)
+from ansys.pyensight.core.launcher import Launcher
+import ansys.pyensight.core.session
+from ansys.pyensight.core.session import Session
 
-    simple_upload_server_is_available = True  # pragma: no cover
-except Exception:
-    simple_upload_server_is_available = False
+if TYPE_CHECKING:
+    from docker import DockerClient
+    from docker.models.containers import Container
 
 
 class DockerLauncher(Launcher):
@@ -117,8 +116,8 @@ class DockerLauncher(Launcher):
         self._enshell_grpc_channel = channel
         self._service_uris: Dict[Any, str] = {}
         self._image_name: Optional[str] = None
-        self._docker_client: Optional[Any] = None
-        self._container = None
+        self._docker_client: Optional["DockerClient"] = None
+        self._container: Optional["Container"] = None
         self._enshell: Optional[Any] = None
         self._pim_instance: Optional[Any] = pim_instance
 
@@ -143,27 +142,20 @@ class DockerLauncher(Launcher):
         )
 
         if self._enshell_grpc_channel and self._pim_instance:
-            if not set(("grpc_private", "http", "ws")).issubset(self._pim_instance.services):
+            service_set = ["grpc_private", "http", "ws"]
+            # if self._launch_webui:
+            #    service_set.append("webui")
+            if not set(service_set).issubset(self._pim_instance.services):
                 raise RuntimeError(
                     "If channel is specified, the PIM instance must have a list of length 3 "
                     + "containing the appropriate service URIs. It does not."
                 )
-            self._service_host_port = {}
             # grab the URIs for the 3 required services passed in from PIM
-            self._service_host_port["grpc_private"] = self._get_host_port(
-                self._pim_instance.services["grpc_private"].uri
-            )
-            self._service_host_port["http"] = self._get_host_port(
-                self._pim_instance.services["http"].uri
-            )
-            self._service_host_port["ws"] = self._get_host_port(
-                self._pim_instance.services["ws"].uri
+            self._service_host_port = populate_service_host_port(
+                self._pim_instance, {}, webui=self._launch_webui
             )
-            # for parity, add 'grpc' as a placeholder even though using PIM sets up the gRPC channel.
-            # this isn't used in this situation.
-            self._service_host_port["grpc"] = ("127.0.0.1", -1)
             # attach to the file service if available
-            self._get_file_service()
+            self._pim_file_service = get_file_service(self._pim_instance)
             # if using PIM, we have a query parameter to append to http requests
             if self._pim_instance is not None:
                 d = {"instance_name": self._pim_instance.name}
@@ -173,7 +165,10 @@ class DockerLauncher(Launcher):
 
         # EnShell gRPC port, EnSight gRPC port, HTTP port, WSS port
         # skip 1999 as that internal to the container is used to the container for the VNC connection
-        ports = self._find_unused_ports(4, avoid=[1999])
+        num_ports = 4
+        if self._launch_webui:
+            num_ports = 5
+        ports = find_unused_ports(num_ports, avoid=[1999])
         if ports is None:  # pragma: no cover
             raise RuntimeError(
                 "Unable to allocate local ports for EnSight session"
@@ -183,6 +178,8 @@ class DockerLauncher(Launcher):
         self._service_host_port["grpc_private"] = ("127.0.0.1", ports[1])
         self._service_host_port["http"] = ("127.0.0.1", ports[2])
         self._service_host_port["ws"] = ("127.0.0.1", ports[3])
+        if self._launch_webui:
+            self._service_host_port["webui"] = ("127.0.0.1", ports[4])
 
         # get the optional user-specified image name
         # Note: the default name needs to change over time...  TODO
@@ -193,14 +190,7 @@ class DockerLauncher(Launcher):
             self._image_name = docker_image_name
 
         # Load up Docker from the user's environment
-        try:
-            import docker
-
-            self._docker_client = docker.from_env()
-        except ModuleNotFoundError:
-            raise RuntimeError("The docker module must be installed for DockerLauncher")
-        except Exception:
-            raise RuntimeError("Cannot initialize Docker")
+        self._docker_client = docker.from_env()
 
     def ansys_version(self) -> Optional[str]:
         """Get the Ansys version (three-digit string) found in the Docker container.
@@ -222,11 +212,7 @@ class DockerLauncher(Launcher):
             If the Docker image couldn't be pulled.
 
         """
-        try:
-            if self._docker_client is not None:  # pragma: no cover
-                self._docker_client.images.pull(self._image_name)
-        except Exception:
-            raise RuntimeError(f"Can't pull Docker image: {self._image_name}")
+        pull_image(self._docker_client, self._image_name)
 
     def _get_container_env(self) -> Dict:
         # Create the environmental variables
@@ -251,6 +237,10 @@ class DockerLauncher(Launcher):
             if "ENSIGHT_ANSYS_APIP_CONFIG" in os.environ:
                 container_env["ENSIGHT_ANSYS_APIP_CONFIG"] = os.environ["ENSIGHT_ANSYS_APIP_CONFIG"]
 
+        if self._launch_webui:
+            container_env["SIMBA_WEBSERVER_TOKEN"] = self._secret_key
+            container_env["FLUENT_WEBSERVER_TOKEN"] = self._secret_key
+
         return container_env
 
     def start(self) -> "Session":
@@ -299,7 +289,13 @@ class DockerLauncher(Launcher):
             + "/tcp": str(self._service_host_port["http"][1]),
             str(self._service_host_port["ws"][1]) + "/tcp": str(self._service_host_port["ws"][1]),
         }
-
+        if self._launch_webui:
+            ports_to_map.update(
+                {
+                    str(self._service_host_port["webui"][1])
+                    + "/tcp": str(self._service_host_port["webui"][1])
+                }
+            )
         # The data directory to map into the container
         data_volume = None
         if self._data_directory:
@@ -310,13 +306,6 @@ class DockerLauncher(Launcher):
         #
         enshell_cmd = "-app -v 3 -grpc_server " + str(grpc_port)
 
-        try:
-            import docker
-        except ModuleNotFoundError:  # pragma: no cover
-            raise RuntimeError("The docker module must be installed for DockerLauncher")
-        except Exception:  # pragma: no cover
-            raise RuntimeError("Cannot initialize Docker")
-
         use_egl = self._use_egl()
 
         logging.debug("Starting Container...\n")
@@ -389,6 +378,33 @@ class DockerLauncher(Launcher):
         logging.debug("Container started.\n")
         return self.connect()
 
+    def launch_webui(self, container_env_str):
+        # Run websocketserver
+        cmd = f"cpython /ansys_inc/v{self._ansys_version}/CEI/"
+        cmd += f"nexus{self._ansys_version}/nexus_launcher/webui_launcher.py"
+        # websocket port - this needs to come first since we now have
+        # --add_header as a optional arg that can take an arbitrary
+        # number of optional headers.
+        webui_port = self._service_host_port["webui"][1]
+        grpc_port = self._service_host_port["grpc_private"][1]
+        http_port = self._service_host_port["http"][1]
+        ws_port = self._service_host_port["ws"][1]
+        cmd += f" --server-listen-port {webui_port}"
+        cmd += (
+            f" --server-web-roots /ansys_inc/v{self._ansys_version}/CEI/nexus{self._ansys_version}/"
+        )
+        cmd += f"ansys{self._ansys_version}/ensight/WebUI/web/ui/"
+        cmd += f" --ensight-grpc-port {grpc_port}"
+        cmd += f" --ensight-html-port {http_port}"
+        cmd += f" --ensight-ws-port {ws_port}"
+        cmd += f" --ensight-session-directory {self._session_directory}"
+        cmd += f" --ensight-secret-key {self._secret_key}"
+        logging.debug(f"Starting WebUI: {cmd}\n")
+        ret = self._enshell.start_other(cmd, extra_env=container_env_str)
+        if ret[0] != 0:  # pragma: no cover
+            self.stop()  # pragma: no cover
+            raise RuntimeError(f"Error starting WebUI: {cmd}\n")  # pragma: no cover
+
     def connect(self):
         """Create and bind a :class:`Session<ansys.pyensight.core.Session>` instance
         to the created EnSight gRPC connection started by EnShell.
@@ -408,24 +424,12 @@ class DockerLauncher(Launcher):
         #
         #
         # Start up the EnShell gRPC interface
+        self._enshell = launch_enshell_interface(
+            self._enshell_grpc_channel, self._service_host_port["grpc"][1], self._timeout
+        )
         log_dir = "/data"
         if self._enshell_grpc_channel:  # pragma: no cover
-            self._enshell = enshell_grpc.EnShellGRPC()
-            self._enshell.connect_existing_channel(self._enshell_grpc_channel)
             log_dir = "/work"
-        else:
-            logging.debug(
-                f"Connecting to EnShell over gRPC port: {self._service_host_port['grpc'][1]}...\n"
-            )
-            self._enshell = enshell_grpc.EnShellGRPC(port=self._service_host_port["grpc"][1])
-            time_start = time.time()
-            while time.time() - time_start < self._timeout:  # pragma: no cover
-                if self._enshell.is_connected():
-                    break
-                try:
-                    self._enshell.connect(timeout=self._timeout)
-                except OSError:  # pragma: no cover
-                    pass  # pragma: no cover
 
         if not self._enshell.is_connected():  # pragma: no cover
             self.stop()  # pragma: no cover
@@ -581,10 +585,13 @@ class DockerLauncher(Launcher):
             timeout=self._timeout,
             sos=use_sos,
             rest_api=self._enable_rest_api,
+            webui_port=self._service_host_port["webui"][1] if self._launch_webui else None,
         )
         session.launcher = self
         self._sessions.append(session)
 
+        if self._launch_webui:
+            self.launch_webui(container_env_str)
         logging.debug("Return session.\n")
 
         return session
@@ -619,32 +626,10 @@ class DockerLauncher(Launcher):
             self._pim_instance = None
         super().stop()
 
-    def _get_file_service(self) -> None:  # pragma: no cover
-        if simple_upload_server_is_available is False:
-            return
-        if self._pim_instance is None:
-            return
-
-        if "http-simple-upload-server" in self._pim_instance.services:
-            self._pim_file_service = Client(
-                token="token",
-                url=self._pim_instance.services["http-simple-upload-server"].uri,
-                headers=self._pim_instance.services["http-simple-upload-server"].headers,
-            )
-
     def file_service(self) -> Optional[Any]:
         """Get the PIM file service object if available."""
         return self._pim_file_service
 
-    def _get_host_port(self, uri: str) -> tuple:
-        parse_results = urllib3.util.parse_url(uri)
-        port = (
-            parse_results.port
-            if parse_results.port
-            else (443 if re.search("^https|wss$", parse_results.scheme) else None)
-        )
-        return (parse_results.host, port)
-
     def _is_system_egl_capable(self) -> bool:
         """Check if the system is EGL capable.
 

ansys/pyensight/core/enshell_grpc.py

@@ -355,6 +355,38 @@ class EnShellGRPC(object):
         else:
             return self.run_command_with_env(command_string, ensight_env)  # pragma: no cover
 
+    def start_ensight_server(
+        self, ensight_args: Optional[str] = None, ensight_env: Optional[str] = None
+    ):
+        """Tell EnShell to start the EnSight server.
+
+        The string will be sent to EnShell via the EnShellService::run_command()
+        gRPC call.  An IOError exception may be thrown
+        if there's a gRPC communication problem.  The response
+        is the tuple of the EnShell return code and return string.
+
+        Parameters
+        ----------
+        ensight_args : Optional[str], optional
+            ensight_args arguments for the ensight command line, by default None
+
+        Returns
+        -------
+        Tuple
+            A tuple of (int, string) for (returnCode, returnString)
+        """
+        self.connect()
+        command_string = (
+            f"start_app OTHER /ansys_inc/v{self.ansys_version()}/CEI/bin/ensight_server"
+        )
+        if ensight_args and (ensight_args != ""):
+            command_string += " " + ensight_args
+
+        if ensight_env is None or ensight_env == "":  # pragma: no cover
+            return self.run_command(command_string)
+        else:
+            return self.run_command_with_env(command_string, ensight_env)  # pragma: no cover
+
     # @brief
     #
     # @param cmd The command line