Merge pull request #280 from ThePorgs/dev

Release 5.1.3

Author: Dramelac

.github/workflows/sub_testing.yml

@@ -33,7 +33,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+        version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
         os: [win32, linux, darwin]
     steps:
       - uses: actions/checkout@main

CONTRIBUTING.md

@@ -1 +1 @@
-If you'd like to contributing to this project, everything you need to know is at https://docs.exegol.com/contribute/intro
+If you'd like to contribute to this project, everything you need to know is at https://docs.exegol.com/contribute/intro

exegol-images

@@ -1,7 +1,7 @@
 import os
 from pathlib import Path
 
-__version__ = "5.1.2"
+__version__ = "5.1.3"
 
 
 class ConstantConfig:

exegol-resources

@@ -32,8 +32,11 @@ async def Acknowledge(message: str) -> None:
         """Quick function to format rich Confirmation and options on every exegol interaction"""
         formatted_question = f"[bold blue][>][/bold blue] {message} [bright_magenta][Press ENTER to acknowledge][/bright_magenta]"
         async with ConsoleLock:
-            rich.prompt.Prompt.ask(
-                formatted_question,
-                show_choices=False,
-                show_default=False,
-                console=console)
+            try:
+                rich.prompt.Prompt.ask(
+                    formatted_question,
+                    show_choices=False,
+                    show_default=False,
+                    console=console)
+            except ValueError:
+                raise EOFError

exegol/config/ConstantConfig.py

