feat: add terraform generator printer

Author: quantumsheep

internal/core/bootstrap.go

@@ -87,7 +87,7 @@ func Bootstrap(config *BootstrapConfig) (exitCode int, result interface{}, err e
 	flags := pflag.NewFlagSet(config.Args[0], pflag.ContinueOnError)
 	flags.StringVarP(&profileFlag, "profile", "p", "", "The config profile to use")
 	flags.StringVarP(&configPathFlag, "config", "c", "", "The path to the config file")
-	flags.StringVarP(&outputFlag, "output", "o", cliConfig.DefaultOutput, "Output format: json or human")
+	flags.StringVarP(&outputFlag, "output", "o", cliConfig.DefaultOutput, "Output format: json, yaml, terraform, human, wide or template")
 	flags.BoolVarP(&debug, "debug", "D", os.Getenv("SCW_DEBUG") == "true", "Enable debug mode")
 	// Ignore unknown flag
 	flags.ParseErrorsWhitelist.UnknownFlags = true

internal/core/printer.go

@@ -1,9 +1,12 @@
 package core
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
+	"os"
+	"path/filepath"
 	"reflect"
 	"strings"
 	"text/template"
@@ -12,6 +15,7 @@ import (
 
 	"github.com/scaleway/scaleway-cli/v2/internal/gofields"
 	"github.com/scaleway/scaleway-cli/v2/internal/human"
+	"github.com/scaleway/scaleway-cli/v2/internal/terraform"
 )
 
 // Type defines an formatter format.
@@ -28,6 +32,9 @@ const (
 	// PrinterTypeYAML defines a YAML formatter.
 	PrinterTypeYAML = PrinterType("yaml")
 
+	// PrinterTypeYAML defines a Terraform formatter.
+	PrinterTypeTerraform = PrinterType("terraform")
+
 	// PrinterTypeHuman defines a human readable formatted formatter.
 	PrinterTypeHuman = PrinterType("human")
 
@@ -39,6 +46,9 @@ const (
 
 	// Option to enable pretty output on json printer.
 	PrinterOptJSONPretty = "pretty"
+
+	// Option to enable pretty output on json printer.
+	PrinterOptTerraformWithChildren = "with-children"
 )
 
 type PrinterConfig struct {
@@ -75,6 +85,11 @@ func NewPrinter(config *PrinterConfig) (*Printer, error) {
 		}
 	case PrinterTypeYAML.String():
 		printer.printerType = PrinterTypeYAML
+	case PrinterTypeTerraform.String():
+		err := setupTerraformPrinter(printer, printerOpt)
+		if err != nil {
+			return nil, err
+		}
 	case PrinterTypeTemplate.String():
 		err := setupTemplatePrinter(printer, printerOpt)
 		if err != nil {
@@ -100,6 +115,28 @@ func setupJSONPrinter(printer *Printer, opts string) error {
 	return nil
 }
 
+func setupTerraformPrinter(printer *Printer, opts string) error {
+	printer.printerType = PrinterTypeTerraform
+	switch opts {
+	case PrinterOptTerraformWithChildren:
+		printer.terraformWithChildren = true
+	case "":
+	default:
+		return fmt.Errorf("invalid option %s for terraform outout. Valid options are: %s", opts, PrinterOptTerraformWithChildren)
+	}
+
+	terraformVersion, err := terraform.GetVersion()
+	if err != nil {
+		return err
+	}
+
+	if terraformVersion.Major < 1 || (terraformVersion.Major == 1 && terraformVersion.Minor < 5) {
+		return fmt.Errorf("terraform version %s is not supported. Please upgrade to terraform >= 1.5.0", terraformVersion.String())
+	}
+
+	return nil
+}
+
 func setupTemplatePrinter(printer *Printer, opts string) error {
 	printer.printerType = PrinterTypeTemplate
 	if opts == "" {
@@ -139,6 +176,9 @@ type Printer struct {
 	// Enable pretty print on json output
 	jsonPretty bool
 
+	// Enable children fetching on terraform output
+	terraformWithChildren bool
+
 	// go template to use on template output
 	template *template.Template
 
@@ -163,6 +203,8 @@ func (p *Printer) Print(data interface{}, opt *human.MarshalOpt) error {
 		err = p.printJSON(data)
 	case PrinterTypeYAML:
 		err = p.printYAML(data)
+	case PrinterTypeTerraform:
+		err = p.printTerraform(data)
 	case PrinterTypeTemplate:
 		err = p.printTemplate(data)
 	default:
@@ -283,6 +325,120 @@ func (p *Printer) printYAML(data interface{}) error {
 	return encoder.Encode(data)
 }
 
+type TerraformImportTemplateData struct {
+	ResourceID   string
+	ResourceName string
+}
+
+const terraformImportTemplate = `
+terraform {
+	required_providers {
+	  	scaleway = {
+			source = "scaleway/scaleway"
+	  	}
+	}
+	required_version = ">= 0.13"
+}
+  
+import {
+	# ID of the cloud resource
+	# Check provider documentation for importable resources and format
+	id = "{{ .ResourceID }}"
+  
+	# Resource address
+	to = {{ .ResourceName }}.main
+}  
+`
+
+func (p *Printer) printTerraform(data interface{}) error {
+	writer := p.stdout
+	if _, isError := data.(error); isError {
+		return p.printHuman(data, nil)
+	}
+
+	dataValue := reflect.ValueOf(data)
+	dataType := dataValue.Type().Elem()
+
+	for i, association := range terraform.Associations {
+		iValue := reflect.ValueOf(i)
+		iType := iValue.Type().Elem()
+		if dataType != iType {
+			continue
+		}
+
+		tmpl, err := template.New("terraform").Parse(association.ImportFormat)
+		if err != nil {
+			return err
+		}
+
+		var resourceID bytes.Buffer
+		err = tmpl.Execute(&resourceID, data)
+		if err != nil {
+			return err
+		}
+
+		// Create temporary directory
+		tmpDir, err := os.MkdirTemp("", "scw-*")
+		if err != nil {
+			return err
+		}
+
+		tmplFile, err := os.CreateTemp(tmpDir, "*.tf")
+		if err != nil {
+			return err
+		}
+		defer os.Remove(tmplFile.Name())
+
+		tmpl, err = template.New("terraform").Parse(terraformImportTemplate)
+		if err != nil {
+			return err
+		}
+		// Write the terraform file
+		err = tmpl.Execute(tmplFile, TerraformImportTemplateData{
+			ResourceID:   resourceID.String(),
+			ResourceName: association.ResourceName,
+		})
+		if err != nil {
+			return err
+		}
+
+		// Close the file
+		err = tmplFile.Close()
+		if err != nil {
+			return err
+		}
+
+		res, err := terraform.Init(tmpDir)
+		if err != nil {
+			return err
+		}
+		if res.ExitCode != 0 {
+			return fmt.Errorf("terraform init failed: %s", res.Stderr)
+		}
+
+		res, err = terraform.GenerateConfig(tmpDir, "output.tf")
+		if err != nil {
+			return err
+		}
+		if res.ExitCode != 0 {
+			return fmt.Errorf("terraform generate failed: %s", res.Stderr)
+		}
+
+		// Print the generated config
+		data, err := os.ReadFile(filepath.Join(tmpDir, "output.tf"))
+		if err != nil {
+			return err
+		}
+
+		_, err = writer.Write(data)
+		return err
+	}
+
+	return p.printHuman(&CliError{
+		Err: fmt.Errorf("no terraform association found for this resource type (%s)", dataType),
+	}, nil)
+}
+
 func (p *Printer) printTemplate(data interface{}) error {
 	writer := p.stdout
 	if _, isError := data.(error); isError {

internal/terraform/association.go

@@ -0,0 +1,32 @@
+package terraform
+
+import (
+	"github.com/scaleway/scaleway-sdk-go/api/baremetal/v1"
+	container "github.com/scaleway/scaleway-sdk-go/api/container/v1beta1"
+	"github.com/scaleway/scaleway-sdk-go/api/instance/v1"
+)
+
+type Association struct {
+	ResourceName string
+	ImportFormat string
+	SubResources []string
+}
+
+const ImportFormatID = "{{ .Region }}/{{ .ID }}"
+const ImportFormatZoneID = "{{ .Zone }}/{{ .ID }}"
+const ImportFormatRegionID = "{{ .Region }}/{{ .ID }}"
+
+var Associations = map[interface{}]Association{
+	&baremetal.Server{}: {
+		ResourceName: "scaleway_baremetal_server",
+		ImportFormat: ImportFormatZoneID,
+	},
+	&instance.Server{}: {
+		ResourceName: "scaleway_instance_server",
+		ImportFormat: ImportFormatZoneID,
+	},
+	&container.Container{}: {
+		ResourceName: "scaleway_container",
+		ImportFormat: ImportFormatRegionID,
+	},
+}

internal/terraform/runner.go

@@ -0,0 +1,117 @@
+package terraform
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+type RunResponse struct {
+	Stdout   string `js:"stdout"`
+	Stderr   string `js:"stderr"`
+	ExitCode int    `js:"exitCode"`
+}
+
+func runCommandInDir(dir string, command string, args ...string) (*RunResponse, error) {
+	cmd := exec.Command(command, args...)
+	cmd.Dir = dir
+
+	var outb, errb bytes.Buffer
+	cmd.Stdout = &outb
+	cmd.Stderr = &errb
+
+	err := cmd.Run()
+	if err != nil {
+		if exitError, ok := err.(*exec.ExitError); ok {
+			return &RunResponse{
+				Stdout:   outb.String(),
+				Stderr:   errb.String(),
+				ExitCode: exitError.ExitCode(),
+			}, nil
+		}
+
+		return nil, err
+	}
+
+	return &RunResponse{
+		Stdout:   outb.String(),
+		Stderr:   errb.String(),
+		ExitCode: 0,
+	}, nil
+}
+
+func runTerraformCommand(dir string, args ...string) (*RunResponse, error) {
+	return runCommandInDir(dir, "terraform", args...)
+}
+
+type Version struct {
+	Major int
+	Minor int
+	Patch int
+}
+
+func (v *Version) String() string {
+	return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
+}
+
+// GetClientVersion runs terraform version and returns the version string
+func GetVersion() (*Version, error) {
+	response, err := runTerraformCommand("", "version", "-json")
+	if err != nil {
+		return nil, err
+	}
+
+	var data map[string]interface{}
+	err = json.Unmarshal([]byte(response.Stdout), &data)
+	if err != nil {
+		return nil, err
+	}
+
+	rawVersion, ok := data["terraform_version"]
+	if !ok {
+		return nil, errors.New("failed to get terraform version: terraform_version not found")
+	}
+
+	version, ok := rawVersion.(string)
+	if !ok {
+		return nil, errors.New("failed to get terraform version: terraform_version is not a string")
+	}
+
+	parts := strings.Split(version, ".")
+	if len(parts) != 3 {
+		return nil, fmt.Errorf("failed to get terraform version: invalid version format '%s'", version)
+	}
+
+	major, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return nil, fmt.Errorf("failed to get terraform version: invalid major version '%s'", parts[0])
+	}
+
+	minor, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return nil, fmt.Errorf("failed to get terraform version: invalid minor version '%s'", parts[1])
+	}
+
+	patch, err := strconv.Atoi(parts[2])
+	if err != nil {
+		return nil, fmt.Errorf("failed to get terraform version: invalid patch version '%s'", parts[2])
+	}
+
+	return &Version{
+		Major: major,
+		Minor: minor,
+		Patch: patch,
+	}, nil
+}
+
+func Init(dir string) (*RunResponse, error) {
+	return runTerraformCommand(dir, "init")
+}
+
+func GenerateConfig(dir string, target string) (*RunResponse, error) {
+	return runTerraformCommand(dir, "plan", fmt.Sprintf("-generate-config-out=%s", target))
+}