arkitekt-next 0.7.33__py3-none-any.whl → 0.7.34__py3-none-any.whl

arkitekt_next/__blok__.py

@@ -4,10 +4,16 @@ from arkitekt_next.bloks.mikro import MikroBlok
 from arkitekt_next.bloks.fluss import FlussBlok
 from arkitekt_next.bloks.redis import RedisBlok
 from arkitekt_next.bloks.gateway import GatewayBlok
-from arkitekt_next.bloks.livekit import LiveKitBlok
+from arkitekt_next.bloks.livekit import LocalLiveKitBlok
 from arkitekt_next.bloks.postgres import PostgresBlok
 from arkitekt_next.bloks.minio import MinioBlok
+from arkitekt_next.bloks.kabinet import KabinetBlok
 from arkitekt_next.bloks.lok import LokBlok
+from arkitekt_next.bloks.config import ConfigBlok
+from arkitekt_next.bloks.mount import MountBlok
+from arkitekt_next.bloks.internal_docker import InternalDockerBlok
+from arkitekt_next.bloks.socket import DockerSocketBlok
+from arkitekt_next.bloks.rekuest import RekuestBlok
 
 
 def get_bloks():
@@ -18,8 +24,14 @@ def get_bloks():
         FlussBlok(),
         RedisBlok(),
         GatewayBlok(),
-        LiveKitBlok(),
+        LocalLiveKitBlok(),
         PostgresBlok(),
         MinioBlok(),
         LokBlok(),
+        KabinetBlok(),
+        MountBlok(),
+        ConfigBlok(),
+        InternalDockerBlok(),
+        DockerSocketBlok(),
+        RekuestBlok(),
     ]

arkitekt_next/bloks/__init__.py

@@ -1 +1,2 @@
 from .admin import AdminBlok
+

arkitekt_next/bloks/admin.py

@@ -1,28 +1,20 @@
 from pydantic import BaseModel
 from typing import Dict, Any
-from blok import blok, InitContext, CLIOption
+from blok import blok, InitContext, Option
+from arkitekt_next.bloks.services.admin import AdminService, AdminCredentials
 
 
-class AdminCredentials(BaseModel):
-    password: str
-    username: str
-    email: str
-
-
-@blok("live.arkitekt.admin")
+@blok(AdminService)
 class AdminBlok:
     def __init__(self) -> None:
         self.password = "admin"
         self.username = "admin"
         self.email = "admin@admin.com"
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-    def build(self, cwd):
-        pass
-
     def retrieve(self):
         return AdminCredentials(
             password=self.password,
@@ -31,19 +23,19 @@ class AdminBlok:
         )
 
     def get_options(self):
