arkitekt-next 0.7.37__tar.gz → 0.7.38__tar.gz

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.37
+Version: 0.7.38
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/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-0.7.37 → arkitekt_next-0.7.38}/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-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/fluss.py

@@ -58,13 +58,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-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/gateway.py

@@ -36,6 +36,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)

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/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-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/kabinet.py

@@ -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-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/livekit.py

@@ -77,7 +77,7 @@ class LocalLiveKitBlok:
             help="The fakts url for connection",
             default=False,
             type=bool,
-            is_flag=True,
+            
         )
 
         return [

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/lok.py

@@ -5,6 +5,7 @@ from cryptography.hazmat.primitives import serialization as crypto_serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.backends import default_backend as crypto_default_backend
 from typing import Dict
+from arkitekt_next.bloks.secret import SecretBlok
 from arkitekt_next.bloks.services.admin import AdminService
 from arkitekt_next.bloks.services.db import DBService
 from arkitekt_next.bloks.services.gateway import GatewayService
@@ -145,15 +146,9 @@ class LokBlok:
             "accounts",
         ]
         self.token_expiry_seconds = 700000
+        self.preformed_redeem_tokens = [secrets.token_hex(16) for i in range(80)]
+        self.registered_tokens = {}
 
-    def get_dependencies(self):
-        return [
-            "io.livekit.livekit",
-            "live.arkitekt.postgres",
-            "live.arkitekt.redis",
-            "live.arkitekt.admin",
-            "live.arkitekt.gateway",
-        ]
 
     def retrieve_credentials(self) -> LokCredentials:
         return LokCredentials(
@@ -165,11 +160,17 @@ class LokBlok:
             f"fakts.service={service_name}",
             f"fakts.builder=arkitekt.{service_name}",
         ]
+    
+    def retrieve_token(self, user: str = "admin") -> str:
+        new_token = self.secret_blok.retrieve_secret()
+        self.registered_tokens[user] = new_token
+
+        return new_token
 
     def register_scopes(self, scopes_dict: Dict[str, str]) -> LokCredentials:
         self.scopes = self.scopes | scopes_dict
 
-    def preflight(self, init: InitContext, gateway: GatewayService, db: DBService, redis: RedisService, admin: AdminService, livekit: LivekitService, scopes: list[Dict[str, str]]):
+    def preflight(self, init: InitContext, gateway: GatewayService, db: DBService, redis: RedisService, admin: AdminService, secrets: SecretBlok, livekit: LivekitService, scopes: list[Dict[str, str]]):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -183,6 +184,7 @@ class LokBlok:
                 i, 80, self.host, strip_prefix=False
             )
 
+        self.secret_blok = secrets
         self.postgress_access = db.register_db(self.host)
         self.redis_access = redis.register()
         self.admin_access = admin.retrieve()
@@ -235,7 +237,7 @@ class LokBlok:
                 "private_key": self.private_key,
                 "public_key": self.public_key,
                 "scopes": self.scopes,
-                "redeem_tokens": [token for token in self.tokens],
+                "redeem_tokens": [token for token in self.registered_tokens],
                 "groups": [group for group in self.groups],
                 "deployment": {"name": self.deployment_name},
                 "livekit": asdict(self.local_access),
