arkitekt-next 0.7.37__py3-none-any.whl → 0.7.39__py3-none-any.whl

arkitekt_next/__blok__.py

@@ -14,6 +14,9 @@ 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
+from arkitekt_next.bloks.tailscale import TailscaleBlok
+from arkitekt_next.bloks.secret import SecretBlok
+from arkitekt_next.bloks.namegen import PreformedNamesBlok
 
 
 def get_bloks():
@@ -34,4 +37,7 @@ def get_bloks():
         InternalDockerBlok(),
         DockerSocketBlok(),
         RekuestBlok(),
+        TailscaleBlok(),
+        SecretBlok(),
+        PreformedNamesBlok(),
     ]

arkitekt_next/bloks/arkitekt.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel
 from typing import Dict, Any
+from arkitekt_next.bloks.tailscale import TailscaleBlok
 from blok import blok, InitContext, Renderer, Panel
 from .livekit import LocalLiveKitBlok
 from .mikro import MikroBlok
@@ -29,7 +30,7 @@ class ArkitektBlok:
             )
         )
 
-    def preflight(self, lok: LocalLiveKitBlok, mikro: MikroBlok, kabinet: KabinetBlok, rekuest: RekuestBlok, fluss: FlussBlok, gateway: GatewayBlok, internal_engine: InternalDockerBlok):
+    def preflight(self, lok: LocalLiveKitBlok, mikro: MikroBlok, kabinet: KabinetBlok, rekuest: RekuestBlok, fluss: FlussBlok, gateway: GatewayBlok, internal_engine: InternalDockerBlok, scale: TailscaleBlok):
         print (lok, mikro, kabinet, rekuest, fluss, gateway, internal_engine)
 
 

arkitekt_next/bloks/fluss.py

@@ -1,5 +1,8 @@
 import secrets
-from arkitekt_next.bloks.funcs import create_default_service_yaml
+from arkitekt_next.bloks.funcs import (
+    create_default_service_dependencies,
+    create_default_service_yaml,
+)
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 
@@ -21,17 +24,11 @@ class FlussBlok:
         self.secret_key = secrets.token_hex(16)
         self.ensured_repos = []
 
+    def get_builder(self):
+        return "arkitekt.generic"
+
     def get_dependencies(self):
-        return [
-            "live.arkitekt.mount",
-            "live.arkitekt.config",
-            "live.arkitekt.gateway",
-            "live.arkitekt.postgres",
-            "live.arkitekt.lok",
-            "live.arkitekt.admin",
-            "live.arkitekt.redis",
-            "live.arkitekt.s3",
-        ]
+        return create_default_service_dependencies()
 
     def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
@@ -58,13 +55,13 @@ class FlussBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
-            is_flag=True,
+            type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
-            is_flag=True,
+            type=bool,
             default=self.build_repo,
         )
         with_host = Option(

arkitekt_next/bloks/funcs.py

@@ -3,6 +3,20 @@ from blok.tree import YamlFile, Repo
 from typing import Protocol
 from blok.utils import check_protocol_compliance
 from dataclasses import asdict
+from arkitekt_next.bloks.services import (
+    GatewayService,
+    DBService,
+    RedisService,
+    S3Service,
+    ConfigService,
+    MountService,
+    AdminService,
+    SecretService,
+    LokService,
+)
+
+from blok.bloks.services.dns import DnsService
+
 
 class DefaultService(Protocol):
     service_name: str
@@ -15,6 +29,23 @@ class DefaultService(Protocol):
 
     def get_identifier(self) -> str: ...
 
+    def get_builder(self) -> str: ...
+
+
+def create_default_service_dependencies():
+    return [
+        DnsService,
+        GatewayService,
+        DBService,
+        RedisService,
+        S3Service,
+        ConfigService,
+        MountService,
+        AdminService,
+        SecretService,
+        LokService,
+    ]
+
 
 def create_default_service_yaml(
     init: InitContext,
@@ -22,17 +53,28 @@ def create_default_service_yaml(
 ) -> 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)
+    init.get_service(LokService).register_scopes(self.scopes)
+
+    path_name = self.host
+
+    gateway_access = init.get_service(GatewayService).expose(path_name, 80, self.host)
+
+    postgress_access = init.get_service(DBService).register_db(self.host)
+    redis_access = init.get_service(RedisService).register()
+    lok_access = init.get_service(LokService).retrieve_credentials()
+    admin_access = init.get_service(AdminService).retrieve()
+    minio_access = init.get_service(S3Service).create_buckets(self.buckets)
+    lok_labels = init.get_service(LokService).retrieve_labels(
+        self.get_identifier(), self.get_builder()
+    )
+
+    dns_result = init.get_service(DnsService).get_dns_result()
 
-    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())
+    csrf_trusted_origins = []
+    for hostname in dns_result.hostnames:
+        csrf_trusted_origins.append(f"http://{hostname}")
+        csrf_trusted_origins.append(f"https://{hostname}")
 
     configuration = YamlFile(
         **{
@@ -47,10 +89,12 @@ def create_default_service_yaml(
             "lok": asdict(lok_access),
             "s3": asdict(minio_access),
             "scopes": self.scopes,
+            "force_script_name": path_name,
+            "csrf_trusted_origins": csrf_trusted_origins,
         }
     )
 
-    config_mount = deps["live.arkitekt.config"].register_config(
+    config_mount = init.get_service(ConfigService).register_config(
         f"{self.host}.yaml", configuration
     )
 
@@ -72,11 +116,15 @@ def create_default_service_yaml(
     }
 
     if self.mount_repo:
-        mount = deps["live.arkitekt.mount"].register_mount(self.host, Repo(self.repo))
+        mount = init.get_service(MountService).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))
+        mount = init.get_service(MountService).register_mount(
+            self.host, Repo(self.repo)
+        )
         service["build"] = mount
     else:
         service["image"] = self.image

arkitekt_next/bloks/gateway.py

@@ -16,16 +16,25 @@ class ExposedHost(BaseModel):
     stip_prefix: bool = True
 
 
+class ExpostedToHost(BaseModel):
+    port: int
+    host: str
+    to: str
+    tls: bool = False
+
+
 class ExposedPort(BaseModel):
     port: int
     host: str
     tls: bool = False
+    to: int
 
 
 @blok("live.arkitekt.gateway")
 class GatewayBlok:
     def __init__(self) -> None:
         self.exposed_hosts = {}
+        self.exposed_to_hosts = {}
         self.http_expose_default = None
         self.exposed_ports = {}
         self.with_certer = True
@@ -36,6 +45,15 @@ class GatewayBlok:
         self.public_ips = DEFAULT_PUBLIC_URLS
         self.public_hosts = DEFAULT_PUBLIC_HOSTS
 
+    def get_internal_host(self):
+        return "caddy"
+
+    def get_https_port(self):
+        return 443
+
+    def get_http_port(self):
+        return 80
+
     def preflight(self, init: InitContext, dns: DnsService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
@@ -43,7 +61,10 @@ class GatewayBlok:
         self.public_ips = dns.get_dns_result().ip_addresses
         self.public_hosts = dns.get_dns_result().hostnames
 
-    def build(self, context: ExecutionContext,):
+    def build(
+        self,
+        context: ExecutionContext,
+    ):
         caddyfile = """
 {
     auto_https off
@@ -55,13 +76,13 @@ class GatewayBlok:
                 caddyfile += f"""
 :{port.port} {{
     tls /certs/caddy.crt /certs/caddy.key
-    reverse_proxy {port.host}:{port.port}
+    reverse_proxy {port.host}:{port.to}
 }}
                 """
             else:
                 caddyfile += f"""
 :{port.port} {{
-    reverse_proxy {port.host}:{port.port}
+    reverse_proxy {port.host}:{port.to}
 }}
                 """
 
@@ -103,6 +124,15 @@ class GatewayBlok:
     }}
                 """
 
+            for path_name, exposed_to_host in self.exposed_to_hosts.items():
+                caddyfile += f"""
+    @{path_name} path /{path_name}*
+    handle @{path_name} {{
+        rewrite * /{exposed_to_host.to}{{uri}}
+        reverse_proxy {exposed_to_host.host}:{exposed_to_host.port}
+    }}
+                """
+
             if self.http_expose_default:
                 caddyfile += f"""
     handle {{
@@ -120,10 +150,18 @@ class GatewayBlok:
         if self.with_certer:
             caddy_depends_on.append("certer")
 
+        exposed_ports_strings = [
+            f"{port.port}:{port.port}" for port in self.exposed_ports.values()
+        ]
+
         caddy_container = {
             "image": "caddy:latest",
             "volumes": ["./configs/Caddyfile:/etc/caddy/Caddyfile", "./certs:/certs"],
-            "ports": [f"{self.http_port}:80", f"{self.https_port}:443"],
+            "ports": [
+                f"{self.http_port}:80",
+                f"{self.https_port}:443",
+            ]
+            + exposed_ports_strings,
             "depends_on": caddy_depends_on,
         }
 
@@ -141,16 +179,24 @@ class GatewayBlok:
 
         context.docker_compose.set_nested("services", "certer", certer_container)
 
-    def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = True):
+    def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = False):
         self.exposed_hosts[path_name] = ExposedHost(
             host=host, port=port, stip_prefix=strip_prefix
         )
 
+    def expose_mapped(self, path_name: str, port: int, host: str, to: str):
+        self.exposed_to_hosts[path_name] = ExpostedToHost(host=host, port=port, to=to)
+
     def expose_default(self, port: int, host: str):
         self.http_expose_default = ExposedHost(host=host, port=port, stip_prefix=False)
 
     def expose_port(self, port: int, host: str, tls: bool = False):
-        self.exposed_ports[port] = ExposedPort(port=port, host=host, tls=tls)
+        self.exposed_ports[port] = ExposedPort(port=port, host=host, tls=tls, to=port)
+
+    def expose_port_to(self, port: int, host: str, to_port: int, tls: bool = False):
+        self.exposed_ports[port] = ExposedPort(
+            port=port, host=host, tls=tls, to=to_port
+        )
 
     def get_options(self):
         with_public_urls = Option(

arkitekt_next/bloks/internal_docker.py

@@ -1,7 +1,11 @@
 from typing import Dict, Any
 import secrets
 
+from arkitekt_next.bloks.lok import LokBlok
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.socket import DockerSocketBlok
 from blok import blok, InitContext, ExecutionContext, Option
+from blok.bloks.services.dns import DnsService
 from blok.tree import YamlFile, Repo
 
 
@@ -9,16 +13,12 @@ from blok.tree import YamlFile, Repo
 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):
+    def preflight(self, init: InitContext, gateway: GatewayService, lok: LokBlok, socket: DockerSocketBlok):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -27,7 +27,15 @@ class InternalDockerBlok:
         if self.skip:
             return
 
-        self._socket = deps["live.arkitekt.docker_socket"].register_socket(self.host)
+        self._socket = socket.register_socket(self.host)
+        self.gateway_host = gateway.get_internal_host()
+        self.gateway_port = gateway.get_http_port()
+
+        self.token = lok.retrieve_token()
+
+        self.command = (
+           f"arkitekt-next run prod --redeem-token={self.token} --url http://{self.gateway_host}:{self.gateway_port}"
+        )
 
         self.initialized = True
 
@@ -50,27 +58,21 @@ class InternalDockerBlok:
         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",
+            help="The host of this service",
             default=self.host,
         )
         with_skip = Option(
             subcommand="skip",
-            help="The fakts url for connection",
+            help="Should we skip creating this service?",
             default=False,
             type=bool,
-            is_flag=True,
+           
         )
 
         return [
             with_host,
-            with_command,
             with_skip,
         ]
 

arkitekt_next/bloks/kabinet.py

@@ -1,7 +1,10 @@
 from typing import Dict, Any
 import secrets
 
-from arkitekt_next.bloks.funcs import create_default_service_yaml
+from arkitekt_next.bloks.funcs import (
+    create_default_service_yaml,
+    create_default_service_dependencies,
+)
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import Repo, YamlFile
 
@@ -12,7 +15,10 @@ class KabinetBlok:
         self.host = "kabinet"
         self.command = "bash run-debug.sh"
         self.repo = "https://github.com/jhnnsrs/kabinet-server"
-        self.scopes = {"read_image": "Read image from the database"}
+        self.scopes = {
+            "kabinet_deploy": "Deploy containers",
+            "kabinet_add_repo": "Add repositories to the database",
+        }
         self.mount_repo = False
         self.build_repo = False
         self.buckets = ["media"]
@@ -20,17 +26,11 @@ class KabinetBlok:
         self.ensured_repos = []
         self.image = "jhnnsrs/kabinet:next"
 
+    def get_builder(self):
+        return "arkitekt.generic"
+
     def get_dependencies(self):
-        return [
-            "live.arkitekt.mount",
-            "live.arkitekt.config",
-            "live.arkitekt.gateway",
-            "live.arkitekt.postgres",
-            "live.arkitekt.lok",
-            "live.arkitekt.admin",
-            "live.arkitekt.redis",
-            "live.arkitekt.s3",
-        ]
+        return create_default_service_dependencies()
 
     def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
@@ -57,13 +57,13 @@ class KabinetBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
-            is_flag=True,
+            type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
-            is_flag=True,
+            type=bool,
             default=self.build_repo,
         )
         with_host = Option(

arkitekt_next/bloks/livekit.py

@@ -22,7 +22,6 @@ class LocalLiveKitBlok:
         self.api_secret = "secret"
         self.skip = False
 
-
     def preflight(self, init: InitContext, gateway: GatewayService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
@@ -33,16 +32,18 @@ class LocalLiveKitBlok:
             return
 
         gateway.expose_port(7880, self.host, True)
-        gateway.expose_port(7881, self.host, True)
+        gateway.expose_port_to(7882, self.host, 7880, False)
 
         self.initialized = True
 
     def retrieve_access(self):
-        return LivekitCredentials(**{
-            "api_key": self.api_key,
-            "api_secret": self.api_secret,
-            "api_url": f"http://{self.host}:7880",
-        })
+        return LivekitCredentials(
+            **{
+                "api_key": self.api_key,
+                "api_secret": self.api_secret,
+                "api_url": f"http://{self.host}:7880",
+            }
+        )
 
     def build(self, context: ExecutionContext):
         if self.skip:
@@ -55,18 +56,14 @@ class LocalLiveKitBlok:
             "image": self.image,
             "command": self.command,
             "ports": [
-                f"{self.port_range[0]}-{self.port_range[1]}:{self.port_range[0]}-{self.port_range[1]}"
+                f"{self.port_range[0]}-{self.port_range[1]}:{self.port_range[0]}-{self.port_range[1]}",
+                "7881:7881",
             ],
         }
 
         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",
@@ -77,12 +74,10 @@ class LocalLiveKitBlok:
             help="The fakts url for connection",
             default=False,
             type=bool,
-            is_flag=True,
         )
 
         return [
             with_host,
-            with_command,
             with_skip,
         ]