splight-lib 5.10.0__tar.gz → 5.10.1.dev1__tar.gz

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: splight-lib
-Version: 5.10.0
+Version: 5.10.1.dev1
 Summary: Splight Library
 Author: Splight Dev
 Author-email: dev@splight-ae.com

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "splight-lib"
-version = "5.10.0"
+version = "5.10.1.dev1"
 description = "Splight Library"
 authors = ["Splight Dev <dev@splight-ae.com>"]
 readme = "README.md"

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/splight_lib/client/database/classmap.py

@@ -23,9 +23,12 @@ MODEL_NAME_MAP = {
     "secret": f"{ENGINE_PREFIX}/secrets/",
     "setpoint": f"{ENGINE_PREFIX}/setpoints/",
     "solution": f"{ENGINE_PREFIX}/solution/solutions/",
+    "server": f"{ENGINE_PREFIX}/server/servers/",
     "tab": f"{ENGINE_PREFIX}/dashboard/tabs/",
     "hubsolution": f"{HUB_PREFIX}/solution/solutions/",
     "hubsolutionversion": f"{HUB_PREFIX}/solution/versions/",
+    "hubserver": f"{HUB_PREFIX}/server/servers/",
+    "hubserverversion": f"{HUB_PREFIX}/server/versions/",
 }
 
 CUSTOM_PATHS_MAP = {
@@ -33,4 +36,5 @@ CUSTOM_PATHS_MAP = {
     "get-asset-attribute": "{prefix}/assets/{asset}/get-attribute/",
     "decrypt-secret": "{prefix}/secrets/decrypt/",
     "routine-status": "{prefix}/component/routines/{routine}/update_status/",
+    "server-status": "{prefix}/server/servers/{server}/update-status/",
 }

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/splight_lib/client/database/remote_client.py

@@ -211,9 +211,13 @@ class RemoteDatabaseClient(AbstractDatabaseClient, AbstractRemoteClient):
         ------
         InvalidModelName thrown when the model name is not correct.
         """
-        if resource_name.lower() not in ["file", "hubsolutionversion"]:
+        if resource_name.lower() not in [
+            "file",
+            "hubsolutionversion",
+            "hubserverversion",
+        ]:
             raise InvalidModel(
-                "Only files and hub solution can be downloaded."
+                "Only files, hub solution and hub servers can be downloaded."
             )
         api_path = self._get_api_path(resource_name)
         resource_id = instance.get("id")

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/splight_lib/logging/_internal.py

@@ -24,6 +24,7 @@ class LogTags(UppercaseStrEnum):
     DATABASE = auto()
     DATALAKE = auto()
     CACHE = auto()
+    SERVER = auto()
 
 
 # don't used now

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/splight_lib/models/__init__.py

@@ -22,10 +22,12 @@ from splight_lib.models.datalake import DataRequest, PipelineStep, Trace
 from splight_lib.models.file import File
 from splight_lib.models.function import Function, FunctionItem, QueryFilter
 from splight_lib.models.hub import HubComponent
+from splight_lib.models.hub_server import HubServer
 from splight_lib.models.hub_solution import HubSolution
 from splight_lib.models.metadata import Metadata
 from splight_lib.models.native import Boolean, Number, String
 from splight_lib.models.secret import Secret
+from splight_lib.models.server import Server
 from splight_lib.models.solution import Solution
 from splight_lib.models.tag import Tag
 
@@ -52,12 +54,14 @@ __all__ = [
     FunctionItem,
     HubSolution,
     HubComponent,
+    HubServer,
     QueryFilter,
     Metadata,
     Number,
     PipelineStep,
     RoutineEvaluation,
     Secret,
+    Server,
     SetPoint,
     Solution,
     String,

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/splight_lib/models/exceptions.py

@@ -66,6 +66,15 @@ class InvalidArgument(Exception):
     pass
 
 
+class InvalidServerConfigType(Exception):
+    def __init__(self, name: str, type_: str):
+        msg = (
+            f"Config parameter {name} has an invalid type {type_}. The only "
+            "valid types are native and 'File'"
+        )
+        super().__init__(msg)
+
+
 class TraceAlreadyExistsError(Exception):
     def __init__(self, ref_id: str):
         msg = f"Trace with ref_id {ref_id} already exists"

splight_lib-5.10.1.dev1/splight_lib/models/hub_server.py

@@ -0,0 +1,118 @@
+import os
+from glob import glob
+from tempfile import NamedTemporaryFile
+from typing import Dict, List, Optional
+
+import py7zr
+from pydantic import BaseModel, Field
+
+from splight_lib.constants import DESCRIPTION_MAX_LENGTH
+from splight_lib.models.database_base import (
+    FilePath,
+    PrivacyPolicy,
+    SplightDatabaseBaseModel,
+)
+from splight_lib.models.component import InputParameter
+from splight_lib.utils.hub import (
+    COMPRESSION_TYPE,
+    README_FILE_1,
+    get_ignore_pathspec,
+    get_spec,
+)
+
+
+class Port(BaseModel):
+    name: Optional[str]
+    protocol: str = "tcp"
+    internal_port: int
+    exposed_port: int
+
+
+class HubServer(SplightDatabaseBaseModel):
+    id: Optional[str] = None
+    name: str
+    version: str
+    description: Optional[str] = Field(
+        default=None, max_length=DESCRIPTION_MAX_LENGTH
+    )
+    tags: Optional[List[str]] = Field(default=[])
+    privacy_policy: PrivacyPolicy = PrivacyPolicy.PUBLIC
+
+    config: List[InputParameter] = []
+    ports: List[Port] = []
+    environment: List[Dict[str, str]] = []
+
+    @classmethod
+    def upload(cls, path: FilePath, image_file: str) -> "HubServer":
+        db_client = cls._SplightDatabaseBaseModel__get_database_client()
+        image_path = os.path.join(path, image_file)
+        spec = get_spec(path)
+        name = spec.get("name")
+        version = spec.get("version")
+
+        raw_hub_server = db_client.get(
+            resource_name=cls.__name__,
+            name=name,
+            version=version,
+        )
+        server = cls.model_validate(spec)
+        if raw_hub_server:
+            old_hub_server = cls.model_validate(raw_hub_server[0])
+            server.id = old_hub_server.id
+
+        server.save()
+
+        file_name = f"{name}-{version}.{COMPRESSION_TYPE}"
+        ignore_pathspec = get_ignore_pathspec(path)
+        versioned_path = f"{name}-{version}"
+        # TODO: Add required files validations
+        readme_path = os.path.join(path, README_FILE_1)
+        if not os.path.exists(readme_path):
+            raise FileNotFoundError(f"README.md file not found: {readme_path}")
+        with py7zr.SevenZipFile(file_name, "w") as archive:
+            all_files = glob(f"{path}/**", recursive=True)
+            for filepath in all_files:
+                if ignore_pathspec and ignore_pathspec.match_file(filepath):
+                    continue
+                if os.path.isdir(filepath):
+                    continue
+                if image_file in filepath:
+                    continue
+                rel_filename = os.path.relpath(filepath, path)
+                new_filepath = os.path.join(versioned_path, rel_filename)
+                archive.write(filepath, new_filepath)
+
+        data = server.model_dump()
+        try:
+            db_client.upload(
+                "hubserverversion",
+                instance=data,
+                file_path=file_name,
+                type_="source",
+            )
+            db_client.upload(
+                "hubserverversion",
+                instance=data,
+                file_path=readme_path,
+                type_="readme",
+            )
+            db_client.upload(
+                "hubserverversion",
+                instance=data,
+                file_path=image_path,
+                type_="image",
+            )
+        except Exception as exc:
+            raise exc
+        finally:
+            if os.path.exists(file_name):
+                os.remove(file_name)
+        return server
+
+    def download(self) -> NamedTemporaryFile:
+        db_client = self._SplightDatabaseBaseModel__get_database_client()
+        return db_client.download(
+            resource_name="hubserverversion",
+            instance=self.model_dump(),
+            type_="source",
+        )

splight_lib-5.10.1.dev1/splight_lib/models/server.py

@@ -0,0 +1,211 @@
+import re
+import warnings
+from collections import namedtuple
+from datetime import datetime
+from enum import auto
+from typing import Any, NamedTuple, Optional
+
+from pydantic import AnyUrl, BaseModel, Field, computed_field
+from strenum import LowercaseStrEnum, PascalCaseStrEnum
+
+from splight_lib.models.database_base import SplightDatabaseBaseModel
+from splight_lib.models.exceptions import (
+    InvalidArgument,
+    InvalidServerConfigType,
+)
+from splight_lib.models.file import File
+from splight_lib.models.hub_server import HubServer
+from splight_lib.models.secret import Secret
+
+warnings.filterwarnings("ignore", category=RuntimeWarning)
+
+NATIVE_TYPES = {
+    "int": int,
+    "bool": bool,
+    "str": str,
+    "float": float,
+    "datetime": datetime,
+    "url": AnyUrl,
+}
+
+DATABASE_TYPES = {
+    "File": File,
+}
+
+DB_MODEL_TYPE_MAPPING = {
+    **NATIVE_TYPES,
+    **DATABASE_TYPES,
+}
+
+
+def get_field_value(field: dict):
+    field_multiple = field.get("multiple", False)
+    field_type = field.get("type")
+    field_value = field.get("value")
+
+    if not field_value:
+        return [] if field_multiple else None
+
+    if field_type in NATIVE_TYPES:
+        value = (
+            field_value
+            if not isinstance(field_value, str)
+            else parse_variable_string(field_value)
+        )
+    elif field_type in DATABASE_TYPES:
+        model_class = DATABASE_TYPES[field_type]
+        value = (
+            model_class.retrieve(field_value)
+            if not field_multiple
+            else [model_class.retrieve(item) for item in field_value]
+        )
+    return value
+
+
+def get_model_class(config: BaseModel, name: str) -> NamedTuple:
+    config_class = namedtuple(name, [x.name for x in config])
+    return config_class
+
+
+def load_server_config(
+    config: list[dict], config_class: NamedTuple
+) -> NamedTuple:
+    config_dict = {}
+    for item in config:
+        if item["type"] not in DB_MODEL_TYPE_MAPPING:
+            raise InvalidServerConfigType(item["name"], item["type"])
+        config_dict.update({item["name"]: get_field_value(item)})
+    config = config_class(**config_dict)
+    return config
+
+
+def load_server_ports(
+    ports: list[dict], model_class: NamedTuple
+) -> namedtuple:
+    ports_dict = {}
+    for port in ports:
+        if isinstance(port["internal_port"], int) and not (
+            0 <= port["internal_port"] <= 65535
+        ):
+            raise ValueError(
+                f"Internal port {port['internal_port']} is out of valid range (0-65535)"
+            )
+        if isinstance(port["exposed_port"], int) and not (
+            0 <= port["exposed_port"] <= 65535
+        ):
+            raise ValueError(
+                f"External port {port['exposed_port']} is out of valid range (0-65535)"
+            )
+        if port["protocol"] not in ["tcp", "udp"]:
+            raise ValueError(
+                f"Protocol {port['protocol']} is not valid. Must be 'tcp' or 'udp'"
+            )
+        ports_dict.update({port["name"]: port})
+    resources = model_class(**ports_dict)
+    return resources
+
+
+class ServerStatus(PascalCaseStrEnum):
+    RUNNING = auto()
+    FAILED = auto()
+    SUCCEEDED = auto()
+    PENDING = auto()
+    START_REQUESTED = auto()
+    STOP_REQUESTED = auto()
+    STOPPED = auto()
+    UNKNOWN = auto()
+
+
+class PrivacyPolicy(LowercaseStrEnum):
+    PUBLIC = auto()
+    PRIVATE = auto()
+
+
+class Port(BaseModel):
+    name: Optional[str]
+    internal_port: int
+    exposed_port: int
+
+
+class Server(SplightDatabaseBaseModel):
+    id: Optional[str] = None
+    name: Optional[str] = None
+    version: str
+    hub_server: HubServer
+    raw_config: list[dict] = Field(alias="config")
+    raw_ports: list[dict] = Field(alias="ports")
+    raw_env_vars: list[dict] = Field(alias="env_vars")
+
+    def model_dump(self, *args, **kwargs):
+        kwargs.update({"by_alias": True})
+        return super().model_dump(*args, **kwargs)
+
+    def model_dump_json(self, *args, **kwargs):
+        kwargs.update({"by_alias": True})
+        return super().model_dump_json(*args, **kwargs)
+
+    @computed_field(alias="parsed_config")
+    @property
+    def config(self) -> NamedTuple:
+        model_class = get_model_class(self.hub_server.config, "Config")
+        config = load_server_config(self.raw_config, model_class)
+        return config
+
+    @computed_field(alias="parsed_ports")
+    @property
+    def ports(self) -> NamedTuple:
+        model_class = get_model_class(self.hub_server.ports, "Ports")
+        ports = load_server_ports(self.raw_ports, model_class)
+        return ports
+
+    def update_config(self, **kwargs: dict):
+        valid_params = [x["name"] for x in self.raw_config]
+        for key, value in kwargs.items():
+            if key not in valid_params:
+                raise InvalidArgument(
+                    (
+                        f"Got invalid parameter {key}. Valid config parameter "
+                        f"are {valid_params}"
+                    )
+                )
+            for item in self.raw_config:
+                if item["name"] == key:
+                    item["value"] = value
+                    break
+
+    def update_ports(self, **kwargs: dict):
+        valid_params = [x["name"] for x in self.raw_ports]
+        for key, value in kwargs.items():
+            if key not in valid_params:
+                raise InvalidArgument(
+                    (
+                        f"Got invalid parameter {key}. Valid port "
+                        f"parameter are {valid_params}"
+                    )
+                )
+            for item in self.raw_ports:
+                if item["name"] == key:
+                    item["value"] = value
+                    break
+
+    def update_status(self, status: ServerStatus):
+        _ = self._db_client.operate(
+            resource_name="server-status",
+            instance={
+                "server": self.id,
+                "deployment_status": status,
+            },
+        )
+
+
+def parse_variable_string(raw_value: Optional[str]) -> Any:
+    if raw_value is None:
+        return ""
+    pattern = re.compile(r"^\$\{\{(\w+)\.(\w+)\}\}$")
+    match = pattern.search(raw_value)
+    if not match:
+        return raw_value
+    _, secret_name = match.groups()
+    # TODO: handle errors (not found or not allowed)
+    secret = Secret.decrypt(name=secret_name)
+    return secret.value

splight_lib-5.10.1.dev1/splight_lib/server/__init__.py

@@ -0,0 +1,5 @@
+from splight_lib.server.server import ServerLoader
+
+__all__ = [
+    ServerLoader,
+]

splight_lib-5.10.1.dev1/splight_lib/server/exceptions.py

@@ -0,0 +1,3 @@
+class MissingInstanceEnvVar(Exception):
+    def __init__(self, env_var: str):
+        super().__init__(f"Missing environment variable: {env_var}")

splight_lib-5.10.1.dev1/splight_lib/server/server.py

@@ -0,0 +1,16 @@
+import json
+import os
+
+from splight_lib.models import Server
+from splight_lib.server.exceptions import MissingInstanceEnvVar
+
+ENV_VAR = "SPLIGHT_SERVER_ID"
+
+
+class ServerLoader:
+    @classmethod
+    def from_env(cls) -> Server:
+        if not (instance_id := os.environ.get(ENV_VAR)):
+            raise MissingInstanceEnvVar(ENV_VAR)
+        server = Server.retrieve(instance_id)
+        return server

{splight_lib-5.10.0 → splight_lib-5.10.1.dev1}/splight_lib/solution/solution.py

@@ -15,7 +15,7 @@ class SolutionLoader:
     def from_env(cls) -> Solution:
         if not (str_instance := os.environ.get(ENV_VAR)):
             raise MissingInstanceEnvVar(ENV_VAR)
-        str_instance = os.environ.get("INSTANCE_AS_STR", "")
+        str_instance = os.environ.get(ENV_VAR, "")
         instance = json.loads(str_instance)
         if not (instance_id := instance.get("id")):
             raise MissingInstanceId()