334 lines
9.3 KiB
Go
334 lines
9.3 KiB
Go
package vm
|
|
|
|
import (
|
|
"context"
|
|
"text/tabwriter"
|
|
|
|
core "dappco.re/go/core"
|
|
"dappco.re/go/core/container"
|
|
"dappco.re/go/core/container/internal/coreutil"
|
|
"dappco.re/go/core/container/internal/proc"
|
|
"dappco.re/go/core/i18n"
|
|
"dappco.re/go/core/io"
|
|
coreerr "dappco.re/go/core/log"
|
|
"forge.lthn.ai/core/cli/pkg/cli"
|
|
)
|
|
|
|
// addVMTemplatesCommand adds the 'templates' command under vm.
|
|
func addVMTemplatesCommand(parent *cli.Command) {
|
|
templatesCmd := &cli.Command{
|
|
Use: "templates",
|
|
Short: i18n.T("cmd.vm.templates.short"),
|
|
Long: i18n.T("cmd.vm.templates.long"),
|
|
RunE: func(cmd *cli.Command, args []string) error {
|
|
return listTemplates()
|
|
},
|
|
}
|
|
|
|
// Add subcommands
|
|
addTemplatesShowCommand(templatesCmd)
|
|
addTemplatesVarsCommand(templatesCmd)
|
|
|
|
parent.AddCommand(templatesCmd)
|
|
}
|
|
|
|
// addTemplatesShowCommand adds the 'templates show' subcommand.
|
|
func addTemplatesShowCommand(parent *cli.Command) {
|
|
showCmd := &cli.Command{
|
|
Use: "show <template-name>",
|
|
Short: i18n.T("cmd.vm.templates.show.short"),
|
|
Long: i18n.T("cmd.vm.templates.show.long"),
|
|
RunE: func(cmd *cli.Command, args []string) error {
|
|
if len(args) == 0 {
|
|
return coreerr.E("templates show", i18n.T("cmd.vm.error.template_required"), nil)
|
|
}
|
|
return showTemplate(args[0])
|
|
},
|
|
}
|
|
|
|
parent.AddCommand(showCmd)
|
|
}
|
|
|
|
// addTemplatesVarsCommand adds the 'templates vars' subcommand.
|
|
func addTemplatesVarsCommand(parent *cli.Command) {
|
|
varsCmd := &cli.Command{
|
|
Use: "vars <template-name>",
|
|
Short: i18n.T("cmd.vm.templates.vars.short"),
|
|
Long: i18n.T("cmd.vm.templates.vars.long"),
|
|
RunE: func(cmd *cli.Command, args []string) error {
|
|
if len(args) == 0 {
|
|
return coreerr.E("templates vars", i18n.T("cmd.vm.error.template_required"), nil)
|
|
}
|
|
return showTemplateVars(args[0])
|
|
},
|
|
}
|
|
|
|
parent.AddCommand(varsCmd)
|
|
}
|
|
|
|
func listTemplates() error {
|
|
templates := container.ListTemplates()
|
|
|
|
if len(templates) == 0 {
|
|
core.Println(i18n.T("cmd.vm.templates.no_templates"))
|
|
return nil
|
|
}
|
|
|
|
core.Print(nil, "%s", repoNameStyle.Render(i18n.T("cmd.vm.templates.title")))
|
|
core.Println()
|
|
|
|
w := tabwriter.NewWriter(proc.Stdout, 0, 0, 2, ' ', 0)
|
|
core.Print(w, "%s", i18n.T("cmd.vm.templates.header"))
|
|
core.Print(w, "%s", "----\t-----------")
|
|
|
|
for _, tmpl := range templates {
|
|
desc := tmpl.Description
|
|
if len(desc) > 60 {
|
|
desc = desc[:57] + "..."
|
|
}
|
|
core.Print(w, "%s\t%s", repoNameStyle.Render(tmpl.Name), desc)
|
|
}
|
|
_ = w.Flush()
|
|
|
|
core.Println()
|
|
core.Print(nil, "%s %s", i18n.T("cmd.vm.templates.hint.show"), dimStyle.Render("core vm templates show <name>"))
|
|
core.Print(nil, "%s %s", i18n.T("cmd.vm.templates.hint.vars"), dimStyle.Render("core vm templates vars <name>"))
|
|
core.Print(nil, "%s %s", i18n.T("cmd.vm.templates.hint.run"), dimStyle.Render("core vm run --template <name> --var SSH_KEY=\"...\""))
|
|
|
|
return nil
|
|
}
|
|
|
|
func showTemplate(name string) error {
|
|
content, err := container.GetTemplate(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
core.Print(nil, "%s %s", dimStyle.Render(i18n.T("common.label.template")), repoNameStyle.Render(name))
|
|
core.Println()
|
|
core.Println(content)
|
|
|
|
return nil
|
|
}
|
|
|
|
func showTemplateVars(name string) error {
|
|
content, err := container.GetTemplate(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
required, optional := container.ExtractVariables(content)
|
|
|
|
core.Print(nil, "%s %s", dimStyle.Render(i18n.T("common.label.template")), repoNameStyle.Render(name))
|
|
core.Println()
|
|
|
|
if len(required) > 0 {
|
|
core.Print(nil, "%s", errorStyle.Render(i18n.T("cmd.vm.templates.vars.required")))
|
|
for _, v := range required {
|
|
core.Print(nil, " %s", varStyle.Render("${"+v+"}"))
|
|
}
|
|
core.Println()
|
|
}
|
|
|
|
if len(optional) > 0 {
|
|
core.Print(nil, "%s", successStyle.Render(i18n.T("cmd.vm.templates.vars.optional")))
|
|
for v, def := range optional {
|
|
core.Print(nil, " %s = %s",
|
|
varStyle.Render("${"+v+"}"),
|
|
defaultStyle.Render(def))
|
|
}
|
|
core.Println()
|
|
}
|
|
|
|
if len(required) == 0 && len(optional) == 0 {
|
|
core.Println(i18n.T("cmd.vm.templates.vars.none"))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// RunFromTemplate builds and runs a LinuxKit image from a template.
|
|
//
|
|
// Usage:
|
|
//
|
|
// err := RunFromTemplate("core-dev", vars, runOpts)
|
|
func RunFromTemplate(templateName string, vars map[string]string, runOpts container.RunOptions) error {
|
|
// Apply template with variables
|
|
content, err := container.ApplyTemplate(templateName, vars)
|
|
if err != nil {
|
|
return coreerr.E("RunFromTemplate", i18n.T("common.error.failed", map[string]any{"Action": "apply template"}), err)
|
|
}
|
|
|
|
// Create a temporary directory for the build
|
|
tmpDir, err := coreutil.MkdirTemp("core-linuxkit-")
|
|
if err != nil {
|
|
return coreerr.E("RunFromTemplate", i18n.T("common.error.failed", map[string]any{"Action": "create temp directory"}), err)
|
|
}
|
|
defer func() { _ = io.Local.DeleteAll(tmpDir) }()
|
|
|
|
// Write the YAML file
|
|
yamlPath := coreutil.JoinPath(tmpDir, core.Concat(templateName, ".yml"))
|
|
if err := io.Local.Write(yamlPath, content); err != nil {
|
|
return coreerr.E("RunFromTemplate", i18n.T("common.error.failed", map[string]any{"Action": "write template"}), err)
|
|
}
|
|
|
|
core.Print(nil, "%s %s", dimStyle.Render(i18n.T("common.label.template")), repoNameStyle.Render(templateName))
|
|
core.Print(nil, "%s %s", dimStyle.Render(i18n.T("cmd.vm.label.building")), yamlPath)
|
|
|
|
// Build the image using linuxkit
|
|
outputPath := coreutil.JoinPath(tmpDir, templateName)
|
|
if err := buildLinuxKitImage(yamlPath, outputPath); err != nil {
|
|
return coreerr.E("RunFromTemplate", i18n.T("common.error.failed", map[string]any{"Action": "build image"}), err)
|
|
}
|
|
|
|
// Find the built image (linuxkit creates .iso or other format)
|
|
imagePath := findBuiltImage(outputPath)
|
|
if imagePath == "" {
|
|
return coreerr.E("RunFromTemplate", i18n.T("cmd.vm.error.no_image_found"), nil)
|
|
}
|
|
|
|
core.Print(nil, "%s %s", dimStyle.Render(i18n.T("common.label.image")), imagePath)
|
|
core.Println()
|
|
|
|
// Run the image
|
|
manager, err := container.NewLinuxKitManager(io.Local)
|
|
if err != nil {
|
|
return coreerr.E("RunFromTemplate", i18n.T("common.error.failed", map[string]any{"Action": "initialize container manager"}), err)
|
|
}
|
|
|
|
core.Print(nil, "%s %s", dimStyle.Render(i18n.T("cmd.vm.label.hypervisor")), manager.Hypervisor().Name())
|
|
core.Println()
|
|
|
|
ctx := context.Background()
|
|
c, err := manager.Run(ctx, imagePath, runOpts)
|
|
if err != nil {
|
|
return coreerr.E("RunFromTemplate", i18n.T("i18n.fail.run", "container"), err)
|
|
}
|
|
|
|
if runOpts.Detach {
|
|
core.Print(nil, "%s %s", successStyle.Render(i18n.T("common.label.started")), c.ID)
|
|
core.Print(nil, "%s %d", dimStyle.Render(i18n.T("cmd.vm.label.pid")), c.PID)
|
|
core.Println()
|
|
core.Println(i18n.T("cmd.vm.hint.view_logs", map[string]any{"ID": c.ID[:8]}))
|
|
core.Println(i18n.T("cmd.vm.hint.stop", map[string]any{"ID": c.ID[:8]}))
|
|
} else {
|
|
core.Println()
|
|
core.Print(nil, "%s %s", dimStyle.Render(i18n.T("cmd.vm.label.container_stopped")), c.ID)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// buildLinuxKitImage builds a LinuxKit image from a YAML file.
|
|
func buildLinuxKitImage(yamlPath, outputPath string) error {
|
|
// Check if linuxkit is available
|
|
lkPath, err := lookupLinuxKit()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Build the image
|
|
// linuxkit build --format iso-bios --name <output> <yaml>
|
|
cmd := proc.NewCommand(lkPath, "build",
|
|
"--format", "iso-bios",
|
|
"--name", outputPath,
|
|
yamlPath)
|
|
|
|
cmd.Stdout = proc.Stdout
|
|
cmd.Stderr = proc.Stderr
|
|
|
|
return cmd.Run()
|
|
}
|
|
|
|
// findBuiltImage finds the built image file.
|
|
func findBuiltImage(basePath string) string {
|
|
// LinuxKit can create different formats
|
|
extensions := []string{".iso", "-bios.iso", ".qcow2", ".raw", ".vmdk"}
|
|
|
|
for _, ext := range extensions {
|
|
path := core.Concat(basePath, ext)
|
|
if io.Local.IsFile(path) {
|
|
return path
|
|
}
|
|
}
|
|
|
|
// Check directory for any image file
|
|
dir := core.PathDir(basePath)
|
|
base := core.PathBase(basePath)
|
|
|
|
entries, err := io.Local.List(dir)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
|
|
for _, entry := range entries {
|
|
name := entry.Name()
|
|
if core.HasPrefix(name, base) {
|
|
for _, ext := range []string{".iso", ".qcow2", ".raw", ".vmdk"} {
|
|
if core.HasSuffix(name, ext) {
|
|
return coreutil.JoinPath(dir, name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
// lookupLinuxKit finds the linuxkit binary.
|
|
func lookupLinuxKit() (string, error) {
|
|
// Check PATH first
|
|
if path, err := proc.LookPath("linuxkit"); err == nil {
|
|
return path, nil
|
|
}
|
|
|
|
// Check common locations
|
|
paths := []string{
|
|
"/usr/local/bin/linuxkit",
|
|
"/opt/homebrew/bin/linuxkit",
|
|
}
|
|
|
|
for _, p := range paths {
|
|
if io.Local.Exists(p) {
|
|
return p, nil
|
|
}
|
|
}
|
|
|
|
return "", coreerr.E("lookupLinuxKit", i18n.T("cmd.vm.error.linuxkit_not_found"), nil)
|
|
}
|
|
|
|
// ParseVarFlags parses --var flags into a map.
|
|
// Format: --var KEY=VALUE or --var KEY="VALUE"
|
|
//
|
|
// Usage:
|
|
//
|
|
// vars := ParseVarFlags([]string{"SSH_KEY=abc", "PORT=2222"})
|
|
func ParseVarFlags(varFlags []string) map[string]string {
|
|
vars := make(map[string]string)
|
|
|
|
for _, v := range varFlags {
|
|
parts := core.SplitN(v, "=", 2)
|
|
if len(parts) == 2 {
|
|
key := core.Trim(parts[0])
|
|
value := core.Trim(parts[1])
|
|
// Remove surrounding quotes if present
|
|
value = stripWrappingQuotes(value)
|
|
vars[key] = value
|
|
}
|
|
}
|
|
|
|
return vars
|
|
}
|
|
|
|
func stripWrappingQuotes(value string) string {
|
|
if len(value) < 2 {
|
|
return value
|
|
}
|
|
if core.HasPrefix(value, "\"") && core.HasSuffix(value, "\"") {
|
|
return core.TrimSuffix(core.TrimPrefix(value, "\""), "\"")
|
|
}
|
|
if core.HasPrefix(value, "'") && core.HasSuffix(value, "'") {
|
|
return core.TrimSuffix(core.TrimPrefix(value, "'"), "'")
|
|
}
|
|
return value
|
|
}
|