limactl start: show menu for choosing examples (docker, archlinux, ...)

Signed-off-by: Akihiro Suda <[email protected]>

Author: AkihiroSuda

cmd/limactl/edit.go

@@ -56,7 +56,7 @@ func editAction(cmd *cobra.Command, args []string) error {
 	hdr += "# and an empty file will abort the edit.\n"
 	hdr += "\n"
 	hdr += generateEditorWarningHeader()
-	yBytes, err := openEditor(cmd, instName, yContent, hdr)
+	yBytes, err := openEditor(instName, yContent, hdr)
 	if err != nil {
 		return err
 	}

cmd/limactl/info.go

@@ -20,8 +20,14 @@ func newInfoCommand() *cobra.Command {
 	return infoCommand
 }
 
+type TemplateYAML struct {
+	Name     string `json:"name"`
+	Location string `json:"location"`
+}
+
 type Info struct {
 	Version         string             `json:"version"`
+	Templates       []TemplateYAML     `json:"templates"`
 	DefaultTemplate *limayaml.LimaYAML `json:"defaultTemplate"`
 	LimaHome        string             `json:"limaHome"`
 	// TODO: add diagnostic info of QEMU
@@ -40,6 +46,10 @@ func infoAction(cmd *cobra.Command, args []string) error {
 		Version:         version.Version,
 		DefaultTemplate: y,
 	}
+	info.Templates, err = listTemplateYAMLs()
+	if err != nil {
+		return err
+	}
 	info.LimaHome, err = dirnames.LimaDir()
 	if err != nil {
 		return err

cmd/limactl/start.go

@@ -31,7 +31,7 @@ import (
 func newStartCommand() *cobra.Command {
 	var startCommand = &cobra.Command{
 		Use:               "start NAME|FILE.yaml|URL",
-		Short:             fmt.Sprintf("Start an instance of Lima. If the instance does not exist, open an editor for creating new one, with name %q", DefaultInstanceName),
+		Short:             "Start an instance of Lima",
 		Args:              cobra.MaximumNArgs(1),
 		ValidArgsFunction: startBashComplete,
 		RunE:              startAction,
@@ -57,77 +57,105 @@ func loadOrCreateInstance(cmd *cobra.Command, args []string) (*store.Instance, e
 		arg = args[0]
 	}
 
-	yBytes, err := readDefaultTemplate()
-	if err != nil {
-		return nil, err
-	}
-
-	var instName string
-
+	var (
+		st  = &creatorState{}
+		err error
+	)
 	const yBytesLimit = 4 * 1024 * 1024 // 4MiB
 
 	if argSeemsHTTPURL(arg) {
-		instName, err = instNameFromURL(arg)
+		st.instName, err = instNameFromURL(arg)
 		if err != nil {
 			return nil, err
 		}
-		logrus.Debugf("interpreting argument %q as a http url for instance %q", arg, instName)
+		logrus.Debugf("interpreting argument %q as a http url for instance %q", arg, st.instName)
 		resp, err := http.Get(arg)
 		if err != nil {
 			return nil, err
 		}
 		defer resp.Body.Close()
-		yBytes, err = readAtMaximum(resp.Body, yBytesLimit)
+		st.yBytes, err = readAtMaximum(resp.Body, yBytesLimit)
 		if err != nil {
 			return nil, err
 		}
 	} else if argSeemsFileURL(arg) {
-		instName, err = instNameFromURL(arg)
+		st.instName, err = instNameFromURL(arg)
 		if err != nil {
 			return nil, err
 		}
-		logrus.Debugf("interpreting argument %q as a file url for instance %q", arg, instName)
+		logrus.Debugf("interpreting argument %q as a file url for instance %q", arg, st.instName)
 		r, err := os.Open(strings.TrimPrefix(arg, "file://"))
 		if err != nil {
 			return nil, err
 		}
 		defer r.Close()
-		yBytes, err = readAtMaximum(r, yBytesLimit)
+		st.yBytes, err = readAtMaximum(r, yBytesLimit)
 		if err != nil {
 			return nil, err
 		}
 	} else if argSeemsYAMLPath(arg) {
-		instName, err = instNameFromYAMLPath(arg)
+		st.instName, err = instNameFromYAMLPath(arg)
 		if err != nil {
 			return nil, err
 		}
-		logrus.Debugf("interpreting argument %q as a file path for instance %q", arg, instName)
+		logrus.Debugf("interpreting argument %q as a file path for instance %q", arg, st.instName)
 		r, err := os.Open(arg)
 		if err != nil {
 			return nil, err
 		}
 		defer r.Close()
-		yBytes, err = readAtMaximum(r, yBytesLimit)
+		st.yBytes, err = readAtMaximum(r, yBytesLimit)
 		if err != nil {
 			return nil, err
 		}
 	} else {
-		instName = arg
-		logrus.Debugf("interpreting argument %q as an instance name %q", arg, instName)
-		if err := identifiers.Validate(instName); err != nil {
-			return nil, fmt.Errorf("argument must be either an instance name or a YAML file path, got %q: %w", instName, err)
+		st.instName = arg
+		logrus.Debugf("interpreting argument %q as an instance name %q", arg, st.instName)
+		if err := identifiers.Validate(st.instName); err != nil {
+			return nil, fmt.Errorf("argument must be either an instance name or a YAML file path, got %q: %w", st.instName, err)
 		}
-		if inst, err := store.Inspect(instName); err == nil {
-			logrus.Infof("Using the existing instance %q", instName)
+		if inst, err := store.Inspect(st.instName); err == nil {
+			logrus.Infof("Using the existing instance %q", st.instName)
 			return inst, nil
 		} else {
 			if !errors.Is(err, os.ErrNotExist) {
 				return nil, err
 			}
+			// Read the default template for creating a new instance
+			st.yBytes, err = readDefaultTemplate()
+			if err != nil {
+				return nil, err
+			}
 		}
 	}
-	// create a new instance from the template
-	instDir, err := store.InstanceDir(instName)
+
+	// Create an instance, with menu TUI when TTY is available
+	tty, err := cmd.Flags().GetBool("tty")
+	if err != nil {
+		return nil, err
+	}
+	if tty {
+		var err error
+		st, err = chooseNextCreatorState(st)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		logrus.Info("Terminal is not available, proceeding without opening an editor")
+	}
+	saveBrokenEditorBuffer := tty
+	return createInstance(st, saveBrokenEditorBuffer)
+}
+
+func createInstance(st *creatorState, saveBrokenEditorBuffer bool) (*store.Instance, error) {
+	if st.instName == "" {
+		return nil, errors.New("got empty st.instName")
+	}
+	if len(st.yBytes) == 0 {
+		return nil, errors.New("got empty st.yBytes")
+	}
+
+	instDir, err := store.InstanceDir(st.instName)
 	if err != nil {
 		return nil, err
 	}
@@ -136,92 +164,140 @@ func loadOrCreateInstance(cmd *cobra.Command, args []string) (*store.Instance, e
 	maxSockName := filepath.Join(instDir, filenames.LongestSock)
 	if len(maxSockName) >= osutil.UnixPathMax {
 		return nil, fmt.Errorf("instance name %q too long: %q must be less than UNIX_PATH_MAX=%d characters, but is %d",
-			instName, maxSockName, osutil.UnixPathMax, len(maxSockName))
+			st.instName, maxSockName, osutil.UnixPathMax, len(maxSockName))
 	}
 	if _, err := os.Stat(instDir); !errors.Is(err, os.ErrNotExist) {
-		return nil, fmt.Errorf("instance %q already exists (%q)", instName, instDir)
+		return nil, fmt.Errorf("instance %q already exists (%q)", st.instName, instDir)
 	}
-
-	tty, err := cmd.Flags().GetBool("tty")
+	// limayaml.Load() needs to pass the store file path to limayaml.FillDefault() to calculate default MAC addresses
+	filePath := filepath.Join(instDir, filenames.LimaYAML)
+	y, err := limayaml.Load(st.yBytes, filePath)
 	if err != nil {
 		return nil, err
 	}
-	if tty {
-		answerOpenEditor, err := askWhetherToOpenEditor(instName)
-		if err != nil {
+	if err := limayaml.Validate(*y, true); err != nil {
+		if !saveBrokenEditorBuffer {
+			return nil, err
+		}
+		rejectedYAML := "lima.REJECTED.yaml"
+		if writeErr := os.WriteFile(rejectedYAML, st.yBytes, 0644); writeErr != nil {
+			return nil, fmt.Errorf("the YAML is invalid, attempted to save the buffer as %q but failed: %v: %w", rejectedYAML, writeErr, err)
+		}
+		return nil, fmt.Errorf("the YAML is invalid, saved the buffer as %q: %w", rejectedYAML, err)
+	}
+	if err := os.MkdirAll(instDir, 0700); err != nil {
+		return nil, err
+	}
+	if err := os.WriteFile(filePath, st.yBytes, 0644); err != nil {
+		return nil, err
+	}
+	return store.Inspect(st.instName)
+}
+
+type creatorState struct {
+	instName string // instance name
+	yBytes   []byte // yaml bytes
+}
+
+func chooseNextCreatorState(st *creatorState) (*creatorState, error) {
+	for {
+		var ans string
+		prompt := &survey.Select{
+			Message: fmt.Sprintf("Creating an instance %q", st.instName),
+			Options: []string{
+				"Proceed with the current configuration",
+				"Open an editor to review or modify the current configuration",
+				"Choose another example (docker, podman, archlinux, fedora, ...)",
+				"Exit",
+			},
+		}
+		if err := survey.AskOne(prompt, &ans); err != nil {
 			logrus.WithError(err).Warn("Failed to open TUI")
-			answerOpenEditor = false
+			return st, nil
 		}
-		if answerOpenEditor {
-			hdr := fmt.Sprintf("# Review and modify the following configuration for Lima instance %q.\n", instName)
-			if instName == DefaultInstanceName {
+		switch ans {
+		case prompt.Options[0]: // "Proceed with the current configuration"
+			return st, nil
+		case prompt.Options[1]: // "Open an editor ..."
+			hdr := fmt.Sprintf("# Review and modify the following configuration for Lima instance %q.\n", st.instName)
+			if st.instName == DefaultInstanceName {
 				hdr += "# - In most cases, you do not need to modify this file.\n"
 			}
 			hdr += "# - To cancel starting Lima, just save this file as an empty file.\n"
 			hdr += "\n"
 			hdr += generateEditorWarningHeader()
-			yBytes, err = openEditor(cmd, instName, yBytes, hdr)
+			var err error
+			st.yBytes, err = openEditor(st.instName, st.yBytes, hdr)
 			if err != nil {
-				return nil, err
+				return st, err
 			}
-			if len(yBytes) == 0 {
+			if len(st.yBytes) == 0 {
 				logrus.Info("Aborting, as requested by saving the file with empty content")
 				os.Exit(0)
-				return nil, errors.New("should not reach here")
+				return st, errors.New("should not reach here")
+			}
+			return st, nil
+		case prompt.Options[2]: // "Choose another example..."
+			examples, err := listTemplateYAMLs()
+			if err != nil {
+				return st, err
+			}
+			var ansEx int
+			promptEx := &survey.Select{
+				Message: "Choose an example",
+				Options: make([]string, len(examples)),
 			}
+			for i := range examples {
+				promptEx.Options[i] = examples[i].Name
+			}
+			if err := survey.AskOne(promptEx, &ansEx); err != nil {
+				return st, err
+			}
+			if ansEx > len(examples)-1 {
+				return st, fmt.Errorf("invalid answer %d for %d entries", ansEx, len(examples))
+			}
+			yamlPath := examples[ansEx].Location
+			st.instName, err = instNameFromYAMLPath(yamlPath)
+			if err != nil {
+				return nil, err
+			}
+			st.yBytes, err = os.ReadFile(yamlPath)
+			if err != nil {
+				return nil, err
+			}
+			continue
+		case prompt.Options[3]: // "Exit"
+			os.Exit(0)
+			return st, errors.New("should not reach here")
+		default:
+			return st, fmt.Errorf("unexpected answer %q", ans)
 		}
-	} else {
-		logrus.Info("Terminal is not available, proceeding without opening an editor")
 	}
-	// limayaml.Load() needs to pass the store file path to limayaml.FillDefault() to calculate default MAC addresses
-	filePath := filepath.Join(instDir, filenames.LimaYAML)
-	y, err := limayaml.Load(yBytes, filePath)
+}
+
+func listTemplateYAMLs() ([]TemplateYAML, error) {
+	usrlocalsharelimaDir, err := usrlocalsharelima.Dir()
 	if err != nil {
 		return nil, err
 	}
-	if err := limayaml.Validate(*y, true); err != nil {
-		if !tty {
-			return nil, err
-		}
-		rejectedYAML := "lima.REJECTED.yaml"
-		if writeErr := os.WriteFile(rejectedYAML, yBytes, 0644); writeErr != nil {
-			return nil, fmt.Errorf("the YAML is invalid, attempted to save the buffer as %q but failed: %v: %w", rejectedYAML, writeErr, err)
-		}
-		return nil, fmt.Errorf("the YAML is invalid, saved the buffer as %q: %w", rejectedYAML, err)
-	}
-	if err := os.MkdirAll(instDir, 0700); err != nil {
-		return nil, err
-	}
-	if err := os.WriteFile(filePath, yBytes, 0644); err != nil {
+	examplesDir := filepath.Join(usrlocalsharelimaDir, "examples")
+	glob := filepath.Join(examplesDir, "*.yaml")
+	globbed, err := filepath.Glob(glob)
+	if err != nil {
 		return nil, err
 	}
-	return store.Inspect(instName)
-}
-
-func askWhetherToOpenEditor(name string) (bool, error) {
-	var ans string
-	prompt := &survey.Select{
-		Message: fmt.Sprintf("Creating an instance %q", name),
-		Options: []string{
-			"Proceed with the default configuration",
-			"Open an editor to override the configuration",
-			"Exit",
-		},
-	}
-	if err := survey.AskOne(prompt, &ans); err != nil {
-		return false, err
-	}
-	switch ans {
-	case prompt.Options[0]:
-		return false, nil
-	case prompt.Options[1]:
-		return true, nil
-	case prompt.Options[2]:
-		os.Exit(0)
-		return false, errors.New("should not reach here")
-	default:
-		return false, fmt.Errorf("unexpected answer %q", ans)
+	var res []TemplateYAML
+	for _, f := range globbed {
+		base := filepath.Base(f)
+		if strings.HasPrefix(base, ".") {
+			continue
+		}
+		res = append(res, TemplateYAML{
+			Name:     strings.TrimSuffix(filepath.Base(f), ".yaml"),
+			Location: f,
+		})
 	}
+	return res, nil
 }
 
 func fileWarning(filename string) string {
@@ -261,7 +337,7 @@ func generateEditorWarningHeader() string {
 // openEditor opens an editor, and returns the content (not path) of the modified yaml.
 //
 // openEditor returns nil when the file was saved as an empty file, optionally with whitespaces.
-func openEditor(cmd *cobra.Command, name string, content []byte, hdr string) ([]byte, error) {
+func openEditor(name string, content []byte, hdr string) ([]byte, error) {
 	editor := editorcmd.Detect()
 	if editor == "" {
 		return nil, errors.New("could not detect a text editor binary, try setting $EDITOR")