provisioning/core/nulib/servers/create.nu

use std
use lib_provisioning *
use utils.nu *
#use utils.nu on_server_template
use ssh.nu *
use ../lib_provisioning/utils/ssh.nu *
# Provider middleware now available through lib_provisioning

# > Server create
export def "main create" [
    name?: string       # Server hostname in settings
    ...args                 # Args for create command
    --infra (-i): string     # Infra directory
    --settings (-s): string # Settings path
    --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 "servers create" $args
    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 "create " " " )
        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_create = {
        let curr_settings = (find_get_settings --infra $infra --settings $settings)
        $env.WK_CNPROV = $curr_settings.wk_path
        let match_name = if $name == null or $name == "" { "" } else { $name}
        on_create_servers $curr_settings $check $wait $outfile $match_name $serverpos
    }
    match $task {
        "" if $name == "h" => {
            ^$"($env.PROVISIONING_NAME)" -mod server create help --notitles
        },
        "" if $name == "help" => {
            ^$"($env.PROVISIONING_NAME)" -mod server create --help
            _print (provisioning_options "create")
        },
        "" | "c" | "create" => {
            let result = desktop_run_notify $"($env.PROVISIONING_NAME) servers create" "-> " $run_create --timeout 11sec
            if not ($result | get -o status | default true) { exit 1 }
        },
        _ => {
            invalid_task "servers create" $task --end
        }
    }
    if not $notitles and not $env.PROVISIONING_DEBUG { end_run "" }
}
export def on_create_servers [
    settings: record   # Settings record
    check: bool        # Only check mode no servers will be created
    wait: bool         # Wait for creation
    outfile?: string   # Out file for creation
    hostname?: string  # Server hostname in settings
    serverpos?: int    # Server position in settings
    --notitles       # not tittles
]: nothing -> record {
    let match_hostname = if $hostname != null {
        $hostname
    } else if $serverpos != null  {
        let total = $settings.data.servers | length
        let pos = if $serverpos == -1 {
            _print $"Use number form 0 to ($total)"
            $serverpos
        } else if $serverpos <= $total {
            $serverpos - 0
        } else {
            (throw-error $"🛑 server pos" $"($serverpos) from ($total) servers"
                "on_create" --span (metadata $serverpos).span)
            exit 0
        }
        ($settings.data.servers | get $pos).hostname
    }
    #use ../../../providers/prov_lib/middleware.nu  mw_create_server
    # Check servers ... reload settings if are changes
    for server in $settings.data.servers {
        if $match_hostname == null or $match_hostname == "" or $server.hostname == $match_hostname  {
            if (mw_create_server $settings $server $check false) == false {
                return { status: false, error: $"mw_create_sever ($server.hostname) error" }
            }
        }
    }
    let ok_settings = if ($"($settings.wk_path)/changes" | path exists) {
        if $env.PROVISIONING_DEBUG == false {
            _print $"(_ansi blue_bold)Reloading settings(_ansi reset) for (_ansi cyan_bold)($settings.infra)(_ansi reset) (_ansi purple)($settings.src)(_ansi reset)"
            cleanup $settings.wk_path
        } else {
            _print $"(_ansi blue_bold)Review (_ansi green)($settings.wk_path)/changes(_ansi reset) for (_ansi cyan_bold)($settings.infra)(_ansi reset) (_ansi purple)($settings.src)(_ansi reset)"
            _print $"(_ansi green)($settings.wk_path)(_ansi reset) (_ansi red)not deleted(_ansi reset) for debug"
        }
        #use utils/settings.nu [ load_settings ]
        (load_settings --infra $settings.infra --settings $settings.src)
    } else {
        $settings
    }
    let out_file = if $outfile == null { "" } else { $outfile  }
    let target_servers = ($ok_settings.data.servers | where {|it|
        $match_hostname == null or $match_hostname == "" or $it.hostname == $match_hostname
    })
    if $check {
        $target_servers | enumerate | each {|it|
            if not (create_server $it.item $it.index true $wait $ok_settings $out_file) {  return false }
            _print $"\n(_ansi blue_reverse)----🌥 ----🌥 ----🌥 ---- oOo ----🌥 ----🌥 ----🌥 ---- (_ansi reset)\n"
        }
    } else {
        _print $"Create (_ansi blue_bold)($target_servers | length)(_ansi reset) servers in parallel (_ansi blue_bold)>>> 🌥  >>> (_ansi reset)\n"
        $target_servers | enumerate | par-each {|it|
                    if not (create_server $it.item $it.index false $wait $ok_settings $out_file)  {
                return { status: false, error: $"creation ($it.item.hostname) error" }
            }  else {
                let known_hosts_path = (("~" | path join ".ssh" | path join "known_hosts") | path expand)
                ^ssh-keygen -f $known_hosts_path -R $it.item.hostname err> (if $nu.os-info.name == "windows" { "NUL" } else { "/dev/null" })
                if ($it.item | get -o network_public_ip | is-not-empty) {
                    ^ssh-keygen -f $known_hosts_path -R ($it.item | get -o network_public_ip) err> (if $nu.os-info.name == "windows" { "NUL" } else { "/dev/null" })
                }
            }
            _print $"\n(_ansi blue_reverse)----🌥 ----🌥 ----🌥 ---- oOo ----🌥 ----🌥 ----🌥 ---- (_ansi reset)\n"
        }
    }
    if not $check {
        # Running this in 'par-each' does not work
        $target_servers | enumerate | each { |it|
            mw_create_cache $ok_settings $it.item false
        }
    }
    servers_walk_by_costs $ok_settings $match_hostname $check true
    server_ssh $ok_settings "" "pub" false
    { status: true, error: "" }
}
export def create_server [
    server: record
    index: int
    check: bool
    wait: bool
    settings: record
    outfile?: string
]: nothing -> bool {
    ## Provider middleware now available through lib_provisioning
    #use utils.nu *
    let server_info = (mw_server_info $server true)
    let already_created = ($server_info | get -o hostname | is-not-empty)
    if ($already_created) {
        _print $"Server (_ansi green_bold)($server.hostname)(_ansi reset) already created "
        check_server $settings $server $index $server_info $check $wait $settings $outfile
        #mw_server_info $server false
        if not $check { return true }
    }
    let server_template = ($env.PROVISIONING | path join "providers" | path join $server.provider | path join templates |
        path join $"($server.provider)_servers.j2"
    )
    let create_result = on_server_template $server_template $server $index $check false $wait $settings $outfile
    if $check { return true }
    if not $create_result { return false }
    check_server $settings $server $index $server_info $check $wait $settings $outfile
    true
}

