openstoreplugin 0.0.1__tar.gz

openstoreplugin-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alexi Desvignes Nouvel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openstoreplugin-0.0.1/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: openstoreplugin
+Version: 0.0.1
+Summary: A library to base your controller plugins for Open Store
+License-File: LICENSE
+Keywords: open,openstore,store,openstoreplugin,plugin
+Author: Alexi Desvignes Nouvel
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: docker (>=7.1.0,<8.0.0)
+Requires-Dist: pydantic (>=2.11.4,<3.0.0)
+Project-URL: Documentation, https://github.com/AlexiDN/openstoreplugin/wiki
+Project-URL: Repository, https://github.com/AlexiDN/openstoreplugin
+Description-Content-Type: text/markdown
+
+# OpenStorPlugin
+
+
+## Features
+
+TODO
+
+## Installation
+
+```bash
+pip install openstoreplugin
+```
+## Usage
+
+TODO
+
+## License 
+
+The project is released under the MIT License.
+
+## Project Status
+
+> **NOTE** <br>
+> The project is currently in development phase. If you have any remark or question feel free to open an Issue

openstoreplugin-0.0.1/README.md

@@ -0,0 +1,24 @@
+# OpenStorPlugin
+
+
+## Features
+
+TODO
+
+## Installation
+
+```bash
+pip install openstoreplugin
+```
+## Usage
+
+TODO
+
+## License 
+
+The project is released under the MIT License.
+
+## Project Status
+
+> **NOTE** <br>
+> The project is currently in development phase. If you have any remark or question feel free to open an Issue

openstoreplugin-0.0.1/pyproject.toml

