"""Database creation, namespace management and DB build screens.""" import json import os import re import subprocess import threading from pathlib import Path import tkinter as tk from tkinter import ttk, messagebox, simpledialog from knoe import screen as ui from knoe.config import get_docker_build_platform_args from knoe.core.env import ( PROJECT_ROOT, _bool_str, _deployment_mode_from_env, _http_ping_registry, _safe_str, _push_docker_image, get_resource_path, resolve_prole_home, ) from knoe.core.ops import openbao as openbao_ops from knoe.core.ops import registry as registry_ops from knoe.core.build_context import copy_build_context_dir class DatabaseScreenMixin: """Database creation, namespace management and DB build screens.""" def _render_init_password_page(self): # Letterhead at top right content_width = self.bg_canvas.winfo_width() or 975 right_margin = content_width - 48 ui.canvas_text( self, right_margin, 40, "Prole", fill="#6e6e73", font=("SF Pro Text", 32, "bold"), anchor="ne", ) ui.canvas_text( self, right_margin, 85, "Infrastructure Automated.", fill="#6e6e73", font=("SF Pro Text", 18), anchor="ne", ) self._render_title("Database Creation", y=150) self._render_paragraph( "Configure the CloudNativePG target for this deployment. Choose the database namespace where CNPG resources will be deployed and the CNPG Cluster resource name. An ed25519 SSH key will be generated and stored in OpenBao for root access.", y=200, ) x_label = 48 x_field = 300 y = 270 # Database namespace self._canvas_items.append( ui.canvas_text( self, x_label, y, "DATABASE_NAMESPACE:", fill="black", font=("SF Pro Text", 12, "bold"), ) ) ns_frame = tk.Frame( self.bg_canvas, bg="white", highlightbackground="#CCCCCC", highlightthickness=1, bd=0, ) ns_frame.pack_propagate(False) # Placeholder 'db' label placeholder_label = tk.Label( ns_frame, text="db", fg="#CCCCCC", bg="white", font=("SF Pro Text", 11), ) def update_placeholder(*_): if self.db_namespace.get(): placeholder_label.place_forget() else: placeholder_label.place(x=8, y=5) self.db_namespace.trace_add("write", update_placeholder) vcmd = (self.root.register(self._validate_namespace), "%P") namespace_entry = tk.Entry( ns_frame, textvariable=self.db_namespace, bg="white", fg="black", insertbackground="black", highlightthickness=0, relief="flat", font=("SF Pro Text", 11), validate="key", validatecommand=vcmd, ) namespace_entry.pack(side="left", fill="both", expand=True, padx=(8, 8)) update_placeholder() ns_window = self.bg_canvas.create_window( x_field, y - 12, window=ns_frame, anchor="nw", width=400, height=32 ) self._canvas_items.append(ns_window) self._overlay_widgets.append(ns_frame) self._overlay_widgets.append(namespace_entry) y += 42 # CNPG cluster name self._canvas_items.append( ui.canvas_text( self, x_label, y, "CLUSTER_NAME:", fill="black", font=("SF Pro Text", 12, "bold"), ) ) cluster_frame = tk.Frame( self.bg_canvas, bg="white", highlightbackground="#CCCCCC", highlightthickness=1, bd=0, ) cluster_frame.pack_propagate(False) cluster_placeholder_label = tk.Label( cluster_frame, text="knoe-db", fg="#CCCCCC", bg="white", font=("SF Pro Text", 11), ) def update_cluster_placeholder(*_): try: cluster_value = self.cnpg_cluster_name.get() except Exception: cluster_value = "" if cluster_value: cluster_placeholder_label.place_forget() else: cluster_placeholder_label.place(x=8, y=5) self.cnpg_cluster_name.trace_add("write", update_cluster_placeholder) cluster_entry = tk.Entry( cluster_frame, textvariable=self.cnpg_cluster_name, bg="white", fg="black", insertbackground="black", highlightthickness=0, relief="flat", font=("SF Pro Text", 11), validate="key", validatecommand=vcmd, ) cluster_entry.pack(side="left", fill="both", expand=True, padx=(8, 8)) update_cluster_placeholder() cluster_window = self.bg_canvas.create_window( x_field, y - 12, window=cluster_frame, anchor="nw", width=400, height=32 ) self._canvas_items.append(cluster_window) self._overlay_widgets.append(cluster_frame) self._overlay_widgets.append(cluster_entry) y += 42 # Owner (local user) if not self.db_username.get(): self.db_username.set(self.namespace_owner) self._canvas_items.append( ui.canvas_text( self, x_label, y, "Owner:", fill="black", font=("SF Pro Text", 12, "bold"), ) ) owner_entry = tk.Entry( self.bg_canvas, textvariable=self.db_username, bg="white", fg="black", insertbackground="black", highlightbackground="#CCCCCC", highlightthickness=1, relief="flat", font=("SF Pro Text", 11), ) owner_window = self.bg_canvas.create_window( x_field, y - 12, window=owner_entry, anchor="nw", width=400, height=32 ) self._canvas_items.append(owner_window) self._overlay_widgets.append(owner_entry) y += 42 self._canvas_items.append( ui.canvas_text( self, x_label, y, "Master Password:", fill="black", font=("SF Pro Text", 12, "bold"), ) ) # Use tk.Entry on canvas p1 = tk.Entry( self.bg_canvas, textvariable=self.db_password, show="*", bg="white", fg="black", insertbackground="black", highlightbackground="#CCCCCC", highlightthickness=1, relief="flat", font=("SF Pro Text", 11), ) p1_window = self.bg_canvas.create_window( x_field, y - 12, window=p1, anchor="nw", width=400, height=32 ) self._canvas_items.append(p1_window) self._overlay_widgets.append(p1) y += 42 self._canvas_items.append( ui.canvas_text( self, x_label, y, "Confirm:", fill="black", font=("SF Pro Text", 12, "bold"), ) ) # Use tk.Entry on canvas p2 = tk.Entry( self.bg_canvas, textvariable=self.db_password_confirm, show="*", bg="white", fg="black", insertbackground="black", highlightbackground="#CCCCCC", highlightthickness=1, relief="flat", font=("SF Pro Text", 11), ) p2_window = self.bg_canvas.create_window( x_field, y - 12, window=p2, anchor="nw", width=400, height=32 ) self._canvas_items.append(p2_window) self._overlay_widgets.append(p2) y += 42 self._canvas_items.append( ui.canvas_text( self, x_label, y, "Host Port Forward:", fill="black", font=("SF Pro Text", 12, "bold"), ) ) port_entry = tk.Entry( self.bg_canvas, textvariable=self.db_host_port, bg="white", fg="black", insertbackground="black", highlightbackground="#CCCCCC", highlightthickness=1, relief="flat", font=("SF Pro Text", 11), ) port_window = self.bg_canvas.create_window( x_field, y - 12, window=port_entry, anchor="nw", width=100, height=32 ) self._canvas_items.append(port_window) self._overlay_widgets.append(port_entry) # Indicator for password match (X or ✓) self.password_indicator = ui.canvas_text( self, x_field + 410, y, "✘", fill="#dc3545", font=("SF Pro Text", 16, "bold"), state="hidden", ) self._canvas_items.append(self.password_indicator) # Database browser table_y = y + 50 self._canvas_items.append( ui.canvas_text( self, x_label, table_y, "Database Browser", fill="#1d1d1f", font=("SF Pro Text", 12, "bold"), ) ) refresh_btn = tk.Button( self.bg_canvas, text="Refresh", command=self._refresh_namespace_table, bg="#F5F5DC", fg="black", activebackground="#E5E5D5", highlightbackground="#F5F5DC", highlightthickness=0, relief="flat", font=("SF Pro Text", 10), padx=10, pady=4, ) refresh_window = self.bg_canvas.create_window( x_label + 160, table_y - 8, window=refresh_btn, anchor="nw" ) self._canvas_items.append(refresh_window) self._overlay_widgets.append(refresh_btn) add_btn = tk.Button( self.bg_canvas, text="Add", command=self._db_add_namespace, bg="#F5F5DC", fg="black", activebackground="#E5E5D5", highlightbackground="#F5F5DC", highlightthickness=0, relief="flat", font=("SF Pro Text", 10), padx=10, pady=4, ) add_window = self.bg_canvas.create_window( x_label + 240, table_y - 8, window=add_btn, anchor="nw" ) self._canvas_items.append(add_window) self._overlay_widgets.append(add_btn) edit_btn = tk.Button( self.bg_canvas, text="Edit", command=self._db_edit_namespace, bg="#F5F5DC", fg="black", activebackground="#E5E5D5", highlightbackground="#F5F5DC", highlightthickness=0, relief="flat", font=("SF Pro Text", 10), padx=10, pady=4, ) edit_window = self.bg_canvas.create_window( x_label + 300, table_y - 8, window=edit_btn, anchor="nw" ) self._canvas_items.append(edit_window) self._overlay_widgets.append(edit_btn) delete_btn = tk.Button( self.bg_canvas, text="Delete", command=self._db_delete_namespace, bg="#F5F5DC", fg="black", activebackground="#E5E5D5", highlightbackground="#F5F5DC", highlightthickness=0, relief="flat", font=("SF Pro Text", 10), padx=10, pady=4, ) delete_window = self.bg_canvas.create_window( x_label + 360, table_y - 8, window=delete_btn, anchor="nw" ) self._canvas_items.append(delete_window) self._overlay_widgets.append(delete_btn) self._db_action_buttons = [refresh_btn, add_btn, edit_btn, delete_btn] table_frame = tk.Frame( self.bg_canvas, bg="white", highlightbackground="#E0E0E0", highlightthickness=1, ) table_window = self.bg_canvas.create_window( x_label, table_y + 30, window=table_frame, anchor="nw", width=900, height=180, ) self._canvas_items.append(table_window) self._overlay_widgets.append(table_frame) columns = ("select", "name", "owner", "port", "created", "status") tree = ttk.Treeview(table_frame, columns=columns, show="headings", height=5) tree.heading("select", text="Select") tree.heading("name", text="Name") tree.heading("owner", text="Owner") tree.heading("port", text="Host Port") tree.heading("created", text="Creation Date") tree.heading("status", text="Status") tree.column("select", width=60, anchor="center") tree.column("name", width=180, anchor="w") tree.column("owner", width=140, anchor="w") tree.column("port", width=80, anchor="center") tree.column("created", width=200, anchor="w") tree.column("status", width=120, anchor="center") tree.pack(side="left", fill="both", expand=True) scroll = ttk.Scrollbar(table_frame, orient="vertical", command=tree.yview) tree.configure(yscrollcommand=scroll.set) scroll.pack(side="right", fill="y") self._overlay_widgets.append(tree) self._overlay_widgets.append(scroll) self._db_namespace_tree = tree def on_select(event): if getattr(self, "_refreshing_ns_table", False): return sel = tree.selection() if sel: vals = tree.item(sel[0], "values") if vals: ns = vals[1] if ns == "supabase": # Do not allow selecting 'supabase' as the primary knoe-db namespace return if ns == self.db_namespace.get(): # Already selected, don't trigger re-refresh/save return self.db_namespace.set(ns) self._sync_namespace_suffix_from_full() # Mark as selected in tree visually if needed, but we use the checkbox column self._refresh_namespace_table() self._save_prole_cfg() if self.supabase_enabled.get(): self._db_sync_supabase_ports(ns) tree.bind("<>", on_select) self._db_namespace_note = ui.canvas_text( self, x_label, table_y + 220, "", fill="#6e6e73", font=("SF Pro Text", 10) ) self._canvas_items.append(self._db_namespace_note) def on_password_change(*args): p = self.db_password.get() c = self.db_password_confirm.get() if not p: self.bg_canvas.itemconfigure(self.password_indicator, state="hidden") elif p == c: self.bg_canvas.itemconfigure( self.password_indicator, text="✓", fill="#28a745", state="normal" ) else: self.bg_canvas.itemconfigure( self.password_indicator, text="✘", fill="#dc3545", state="normal" ) self.db_password.trace_add("write", on_password_change) self.db_password_confirm.trace_add("write", on_password_change) # Add trace to host port to update mappings immediately def on_port_change(*args): try: self._save_prole_cfg() except: pass self.db_host_port.trace_add("write", on_port_change) # Trigger once in case they are already set on_password_change() self._refresh_namespace_table() def _validate_namespace(self, proposed: str) -> bool: if not proposed: return True # Allow only valid k8s characters while typing return re.match(r"^[a-z0-9-]*$", proposed) is not None def _collect_namespace_rows( self, *, current_ns: str, supabase_enabled: bool, db_host_port: str, ): owner = self.namespace_owner or self._get_local_owner() ns_names = [] notice = "" kubectl_ok = False try: base_cmd = self._kubectl_base_cmd() result = subprocess.run( base_cmd + ["get", "ns", "-o", "json"], capture_output=True, text=True, timeout=5, ) if result.returncode == 0: kubectl_ok = True data = json.loads(result.stdout or "{}") for item in data.get("items", []): name = item.get("metadata", {}).get("name") if name: ns_names.append(name) else: notice = ( result.stderr or "" ).strip() or "kubectl returned a non-zero status." except FileNotFoundError: notice = "kubectl not found; showing local defaults." except Exception as e: notice = f"Unable to query namespaces: {e}" # Filter: names containing 'db' or 'supabase' ns_names = [ name for name in ns_names if "db" in name.lower() or name == "supabase" ] if ( current_ns and ("db" in current_ns.lower() or current_ns == "supabase") and current_ns not in ns_names ): ns_names.append(current_ns) if not ns_names: if current_ns and ( "db" in current_ns.lower() or current_ns == "supabase" ): ns_names = [current_ns] else: ns_names = [] pods_by_ns = {} if kubectl_ok: try: base_cmd = self._kubectl_base_cmd() pods_result = subprocess.run( base_cmd + ["get", "pods", "--all-namespaces", "-o", "json"], capture_output=True, text=True, timeout=8, ) if pods_result.returncode == 0: pods_data = json.loads(pods_result.stdout or "{}") for pod in pods_data.get("items", []): meta = pod.get("metadata", {}) status = pod.get("status", {}) ns = meta.get("namespace") if not ns: continue entry = pods_by_ns.setdefault( ns, {"starts": [], "running": False} ) start_time = status.get("startTime") if start_time: entry["starts"].append(start_time) if status.get("phase") == "Running": entry["running"] = True else: notice = notice or (pods_result.stderr or "").strip() or notice except Exception: # Best effort only pass rows = [] # Filter out any non-string items (like MagicMocks in tests) string_ns_names = [_safe_str(name) for name in ns_names if _safe_str(name)] for ns in sorted(set(string_ns_names)): entry = pods_by_ns.get(ns, {"starts": [], "running": False}) oldest = None if entry["starts"]: parsed = [self._parse_rfc3339(ts) for ts in entry["starts"]] parsed = [p for p in parsed if p is not None] if parsed: oldest_dt = min(parsed) oldest = oldest_dt.isoformat() else: oldest = min(entry["starts"]) creation = self._format_pod_time(oldest) if oldest else "—" status = "active" if entry["running"] else "inactive" # Best effort to find port port = "—" if ns == "supabase": port = "5432" else: # For knoe-db namespaces if ns == current_ns: if supabase_enabled: port = "15432" else: port = db_host_port or "5432" else: # If it's another knoe-db namespace, we might not know its port easily # but if Supabase is enabled globally, we assume standard alternate port if supabase_enabled: port = "15432" else: port = "5432" rows.append((ns, owner, port, creation, status)) return rows, notice def _refresh_namespace_table(self): if getattr(self, "_refreshing_ns_table", False): return self._refreshing_ns_table = True # Snapshot any Tk-backed values on the main thread. The worker thread # must never touch Tk objects. current_ns = (self.db_namespace.get() or "").strip() try: supabase_enabled = bool(int(self.supabase_enabled.get())) except Exception: supabase_enabled = bool(self.supabase_enabled.get()) db_host_port = _safe_str(self.db_host_port.get()) def worker(): try: rows, notice = self._collect_namespace_rows( current_ns=current_ns, supabase_enabled=supabase_enabled, db_host_port=db_host_port, ) def update_ui(): tree = getattr(self, "_db_namespace_tree", None) if not tree: return for item in tree.get_children(): tree.delete(item) for row in rows: # Add checkbox-like symbol for selection ns_name = row[0] prefix = " [✓] " if ns_name == current_ns else " [ ] " display_row = (prefix,) + row tree.insert("", "end", values=display_row) if current_ns: for item in tree.get_children(): vals = tree.item(item, "values") if vals and vals[1] == current_ns: tree.selection_set(item) tree.see(item) break note_item = getattr(self, "_db_namespace_note", None) if note_item and self.bg_canvas.winfo_exists(): msg = notice if notice else "" self.bg_canvas.itemconfig(note_item, text=msg) self.safe_after(update_ui) finally: self._refreshing_ns_table = False threading.Thread(target=worker, daemon=True).start() def _db_set_status(self, message: str, color: str = "#6e6e73"): note_item = getattr(self, "_db_namespace_note", None) if note_item and self.bg_canvas.winfo_exists(): self.bg_canvas.itemconfig(note_item, text=message or "", fill=color) def _db_set_buttons_state(self, state: str): buttons = getattr(self, "_db_action_buttons", None) if not buttons: return for btn in buttons: try: if btn.winfo_exists(): btn.configure(state=state) except Exception: pass def _db_selected_namespace(self) -> str: tree = getattr(self, "_db_namespace_tree", None) if not tree: return "" sel = tree.selection() if not sel: return "" vals = tree.item(sel[0], "values") if not vals: return "" ns = vals[1] if ns == "supabase": return "" return ns def _db_sync_supabase_ports(self, namespace): if not self.supabase_enabled.get(): return script = PROJECT_ROOT / "etc" / "init_supabase_ports.sh" if not script.exists(): return def worker(): try: env = os.environ.copy() env["PROLE_HOME"] = str(PROJECT_ROOT) # Best effort: use kubectl context if selected if hasattr(self, "selected_kubectx") and self.selected_kubectx.get(): env["KUBECONFIG"] = env.get( "KUBECONFIG", "" ) # Ensure it's passed if set subprocess.run( ["bash", str(script), "-n", namespace], cwd=str(PROJECT_ROOT), env=env, capture_output=True, text=True, ) except: pass threading.Thread(target=worker, daemon=True).start() def _db_action_log_path(self) -> Path: logs_dir = PROJECT_ROOT / "logs" try: logs_dir.mkdir(parents=True, exist_ok=True) except Exception: pass return logs_dir / "db-actions.log" def _db_log(self, text: str): try: with self._db_action_log_path().open("a", encoding="utf-8") as fp: fp.write(text) if not text.endswith("\n"): fp.write("\n") except Exception: pass def _db_add_namespace(self): ns = (self.db_namespace.get() or "").strip() if not ns: messagebox.showerror("Database Name", "Database namespace cannot be empty.") return if not self._is_valid_namespace(ns): messagebox.showerror( "Database Name", 'Namespace must be lowercase alphanumeric or "-", start/end with a letter or number, and be 63 characters or less.', ) return self.db_namespace.set(ns) def worker(): self.safe_after(lambda: self._db_set_buttons_state("disabled")) self.safe_after( lambda: self._db_set_status(f"Creating namespace {ns}...", "#1d1d1f") ) cmd = self._kubectl_base_cmd() + ["create", "namespace", ns] rc, out = self._run_cmd_capture(cmd) if rc != 0 and "AlreadyExists" not in out: self._db_log(out) self.safe_after(self._refresh_namespace_table) self.safe_after( lambda: self._db_set_status( f"Failed to create namespace {ns}. See logs/db-actions.log.", "#ff3b30", ) ) else: self._update_env_namespace(ns) self.safe_after(self._refresh_namespace_table) self.safe_after( lambda: self._db_set_status(f"Namespace {ns} is ready.", "#34c759") ) self.safe_after(lambda: self._db_set_buttons_state("normal")) threading.Thread(target=worker, daemon=True).start() def _db_delete_namespace(self): ns = self._db_selected_namespace() or (self.db_namespace.get() or "").strip() if not ns: messagebox.showerror( "Delete Database", "Select a database namespace to delete." ) return if not messagebox.askyesno( "Delete Database", f'Delete namespace "{ns}"? This cannot be undone.' ): return def worker(): self.safe_after(lambda: self._db_set_buttons_state("disabled")) self.safe_after( lambda: self._db_set_status(f"Deleting namespace {ns}...", "#1d1d1f") ) cmd = self._kubectl_base_cmd() + ["delete", "namespace", ns] rc, out = self._run_cmd_capture(cmd) if rc != 0: self._db_log(out) self.safe_after(self._refresh_namespace_table) self.safe_after( lambda: self._db_set_status( f"Failed to delete namespace {ns}. See logs/db-actions.log.", "#ff3b30", ) ) else: self.safe_after(self._refresh_namespace_table) self.safe_after( lambda: self._db_set_status(f"Namespace {ns} deleted.", "#34c759") ) self.safe_after(lambda: self._db_set_buttons_state("normal")) threading.Thread(target=worker, daemon=True).start() def _db_edit_namespace(self): ns = self._db_selected_namespace() or (self.db_namespace.get() or "").strip() if not ns: messagebox.showerror( "Edit Database", "Select a database namespace to edit." ) return self.db_namespace.set(ns) if not self._is_valid_namespace(ns): messagebox.showerror( "Database Name", 'Namespace must be lowercase alphanumeric or "-", start/end with a letter or number, and be 63 characters or less.', ) return p1 = self.db_password.get() p2 = self.db_password_confirm.get() if not p1: messagebox.showerror("Password", "Password cannot be empty.") return if p1 != p2: messagebox.showerror("Password", "Passwords do not match.") return def worker(): self.safe_after(lambda: self._db_set_buttons_state("disabled")) self.safe_after( lambda: self._db_set_status( f"Recreating SSH key for {ns}...", "#1d1d1f" ) ) # We prefer ed25519, but fallback to rsa if not available key_path = Path.home() / ".ssh" / "id_prole_ed25519" pub_path = Path.home() / ".ssh" / "id_prole_ed25519.pub" try: if key_path.exists(): key_path.unlink() if pub_path.exists(): pub_path.unlink() except Exception: pass cmd = [ "ssh-keygen", "-t", "ed25519", "-N", "", "-f", str(key_path), "-C", self.db_username.get().strip(), ] rc, out = self._run_cmd_capture(cmd) if rc != 0: self._db_log(f"ed25519 generation failed, falling back to rsa: {out}") cmd = [ "ssh-keygen", "-t", "rsa", "-b", "4096", "-N", "", "-f", str(key_path), "-C", self.db_username.get().strip(), ] rc, out = self._run_cmd_capture(cmd) self._db_log(out) if rc != 0: self.safe_after( lambda: self._db_set_status( "Failed to recreate SSH key. See logs/db-actions.log.", "#ff3b30", ) ) self.safe_after(lambda: self._db_set_buttons_state("normal")) return self.safe_after( lambda: self._db_set_status("Updating OpenBao...", "#1d1d1f") ) env = self._script_env_for_namespace(ns) env["AT_REST_ENCRYPTION_ENABLED"] = _bool_str( self.at_rest_encryption_enabled.get() ) mode = _deployment_mode_from_env(self.cluster_env.get()) try: openbao_ops.initialize( namespace=ns, env=env, project_root=getattr(self.controller, "project_root", PROJECT_ROOT), mode=mode, log=lambda msg: self._db_log( msg if msg.endswith("\n") else msg + "\n" ), ) rc2 = 0 except Exception as _bao_exc: rc2 = 1 self._db_log(f"OpenBao update failed: {_bao_exc}\n") if rc2 != 0: self.safe_after(self._refresh_namespace_table) self.safe_after( lambda: self._db_set_status( "OpenBao update failed. See logs/db-actions.log.", "#ff3b30" ) ) else: self._update_env_namespace(ns) self.safe_after(self._refresh_namespace_table) self.safe_after( lambda: self._db_set_status( f"Updated SSH key and OpenBao for {ns}.", "#34c759" ) ) self.safe_after(lambda: self._db_set_buttons_state("normal")) threading.Thread(target=worker, daemon=True).start() def _render_init_db_build_page(self): # Letterhead at top right content_width = self.bg_canvas.winfo_width() or 975 right_margin = content_width - 48 ui.canvas_text( self, right_margin, 40, "Prole", fill="#6e6e73", font=("SF Pro Text", 32, "bold"), anchor="ne", ) ui.canvas_text( self, right_margin, 85, "Infrastructure Automated.", fill="#6e6e73", font=("SF Pro Text", 18), anchor="ne", ) self._render_title("Build Database Image", y=150) self._render_paragraph( "Building the knoe-db Postgres image. This may take a few minutes.", y=200 ) # Registry status (checked async) self._db_registry_status_label = ui.canvas_text( self, 48, 230, "Registry: Checking...", fill="#6e6e73", font=("SF Pro Text", 11), ) self._canvas_items.append(self._db_registry_status_label) # k3s registry initialization (shown only when needed) self._db_init_registry_button = tk.Button( self.bg_canvas, text="Initialize Registry", command=self._db_init_registry, bg="#F5F5DC", fg="black", activebackground="#E5E5D5", highlightbackground="#F5F5DC", highlightthickness=0, relief="flat", font=("SF Pro Text", 11), padx=16, pady=6, ) init_btn_window = self.bg_canvas.create_window( 48, 224, window=self._db_init_registry_button, anchor="nw", width=200 ) self._db_init_registry_button_canvas_window = init_btn_window self._canvas_items.append(init_btn_window) self._overlay_widgets.append(self._db_init_registry_button) try: self.bg_canvas.itemconfigure(init_btn_window, state="hidden") except Exception: pass # Output Console self._db_build_console = self._create_console_output( y=260, title="Build Output", width=900, height=520 ) # Use tk.Button self._db_build_button = tk.Button( self.bg_canvas, text="Start Build", command=self.run_db_build, bg="#F5F5DC", fg="black", activebackground="#E5E5D5", highlightbackground="#F5F5DC", highlightthickness=0, relief="flat", font=("SF Pro Text", 11), padx=16, pady=8, ) btn_window = self.bg_canvas.create_window( 48, 800, window=self._db_build_button, anchor="nw", width=180 ) self._canvas_items.append(btn_window) self._overlay_widgets.append(self._db_build_button) # Status Label self._db_build_status_label = ui.canvas_text( self, 240, 812, "", fill="black", font=("SF Pro Text", 12) ) self._canvas_items.append(self._db_build_status_label) # Ensure registry check runs when entering the screen self._ensure_db_build_registry_async() def _ensure_db_build_registry_async(self): def worker(): try: env_key = "dev" try: env_key = self._cluster_env_key() except Exception: env_key = "dev" # If the user selected Service, treat it as k3s even when Global/DEPLOYMENT_MODE remains k3d. mode = _deployment_mode_from_env( ((self.prole_cfg_data.get("Global", {}) or {}).get("DEPLOYMENT_MODE") or "").strip() or env_key ) def _show_init_button(show: bool): try: if not hasattr(self, "_db_init_registry_button_canvas_window"): return state = "normal" if show else "hidden" self.bg_canvas.itemconfigure( self._db_init_registry_button_canvas_window, state=state ) except Exception: return # k3s: never warn about localhost registry. Instead offer init + show reachable status. if mode == "k3s": registry_url = "" try: registry_url = (self.ensure_registry_available(env_key) or "").strip() except Exception: registry_url = "" def _is_unusable_hostport(value: str) -> bool: raw = (value or "").strip() if not raw or ":" not in raw: return True host, _port = raw.rsplit(":", 1) host = (host or "").strip() # Bind addresses are not usable endpoints and often display as confusing "000". if host in ("0.0.0.0", "::", "127.0.0.1", "localhost"): return True return False usable_registry_url = ( "" if _is_unusable_hostport(registry_url) else registry_url ) registry_ns = "knoe-system" try: registry_ns = (self._registry_namespace() or registry_ns).strip() except Exception: registry_ns = "knoe-system" cluster_registry = f"registry.{registry_ns}.svc.cluster.local:5000" deployed_ready = False try: base_cmd = self._kubectl_base_cmd() result = subprocess.run( base_cmd + [ "get", "deploy", "registry", "-n", registry_ns, "-o", "json", ], capture_output=True, text=True, timeout=5, ) if result.returncode == 0: data = json.loads(result.stdout or "{}") status = data.get("status", {}) or {} ready = int(status.get("readyReplicas") or 0) available = int(status.get("availableReplicas") or 0) deployed_ready = ready > 0 or available > 0 except Exception: deployed_ready = False reachable = False if usable_registry_url and ":" in usable_registry_url: host, port_s = usable_registry_url.rsplit(":", 1) try: reachable = _http_ping_registry( host.strip(), int(port_s.strip()) ) except Exception: reachable = False # Prefer Kubernetes readiness for the initialization signal in k3s. if deployed_ready: if usable_registry_url and reachable: msg = f"Registry: {usable_registry_url}" color = "#34c759" elif usable_registry_url: msg = f"Registry: {usable_registry_url} (deployed)" color = "#ff9500" else: msg = f"Registry: {cluster_registry} (deployed)" color = "#ff9500" self.safe_after( lambda: ( _show_init_button(False), self.bg_canvas.itemconfig( self._db_registry_status_label, text=msg, fill=color, ), ) ) return # Not deployed -> prompt init action msg = ( f"Registry: {usable_registry_url} (not initialized)" if usable_registry_url else "Registry: not initialized" ) self.safe_after( lambda: ( _show_init_button(True), self.bg_canvas.itemconfig( self._db_registry_status_label, text=msg, fill="#ff9500", ), ) ) return # Non-k3s: keep local registry checks (requires Docker) if not self.check_docker_running(): self.safe_after( lambda: ( _show_init_button(False), self.bg_canvas.itemconfig( self._db_registry_status_label, text="Registry: Docker not running", fill="#ff3b30", ), ) ) return info = self.ensure_local_registry_available() if info: host_registry, _cluster_registry = info self.safe_after( lambda: ( _show_init_button(False), self.bg_canvas.itemconfig( self._db_registry_status_label, text=f"Registry: {host_registry}", fill="#34c759", ), ) ) else: self.safe_after( lambda: ( _show_init_button(False), self.bg_canvas.itemconfig( self._db_registry_status_label, text="Registry: unavailable", fill="#ff3b30", ), ) ) log_path = getattr(self, "_last_registry_log_path", None) if log_path and self._db_build_console: self.safe_after( lambda p=log_path: self._db_build_console.write( f"Registry log: {p}\n" ) ) except Exception as e: msg = f"Registry: error ({e})" self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_registry_status_label, text=msg, fill="#ff3b30" ) if self.bg_canvas.winfo_exists() else None ) ) log_path = getattr(self, "_last_registry_log_path", None) if log_path and self._db_build_console: self.safe_after( lambda p=log_path: self._db_build_console.write( f"Registry log: {p}\n" ) ) threading.Thread(target=worker, daemon=True).start() def _db_rescan_registry_status_after_init(self): """Re-scan registry availability after init. Registry pods/services may take a few seconds to become reachable after `etc/init_registry.sh` finishes. Schedule a few checks so the UI status flips to green once ready. """ try: if getattr(self, "_db_registry_status_label", None) is not None: self.safe_after( lambda: self.bg_canvas.itemconfig( self._db_registry_status_label, text="Registry: Checking...", fill="#6e6e73", ) ) except Exception: pass # Progressive delays to allow the in-cluster registry to become ready. for d in (0, 1000, 2000, 4000, 8000, 15000): self.safe_after(lambda: self._ensure_db_build_registry_async(), delay=d) def _db_init_registry(self): """Initialize the k3s in-cluster registry (registry:2) via etc/init_registry.sh.""" def _resolve_argocd_namespace() -> str: ns = ( (self.prole_cfg_data.get("Global", {}) or {}) .get("ARGOCD_NAMESPACE", "") .strip() ) if not ns: ns = (os.environ.get("ARGOCD_NAMESPACE") or "").strip() return ns or "argocd" def _resolve_service_namespace_interactive() -> str: # Prefer explicit UI value if available ns = "" try: ns = (self.service_namespace.get() or "").strip() except Exception: ns = "" if not ns: ns = ( (self.prole_cfg_data.get("Global", {}) or {}) .get("SERVICE_NAMESPACE", "") .strip() ) if not ns: ns = (os.environ.get("SERVICE_NAMESPACE") or "").strip() if ns: return ns # UI is interactive: ask the user. try: ns2 = simpledialog.askstring( "Service Namespace", "Enter the service namespace for the k3s registry:", parent=self.root, ) except Exception: ns2 = None return (ns2 or "").strip() def worker(): env_key = "service" try: env_key = self._cluster_env_key() except Exception: env_key = "service" mode = _deployment_mode_from_env(env_key) if mode != "k3s": try: messagebox.showinfo( "Registry", "Registry initialization is only required for k3s (Service) mode.", ) except Exception: pass return service_ns = _resolve_service_namespace_interactive() if not service_ns: # In UI mode we must not guess; prompt is available above. # Only fall back to Kubernetes 'default' when no input is available. try: if getattr(self, "root", None) is not None: self.safe_after( lambda: messagebox.showerror( "Registry", "Service namespace is required to initialize the registry.", ) ) return except Exception: pass service_ns = "default" argocd_ns = _resolve_argocd_namespace() self.safe_after( lambda: ( self._db_init_registry_button.configure(state="disabled") if self._db_init_registry_button.winfo_exists() else None ) ) if self._db_build_console: self.safe_after( lambda: self._db_build_console.write( f"Running registry init in namespace {service_ns} (mode=k3s)\n\n" ) ) try: env_run = os.environ.copy() env_run["PROLE_MODE"] = "k3s" env_run["REGISTRY_NAMESPACE"] = service_ns env_run["ARGOCD_NAMESPACE"] = argocd_ns registry_ops.update( namespace=service_ns, env=env_run, project_root=getattr(self.controller, "project_root", PROJECT_ROOT), mode="k3s", log=lambda msg: self._db_build_console.write( msg if msg.endswith("\n") else msg + "\n" ) if self._db_build_console else None, ) rc = 0 except Exception as e: rc = 1 if self._db_build_console: self._db_build_console.write(f"Registry init failed: {e}\n") if self._db_build_console: self._db_build_console.write( f"\nRegistry init {'completed' if rc == 0 else 'failed'} (exit {rc}).\n" ) self.safe_after( lambda: ( self._db_init_registry_button.configure(state="normal") if self._db_init_registry_button.winfo_exists() else None ) ) if rc == 0: self._db_rescan_registry_status_after_init() else: self._ensure_db_build_registry_async() threading.Thread(target=worker, daemon=True).start() def run_db_build(self): self._action_flags["init_db_build.run_build"] = True def worker(): self.safe_after( lambda: ( self._db_build_button.configure(state="disabled") if self._db_build_button.winfo_exists() else None ) ) self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Building...", fill="blue" ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) tag = self.get_knoe_db_version() image_name = f"knoe-db:{tag}" # Use $PROLE_HOME/build for Docker build context # This avoids issues with PyInstaller's temporary _MEIPASS directory prole_home = resolve_prole_home() env_key = self._cluster_env_key() mode_key = _deployment_mode_from_env(env_key) or "default" build_dir = prole_home / "build" / mode_key / "knoe-db" build_dir.mkdir(parents=True, exist_ok=True) # Copy DB image build directory to writable location, unless a generated # build context was already prepared by the Database Options screen. marker = build_dir / ".prole_build_context_ready" if not marker.exists(): source_dir = get_resource_path("knoe-db") if not source_dir.exists(): source_dir = get_resource_path("knoe-db") copy_build_context_dir(source_dir, build_dir) cwd = build_dir # Fetch the generated public key pub_key = "" pub_key_path = Path.home() / ".ssh" / "id_prole_ed25519.pub" if pub_key_path.exists(): pub_key = pub_key_path.read_text().strip() username = self.db_username.get() cmd = ["docker", "build", "--progress=plain"] cmd.extend(get_docker_build_platform_args(env_key)) cmd += [ "--build-arg", f"PROLE_USER={username}", "--build-arg", f"PROLE_SSH_PUB_KEY={pub_key}", "-t", image_name, ".", ] self._db_build_console.clear() self._db_build_console.write(f"Building {image_name} in {cwd}...\n\n") build_env = os.environ.copy() build_env["PYTHONUNBUFFERED"] = "1" proc = subprocess.Popen( cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, env=build_env, ) while True: line = proc.stdout.readline() if not line and proc.poll() is not None: break if line: self._db_build_console.write(line) if proc.returncode == 0: self._db_build_console.write("\nBuild successful!\n") self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build successful! Tagging...", fill="#34c759", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) self._db_built_success = True if env_key == "dev": # Tag + push to local registry for k3d pulls registry_info = self.ensure_local_registry_available() import_tag = image_name if registry_info: host_registry, cluster_registry = registry_info remote_tag = f"{host_registry}/knoe-db:{tag}" self._db_build_console.write( f"Tagging image for registry: {remote_tag}\n" ) tag_res = subprocess.run( ["docker", "tag", image_name, remote_tag], capture_output=True, text=True, ) if tag_res.returncode != 0: self._db_build_console.write(tag_res.stdout or "") self._db_build_console.write(tag_res.stderr or "") self._db_build_console.write( "Tag failed; skipping push/import.\n" ) self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build ok, tag failed.", fill="#ff3b30", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) self.safe_after( lambda: ( self._db_build_button.configure(state="normal") if self._db_build_button.winfo_exists() else None ) ) return self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Pushing to registry...", fill="#34c759", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) if not _push_docker_image( remote_tag, log_fn=self._db_build_console.write ): self._db_build_console.write( "Push failed; skipping import.\n" ) self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build ok, push failed.", fill="#ff3b30", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) self.safe_after( lambda: ( self._db_build_button.configure(state="normal") if self._db_build_button.winfo_exists() else None ) ) return self._db_build_console.write(f"Push complete: {remote_tag}\n") if cluster_registry: import_tag = f"{cluster_registry}/knoe-db:{tag}" # k3d registry is often reachable internally without the .localhost suffix if cluster_registry.endswith(".localhost:5000"): alt_registry = cluster_registry.replace( ".localhost", "" ) alt_tag = f"{alt_registry}/knoe-db:{tag}" if alt_tag != import_tag: self._db_build_console.write( f"Tagging image for k3d import: {alt_tag}\n" ) subprocess.run( ["docker", "tag", image_name, alt_tag], capture_output=True, text=True, ) import_tag = alt_tag else: self._db_build_console.write( "Local registry unavailable; skipping tag/push.\n" ) # Import to k3d cluster_name = "knoe-dev-cluster" self._db_build_console.write( f"Importing image to {cluster_name} ({import_tag})...\n" ) subprocess.run( ["k3d", "image", "import", import_tag, "-c", cluster_name] ) self._db_build_console.write("Import complete.\n") self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build, tag, push, and import complete.", fill="#34c759", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) else: # Service/prod clusters must pull from a registry; do not skip push. registry_url = "" try: registry_url = (self.ensure_registry_available(env_key) or "").strip() except Exception: registry_url = "" if not registry_url: self._db_build_console.write( "No registry configured/resolved for this environment. Initialize the registry first.\n" ) self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build ok, registry not configured.", fill="#ff3b30", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) return remote_tag = f"{registry_url}/knoe-db:{tag}" self._db_build_console.write( f"Tagging image for registry: {remote_tag}\n" ) tag_res = subprocess.run( ["docker", "tag", image_name, remote_tag], capture_output=True, text=True, ) if tag_res.returncode != 0: self._db_build_console.write(tag_res.stdout or "") self._db_build_console.write(tag_res.stderr or "") self._db_build_console.write("Tag failed; cannot push.\n") self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build ok, tag failed.", fill="#ff3b30", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) return self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Pushing to registry...", fill="#34c759", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) if not _push_docker_image( remote_tag, log_fn=self._db_build_console.write ): self._db_build_console.write( "Push failed. Ensure the registry is initialized and reachable.\n" ) self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build ok, push failed.", fill="#ff3b30", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) return self._db_build_console.write(f"Push complete: {remote_tag}\n") self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build, tag and push complete.", fill="#34c759", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) else: self._db_build_console.write( f"\nBuild failed with code {proc.returncode}\n" ) self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text=f"Build failed (code {proc.returncode})", fill="#ff3b30", ) if self.bg_canvas.winfo_exists() and self._db_build_status_label in self.bg_canvas.find_all() else None ) ) self.safe_after( lambda: ( self._db_build_button.configure(state="normal") if self._db_build_button.winfo_exists() else None ) ) threading.Thread(target=worker, daemon=True).start()