export def verify_server_info [
    settings: record
    server: record
    info: record
]: nothing -> nothing {
    _print $"Checking server (_ansi green_bold)($server.hostname)(_ansi reset) info "
    let server_plan = ($server | get -o plan | default "")
    let curr_plan = ($info | get -o plan | default "")
    if ($server_plan | is-not-empty) {
        if $server_plan != $curr_plan {
            mw_modify_server $settings $server [{plan: $server_plan}] false
        }
    }
}
export def check_server [
    settings: record
    server: record
    index: int
    info: record
    check: bool
    wait: bool
    settings: record
    outfile?: string
]: nothing -> bool {
    ## Provider middleware now available through lib_provisioning
    #use utils.nu *
    let server_info = if ($info | is-empty) {
        (mw_server_info $server true)
    } else {
        $info
    }
    let already_created = ($server_info | is-not-empty)
    if not $already_created {
        _print $"🛑 server (_ansi green_bold)($server.hostname)(_ansi reset) not exists"
        return false
    }
    if not $check {
        ^ssh-keygen -f $"($env.HOME)/.ssh/known_hosts" -R $server.hostname err> (if $nu.os-info.name == "windows" { "NUL" } else { "/dev/null" })
        let ip = (mw_get_ip $settings $server $server.liveness_ip false )
        if $ip == "" {
            _print "🛑 No liveness ip found for state checking "
            return false
        }
        verify_server_info $settings $server $server_info
        _print $"liveness (_ansi purple)($ip):($server.liveness_port)(_ansi reset)"
        if (wait_for_server $index $server $settings $ip) {
            on_server_ssh $settings $server "pub" "create" false
            # collect fingerprint
            let res = (^ssh-keyscan "-H" $ip err> (if $nu.os-info.name == "windows" { "NUL" } else { "/dev/null" })| complete)
            if $res.exit_code == 0 {
                let known_hosts_path = (("~" | path join ".ssh" | path join "known_hosts") | path expand)
                let markup = $"# ($ip) keyscan"
                let lines_found = (open $known_hosts_path --raw | lines |  find $markup | length)
                if $lines_found == 0 {
                    ( $"($markup)\n" | save --append $known_hosts_path)
                    ($res.stdout | save --append $known_hosts_path)
                    _print $"(_ansi green_bold)($ip)(_ansi reset) (_ansi yellow)ssh-keyscan(_ansi reset) added to ($known_hosts_path)"
                }
            #} else {
            #   _print $"🛑 Error (_ansi yellow)ssh-keyscan(_ansi reset) from ($ip)"
            #   _print $"($res.stdout)"
            }
            if $already_created {
                let res = (mw_post_create_server $settings $server $check)
                match $res {
                    "error" | "-1" => { exit 1},
                    "storage" | "" => {
                        let storage_sh = ($settings.wk_path | path join $"($server.hostname)-storage.sh")
                        let result = (on_server_template ($env.PROVISIONING_TEMPLATES_PATH | path join "storage.j2") $server 0 true true true $settings $storage_sh)
                        if $result and ($storage_sh | path exists) and (wait_for_server $index $server $settings $ip) {
                            let target_cmd = "/tmp/storage.sh"
                            #use ssh.nu scp_to ssh_cmd
                            if not (scp_to $settings $server [$storage_sh] $target_cmd $ip) { return false }
                            _print $"Running (_ansi blue_italic)($target_cmd | path basename)(_ansi reset) in (_ansi green_bold)($server.hostname)(_ansi reset)"
                            if not (ssh_cmd $settings $server true $target_cmd $ip) { return false }
                            if $env.PROVISIONING_SSH_DEBUG? != null and $env.PROVISIONING_SSH_DEBUG { return true }
                            if not $env.PROVISIONING_DEBUG {
                                (ssh_cmd $settings $server false $"rm -f ($target_cmd)" $ip)
                            }
                        } else {
                            return false
                        }
                    }
                    _  => {
                        return true
                    },
                }
            }
        }
    }
    true
}