@@ -0,0 +1,100 @@
+[tool.poetry]
+packages = [{ include = "openstoreplugin", from = "src" }]
+
+[project]
+name = "openstoreplugin"
+version = "0.0.1"
+readme = "README.md"
+description = "A library to base your controller plugins for Open Store"
+authors = [{name="Alexi Desvignes Nouvel"}]
+keywords = [ "open", "openstore","store","openstoreplugin","plugin" ]
+requires-python=">=3.10"
+dynamic=["dependencies"]
+
+[project.urls]
+repository = "https://github.com/AlexiDN/openstoreplugin"
+documentation = "https://github.com/AlexiDN/openstoreplugin/wiki"
+
+# Common dependencies
+[tool.poetry.dependencies]
+pydantic = "^2.11.4"
+docker = "^7.1.0"
+
+[tool.poetry.group.lint.dependencies]
+ruff = "^0.11.9"
+
+[tool.poetry.group.test.dependencies]
+pytest = "^8.4.1"
+
+[tool.pytest.ini_options]
+addopts = "-ra -q"
+testpaths = ["tests"]
+pythonpath = ["src", "tests"]
+
+[tool.ruff]
+src = ["src"]
+exclude = [".cache"]
+extend-exclude = []
+line-length = 120
+indent-width = 4
+
+[tool.ruff.lint]
+fixable = ["ALL"]
+unfixable = []
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+select = ["ALL"]
+ignore = [
+    "D107",
+    "D101",
+    "D400",
+    "D415",
+    "PLR0913",
+    "FBT001",
+    "FBT002",
+    "N815",
+    "PYI051",
+    "FA102",
+    "FA100",
+    "D100",
+    "I001",
+    "CPY001",
+    "D205",
+    "FBT003",
+    "FIX002",
+    "TD002",
+    "TD003",
+    "TD004",
+    "PLR0917",
+    "DOC201",
+    "D203",
+    "COM812",
+    "D213",
+    "RUF012",
+    "PGH004",
+    "DOC501",
+    "D401",
+    "BLE001",
+    "TRY003",
+    "EM101",
+    "D104",
+    "ANN401",
+    "T201",
+    "TC001",
+    "PTH120",
+    "PTH123",
+    "PTH103",
+    "F403",
+
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-format = true
+
+
+[build-system]
+requires = ["poetry-core>=1.8.5"]
+build-backend = "poetry.core.masonry.api"

openstoreplugin-0.0.1/src/openstoreplugin/__init__.py

@@ -0,0 +1,4 @@
+from .controller_plugin import *
+from .enums import *
+from .models import *
+from .connectors import *

openstoreplugin-0.0.1/src/openstoreplugin/connectors/__init__.py

@@ -0,0 +1 @@
+from .docker_engine_connector import *

openstoreplugin-0.0.1/src/openstoreplugin/connectors/docker_engine_connector.py

@@ -0,0 +1,88 @@
+from docker import from_env
+from docker.errors import NotFound
+from docker.models.containers import Container, ExecResult
+from docker.models.networks import Network
+
+from openstoreplugin.models.docker import DockerContainerOptions, DockerNetworkOptions
+
+
+class DockerEngineConnector:
+    user: str
+
+    def __init__(self, user: str = "root") -> None:
+        self.client = from_env()
+        self.user = user
+
+    def get_api_version(self) -> str:
+        """Return the docker API Version or 'Unknown' if it does not exist"""
+        return self.client.version().get("ApiVersion", "Unknown")
+
+    def get_container_from_hostname(self, container_hostname: str, allow_failure: bool = False) -> Container:
+        """Return the container associated to the hostname given or raise an error if it is not found"""
+        for container in self.client.containers.list():
+            hostname = container.attrs.get("Config", {})("Hostname")
+            if hostname == container_hostname:
+                return container
+        if allow_failure:
+            return None
+        msg = f"No container found with hostname {container_hostname}."
+        raise NotFound(msg)
+
+    def get_container_from_name(self, container_name: str, allow_failure: bool = False) -> Container:
+        """Return the container associated to the name given or raise an error if it is not found"""
+        try:
+            return self.client.containers.get(container_name)
+        except NotFound as err:
+            if allow_failure:
+                return None
+            msg = f"No container found with name {container_name}."
+            raise NotFound(msg) from err
+
+    def get_network_from_name(self, network_name: str, allow_failure: bool = False) -> Network:
+        """Return the network associated to the name given or raise an error if it is not found"""
+        try:
+            return self.client.networks.get(network_name)
+        except NotFound as err:
+            if allow_failure:
+                return None
+            msg = f"No network found with name {network_name}."
+            raise NotFound(msg) from err
+
+    def execute_command_on_container(self, container_name: str, command: str, user: str | None = None) -> ExecResult:
+        """Execute the command on the container described
+        by container_name and return the ExecResult object associated
+        """
+        return self.get_container_from_name(container_name).exec_run(command, user=user or self.user)
+
+    def deploy_container(self, options: DockerContainerOptions) -> str:
+        """Deploy a container and return its name"""
+        try:
+            self.get_network_from_name(options.network)
+        except NotFound as err:
+            msg = f"Can't deploy container {options.name} since the network {options.network} does not exist."
+            raise RuntimeError(msg) from err
+        data = options.to_docker(self.get_api_version())
+        container: Container = self.client.containers.run(detach=True, **data)
+        return container.name
+
+    def remove_container(self, container_name: str, force: bool = True) -> None:
+        """Remove a container from docker"""
+        if force:
+            self.stop_container(container_name)
+        return self.get_container_from_name(container_name).remove()
+
+    def start_container(self, container_name: str) -> None:
+        """Start an already created container"""
+        return self.get_container_from_name(container_name).start()
+
+    def stop_container(self, container_name: str, timeout: int = 60) -> None:
+        """Stop the container without removing it"""
+        return self.get_container_from_name(container_name).stop(timeout=timeout)
+
+    def create_network(self, network_options: DockerNetworkOptions) -> str:
+        """Create a docker network"""
+        return self.client.networks.create(**network_options.model_dump(mode="json", exclude_unset=True)).name
+
+    def remove_network(self, network_name: str) -> None:
+        """Remove a Docker network and return its name"""
+        return self.get_network_from_name(network_name).remove()

openstoreplugin-0.0.1/src/openstoreplugin/controller_plugin.py

@@ -0,0 +1,109 @@
+from typing import Any
+
+from openstoreplugin.controller_tasks_args import CONTROLLER_DEFAULT_TASKS
+from openstoreplugin.models.controller_task import ControllerTask
+
+from openstoreplugin.models.store_config import OpenStoreConfigModel
+from openstoreplugin.models.application_config import ApplicationConfiguration
+from openstoreplugin.enums import TaskResponse, TaskStatus
+from openstoreplugin.connectors import DockerEngineConnector
+
+
+class ControllerPlugin:
+    application_config: ApplicationConfiguration
+    docker_connector: DockerEngineConnector
+    tasks: dict[str, ControllerTask]
+    store_config: OpenStoreConfigModel
+
+    def __init__(
+        self,
+        application_config: ApplicationConfiguration,
+        store_config: OpenStoreConfigModel,
+    ) -> None:
+        self.application_config = application_config
+        self.application_config.set_store_config(store_config)
+        self.docker_connector = DockerEngineConnector()
+        self.store_config = store_config
+        # create task mapping after verifying method exist
+        # TODO also verify args and make it better to declaire tasks using decorator @tasks to prefill arg of __init__
+        for task in CONTROLLER_DEFAULT_TASKS:
+            if not hasattr(self, task.controller_method.name):
+                msg = f"{self.__class__.__name__} does not have method \
+                    {task.controller_method.name} required for task {task.name}"
+                raise ValueError(msg)
+        self.tasks = {task.name: task for task in CONTROLLER_DEFAULT_TASKS}
+
+    def execute_task(self, task: str, **kwargs: dict[str, Any]) -> TaskResponse:
+        """Execute a task using the tasks mapping of the instance.
+        Return the TaskResponse return by the method called
+        """
+        # verify task exist
+        if task in self.tasks:
+            method_info = self.tasks.get(task).controller_method
+            method_args = {arg.name: arg for arg in method_info.args}
+            # verify task arguments
+            for arg, value in kwargs.items():
+                if arg not in method_args or not isinstance(value, method_args[arg].type_):
+                    msg = f"Arg {arg} does not match any arguments avalaible for task {task}.\
+                        Available args: {method_args.keys()}"
+                    raise ValueError(msg)
+            # extract method
+            method = getattr(self, method_info.name)
+            try:
+                return method(**kwargs) or TaskResponse(status=TaskStatus.SUCCESS)
+            except Exception as err:
+                return TaskResponse(
+                    status=TaskStatus.FAILURE,
+                    details=f"{err.__class__.__name__}:{err}",
+                )
+        msg = f"Task {task} does not exist."
+        raise RuntimeError(msg)
+
+    # ================
+    # Default tasks
+    # ================
+
+    def install(self) -> None:
+        """Install the application"""
+        self.create_bind_mounts()
+        self.deploy_docker()
+        return TaskResponse(status=TaskStatus.SUCCESS)
+
+    def create_bind_mounts(self) -> None:
+        """Create the directories and files mounted onto the docker container"""
+        for docker_config in self.application_config.docker_configs:
+            for volume in docker_config.container_options.volumes:
+                volume.create_on_host()
+
+    def delete_bind_mounts(self) -> None:
+        """Delete all bind mounts for the application"""
+        for docker_config in self.application_config.docker_configs:
+            for volume in docker_config.container_options.volumes:
+                volume.remove_from_host()
+
+    def deploy_docker(self) -> None:
+        """Deploy the docker part of the application"""
+        docker_configs = self.application_config.docker_configs
+        for docker_config in docker_configs:
+            # create network if it does not exist
+            if not self.docker_connector.get_network_from_name(
+                docker_config.container_options.network,
+                allow_failure=True,
+            ):
+                if not hasattr(docker_config, "network_options"):
+                    msg = f"Network {docker_config.container_options.network} \
+                        does not exist and is not declared in application config"
+                    raise ValueError(msg)
+                self.docker_connector.create_network(docker_config.network_options)
+
+            # deploy the container
+            self.docker_connector.deploy_container(docker_config.container_options)
+
+    def uninstall(self, cleanup_volumes: bool = False) -> None:
+        """Uninstall the application"""
+        # remove docker containers
+        for docker_config in self.application_config.docker_configs:
+            self.docker_connector.remove_container(docker_config.container_options.name)
+        # cleanup volumes
+        if cleanup_volumes:
+            self.delete_bind_mounts()

openstoreplugin-0.0.1/src/openstoreplugin/controller_tasks_args.py

@@ -0,0 +1,26 @@
+from openstoreplugin.models.controller_task import ControllerMethod, ControllerTask, MethodArg
+
+
+CONTROLLER_DEFAULT_TASKS = [
+    ControllerTask(
+        name="Install",
+        description="Install the application.",
+        controller_method=ControllerMethod(
+            name="install",
+        ),
+    ),
+    ControllerTask(
+        name="Uninstall",
+        description="Uninstall the application and optionnally remove its files.",
+        controller_method=ControllerMethod(
+            name="uninstall",
+            args=[
+                MethodArg(
+                    name="cleanup_volumes",
+                    type=bool,
+                    description="Should the applications files be removed?",
+                )
+            ],
+        ),
+    ),
+]

openstoreplugin-0.0.1/src/openstoreplugin/enums.py

@@ -0,0 +1,12 @@
+from enum import Enum
+from pydantic import BaseModel
+
+
+class TaskStatus(str, Enum):
+    SUCCESS = "success"
+    FAILURE = "failure"
+
+
+class TaskResponse(BaseModel):
+    status: TaskStatus
+    details: str = ""

openstoreplugin-0.0.1/src/openstoreplugin/models/__init__.py

@@ -0,0 +1,4 @@
+from .application_config import *
+from .docker import *
+from .docker import *
+from .base_model import *

openstoreplugin-0.0.1/src/openstoreplugin/models/application_config.py

@@ -0,0 +1,19 @@
+from typing import Any
+from pydantic import Field
+
+from openstoreplugin.models.base_model import BaseConfig
+
+from openstoreplugin.models.docker import DockerContainerOptions, DockerNetworkOptions
+
+
+class DockerConfig(BaseConfig):
+    container_options: DockerContainerOptions = Field(title="Options for the docker container")
+    network_options: DockerNetworkOptions | None = Field(
+        None, title="Options for the docker network used by the container if it does not already exist "
+    )
+
+
+class ApplicationConfiguration(BaseConfig):
+    version: str = Field(title="Version of the Application")
+    docker_configs: list[DockerConfig] = Field(title="Options for the docker containers")
+    extra: dict[str, Any] = Field(default={}, title="Extra configuration")

openstoreplugin-0.0.1/src/openstoreplugin/models/base_model.py

@@ -0,0 +1,153 @@
+from types import SimpleNamespace
+from typing import Any, Literal
+from collections.abc import Callable
+from pydantic import BaseModel, Field
+
+
+class BaseConfig(BaseModel):
+    model_variables: dict[str, Any] = Field(
+        default={},
+        description="The variables shared accross the model and its submodels. \
+            This is accessible using '{config.key_to_access}'",
+    )
+    _config: dict[str, Any] = None
+    _interpolate: bool = True
+
+    def __init__(self, *args: tuple, **kwargs: dict[str, Any]) -> None:
+        super().__init__(*args, **kwargs)
+        self._propagate_model_variables()
+
+    def model_dump(
+        self,
+        *,
+        mode: str | Literal["json", "python"] = "python",
+        include: Any | None = None,
+        exclude: Any | None = None,
+        context: dict | None = None,
+        by_alias: Any | None = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+        fallback: Callable | None = None,
+        serialize_as_any: bool = False,
+        interpolate: bool = True,
+    ) -> dict[str, Any]:
+        """Generate a dictionary representation of the model,
+        optionally specifying which fields to include or exclude.
+        """
+        if isinstance(context, dict):
+            interpolate = interpolate or context.get("interpolate", False)
+            context["interpolate"] = interpolate
+        if not context:
+            context = {"interpolate": interpolate}
+
+        data = super().model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            context=context,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+            fallback=fallback,
+            serialize_as_any=serialize_as_any,
+        )
+        if interpolate:
+            return BaseConfig._recursive_interpolate(data, SimpleNamespace(**self._config))
+        return data
+
+    def set_store_config(self, config: BaseModel) -> None:
+        """Set the _config variable using the store config object.
+        Apply it recursively to the model fields
+        Note that only lists and dicts iterables are checked
+        """
+        # set or update self._config with the config_model
+        if not self._config:
+            self._config = config.model_dump(mode="json")
+        else:
+            # Interpolate self_config with the store config before merging everything
+            interpolated_config = BaseConfig._recursive_interpolate(
+                self._config, SimpleNamespace(**config.model_dump(mode="json"))
+            )
+            # do not use .update since config does not have priority over model_variables
+            self._config = {**config.model_dump(mode="json"), **interpolated_config}
+        # propagate to model fields
+        for attr in vars(self).values():
+            self._recursive_call_method_on_fields(attr, "set_store_config", config)
+
+    def change_interpolation(self, interpolate: bool) -> None:
+        """Set the _interpolate variable using the boolean given.
+        Apply it recursively to the model fields
+        Note that only lists and dicts iterables are checked
+        """
+        self._interpolate = interpolate
+        for attr in vars(self).values():
+            self._recursive_call_method_on_fields(attr, "change_interpolation", interpolate)
+
+    def _propagate_model_variables(self, parent_model_variables: dict[str, Any] | None = None) -> None:
+        """Propagate model_variables to self._config for model and submodels"""
+        parent_model_variables = parent_model_variables or {}
+        # model_variables are top priority then parent ones then _config
+        base_config = {**(self._config or {}), **parent_model_variables}
+        # try to interpolate variables that can be interpolated
+        interpolated_model_variables = BaseConfig._recursive_interpolate(
+            self.model_variables, SimpleNamespace(**base_config)
+        )
+        self._config = {
+            **(self._config or {}),
+            **parent_model_variables,
+            **interpolated_model_variables,
+        }
+        # propagate to model fields
+        for attr in vars(self).values():
+            self._recursive_call_method_on_fields(attr, "_propagate_model_variables", self._config)
+
+    @staticmethod
+    def _recursive_call_method_on_fields(obj: Any, method_name: str, *args: tuple, **kwargs: dict[str, Any]) -> None:
+        """Recursively call method on fields with the args and kwargs given.
+        Only lists and dicts iterables are checked
+        """
+        if isinstance(obj, BaseConfig):
+            method: Callable = getattr(obj, method_name)
+            method(*args, **kwargs)
+        elif isinstance(obj, list):
+            for elem in obj:
+                BaseConfig._recursive_call_method_on_fields(elem, method_name, *args, **kwargs)
+        elif isinstance(obj, dict):
+            for v in obj.values():
+                BaseConfig._recursive_call_method_on_fields(v, method_name, *args, **kwargs)
+
+    def __getattribute__(self, name: str) -> Any:
+        """Return the attribute requested after interpolating it with  self._config"""
+        res = super().__getattribute__(name)
+        if (
+            not name.startswith("_")  # exclude private attributes
+            and name in self.__pydantic_fields__  # select only fields
+            and self.__pydantic_private__.get("_interpolate")  # is interpolation active
+            and self.__pydantic_private__.get("_config")  # is _config set
+            and name != "model_variables"  # prevent double interpolation
+        ):
+            return BaseConfig._recursive_interpolate(res, SimpleNamespace(**self._config))
+        return res
+
+    @staticmethod
+    def _recursive_interpolate(data: Any, config: SimpleNamespace) -> Any:
+        """Recursively interpolate strings with a config object"""
+        # case dict
+        if isinstance(data, dict):
+            return {k: BaseConfig._recursive_interpolate(v, config) for k, v in data.items()}
+        # case list/tuple
+        if isinstance(data, list):
+            return [BaseConfig._recursive_interpolate(v, config) for v in data]
+        # ensure data is string
+        if isinstance(data, str) and "{config" in data:
+            try:
+                return data.format(config=config)
+            except Exception:
+                return data
+        return data

