feat: add --from-controller flag for self-contained code generation

Adds `ack-generate controller <service> --from-controller` and
`ack-generate release <service> <version> --from-controller`, which run
the full generation pipeline from within a controller repo without
needing shell scripts or a local code-generator checkout.

Usage (from a controller repo):
  ack-generate controller s3 --from-controller
  ack-generate release s3 v1.2.3 --from-controller

The generated Makefile wires these up:
  make generate          # installs ack-generate, runs controller --from-controller
  make release V=v1.2.3  # installs ack-generate, runs release --from-controller

Without --from-controller, both commands behave exactly as before —
existing generation via build-controller.sh and build-controller-release.sh
is unaffected.

Author: michaelhtm

cmd/ack-generate/command/apis.go

@@ -112,7 +112,7 @@ func generateAPIs(cmd *cobra.Command, args []string) error {
 	util.Tracef("loadModel: %s\n", time.Since(modelStart))
 
 	apisStart := time.Now()
-	ts, err := ackgenerate.APIs(m, optTemplateDirs)
+	ts, err := ackgenerate.APIs(m, optTemplateDirs, embeddedTemplatesFS)
 	if err != nil {
 		return err
 	}

cmd/ack-generate/command/controller.go

@@ -16,6 +16,7 @@ package command
 import (
 	"fmt"
 	"io/ioutil"
+	"os"
 	"path/filepath"
 	"strings"
 	"time"
@@ -29,28 +30,44 @@ import (
 )
 
 var (
-	cmdControllerPath string
-	pkgResourcePath   string
-	latestAPIVersion  string
+	cmdControllerPath    string
+	pkgResourcePath      string
+	latestAPIVersion     string
+	optRunFromController bool
 )
 
 var controllerCmd = &cobra.Command{
 	Use:   "controller <service>",
 	Short: "Generates Go files containing service controller implementation for a given service",
-	RunE:  generateController,
+	Long: `When --from-controller is set, runs the full generation pipeline from the
+current working directory (which must be a controller repo). This includes
+APIs, deepcopy, CRDs, controller code, RBAC, formatting, and boilerplate
+file copying. Without it, only generates the controller Go code.`,
+	RunE: generateController,
 }
 
 func init() {
+	controllerCmd.PersistentFlags().BoolVar(
+		&optRunFromController, "from-controller", false,
+		"Run the full generation pipeline from the current directory (must be a controller repo).",
+	)
 	rootCmd.AddCommand(controllerCmd)
 }
 
-// generateController generates the Go files for a service controller
+// generateController generates the Go files for a service controller.
+// When --controller-source-path is provided, it runs the full pipeline
+// (APIs + deepcopy + CRDs + controller code + RBAC + formatting + boilerplate).
 func generateController(cmd *cobra.Command, args []string) error {
 	cmdStart := time.Now()
 	if len(args) != 1 {
 		return fmt.Errorf("please specify the service alias for the AWS service API to generate")
 	}
 	svcAlias := strings.ToLower(args[0])
+
+	if optRunFromController {
+		return generateControllerFullPipeline(svcAlias)
+	}
+
 	if optOutputPath == "" {
 		optOutputPath = filepath.Join(optServicesDir, svcAlias)
 	}
@@ -78,7 +95,7 @@ func generateController(cmd *cobra.Command, args []string) error {
 	}
 
 	ctrlStart := time.Now()
-	ts, err := ackgenerate.Controller(m, optTemplateDirs, serviceAccountName)
+	ts, err := ackgenerate.Controller(m, optTemplateDirs, serviceAccountName, embeddedTemplatesFS)
 	if err != nil {
 		return err
 	}
@@ -110,3 +127,148 @@ func generateController(cmd *cobra.Command, args []string) error {
 	util.Tracef("generateController total: %s\n", time.Since(cmdStart))
 	return nil
 }
+
+// generateControllerFullPipeline runs the complete generation pipeline when
+// --controller-source-path is provided.
+func generateControllerFullPipeline(svcAlias string) error {
+	controllerPath, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("determining current directory: %w", err)
+	}
+
+	// Resolve config paths from the controller repo if not explicitly set
+	resolved := ackgenerate.ResolveConfigPaths(controllerPath)
+	if optGeneratorConfigPath == "" {
+		optGeneratorConfigPath = resolved.GeneratorConfigPath
+	}
+	if optMetadataConfigPath == "" {
+		optMetadataConfigPath = resolved.MetadataConfigPath
+	}
+	if optDocumentationConfigPath == "" {
+		optDocumentationConfigPath = resolved.DocumentationConfigPath
+	}
+
+	if optOutputPath == "" {
+		optOutputPath = controllerPath
+	}
+
+	rbacRoleName := fmt.Sprintf("ack-%s-controller", svcAlias)
+
+	if optServiceAccountName == "" {
+		optServiceAccountName = fmt.Sprintf("ack-%s-controller", svcAlias)
+	}
+
+	runtimeVersion, err := ackgenerate.ResolveRuntimeVersion(controllerPath)
+	if err != nil {
+		return fmt.Errorf("resolving runtime version: %w", err)
+	}
+
+	// Detect template overrides in the controller repo
+	svcTemplatesDir := filepath.Join(controllerPath, "templates")
+	if fi, err := os.Stat(svcTemplatesDir); err == nil && fi.IsDir() {
+		optTemplateDirs = append([]string{svcTemplatesDir}, optTemplateDirs...)
+	}
+
+	// Load generator config to resolve model name before fetching
+	cfg, err := setupGenerator(svcAlias)
+	if err != nil {
+		return err
+	}
+
+	metadata, err := ackmetadata.NewServiceMetadata(optMetadataConfigPath)
+	if err != nil {
+		return err
+	}
+	m, err := loadModelWithLatestAPIVersion(svcAlias, metadata, cfg)
+	if err != nil {
+		return err
+	}
+
+	apiVersion := "v1alpha1"
+	if len(metadata.APIVersions) > 0 {
+		av, err := getLatestAPIVersion(metadata.APIVersions)
+		if err == nil {
+			apiVersion = av
+		}
+	}
+
+	// Step 1: Runtime CRDs + controller-gen steps (pre-codegen)
+	pipelineOpts := ackgenerate.BuildControllerOptions{
+		SvcAlias:             svcAlias,
+		ControllerSourcePath: controllerPath,
+		APIVersion:           apiVersion,
+		RBACRoleName:         rbacRoleName,
+		RuntimeVersion:       runtimeVersion,
+		BoilerplateFS:        embeddedBoilerplateFS,
+		TemplatesFS:          embeddedTemplatesFS,
+	}
+
+	// Step 2: Generate APIs
+	fmt.Printf("Building Kubernetes API objects for %s\n", svcAlias)
+	apisTS, err := ackgenerate.APIs(m, optTemplateDirs, embeddedTemplatesFS)
+	if err != nil {
+		return err
+	}
+	if err = apisTS.Execute(); err != nil {
+		return err
+	}
+	apisVersionPath := filepath.Join(optOutputPath, "apis", apiVersion)
+	for path, contents := range apisTS.Executed() {
+		outPath := filepath.Join(apisVersionPath, path)
+		outDir := filepath.Dir(outPath)
+		if _, err := sdk.EnsureDir(outDir); err != nil {
+			return err
+		}
+		if err = ioutil.WriteFile(outPath, contents.Bytes(), 0666); err != nil {
+			return err
+		}
+	}
+
+	// Save generation metadata (ack-generate-metadata.yaml) and copy generator.yaml
+	apisPath := filepath.Join(optOutputPath, "apis")
+	if err = ackmetadata.CreateGenerationMetadata(
+		apiVersion,
+		apisPath,
+		ackmetadata.UpdateReasonAPIGeneration,
+		sdkVersion,
+		optGeneratorConfigPath,
+	); err != nil {
+		return fmt.Errorf("creating generation metadata: %w", err)
+	}
+	generatorCopyDest := filepath.Join(apisPath, apiVersion, "generator.yaml")
+	if err = util.CopyFile(optGeneratorConfigPath, generatorCopyDest); err != nil {
+		return fmt.Errorf("copying generator.yaml: %w", err)
+	}
+
+	// Pre-codegen pipeline steps (runtime CRDs, deepcopy, CRDs)
+	if err := ackgenerate.BuildControllerPreCodegen(pipelineOpts); err != nil {
+		return err
+	}
+
+	// Step 5: Generate controller code
+	fmt.Printf("Building service controller for %s\n", svcAlias)
+	serviceAccountName, err := getServiceAccountName()
+	if err != nil {
+		return err
+	}
+	ctrlTS, err := ackgenerate.Controller(m, optTemplateDirs, serviceAccountName, embeddedTemplatesFS)
+	if err != nil {
+		return err
+	}
+	if err = ctrlTS.Execute(); err != nil {
+		return err
+	}
+	for path, contents := range ctrlTS.Executed() {
+		outPath := filepath.Join(optOutputPath, path)
+		outDir := filepath.Dir(outPath)
+		if _, err := sdk.EnsureDir(outDir); err != nil {
+			return err
+		}
+		if err = ioutil.WriteFile(outPath, contents.Bytes(), 0666); err != nil {
+			return err
+		}
+	}
+
+	// Post-codegen pipeline steps (go mod tidy, RBAC, formatting, boilerplate)
+	return ackgenerate.BuildControllerPostCodegen(pipelineOpts)
+}

cmd/ack-generate/command/olm.go

@@ -127,7 +127,7 @@ func generateOLMAssets(cmd *cobra.Command, args []string) error {
 	}
 
 	// generate templates
-	ts, err := olmgenerate.BundleAssets(m, commonMeta, svcConf, version, optImageRepository, optTemplateDirs)
+	ts, err := olmgenerate.BundleAssets(m, commonMeta, svcConf, version, optImageRepository, optTemplateDirs, embeddedTemplatesFS)
 	if err != nil {
 		return err
 	}

cmd/ack-generate/command/release.go

@@ -16,6 +16,7 @@ package command
 import (
 	"fmt"
 	"io/ioutil"
+	"os"
 	"path/filepath"
 	"strings"
 
@@ -26,39 +27,77 @@ import (
 	"github.com/aws-controllers-k8s/code-generator/pkg/sdk"
 )
 
-var optReleaseOutputPath string
+var (
+	optReleaseOutputPath    string
+	optRelRunFromController bool
+)
 
 var releaseCmd = &cobra.Command{
 	Use:   "release <service> <release_version>",
 	Short: "Generates release artifacts for a specific service controller and release version",
-	RunE:  generateRelease,
+	Long: `When --from-controller is set, runs the full release pipeline from the current
+working directory (which must be a controller repo). This includes template
+generation, CRDs, RBAC, and Helm template post-processing. Without it, only
+generates the release templates.`,
+	RunE: generateRelease,
 }
 
 func init() {
 	releaseCmd.PersistentFlags().StringVarP(
 		&optReleaseOutputPath, "output", "o", "", "path to root directory to create generated files. Defaults to "+optServicesDir+"/$service",
 	)
+	releaseCmd.PersistentFlags().BoolVar(
+		&optRelRunFromController, "from-controller", false,
+		"Run the full release pipeline from the current directory (must be a controller repo).",
+	)
 	rootCmd.AddCommand(releaseCmd)
 }
 
 // generateRelease generates the Helm charts and other release artifacts for a
-// service controller and release version
+// service controller and release version. When --controller-source-path is
+// provided, it also runs the post-processing pipeline (CRDs, RBAC, Helm
+// template patching).
 func generateRelease(cmd *cobra.Command, args []string) error {
 	if len(args) != 2 {
 		return fmt.Errorf("please specify the service alias and the release version to generate release artifacts for")
 	}
 	svcAlias := strings.ToLower(args[0])
+	releaseVersion := strings.ToLower(args[1])
+
+	var controllerPath string
+	if optRelRunFromController {
+		var err error
+		controllerPath, err = os.Getwd()
+		if err != nil {
+			return fmt.Errorf("determining current directory: %w", err)
+		}
+
+		resolved := ackgenerate.ResolveConfigPaths(controllerPath)
+		if optGeneratorConfigPath == "" {
+			optGeneratorConfigPath = resolved.GeneratorConfigPath
+		}
+		if optMetadataConfigPath == "" {
+			optMetadataConfigPath = resolved.MetadataConfigPath
+		}
+		if optDocumentationConfigPath == "" {
+			optDocumentationConfigPath = resolved.DocumentationConfigPath
+		}
+	}
+
 	if optReleaseOutputPath == "" {
-		optReleaseOutputPath = filepath.Join(optServicesDir, svcAlias)
+		if controllerPath != "" {
+			optReleaseOutputPath = controllerPath
+		} else {
+			optReleaseOutputPath = filepath.Join(optServicesDir, svcAlias)
+		}
 	}
 	if optImageRepository == "" {
 		optImageRepository = fmt.Sprintf("public.ecr.aws/aws-controllers-k8s/%s-controller", svcAlias)
 	}
-	// TODO(jaypipes): We could do some git-fu here to verify that the release
-	// version supplied hasn't been used (as a Git tag) before...
-	releaseVersion := strings.ToLower(args[1])
+	if optServiceAccountName == "" {
+		optServiceAccountName = fmt.Sprintf("ack-%s-controller", svcAlias)
+	}
 
-	// Load generator config to resolve model name before fetching
 	cfg, err := setupGenerator(svcAlias)
 	if err != nil {
 		return err
@@ -74,9 +113,11 @@ func generateRelease(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	fmt.Printf("Building release artifacts for %s-%s\n", svcAlias, releaseVersion)
 	ts, err := ackgenerate.Release(
 		m, metadata, optTemplateDirs,
 		releaseVersion, optImageRepository, optServiceAccountName,
+		embeddedTemplatesFS,
 	)
 	if err != nil {
 		return err
@@ -101,5 +142,32 @@ func generateRelease(cmd *cobra.Command, args []string) error {
 			return err
 		}
 	}
+
+	if optRelRunFromController {
+		apiVersion := "v1alpha1"
+		if len(metadata.APIVersions) > 0 {
+			av, err := getLatestAPIVersion(metadata.APIVersions)
+			if err == nil {
+				apiVersion = av
+			}
+		}
+
+		runtimeVersion, err := ackgenerate.ResolveRuntimeVersion(controllerPath)
+		if err != nil {
+			return fmt.Errorf("resolving runtime version: %w", err)
+		}
+
+		releaseOpts := ackgenerate.BuildReleaseOptions{
+			SvcAlias:             svcAlias,
+			ControllerSourcePath: controllerPath,
+			APIVersion:           apiVersion,
+			RBACRoleName:         fmt.Sprintf("ack-%s-controller", svcAlias),
+			RuntimeVersion:       runtimeVersion,
+		}
+		if err := ackgenerate.BuildRelease(releaseOpts); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }