fix: refactor sqlserver to handle encryption correctly (#31)

## Description

<!-- **Please link some issue here describing what you are trying to achieve.**

In case there is no issue present for your PR, please consider creating one.
At least please give us some description what you are trying to achieve and why your change is needed. -->

relates to #1234

## Checklist

- [ ] Issue was linked above
- [ ] Code format was applied: `make fmt`
- [ ] Examples were added / adjusted (see `examples/` directory)
- [x] Docs are up-to-date: `make generate-docs` (will be checked by CI)
- [ ] Unit tests got implemented or updated
- [ ] Acceptance tests got implemented or updated (see e.g. [here](f5f99d1709/stackit/internal/services/dns/dns_acc_test.go))
- [x] Unit tests are passing: `make test` (will be checked by CI)
- [x] No linter issues: `make lint` (will be checked by CI)

Reviewed-on: #31
Reviewed-by: Andre_Harms <andre.harms@stackit.cloud>

cmd/cmd/build/build.go

@@ -35,10 +35,15 @@ type version struct {
 	minor     int
 }
 
-func Build() error {
+type Builder struct {
+	SkipClone   bool
+	SkipCleanup bool
+}
+
+func (b *Builder) Build() error {
 	slog.Info("Starting Builder")
 
-	slog.Info("Checking needed commands available")
+	slog.Info("  ... Checking needed commands available")
 	err := checkCommands([]string{"tfplugingen-framework", "tfplugingen-openapi"})
 	if err != nil {
 		return err
@@ -51,28 +56,33 @@ func Build() error {
 	if root == nil || *root == "" {
 		return fmt.Errorf("unable to determine root directory from git")
 	}
-	slog.Info("Using root directory", "dir", *root)
+	slog.Info("  ... using root directory", "dir", *root)
 
-	slog.Info("Cleaning up old generator directory")
-	err = os.RemoveAll(path.Join(*root, GEN_REPO_NAME))
-	if err != nil {
-		return err
-	}
+	if !b.SkipCleanup {
+		slog.Info("Cleaning up old generator directory")
+		err = os.RemoveAll(path.Join(*root, GEN_REPO_NAME))
+		if err != nil {
+			return err
+		}
 
-	slog.Info("Cleaning up old packages directory")
-	err = os.RemoveAll(path.Join(*root, "pkg_gen"))
-	if err != nil {
-		return err
+		slog.Info("Cleaning up old packages directory")
+		err = os.RemoveAll(path.Join(*root, "pkg_gen"))
+		if err != nil {
+			return err
+		}
 	}
 
 	slog.Info("Creating generator dir", "dir", fmt.Sprintf("%s/%s", *root, GEN_REPO_NAME))
-	genDir, err := createGeneratorDir(*root, GEN_REPO, GEN_REPO_NAME)
-	if err != nil {
-		return err
+	genDir := path.Join(*root, GEN_REPO_NAME)
+	if !b.SkipClone {
+		err = createGeneratorDir(GEN_REPO, genDir, b.SkipClone)
+		if err != nil {
+			return err
+		}
 	}
 
-	slog.Info("Creating oas dir", "dir", fmt.Sprintf("%s/%s", *root, OAS_REPO_NAME))
-	repoDir, err := createRepoDir(genDir, OAS_REPO, OAS_REPO_NAME)
+	slog.Info("Creating oas repo dir", "dir", fmt.Sprintf("%s/%s", *root, OAS_REPO_NAME))
+	repoDir, err := createRepoDir(genDir, OAS_REPO, OAS_REPO_NAME, b.SkipClone)
 	if err != nil {
 		return fmt.Errorf("%s", err.Error())
 	}
@@ -118,12 +128,6 @@ func Build() error {
 		}
 	}
 
-	slog.Info("Cleaning up", "dir", repoDir)
-	err = os.RemoveAll(filepath.Dir(repoDir))
-	if err != nil {
-		return fmt.Errorf("%s", err.Error())
-	}
-
 	slog.Info("Changing dir", "dir", genDir)
 	err = os.Chdir(genDir)
 	if err != nil {
@@ -191,30 +195,16 @@ func Build() error {
 		if item.IsDir() {
 			slog.Info(" -> package", "name", item.Name())
 			tgtDir := path.Join(*root, "pkg_gen", item.Name())
-			// no backup needed as we generate new
-			//bakName := fmt.Sprintf("%s.%s", item.Name(), time.Now().Format("20060102-150405"))
-			//if _, err = os.Stat(tgtDir); !os.IsNotExist(err) {
-			//	err = os.Rename(
-			//		tgtDir,
-			//		path.Join(*root, "pkg", bakName),
-			//	)
-			//	if err != nil {
-			//		return err
-			//	}
-			//}
+			if fileExists(tgtDir) {
+				delErr := os.RemoveAll(tgtDir)
+				if delErr != nil {
+					return delErr
+				}
+			}
 			err = os.Rename(path.Join(srcDir, item.Name()), tgtDir)
 			if err != nil {
 				return err
 			}
-
-			// wait is placed outside now
-			//if _, err = os.Stat(path.Join(*root, "pkg", bakName, "wait")); !os.IsNotExist(err) {
-			//	slog.Info("    Copying wait subfolder")
-			//	err = os.Rename(path.Join(*root, "pkg", bakName, "wait"), path.Join(tgtDir, "wait"))
-			//	if err != nil {
-			//		return err
-			//	}
-			//}
 		}
 	}
 
@@ -238,17 +228,25 @@ func Build() error {
 		return err
 	}
 
-	slog.Info("Finally removing temporary files and directories")
-	//err = os.RemoveAll(path.Join(*root, "generated"))
-	//if err != nil {
-	//	slog.Error("RemoveAll", "dir", path.Join(*root, "generated"), "err", err)
-	//	return err
-	//}
+	if !b.SkipCleanup {
+		slog.Info("Finally removing temporary files and directories")
+		err = os.RemoveAll(path.Join(*root, "generated"))
+		if err != nil {
+			slog.Error("RemoveAll", "dir", path.Join(*root, "generated"), "err", err)
+			return err
+		}
 
-	err = os.RemoveAll(path.Join(*root, GEN_REPO_NAME))
-	if err != nil {
-		slog.Error("RemoveAll", "dir", path.Join(*root, GEN_REPO_NAME), "err", err)
-		return err
+		err = os.RemoveAll(path.Join(*root, GEN_REPO_NAME))
+		if err != nil {
+			slog.Error("RemoveAll", "dir", path.Join(*root, GEN_REPO_NAME), "err", err)
+			return err
+		}
+
+		slog.Info("Cleaning up", "dir", repoDir)
+		err = os.RemoveAll(filepath.Dir(repoDir))
+		if err != nil {
+			return fmt.Errorf("%s", err.Error())
+		}
 	}
 
 	slog.Info("Done")
@@ -421,6 +419,7 @@ func generateServiceFiles(rootDir, generatorDir string) error {
 				continue
 			}
 
+			// TODO: use const of supported versions
 			if svcVersion.Name() != "alpha" && svcVersion.Name() != "beta" {
 				continue
 			}
@@ -442,7 +441,7 @@ func generateServiceFiles(rootDir, generatorDir string) error {
 					fileName := matches[0][0]
 					resource := matches[0][1]
 					slog.Info(
-						"Found service spec",
+						"    found service spec",
 						"name",
 						specFile.Name(),
 						"service",
@@ -451,136 +450,147 @@ func generateServiceFiles(rootDir, generatorDir string) error {
 						resource,
 					)
 
-					//for _, part := range []string{"alpha", "beta"} {
-					oasFile := path.Join(generatorDir, "oas", fmt.Sprintf("%s%s.json", service.Name(), svcVersion))
-					if _, err = os.Stat(oasFile); !os.IsNotExist(err) {
-						slog.Info("found matching oas", "svc", service.Name(), "version", svcVersion.Name())
-						scName := fmt.Sprintf("%s%s", service.Name(), svcVersion.Name())
-						scName = strings.ReplaceAll(scName, "-", "")
-						err = os.MkdirAll(path.Join(rootDir, "generated", "internal", "services", scName, resource), 0755)
-						if err != nil {
-							return err
-						}
+					oasFile := path.Join(generatorDir, "oas", fmt.Sprintf("%s%s.json", service.Name(), svcVersion.Name()))
+					if _, oasErr := os.Stat(oasFile); os.IsNotExist(oasErr) {
+						slog.Warn("        coulc not find matching oas", "svc", service.Name(), "version", svcVersion.Name())
+						continue
+					}
 
-						// slog.Info("Generating openapi spec json")
-						specJsonFile := path.Join(rootDir, "generated", "specs", fmt.Sprintf("%s_%s_spec.json", scName, resource))
+					scName := fmt.Sprintf("%s%s", service.Name(), svcVersion.Name())
+					scName = strings.ReplaceAll(scName, "-", "")
+					err = os.MkdirAll(path.Join(rootDir, "generated", "internal", "services", scName, resource), 0755)
+					if err != nil {
+						return err
+					}
 
-						var stdOut, stdErr bytes.Buffer
+					// slog.Info("Generating openapi spec json")
+					specJsonFile := path.Join(rootDir, "generated", "specs", fmt.Sprintf("%s_%s_spec.json", scName, resource))
 
-						// noqa:gosec
-						cmd := exec.Command(
-							"tfplugingen-openapi",
-							"generate",
-							"--config",
-							path.Join(rootDir, "service_specs", fileName),
-							"--output",
-							specJsonFile,
-							oasFile,
+					var stdOut, stdErr bytes.Buffer
+
+					// noqa:gosec
+					cmd := exec.Command(
+						"tfplugingen-openapi",
+						"generate",
+						"--config",
+						path.Join(rootDir, "service_specs", service.Name(), svcVersion.Name(), fileName),
+						"--output",
+						specJsonFile,
+						oasFile,
+					)
+					cmd.Stdout = &stdOut
+					cmd.Stderr = &stdErr
+
+					if err = cmd.Start(); err != nil {
+						slog.Error(
+							"tfplugingen-openapi generate",
+							"error",
+							err,
+							"stdOut",
+							stdOut.String(),
+							"stdErr",
+							stdErr.String(),
 						)
-						cmd.Stdout = &stdOut
-						cmd.Stderr = &stdErr
+						return err
+					}
 
-						if err = cmd.Start(); err != nil {
-							slog.Error("tfplugingen-openapi generate", "error", err)
-							return err
+					if err = cmd.Wait(); err != nil {
+						var exitErr *exec.ExitError
+						if errors.As(err, &exitErr) {
+							slog.Error("tfplugingen-openapi generate", "code", exitErr.ExitCode(), "error", err, "stdout", stdOut.String(), "stderr", stdErr.String())
+							return fmt.Errorf("%s", stdErr.String())
 						}
-
-						if err = cmd.Wait(); err != nil {
-							var exitErr *exec.ExitError
-							if errors.As(err, &exitErr) {
-								slog.Error("tfplugingen-openapi generate", "code", exitErr.ExitCode(), "error", err, "stdout", stdOut.String(), "stderr", stdErr.String())
-								return fmt.Errorf("%s", stdErr.String())
-							}
-							if err != nil {
-								slog.Error("tfplugingen-openapi generate", "err", err, "stdout", stdOut.String(), "stderr", stdErr.String())
-								return err
-							}
-						}
-
-						// slog.Info("Creating terraform svc resource files folder")
-						tgtFolder := path.Join(rootDir, "generated", "internal", "services", scName, resource, "resources_gen")
-						err = os.MkdirAll(tgtFolder, 0755)
 						if err != nil {
+							slog.Error("tfplugingen-openapi generate", "err", err, "stdout", stdOut.String(), "stderr", stdErr.String())
+							return err
+						}
+					}
+					if stdOut.Len() > 0 {
+						slog.Warn("    command output", "stdout", stdOut.String(), "stderr", stdErr.String())
+					}
+
+					// slog.Info("Creating terraform svc resource files folder")
+					tgtFolder := path.Join(rootDir, "generated", "internal", "services", scName, resource, "resources_gen")
+					err = os.MkdirAll(tgtFolder, 0755)
+					if err != nil {
+						return err
+					}
+
+					// slog.Info("Generating terraform svc resource files")
+
+					// noqa:gosec
+					cmd2 := exec.Command(
+						"tfplugingen-framework",
+						"generate",
+						"resources",
+						"--input",
+						specJsonFile,
+						"--output",
+						tgtFolder,
+						"--package",
+						scName,
+					)
+
+					cmd2.Stdout = &stdOut
+					cmd2.Stderr = &stdErr
+					if err = cmd2.Start(); err != nil {
+						slog.Error("tfplugingen-framework generate resources", "error", err)
+						return err
+					}
+
+					if err = cmd2.Wait(); err != nil {
+						var exitErr *exec.ExitError
+						if errors.As(err, &exitErr) {
+							slog.Error("tfplugingen-framework generate resources", "code", exitErr.ExitCode(), "error", err, "stdout", stdOut.String(), "stderr", stdErr.String())
+							return fmt.Errorf("%s", stdErr.String())
+						}
+						if err != nil {
+							slog.Error("tfplugingen-framework generate resources", "err", err, "stdout", stdOut.String(), "stderr", stdErr.String())
+							return err
+						}
+					}
+
+					// slog.Info("Creating terraform svc datasource files folder")
+					tgtFolder = path.Join(rootDir, "generated", "internal", "services", scName, resource, "datasources_gen")
+					err = os.MkdirAll(tgtFolder, 0755)
+					if err != nil {
+						return err
+					}
+
+					// slog.Info("Generating terraform svc resource files")
+
+					// noqa:gosec
+					cmd3 := exec.Command(
+						"tfplugingen-framework",
+						"generate",
+						"data-sources",
+						"--input",
+						specJsonFile,
+						"--output",
+						tgtFolder,
+						"--package",
+						scName,
+					)
+					var stdOut3, stdErr3 bytes.Buffer
+					cmd3.Stdout = &stdOut3
+					cmd3.Stderr = &stdErr3
+
+					if err = cmd3.Start(); err != nil {
+						slog.Error("tfplugingen-framework generate data-sources", "error", err)
+						return err
+					}
+
+					if err = cmd3.Wait(); err != nil {
+						var exitErr *exec.ExitError
+						if errors.As(err, &exitErr) {
+							slog.Error("tfplugingen-framework generate data-sources", "code", exitErr.ExitCode(), "error", err, "stdout", stdOut.String(), "stderr", stdErr.String())
+							return fmt.Errorf("%s", stdErr.String())
+						}
+						if err != nil {
+							slog.Error("tfplugingen-framework generate data-sources", "err", err, "stdout", stdOut.String(), "stderr", stdErr.String())
 							return err
 						}
-
-						// slog.Info("Generating terraform svc resource files")
-
-						// noqa:gosec
-						cmd2 := exec.Command(
-							"tfplugingen-framework",
-							"generate",
-							"resources",
-							"--input",
-							specJsonFile,
-							"--output",
-							tgtFolder,
-							"--package",
-							scName,
-						)
-
-						cmd2.Stdout = &stdOut
-						cmd2.Stderr = &stdErr
-						if err = cmd2.Start(); err != nil {
-							slog.Error("tfplugingen-framework generate resources", "error", err)
-							return err
-						}
-
-						if err = cmd2.Wait(); err != nil {
-							var exitErr *exec.ExitError
-							if errors.As(err, &exitErr) {
-								slog.Error("tfplugingen-framework generate resources", "code", exitErr.ExitCode(), "error", err, "stdout", stdOut.String(), "stderr", stdErr.String())
-								return fmt.Errorf("%s", stdErr.String())
-							}
-							if err != nil {
-								slog.Error("tfplugingen-framework generate resources", "err", err, "stdout", stdOut.String(), "stderr", stdErr.String())
-								return err
-							}
-						}
-
-						// slog.Info("Creating terraform svc datasource files folder")
-						tgtFolder = path.Join(rootDir, "generated", "internal", "services", scName, resource, "datasources_gen")
-						err = os.MkdirAll(tgtFolder, 0755)
-						if err != nil {
-							return err
-						}
-
-						// slog.Info("Generating terraform svc resource files")
-
-						// noqa:gosec
-						cmd3 := exec.Command(
-							"tfplugingen-framework",
-							"generate",
-							"data-sources",
-							"--input",
-							specJsonFile,
-							"--output",
-							tgtFolder,
-							"--package",
-							scName,
-						)
-						var stdOut3, stdErr3 bytes.Buffer
-						cmd3.Stdout = &stdOut3
-						cmd3.Stderr = &stdErr3
-
-						if err = cmd3.Start(); err != nil {
-							slog.Error("tfplugingen-framework generate data-sources", "error", err)
-							return err
-						}
-
-						if err = cmd3.Wait(); err != nil {
-							var exitErr *exec.ExitError
-							if errors.As(err, &exitErr) {
-								slog.Error("tfplugingen-framework generate data-sources", "code", exitErr.ExitCode(), "error", err, "stdout", stdOut.String(), "stderr", stdErr.String())
-								return fmt.Errorf("%s", stdErr.String())
-							}
-							if err != nil {
-								slog.Error("tfplugingen-framework generate data-sources", "err", err, "stdout", stdOut.String(), "stderr", stdErr.String())
-								return err
-							}
-						}
 					}
-					//}
 				}
 			}
 		}
@@ -593,7 +603,7 @@ func checkCommands(commands []string) error {
 		if !commandExists(commandName) {
 			return fmt.Errorf("missing command %s", commandName)
 		}
-		slog.Info("found", "command", commandName)
+		slog.Info("        found", "command", commandName)
 	}
 	return nil
 }
@@ -726,32 +736,41 @@ func handleVersion(service string, match []string) (*string, *version, error) {
 	return &resStr, &version{verString: verString, major: majVer, minor: minVer}, nil
 }
 
-func createRepoDir(root, repoUrl, repoName string) (string, error) {
-	oasTmpDir, err := os.MkdirTemp(root, "oas-tmp")
-	if err != nil {
-		return "", err
-	}
-	targetDir := path.Join(oasTmpDir, repoName)
-	_, err = git.Clone(
-		clone.Repository(repoUrl),
-		clone.Directory(targetDir),
-	)
-	if err != nil {
-		return "", err
+func createRepoDir(root, repoUrl, repoName string, skipClone bool) (string, error) {
+	targetDir := path.Join(root, repoName)
+	if !skipClone {
+		if fileExists(targetDir) {
+			slog.Warn("target dir exists - skipping", "targetDir", targetDir)
+			return targetDir, nil
+		}
+		_, err := git.Clone(
+			clone.Repository(repoUrl),
+			clone.Directory(targetDir),
+		)
+		if err != nil {
+			return "", err
+		}
 	}
 	return targetDir, nil
 }
 
-func createGeneratorDir(root, repoUrl, repoName string) (string, error) {
-	targetDir := path.Join(root, repoName)
-	_, err := git.Clone(
-		clone.Repository(repoUrl),
-		clone.Directory(targetDir),
-	)
-	if err != nil {
-		return "", err
+func createGeneratorDir(repoUrl, targetDir string, skipClone bool) error {
+	if !skipClone {
+		if fileExists(targetDir) {
+			remErr := os.RemoveAll(targetDir)
+			if remErr != nil {
+				return remErr
+			}
+		}
+		_, cloneErr := git.Clone(
+			clone.Repository(repoUrl),
+			clone.Directory(targetDir),
+		)
+		if cloneErr != nil {
+			return cloneErr
+		}
 	}
-	return targetDir, nil
+	return nil
 }
 
 func getRoot() (*string, error) {

cmd/cmd/build/templates/resource_scaffold.gotmpl

@@ -3,6 +3,7 @@ package {{.PackageName}}
 import (
 	"context"
 
+    "github.com/hashicorp/terraform-plugin-framework/resource/identityschema"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
 	"github.com/hashicorp/terraform-plugin-framework/types"
 
@@ -17,6 +18,7 @@ var (
 	_ resource.ResourceWithConfigure   = &{{.NameCamel}}Resource{}
 	_ resource.ResourceWithImportState = &{{.NameCamel}}Resource{}
 	_ resource.ResourceWithModifyPlan  = &{{.NameCamel}}Resource{}
+	_ resource.ResourceWithIdentity    = &{{.NameCamel}}Resource{}
 )
 
 func New{{.NamePascal}}Resource() resource.Resource {
@@ -28,6 +30,13 @@ type {{.NameCamel}}Resource struct{
 	providerData core.ProviderData
 }
 
+type InstanceResourceIdentityModel struct {
+	ProjectID  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	InstanceID types.String `tfsdk:"instance_id"`
+	// TODO: implement further needed parts
+}
+
 func (r *{{.NameCamel}}Resource) Metadata(ctx context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
 	resp.TypeName = req.ProviderTypeName + "_{{.PackageName}}_{{.NameSnake}}"
 }
@@ -36,6 +45,23 @@ func (r *{{.NameCamel}}Resource) Schema(ctx context.Context, req resource.Schema
 	resp.Schema = {{.PackageName}}Gen.{{.NamePascal}}ResourceSchema(ctx)
 }
 
+func (r *instanceResource) IdentitySchema(_ context.Context, _ resource.IdentitySchemaRequest, resp *resource.IdentitySchemaResponse) {
+	resp.IdentitySchema = identityschema.Schema{
+		Attributes: map[string]identityschema.Attribute{
+			"project_id": identityschema.StringAttribute{
+				RequiredForImport: true, // must be set during import by the practitioner
+			},
+			"region": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
+			},
+			"instance_id": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
+			},
+		},
+	}
+}
+
+
 // Configure adds the provider configured client to the resource.
 func (r *{{.NameCamel}}Resource) Configure(
 	ctx context.Context,
@@ -81,6 +107,19 @@ func (r *{{.NameCamel}}Resource) Create(ctx context.Context, req resource.Create
 	// Example data value setting
 	data.{{.NameCamel | ucfirst}}Id = types.StringValue("id-from-response")
 
+	// TODO: Set data returned by API in identity
+	identity := InstanceResourceIdentityModel{
+		ProjectID:  types.StringValue(projectId),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceId),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// TODO: implement wait handler if needed
+
 	// Save data into Terraform state
 	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
 
@@ -93,6 +132,13 @@ func (r *{{.NameCamel}}Resource) Read(ctx context.Context, req resource.ReadRequ
 	// Read Terraform prior state data into the model
 	resp.Diagnostics.Append(req.State.Get(ctx, &data)...)
 
+	// Read identity data
+	var identityData InstanceResourceIdentityModel
+	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
 	if resp.Diagnostics.HasError() {
 		return
 	}

cmd/cmd/buildCmd.go

@@ -5,13 +5,29 @@ import (
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/cmd/cmd/build"
 )
 
-func NewBuildCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "build",
-		Short: "Build the necessary boilerplate",
-		Long:  `...`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return build.Build()
-		},
-	}
+var (
+	skipCleanup bool
+	skipClone   bool
+)
+
+var buildCmd = &cobra.Command{
+	Use:   "build",
+	Short: "Build the necessary boilerplate",
+	Long:  `...`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		b := build.Builder{
+			SkipClone:   skipClone,
+			SkipCleanup: skipCleanup,
+		}
+		return b.Build()
+	},
+}
+
+func NewBuildCmd() *cobra.Command {
+	return buildCmd
+}
+
+func init() { // nolint: gochecknoinits
+	buildCmd.Flags().BoolVarP(&skipCleanup, "skip-clean", "c", false, "Skip cleanup steps")
+	buildCmd.Flags().BoolVarP(&skipClone, "skip-clone", "g", false, "Skip cloning from git")
 }