@@ -280,12 +280,16 @@ async def selectFromTable(cls,
                               data: Sequence[SelectableInterface],
                               object_type: Optional[Type] = None,
                               default: Optional[str] = None,
-                              allow_None: bool = False,
-                              conflict_mode: bool = False) -> Union[SelectableInterface, str]:
+                              allow_none: bool = False,
+                              conflict_mode: bool = False,
+                              multiple: bool = False) -> Union[SelectableInterface, str, Sequence[SelectableInterface], Sequence[str]]:
         """Return an object (implementing SelectableInterface) selected by the user
         Return a str when allow_none is true and no object have been selected
         Raise IndexError of the data list is empty.
-        Set conflict_mode to override the key in order to select a specific object with duplicate name"""
+        Set allow_none to allow the user to select no object and return a str
+        Set conflict_mode to override the key in order to select a specific object with duplicate name
+        Set multiple to add * option to select multiple objects
+        """
         cls.__isInteractionAllowed()
         # Check if there is at least one object in the list
         if len(data) == 0:
@@ -308,8 +312,10 @@ async def selectFromTable(cls,
         # If no default have been supplied, using the first one
         if default is None:
             default = choices[0]
+        if multiple:
+            choices.append("*")
         # When allow_none is enabled, disabling choices restriction
-        if allow_None:
+        if allow_none:
             choices_select: Optional[List[str]] = None
             logger.info(
                 f"You can use a name that does not already exist to {action} a new {object_name}"
@@ -322,6 +328,8 @@ async def selectFromTable(cls,
                                           default=default,
                                           choices=choices_select,
                                           show_choices=False)
+            if choice == "*":
+                return list(data)
             if conflict_mode:
                 # In conflict mode, choice are only index number offset by 1
                 return data[int(choice) - 1]
@@ -332,8 +340,8 @@ async def selectFromTable(cls,
                 return match[0]
             elif len(match) > 1:
                 logger.error(f"Conflict detected ! Multiple {object_name} have the same name, please select the intended one.")
-                return await cls.selectFromTable(match, object_type, default=None, allow_None=False, conflict_mode=True)
-            if allow_None:
+                return await cls.selectFromTable(match, object_type, default=None, allow_none=False, conflict_mode=True, multiple=multiple)
+            if allow_none:
                 if await ExegolRich.Confirm(
                         f"No {object_name} is available under this name, do you want to {action} it?",
                         default=True):
@@ -361,9 +369,14 @@ async def multipleSelectFromTable(cls,
         else:
             object_subject = "object"
         while True:
-            selected = cast(SelectableInterface, await cls.selectFromTable(pool, object_type, default))
-            result.append(selected)
-            pool.remove(selected)
+            selected = cast(Union[SelectableInterface, Sequence[SelectableInterface]], await cls.selectFromTable(pool, object_type, default, multiple=True))
+            if isinstance(selected, SelectableInterface):
+                result.append(selected)
+                pool.remove(selected)
+            else:
+                result.extend(selected)
+                for i in selected:
+                    pool.remove(i)
             if len(pool) == 0:
                 return result
             elif not await ExegolRich.Confirm(f"Do you want to select another {object_subject}?", default=False):

exegol/console/ExegolPrompt.py

@@ -76,11 +76,10 @@ async def info(cls) -> None:
     @classmethod
     async def start(cls) -> None:
         """Create and/or start an exegol container to finally spawn an interactive shell"""
-        logger.info("Starting exegol")
         # Check if the first positional parameter have been supplied
         cls.__interactive_mode = not bool(ParametersManager().containertag)
         if not cls.__interactive_mode:
-            logger.info("Arguments supplied with the command, skipping interactive mode")
+            logger.info("Skipping interactive mode (arguments supplied)")
         container = await cls.__loadOrCreateContainer()
         assert container is not None and type(container) is ExegolContainer
         if not container.isNew():
@@ -113,7 +112,6 @@ async def upgrade(cls) -> None:
     async def exec(cls) -> None:
         """Create and/or start an exegol container to execute a specific command.
         The execution can be seen in console output or be relayed in the background as a daemon."""
-        logger.info("Starting exegol")
         if ParametersManager().tmp:
             container = await cls.__createTmpContainer(ParametersManager().selector)
             if not ParametersManager().daemon:
@@ -129,7 +127,7 @@ async def exec(cls) -> None:
     @classmethod
     async def stop(cls) -> None:
         """Stop an exegol container"""
-        logger.info("Stopping exegol")
+        logger.info("Stopping container(s)")
         container = await cls.__loadOrCreateContainer(multiple=True, must_exist=True, filters=[ExegolContainer.Filters.STARTED])
         assert container is not None and type(container) is list
         for c in container:
@@ -165,7 +163,7 @@ async def build(cls) -> None:
     async def update(cls) -> None:
         """Update python wrapper (git installation required) and Pull a docker exegol image"""
         if ParametersManager().offline_mode:
-            logger.critical("It's not possible to update Exegol in offline mode. Please retry later with an internet connection.")
+            logger.critical("Exegol cannot be updated without Internet access. Skipping.")
         if not ParametersManager().skip_git:
             await UpdateManager.updateWrapper()
             await UpdateManager.updateResources()
@@ -175,7 +173,7 @@ async def update(cls) -> None:
     @classmethod
     async def uninstall(cls) -> None:
         """Remove an exegol image"""
-        logger.info("Uninstalling an exegol image")
+        logger.info("Uninstalling image")
         # Set log level to verbose in order to show every image installed including the outdated.
         if not logger.isEnabledFor(ExeLog.VERBOSE):
             logger.setLevel(ExeLog.VERBOSE)
@@ -195,7 +193,7 @@ async def uninstall(cls) -> None:
     @classmethod
     async def remove(cls) -> None:
         """Remove an exegol container"""
-        logger.info("Removing an exegol container")
+        logger.info("Removing container(s)")
         containers = await cls.__loadOrCreateContainer(multiple=True, must_exist=True)
         assert type(containers) is list
         if len(containers) == 0:
@@ -335,7 +333,7 @@ async def __loadOrInstallImage(cls,
                     else:
                         # Interactive (TUI) image selection
                         image_selection = cast(Union[Optional[ExegolImage], List[ExegolImage]],
-                                               await cls.__interactiveSelection(ExegolImage, image_list, multiple, must_exist))
+                                               await cls.__interactiveSelection(ExegolImage, image_list, multiple))
                 else:
                     # Select image by tag name (non-interactive)
                     if multiple:
@@ -463,7 +461,7 @@ async def __loadOrCreateContainer(cls,
                 else:
                     # Interactive container selection
                     cls.__container = cast(Union[Optional[ExegolContainer], List[ExegolContainer]],
-                                           await cls.__interactiveSelection(ExegolContainer, container_list, multiple, must_exist))
+                                           await cls.__interactiveSelection(ExegolContainer, container_list, multiple))
             else:
                 # Try to find the corresponding container
                 if multiple:
@@ -491,9 +489,9 @@ async def __loadOrCreateContainer(cls,
             # Create container
             if must_exist:
                 if container_tag is not None:
-                    logger.warning(f"The container named '{container_tag}' has not been found")
+                    logger.warning(f"Container '{container_tag}' has not been found")
                 return [] if multiple else None
-            logger.info(f"Creating new container named '{container_tag}'")
+            logger.info(f"Creating new container '{container_tag}'")
             return await cls.__createContainer(container_tag)
         assert cls.__container is not None
         return cast(Union[Optional[ExegolContainer], List[ExegolContainer]], cls.__container)
@@ -502,16 +500,15 @@ async def __loadOrCreateContainer(cls,
     async def __interactiveSelection(cls,
                                      object_type: Type[Union[ExegolImage, ExegolContainer]],
                                      object_list: Sequence[SelectableInterface],
-                                     multiple: bool = False,
-                                     must_exist: bool = False) -> \
+                                     multiple: bool = False) -> \
             Union[Optional[ExegolImage], Optional[ExegolContainer], Sequence[ExegolImage], Sequence[ExegolContainer]]:
         """Interactive object selection process, depending on object_type.
         object_type can be ExegolImage or ExegolContainer."""
-        user_selection: Union[SelectableInterface, Sequence[SelectableInterface], str]
+        user_selection: Union[SelectableInterface, Sequence[SelectableInterface], Sequence[str], str]
         if multiple:
             user_selection = await ExegolTUI.multipleSelectFromTable(object_list, object_type=object_type)
         else:
-            user_selection = await ExegolTUI.selectFromTable(object_list, object_type=object_type, allow_None=object_type is ExegolContainer)
+            user_selection = await ExegolTUI.selectFromTable(object_list, object_type=object_type, allow_none=object_type is ExegolContainer)
             # Check if the user has chosen an existing object
             if type(user_selection) is str:
                 # Otherwise, create a new object with the supplied name
@@ -523,19 +520,19 @@ async def __interactiveSelection(cls,
     async def __createContainer(cls, name: Optional[str]) -> ExegolContainer:
         """Create an ExegolContainer"""
         if name is None:
-            name = await ExegolRich.Ask("Enter the name of your new exegol container", default="default")
+            name = await ExegolRich.Ask("Enter new container name", default="default")
         logger.verbose("Configuring new exegol container")
         # Create exegol config
         image: Optional[ExegolImage] = cast(ExegolImage, await cls.__loadOrInstallImage(show_custom=True))
         assert image is not None  # load or install return an image
         if name is None:
-            name = await ExegolRich.Ask("Enter the name of your new exegol container", default="default")
+            name = await ExegolRich.Ask("Enter new container name", default="default")
         model = await ExegolContainerTemplate.newContainer(name, image, hostname=ParametersManager().hostname)
 
         # Recap
         await ExegolTUI.printContainerRecap(model)
         if cls.__interactive_mode:
-            if not model.image.isUpToDate() and \
+            if not model.image.isUpToDate() and "Unknown" not in model.image.getStatus() and \
                     await ExegolRich.Confirm("Do you want to [green]update[/green] the selected image?", False):
                 image = await UpdateManager.updateImage(model.image.getName())
                 if image is not None:

exegol/console/TUI.py

@@ -1,6 +1,6 @@
 import re
 from pathlib import Path
-from typing import Optional, Dict, cast, Tuple, Sequence
+from typing import Optional, Dict, cast, Tuple, Sequence, List
 
 from exegol.config.ConstantConfig import ConstantConfig
 from exegol.config.DataCache import DataCache
@@ -30,20 +30,20 @@ async def updateImage(cls, tag: Optional[str] = None, install_mode: bool = False
         if image_args is not None and tag is None:
             tag = image_args
         if tag is None:
-            all_images = await DockerUtils().listImages()
+            all_images: List[ExegolImage] = await DockerUtils().listImages()
             # Filter for updatable images
             if install_mode:
-                available_images = [i for i in all_images if not i.isLocked()]
+                available_images = [i for i in all_images if not i.isLocked() and not i.isLocal()]
             else:
-                available_images = [i for i in all_images if i.isInstall() and not i.isUpToDate() and not i.isLocked()]
+                available_images = [i for i in all_images if i.isInstall() and not i.isLocal() and not i.isUpToDate() and not i.isLocked()]
                 if len(available_images) == 0:
                     logger.success("All images already installed are up to date!")
                     return None
             try:
                 # Interactive selection
                 selected_image = await ExegolTUI.selectFromTable(available_images,
                                                                  object_type=ExegolImage,
-                                                                 allow_None=False)
+                                                                 allow_none=False)
             except IndexError:
                 # No images are available
                 if install_mode:

exegol/manager/ExegolManager.py

@@ -126,7 +126,7 @@ def __init__(self, container: Optional[Container] = None, container_name: Option
         self.__workspace_dedicated_path: Optional[str] = None
         self.__disable_workspace: bool = False
         self.__container_entrypoint: List[str] = self.__default_entrypoint
-        self.__vpn_path: Optional[Union[Path, PurePath]] = None
+        self.__vpn_path: Optional[Path] = None
         self.__shell_logging: bool = False
         # Entrypoint features
         self.legacy_entrypoint: bool = True
@@ -770,10 +770,6 @@ async def enableVPN(self, config_path: Optional[Union[str, PurePath]] = None, ap
                 self.__vpn_mode = "ovpn"
                 self.__vpn_parameters = await self.__prepareOpenVpnVolumes(vpn_path, skip_conf_checks=apply_only)
             elif vpn_path.is_file() and vpn_path.suffix == ".conf":
-                if not SessionHandler().pro_feature_access():
-                    logger.error("WireGuard VPN support is exclusive to Pro/Enterprise users. Coming soon to Community.")
-                    self.__disableVPN()
-                    raise InteractiveError
                 # Wireguard config
                 self.__addSysctl("net.ipv4.conf.all.src_valid_mark", "1")
                 self.__vpn_mode = "wgconf"
@@ -1616,6 +1612,10 @@ def getTextFeatures(self, verbose: bool = False) -> str:
             return "[i][bright_black]Default configuration[/bright_black][/i]"
         return result
 
+    def getVpnConfigPath(self) -> Optional[Path]:
+        """Get VPN Config path"""
+        return self.__vpn_path
+
     def getVpnName(self) -> str:
         """Get VPN Config name"""
         if self.__vpn_path is None: