jesus/provisioning
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: add current provisioning state before migration

Browse source
This commit is contained in:
Jesús Pérez 2025-09-22 23:11:41 +01:00
parent a9703b4748
commit 50745b0f22
660 changed files with 88126 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

75
core/nulib/taskservs/create.nu Normal file
View file

@ -0,0 +1,75 @@
use lib_provisioning *
use utils.nu *
use handlers.nu *
use ../lib_provisioning/utils/ssh.nu *
# Provider middleware now available through lib_provisioning
# > TaskServs create
export def "main create" [
task_name?: string # task in settings
server?: string # Server hostname in settings
...args # Args for create command
--infra (-i): string # Infra directory
--settings (-s): string # Settings path
--iptype: string = "public" # Ip type to connect
--outfile (-o): string # Output file
--taskserv_pos (-p): int # Server position in settings
--check (-c) # Only check mode no taskservs will be created
--wait (-w) # Wait taskservs to be created
--select: string # Select with task as option
--debug (-x) # Use Debug mode
--xm # Debug with PROVISIONING_METADATA
--xc # Debuc for task and services locally PROVISIONING_DEBUG_CHECK
--xr # Debug for remote taskservs PROVISIONING_DEBUG_REMOTE
--xld # Log level with DEBUG PROVISIONING_LOG_LEVEL=debug
--metadata # Error with metadata (-xm)
--notitles # not tittles
--helpinfo (-h) # For more details use options "help" (no dashes)
--out: string # Print Output format: json, yaml, text (default)
]: nothing -> nothing {
if ($out | is-not-empty) {
$env.PROVISIONING_OUT = $out
$env.PROVISIONING_NO_TERMINAL = true
}
provisioning_init $helpinfo "taskserv create" ([($task_name | default "") ($server | default "")] | append $args)
if $debug { $env.PROVISIONING_DEBUG = true }
if $metadata { $env.PROVISIONING_METADATA = true }
let curr_settings = (find_get_settings --infra $infra --settings $settings)
let task = ($env.PROVISIONING_ARGS? | default "" | split row " "| get -o 0)
let options = if ($args | length) > 0 {
$args
} else {
let str_task = (($env.PROVISIONING_ARGS? | default "") | str replace $"($task) " "" |
str replace $"($task_name) " "" | str replace $"($server) " "")
($str_task | split row "-" | get -o 0 | default "" | str trim )
}
let other = if ($args | length) > 0 { ($args| skip 1) } else { "" }
let ops = $"($env.PROVISIONING_ARGS? | default "") " | str replace $"($task_name) " "" | str trim
let run_create = {
let curr_settings = (settings_with_env $curr_settings)
$env.WK_CNPROV = $curr_settings.wk_path
let arr_task = if $task_name == null or $task_name == "" or $task_name == "-" { [] } else { $task_name | split row "/" }
let match_task = if ($arr_task | length ) == 0 { "" } else { ($arr_task | get -o 0) }
let match_task_profile = if ($arr_task | length ) < 2 { "" } else { ($arr_task | get -o 1) }
let match_server = if $server == null or $server == "" { "" } else { $server}
on_taskservs $curr_settings $match_task $match_task_profile $match_server $iptype $check
}
match $task {
"" if $task_name == "h" => {
^$"($env.PROVISIONING_NAME)" -mod taskserv update help --notitles
},
"" if $task_name == "help" => {
^$"($env.PROVISIONING_NAME)" -mod taskserv update --help
_print (provisioning_options "update")
},
"c" | "create" | "" => {
let result = desktop_run_notify $"($env.PROVISIONING_NAME) taskservs create" "-> " $run_create --timeout 11sec
},
_ => {
if $task_name != "" {_print $"🛑 invalid_option ($task_name)" }
_print $"\nUse (_ansi blue_bold)($env.PROVISIONING_NAME) -h(_ansi reset) for help on commands and options"
}
}
# "" | "create"
#if not $env.PROVISIONING_DEBUG { end_run "" }
}

130
core/nulib/taskservs/delete.nu Normal file
View file

@ -0,0 +1,130 @@
use lib_provisioning *
# > TaskServs Delete
export def "main delete" [
name?: string # Server hostname in settings
...args # Args for create command
--infra (-i): string # Infra directory
--keepstorage # keep storage
--settings (-s): string # Settings path
--yes (-y) # confirm delete
--outfile (-o): string # Output file
--serverpos (-p): int # Server position in settings
--check (-c) # Only check mode no servers will be created
--wait (-w) # Wait servers to be created
--select: string # Select with task as option
--debug (-x) # Use Debug mode
--xm # Debug with PROVISIONING_METADATA
--xc # Debuc for task and services locally PROVISIONING_DEBUG_CHECK
--xr # Debug for remote servers PROVISIONING_DEBUG_REMOTE
--xld # Log level with DEBUG PROVISIONING_LOG_LEVEL=debug
--metadata # Error with metadata (-xm)
--notitles # not tittles
--helpinfo (-h) # For more details use options "help" (no dashes)
--out: string # Print Output format: json, yaml, text (default)
]: nothing -> nothing {
if ($out | is-not-empty) {
$env.PROVISIONING_OUT = $out
$env.PROVISIONING_NO_TERMINAL = true
}
provisioning_init $helpinfo "taskservs delete" $args
#parse_help_command "server create" $name --ismod --end
#print "on taskservs main delete"
if $debug { $env.PROVISIONING_DEBUG = true }
if $metadata { $env.PROVISIONING_METADATA = true }
if $name != null and $name != "h" and $name != "help" {
let curr_settings = (find_get_settings --infra $infra --settings $settings)
if ($curr_settings.data.servers | find $name| length) == 0 {
_print $"🛑 invalid name ($name)"
exit 1
}
}
let task = if ($args | length) > 0 {
($args| get 0)
} else {
let str_task = (($env.PROVISIONING_ARGS? | default "") | str replace "delete " " " )
let str_task = if $name != null {
($str_task | str replace $name "")
} else {
$str_task
}
($str_task | str trim | split row " " | get -o 0 | default "" |
split row "-" | get -o 0 | default "" | str trim )
}
let other = if ($args | length) > 0 { ($args| skip 1) } else { "" }
let ops = $"($env.PROVISIONING_ARGS? | default "") " | str replace $"($task) " "" | str trim
let run_delete = {
let curr_settings = (find_get_settings --infra $infra --settings $settings)
$env.WK_CNPROV = $curr_settings.wk_path
on_delete_taskservs $curr_settings $keepstorage $wait $name $serverpos
}
match $task {
"" if $name == "h" => {
^$"($env.PROVISIONING_NAME)" -mod takserv delete --help --notitles
},
"" if $name == "help" => {
^$"($env.PROVISIONING_NAME)" -mod takserv delete --help
_print (provisioning_options "delete")
},
"" => {
if not $yes or not (($env.PROVISIONING_ARGS? | default "") | str contains "--yes") {
_print $"Run (_ansi red_bold)delete servers(_ansi reset) (_ansi green_bold)($name)(_ansi reset) type (_ansi green_bold)yes(_ansi reset) ? "
let user_input = (input --numchar 3)
if $user_input != "yes" and $user_input != "YES" {
exit 1
}
}
let result = desktop_run_notify $"($env.PROVISIONING_NAME) servers delete" "-> " $run_delete --timeout 11sec
},
_ => {
if $task != "" { _print $"🛑 invalid_option ($task)" }
_print $"\nUse (_ansi blue_bold)($env.PROVISIONING_NAME) -h(_ansi reset) for help on commands and options"
}
}
if not $env.PROVISIONING_DEBUG { end_run "" }
}
export def on_delete_taskservs [
settings: record # Settings record
keep_storage: bool # keep storage
wait: bool # Wait for creation
hostname?: string # Server hostname in settings
serverpos?: int # Server position in settings
]: nothing -> record {
#use lib_provisioning *
#use utils.nu *
# TODO review
return { status: true, error: "" }
let match_hostname = if $hostname != null and $hostname != "" {
$hostname
} else if $serverpos != null {
let total = $settings.data.servers | length
let pos = if $serverpos == 0 {
_print $"Use number form 1 to ($total)"
$serverpos
} else if $serverpos <= $total {
$serverpos - 1
} else {
(throw-error $"🛑 server pos" $"($serverpos) from ($total) servers"
"on_create" --span (metadata $serverpos).span)
exit 1
}
($settings.data.servers | get $pos).hostname
}
_print $"Delete (_ansi blue_bold)($settings.data.servers | length)(_ansi reset) server\(s\) in parallel (_ansi blue_bold)>>> 🌥 >>> (_ansi reset)\n"
$settings.data.servers | enumerate | par-each { |it|
if $match_hostname == null or $match_hostname == "" or $it.item.hostname == $match_hostname {
if not (mw_delete_server $settings $it.item $keep_storage false) {
return false
}
_print $"\n(_ansi blue_reverse)----🌥 ----🌥 ----🌥 ---- oOo ----🌥 ----🌥 ----🌥 ---- (_ansi reset)\n"
}
}
for server in $settings.data.servers {
let already_created = (mw_server_exists $server false)
if ($already_created) {
return { status: false, error: $"($server.hostname) created" }
}
}
{ status: true, error: "" }
}

80
core/nulib/taskservs/generate.nu Normal file
View file

@ -0,0 +1,80 @@
use lib_provisioning *
#use ../lib_provisioning/utils/generate.nu *
use utils.nu *
use handlers.nu *
use ../lib_provisioning/utils/ssh.nu *
#use providers/prov_lib/middleware.nu *
# Provider middleware now available through lib_provisioning
# > TaskServs generate
export def "main generate" [
task_name?: string # task in settings
server?: string # Server hostname in settings
...args # Args for generate command
--infra (-i): string # Infra directory
--settings (-s): string # Settings path
--iptype: string = "public" # Ip type to connect
--outfile (-o): string # Output file
--taskserv_pos (-p): int # Server position in settings
--check (-c) # Only check mode no taskservs will be generated
--wait (-w) # Wait taskservs to be generated
--select: string # Select with task as option
--debug (-x) # Use Debug mode
--xm # Debug with PROVISIONING_METADATA
--xc # Debuc for task and services locally PROVISIONING_DEBUG_CHECK
--xr # Debug for remote taskservs PROVISIONING_DEBUG_REMOTE
--xld # Log level with DEBUG PROVISIONING_LOG_LEVEL=debug
--metadata # Error with metadata (-xm)
--notitles # not tittles
--helpinfo (-h) # For more details use options "help" (no dashes)
--out: string # Print Output format: json, yaml, text (default)
]: nothing -> nothing {
if ($out | is-not-empty) {
$env.PROVISIONING_OUT = $out
$env.PROVISIONING_NO_TERMINAL = true
}
provisioning_init $helpinfo "taskserv generate" ([($task_name | default "") ($server | default "")] | append $args)
if $debug { $env.PROVISIONING_DEBUG = true }
if $metadata { $env.PROVISIONING_METADATA = true }
let curr_settings = (find_get_settings --infra $infra --settings $settings)
let task = ($env.PROVISIONING_ARGS? | default "" | split row " "| get -o 0)
let options = if ($args | length) > 0 {
$args
} else {
let str_task = (($env.PROVISIONING_ARGS? | default "") | str replace $"($task) " "" |
str replace $"($task_name) " "" | str replace $"($server) " "")
($str_task | split row "-" | get -o 0 | default "" | str trim )
}
let other = if ($args | length) > 0 { ($args| skip 1) } else { "" }
let ops = $"($env.PROVISIONING_ARGS? | default "") " | str replace $"($task_name) " "" | str trim
#print "GENEREATE"
# "/wuwei/repo-cnz/src/provisioning/taskservs/oci-reg/generate/defs.toml"
#exit
let run_generate = {
let curr_settings = (settings_with_env $curr_settings)
$env.WK_CNPROV = $curr_settings.wk_path
let arr_task = if $task_name == null or $task_name == "" or $task_name == "-" { [] } else { $task_name | split row "/" }
let match_task = if ($arr_task | length ) == 0 { "" } else { ($arr_task | get -o 0) }
let match_task_profile = if ($arr_task | length ) < 2 { "" } else { ($arr_task | get -o 1) }
let match_server = if $server == null or $server == "" { "" } else { $server}
on_taskservs $curr_settings $match_task $match_task_profile $match_server $iptype $check
}
match $task {
"" if $task_name == "h" => {
^$"($env.PROVISIONING_NAME)" -mod taskserv update help --notitles
},
"" if $task_name == "help" => {
^$"($env.PROVISIONING_NAME)" -mod taskserv update --help
_print (provisioning_options "update")
},
"g" | "generate" | "" => {
let result = desktop_run_notify $"($env.PROVISIONING_NAME) taskservs generate" "-> " $run_generate --timeout 11sec
},
_ => {
if $task_name != "" {_print $"🛑 invalid_option ($task_name)" }
_print $"\nUse (_ansi blue_bold)($env.PROVISIONING_NAME) -h(_ansi reset) for help on commands and options"
}
}
# "" | "generate"
#if not $env.PROVISIONING_DEBUG { end_run "" }
}

138
core/nulib/taskservs/handlers.nu Normal file
View file

@ -0,0 +1,138 @@
use utils.nu *
use lib_provisioning *
use taskservs/run.nu *
#use taskservs/run.nu run_taskserv
def install_from_server [
defs: record
server_taskserv_path: string
wk_server: string
]: nothing -> bool {
_print (
$"(_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) (_ansi default_dimmed)on(_ansi reset) " +
$"($defs.server.hostname) (_ansi default_dimmed)install(_ansi reset) " +
$"(_ansi purple_bold)from ($defs.taskserv_install_mode)(_ansi reset)"
)
(run_taskserv $defs
($env.PROVISIONING_RUN_TASKSERVS_PATH | path join $defs.taskserv.name | path join $server_taskserv_path)
($wk_server | path join $defs.taskserv.name)
)
}
def install_from_library [
defs: record
server_taskserv_path: string
wk_server: string
]: nothing -> bool {
_print (
$"(_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) (_ansi default_dimmed)on(_ansi reset) " +
$"($defs.server.hostname) (_ansi default_dimmed)install(_ansi reset) " +
$"(_ansi purple_bold)from library(_ansi reset)"
)
( run_taskserv $defs
($env.PROVISIONING_TASKSERVS_PATH |path join $defs.taskserv.name | path join $defs.taskserv_profile)
($wk_server | path join $defs.taskserv.name)
)
}
export def on_taskservs [
settings: record
match_taskserv: string
match_taskserv_profile: string
match_server: string
iptype: string
check: bool
]: nothing -> bool {
_print $"Running (_ansi yellow_bold)taskservs(_ansi reset) ..."
if $env.PROVISIONING_SOPS? == null {
# A SOPS load env
$env.CURRENT_INFRA_PATH = ($settings.infra_path | path join $settings.infra)
use sops_env.nu
}
let ip_type = if $iptype == "" { "public" } else { $iptype }
let str_created_taskservs_dirpath = ( $settings.data.created_taskservs_dirpath | default (["/tmp"] | path join) |
str replace "./" $"($settings.src_path)/" | str replace "~" $env.HOME | str replace "NOW" $env.NOW
)
let created_taskservs_dirpath = if ($str_created_taskservs_dirpath | str starts-with "/" ) { $str_created_taskservs_dirpath } else { $settings.src_path | path join $str_created_taskservs_dirpath }
let root_wk_server = ($created_taskservs_dirpath | path join "on-server")
if not ($root_wk_server | path exists ) { ^mkdir "-p" $root_wk_server }
let dflt_clean_created_taskservs = ($settings.data.clean_created_taskservs? | default $created_taskservs_dirpath |
str replace "./" $"($settings.src_path)/" | str replace "~" $env.HOME
)
let run_ops = if $env.PROVISIONING_DEBUG { "bash -x" } else { "" }
$settings.data.servers | enumerate | each {|it|
let server_pos = $it.index
let srvr = $it.item
if $match_server != "" and $srvr.hostname != $match_server { continue }
_print $"on (_ansi green_bold)($srvr.hostname)(_ansi reset) pos ($server_pos) ..."
let clean_created_taskservs = ($settings.data.servers | get -o $server_pos | get -o clean_created_taskservs | default $dflt_clean_created_taskservs )
let ip = if $env.PROVISIONING_DEBUG_CHECK or $check {
"127.0.0.1"
} else {
# use ../../../providers/prov_lib/middleware.nu mw_get_ip
let curr_ip = (mw_get_ip $settings $srvr $ip_type false | default "")
if $curr_ip == "" {
_print $"🛑 No IP ($ip_type) found for (_ansi green_bold)($srvr.hostname)(_ansi reset) ($server_pos) "
continue
}
let network_public_ip = ($srvr | get -o network_public_ip | default "")
if ($network_public_ip | is-not-empty) and $network_public_ip != $curr_ip {
_print $"🛑 IP ($network_public_ip) not equal to ($curr_ip) in (_ansi green_bold)($srvr.hostname)(_ansi reset)"
}
#use utils.nu wait_for_server
if not (wait_for_server $server_pos $srvr $settings $curr_ip) {
_print $"🛑 server ($srvr.hostname) ($curr_ip) (_ansi red_bold)not in running state(_ansi reset)"
continue
}
$curr_ip
}
let server = ($srvr | merge { ip_addresses: { pub: $ip, priv: $srvr.network_private_ip }})
let wk_server = ($root_wk_server | path join $server.hostname)
if ($wk_server | path exists ) { rm -rf $wk_server }
^mkdir "-p" $wk_server
$server.taskservs | enumerate | each {|it|
let taskserv = $it.item
let taskserv_pos = $it.index
if $match_taskserv != "" and $match_taskserv != $taskserv.name { continue }
if $match_taskserv_profile != "" and $match_taskserv_profile != $taskserv.profile { continue }
if not ($env.PROVISIONING_TASKSERVS_PATH | path join $taskserv.name | path exists) {
_print $"taskserv path: ($env.PROVISIONING_TASKSERVS_PATH | path join $taskserv.name) (_ansi red_bold)not found(_ansi reset)"
continue
}
if not ($wk_server | path join $taskserv.name| path exists) { ^mkdir "-p" ($wk_server | path join $taskserv.name) }
let $taskserv_profile = if $taskserv.profile == "" { "default" } else { $taskserv.profile }
let $taskserv_install_mode = if $taskserv.install_mode == "" { "library" } else { $taskserv.install_mode }
let server_taskserv_path = ($server.hostname | path join $taskserv_profile)
let defs = {
settings: $settings, server: $server, taskserv: $taskserv,
taskserv_install_mode: $taskserv_install_mode, taskserv_profile: $taskserv_profile,
pos: { server: $"($server_pos)", taskserv: $taskserv_pos}, ip: $ip, check: $check }
match $taskserv.install_mode {
"server" | "getfile" => {
(install_from_server $defs $server_taskserv_path $wk_server )
},
"library-server" => {
(install_from_library $defs $server_taskserv_path $wk_server)
(install_from_server $defs $server_taskserv_path $wk_server )
},
"server-library" => {
(install_from_server $defs $server_taskserv_path $wk_server )
(install_from_library $defs $server_taskserv_path $wk_server)
},
"library" => {
(install_from_library $defs $server_taskserv_path $wk_server)
},
}
if $clean_created_taskservs == "yes" { rm -rf ($wk_server | pth join $taskserv.name) }
}
if $clean_created_taskservs == "yes" { rm -rf $wk_server }
_print $"Tasks completed on ($server.hostname)"
}
if ("/tmp/k8s_join.sh" | path exists) { cp "/tmp/k8s_join.sh" $root_wk_server ; rm -r /tmp/k8s_join.sh }
if $dflt_clean_created_taskservs == "yes" { rm -rf $root_wk_server }
_print $"✅ Tasks (_ansi green_bold)completed(_ansi reset) ($match_server) ($match_taskserv) ($match_taskserv_profile) ....."
if not $check and ($match_server | is-empty) {
#use utils.nu servers_selector
servers_selector $settings $ip_type false
}
true
}

8
core/nulib/taskservs/mod.nu Normal file
View file

@ -0,0 +1,8 @@
export use create.nu *
export use delete.nu *
export use update.nu *
export use utils.nu *
export use generate.nu *
export use handlers.nu on_taskservs
export use run.nu *
export use ops.nu *

13
core/nulib/taskservs/ops.nu Normal file
View file

@ -0,0 +1,13 @@
export def provisioning_options [
source: string
]: nothing -> string {
(
$"(_ansi blue_bold)($env.PROVISIONING_NAME) server ($source)(_ansi reset) options:\n" +
$"(_ansi blue)($env.PROVISIONING_NAME)(_ansi reset) sed - to edit content from a SOPS file \n" +
$"(_ansi blue)($env.PROVISIONING_NAME)(_ansi reset) ssh - to config and get SSH settings for servers \n" +
$"(_ansi blue)($env.PROVISIONING_NAME)(_ansi reset) list [items] - to list items: " +
$"[ (_ansi green)providers(_ansi reset) p | (_ansi green)tasks(_ansi reset) t | (_ansi green)services(_ansi reset) s ]\n" +
$"(_ansi blue)($env.PROVISIONING_NAME)(_ansi reset) nu - to run a nushell in ($env.PROVISIONING) path\n" +
$"(_ansi blue)($env.PROVISIONING_NAME)(_ansi reset) qr - to get ($env.PROVISIONING_URL) QR code\n"
)
}

330
core/nulib/taskservs/run.nu Normal file
View file

