provisioning-core/nulib/cli/taskserv.nu

224 lines
8.5 KiB
Text
Raw Permalink Normal View History

use std
# REMOVED: use ../lib_provisioning * - causes circular import (already loaded by main provisioning script)
use platform/mod.nu *
use platform/config/accessor.nu *
# Taskserv workflow definitions
def get-orchestrator-url [--orchestrator: string = ""] {
if ($orchestrator | is-not-empty) {
return $orchestrator
}
if ($env.PROVISIONING_ORCHESTRATOR_URL? | is-not-empty) {
return $env.PROVISIONING_ORCHESTRATOR_URL
}
config-get "platform.orchestrator.url" "http://localhost:9011"
}
# Detect if orchestrator URL is local (for plugin usage)
def use-local-plugin [orchestrator_url: string] {
# Check if it's a local endpoint
(detect-platform-mode $orchestrator_url) == "local"
}
export def taskserv_workflow [
taskserv: string # Taskserv name
operation: string # Operation: create, delete, generate, check-updates
infra?: string # Infrastructure target
settings?: string # Settings file path
--check (-c) # Check mode only
--wait (-w) # Wait for completion
--orchestrator: string = "" # Orchestrator URL (optional, uses platform config if not provided)
] {
let orch_url = (get-orchestrator-url --orchestrator=$orchestrator)
let workflow_data = {
taskserv: $taskserv,
operation: $operation,
infra: ($infra | default ""),
settings: ($settings | default ""),
check_mode: $check,
wait: $wait
}
# Submit to orchestrator
let response = (http post $"($orch_url)/workflows/taskserv/create" --content-type "application/json" ($workflow_data | to json))
if not ($response | get success) {
return { status: "error", message: ($response | get error) }
}
let task_id = ($response | get data)
_print $"Taskserv ($operation) workflow submitted: ($task_id)"
if $wait {
wait_for_workflow_completion $orch_url $task_id
} else {
{ status: "submitted", task_id: $task_id }
}
}
# Specific taskserv operations
export def "taskserv create" [
taskserv: string # Taskserv name
infra?: string # Infrastructure target
settings?: string # Settings file path
--check (-c) # Check mode only
--wait (-w) # Wait for completion
--orchestrator: string = "" # Orchestrator URL (optional, uses platform config if not provided)
] {
taskserv_workflow $taskserv "create" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
export def "taskserv delete" [
taskserv: string # Taskserv name
infra?: string # Infrastructure target
settings?: string # Settings file path
--check (-c) # Check mode only
--wait (-w) # Wait for completion
--orchestrator: string = "" # Orchestrator URL (optional, uses platform config if not provided)
] {
taskserv_workflow $taskserv "delete" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
export def "taskserv generate" [
taskserv: string # Taskserv name
infra?: string # Infrastructure target
settings?: string # Settings file path
--check (-c) # Check mode only
--wait (-w) # Wait for completion
--orchestrator: string = "" # Orchestrator URL (optional, uses platform config if not provided)
] {
taskserv_workflow $taskserv "generate" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
def main [
...args: string
--infra (-i): string = ""
--settings (-s): string = ""
--check (-c)
--wait (-w)
--orchestrator: string = ""
--out: string = ""
--debug (-x)
] : nothing -> nothing {
if $debug { $env.PROVISIONING_DEBUG = true }
let first = ($args | get 0? | default "")
let rest = if $first in ["taskserv", "task", "t"] { $args | skip 1 } else { $args }
let subcmd = ($rest | get 0? | default "")
let name = ($rest | get 1? | default "")
match $subcmd {
"status" | "s" => {
use orchestration/taskservs/status.nu *
main status --infra=$infra --settings=$settings
}
"list" | "l" => {
use cli/components.nu ["main component list"]
let rows = if ($infra | is-not-empty) {
main component list --mode "taskserv" --infra $infra
} else {
main component list --mode "taskserv"
}
if ($rows | is-empty) {
print "No taskserv-mode components declared in the active workspace."
return
}
if $out == "json" { $rows | to json; return }
if $out == "yaml" { $rows | to yaml; return }
$rows | reject pod_selector
}
"create" | "c" => {
taskserv_workflow $name "create" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
"delete" | "d" => {
taskserv_workflow $name "delete" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
"generate" | "g" => {
taskserv_workflow $name "generate" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
"check-updates" => {
taskserv_workflow $name "check-updates" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
_ => {
print "Task Service Management"
print "========================"
print ""
print "Usage: prvng taskserv <subcommand> [options]"
print ""
print "Subcommands:"
print " status [--infra <i>] [--settings <s>] DAG formula progress (alias: s)"
print " list [--infra <i>] [--settings <s>] List all taskservs (alias: l)"
print " create <name> [--infra <i>] [--check] [--wait] Create taskserv (alias: c)"
print " delete <name> [--infra <i>] Delete taskserv (alias: d)"
print " generate <name> [--infra <i>] Generate taskserv (alias: g)"
print " check-updates <name> Check for updates"
print ""
print "Examples:"
print " prvng taskserv status"
print " prvng taskserv list --infra sgoyol"
print " prvng taskserv create postgresql --wait"
print " prvng t s # status short form"
print " prvng t l # list short form"
}
}
}
export def "taskserv check-updates" [
taskserv?: string # Taskserv name (optional for all)
infra?: string # Infrastructure target
settings?: string # Settings file path
--check (-c) # Check mode only
--wait (-w) # Wait for completion
--orchestrator: string = "" # Orchestrator URL (optional, uses platform config if not provided)
] {
let taskserv_name = ($taskserv | default "")
taskserv_workflow $taskserv_name "check-updates" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}
def wait_for_workflow_completion [orchestrator: string, task_id: string] {
_print "Waiting for workflow completion..."
mut result = { status: "pending" }
while true {
let status_response = (http get $"($orchestrator)/tasks/($task_id)")
if not ($status_response | get success) {
return { status: "error", message: "Failed to get task status" }
}
let task = ($status_response | get data)
let task_status = ($task | get status)
match $task_status {
"Completed" => {
_print $"✅ Workflow completed successfully"
if ($task | get output | is-not-empty) {
_print "Output:"
_print ($task | get output)
}
$result = { status: "completed", task: $task }
break
},
"Failed" => {
_print $"❌ Workflow failed"
if ($task | get error | is-not-empty) {
_print "Error:"
_print ($task | get error)
}
$result = { status: "failed", task: $task }
break
},
"Running" => {
_print $"🔄 Workflow is running..."
},
_ => {
_print $"⏳ Workflow status: ($task_status)"
}
}
sleep 2sec
}
return $result
}