arkitekt-next 0.7.43__tar.gz → 0.7.45__tar.gz

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/PKG-INFO

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

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/arkitekt_next/bloks/fluss.py

@@ -1,5 +1,6 @@
 import secrets
 from arkitekt_next.bloks.funcs import (
+    build_default_service_options,
     create_default_service_dependencies,
     create_default_service_yaml,
 )
@@ -13,6 +14,7 @@ DEFAULT_ARKITEKT_URL = "http://localhost:8000"
 @blok("live.arkitekt.fluss")
 class FlussBlok:
     def __init__(self) -> None:
+        self.dev = False
         self.host = "fluss"
         self.command = "bash run-debug.sh"
         self.image = "jhnnsrs/fluss:next"
@@ -42,44 +44,8 @@ class FlussBlok:
         context.docker_compose.set_nested("services", self.host, self.service)
 
     def get_options(self):
-        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 = Option(
-            subcommand="command",
-            help="Which command should be run when starting the service",
-            default=self.command,
-        )
-        mount_repo = Option(
-            subcommand="mount_repo",
-            help="Should we mount the repo into the container?",
-            type=bool,
-            default=self.mount_repo,
-        )
-        build_repo = Option(
-            subcommand="build_repo",
-            help="Should we build the container from the repo?",
-            type=bool,
-            default=self.build_repo,
-        )
-        with_host = Option(
-            subcommand="host",
-            help="How should the service be named inside the docker-compose file?",
-            default=self.host,
-        )
-        with_secret_key = Option(
-            subcommand="secret_key",
-            help="The secret key to use for the django service",
-            default=self.secret_key,
-        )
+        def_options = build_default_service_options(self)
 
         return [
-            with_repo,
-            mount_repo,
-            build_repo,
-            with_host,
-            with_command,
-            with_secret_key,
+            *def_options,
         ]

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/arkitekt_next/bloks/funcs.py

@@ -1,6 +1,6 @@
 from blok import blok, InitContext, Option
 from blok.tree import YamlFile, Repo
-from typing import Protocol
+from typing import Any, Protocol
 from blok.utils import check_protocol_compliance
 from dataclasses import asdict
 from arkitekt_next.bloks.services import (
@@ -19,6 +19,9 @@ from blok.bloks.services.dns import DnsService
 
 
 class DefaultService(Protocol):
+    dev: bool
+    repo: str
+    command: str
     service_name: str
     host: str
     buckets: list[str]
@@ -47,12 +50,61 @@ def create_default_service_dependencies():
     ]
 
 
+def build_default_service_options(self: DefaultService) -> list[Option]:
+    return [
+        Option(
+            subcommand="dev",
+            help="Shoud we run the service in development mode (includes withrepo, mountrepo)?",
+            default=self.dev,
+        ),
+        Option(
+            subcommand="disable",
+            help="Shoud we disable the service?",
+            default=False,
+        ),
+        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,
+        ),
+        Option(
+            subcommand="with_command",
+            help="Which command should we use when building the service?",
+            default=self.command,
+        ),
+        Option(
+            subcommand="mount_repo",
+            help="Should we mount the repo into the container?",
+            type=bool,
+            default=self.mount_repo,
+        ),
+        Option(
+            subcommand="build_repo",
+            help="Should we build the container from the repo?",
+            type=bool,
+            default=self.build_repo,
+        ),
+        Option(
+            subcommand="host",
+            help="How should the service be named inside the docker-compose file?",
+            default=self.host,
+        ),
+        Option(
+            subcommand="secret_key",
+            help="The secret key to use for the django service",
+            default=self.secret_key,
+        ),
+    ]
+
+
 def create_default_service_yaml(
     init: InitContext,
     self: DefaultService,
+    additional_keys: dict[str, Any] = None,
 ) -> YamlFile:
     check_protocol_compliance(self, DefaultService)
     deps = init.dependencies
+    additional_keys = additional_keys or {}
 
     init.get_service(LokService).register_scopes(self.scopes)
 
@@ -91,6 +143,7 @@ def create_default_service_yaml(
             "scopes": self.scopes,
             "force_script_name": path_name,
             "csrf_trusted_origins": csrf_trusted_origins,
+            **additional_keys,
         }
     )
 
