feat: enable launcher on Windows

Author: RobPasMue

src/ansys/geometry/core/connection/__init__.py

@@ -50,6 +50,7 @@
 from ansys.geometry.core.connection.launcher import (
     launch_docker_modeler,
     launch_modeler,
+    launch_modeler_with_core_service,
     launch_modeler_with_discovery,
     launch_modeler_with_discovery_and_pimlight,
     launch_modeler_with_geometry_service,

src/ansys/geometry/core/connection/launcher.py

@@ -75,6 +75,7 @@ def launch_modeler(mode: str = None, **kwargs: dict | None) -> "Modeler":
         * For ``"docker"`` mode, see the :func:`launch_docker_modeler` method.
         * For ``"geometry_service"`` mode, see the
           :func:`launch_modeler_with_geometry_service` method.
+        * For ``"core_service"`` mode, see the :func:`launch_modeler_with_core_service` method.
         * For ``"spaceclaim"`` mode, see the :func:`launch_modeler_with_spaceclaim` method.
         * For ``"discovery"`` mode, see the :func:`launch_modeler_with_discovery` method.
 
@@ -108,6 +109,8 @@ def _launch_with_launchmode(mode: str, **kwargs: dict | None) -> "Modeler":
         * ``"docker"``: Launches the ``Modeler`` service locally using Docker.
         * ``"geometry_service"``: Launches the ``Modeler`` service locally using the
           Ansys Geometry Service.
+        * ``"core_service"``: Launches the ``Modeler`` service locally using the
+          Ansys Geometry Core Service.
         * ``"spaceclaim"``: Launches the ``Modeler`` service locally using Ansys SpaceClaim.
         * ``"discovery"``: Launches the ``Modeler`` service locally using Ansys Discovery.
 
@@ -132,6 +135,8 @@ def _launch_with_launchmode(mode: str, **kwargs: dict | None) -> "Modeler":
         return launch_remote_modeler(**kwargs)
     elif mode == "docker":
         return launch_docker_modeler(**kwargs)
+    elif mode == "core_service":
+        return launch_modeler_with_core_service(**kwargs)
     elif mode == "geometry_service":
         return launch_modeler_with_geometry_service(**kwargs)
     elif mode == "spaceclaim":
@@ -167,8 +172,9 @@ def _launch_with_automatic_detection(**kwargs: dict | None) -> "Modeler":
     #
     # 1. Check if PyPIM is configured and if the environment is configured for it.
     # 2. Check if Docker is installed and if the environment is configured for it.
-    # 3. If you are on a Windows machine:
-    #     - check if the Ansys Geometry service is installed.
+    # 3. Check if the Ansys Geometry Core service is installed. (OS agnostic)
+    # 4. If you are on a Windows machine:
+    #     - check if the Ansys Geometry DMS service is installed.
     #     - check if Ansys SpaceClaim is installed.
     #     - check if Ansys Discovery is installed.
 
@@ -189,15 +195,26 @@ def _launch_with_automatic_detection(**kwargs: dict | None) -> "Modeler":
             " Trying to start the Geometry service locally."
         )
 
+    try:
+        LOG.info("Starting Geometry Core service locally.")
+        return launch_modeler_with_core_service(**kwargs)
+    except Exception:
+        LOG.warning(
+            "The Geometry Core service could not be started locally."
+            " Trying to start Geometry DMS service locally."
+            if os.name == "nt"
+            else ""
+        )
+
     # If we are on a Windows machine, we can try to start the Geometry service locally,
     # through various methods: Geometry service, SpaceClaim, Discovery.
     if os.name == "nt":
         try:
-            LOG.info("Starting Geometry service locally.")
+            LOG.info("Starting Geometry DMS service locally.")
             return launch_modeler_with_geometry_service(**kwargs)
         except Exception:
             LOG.warning(
-                "The Geometry service could not be started locally."
+                "The Geometry DMS service could not be started locally."
                 " Trying to start Ansys SpaceClaim locally."
             )
 
@@ -962,3 +979,128 @@ def _launch_pim_instance(
         logging_level=client_log_level,
         logging_file=client_log_file,
     )
