Merge pull request 'fix: spec files in subfolders and refactored builder' (#28) from fix/cmd_refactor_subfolders_and-version into alpha

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

cmd/cmd/build/build.go

@@ -27,6 +27,8 @@ const (
 	GEN_REPO      = "https://github.com/stackitcloud/stackit-sdk-generator.git"
 )
 
+var supportedVersions = []string{"alpha", "beta"}
+
 type version struct {
 	verString string
 	major     int
@@ -35,6 +37,13 @@ type version struct {
 
 func Build() error {
 	slog.Info("Starting Builder")
+
+	slog.Info("Checking needed commands available")
+	err := checkCommands([]string{"tfplugingen-framework", "tfplugingen-openapi"})
+	if err != nil {
+		return err
+	}
+
 	root, err := getRoot()
 	if err != nil {
 		log.Fatal(err)
@@ -209,12 +218,6 @@ func Build() error {
 		}
 	}
 
-	slog.Info("Checking needed commands available")
-	err = checkCommands([]string{"tfplugingen-framework", "tfplugingen-openapi"})
-	if err != nil {
-		return err
-	}
-
 	slog.Info("Generating service boilerplate")
 	err = generateServiceFiles(*root, path.Join(*root, GEN_REPO_NAME))
 	if err != nil {
@@ -400,159 +403,184 @@ func generateServiceFiles(rootDir, generatorDir string) error {
 		return err
 	}
 
-	specs, err := os.ReadDir(path.Join(rootDir, "service_specs"))
+	services, err := os.ReadDir(path.Join(rootDir, "service_specs"))
 	if err != nil {
 		return err
 	}
-	for _, spec := range specs {
+	for _, service := range services {
-		if spec.IsDir() {
+		if !service.IsDir() {
 			continue
 		}
-		// slog.Info("Checking spec", "name", spec.Name())
-		r := regexp.MustCompile(`^([a-z-]+)_(.*)_config.yml$`)
-		matches := r.FindAllStringSubmatch(spec.Name(), -1)
-		if matches != nil {
-			fileName := matches[0][0]
-			service := matches[0][1]
-			resource := matches[0][2]
-			slog.Info(
-				"Found service spec",
-				"name",
-				spec.Name(),
-				"service",
-				service,
-				"resource",
-				resource,
-			)
 
-			for _, part := range []string{"alpha", "beta"} {
+		versions, err := os.ReadDir(path.Join(rootDir, "service_specs", service.Name()))
-				oasFile := path.Join(generatorDir, "oas", fmt.Sprintf("%s%s.json", service, part))
+		if err != nil {
-				if _, err = os.Stat(oasFile); !os.IsNotExist(err) {
+			return err
-					slog.Info("found matching oas", "service", service, "version", part)
+		}
-					scName := fmt.Sprintf("%s%s", service, part)
+		for _, svcVersion := range versions {
-					scName = strings.ReplaceAll(scName, "-", "")
+			if !svcVersion.IsDir() {
-					err = os.MkdirAll(path.Join(rootDir, "generated", "internal", "services", scName, resource), 0755)
+				continue
-					if err != nil {
+			}
-						return err
-					}
 
-					// slog.Info("Generating openapi spec json")
+			if svcVersion.Name() != "alpha" && svcVersion.Name() != "beta" {
-					specFile := path.Join(rootDir, "generated", "specs", fmt.Sprintf("%s_%s_spec.json", scName, resource))
+				continue
+			}
 
-					var stdOut, stdErr bytes.Buffer
+			specFiles, err := os.ReadDir(path.Join(rootDir, "service_specs", service.Name(), svcVersion.Name()))
+			if err != nil {
+				return err
+			}
 
-					// noqa:gosec
+			for _, specFile := range specFiles {
-					cmd := exec.Command(
+				if specFile.IsDir() {
-						"tfplugingen-openapi",
+					continue
-						"generate",
+				}
-						"--config",
-						path.Join(rootDir, "service_specs", fileName),
-						"--output",
-						specFile,
-						oasFile,
-					)
-					cmd.Stdout = &stdOut
-					cmd.Stderr = &stdErr
 
-					if err = cmd.Start(); err != nil {
+				// slog.Info("Checking spec", "name", spec.Name())
-						slog.Error("tfplugingen-openapi generate", "error", err)
+				r := regexp.MustCompile(`^(.*)_config.yml$`)
-						return err
+				matches := r.FindAllStringSubmatch(specFile.Name(), -1)
-					}
+				if matches != nil {
-
+					fileName := matches[0][0]
-					if err = cmd.Wait(); err != nil {
+					resource := matches[0][1]
-						var exitErr *exec.ExitError
+					slog.Info(
-						if errors.As(err, &exitErr) {
+						"Found service spec",
-							slog.Error("tfplugingen-openapi generate", "code", exitErr.ExitCode(), "error", err, "stdout", stdOut.String(), "stderr", stdErr.String())
+						"name",
-							return fmt.Errorf("%s", stdErr.String())
+						specFile.Name(),
-						}
+						"service",
-						if err != nil {
+						service.Name(),
-							slog.Error("tfplugingen-openapi generate", "err", err, "stdout", stdOut.String(), "stderr", stdErr.String())
+						"resource",
-							return err
+						resource,
-						}
-					}
-
-					// slog.Info("Creating terraform service 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 service resource files")
-
-					// noqa:gosec
-					cmd2 := exec.Command(
-						"tfplugingen-framework",
-						"generate",
-						"resources",
-						"--input",
-						specFile,
-						"--output",
-						tgtFolder,
-						"--package",
-						scName,
 					)
 
-					cmd2.Stdout = &stdOut
+					//for _, part := range []string{"alpha", "beta"} {
-					cmd2.Stderr = &stdErr
+					oasFile := path.Join(generatorDir, "oas", fmt.Sprintf("%s%s.json", service.Name(), svcVersion))
-					if err = cmd2.Start(); err != nil {
+					if _, err = os.Stat(oasFile); !os.IsNotExist(err) {
-						slog.Error("tfplugingen-framework generate resources", "error", err)
+						slog.Info("found matching oas", "svc", service.Name(), "version", svcVersion.Name())
-						return err
+						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 = 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 service datasource files folder")
+						// slog.Info("Generating openapi spec json")
-					tgtFolder = path.Join(rootDir, "generated", "internal", "services", scName, resource, "datasources_gen")
+						specJsonFile := path.Join(rootDir, "generated", "specs", fmt.Sprintf("%s_%s_spec.json", scName, resource))
-					err = os.MkdirAll(tgtFolder, 0755)
-					if err != nil {
-						return err
-					}
 
-					// slog.Info("Generating terraform service resource files")
+						var stdOut, stdErr bytes.Buffer
 
-					// noqa:gosec
+						// noqa:gosec
-					cmd3 := exec.Command(
+						cmd := exec.Command(
-						"tfplugingen-framework",
+							"tfplugingen-openapi",
-						"generate",
+							"generate",
-						"data-sources",
+							"--config",
-						"--input",
+							path.Join(rootDir, "service_specs", fileName),
-						specFile,
+							"--output",
-						"--output",
+							specJsonFile,
-						tgtFolder,
+							oasFile,
-						"--package",
+						)
-						scName,
+						cmd.Stdout = &stdOut
-					)
+						cmd.Stderr = &stdErr
-					var stdOut3, stdErr3 bytes.Buffer
-					cmd3.Stdout = &stdOut3
-					cmd3.Stderr = &stdErr3
 
-					if err = cmd3.Start(); err != nil {
+						if err = cmd.Start(); err != nil {
-						slog.Error("tfplugingen-framework generate data-sources", "error", err)
+							slog.Error("tfplugingen-openapi generate", "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
 						}
+
+						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 {
+							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
+							}
+						}
 					}
+					//}
 				}
 			}
 		}