@@ -115,13 +168,13 @@ def create_default_service_yaml(
         "depends_on": depends_on,
     }
 
-    if self.mount_repo:
+    if self.mount_repo or self.dev:
         mount = init.get_service(MountService).register_mount(
             self.host, Repo(self.repo)
         )
         service["volumes"].extend([f"{mount}:/workspace"])
 
-    if self.build_repo:
+    if self.build_repo or self.dev:
         mount = init.get_service(MountService).register_mount(
             self.host, Repo(self.repo)
         )

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/arkitekt_next/bloks/gateway.py

@@ -1,3 +1,4 @@
+from arkitekt_next.bloks.services.name import NameService
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from pydantic import BaseModel
@@ -54,12 +55,16 @@ class GatewayBlok:
     def get_http_port(self):
         return 80
 
-    def preflight(self, init: InitContext, dns: DnsService):
+    def retrieve_gateway_network(self):
+        return self.gateway_network
+
+    def preflight(self, init: InitContext, dns: DnsService, name: NameService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
         self.public_ips = dns.get_dns_result().ip_addresses
         self.public_hosts = dns.get_dns_result().hostnames
+        self.gateway_network = name.retrieve_name().replace("-", "_")
 
     def build(
         self,
@@ -163,7 +168,7 @@ class GatewayBlok:
             ]
             + exposed_ports_strings,
             "depends_on": caddy_depends_on,
-            "networks": ["gateway", "default"],
+            "networks": [self.gateway_network, "default"],
         }
 
         context.docker_compose.set_nested("services", "caddy", caddy_container)
@@ -179,7 +184,11 @@ class GatewayBlok:
         }
 
         context.docker_compose.set_nested("services", "certer", certer_container)
-        context.docker_compose.set_nested("networks", "gateway", {"driver": "bridge"})
+        context.docker_compose.set_nested(
+            "networks",
+            self.gateway_network,
+            {"driver": "bridge", "name": self.gateway_network},
+        )
 
     def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = False):
         self.exposed_hosts[path_name] = ExposedHost(

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/arkitekt_next/bloks/internal_docker.py

@@ -14,7 +14,7 @@ class InternalDockerBlok:
     def __init__(self) -> None:
         self.host = "internal_docker"
 
-        self.image = "jhnnsrs/deployer:0.0.2-vanilla"
+        self.image = "jhnnsrs/deployer:0.0.8-vanilla"
         self.instance_id = "INTERNAL_DOCKER"
 
     def preflight(
@@ -38,6 +38,8 @@ class InternalDockerBlok:
 
         self.token = lok.retrieve_token()
 
+        self.gateway_network = gateway.retrieve_gateway_network()
+
         self.command = f"arkitekt-next run prod --redeem-token={self.token} --url http://{self.gateway_host}:{self.gateway_port}"
 
         self.initialized = True
@@ -56,14 +58,14 @@ class InternalDockerBlok:
             "environment": {
                 "INSTANCE_ID": self.instance_id,
                 "ARKITEKT_GATEWAY": f"http://{self.gateway_host}:{self.gateway_port}",
-                "ARKITEKT_NETWORK": "gateway",
+                "ARKITEKT_NETWORK": self.gateway_network,
             },
             "deploy": {
                 "restart_policy": {
                     "condition": "on-failure",
                     "delay": "10s",
-                    "max_attempts": 3,
-                    "window": "120s",
+                    "max_attempts": 10,
+                    "window": "300s",
                 },
             },
         }

arkitekt_next-0.7.45/arkitekt_next/bloks/kabinet.py

@@ -0,0 +1,61 @@
+from typing import Dict, Any
+import secrets
+
+from arkitekt_next.bloks.funcs import (
+    create_default_service_yaml,
+    create_default_service_dependencies,
+    build_default_service_options,
+)
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import Repo, YamlFile
+
+
+@blok("live.arkitekt.kabinet")
+class KabinetBlok:
+    def __init__(self) -> None:
+        self.dev = False
+        self.host = "kabinet"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/arkitektio/kabinet-server"
+        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"]
+        self.secret_key = secrets.token_hex(16)
+        self.ensured_repos = ["jhnnsrs/ome:main", "jhnnsrs/renderer:main"]
+        self.image = "jhnnsrs/kabinet:next"
+
+    def get_builder(self):
+        return "arkitekt.generic"
+
+    def get_dependencies(self):
+        return create_default_service_dependencies()
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        self.service = create_default_service_yaml(
+            init, self, {"ensured_repos": self.ensured_repos}
+        )
+
+        self.initialized = True
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)
+
+    def get_options(self):
+        def_options = build_default_service_options(self)
+        with_repos = Option(
+            subcommand="repos",
+            help="The default repos to enable for the service",
+            default=self.secret_key,
+        )
+
+        return [
+            *def_options,
+            with_repos,
+        ]

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/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.funcs import build_default_service_options
 from arkitekt_next.bloks.secret import SecretBlok
 from arkitekt_next.bloks.services.admin import AdminService
 from arkitekt_next.bloks.services.db import DBService
