"""Database creation, namespace management and DB build screens.""" import json import os import re import shutil import subprocess import threading from pathlib import Path import tkinter as tk from tkinter import ttk, messagebox, filedialog from installer import screen as ui from installer.config import get_docker_build_platform_args from installer.core.env import ( NAMESPACE_PREFIX, POSTGRES_DB_NAME_MAX_LEN, PROJECT_ROOT, _bool_str, _deployment_mode_from_env, _safe_str, _push_docker_image, get_resource_path, ) 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( "Create a database namespace for this deployment. The namespace is treated as a single database with a name and one root password. 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) name self._canvas_items.append( ui.canvas_text( self, x_label, y, "Database Name (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) prefix_label = tk.Label( ns_frame, text=self._namespace_prefix(), fg="#9a9aa0", bg="white", font=("SF Pro Text", 11), ) vcmd = (self.root.register(self._validate_namespace_suffix), "%P") suffix_entry = tk.Entry( ns_frame, textvariable=self.db_namespace_suffix, bg="white", fg="black", insertbackground="black", highlightthickness=0, relief="flat", font=("SF Pro Text", 11), validate="key", validatecommand=vcmd, ) prefix_label.pack(side="left", padx=(8, 2)) suffix_entry.pack(side="left", fill="both", expand=True, padx=(0, 8)) 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(prefix_label) self._overlay_widgets.append(suffix_entry) y += 42 # Owner (local user) 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 prole-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 _namespace_prefix(self) -> str: return NAMESPACE_PREFIX def _max_namespace_suffix_len(self) -> int: return max(0, POSTGRES_DB_NAME_MAX_LEN - len(self._namespace_prefix())) def _strip_namespace_prefix(self, name: str) -> str: prefix = self._namespace_prefix() if name.startswith(prefix): return name[len(prefix) :] return name def _ensure_namespace_prefix(self, name: str) -> str: cleaned = (name or "").strip() prefix = self._namespace_prefix() if not cleaned: return prefix if cleaned.startswith(prefix): return cleaned return f"{prefix}{cleaned}" def _sync_namespace_suffix_from_full(self): if self._updating_namespace_fields: return self._updating_namespace_fields = True try: full = (self.db_namespace.get() or "").strip() full = self._ensure_namespace_prefix(full) if full != self.db_namespace.get(): self.db_namespace.set(full) self.db_namespace_suffix.set(self._strip_namespace_prefix(full)) finally: self._updating_namespace_fields = False def _sync_namespace_full_from_suffix(self): if self._updating_namespace_fields: return self._updating_namespace_fields = True try: suffix = (self.db_namespace_suffix.get() or "").strip() self.db_namespace.set(f"{self._namespace_prefix()}{suffix}") finally: self._updating_namespace_fields = False def _validate_namespace_suffix(self, proposed: str) -> bool: return len(proposed) <= self._max_namespace_suffix_len() def _collect_namespace_rows(self): 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}" current_ns = (self.db_namespace.get() or "").strip() prefix = self._namespace_prefix() ns_names = [ name for name in ns_names if name.startswith(prefix) or name == "supabase" ] if ( current_ns and (current_ns.startswith(prefix) or current_ns == "supabase") and current_ns not in ns_names ): ns_names.append(current_ns) if not ns_names: if current_ns and ( current_ns.startswith(prefix) 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 prole-db namespaces if ns == (self.db_namespace.get() or "").strip(): if self.supabase_enabled.get(): port = "15432" else: port = self.db_host_port.get() or "5432" else: # If it's another prole-db namespace, we might not know its port easily # but if Supabase is enabled globally, we assume standard alternate port if self.supabase_enabled.get(): 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 def worker(): try: rows, notice = self._collect_namespace_rows() current_ns = (self.db_namespace.get() or "").strip() 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() ) script_path = str(PROJECT_ROOT / "etc" / "init_openbao.sh") mode = _deployment_mode_from_env(self.cluster_env.get()) rc2, out2 = self._run_cmd_capture( [ "bash", script_path, "initialize", "--mode", mode, "--namespace", ns, "--config", str(self.controller.cfg_path), ], env=env, stdin_text=f"{p1}\n", ) self._db_log(out2) 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 prole-db Postgres image. This may take a few minutes.", y=200 ) # Local registry status (checked async) self._db_registry_status_label = ui.canvas_text( self, 48, 230, "Local Registry: Checking...", fill="#6e6e73", font=("SF Pro Text", 11), ) self._canvas_items.append(self._db_registry_status_label) # 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: if not self.check_docker_running(): self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_registry_status_label, text="Local Registry: Docker not running", fill="#ff3b30", ) if self.bg_canvas.winfo_exists() else None ) ) return info = self.ensure_local_registry_available() if info: host_registry, _cluster_registry = info self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_registry_status_label, text=f"Local Registry: {host_registry}", fill="#34c759", ) if self.bg_canvas.winfo_exists() else None ) ) else: self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_registry_status_label, text="Local Registry: unavailable", 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" ) ) except Exception as e: msg = f"Local 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 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_prole_db_version() image_name = f"prole-db:{tag}" # Use $HOME/.prole/build for Docker build context # This avoids issues with PyInstaller's temporary _MEIPASS directory prole_home = Path.home() / ".prole" build_dir = prole_home / "build" / "prole-db" build_dir.mkdir(parents=True, exist_ok=True) # Copy prole-db directory to writable location source_dir = get_resource_path("prole-db") if source_dir.exists(): import shutil # Remove old build dir and copy fresh if source_dir.resolve() != build_dir.resolve(): if build_dir.exists(): shutil.rmtree(build_dir) shutil.copytree(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() env_key = self._cluster_env_key() 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}/prole-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}/prole-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}/prole-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: self._db_build_console.write( "Import skipped for non-dev clusters.\n" ) self.safe_after( lambda: ( self.bg_canvas.itemconfig( self._db_build_status_label, text="Build complete. Import skipped.", 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()