openstoreplugin-0.0.1/src/openstoreplugin/models/controller_task.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+
+
+class MethodArg(BaseModel):
+    name: str = Field(description="Name of the arg. ex: 'timeout'.")
+    type_: type = Field(description="Type of the arg. ex: int.", alias="type")
+    description: str = Field(description="Description of the arg. ex: 'Timeout of the action'.")
+
+
+class ControllerMethod(BaseModel):
+    name: str = Field(description="Name of the method. ex: 'install'.")
+    args: list[MethodArg] = Field([], description="List of the args of the method.")
+
+
+class ControllerTask(BaseModel):
+    name: str = Field(description="Name of the task. ex: 'Install'.")
+    description: str = Field(description="Description of the task. ex: 'Install the app'.")
+    controller_method: ControllerMethod = Field(description="Controller Method associated.")

openstoreplugin-0.0.1/src/openstoreplugin/models/docker.py

@@ -0,0 +1,185 @@
+from fnmatch import fnmatch
+from pathlib import Path
+import shutil
+from typing import Any, Literal, Self
+from pydantic import (
+    Field,
+    FieldSerializationInfo,
+    field_serializer,
+    model_validator,
+)
+from openstoreplugin.models.base_model import BaseConfig
+from docker.types.networks import EndpointConfig
+
+# NETWORKS
+
+
+class IPAMPool(BaseConfig):
+    subnet: str = Field(description="Subnet in CIDR format (e.g. '172.28.0.0/16')")
+    gateway: str | None = Field(None, description="Gateway address within the subnet")
+
+
+class IPAMConfig(BaseConfig):
+    pool_configs: list[IPAMPool] = Field(description="List of IPAM pools for the network")
+
+
+class DockerNetworkOptions(BaseConfig):
+    name: str = Field(description="Name of the network")
+    driver: str | None = Field(None, description="Name of the driver used to create the network")
+    internal: bool = Field(False, description="Restrict external access to the network.")
+    check_duplicate: bool | None = Field(None, description="Request daemon to check for networks with same name.")
+    ipam: IPAMConfig | None = Field(None, description="IPAM configuration for the network")
+
+
+# CONTAINERS
+
+
+class DockerVolume(BaseConfig):
+    host_path: str = Field(description="Path of the volume on the host")
+    container_path: str = Field(description="Path of the volume on the container")
+    mode: Literal["ro", "rw"] | None = Field(None, description="Mode of the mount (rw or ro)")
+    type: Literal["dir", "file"] | None = Field(None, description="Type of mount (dir or file)")
+    removable_globs: list[str] | bool | None = Field(
+        None,
+        description="The globs of files that are removable during uninstall operation. \
+            Can be True to specify that all the volume is deletable. It will be ignored if content is not None",
+    )
+    content: str | None = Field(None, description="Content of the file if the volume is a file")
+
+    @model_validator(mode="after")
+    def validate_model(self) -> Self:
+        """Validate coherence of fields"""
+        if self.content:
+            if not Path(self.host_path).suffix:
+                raise ValueError(
+                    "Volume can't hold content if the host path does not point to a file (ie has a suffix)"
+                )
+            if self.type == "dir":
+                raise ValueError("Volume can't hold content if its type is directory")
+        return self
+
+    def create_on_host(self) -> None:
+        """Create the volume on host.
+        If there is content -> Create parent directories and file with content
+        If there is no content -> Create the volume only if it is a directory (also create parents)
+        """
+        # if volume is a file with a specified content
+        if self.content:
+            path = Path(self.host_path)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(self.content, encoding="utf-8")
+        # if volume is a directory
+        elif self.get_type() == "dir":
+            Path(self.host_path).mkdir(parents=True, exist_ok=True)
+
+    def remove_from_host(self) -> None:
+        """Remove all files and subdirectories of the volumes neccessary depending on self.removable_globs.
+        Note: if volume has a content field which is not null it will be removed
+        """
+        # Full removal (if content->volume is custom file so it should be removed)
+        if self.content or self.removable_globs is True:
+            # If volume is a file remove it
+            if self.get_type() == "file":
+                Path(self.host_path).unlink()
+            # If volume is a dir delete all the subtree
+            else:
+                shutil.rmtree(Path(self.host_path))
+        # Partial removal
+        elif self.removable_globs:
+            # If volume is a file remove it if it match a glob
+            if self.get_type() == "file" and any(
+                fnmatch.fnmatch(self.host_path, pattern) for pattern in self.removable_globs
+            ):
+                Path(self.host_path).unlink()
+            # if volume is a dir
+            else:
+                for glob in self.removable_globs:
+                    # Delete the glob
+                    for path in Path(self.host_path).glob(glob):
+                        # Dinstinguish directories from files
+                        if path.is_file() or path.is_symlink():
+                            path.unlink()
+                        elif path.is_dir():
+                            shutil.rmtree(path)
+
+    def get_type(self) -> Literal["dir", "file"]:
+        """Return the type of the volume: either file or dir"""
+        if self.type == "file" or self.content or Path(self.host_path).suffix:
+            return "file"
+        return "dir"
+
+    def to_docker(self) -> str:
+        """Convert to a string interpretable by docker"""
+        return f"{self.host_path}:{self.container_path}" + (f":{self.mode}" if self.mode else "")
+
+
+class EndpointConfiguration(BaseConfig):
+    ipv4_address: str = Field(description="Custom IPv4 address for the container")
+    ipv6_address: str | None = Field(None, description="Custom IPv6 address for the container")
+
+    def to_docker(self, api_version: str) -> EndpointConfig:
+        """Convert to EndpointConfig model from docker.types.networks"""
+        return EndpointConfig(api_version, **self.model_dump(mode="json", exclude_unset=True))
+
+
+class RestartPolicy(BaseConfig):
+    Name: Literal["on-failure", "always"] = Field(description="The type of policy")
+    MaximumRetryCount: int = Field(ge=0, description="Maximum number of retry before stoping the container")
+
+
+class DockerContainerOptions(BaseConfig, arbitrary_types_allowed=True):
+    name: str = Field(description="The name for this container")
+    hostname: str = Field(description="Hostname for the container")
+    image: str = Field(description="The image to run")
+    network: str = Field(description="Name of the network this container will be connected to at creation time")
+    networking_config: dict[str, EndpointConfiguration] | None = Field(
+        None,
+        description="Dictionary of EndpointConfig objects for each container network. \
+            The key is the name of the network. Defaults to None.Used in conjuction with network.",
+    )
+    restart_policy: RestartPolicy | None = Field(None, description="Restart the container when it exits.")
+    command: str | list[str] | None = Field(None, description="The command to run in the container")
+    entrypoint: str | list[str] | None = Field(None, description="The entrypoint for the container")
+    ports: dict[int | str, int | list[int], tuple[str, int]] | None = Field(
+        None,
+        description="Ports to bind inside the container.\n\
+        The keys of the dictionary are the ports to bind inside the container,\
+        either as an integer or a string in the form port/protocol, where the protocol is either tcp, udp, or sctp.",
+    )
+    volumes: list[DockerVolume] = Field(
+        [],
+        description="A list of volumes mounted inside the container.",
+    )
+    environment: list[str] | dict[str, str] | None = Field(
+        None, description="Environment variables to set inside the container"
+    )
+    labels: dict[str, str] | list[str] | None = Field(None, description="The labels of the container")
+    user: str | int | None = Field(None, description="Username or UID to run commands as inside the container.")
+    privileged: bool = Field(False, description="Give extended privileges to this container.")
+
+    @field_serializer("networking_config", when_used="json")
+    @staticmethod
+    def serialize_networking_config(
+        networking_config: dict[str, EndpointConfiguration] | None,
+        info: FieldSerializationInfo,
+    ) -> EndpointConfig | None:  # Optional[dict[str, EndpointConfiguration]]:
+        """Serialize networking_config"""
+        if networking_config and isinstance(info.context, dict) and info.context.get("api_version"):
+            api_version = info.context.get("docker", "no_version")
+            return {key: value.to_docker(api_version) for key, value in networking_config.items()}
+        return {key: value.model_dump(**info.__dict__) for key, value in networking_config.items()}
+
+    @field_serializer("volumes", when_used="json")
+    @staticmethod
+    def serialize_volumes(
+        volumes: list[DockerVolume] | None,
+        info: FieldSerializationInfo,
+    ) -> list[str] | None:
+        """Serialize volumes"""
+        if volumes and isinstance(info.context, dict) and info.context.get("api_version"):
+            return [volume.to_docker() for volume in volumes]
+        return [volume.model_dump(**info.__dict__) for volume in volumes]
+
+    def to_docker(self, api_version: str) -> dict[str, Any]:
+        """Dump the model to be compatible with docker client.containers.run() command"""
+        return self.model_dump(mode="json", exclude_unset=True, context={"api_version": api_version})

openstoreplugin-0.0.1/src/openstoreplugin/models/store_config.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, Field
+
+from openstoreplugin.models.application_config import ApplicationConfiguration
+
+
+class OpenStoreConfigModel(BaseModel):
+    # SMARTHOST
+    REMOTE_STORE_URL: str = Field("The url of the remote store")
+    # HOST
+    HOST_USER: str = Field("The user used on the host")
+    SERVER_BASE_DOMAIN: str = Field("The base domain of the server (example: test.com)")
+    SERVER_PUBLIC_IP: str = Field("The public ip of the server")
+    SERVER_PRIVATE_IP: str = Field("The private ip of the server")
+    # DOCKER
+    VOLUMES_ROOT_DIR: str = Field("The root directory for docker volumes on the host")
+    TRAEFIK_CONF: ApplicationConfiguration = Field("The private ip of treafik")