@@ -124,6 +125,7 @@ class LokBlok:
         self.private_key = None
         self.public_key = None
         self.host = "lok"
+        self.dev = False
         self.with_repo = False
         self.command = "bash run-debug.sh"
         self.repo = "https://github.com/jhnnsrs/lok-server-next"
@@ -210,11 +212,11 @@ class LokBlok:
             ],
         }
 
-        if self.mount_repo:
+        if self.mount_repo or self.dev:
             context.file_tree.set_nested("mounts", "lok", Repo(self.repo))
-            db_service["volumes"].append("./mounts/lok:/lok")
+            db_service["volumes"].append("./mounts/lok:/workspace")
 
-        if self.build_repo:
+        if self.build_repo or self.dev:
             context.file_tree.set_nested("mounts", "lok", Repo(self.repo))
             db_service["build"] = "./mounts/lok"
         else:
@@ -281,6 +283,16 @@ class LokBlok:
             .decode()
         )
 
+        def_options = build_default_service_options(self)
+
+        with_dev = Option(
+            subcommand="dev",
+            help="Run the service in development mode",
+            type=bool,
+            default=self.dev,
+            show_default=True,
+        )
+
         with_fakts_url = Option(
             subcommand="db_name",
             help="The name of the database",
@@ -303,38 +315,6 @@ class LokBlok:
             type=GROUP,
             show_default=True,
         )
-        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,
-            show_default=True,
-        )
-        with_repo = Option(
-            subcommand="command",
-            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",
-            type=bool,
-            default=False,
-        )
-        build_repo = Option(
-            subcommand="build_repo",
-            help="Should we build the container from the repo?",
-            type=bool,
-            default=False,
-            show_default=True,
-        )
-        with_host = Option(
-            subcommand="host",
-            help="Which internal hostname should be used",
-            default=self.host,
-            show_default=True,
-        )
-        #
         with_public_key = Option(
             subcommand="public_key",
             help="The public key for the JWT creation",
@@ -349,23 +329,14 @@ class LokBlok:
             callback=validate_private_key,
             required=True,
         )
-        with_secret_key = Option(
-            subcommand="secret_key",
-            help="The secret key to use for the django service",
-            default=self.secret_key,
-        )
 
         return [
+            *def_options,
             with_fakts_url,
             with_users,
-            with_repo,
-            mount_repo,
             with_groups,
-            build_repo,
-            with_host,
             with_private_key,
             with_public_key,
-            with_secret_key,
         ]
 
 

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/arkitekt_next/bloks/mikro.py

