210 lines
7.9 KiB
Plaintext
210 lines
7.9 KiB
Plaintext
|
|
#use utils *
|
|
#use defs *
|
|
use lib_provisioning *
|
|
|
|
# - > Query infrastructure and services
|
|
export def "main generate" [
|
|
#hostname?: string # Server hostname in settings
|
|
...args # Args for create command
|
|
--infra (-i): string # Infra path
|
|
--settings (-s): string # Settings path
|
|
--serverpos (-p): int # Server position in settings
|
|
--check (-c) # Only check mode no servers will be created
|
|
--wait (-w) # Wait servers to be created
|
|
--outfile: string # Optional output format: json | yaml | csv | text | md | nuon
|
|
--find (-f): string # Optional generate find a value (empty if no value found)
|
|
--cols (-l): string # Optional generate columns list separated with comma
|
|
--template(-t): string # Template path or name in PROVISION_KLOUDS_PATH
|
|
--ips # Optional generate get IPS only for target "servers-info"
|
|
--prov: string # Optional provider name to filter generate
|
|
--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
|
|
}
|
|
if $helpinfo {
|
|
_print (provisioning_generate_options)
|
|
if not $env.PROVISIONING_DEBUG { end_run "" }
|
|
exit
|
|
}
|
|
parse_help_command "generate" --end
|
|
if $debug { $env.PROVISIONING_DEBUG = true }
|
|
#use defs [ load_settings ]
|
|
let curr_settings = if $infra != null {
|
|
if $settings != null {
|
|
(load_settings --infra $infra --settings $settings)
|
|
} else {
|
|
(load_settings --infra $infra)
|
|
}
|
|
} else {
|
|
if $settings != null {
|
|
(load_settings --settings $settings)
|
|
} else {
|
|
(load_settings false true)
|
|
}
|
|
}
|
|
#let cmd_template = if ($template | is-empty ) {
|
|
# ($args | get -o 0 | default "")
|
|
#} else { $template }
|
|
#let str_out = if $outfile == null { "none" } else { $outfile }
|
|
let str_out = if $out == null { "" } else { $out }
|
|
let str_cols = if $cols == null { "" } else { $cols }
|
|
let str_find = if $find == null { "" } else { $find }
|
|
let str_template = if $template == null { "" } else { $template }
|
|
let cmd_target = if ($args | length) > 0 { ($args| get 0) } else { "" }
|
|
$env.PROVISIONING_MODULE = "generate"
|
|
let ops = $"($env.PROVISIONING_ARGS? | default "") " | str replace $env.PROVISIONING_MODULE "" | str replace $" ($cmd_target) " "" | str trim
|
|
#generate_provision $args $curr_settings $str_template
|
|
match $cmd_target {
|
|
"new" | "n" => {
|
|
let args_list = if ($args | length) > 0 {
|
|
($args| skip 1)
|
|
} else { [] }
|
|
generate_provision $args_list $curr_settings $str_template
|
|
},
|
|
"server" | "servers" => {
|
|
#use utils/format.nu datalist_to_format
|
|
_print (datalist_to_format $str_out
|
|
(mw_generate_servers $curr_settings $str_find $cols --prov $prov --serverpos $serverpos)
|
|
)
|
|
},
|
|
"server-status" | "servers-status" | "server-info" | "servers-info" => {
|
|
let list_cols = if ($cmd_target | str contains "status") {
|
|
if ($str_cols | str contains "state") { $str_cols } else { $str_cols + ",state" }
|
|
} else {
|
|
$str_cols
|
|
}
|
|
# not use $str_cols to filter previous $ips selection
|
|
(out_data_generate_info
|
|
$curr_settings
|
|
(mw_servers_info $curr_settings $str_find --prov $prov --serverpos $serverpos)
|
|
#(mw_servers_info $curr_settings $find $cols --prov $prov --serverpos $serverpos)
|
|
$list_cols
|
|
$str_out
|
|
$ips
|
|
)
|
|
},
|
|
"servers-def" | "server-def" => {
|
|
let data = if $str_find != "" { ($curr_settings.data.servers | find $find) } else { $curr_settings.data.servers}
|
|
(out_data_generate_info
|
|
$curr_settings
|
|
$data
|
|
$str_cols
|
|
$str_out
|
|
false
|
|
)
|
|
},
|
|
"def" | "defs" => {
|
|
let data = if $str_find != "" { ($curr_settings.data | find $find) } else { $curr_settings.data}
|
|
(out_data_generate_info
|
|
$curr_settings
|
|
[ $data ]
|
|
$str_cols
|
|
$str_out
|
|
false
|
|
)
|
|
}
|
|
_ => {
|
|
(throw-error $"🛑 ($env.PROVISIONING_NAME) generate " $"Invalid option (_ansi red)($cmd_target)(_ansi reset)"
|
|
$"($env.PROVISIONING_NAME) generate --target ($cmd_target)" --span (metadata $cmd_target).span
|
|
)
|
|
}
|
|
}
|
|
cleanup ($curr_settings | get -o wk_path | default "")
|
|
if $outfile == null { end_run "generate" }
|
|
}
|
|
|
|
export def generate_new_infra [
|
|
args: list
|
|
template: string
|
|
]: nothing -> record {
|
|
let infra_path = ($args | get -o 0 | default "")
|
|
let infra_name = ($infra_path | path basename)
|
|
let target_path = if ($infra_path | str contains "/") {
|
|
$infra_path
|
|
} else if ($env.PROVISIONING_INFRA_PATH | path exists) and not ($env.PROVISIONING_INFRA_PATH | path join $infra_path | path exists) {
|
|
($env.PROVISIONING_INFRA_PATH | path join $infra_path)
|
|
} else {
|
|
$infra_path
|
|
}
|
|
if ($target_path | path exists) {
|
|
_print $"🛑 Path (_ansi yellow_bold)($target_path)(_ansi reset) already exits"
|
|
return
|
|
}
|
|
^mkdir -p $target_path
|
|
_print $"(_ansi green)($infra_name)(_ansi reset) created in (_ansi green)($target_path | path dirname)(_ansi reset)"
|
|
_print $"(_ansi green)($infra_name)(_ansi reset) ... "
|
|
let template_path = if ($template | is-empty) {
|
|
($env.PROVISIONING | path join $env.PROVISIONING_GENERATE_DIRPATH | path join "default")
|
|
} else if ($template | str contains "/") and ($template | path exists) {
|
|
$template
|
|
} else if ($env.PROVISIONING_INFRA_PATH | path join $template | path exists) {
|
|
($env.PROVISIONING_INFRA_PATH | path join $template)
|
|
}
|
|
let new_created = if not ($target_path | path join "settings.k" | path exists) {
|
|
^cp -pr ...(glob ($template_path | path join "*")) ($target_path)
|
|
_print $"copy (_ansi green)($template)(_ansi reset) to (_ansi green)($infra_name)(_ansi reset)"
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
{ path: $target_path, name: $infra_name, created: $new_created }
|
|
}
|
|
export def generate_provision [
|
|
args: list
|
|
settings: record
|
|
template: string
|
|
]: nothing -> nothing {
|
|
let generated_infra = if ($settings | is-empty) {
|
|
if ($args | is-empty) {
|
|
(throw-error $"🛑 ($env.PROVISIONING_NAME) generate " $"Invalid option (_ansi red)no settings and path found(_ansi reset)"
|
|
$"($env.PROVISIONING_NAME) generate " --span (metadata $settings).span
|
|
)
|
|
} else {
|
|
generate_new_infra $args $template
|
|
}
|
|
}
|
|
if ($generated_infra | is-empty) {
|
|
(throw-error $"🛑 ($env.PROVISIONING_NAME) generate " $"Invalid option (_ansi red)no settings and path found(_ansi reset)"
|
|
$"($env.PROVISIONING_NAME) generate " --span (metadata $settings).span
|
|
)
|
|
}
|
|
generate_data_def $env.PROVISIONING $generated_infra.name $generated_infra.path $generated_infra.created
|
|
}
|
|
def out_data_generate_info [
|
|
settings: record
|
|
data: list
|
|
cols: string
|
|
outfile: string
|
|
ips: bool
|
|
]: nothing -> nothing {
|
|
if ($data | get -o 0 | is-empty) {
|
|
if $env.PROVISIONING_DEBUG { print $"🛑 ($env.PROVISIONING_NAME) generate (_ansi red)no data found(_ansi reset)" }
|
|
_print ""
|
|
return
|
|
}
|
|
let sel_data = if ($cols | is-not-empty) {
|
|
$data | select -o ($cols | split row ",")
|
|
} else {
|
|
$data
|
|
}
|
|
#use ../../../providers/prov_lib/middleware.nu mw_servers_ips
|
|
#use utils/format.nu datalist_to_format
|
|
print (datalist_to_format $outfile $sel_data)
|
|
# let data_ips = (($data).ip_addresses? | flatten | find "public")
|
|
if $ips {
|
|
let ips_result = (mw_servers_ips $settings $data)
|
|
print $ips_result
|
|
}
|
|
}
|