@ -0,0 +1,330 @@
use std
#use utils.nu taskserv_get_file
#use utils/templates.nu on_template_path
def make_cmd_env_temp [
defs: record
taskserv_env_path: string
wk_vars: string
]: nothing -> string {
let cmd_env_temp = $"($taskserv_env_path | path join "cmd_env")_(mktemp --tmpdir-path $taskserv_env_path --suffix ".sh" | path basename)"
($"export PROVISIONING_VARS=($wk_vars)\nexport PROVISIONING_DEBUG=($env.PROVISIONING_DEBUG)\n" +
$"export NU_LOG_LEVEL=($env.NU_LOG_LEVEL)\n" +
$"export PROVISIONING_RESOURCES=($env.PROVISIONING_RESOURCES)\n" +
$"export PROVISIONING_SETTINGS_SRC=($defs.settings.src)\nexport PROVISIONING_SETTINGS_SRC_PATH=($defs.settings.src_path)\n" +
$"export PROVISIONING_KLOUD=($defs.settings.infra)\nexport PROVISIONING_KLOUD_PATH=($defs.settings.infra_path)\n" +
$"export PROVISIONING_USE_SOPS=($env.PROVISIONING_USE_SOPS)\nexport PROVISIONING_WK_ENV_PATH=($taskserv_env_path)\n" +
$"export SOPS_AGE_KEY_FILE=($env.SOPS_AGE_KEY_FILE)\nexport PROVISIONING_KAGE=($env.PROVISIONING_KAGE)\n" +
$"export SOPS_AGE_RECIPIENTS=($env.SOPS_AGE_RECIPIENTS)\n"
) | save --force $cmd_env_temp
if $env.PROVISIONING_DEBUG { _print $"cmd_env_temp: ($cmd_env_temp)" }
$cmd_env_temp
}
def run_cmd [
cmd_name: string
title: string
where: string
defs: record
taskserv_env_path: string
wk_vars: string
]: nothing -> nothing {
_print (
$"($title) for (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) (_ansi default_dimmed)on(_ansi reset) " +
$"($defs.server.hostname) ($defs.pos.server) ..."
)
let runner = (grep "^#!" ($taskserv_env_path | path join $cmd_name) | str trim)
let run_ops = if $env.PROVISIONING_DEBUG { if ($runner | str contains "bash" ) { "-x" } else { "" } } else { "" }
let cmd_run_file = make_cmd_env_temp $defs $taskserv_env_path $wk_vars
if ($cmd_run_file | path exists) and ($wk_vars | path exists) {
if ($runner | str ends-with "bash" ) {
$"($run_ops) ($taskserv_env_path | path join $cmd_name) ($wk_vars) ($defs.pos.server) ($defs.pos.taskserv) (^pwd)" | save --append $cmd_run_file
} else if ($runner | str ends-with "nu" ) {
$"($env.NU) ($env.NU_ARGS) ($taskserv_env_path | path join $cmd_name)" | save --append $cmd_run_file
} else {
$"($taskserv_env_path | path join $cmd_name) ($wk_vars)" | save --append $cmd_run_file
}
let run_res = (^bash $cmd_run_file | complete)
if $run_res.exit_code != 0 {
(throw-error $"🛑 Error server ($defs.server.hostname) taskserv ($defs.taskserv.name)
($taskserv_env_path)/($cmd_name) with ($wk_vars) ($defs.pos.server) ($defs.pos.taskserv) (^pwd)"
$"($run_res.stdout)\n($run_res.stderr)\n"
$where --span (metadata $run_res).span)
exit 1
}
if $env.PROVISIONING_DEBUG {
if ($run_res.stdout | is-not-empty) { _print $"($run_res.stdout)" }
if ($run_res.stderr | is-not-empty) { _print $"($run_res.stderr)" }
} else {
rm -f $cmd_run_file
rm -f ($taskserv_env_path | path join "prepare")
}
}
}
export def run_taskserv_library [
defs: record
taskserv_path: string
taskserv_env_path: string
wk_vars: string
]: nothing -> bool {
if not ($taskserv_path | path exists) { return false }
let prov_resources_path = ($defs.settings.data.prov_resources_path | default "" | str replace "~" $env.HOME)
let taskserv_server_name = $defs.server.hostname
rm -rf ...(glob ($taskserv_env_path | path join "*.k")) ($taskserv_env_path |path join "kcl")
mkdir ($taskserv_env_path | path join "kcl")
let err_out = ($taskserv_env_path | path join (mktemp --tmpdir-path $taskserv_env_path --suffix ".err" | path basename))
let kcl_temp = ($taskserv_env_path | path join "kcl"| path join (mktemp --tmpdir-path $taskserv_env_path --suffix ".k" | path basename))
let wk_format = if $env.PROVISIONING_WK_FORMAT == "json" { "json" } else { "yaml" }
let wk_data = { # providers: $defs.settings.providers,
defs: $defs.settings.data,
pos: $defs.pos,
server: $defs.server
}
if $wk_format == "json" {
$wk_data | to json | save --force $wk_vars
} else {
$wk_data | to yaml | save --force $wk_vars
}
if $env.PROVISIONING_USE_KCL {
cd ($defs.settings.infra_path | path join $defs.settings.infra)
if ($kcl_temp | path exists) { rm -f $kcl_temp }
let res = (^kcl import -m $wk_format $wk_vars -o $kcl_temp | complete)
if $res.exit_code != 0 {
_print $"❗KCL import (_ansi red_bold)($wk_vars)(_ansi reset) Errors found "
_print $res.stdout
rm -f $kcl_temp
cd $env.PWD
return false
}
# Very important! Remove external block for import and re-format it
# ^sed -i "s/^{//;s/^}//" $kcl_temp
open $kcl_temp -r | lines | find -v --regex "^{" | find -v --regex "^}" | save -f $kcl_temp
let res = (^kcl fmt $kcl_temp | complete)
let kcl_taskserv_path = if ($taskserv_path | path join "kcl"| path join $"($defs.taskserv.name).k" | path exists) {
($taskserv_path | path join "kcl"| path join $"($defs.taskserv.name).k")
} else if ($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.name).k" | path exists) {
($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.name).k")
} else if ($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.name).k" | path exists) {
($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.name).k")
} else { "" }
if $kcl_taskserv_path != "" and ($kcl_taskserv_path | path exists) {
if $env.PROVISIONING_DEBUG {
_print $"adding task name: ($defs.taskserv.name) -> ($kcl_taskserv_path)"
}
cat $kcl_taskserv_path | save --append $kcl_temp
}
let kcl_taskserv_profile_path = if ($taskserv_path | path join "kcl"| path join $"($defs.taskserv.profile).k" | path exists) {
($taskserv_path | path join "kcl"| path join $"($defs.taskserv.profile).k")
} else if ($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.profile).k" | path exists) {
($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.profile).k")
} else if ($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.profile).k" | path exists) {
($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.profile).k")
} else { "" }
if $kcl_taskserv_profile_path != "" and ($kcl_taskserv_profile_path | path exists) {
if $env.PROVISIONING_DEBUG {
_print $"adding task profile: ($defs.taskserv.profile) -> ($kcl_taskserv_profile_path)"
}
cat $kcl_taskserv_profile_path | save --append $kcl_temp
}
if $env.PROVISIONING_KEYS_PATH != "" {
#use sops on_sops
let keys_path = ($defs.settings.src_path | path join $env.PROVISIONING_KEYS_PATH)
if not ($keys_path | path exists) {
if $env.PROVISIONING_DEBUG {
_print $"❗Error KEYS_PATH (_ansi red_bold)($keys_path)(_ansi reset) found "
} else {
_print $"❗Error (_ansi red_bold)KEYS_PATH(_ansi reset) not found "
}
return false
}
(on_sops d $keys_path) | save --append $kcl_temp
let kcl_defined_taskserv_path = if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.profile).k" | path exists ) {
($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.profile).k")
} else if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.profile).k" | path exists ) {
($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.profile).k")
} else if ($defs.settings.src_path | path join "taskservs" | path join $"($defs.taskserv.profile).k" | path exists ) {
($defs.settings.src_path | path join "taskservs" | path join $"($defs.taskserv.profile).k")
} else if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.name).k" | path exists ) {
($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.name).k")
} else if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $defs.taskserv.profile | path join $"($defs.taskserv.name).k" | path exists ) {
($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $defs.taskserv.profile | path join $"($defs.taskserv.name).k")
} else if ($defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).k" | path exists ) {
($defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).k")
} else { "" }
if $kcl_defined_taskserv_path != "" and ($kcl_defined_taskserv_path | path exists) {
if $env.PROVISIONING_DEBUG {
_print $"adding defs taskserv: ($kcl_defined_taskserv_path)"
}
cat $kcl_defined_taskserv_path | save --append $kcl_temp
}
let res = (^kcl $kcl_temp -o $wk_vars | complete)
if $res.exit_code != 0 {
_print $"❗KCL errors (_ansi red_bold)($kcl_temp)(_ansi reset) found "
_print $res.stdout
_print $res.stderr
rm -f $wk_vars
cd $env.PWD
return false
}
rm -f $kcl_temp $err_out
} else if ( $defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).yaml" | path exists) {
cat ($defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).yaml") | tee { save -a $wk_vars } | ignore
}
cd $env.PWD
}
(^sed -i $"s/NOW/($env.NOW)/g" $wk_vars)
if $defs.taskserv_install_mode == "library" {
let taskserv_data = (open $wk_vars)
let quiet = if $env.PROVISIONING_DEBUG { false } else { true }
if $taskserv_data.taskserv? != null and $taskserv_data.taskserv.copy_paths? != null {
#use utils/files.nu *
for it in $taskserv_data.taskserv.copy_paths {
let it_list = ($it | split row "|" | default [])
let cp_source = ($it_list | get -o 0 | default "")
let cp_target = ($it_list | get -o 1 | default "")
if ($cp_source | path exists) {
copy_prov_files $cp_source "." ($taskserv_env_path | path join $cp_target) false $quiet
} else if ($prov_resources_path | path join $cp_source | path exists) {
copy_prov_files $prov_resources_path $cp_source ($taskserv_env_path | path join $cp_target) false $quiet
} else if ($"($prov_resources_path)/($cp_source)" | path exists) {
copy_prov_file ($prov_resources_path | path join $cp_source) ($taskserv_env_path | path join $cp_target) $quiet
}
}
}
}
rm -f ($taskserv_env_path | path join "kcl") ...(glob $"($taskserv_env_path)/*.k")
on_template_path $taskserv_env_path $wk_vars true true
if ($taskserv_env_path | path join $"env-($defs.taskserv.name)" | path exists) {
^sed -i 's,\t,,g;s,^ ,,g;/^$/d' ($taskserv_env_path | path join $"env-($defs.taskserv.name)")
}
if ($taskserv_env_path | path join "prepare" | path exists) {
run_cmd "prepare" "prepare" "run_taskserv_library" $defs $taskserv_env_path $wk_vars
if ($taskserv_env_path | path join "resources" | path exists) {
on_template_path ($taskserv_env_path | path join "resources") $wk_vars false true
}
}
if not $env.PROVISIONING_DEBUG {
rm -f ...(glob $"($taskserv_env_path)/*.j2") $err_out $kcl_temp
}
true
}
export def run_taskserv [
defs: record
taskserv_path: string
env_path: string
]: nothing -> bool {
if not ($taskserv_path | path exists) { return false }
let prov_resources_path = ($defs.settings.data.prov_resources_path | default "" | str replace "~" $env.HOME)
let taskserv_server_name = $defs.server.hostname
let str_created_taskservs_dirpath = ($defs.settings.data.created_taskservs_dirpath | default "/tmp" |
str replace "~" $env.HOME | str replace "NOW" $env.NOW | str replace "./" $"($defs.settings.src_path)/")
let created_taskservs_dirpath = if ($str_created_taskservs_dirpath | str starts-with "/" ) { $str_created_taskservs_dirpath } else { $defs.settings.src_path | path join $str_created_taskservs_dirpath }
if not ( $created_taskservs_dirpath | path exists) { ^mkdir -p $created_taskservs_dirpath }
let str_taskserv_env_path = if $defs.taskserv_install_mode == "server" { $"($env_path)_($defs.taskserv_install_mode)" } else { $env_path }
let taskserv_env_path = if ($str_taskserv_env_path | str starts-with "/" ) { $str_taskserv_env_path } else { $defs.settings.src_path | path join $str_taskserv_env_path }
if not ( $taskserv_env_path | path exists) { ^mkdir -p $taskserv_env_path }
(^cp -pr ...(glob ($taskserv_path | path join "*")) $taskserv_env_path)
rm -rf ...(glob ($taskserv_env_path | path join "*.k")) ($taskserv_env_path | path join "kcl")
let wk_vars = ($created_taskservs_dirpath | path join $"($defs.server.hostname).yaml")
let require_j2 = (^ls ...(glob ($taskserv_env_path | path join "*.j2")) err> (if $nu.os-info.name == "windows" { "NUL" } else { "/dev/null" }))
let res = if $defs.taskserv_install_mode == "library" or $require_j2 != "" {
(run_taskserv_library $defs $taskserv_path $taskserv_env_path $wk_vars)
}
if not $res {
if not $env.PROVISIONING_DEBUG { rm -f $wk_vars }
return $res
}
let err_out = ($env_path | path join (mktemp --tmpdir-path $env_path --suffix ".err") | path basename)
let tar_ops = if $env.PROVISIONING_DEBUG { "v" } else { "" }
let bash_ops = if $env.PROVISIONING_DEBUG { "bash -x" } else { "" }
let res_tar = (^tar -C $taskserv_env_path $"-c($tar_ops)zmf" (["/tmp" $"($defs.taskserv.name).tar.gz"] | path join) . | complete)
if $res_tar.exit_code != 0 {
_print (
$"🛑 Error (_ansi red_bold)tar taskserv(_ansi reset) server (_ansi green_bold)($defs.server.hostname)(_ansi reset)" +
$" taskserv (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) ($taskserv_env_path) -> (['/tmp' $'($defs.taskserv.name).tar.gz'] | path join)"
)
return false
}
if $defs.check {
if not $env.PROVISIONING_DEBUG {
rm -f $wk_vars
if $err_out != "" { rm -f $err_out }
rm -rf ...(glob $"($taskserv_env_path)/*.k") ($taskserv_env_path | path join join "kcl")
}
return true
}
let is_local = (^ip addr | grep "inet " | grep "$defs.ip")
if $is_local != "" and not $env.PROVISIONING_DEBUG_CHECK {
if $defs.taskserv_install_mode == "getfile" {
if (taskserv_get_file $defs.settings $defs.taskserv $defs.server $defs.ip true true) { return false }
return true
}
rm -rf (["/tmp" $defs.taskserv.name ] | path join)
mkdir (["/tmp" $defs.taskserv.name ] | path join)
cd (["/tmp" $defs.taskserv.name ] | path join)
tar x($tar_ops)zmf (["/tmp" $"($defs.taskserv.name).tar.gz"] | path join)
let res_run = (^sudo $bash_ops $"./install-($defs.taskserv.name).sh" err> $err_out | complete)
if $res_run.exit_code != 0 {
(throw-error $"🛑 Error server ($defs.server.hostname) taskserv ($defs.taskserv.name)
./install-($defs.taskserv.name).sh ($defs.server_pos) ($defs.taskserv_pos) (^pwd)"
$"($res_run.stdout)\n(cat $err_out)"
"run_taskserv_library" --span (metadata $res_run).span)
exit 1
}
fi
rm -fr (["/tmp" $"($defs.taskserv.name).tar.gz"] | path join) (["/tmp" $"($defs.taskserv.name)"] | path join)
} else {
if $defs.taskserv_install_mode == "getfile" {
if (taskserv_get_file $defs.settings $defs.taskserv $defs.server $defs.ip true false) { return false }
return true
}
if not $env.PROVISIONING_DEBUG_CHECK {
#use ssh.nu *
let scp_list: list<string> = ([] | append $"/tmp/($defs.taskserv.name).tar.gz")
if not (scp_to $defs.settings $defs.server $scp_list "/tmp" $defs.ip) {
_print (
$"🛑 Error (_ansi red_bold)ssh_to(_ansi reset) server (_ansi green_bold)($defs.server.hostname)(_ansi reset) [($defs.ip)] " +
$" taskserv (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) /tmp/($defs.taskserv.name).tar.gz"
)
return false
}
# $"rm -rf /tmp/($defs.taskserv.name); mkdir -p /tmp/($defs.taskserv.name) ;" +
let run_ops = if $env.PROVISIONING_DEBUG { "bash -x" } else { "" }
let cmd = (
$"rm -rf /tmp/($defs.taskserv.name); mkdir -p /tmp/($defs.taskserv.name) ;" +
$" cd /tmp/($defs.taskserv.name) ; sudo tar x($tar_ops)zmf /tmp/($defs.taskserv.name).tar.gz &&" +
$" sudo ($run_ops) ./install-($defs.taskserv.name).sh " # ($env.PROVISIONING_MATCH_CMD) "
)
if not (ssh_cmd $defs.settings $defs.server false $cmd $defs.ip) {
_print (
$"🛑 Error (_ansi red_bold)ssh_cmd(_ansi reset) server (_ansi green_bold)($defs.server.hostname)(_ansi reset) [($defs.ip)] " +
$" taskserv (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) install_($defs.taskserv.name).sh"
)
return false
}
if not $env.PROVISIONING_DEBUG {
let rm_cmd = $"sudo rm -f /tmp/($defs.taskserv.name).tar.gz; sudo rm -rf /tmp/($defs.taskserv.name)"
let _res = (ssh_cmd $defs.settings $defs.server false $rm_cmd $defs.ip)
rm -f $"/tmp/($defs.taskserv.name).tar.gz"
}
}
}
if ($taskserv_path | path join "postrun" | path exists ) {
cp ($taskserv_path | path join "postrun") ($taskserv_env_path | path join "postrun")
run_cmd "postrun" "PostRune" "run_taskserv_library" $defs $taskserv_env_path $wk_vars
}
if not $env.PROVISIONING_DEBUG {
rm -f $wk_vars
if $err_out != "" { rm -f $err_out }
rm -rf ...(glob $"($taskserv_env_path)/*.k") ($taskserv_env_path | path join join "kcl")
}
true
}

