981 lines
34 KiB
Plaintext
981 lines
34 KiB
Plaintext
|
#!/usr/bin/env nu
|
||
|
|
|
||
|
|
# Enhanced Module Loader CLI
|
||
|
|
# Unified CLI for discovering and loading taskservs, providers, and clusters
|
||
|
|
# Includes template and layer support from enhanced version
|
||
|
|
|
||
|
|
use ../nulib/taskservs/discover.nu *
|
||
|
|
use ../nulib/taskservs/load.nu *
|
||
|
|
use ../nulib/providers/discover.nu *
|
||
|
|
use ../nulib/providers/load.nu *
|
||
|
|
use ../nulib/clusters/discover.nu *
|
||
|
|
use ../nulib/clusters/load.nu *
|
||
|
|
use ../nulib/lib_provisioning/kcl_module_loader.nu *
|
||
|
|
use ../nulib/lib_provisioning/config/accessor.nu config-get
|
||
|
|
|
||
|
|
# Main module loader command with enhanced features
|
||
|
|
def main [subcommand?: string] {
|
||
|
|
if ($subcommand | is-empty) {
|
||
|
|
print_enhanced_help
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
match $subcommand {
|
||
|
|
"help" => print_enhanced_help
|
||
|
|
"discover" => print_discover_help
|
||
|
|
"load" => print_load_help
|
||
|
|
"list" => print_list_help
|
||
|
|
"unload" => print_unload_help
|
||
|
|
"init" => print_init_help
|
||
|
|
"validate" => print_validate_help
|
||
|
|
"info" => print_info_help
|
||
|
|
"template" => print_template_help
|
||
|
|
"layer" => print_layer_help
|
||
|
|
"override" => print_override_help
|
||
|
|
_ => {
|
||
|
|
print $"Unknown command: ($subcommand)"
|
||
|
|
print_enhanced_help
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# === DISCOVERY COMMANDS ===
|
||
|
|
|
||
|
|
# Discover available modules
|
||
|
|
export def "main discover" [
|
||
|
|
type: string, # Module type: taskservs, providers, clusters
|
||
|
|
query?: string, # Search query
|
||
|
|
--format: string = "table", # Output format: table, yaml, json, names
|
||
|
|
--category: string = "", # Filter by category (for taskservs)
|
||
|
|
--group: string = "" # Filter by group (for taskservs)
|
||
|
|
] {
|
||
|
|
match $type {
|
||
|
|
"taskservs" => {
|
||
|
|
let taskservs = if ($query | is-empty) {
|
||
|
|
discover-taskservs
|
||
|
|
} else {
|
||
|
|
search-taskservs $query
|
||
|
|
}
|
||
|
|
|
||
|
|
let filtered = if ($category | is-empty) and ($group | is-empty) {
|
||
|
|
$taskservs
|
||
|
|
} else if not ($category | is-empty) {
|
||
|
|
$taskservs | where group == $category
|
||
|
|
} else if not ($group | is-empty) {
|
||
|
|
$taskservs | where group == $group
|
||
|
|
} else {
|
||
|
|
$taskservs
|
||
|
|
}
|
||
|
|
|
||
|
|
format_output $filtered $format
|
||
|
|
}
|
||
|
|
"providers" => {
|
||
|
|
print "Provider discovery not implemented yet"
|
||
|
|
}
|
||
|
|
"clusters" => {
|
||
|
|
print "Cluster discovery not implemented yet"
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
print $"Unknown module type: ($type)"
|
||
|
|
print "Available types: taskservs, providers, clusters"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Sync KCL dependencies for infrastructure workspace
|
||
|
|
export def "main sync-kcl" [
|
||
|
|
infra: string, # Infrastructure name or path
|
||
|
|
--manifest: string = "providers.manifest.yaml", # Manifest file name
|
||
|
|
--kcl # Show KCL module info after sync
|
||
|
|
] {
|
||
|
|
# Resolve infrastructure path
|
||
|
|
let infra_path = if ($infra | path exists) {
|
||
|
|
$infra
|
||
|
|
} else {
|
||
|
|
# Try workspace path
|
||
|
|
let workspace_path = $"workspace/infra/($infra)"
|
||
|
|
if ($workspace_path | path exists) {
|
||
|
|
$workspace_path
|
||
|
|
} else {
|
||
|
|
print $"❌ Infrastructure not found: ($infra)"
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Sync KCL dependencies using library function
|
||
|
|
sync-kcl-dependencies $infra_path --manifest $manifest
|
||
|
|
|
||
|
|
# Show KCL module info if requested
|
||
|
|
if $kcl {
|
||
|
|
print ""
|
||
|
|
print "📋 KCL Modules:"
|
||
|
|
let modules_dir = (get-config-value "kcl" "modules_dir")
|
||
|
|
let modules_path = ($infra_path | path join $modules_dir)
|
||
|
|
|
||
|
|
if ($modules_path | path exists) {
|
||
|
|
ls $modules_path | each {|entry|
|
||
|
|
print $" • ($entry.name | path basename) → ($entry.name)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# === LOAD/UNLOAD COMMANDS ===
|
||
|
|
|
||
|
|
# Load modules into workspace
|
||
|
|
export def "main load" [
|
||
|
|
type: string, # Module type: taskservs, providers, clusters
|
||
|
|
workspace: string, # Workspace path
|
||
|
|
...modules: string, # Module names to load
|
||
|
|
--layer: string = "workspace", # Layer to load into: workspace, infra
|
||
|
|
--validate # Validate after loading
|
||
|
|
--force (-f) # Force overwrite existing files
|
||
|
|
] {
|
||
|
|
if ($modules | is-empty) {
|
||
|
|
print $"No modules specified for loading"
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
print $"Loading ($modules | length) ($type) into ($workspace) at layer ($layer)"
|
||
|
|
|
||
|
|
match $type {
|
||
|
|
"taskservs" | "providers" | "clusters" | "workflows" => {
|
||
|
|
load_extension_to_workspace $type $workspace $modules $layer $force
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
print $"Unknown module type: ($type)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if $validate {
|
||
|
|
main validate $workspace
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Enhanced load with template support
|
||
|
|
export def "main load enhanced" [
|
||
|
|
type: string, # Module type
|
||
|
|
workspace: string, # Workspace path
|
||
|
|
infra: string, # Infrastructure name
|
||
|
|
modules: list<string>, # Module names
|
||
|
|
--layer: string = "workspace", # Target layer
|
||
|
|
--template-base # Use template as base
|
||
|
|
] {
|
||
|
|
print $"🚀 Enhanced loading ($modules | length) ($type) for infra ($infra)"
|
||
|
|
|
||
|
|
for module in $modules {
|
||
|
|
print $" 📦 Loading ($module)..."
|
||
|
|
|
||
|
|
# Check if template exists for this module
|
||
|
|
let template_path = $"provisioning/workspace/templates/taskservs/*/($module).k"
|
||
|
|
let has_template = (glob $template_path | length) > 0
|
||
|
|
|
||
|
|
if $has_template and $template_base {
|
||
|
|
print $" ✓ Using template base for ($module)"
|
||
|
|
# Template-based loading would go here
|
||
|
|
} else {
|
||
|
|
print $" ✓ Direct loading for ($module)"
|
||
|
|
# Direct loading
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
print "✅ Enhanced loading completed"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Unload module from workspace
|
||
|
|
export def "main unload" [
|
||
|
|
type: string, # Module type
|
||
|
|
workspace: string, # Workspace path
|
||
|
|
module: string, # Module name to unload
|
||
|
|
--layer: string = "workspace" # Layer to unload from
|
||
|
|
] {
|
||
|
|
print $"Unloading ($module) from ($workspace) at layer ($layer)"
|
||
|
|
|
||
|
|
match $type {
|
||
|
|
"taskservs" => {
|
||
|
|
unload_taskserv_from_workspace $workspace $module $layer
|
||
|
|
}
|
||
|
|
"providers" => {
|
||
|
|
print "Provider unloading not implemented yet"
|
||
|
|
}
|
||
|
|
"clusters" => {
|
||
|
|
print "Cluster unloading not implemented yet"
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
print $"Unknown module type: ($type)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# === LIST COMMANDS ===
|
||
|
|
|
||
|
|
# List modules in workspace
|
||
|
|
export def "main list" [
|
||
|
|
type: string, # Module type
|
||
|
|
workspace: string, # Workspace path
|
||
|
|
--layer: string = "all", # Layer to list: workspace, infra, all
|
||
|
|
--format: string = "table" # Output format
|
||
|
|
] {
|
||
|
|
print $"Listing ($type) in ($workspace) for layer ($layer)"
|
||
|
|
|
||
|
|
match $type {
|
||
|
|
"taskservs" => {
|
||
|
|
list_workspace_taskservs $workspace $layer $format
|
||
|
|
}
|
||
|
|
"providers" => {
|
||
|
|
print "Provider listing not implemented yet"
|
||
|
|
}
|
||
|
|
"clusters" => {
|
||
|
|
print "Cluster listing not implemented yet"
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
print $"Unknown module type: ($type)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# === TEMPLATE COMMANDS ===
|
||
|
|
|
||
|
|
# List available templates
|
||
|
|
export def "main template list" [
|
||
|
|
--template-type: string = "all", # Template type: taskservs, providers, servers, clusters
|
||
|
|
--format: string = "table" # Output format
|
||
|
|
] {
|
||
|
|
print $"📋 Available templates type: ($template_type)"
|
||
|
|
|
||
|
|
let template_base = "provisioning/workspace/templates"
|
||
|
|
|
||
|
|
match $template_type {
|
||
|
|
"taskservs" | "all" => {
|
||
|
|
let taskserv_templates = if (($template_base | path join "taskservs") | path exists) {
|
||
|
|
glob ($template_base | path join "taskservs" "*" "*.k")
|
||
|
|
| each { |path|
|
||
|
|
let category = ($path | path dirname | path basename)
|
||
|
|
let name = ($path | path basename | str replace ".k" "")
|
||
|
|
{ type: "taskserv", category: $category, name: $name, path: $path }
|
||
|
|
}
|
||
|
|
} else { [] }
|
||
|
|
|
||
|
|
format_output $taskserv_templates $format
|
||
|
|
}
|
||
|
|
"providers" => {
|
||
|
|
print "Provider templates not implemented yet"
|
||
|
|
}
|
||
|
|
"servers" => {
|
||
|
|
let server_templates = if (($template_base | path join "servers") | path exists) {
|
||
|
|
ls ($template_base | path join "servers") | get name
|
||
|
|
| each { |path| { type: "server", name: ($path | path basename), path: $path } }
|
||
|
|
} else { [] }
|
||
|
|
|
||
|
|
format_output $server_templates $format
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
print $"Unknown template type: ($template_type)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Extract template from existing infrastructure
|
||
|
|
export def "main template extract" [
|
||
|
|
source_infra: string, # Source infrastructure path
|
||
|
|
template_name: string, # Name for the new template
|
||
|
|
--type: string = "taskserv", # Template type
|
||
|
|
--output: string = "provisioning/workspace/templates" # Output directory
|
||
|
|
] {
|
||
|
|
print $"📤 Extracting template ($template_name) from ($source_infra)"
|
||
|
|
|
||
|
|
# Implementation would analyze the source infra and create template
|
||
|
|
print "Template extraction not yet implemented"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Apply template to infrastructure
|
||
|
|
export def "main template apply" [
|
||
|
|
template_name: string, # Template to apply
|
||
|
|
target_infra: string, # Target infrastructure
|
||
|
|
--override-file: string = "", # Override file path
|
||
|
|
--dry-run # Show what would be done
|
||
|
|
] {
|
||
|
|
if $dry_run {
|
||
|
|
print $"🔍 [DRY RUN] Would apply template ($template_name) to ($target_infra)"
|
||
|
|
} else {
|
||
|
|
print $"📥 Applying template ($template_name) to ($target_infra)"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Implementation would apply template with overrides
|
||
|
|
print "Template application not yet implemented"
|
||
|
|
}
|
||
|
|
|
||
|
|
# === LAYER COMMANDS ===
|
||
|
|
|
||
|
|
# Show layer information
|
||
|
|
export def "main layer show" [
|
||
|
|
workspace: string, # Workspace path
|
||
|
|
--module: string = "", # Specific module to show
|
||
|
|
--type: string = "taskservs" # Module type
|
||
|
|
] {
|
||
|
|
print $"📊 Layer information for ($workspace)"
|
||
|
|
|
||
|
|
if not ($module | is-empty) {
|
||
|
|
# Use existing layer utilities
|
||
|
|
try {
|
||
|
|
nu -c $"use provisioning/workspace/tools/layer-utils.nu *; test_layer_resolution ($module) ($workspace) upcloud"
|
||
|
|
} catch {
|
||
|
|
print $"Could not test layer resolution for ($module)"
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
print "Showing overall layer structure..."
|
||
|
|
try {
|
||
|
|
nu -c "use provisioning/workspace/tools/layer-utils.nu *; show_layer_stats"
|
||
|
|
} catch {
|
||
|
|
print "Could not show layer statistics"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Test layer resolution
|
||
|
|
export def "main layer test" [
|
||
|
|
module: string, # Module to test
|
||
|
|
workspace: string, # Workspace/infra name
|
||
|
|
provider: string = "upcloud" # Provider for testing
|
||
|
|
] {
|
||
|
|
print $"🧪 Testing layer resolution: ($module) in ($workspace) with ($provider)"
|
||
|
|
|
||
|
|
try {
|
||
|
|
nu -c $"use provisioning/workspace/tools/layer-utils.nu *; test_layer_resolution ($module) ($workspace) ($provider)"
|
||
|
|
} catch {
|
||
|
|
print $"❌ Layer resolution test failed for ($module)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# === OVERRIDE COMMANDS ===
|
||
|
|
|
||
|
|
# Create configuration override
|
||
|
|
export def "main override create" [
|
||
|
|
type: string, # Type: taskservs, providers, clusters
|
||
|
|
infra: string, # Infrastructure name
|
||
|
|
module: string, # Module name
|
||
|
|
--from: string = "", # Template to base override on
|
||
|
|
--layer: string = "infra" # Layer for override
|
||
|
|
] {
|
||
|
|
print $"⚙️ Creating override for ($module) in ($infra) at layer ($layer)"
|
||
|
|
|
||
|
|
let override_path = match $layer {
|
||
|
|
"infra" => $"workspace/infra/($infra)/overrides/($module).k"
|
||
|
|
"workspace" => $"provisioning/workspace/templates/($type)/($module).k"
|
||
|
|
_ => {
|
||
|
|
print $"Unknown layer: ($layer)"
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
print $"📝 Override will be created at: ($override_path)"
|
||
|
|
|
||
|
|
if not ($from | is-empty) {
|
||
|
|
print $"📋 Based on template: ($from)"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Create directory if needed
|
||
|
|
mkdir ($override_path | path dirname)
|
||
|
|
|
||
|
|
# Create basic override file
|
||
|
|
let content = if not ($from | is-empty) {
|
||
|
|
$"# Override for ($module) in ($infra)
|
||
|
|
# Based on template: ($from)
|
||
|
|
|
||
|
|
import ($type).*.($module).kcl.($module) as base
|
||
|
|
import provisioning.workspace.templates.($type).($from) as template
|
||
|
|
|
||
|
|
# Infrastructure-specific overrides
|
||
|
|
($module)_($infra)_override: base.($module | str capitalize) = template.($from)_template {
|
||
|
|
# Add your overrides here
|
||
|
|
# Example:
|
||
|
|
# replicas = 3
|
||
|
|
# resources.memory = \"1Gi\"
|
||
|
|
}
|
||
|
|
"
|
||
|
|
} else {
|
||
|
|
$"# Override for ($module) in ($infra)
|
||
|
|
|
||
|
|
import ($type).*.($module).kcl.($module) as base
|
||
|
|
|
||
|
|
# Infrastructure-specific overrides
|
||
|
|
($module)_($infra)_override: base.($module | str capitalize) = base.($module)_config {
|
||
|
|
# Add your overrides here
|
||
|
|
# Example:
|
||
|
|
# replicas = 3
|
||
|
|
# resources.memory = \"1Gi\"
|
||
|
|
}
|
||
|
|
"
|
||
|
|
}
|
||
|
|
|
||
|
|
$content | save $override_path
|
||
|
|
print $"✅ Override created: ($override_path)"
|
||
|
|
}
|
||
|
|
|
||
|
|
# === WORKSPACE MANAGEMENT ===
|
||
|
|
|
||
|
|
# Initialize workspace with modules
|
||
|
|
export def "main init" [
|
||
|
|
workspace: string, # Workspace path
|
||
|
|
--modules: list<string> = [], # Initial modules to load
|
||
|
|
--template: string = "", # Workspace template
|
||
|
|
--provider: string = "upcloud" # Default provider
|
||
|
|
] {
|
||
|
|
print $"🚀 Initializing workspace: ($workspace)"
|
||
|
|
|
||
|
|
# Create workspace structure
|
||
|
|
let workspace_dirs = [
|
||
|
|
$"($workspace)/config"
|
||
|
|
$"($workspace)/taskservs"
|
||
|
|
$"($workspace)/overrides"
|
||
|
|
$"($workspace)/defs"
|
||
|
|
$"($workspace)/clusters"
|
||
|
|
]
|
||
|
|
|
||
|
|
for dir in $workspace_dirs {
|
||
|
|
mkdir $dir
|
||
|
|
print $" 📁 Created: ($dir)"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Create basic configuration
|
||
|
|
let config_content = $"# Workspace configuration for ($workspace)
|
||
|
|
# Provider: ($provider)
|
||
|
|
# Initialized: (date now)
|
||
|
|
|
||
|
|
provider = "($provider)"
|
||
|
|
workspace = "($workspace)"
|
||
|
|
"
|
||
|
|
$config_content | save $"($workspace)/config/workspace.toml"
|
||
|
|
print $" 📄 Created: ($workspace)/config/workspace.toml"
|
||
|
|
|
||
|
|
# Load initial modules
|
||
|
|
if ($modules | length) > 0 {
|
||
|
|
print $"📦 Loading initial modules: (($modules | str join ', '))"
|
||
|
|
main load taskservs $workspace ...$modules
|
||
|
|
}
|
||
|
|
|
||
|
|
print $"✅ Workspace ($workspace) initialized successfully"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Validate workspace integrity
|
||
|
|
export def "main validate" [workspace: string] {
|
||
|
|
print $"🔍 Validating workspace: ($workspace)"
|
||
|
|
|
||
|
|
let required_dirs = ["config", "taskservs", "overrides", "defs"]
|
||
|
|
mut validation_errors = []
|
||
|
|
|
||
|
|
for dir in $required_dirs {
|
||
|
|
let full_path = ($workspace | path join $dir)
|
||
|
|
if not ($full_path | path exists) {
|
||
|
|
$validation_errors = ($validation_errors | append $"Missing directory: ($full_path)")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Check configuration file
|
||
|
|
let config_file = ($workspace | path join "config" "workspace.toml")
|
||
|
|
if not ($config_file | path exists) {
|
||
|
|
$validation_errors = ($validation_errors | append $"Missing configuration: ($config_file)")
|
||
|
|
}
|
||
|
|
|
||
|
|
# Report results
|
||
|
|
if ($validation_errors | is-empty) {
|
||
|
|
print "✅ Workspace validation passed"
|
||
|
|
return true
|
||
|
|
} else {
|
||
|
|
print "❌ Workspace validation failed:"
|
||
|
|
for error in $validation_errors {
|
||
|
|
print $" • ($error)"
|
||
|
|
}
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Show workspace information
|
||
|
|
export def "main info" [workspace: string] {
|
||
|
|
print $"📊 Workspace Information: ($workspace)"
|
||
|
|
|
||
|
|
if not (($workspace | path join "config" "workspace.toml") | path exists) {
|
||
|
|
print "❌ Workspace not found or not initialized"
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
# Show basic info
|
||
|
|
let config = try { open ($workspace | path join "config" "workspace.toml") | from toml } catch { {} }
|
||
|
|
|
||
|
|
print $" Provider: (($config.provider? | default 'unknown'))"
|
||
|
|
print $" Path: ($workspace)"
|
||
|
|
|
||
|
|
# Count modules
|
||
|
|
let taskserv_count = try {
|
||
|
|
ls ($workspace | path join "taskservs") | length
|
||
|
|
} catch { 0 }
|
||
|
|
|
||
|
|
let override_count = try {
|
||
|
|
ls ($workspace | path join "overrides") | length
|
||
|
|
} catch { 0 }
|
||
|
|
|
||
|
|
print $" Task Services: ($taskserv_count)"
|
||
|
|
print $" Overrides: ($override_count)"
|
||
|
|
|
||
|
|
# Show recent activity
|
||
|
|
let recent_files = try {
|
||
|
|
ls $workspace | where type == file | sort-by modified | last 3 | get name
|
||
|
|
} catch { [] }
|
||
|
|
|
||
|
|
if ($recent_files | length) > 0 {
|
||
|
|
print " Recent activity:"
|
||
|
|
for file in $recent_files {
|
||
|
|
print $" • ($file | path basename)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# === HELPER FUNCTIONS ===
|
||
|
|
|
||
|
|
# Generic extension loading function (taskservs, providers, clusters, workflows)
|
||
|
|
def load_extension_to_workspace [
|
||
|
|
extension_type: string, # taskservs, providers, clusters, workflows
|
||
|
|
workspace: string,
|
||
|
|
modules: list<string>,
|
||
|
|
layer: string,
|
||
|
|
force: bool = false
|
||
|
|
] {
|
||
|
|
# Get extension-specific info function based on type
|
||
|
|
let get_info_fn = match $extension_type {
|
||
|
|
"taskservs" => { |name| get-taskserv-info $name }
|
||
|
|
"providers" => { |name| get-provider-info $name }
|
||
|
|
"clusters" => { |name| get-cluster-info $name }
|
||
|
|
_ => { |name| {name: $name, group: "", type: $extension_type} }
|
||
|
|
}
|
||
|
|
|
||
|
|
# Get source path from config
|
||
|
|
let source_base_path = (config-get $"paths.($extension_type)" | path expand)
|
||
|
|
|
||
|
|
# Get template base path from config
|
||
|
|
let provisioning_base = (config-get "paths.base" | path expand)
|
||
|
|
let template_base_path = ($provisioning_base | path join "workspace" "templates" $extension_type)
|
||
|
|
|
||
|
|
for module in $modules {
|
||
|
|
print $" 📦 Loading ($extension_type): ($module)"
|
||
|
|
|
||
|
|
# Get module info
|
||
|
|
let module_info = try {
|
||
|
|
do $get_info_fn $module
|
||
|
|
} catch {
|
||
|
|
print $" ❌ Module not found: ($module)"
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
print $" ✓ Found: ($module_info.name) (($module_info.group? | default ""))"
|
||
|
|
|
||
|
|
# Resolve workspace paths
|
||
|
|
let workspace_abs = ($workspace | path expand)
|
||
|
|
let workspace_root = if ($workspace_abs | str contains "/infra/") {
|
||
|
|
let parts = ($workspace_abs | split row "/infra/")
|
||
|
|
$parts.0
|
||
|
|
} else {
|
||
|
|
$workspace_abs
|
||
|
|
}
|
||
|
|
|
||
|
|
# Build source path (handle optional group, "root" means no category)
|
||
|
|
let group_path = ($module_info.group? | default "")
|
||
|
|
let group_path = if ($group_path == "root") { "" } else { $group_path }
|
||
|
|
let source_module_path = if ($group_path | is-not-empty) {
|
||
|
|
$source_base_path | path join $group_path $module
|
||
|
|
} else {
|
||
|
|
$source_base_path | path join $module
|
||
|
|
}
|
||
|
|
|
||
|
|
# STEP 1: Copy schemas to workspace/.{extension_type}
|
||
|
|
let target_schemas_dir = ($workspace_root | path join $".($extension_type)")
|
||
|
|
let target_module_path = if ($group_path | is-not-empty) {
|
||
|
|
$target_schemas_dir | path join $group_path $module
|
||
|
|
} else {
|
||
|
|
$target_schemas_dir | path join $module
|
||
|
|
}
|
||
|
|
|
||
|
|
# Config file directory
|
||
|
|
let config_dir = ($workspace_abs | path join $extension_type)
|
||
|
|
let config_file_path = ($config_dir | path join $"($module).k")
|
||
|
|
|
||
|
|
# Check if already loaded
|
||
|
|
if ($config_file_path | path exists) and ($target_module_path | path exists) {
|
||
|
|
if not $force {
|
||
|
|
print $" ✅ Module already loaded: ($module)"
|
||
|
|
print $" Config: ($config_file_path)"
|
||
|
|
print $" Source: ($target_module_path)"
|
||
|
|
print $" 💡 Use --force to overwrite existing files"
|
||
|
|
continue
|
||
|
|
} else {
|
||
|
|
print $" 🔄 Overwriting existing module: ($module)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Copy schemas from system extensions to workspace
|
||
|
|
let parent_dir = ($target_module_path | path dirname)
|
||
|
|
mkdir $parent_dir
|
||
|
|
|
||
|
|
if ($source_module_path | path exists) {
|
||
|
|
print $" 📦 Copying schemas to workspace .($extension_type)..."
|
||
|
|
print $" From: ($source_module_path)"
|
||
|
|
print $" To: ($target_module_path)"
|
||
|
|
|
||
|
|
if ($target_module_path | path exists) {
|
||
|
|
rm -rf $target_module_path
|
||
|
|
}
|
||
|
|
|
||
|
|
cp -r $source_module_path $parent_dir
|
||
|
|
print $" ✓ Schemas copied to workspace .($extension_type)/"
|
||
|
|
|
||
|
|
# STEP 2a: Update individual module's kcl.mod with correct workspace paths
|
||
|
|
# Calculate relative paths based on categorization depth
|
||
|
|
let provisioning_path = if ($group_path | is-not-empty) {
|
||
|
|
# Categorized: .{ext}/{category}/{module}/kcl/ -> ../../../../.kcl/packages/provisioning
|
||
|
|
"../../../../.kcl/packages/provisioning"
|
||
|
|
} else {
|
||
|
|
# Non-categorized: .{ext}/{module}/kcl/ -> ../../../.kcl/packages/provisioning
|
||
|
|
"../../../.kcl/packages/provisioning"
|
||
|
|
}
|
||
|
|
|
||
|
|
let parent_path = if ($group_path | is-not-empty) {
|
||
|
|
# Categorized: .{ext}/{category}/{module}/kcl/ -> ../../..
|
||
|
|
"../../.."
|
||
|
|
} else {
|
||
|
|
# Non-categorized: .{ext}/{module}/kcl/ -> ../..
|
||
|
|
"../.."
|
||
|
|
}
|
||
|
|
|
||
|
|
# Update the module's kcl.mod file with workspace-relative paths
|
||
|
|
let module_kcl_mod_path = ($target_module_path | path join "kcl" "kcl.mod")
|
||
|
|
if ($module_kcl_mod_path | path exists) {
|
||
|
|
print $" 🔧 Updating module kcl.mod with workspace paths"
|
||
|
|
let module_kcl_mod_content = $"[package]
|
||
|
|
name = \"($module)\"
|
||
|
|
edition = \"v0.11.3\"
|
||
|
|
version = \"0.0.1\"
|
||
|
|
|
||
|
|
[dependencies]
|
||
|
|
provisioning = { path = \"($provisioning_path)\", version = \"0.0.1\" }
|
||
|
|
($extension_type) = { path = \"($parent_path)\", version = \"0.1.0\" }
|
||
|
|
"
|
||
|
|
$module_kcl_mod_content | save -f $module_kcl_mod_path
|
||
|
|
print $" ✓ Updated kcl.mod: ($module_kcl_mod_path)"
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
print $" ⚠️ Warning: Source not found at ($source_module_path)"
|
||
|
|
}
|
||
|
|
|
||
|
|
# STEP 2b: Create kcl.mod in workspace/.{extension_type}
|
||
|
|
let extension_kcl_mod = ($target_schemas_dir | path join "kcl.mod")
|
||
|
|
if not ($extension_kcl_mod | path exists) {
|
||
|
|
print $" 📦 Creating kcl.mod for .($extension_type) package"
|
||
|
|
let kcl_mod_content = $"[package]
|
||
|
|
name = \"($extension_type)\"
|
||
|
|
edition = \"v0.11.3\"
|
||
|
|
version = \"0.1.0\"
|
||
|
|
description = \"Workspace-level ($extension_type) schemas\"
|
||
|
|
"
|
||
|
|
$kcl_mod_content | save $extension_kcl_mod
|
||
|
|
}
|
||
|
|
|
||
|
|
# Ensure config directory exists
|
||
|
|
mkdir $config_dir
|
||
|
|
|
||
|
|
# STEP 4: Generate config from template
|
||
|
|
let template_path = if ($group_path | is-not-empty) {
|
||
|
|
$template_base_path | path join $group_path $"($module).k"
|
||
|
|
} else {
|
||
|
|
$template_base_path | path join $"($module).k"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Build import statement with "as {module}" alias
|
||
|
|
let import_stmt = if ($group_path | is-not-empty) {
|
||
|
|
$"import ($extension_type).($group_path).($module).kcl.($module) as ($module)"
|
||
|
|
} else {
|
||
|
|
$"import ($extension_type).($module).kcl.($module) as ($module)"
|
||
|
|
}
|
||
|
|
|
||
|
|
# Get relative paths for comments
|
||
|
|
let workspace_name = ($workspace_root | path basename)
|
||
|
|
let relative_schema_path = if ($group_path | is-not-empty) {
|
||
|
|
$"($workspace_name)/.($extension_type)/($group_path)/($module)"
|
||
|
|
} else {
|
||
|
|
$"($workspace_name)/.($extension_type)/($module)"
|
||
|
|
}
|
||
|
|
|
||
|
|
let config_content = if ($template_path | path exists) {
|
||
|
|
print $" 📄 Using template from: ($template_path)"
|
||
|
|
let template_body = (open $template_path)
|
||
|
|
$"# Configuration for ($module)
|
||
|
|
# Workspace: ($workspace_name)
|
||
|
|
# Schemas from: ($relative_schema_path)
|
||
|
|
($import_stmt)
|
||
|
|
|
||
|
|
($template_body)"
|
||
|
|
} else {
|
||
|
|
$"# Configuration for ($module)
|
||
|
|
# Workspace: ($workspace_name)
|
||
|
|
# Schemas from: ($relative_schema_path)
|
||
|
|
($import_stmt)
|
||
|
|
|
||
|
|
# TODO: Configure your ($module) instance
|
||
|
|
# See available schemas at: ($relative_schema_path)/kcl/
|
||
|
|
"
|
||
|
|
}
|
||
|
|
|
||
|
|
$config_content | save -f $config_file_path
|
||
|
|
print $" ✓ Config created: ($config_file_path)"
|
||
|
|
print $" 📝 Edit ($extension_type)/($module).k to configure settings"
|
||
|
|
|
||
|
|
# STEP 3: Update infra kcl.mod
|
||
|
|
if ($workspace_abs | str contains "/infra/") {
|
||
|
|
let kcl_mod_path = ($workspace_abs | path join "kcl.mod")
|
||
|
|
if ($kcl_mod_path | path exists) {
|
||
|
|
let kcl_mod_content = (open $kcl_mod_path)
|
||
|
|
if not ($kcl_mod_content | str contains $"($extension_type) =") {
|
||
|
|
print $" 🔧 Updating kcl.mod to include ($extension_type) dependency"
|
||
|
|
let new_dependency = $"\n# Workspace-level ($extension_type) \(shared across infras\)\n($extension_type) = { path = \"../../.($extension_type)\" }\n"
|
||
|
|
$"($kcl_mod_content)($new_dependency)" | save -f $kcl_mod_path
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Unload taskserv from workspace
|
||
|
|
def unload_taskserv_from_workspace [workspace: string, module: string, layer: string] {
|
||
|
|
let target_path = match $layer {
|
||
|
|
"workspace" => ($workspace | path join "taskservs" $"($module).k")
|
||
|
|
"infra" => ($workspace | path join "overrides" $"($module).k")
|
||
|
|
_ => ($workspace | path join "taskservs" $"($module).k")
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($target_path | path exists) {
|
||
|
|
rm $target_path
|
||
|
|
print $" ✓ Removed: ($target_path)"
|
||
|
|
} else {
|
||
|
|
print $" ❌ Not found: ($target_path)"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# List workspace taskservs
|
||
|
|
def list_workspace_taskservs [workspace: string, layer: string, format: string] {
|
||
|
|
let paths = match $layer {
|
||
|
|
"workspace" => [($workspace | path join "taskservs")]
|
||
|
|
"infra" => [($workspace | path join "overrides")]
|
||
|
|
"all" => [($workspace | path join "taskservs"), ($workspace | path join "overrides")]
|
||
|
|
_ => [($workspace | path join "taskservs")]
|
||
|
|
}
|
||
|
|
|
||
|
|
mut all_taskservs = []
|
||
|
|
|
||
|
|
for path in $paths {
|
||
|
|
if ($path | path exists) {
|
||
|
|
let taskservs = ls $path
|
||
|
|
| where type == file
|
||
|
|
| where name =~ '\\.k$'
|
||
|
|
| each { |file|
|
||
|
|
{
|
||
|
|
name: ($file.name | path basename | str replace ".k" "")
|
||
|
|
layer: ($path | path basename)
|
||
|
|
path: $file.name
|
||
|
|
modified: $file.modified
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$all_taskservs = ($all_taskservs | append $taskservs)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
format_output $all_taskservs $format
|
||
|
|
}
|
||
|
|
|
||
|
|
# Format output based on requested format
|
||
|
|
def format_output [data: any, format: string] {
|
||
|
|
match $format {
|
||
|
|
"json" => ($data | to json)
|
||
|
|
"yaml" => ($data | to yaml)
|
||
|
|
"names" => ($data | get name | str join "\n")
|
||
|
|
"table" | _ => ($data | table)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# === HELP FUNCTIONS ===
|
||
|
|
|
||
|
|
def print_enhanced_help [] {
|
||
|
|
print "Enhanced Module Loader CLI - Discovery and loading with template support"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader <command> [options]"
|
||
|
|
print ""
|
||
|
|
print "CORE COMMANDS:"
|
||
|
|
print " discover <type> [query] [--format <fmt>] [--category <cat>] - Discover available modules"
|
||
|
|
print " sync-kcl <infra> [--manifest <file>] [--kcl] - Sync KCL dependencies for infrastructure"
|
||
|
|
print " load <type> <workspace> <modules...> [--layer <layer>] - Load modules into workspace"
|
||
|
|
print " list <type> <workspace> [--layer <layer>] - List loaded modules"
|
||
|
|
print " unload <type> <workspace> <module> [--layer <layer>] - Unload module from workspace"
|
||
|
|
print ""
|
||
|
|
print "WORKSPACE COMMANDS:"
|
||
|
|
print " init <workspace> [--modules <list>] [--template <name>] - Initialize workspace"
|
||
|
|
print " validate <workspace> - Validate workspace integrity"
|
||
|
|
print " info <workspace> - Show workspace information"
|
||
|
|
print ""
|
||
|
|
print "TEMPLATE COMMANDS:"
|
||
|
|
print " template list [--type <type>] [--format <fmt>] - List available templates"
|
||
|
|
print " template extract <source> <name> [--type <type>] - Extract template from infra"
|
||
|
|
print " template apply <template> <target> [--dry-run] - Apply template to infra"
|
||
|
|
print ""
|
||
|
|
print "LAYER COMMANDS:"
|
||
|
|
print " layer show <workspace> [--module <name>] - Show layer information"
|
||
|
|
print " layer test <module> <workspace> [provider] - Test layer resolution"
|
||
|
|
print ""
|
||
|
|
print "OVERRIDE COMMANDS:"
|
||
|
|
print " override create <type> <infra> <module> [--from <template>] - Create configuration override"
|
||
|
|
print ""
|
||
|
|
print "ENHANCED COMMANDS:"
|
||
|
|
print " load enhanced <type> <workspace> <infra> <modules> [--layer <layer>] - Enhanced template loading"
|
||
|
|
print ""
|
||
|
|
print "Types: taskservs, providers, clusters"
|
||
|
|
print "Layers: workspace, infra, all"
|
||
|
|
print "Formats: table, json, yaml, names"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader discover taskservs --category databases"
|
||
|
|
print " module-loader load taskservs ./workspace [redis, postgres]"
|
||
|
|
print " module-loader template list --type taskservs"
|
||
|
|
print " module-loader layer test redis wuji upcloud"
|
||
|
|
print " module-loader override create taskservs wuji kubernetes --from ha-cluster"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_discover_help [] {
|
||
|
|
print "Discover available modules"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader discover <type> [query] [options]"
|
||
|
|
print ""
|
||
|
|
print "Options:"
|
||
|
|
print " --format <fmt> Output format: table, json, yaml, names (default: table)"
|
||
|
|
print " --category <cat> Filter by category (taskservs only)"
|
||
|
|
print " --group <group> Filter by group (taskservs only)"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader discover taskservs"
|
||
|
|
print " module-loader discover taskservs redis"
|
||
|
|
print " module-loader discover taskservs --category databases"
|
||
|
|
print " module-loader discover taskservs --format json"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_load_help [] {
|
||
|
|
print "Load modules into workspace"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader load <type> <workspace> <modules...> [options]"
|
||
|
|
print ""
|
||
|
|
print "Options:"
|
||
|
|
print " --layer <layer> Target layer: workspace, infra (default: workspace)"
|
||
|
|
print " --validate Validate workspace after loading"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader load taskservs ./workspace [kubernetes, cilium]"
|
||
|
|
print " module-loader load taskservs ./workspace [redis] --layer infra"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_list_help [] {
|
||
|
|
print "List modules in workspace"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader list <type> <workspace> [options]"
|
||
|
|
print ""
|
||
|
|
print "Options:"
|
||
|
|
print " --layer <layer> Layer to list: workspace, infra, all (default: all)"
|
||
|
|
print " --format <fmt> Output format: table, json, yaml, names"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader list taskservs ./workspace"
|
||
|
|
print " module-loader list taskservs ./workspace --layer workspace"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_unload_help [] {
|
||
|
|
print "Unload module from workspace"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader unload <type> <workspace> <module> [options]"
|
||
|
|
print ""
|
||
|
|
print "Options:"
|
||
|
|
print " --layer <layer> Layer to unload from: workspace, infra (default: workspace)"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader unload taskservs ./workspace kubernetes"
|
||
|
|
print " module-loader unload taskservs ./workspace redis --layer infra"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_init_help [] {
|
||
|
|
print "Initialize workspace with modules"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader init <workspace> [options]"
|
||
|
|
print ""
|
||
|
|
print "Options:"
|
||
|
|
print " --modules <list> Initial modules to load"
|
||
|
|
print " --template <name> Workspace template to use"
|
||
|
|
print " --provider <name> Default provider (default: upcloud)"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader init ./my-workspace"
|
||
|
|
print " module-loader init ./k8s-workspace --modules [kubernetes, cilium]"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_validate_help [] {
|
||
|
|
print "Validate workspace integrity"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader validate <workspace>"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader validate ./workspace"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_info_help [] {
|
||
|
|
print "Show workspace information"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader info <workspace>"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader info ./workspace"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_template_help [] {
|
||
|
|
print "Template management commands"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader template <subcommand> [options]"
|
||
|
|
print ""
|
||
|
|
print "Subcommands:"
|
||
|
|
print " list List available templates"
|
||
|
|
print " extract Extract template from existing infrastructure"
|
||
|
|
print " apply Apply template to infrastructure"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader template list --type taskservs"
|
||
|
|
print " module-loader template extract ./wuji wuji-production"
|
||
|
|
print " module-loader template apply wuji-production ./new-infra"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_layer_help [] {
|
||
|
|
print "Layer resolution commands"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader layer <subcommand> [options]"
|
||
|
|
print ""
|
||
|
|
print "Subcommands:"
|
||
|
|
print " show Show layer information for workspace"
|
||
|
|
print " test Test layer resolution for specific module"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader layer show ./workspace"
|
||
|
|
print " module-loader layer test kubernetes wuji upcloud"
|
||
|
|
}
|
||
|
|
|
||
|
|
def print_override_help [] {
|
||
|
|
print "Configuration override commands"
|
||
|
|
print ""
|
||
|
|
print "Usage: module-loader override create <type> <infra> <module> [options]"
|
||
|
|
print ""
|
||
|
|
print "Options:"
|
||
|
|
print " --from <template> Base override on template"
|
||
|
|
print " --layer <layer> Target layer: infra, workspace (default: infra)"
|
||
|
|
print ""
|
||
|
|
print "Examples:"
|
||
|
|
print " module-loader override create taskservs wuji kubernetes"
|
||
|
|
print " module-loader override create taskservs wuji redis --from databases/redis"
|
||
|
|
}
|