@@ -270,82 +272,82 @@ class LokBlok:
 
         with_fakts_url = Option(
             subcommand="db_name",
-            help="The fakts url for connection",
+            help="The name of the database",
             default="db_name",
+            show_default=True,
         )
         with_users = Option(
             subcommand="users",
-            help="The fakts url for connection",
+            help="Users that should be greated by default. Format is name:password",
             default=["admin:admin"],
             multiple=True,
             type=USER,
+            show_default=True,
         )
         with_groups = Option(
             subcommand="groups",
-            help="The fakts url for connection",
+            help="Groups that should be greated by default. Format is name:description",
             default=["admin:admin_group"],
             multiple=True,
             type=GROUP,
-        )
-        with_redeem_token = Option(
-            subcommand="tokens",
-            help="The fakts url for connection",
-            default=[],
-            multiple=True,
-            type=TOKEN,
+            show_default=True,
         )
         with_scopes = Option(
             subcommand="scopes",
-            help="The scopes",
+            help="Additional scopes that should be created (normally handled by the bloks)",
             default=[f"{key}:{value}" for key, value in self.scopes.items()],
             multiple=True,
             type=SCOPE,
         )
         with_repo = Option(
             subcommand="with_repo",
-            help="The fakts url for connection",
+            help="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
             default=self.repo,
+            show_default=True,
         )
         with_repo = Option(
             subcommand="command",
-            help="The fakts url for connection",
+            help="Which command should be run when starting the service?",
             default=self.command,
+            show_default=True,
         )
         mount_repo = Option(
             subcommand="mount_repo",
             help="The fakts url for connection",
-            is_flag=True,
+           type=bool,
             default=False,
         )
         build_repo = Option(
             subcommand="build_repo",
-            help="The fakts url for connection",
-            is_flag=True,
+            help="Should we build the container from the repo?",
+            type=bool,
             default=False,
+            show_default=True,
         )
         with_host = Option(
             subcommand="host",
-            help="The fakts url for connection",
+            help="Which internal hostname should be used",
             default=self.host,
+            show_default=True,
         )
         #
         with_public_key = Option(
             subcommand="public_key",
-            help="The fakts url for connection",
+            help="The public key for the JWT creation",
             default=public_key,
             required=True,
             callback=validate_public_key,
         )
         with_private_key = Option(
             subcommand="private_key",
-            help="The fakts url for connection",
+            help="The corresponding private key for the JWT creation",
             default=private_key,
             callback=validate_private_key,
             required=True,
         )
         with_secret_key = Option(
             subcommand="secret_key",
-            help="The fakts url for connection",
+            help="The secret key to use for the django service",
             default=self.secret_key,
         )
 
@@ -357,7 +359,6 @@ class LokBlok:
             with_groups,
             build_repo,
             with_host,
-            with_redeem_token,
             with_private_key,
             with_public_key,
             with_scopes,

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/mikro.py

@@ -23,7 +23,7 @@ class MikroBlok:
     def __init__(self) -> None:
         self.host = "mikro"
         self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/jhnnsrs/mikro-server-next"
+        self.repo = "https://github.com/arkitektio/mikro-server-next"
         self.scopes = {"read_image": "Read image from the database"}
         self.image = "jhnnsrs/mikro:next"
         self.mount_repo = False