79
core/nulib/taskservs/update.nu Normal file
View file

@ -0,0 +1,79 @@
use lib_provisioning *
use utils.nu *
use handlers.nu *
use ../lib_provisioning/utils/ssh.nu *
# Provider middleware now available through lib_provisioning
# > TaskServs update
export def "main update" [
name?: string # task in settings
server?: string # Server hostname in settings
...args # Args for update command
--infra (-i): string # Infra directory
--settings (-s): string # Settings path
--iptype: string = "public" # Ip type to connect
--outfile (-o): string # Output file
--taskserv_pos (-p): int # Server position in settings
--check (-c) # Only check mode no taskservs will be created
--wait (-w) # Wait taskservs to be updated
--select: string # Select with task as option
--debug (-x) # Use Debug mode
--xm # Debug with PROVISIONING_METADATA
--xc # Debuc for task and services locally PROVISIONING_DEBUG_CHECK
--xr # Debug for remote taskservs PROVISIONING_DEBUG_REMOTE
--xld # Log level with DEBUG PROVISIONING_LOG_LEVEL=debug
--metadata # Error with metadata (-xm)
--notitles # not tittles
--helpinfo (-h) # For more details use options "help" (no dashes)
--out: string # Print Output format: json, yaml, text (default)
]: nothing -> nothing {
if ($out | is-not-empty) {
$env.PROVISIONING_OUT = $out
$env.PROVISIONING_NO_TERMINAL = true
}
provisioning_init $helpinfo "taskserv update" $args
if $debug { $env.PROVISIONING_DEBUG = true }
if $metadata { $env.PROVISIONING_METADATA = true }
let curr_settings = (find_get_settings --infra $infra --settings $settings)
let task = if ($args | length) > 0 {
($args| get 0)
} else {
let str_task = (($env.PROVISIONING_ARGS? | default "") | str replace "update " " " )
let str_task = if $name != null {
($str_task | str replace $name "")
} else {
$str_task
}
($str_task | str trim | split row " " | get -o 0 | default "" |
split row "-" | get -o 0 | default "" | str trim )
}
let other = if ($args | length) > 0 { ($args| skip 1) } else { "" }
let ops = $"($env.PROVISIONING_ARGS? | default "") " | str replace $"($task) " "" | str trim
let run_update = {
let curr_settings = (settings_with_env (find_get_settings --infra $infra --settings $settings))
$env.WK_CNPROV = $curr_settings.wk_path
let arr_task = if $name == null or $name == "" or $name == $task { [] } else { $name | split row "/" }
let match_task = if ($arr_task | length ) == 0 { "" } else { ($arr_task | get -o 0) }
let match_task_profile = if ($arr_task | length ) < 2 { "" } else { ($arr_task | get -o 1) }
let match_server = if $server == null or $server == "" { "" } else { $server}
on_taskservs $curr_settings $match_task $match_task_profile $match_server $iptype $check
}
match $task {
"" if $name == "h" => {
^$"($env.PROVISIONING_NAME)" -mod taskserv update help --notitles
},
"" if $name == "help" => {
^$"($env.PROVISIONING_NAME)" -mod taskserv update --help
print (provisioning_options "update")
},
"" | "u" | "update" => {
let result = desktop_run_notify $"($env.PROVISIONING_NAME) taskservs update" "-> " $run_update --timeout 11sec
#do $run_update
},
_ => {
if $task != "" { print $"🛑 invalid_option ($task)" }
_print $"\nUse (_ansi blue_bold)($env.PROVISIONING_NAME) -h(_ansi reset) for help on commands and options"
}
}
if not $env.PROVISIONING_DEBUG { end_run "" }
}