@@ -8,6 +8,7 @@ from blok import blok, InitContext
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from arkitekt_next.bloks.funcs import (
+    build_default_service_options,
     create_default_service_dependencies,
     create_default_service_yaml,
     DefaultService,
@@ -25,6 +26,7 @@ class AccessCredentials(BaseModel):
 @blok("live.arkitekt.mikro")
 class MikroBlok:
     def __init__(self) -> None:
+        self.dev = False
         self.host = "mikro"
         self.command = "bash run-debug.sh"
         self.repo = "https://github.com/arkitektio/mikro-server-next"
@@ -56,44 +58,8 @@ class MikroBlok:
         context.docker_compose.set_nested("services", self.host, self.service)
 
     def get_options(self):
-        with_repo = Option(
-            subcommand="with_repo",
-            help="The fakts url for connection",
-            default=self.repo,
-        )
-        with_command = Option(
-            subcommand="command",
-            help="The fakts url for connection",
-            default=self.command,
-        )
-        mount_repo = Option(
-            subcommand="mount_repo",
-            help="The fakts url for connection",
-            type=bool,
-            default=self.mount_repo,
-        )
-        build_repo = Option(
-            subcommand="build_repo",
-            help="The fakts url for connection",
-            type=bool,
-            default=self.build_repo,
-        )
-        with_host = Option(
-            subcommand="host",
-            help="The fakts url for connection",
-            default=self.host,
-        )
-        with_secret_key = Option(
-            subcommand="secret_key",
-            help="The fakts url for connection",
-            default=self.secret_key,
-        )
+        def_options = build_default_service_options(self)
 
         return [
-            with_repo,
-            mount_repo,
-            build_repo,
-            with_host,
-            with_command,
-            with_secret_key,
+            *def_options,
         ]

arkitekt_next-0.7.45/arkitekt_next/bloks/orkestrator.py

@@ -0,0 +1,55 @@
+from typing import Dict, Any
+import secrets
+
+from arkitekt_next.bloks.funcs import (
+    create_default_service_yaml,
+    create_default_service_dependencies,
+    build_default_service_options,
+)
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import Repo, YamlFile
+
+
+@blok("live.arkitekt.orkestrator")
+class OrkestratorBlok:
+    def __init__(self) -> None:
+        self.dev = False
+        self.repo = "https://github.com/arkitektio/orkestrator-next"
+        self.scopes = {
+            "kabinet_deploy": "Deploy containers",
+            "kabinet_add_repo": "Add repositories to the database",
+        }
+        self.build_command = "yarn"
+        self.up_command = "yarn start"
+
+    def get_builder(self):
+        return "arkitekt.generic"
+
+    def get_dependencies(self):
+        return create_default_service_dependencies()
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        self.service = create_default_service_yaml(
+            init, self, {"ensured_repos": self.ensured_repos}
+        )
+
+        self.initialized = True
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)
+
+    def get_options(self):
+        def_options = build_default_service_options(self)
+        with_repos = Option(
+            subcommand="repos",
+            help="The default repos to enable for the service",
+            default=self.secret_key,
+        )
+
+        return [
+            *def_options,
+            with_repos,
+        ]

arkitekt_next-0.7.45/arkitekt_next/bloks/rekuest.py

@@ -0,0 +1,53 @@
+from typing import Dict, Any
+import secrets
+
+from arkitekt_next.bloks.funcs import (
+    build_default_service_options,
+    create_default_service_dependencies,
+    create_default_service_yaml,
+)
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import Repo, YamlFile
+
+
+@blok("live.arkitekt.rekuest")
+class RekuestBlok:
+    def __init__(self) -> None:
+        self.dev = False
+        self.host = "rekuest"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/jhnnsrs/rekuest-server-next"
+        self.scopes = {
+            "rekuest_agent": "Act as an agent",
+            "rekuest_call": "Call other apps with rekuest",
+        }
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
+        self.secret_key = secrets.token_hex(16)
+        self.ensured_repos = []
+        self.image = "jhnnsrs/rekuest:next"
+
+    def get_dependencies(self):
+        return create_default_service_dependencies()
+
+    def get_builder(self):
+        return "arkitekt.rekuest"
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        self.service = create_default_service_yaml(init, self)
+
+        self.initialized = True
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)
+
+    def get_options(self):
+        def_options = build_default_service_options(self)
+
+        return [
+            *def_options,
+        ]

{arkitekt_next-0.7.43 → arkitekt_next-0.7.45}/arkitekt_next/bloks/services/gateway.py

@@ -12,6 +12,8 @@ class GatewayService(Protocol):
         self, path_name: str, port: int, host: str, strip_prefix: bool = True
     ): ...
 
+    def retrieve_gateway_network(self): ...
+
     def expose_mapped(self, path_name: str, port: int, host: str, to_name: str): ...
 
     def expose_default(self, port: int, host: str): ...