@@ -68,13 +68,13 @@ class MikroBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="The fakts url for connection",
-            is_flag=True,
+            type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(
             subcommand="build_repo",
             help="The fakts url for connection",
-            is_flag=True,
+            type=bool,
             default=self.build_repo,
         )
         with_host = Option(

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/minio.py

@@ -1,5 +1,9 @@
 import click
 
+from arkitekt_next.bloks.services.config import ConfigService
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.services.name import NameService
+from arkitekt_next.bloks.services.secret import SecretService
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from pydantic import BaseModel
@@ -50,20 +54,16 @@ class MinioBlok:
         self.preformed_access_keys = [secrets.token_hex(16) for i in range(100)]
         self.preformed_secret_keys = [secrets.token_hex(16) for i in range(100)]
 
-    def get_identifier(self):
-        return "live.arkitekt.s3"
 
-    def get_dependencies(self):
-        return ["live.arkitekt.config", "live.arkitekt.gateway"]
 
     def create_buckets(self, buckets: list[str]) -> S3Credentials:
-        new_access_key = self.preformed_access_keys.pop()
-        new_secret_key = self.preformed_secret_keys.pop()
+        new_access_key = self.secret_service.retrieve_secret()
+        new_secret_key = self.secret_service.retrieve_secret()
 
         bucket_map = {}
 
         for bucket in buckets:
-            bucket_map[bucket] = self.preformed_bucket_names.pop()
+            bucket_map[bucket] = self.name_service.retrieve_name()
 
         self.buckets.extend(bucket_map.values())
 
@@ -81,19 +81,15 @@ class MinioBlok:
 
         return creds
 
-    def preflight(self, init: InitContext):
+    def preflight(self, init: InitContext, secret: SecretService, name: NameService, gateway: GatewayService, config: ConfigService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        self.preformed_bucket_names = list(
-            init.kwargs.get("preformed_bucket_names", [])
-        )
-        self.preformed_access_keys = list(init.kwargs.get("preformed_access_keys", []))
-        self.preformed_secret_keys = list(init.kwargs.get("preformed_secret_keys", []))
-
-        init.dependencies["live.arkitekt.gateway"].expose_default(9000, self.host)
+        gateway.expose_default(9000, self.host)
+        self.secret_service = secret
+        self.name_service = name
 
-        self.config_path = init.dependencies["live.arkitekt.config"].get_path(
+        self.config_path = config.get_path(
             self.host + ".yaml"
         )
 
@@ -151,30 +147,9 @@ class MinioBlok:
             help="The fakts url for connection",
             default=self.password,
         )
-        with_preformed_bucket_names = Option(
-            subcommand="preformed_bucket_names",
-            help="The fakts url for connection",
-            multiple=True,
-            default=self.preformed_bucket_names,
-        )
-        with_preformed_acces_key = Option(
-            subcommand="preformed_access_keys",
-            help="The fakts url for connection",
-            multiple=True,
-            default=self.preformed_access_keys,
-        )
-        with_preformed_secret_keys = Option(
-            subcommand="preformed_secret_keys",
-            help="The fakts url for connection",
-            multiple=True,
-            default=self.preformed_secret_keys,
-        )
 
         return [
             with_host,
             with_password,
             with_username,
-            with_preformed_bucket_names,
-            with_preformed_acces_key,
-            with_preformed_secret_keys,
         ]

arkitekt_next-0.7.38/arkitekt_next/bloks/namegen.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from arkitekt_next.bloks.services.name import NameService
+from blok import blok, InitContext, Option, ExecutionContext
+from blok.tree import YamlFile
+from arkitekt_next.bloks.services.secret import SecretService
+import secrets
+import namegenerator
+
+@blok(NameService)
+class PreformedNamesBlok:
+    def __init__(self) -> None:
+        self.preformed_names = [namegenerator.gen() for _ in range(100)]
+        self.used_names = []
+
+    def preflight(self, init: InitContext, preformed_names: list[str]):
+        self.preformed_names = list(preformed_names)
+        self.used_names = []
+
+    def retrieve_name(self) -> str:
+        name = self.preformed_names.pop()
+        self.used_names.append(name)
+        return name
+
+
+    def get_options(self):
+        config_path = Option(
+            subcommand="preformed_names",
+            help="A list of preformed names",
+            default=self.preformed_names,
+            multiple=True,
+        )
+
+        return [config_path]

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/redis.py

@@ -65,7 +65,7 @@ class RedisBlok:
         with_skip = Option(
             subcommand="skip",
             help="Skip docker creation (if using external redis?)",
-            is_flag=True,
+           type=bool,
             default=self.skip,
         )
         with_image = Option(

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/rekuest.py

@@ -47,23 +47,25 @@ class RekuestBlok:
         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",
+            type=str,
             default=self.repo,
         )
         with_command = Option(
             subcommand="command",
             help="Which command should be run when starting the service",
+            type=str,
             default=self.command,
         )
         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-0.7.38/arkitekt_next/bloks/secret.py

@@ -0,0 +1,33 @@
+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.secret import SecretService
+import secrets
+
+@blok(SecretService)
+class SecretBlok:
+    def __init__(self) -> None:
+        self.preformed_secrets = [secrets.token_urlsafe(32) for _ in range(100)]
+        self.registered_secrets = []
+
+    def preflight(self, init: InitContext, preformed_secrets: list[str]):
+        self.preformed_secrets = list(preformed_secrets)
+
+    def retrieve_secret(self) -> str:
+        new_secret = self.preformed_secrets.pop()
+        self.registered_secrets.append(new_secret)
+        return new_secret
+
+
+
+    def get_options(self):
+        config_path = Option(
+            subcommand="preformed_secrets",
+            help="Which path to use for configs",
+            default=self.preformed_secrets,
+            multiple=True,
+            show_default=False,
+        )
+
+        return [config_path]

{arkitekt_next-0.7.37 → arkitekt_next-0.7.38}/arkitekt_next/bloks/services/gateway.py

@@ -17,4 +17,14 @@ class GatewayService(Protocol):
 
     def expose_port(self, port: int, host: str, tls: bool = False):
         ...
+
+    def get_internal_host(self):
+        ...
+
+
+    def get_https_port(self):
+        ...
+
+    def get_http_port(self):
+        ...
     

arkitekt_next-0.7.38/arkitekt_next/bloks/services/name.py

@@ -0,0 +1,12 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+
+
+@service("live.arkitekt.names")
+class NameService(Protocol):
+
+    def retrieve_name(self) -> str:
+        pass

arkitekt_next-0.7.38/arkitekt_next/bloks/services/secret.py

@@ -0,0 +1,17 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+@dataclass
+class AdminCredentials:
+    password: str
+    username: str
+    email: str
+
+
+@service("live.arkitekt.secrets")
+class SecretService(Protocol):
+
+    def retrieve_secret() -> str:
+        pass