mirror of
https://github.com/DeBrosOfficial/orama.git
synced 2026-03-17 12:46:57 +00:00
268 lines
7.3 KiB
Go
268 lines
7.3 KiB
Go
package cli
|
|
|
|
import (
|
|
"bufio"
|
|
"crypto/tls"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/DeBrosOfficial/network/pkg/auth"
|
|
"github.com/DeBrosOfficial/network/pkg/constants"
|
|
)
|
|
|
|
// HandleNamespaceCommand handles namespace management commands
|
|
func HandleNamespaceCommand(args []string) {
|
|
if len(args) == 0 {
|
|
showNamespaceHelp()
|
|
return
|
|
}
|
|
|
|
subcommand := args[0]
|
|
switch subcommand {
|
|
case "delete":
|
|
var force bool
|
|
fs := flag.NewFlagSet("namespace delete", flag.ExitOnError)
|
|
fs.BoolVar(&force, "force", false, "Skip confirmation prompt")
|
|
_ = fs.Parse(args[1:])
|
|
handleNamespaceDelete(force)
|
|
case "list":
|
|
handleNamespaceList()
|
|
case "repair":
|
|
if len(args) < 2 {
|
|
fmt.Fprintf(os.Stderr, "Usage: orama namespace repair <namespace_name>\n")
|
|
os.Exit(1)
|
|
}
|
|
handleNamespaceRepair(args[1])
|
|
case "help":
|
|
showNamespaceHelp()
|
|
default:
|
|
fmt.Fprintf(os.Stderr, "Unknown namespace command: %s\n", subcommand)
|
|
showNamespaceHelp()
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func showNamespaceHelp() {
|
|
fmt.Printf("Namespace Management Commands\n\n")
|
|
fmt.Printf("Usage: orama namespace <subcommand>\n\n")
|
|
fmt.Printf("Subcommands:\n")
|
|
fmt.Printf(" list - List namespaces owned by the current wallet\n")
|
|
fmt.Printf(" delete - Delete the current namespace and all its resources\n")
|
|
fmt.Printf(" repair <namespace> - Repair an under-provisioned namespace cluster (add missing nodes)\n")
|
|
fmt.Printf(" help - Show this help message\n\n")
|
|
fmt.Printf("Flags:\n")
|
|
fmt.Printf(" --force - Skip confirmation prompt (delete only)\n\n")
|
|
fmt.Printf("Examples:\n")
|
|
fmt.Printf(" orama namespace list\n")
|
|
fmt.Printf(" orama namespace delete\n")
|
|
fmt.Printf(" orama namespace delete --force\n")
|
|
fmt.Printf(" orama namespace repair anchat\n")
|
|
}
|
|
|
|
func handleNamespaceRepair(namespaceName string) {
|
|
fmt.Printf("Repairing namespace cluster '%s'...\n", namespaceName)
|
|
|
|
// Call the internal repair endpoint on the local gateway
|
|
url := fmt.Sprintf("http://localhost:%d/v1/internal/namespace/repair?namespace=%s", constants.GatewayAPIPort, namespaceName)
|
|
req, err := http.NewRequest(http.MethodPost, url, nil)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to create request: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
req.Header.Set("X-Orama-Internal-Auth", "namespace-coordination")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to connect to local gateway (is the node running?): %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
errMsg := "unknown error"
|
|
if e, ok := result["error"].(string); ok {
|
|
errMsg = e
|
|
}
|
|
fmt.Fprintf(os.Stderr, "Repair failed: %s\n", errMsg)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Printf("Namespace '%s' cluster repaired successfully.\n", namespaceName)
|
|
if msg, ok := result["message"].(string); ok {
|
|
fmt.Printf(" %s\n", msg)
|
|
}
|
|
}
|
|
|
|
func handleNamespaceDelete(force bool) {
|
|
// Load credentials
|
|
store, err := auth.LoadEnhancedCredentials()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to load credentials: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
gatewayURL := getGatewayURL()
|
|
creds := store.GetDefaultCredential(gatewayURL)
|
|
|
|
if creds == nil || !creds.IsValid() {
|
|
fmt.Fprintf(os.Stderr, "Not authenticated. Run 'orama auth login' first.\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
namespace := creds.Namespace
|
|
if namespace == "" || namespace == "default" {
|
|
fmt.Fprintf(os.Stderr, "Cannot delete default namespace.\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Confirm deletion
|
|
if !force {
|
|
fmt.Printf("This will permanently delete namespace '%s' and all its resources:\n", namespace)
|
|
fmt.Printf(" - All deployments and their processes\n")
|
|
fmt.Printf(" - RQLite cluster (3 nodes)\n")
|
|
fmt.Printf(" - Olric cache cluster (3 nodes)\n")
|
|
fmt.Printf(" - Gateway instances\n")
|
|
fmt.Printf(" - API keys and credentials\n")
|
|
fmt.Printf(" - IPFS content and DNS records\n\n")
|
|
fmt.Printf("Type the namespace name to confirm: ")
|
|
|
|
scanner := bufio.NewScanner(os.Stdin)
|
|
scanner.Scan()
|
|
input := strings.TrimSpace(scanner.Text())
|
|
|
|
if input != namespace {
|
|
fmt.Println("Aborted - namespace name did not match.")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
fmt.Printf("Deleting namespace '%s'...\n", namespace)
|
|
|
|
// Make DELETE request to gateway
|
|
url := fmt.Sprintf("%s/v1/namespace/delete", gatewayURL)
|
|
req, err := http.NewRequest(http.MethodDelete, url, nil)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to create request: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
req.Header.Set("Authorization", "Bearer "+creds.APIKey)
|
|
|
|
client := &http.Client{
|
|
Transport: &http.Transport{
|
|
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
|
},
|
|
}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to connect to gateway: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
errMsg := "unknown error"
|
|
if e, ok := result["error"].(string); ok {
|
|
errMsg = e
|
|
}
|
|
fmt.Fprintf(os.Stderr, "Failed to delete namespace: %s\n", errMsg)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Printf("Namespace '%s' deleted successfully.\n", namespace)
|
|
|
|
// Clean up local credentials for the deleted namespace
|
|
if store.RemoveCredentialByNamespace(gatewayURL, namespace) {
|
|
if err := store.Save(); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to clean up local credentials: %v\n", err)
|
|
} else {
|
|
fmt.Printf("Local credentials for '%s' cleared.\n", namespace)
|
|
}
|
|
}
|
|
|
|
fmt.Printf("Run 'orama auth login' to create a new namespace.\n")
|
|
}
|
|
|
|
func handleNamespaceList() {
|
|
// Load credentials
|
|
store, err := auth.LoadEnhancedCredentials()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to load credentials: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
gatewayURL := getGatewayURL()
|
|
creds := store.GetDefaultCredential(gatewayURL)
|
|
|
|
if creds == nil || !creds.IsValid() {
|
|
fmt.Fprintf(os.Stderr, "Not authenticated. Run 'orama auth login' first.\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Make GET request to namespace list endpoint
|
|
url := fmt.Sprintf("%s/v1/namespace/list", gatewayURL)
|
|
req, err := http.NewRequest(http.MethodGet, url, nil)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to create request: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
req.Header.Set("Authorization", "Bearer "+creds.APIKey)
|
|
|
|
client := &http.Client{
|
|
Transport: &http.Transport{
|
|
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
|
},
|
|
}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Failed to connect to gateway: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
errMsg := "unknown error"
|
|
if e, ok := result["error"].(string); ok {
|
|
errMsg = e
|
|
}
|
|
fmt.Fprintf(os.Stderr, "Failed to list namespaces: %s\n", errMsg)
|
|
os.Exit(1)
|
|
}
|
|
|
|
namespaces, _ := result["namespaces"].([]interface{})
|
|
if len(namespaces) == 0 {
|
|
fmt.Println("No namespaces found.")
|
|
return
|
|
}
|
|
|
|
activeNS := creds.Namespace
|
|
|
|
fmt.Printf("Namespaces (%d):\n\n", len(namespaces))
|
|
for _, ns := range namespaces {
|
|
nsMap, _ := ns.(map[string]interface{})
|
|
name, _ := nsMap["name"].(string)
|
|
status, _ := nsMap["cluster_status"].(string)
|
|
|
|
marker := " "
|
|
if name == activeNS {
|
|
marker = "* "
|
|
}
|
|
|
|
fmt.Printf("%s%-20s cluster: %s\n", marker, name, status)
|
|
}
|
|
fmt.Printf("\n* = active namespace\n")
|
|
}
|