+
+
+def launch_modeler_with_core_service(
+    product_version: int = None,
+    host: str = "localhost",
+    port: int = None,
+    enable_trace: bool = False,
+    timeout: int = 60,
+    server_log_level: int = 2,
+    client_log_level: int = logging.INFO,
+    server_logs_folder: str = None,
+    client_log_file: str = None,
+    **kwargs: dict | None,
+) -> "Modeler":
+    """Start the Geometry Core service locally using the ``ProductInstance`` class.
+
+    When calling this method, a standalone Geometry Core service is started.
+    By default, if an endpoint is specified (by defining `host` and `port` parameters)
+    but the endpoint is not available, the startup will fail. Otherwise, it will try to
+    launch its own service.
+
+    Parameters
+    ----------
+    product_version: int, optional
+        The product version to be started. Goes from v25.2 to
+        the latest. Default is ``None``.
+        If a specific product version is requested but not installed locally,
+        a SystemError will be raised.
+
+        **Ansys products versions and their corresponding int values:**
+
+        * ``252`` : Ansys 25R2
+        * ``261`` : Ansys 26R1
+    host: str, optional
+        IP address at which the service will be deployed. By default,
+        its value will be ``localhost``.
+    port : int, optional
+        Port at which the service will be deployed. By default, its
+        value will be ``None``.
+    enable_trace : bool, optional
+        Boolean enabling the logs trace on the service console window.
+        By default its value is ``False``.
+    timeout : int, optional
+        Timeout for starting the backend startup process. The default is 60.
+    server_log_level : int, optional
+        Backend's log level from 0 to 3:
+            0: Chatterbox
+            1: Debug
+            2: Warning
+            3: Error
+
+        The default is ``2`` (Warning).
+    client_log_level : int, optional
+        Logging level to apply to the client. By default, INFO level is used.
+        Use the logging module's levels: DEBUG, INFO, WARNING, ERROR, CRITICAL.
+    server_logs_folder : str, optional
+        Sets the backend's logs folder path. If nothing is defined,
+        the backend will use its default path.
+    client_log_file : str, optional
+        Sets the client's log file path. If nothing is defined,
+        the client will log to the console.
+    **kwargs : dict, default: None
+        Placeholder to prevent errors when passing additional arguments that
+        are not compatible with this method.
+
+    Returns
+    -------
+    Modeler
+        Instance of the Geometry Core service.
+
+    Raises
+    ------
+    ConnectionError
+        If the specified endpoint is already in use, a connection
+        error will be raised.
+    SystemError
+        If there is not an Ansys product 25.2 version or later installed
+        a SystemError will be raised.
+
+    Examples
+    --------
+    Starting a geometry core service with the default parameters and getting back a ``Modeler``
+    object:
+
+    >>> from ansys.geometry.core import launch_modeler_with_core_service
+    >>> modeler = launch_modeler_with_core_service()
+
+    Starting a geometry service, on address ``10.171.22.44``, port ``5001``, with chatty
+    logs, traces enabled and a ``300`` seconds timeout:
+
+    >>> from ansys.geometry.core import launch_modeler_with_core_service
+    >>> modeler = launch_modeler_with_core_service(host="10.171.22.44",
+        port=5001,
+        enable_trace= True,
+        timeout=300,
+        server_log_level=0)
+    """
+    # if api_version is passed, throw a warning saying that it is not used
+    if "api_version" in kwargs:
+        LOG.warning(
+            "The 'api_version' parameter is not used in 'launch_modeler_with_core_service'. "
+            "Please remove it from the arguments."
+        )
+
+    # If we are in a Windows environment, we are going to write down the server
+    # logs in the %PUBLIC%/Documents/Ansys/GeometryService folder.
+    if os.name == "nt" and server_logs_folder is None:
+        # Writing to the "Public" folder by default - no write permissions specifically required.
+        server_logs_folder = Path(os.getenv("PUBLIC"), "Documents", "Ansys", "GeometryService")
+        LOG.info(f"Writing server logs to the default folder at {server_logs_folder}.")
+
+    return prepare_and_start_backend(
+        BackendType.LINUX_SERVICE,
+        product_version=product_version,
+        host=host,
+        port=port,
+        enable_trace=enable_trace,
+        api_version=ApiVersions.LATEST,
+        timeout=timeout,
+        server_log_level=server_log_level,
+        client_log_level=client_log_level,
+        server_logs_folder=server_logs_folder,
+        client_log_file=client_log_file,
+        specific_minimum_version=252,
+    )