114
core/nulib/taskservs/utils.nu Normal file
View file

@ -0,0 +1,114 @@
use ../lib_provisioning/utils/ssh.nu *
use ../lib_provisioning/defs/lists.nu *
use lib_provisioning *
export def taskserv_get_file [
settings: record
taskserv: record
server: record
live_ip: string
req_sudo: bool
local_mode: bool
]: nothing -> bool {
let target_path = ($taskserv.target_path | default "")
if $target_path == "" {
_print $"🛑 No (_ansi red_bold)target_path(_ansi reset) found in ($server.hostname) taskserv ($taskserv.name)"
return false
}
let source_path = ($taskserv.soruce_path | default "")
if $source_path == "" {
_print $"🛑 No (_ansi red_bold)source_path(_ansi reset) found in ($server.hostname) taskserv ($taskserv.name)"
return false
}
if $local_mode {
let res = (^cp $source_path $target_path | combine)
if $res.exit_code != 0 {
_print $"🛑 Error get_file [ local-mode ] (_ansi red_bold)($source_path) to ($target_path)(_ansi reset) in ($server.hostname) taskserv ($taskserv.name)"
_print $res.stdout
return false
}
return true
}
let ip = if $live_ip != "" {
$live_ip
} else {
#use ../../../providers/prov_lib/middleware.nu mw_get_ip
(mw_get_ip $settings $server $server.liveness_ip false)
}
let ssh_key_path = ($server.ssh_key_path | default "")
if $ssh_key_path == "" {
_print $"🛑 No (_ansi red_bold)ssh_key_path(_ansi reset) found in ($server.hostname) taskserv ($taskserv.name)"
return false
}
if not ($ssh_key_path | path exists) {
_print $"🛑 Error (_ansi red_bold)($ssh_key_path)(_ansi reset) not found for ($server.hostname) taskserv ($taskserv.name)"
return false
}
mut cmd = if $req_sudo { "sudo" } else { "" }
let wk_path = $"/home/($env.SSH_USER)/($source_path | path basename)"
$cmd = $"($cmd) cp ($source_path) ($wk_path); sudo chown ($env.SSH_USER) ($wk_path)"
let res = (ssh_cmd $settings $server false $cmd $ip)
if not $res { return false }
if not (scp_from $settings $server $wk_path $target_path $ip ) {
return false
}
let rm_cmd = if $req_sudo {
$"sudo rm -f ($wk_path)"
} else {
$"rm -f ($wk_path)"
}
return ( ssh_cmd $settings $server false $rm_cmd $ip )
}
export def find_taskserv [
settings: record,
server: record,
taskserv_name: string,
out: string
]: nothing -> record {
let taskserv = ($server | get -o taskservs | where {|t| ($t | get -o name | default "") == $taskserv_name} | get -o 0 | default {} )
if ($taskserv | is-empty) {
_print $"🛑 No taskserv found" $"for (_ansi yellow_bold)($taskserv_name)(_ansi reset)"
return ""
}
let src_path = ($settings | get -o src_path | default "")
let hostname = ($server | get -o hostname | default "")
mut taskserv_host_path = ($src_path | path join $env.PROVISIONING_RUN_TASKSERVS_PATH |
path join $hostname | path join $"($taskserv_name).k")
let def_taskserv = if ($taskserv_host_path | path exists) {
(open -r $taskserv_host_path)
} else {
$taskserv_host_path = ($src_path | path join $env.PROVISIONING_RUN_TASKSERVS_PATH | path join $"($taskserv_name).k")
if ($taskserv_host_path | path exists) {
(open -r $taskserv_host_path)
} else {
_print $"🛑 No taskserv path found" $"for (_ansi yellow_bold)($taskserv_name)(_ansi reset) in ($taskserv_host_path)"
$taskserv_host_path = ""
""
}
}
mut main_taskserv_path = ($env.PROVISIONING_TASKSERVS_PATH | path join $taskserv_name | path join "kcl" | path join $"($taskserv_name).k")
if not ($main_taskserv_path | path exists) {
$main_taskserv_path = ($env.PROVISIONING_TASKSERVS_PATH | path join $taskserv_name | path join ($taskserv |
get -o profile | default "") | path join "kcl" | path join $"($taskserv_name).k")
}
let def_main = if ($main_taskserv_path | path exists) {
(open -r $main_taskserv_path)
} else {
_print $"🛑 No taskserv main path found" $"for (_ansi yellow_bold)($taskserv_name)(_ansi reset) ($main_taskserv_path)"
$main_taskserv_path = ""
""
}
{ path_def: $taskserv_host_path, def: $def_taskserv, path_main: $main_taskserv_path, main: $def_main }
}
export def list_taskservs [
settings: record
]: nothing -> list {
let list_taskservs = (taskservs_list)
if ($list_taskservs | length) == 0 {
_print $"🛑 no items found for (_ansi cyan)taskservs list(_ansi reset)"
return
}
$list_taskservs
}