-        with_username = CLIOption(
+        with_username = Option(
             subcommand="username",
             help="Which admin username to use",
             default=self.username,
             show_default=True,
         )
-        with_username = CLIOption(
+        with_username = Option(
             subcommand="password",
             help="Which password to use",
             default=self.password,
             show_default=True,
         )
-        with_email = CLIOption(
+        with_email = Option(
             subcommand="password",
             help="Which password to use",
             default=self.password,

arkitekt_next/bloks/arkitekt.py

@@ -1,6 +1,13 @@
 from pydantic import BaseModel
 from typing import Dict, Any
 from blok import blok, InitContext, Renderer, Panel
+from .livekit import LocalLiveKitBlok
+from .mikro import MikroBlok
+from .kabinet import KabinetBlok
+from .rekuest import RekuestBlok
+from .fluss import FlussBlok
+from .gateway import GatewayBlok
+from .internal_docker import InternalDockerBlok
 
 
 class AdminCredentials(BaseModel):
@@ -11,17 +18,6 @@ class AdminCredentials(BaseModel):
 
 @blok("live.arkitekt")
 class ArkitektBlok:
-    def __init__(self) -> None:
-        pass
-
-    def get_dependencies(self):
-        return [
-            "live.arkitekt.lok",
-            "live.arkitekt.mikro",
-            "live.arkitekt.kabinet",
-            "live.arkitekt.gateway",
-            "io.livekit.livekit",
-        ]
 
     def entry(self, renderer: Renderer):
         renderer.render(
@@ -33,19 +29,10 @@ class ArkitektBlok:
             )
         )
 
-    def init(self, init: InitContext):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
+    def preflight(self, lok: LocalLiveKitBlok, mikro: MikroBlok, kabinet: KabinetBlok, rekuest: RekuestBlok, fluss: FlussBlok, gateway: GatewayBlok, internal_engine: InternalDockerBlok):
+        print (lok, mikro, kabinet, rekuest, fluss, gateway, internal_engine)
+
 
     def build(self, cwd):
         pass
 
-    def retrieve(self):
-        return AdminCredentials(
-            password=self.password,
-            username=self.username,
-            email=self.email,
-        )
-
-    def get_options(self):
-        return []

arkitekt_next/bloks/config.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from blok import blok, InitContext, Option, ExecutionContext
+from blok.tree import YamlFile
+from arkitekt_next.bloks.services.config import ConfigService
+
+class AdminCredentials(BaseModel):
+    password: str
+    username: str
+    email: str
+
+
+@blok(ConfigService)
+class ConfigBlok:
+    def __init__(self) -> None:
+        self.config_path = "configs"
+        self.registered_configs = {}
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def build(self, ex: ExecutionContext):
+        for name, file in self.registered_configs.items():
+            ex.file_tree.set_nested(*f"{self.config_path}/{name}".split("/"), file)
+
+    def register_config(self, name: str, file: YamlFile) -> str:
+        self.registered_configs[name] = file
+        return f"./{self.config_path}/" + name
+
+    def get_path(self, name: str) -> str:
+        return f"./{self.config_path}/" + name
+
+    def get_options(self):
+        config_path = Option(
+            subcommand="config_path",
+            help="Which path to use for configs",
+            default=self.config_path,
+            show_default=True,
+        )
+
+        return [config_path]

arkitekt_next/bloks/fluss.py

@@ -1,25 +1,30 @@
 import secrets
-from blok import blok, InitContext, ExecutionContext, CLIOption
+from arkitekt_next.bloks.funcs import create_default_service_yaml
+from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 
 
 DEFAULT_ARKITEKT_URL = "http://localhost:8000"
 
 
-@blok("live.arkitekt.kabinet")
+@blok("live.arkitekt.fluss")
 class FlussBlok:
     def __init__(self) -> None:
         self.host = "fluss"
         self.command = "bash run-debug.sh"
+        self.image = "jhnnsrs/fluss:next"
         self.repo = "https://github.com/jhnnsrs/fluss-server-next"
         self.scopes = {"read_image": "Read image from the database"}
-        self.mount_repo = True
-        self.build_repo = True
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
         self.secret_key = secrets.token_hex(16)
         self.ensured_repos = []
 
     def get_dependencies(self):
         return [
+            "live.arkitekt.mount",
+            "live.arkitekt.config",
             "live.arkitekt.gateway",
             "live.arkitekt.postgres",
             "live.arkitekt.lok",
@@ -28,101 +33,46 @@ class FlussBlok:
             "live.arkitekt.s3",
         ]
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        deps = init.dependencies
+        self.service = create_default_service_yaml(init, self)
 
-        deps["live.arkitekt.lok"].register_scopes(self.scopes)
-
-        self.gateway_access = deps["live.arkitekt.gateway"].expose(
-            self.host, 80, self.host
-        )
-
-        self.postgress_access = deps["live.arkitekt.postgres"].register_db(self.host)
-        self.redis_access = deps["live.arkitekt.redis"].register()
-        self.lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
-        self.admin_access = deps["live.arkitekt.admin"].retrieve()
-        self.minio_access = deps["live.arkitekt.s3"].retrieve_credentials(["media"])
         self.initialized = True
 
     def build(self, context: ExecutionContext):
-        depends_on = []
-
-        if self.redis_access.dependency:
-            depends_on.append(self.redis_access.dependency)
-
-        if self.postgress_access.dependency:
-            depends_on.append(self.postgress_access.dependency)
-
-        db_service = {
-            "labels": [
-                "fakts.service=live.arkitekt.fluss",
-                "fakts.builder=arkitekt.fluss",
-            ],
-            "depends_on": depends_on,
-        }
-
-        if self.mount_repo:
-            context.file_tree.set_nested("mounts", self.host, Repo(self.repo))
-            db_service["volumes"] = [f"./mounts/{self.host}:/workspace"]
-
-        if self.build_repo:
-            context.file_tree.set_nested("mounts", self.host, Repo(self.repo))
-            db_service["build"] = f"./mounts/{self.host}"
-
-        db_service["command"] = self.command
-
-        configuration = YamlFile(
-            **{
-                "db": self.postgress_access.dict(),
-                "django": {
-                    "admin": self.admin_access.dict(),
-                    "debug": True,
-                    "hosts": ["*"],
-                    "secret_key": self.secret_key,
-                },
-                "redis": self.redis_access.dict(),
-                "lok": self.lok_access.dict(),
-                "s3": self.minio_access.dict(),
-                "scopes": self.scopes,
-            }
-        )
-
-        context.file_tree.set_nested("configs", "fluss.yaml", configuration)
-
-        context.docker_compose.set_nested("services", self.host, db_service)
+        context.docker_compose.set_nested("services", self.host, self.service)
 
     def get_options(self):
-        with_repo = CLIOption(
+        with_repo = Option(
             subcommand="with_repo",
             help="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
             default=self.repo,
         )
-        with_command = CLIOption(
+        with_command = Option(
             subcommand="command",
             help="Which command should be run when starting the service",
             default=self.command,
         )
-        mount_repo = CLIOption(
+        mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
             is_flag=True,
-            default=True,
+            default=self.mount_repo,
         )
-        build_repo = CLIOption(
+        build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
             is_flag=True,
-            default=True,
+            default=self.build_repo,
         )
-        with_host = CLIOption(
+        with_host = Option(
             subcommand="host",
             help="How should the service be named inside the docker-compose file?",
             default=self.host,
         )
-        with_secret_key = CLIOption(
+        with_secret_key = Option(
             subcommand="secret_key",
             help="The secret key to use for the django service",
             default=self.secret_key,

arkitekt_next/bloks/funcs.py

@@ -0,0 +1,86 @@
+from blok import blok, InitContext, Option
+from blok.tree import YamlFile, Repo
+from typing import Protocol
+from blok.utils import check_protocol_compliance
+from dataclasses import asdict
+
+class DefaultService(Protocol):
+    service_name: str
+    host: str
+    buckets: list[str]
+    scopes: dict[str, str]
+    secret_key: str
+    mount_repo: bool
+    build_repo: bool
+
+    def get_identifier(self) -> str: ...
+
+
+def create_default_service_yaml(
+    init: InitContext,
+    self: DefaultService,
+) -> YamlFile:
+    check_protocol_compliance(self, DefaultService)
+    deps = init.dependencies
+    deps["live.arkitekt.lok"].register_scopes(self.scopes)
+
+    gateway_access = deps["live.arkitekt.gateway"].expose(self.host, 80, self.host)
+
+    postgress_access = deps["live.arkitekt.postgres"].register_db(self.host)
+    redis_access = deps["live.arkitekt.redis"].register()
+    lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
+    admin_access = deps["live.arkitekt.admin"].retrieve()
+    minio_access = deps["live.arkitekt.s3"].create_buckets(self.buckets)
+    lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
+    lok_labels = deps["live.arkitekt.lok"].retrieve_labels(self.get_identifier())
+
+    configuration = YamlFile(
+        **{
+            "db": asdict(postgress_access),
+            "django": {
+                "admin": asdict(admin_access),
+                "debug": True,
+                "hosts": ["*"],
+                "secret_key": self.secret_key,
+            },
+            "redis": asdict(redis_access),
+            "lok": asdict(lok_access),
+            "s3": asdict(minio_access),
+            "scopes": self.scopes,
+        }
+    )
+
+    config_mount = deps["live.arkitekt.config"].register_config(
+        f"{self.host}.yaml", configuration
+    )
+
+    depends_on = []
+
+    if redis_access.dependency:
+        depends_on.append(redis_access.dependency)
+
+    if postgress_access.dependency:
+        depends_on.append(postgress_access.dependency)
+
+    if minio_access.dependency:
+        depends_on.append(minio_access.dependency)
+
+    service = {
+        "labels": lok_labels,
+        "volumes": [f"{config_mount}:/workspace/config.yaml"],
+        "depends_on": depends_on,
+    }
+
+    if self.mount_repo:
+        mount = deps["live.arkitekt.mount"].register_mount(self.host, Repo(self.repo))
+        service["volumes"].extend([f"{mount}:/workspace"])
+
+    if self.build_repo:
+        mount = deps["live.arkitekt.mount"].register_mount(self.host, Repo(self.repo))
+        service["build"] = mount
+    else:
+        service["image"] = self.image
+
+    service["command"] = self.command
+
+    return service

arkitekt_next/bloks/gateway.py

@@ -1,4 +1,4 @@
-from blok import blok, InitContext, ExecutionContext, CLIOption
+from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from pydantic import BaseModel
 from typing import Dict, Any
@@ -30,16 +30,16 @@ class GatewayBlok:
         self.exposed_ports = {}
         self.with_certer = True
         self.with_tailscale = True
+        self.certer_image = "jhnnsrs/certer:next"
         self.http_port = 80
         self.https_port = 443
-
-    def get_identifier(self):
-        return "live.arkitekt.gateway"
+        self.public_ips = DEFAULT_PUBLIC_URLS
+        self.public_hosts = DEFAULT_PUBLIC_HOSTS
 
     def get_dependencies(self):
         return []
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -65,10 +65,18 @@ class GatewayBlok:
 }}
                 """
 
-        caddyfile += """
-https:// {
+        for protocol in ["http", "https"]:
+            caddyfile += f"""
+{protocol}:// {{
+"""
+            caddyfile += (
+                """
     tls /certs/caddy.crt /certs/caddy.key
-
+    """
+                if protocol == "https"
+                else ""
+            )
+            caddyfile += """
     header {
         -Server
         X-Forwarded-Proto {scheme}
@@ -78,26 +86,35 @@ https:// {
     }
         """
 
-        for path_name, exposed_host in self.exposed_hosts.items():
-            if exposed_host.stip_prefix:
-                caddyfile += f"""
-    @{path_name} path /{path_name} {{
+            for path_name, exposed_host in self.exposed_hosts.items():
+                if exposed_host.stip_prefix:
+                    caddyfile += f"""
+    @{path_name} path /{path_name}* 
+    handle @{path_name} {{
         uri strip_prefix /{path_name}
         reverse_proxy {exposed_host.host}:{exposed_host.port}
     }}
                 """
-            else:
-                caddyfile += f"""
-    @{path_name} path /{path_name}{{
+                else:
+                    caddyfile += f"""
+    @{path_name} path /{path_name}*
+    handle @{path_name} {{
         reverse_proxy {exposed_host.host}:{exposed_host.port}
     }}
                 """
 
-        caddyfile += """
+            if self.http_expose_default:
+                caddyfile += f"""
+    handle {{
+        reverse_proxy {self.http_expose_default.host}:{self.http_expose_default.port}
+    }}
+            """
+
+            caddyfile += """
 }
         """
 
-        context.file_tree.set_nested("config", "Caddyfile", caddyfile)
+        context.file_tree.set_nested("configs", "Caddyfile", caddyfile)
 
         caddy_depends_on = []
         if self.with_certer:
@@ -105,21 +122,24 @@ https:// {
 
         caddy_container = {
             "image": "caddy:latest",
-            "volumes": ["./config/Caddyfile:/etc/caddy/Caddyfile"],
+            "volumes": ["./configs/Caddyfile:/etc/caddy/Caddyfile", "./certs:/certs"],
             "ports": [f"{self.http_port}:80", f"{self.https_port}:443"],
             "depends_on": caddy_depends_on,
         }
 
         context.docker_compose.set_nested("services", "caddy", caddy_container)
 
-        if self.with_certer:
-            context.file_tree.set_nested("certs", {})
-            caddy_container = {
-                "image": "jhnnsrs/certer:latest",
-                "volumes": ["./certs:/certs"],
-                "ports": [f"{self.http_port}:80", f"{self.https_port}:443"],
-                "depends_on": caddy_depends_on,
-            }
+        context.file_tree.set_nested("certs", {})
+        certer_container = {
+            "image": self.certer_image,
+            "volumes": ["./certs:/certs"],
+            "environment": {
+                "DOMAIN_NAMES": ",".join(self.public_hosts),
+                "IP_ADDRESSED": ",".join(self.public_ips),
+            },
+        }
+
+        context.docker_compose.set_nested("services", "certer", certer_container)
 
     def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = True):
         self.exposed_hosts[path_name] = ExposedHost(
@@ -133,7 +153,7 @@ https:// {
         self.exposed_ports[port] = ExposedPort(port=port, host=host, tls=tls)
 
     def get_options(self):
-        with_public_urls = CLIOption(
+        with_public_urls = Option(
             subcommand="public_url",
             help="Which public urls to use",
             type=str,
@@ -141,7 +161,7 @@ https:// {
             default=DEFAULT_PUBLIC_URLS,
             show_default=True,
         )
-        with_public_services = CLIOption(
+        with_public_services = Option(
             subcommand="public_hosts",
             help="Which public hosts to use",
             type=str,

arkitekt_next/bloks/internal_docker.py

@@ -0,0 +1,80 @@
+from typing import Dict, Any
+import secrets
+
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+
+
+@blok("live.arkitekt.internal_engine")
+class InternalDockerBlok:
+    def __init__(self) -> None:
+        self.host = "internal_docker"
+        self.command = (
+            "arkitekt-next run prod --redeem-token=mylittletoken --url http://caddy:80"
+        )
+        self.image = "jhnnsrs/deployer:0.0.1-vanilla"
+        self.instance_id = "INTERNAL_DOCKER"
+
+    def get_dependencies(self):
+        return ["live.arkitekt.docker_socket"]
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        deps = init.dependencies
+
+        if self.skip:
+            return
+
+        self._socket = deps["live.arkitekt.docker_socket"].register_socket(self.host)
+
+        self.initialized = True
+
+    def build(self, context: ExecutionContext):
+        if self.skip:
+            return
+        db_service = {
+            "labels": [
+                "fakts.service=io.livekit.livekit",
+                "fakts.builder=livekitio.livekit",
+            ],
+            "image": self.image,
+            "command": self.command,
+            "volumes": [f"{self._socket}:/var/run/docker.sock"],
+            "environment": {
+                "INSTANCE_ID": self.instance_id,
+            },
+        }
+
+        context.docker_compose.set_nested("services", self.host, db_service)
+
+    def get_options(self):
+        with_command = Option(
+            subcommand="command",
+            help="The fakts url for connection",
+            default=self.command,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="The fakts url for connection",
+            default=self.host,
+        )
+        with_skip = Option(
+            subcommand="skip",
+            help="The fakts url for connection",
+            default=False,
+            type=bool,
+            is_flag=True,
+        )
+
+        return [
+            with_host,
+            with_command,
+            with_skip,
+        ]
+
+    def __str__(self) -> str:
+        return (
+            f"InterDocker(host={self.host}, command={self.command}, image={self.image})"
+        )