src/ansys/geometry/core/connection/product_instance.py

@@ -41,7 +41,10 @@
 
 
 WINDOWS_GEOMETRY_SERVICE_FOLDER = "GeometryService"
-"""Default Geometry Service's folder name into the unified installer."""
+"""Default Geometry Service's folder name into the unified installer (DMS)."""
+
+CORE_WINDOWS_GEOMETRY_SERVICE_FOLDER = "CoreGeometryService"
+"""Default Geometry Service's folder name into the unified installer (Core Service)."""
 
 DISCOVERY_FOLDER = "Discovery"
 """Default Discovery's folder name into the unified installer."""
@@ -62,7 +65,10 @@
 """
 
 GEOMETRY_SERVICE_EXE = "Presentation.ApiServerDMS.exe"
-"""The Windows Geometry Service's filename."""
+"""The Windows Geometry Service's filename (DMS)."""
+
+CORE_GEOMETRY_SERVICE_EXE = "Presentation.ApiServerLinux.dll"
+"""The Windows Geometry Service's filename (Core Service)."""
 
 DISCOVERY_EXE = "Discovery.exe"
 """The Ansys Discovery's filename."""
@@ -179,6 +185,7 @@ def prepare_and_start_backend(
     client_log_level: int = logging.INFO,
     server_logs_folder: str = None,
     client_log_file: str = None,
+    specific_minimum_version: int = None,
     log_level: int = None,  # DEPRECATED
     logs_folder: str = None,  # DEPRECATED
 ) -> "Modeler":
@@ -232,6 +239,9 @@ def prepare_and_start_backend(
     client_log_file : str, optional
         Sets the client's log file path. If nothing is defined,
         the client will log to the console.
+    specific_minimum_version : int, optional
+        Sets a specific minimum version to be checked. If this is not defined,
+        the minimum version will be set to 24.1.0.
     log_level : int, optional
         DEPRECATED. Use ``server_log_level`` instead.
     logs_folder : str, optional
@@ -285,7 +295,7 @@ def prepare_and_start_backend(
         product_version = get_latest_ansys_installation()[0]
 
     # Verify that the minimum version is installed.
-    _check_minimal_versions(product_version)
+    _check_minimal_versions(product_version, specific_minimum_version)
 
     if server_logs_folder is not None:
         # Verify that the user has write permissions to the folder and that it exists.
@@ -348,6 +358,18 @@ def prepare_and_start_backend(
                 GEOMETRY_SERVICE_EXE,
             )
         )
+    # This should be modified to Windows Core Service in the future
+    elif backend_type == BackendType.LINUX_SERVICE:
+        args.append("dotnet")
+        env_copy["ANS_DSCO_REMOTE_IP"] = host
+        env_copy["ANS_DSCO_REMOTE_PORT"] = str(port)
+        args.append(
+            Path(
+                installations[product_version],
+                CORE_WINDOWS_GEOMETRY_SERVICE_FOLDER,
+                CORE_GEOMETRY_SERVICE_EXE,
+            )
+        )
     else:
         raise RuntimeError(
             f"Cannot connect to backend {backend_type.name} using ``prepare_and_start_backend()``"
@@ -491,15 +513,21 @@ def __start_program(args: list[str], local_env: dict[str, str]) -> subprocess.Po
     )
 
 
-def _check_minimal_versions(latest_installed_version: int) -> None:
+def _check_minimal_versions(
+    latest_installed_version: int, specific_minimum_version: int | None
+) -> None:
     """Check client is compatible with Ansys Products.
 
-    Check that at least V241 is installed.
+    Check that at least V241 is installed. Or, if a specific version is requested,
+    check that it is installed.
     """
-    if abs(latest_installed_version) < 241:
+    min_ver = specific_minimum_version or 241
+    if abs(latest_installed_version) < min_ver:
+        # Split the version into its components.
+        major, minor = divmod(min_ver, 10)
         msg = (
-            "PyAnsys Geometry is compatible with Ansys Products from version 24.1.0. "
-            + "Please install Ansys products 24.1.0 or later."
+            f"PyAnsys Geometry is compatible with Ansys Products from version {major}.{minor}.0. "
+            + f"Please install Ansys products {major}.{minor}.0 or later."
         )
         raise SystemError(msg)