update

Author: reshnm

cmd/manageDeploymentRepo.go

@@ -1,21 +1,15 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"time"
 
 	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/config"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/object"
+	deploymentrepo "github.com/openmcp-project/bootstrapper/internal/deployment-repo"
+	"github.com/openmcp-project/bootstrapper/internal/log"
+	"github.com/openmcp-project/bootstrapper/internal/util"
 	"github.com/spf13/cobra"
 
 	gitconfig "github.com/openmcp-project/bootstrapper/internal/git-config"
-	"github.com/openmcp-project/bootstrapper/internal/template"
 )
 
 const (
@@ -25,34 +19,34 @@ const (
 type LogWriter struct{}
 
 func (w LogWriter) Write(p []byte) (n int, err error) {
-	log.Print(string(p))
+	logger := log.GetLogger()
+	logger.Debugf("Git progress: %s", string(p))
 	return len(p), nil
 }
 
 // manageDeploymentRepoCmd represents the manageDeploymentRepo command
 var manageDeploymentRepoCmd = &cobra.Command{
 	Use:   "manageDeploymentRepo",
-	Short: "A brief description of your command",
-	Long: `A longer description that spans multiple lines and likely contains examples
-and usage of using your command. For example:
-
-Cobra is a CLI library for Go that empowers applications.
-This application is a tool to generate the needed files
-to quickly create a Cobra application.`,
+	Short: "Updates the openMCP deployment specification in the specified Git repository",
+	Long: `Updates the openMCP deployment specification in the specified Git repository.
+The update is based on the specified component version.
+openmcp-bootstrapper manageDeploymentRepo <componentLocation> <templateDirectory> <deploymentRepository> <deploymentRepositoryBranch>`,
 	Args: cobra.ExactArgs(4),
 	ArgAliases: []string{
 		"componentLocation",
 		"templateDirectory",
 		"deploymentRepository",
 		"deploymentRepositoryBranch",
 	},
+	Example: `  openmcp-bootstrapper manageDeploymentRepo "ghcr.io/openmcp-project/components//github.com/openmcp-project/openmcp:${OPENMCP_VERSION}" ./templates "https://github.com/${GITHUB_USER}/deployment-repo.git" incoming-branch`,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		//componentLocation := args[0]
 		templateDirectory := args[1]
 		deploymentRepository := args[2]
 		deploymentRepositoryBranch := args[3]
 
-		log.Println("parsing git config file from flag:", cmd.Flag(FlagGitConfig).Value.String())
+		logger := log.GetLogger()
+		logger.Debug("parsing git config file from flag:", cmd.Flag(FlagGitConfig).Value.String())
 
 		gitConfig, err := gitconfig.ParseConfig(cmd.Flag(FlagGitConfig).Value.String())
 		if err != nil {
@@ -70,164 +64,40 @@ to quickly create a Cobra application.`,
 			return err
 		}
 
-		tmpDir, err := os.MkdirTemp("", "deployment-repo-")
-		if err != nil {
-			return fmt.Errorf("failed to create temp dir: %w", err)
-		}
-
-		repo, err := CloneRepo(deploymentRepository, tmpDir, gitConfig)
-		log.Println("Cloned repository to temporary directory: ", tmpDir)
+		tempDir, err := util.CreateTempDir("deployment-repo-")
+		logger.Tracef("Created temp dir: %s", tempDir)
 		if err != nil {
-			return fmt.Errorf("failed to clone repository: %w", err)
+			return fmt.Errorf("failed to create temporary directory for deployment repository: %w", err)
 		}
-		defer func(path string) {
-			err := os.RemoveAll(path)
-			if err != nil {
-				_, _ = fmt.Fprintf(os.Stderr, "failed to remove temporary directory %s: %v\n", path, err)
+		defer func() {
+			if err := util.DeleteTempDir(tempDir); err != nil {
+				logger.Errorf("failed to delete temporary directory %s: %v", tempDir, err)
 			}
-		}(tmpDir)
+		}()
 
-		// Check if branch exists (local or remote)
-		branchExists := false
-		references, err := repo.References()
+		repo, err := deploymentrepo.CloneRepo(deploymentRepository, tempDir, gitConfig)
 		if err != nil {
-			return fmt.Errorf("failed to list references: %w", err)
-		}
-		localRef := plumbing.NewBranchReferenceName(deploymentRepositoryBranch)
-		remoteRef := plumbing.NewRemoteReferenceName("origin", deploymentRepositoryBranch)
-		err = references.ForEach(func(ref *plumbing.Reference) error {
-			log.Printf("Found reference: %s", ref.Name())
-			if ref.Name() == localRef || ref.Name() == remoteRef {
-				branchExists = true
-				log.Printf("Branch %s exists as %s", deploymentRepositoryBranch, ref.Name())
-			}
-			return nil
-		})
-		if err != nil {
-			return err
+			return fmt.Errorf("failed to clone deployment repository: %w", err)
 		}
 
-		workTree, err := repo.Worktree()
+		err = deploymentrepo.CheckoutAndCreateBranchIfNotExists(repo, deploymentRepositoryBranch, gitConfig)
 		if err != nil {
-			return fmt.Errorf("failed to get worktree: %w", err)
-		}
-
-		if !branchExists {
-			// Create and checkout new branch
-			log.Printf("Branch %s does not exist. Creating...\n", deploymentRepositoryBranch)
-			err = workTree.Checkout(&git.CheckoutOptions{
-				Branch: localRef,
-				Create: true,
-			})
-			if err != nil {
-				return fmt.Errorf("failed to create branch: %w", err)
-			}
-
-			pushOptions := &git.PushOptions{
-				RefSpecs: []config.RefSpec{
-					config.RefSpec(localRef + ":" + localRef),
-				},
-				Progress: LogWriter{},
-			}
-
-			if err := gitConfig.ConfigurePushOptions(pushOptions); err != nil {
-				return fmt.Errorf("failed to configure push options: %w", err)
-			}
-
-			// Push new branch to remote
-			err = repo.Push(pushOptions)
-			if err != nil && !errors.Is(err, git.NoErrAlreadyUpToDate) {
-				return fmt.Errorf("failed to push new branch: %w", err)
-			}
-		} else {
-			// Checkout existing branch
-			err = workTree.Checkout(&git.CheckoutOptions{
-				Branch: remoteRef,
-			})
-			if err != nil {
-				return fmt.Errorf("failed to checkout branch: %w", err)
-			}
+			return fmt.Errorf("failed to checkout or create branch %s: %w", deploymentRepositoryBranch, err)
 		}
 
-		// open the template directory
-		templateDir, err := os.Open(templateDirectory)
+		err = deploymentrepo.TemplateDir(templateDirectory, repo)
 		if err != nil {
-			return fmt.Errorf("failed to open template directory: %w", err)
+			return fmt.Errorf("failed to apply templates from directory %s: %w", templateDirectory, err)
 		}
-		defer func() {
-			if err := templateDir.Close(); err != nil {
-				fmt.Fprintf(os.Stderr, "failed to close template directory: %v\n", err)
-			}
-		}()
-
-		te := template.NewTemplateExecution()
-		templateInput := make(map[string]interface{})
-
-		// Recursively walk through all files in the template directory
-		err = filepath.WalkDir(templateDirectory, func(path string, d os.DirEntry, err error) error {
-			if err != nil {
-				return err
-			}
-			if !d.IsDir() {
-				// Process the file (path)
-				log.Printf("Found file: %s\n", path)
-				template, err := os.ReadFile(path)
-				if err != nil {
-					return fmt.Errorf("failed to read template file %s: %w", path, err)
-				}
-
-				templateResult, err := te.Execute(path, string(template), templateInput)
-				if err != nil {
-					return fmt.Errorf("failed to execute template %s: %w", path, err)
-				}
 
-				pathInRepo, err := filepath.Rel(templateDirectory, path)
-				fileInWt, err := workTree.Filesystem.OpenFile(pathInRepo, os.O_WRONLY|os.O_CREATE, 0644)
-				if err != nil {
-					return fmt.Errorf("failed to open file in worktree %s: %w", path, err)
-				}
-				defer fileInWt.Close()
-				_, err = fileInWt.Write(templateResult)
-				if err != nil {
-					return fmt.Errorf("failed to write to file in worktree %s: %w", path, err)
-				}
-				// Add the file to the git index
-				if _, err := workTree.Add(pathInRepo); err != nil {
-					return fmt.Errorf("failed to add file to git index: %w", err)
-				}
-			}
-			return nil
-		})
+		err = deploymentrepo.CommitChanges(repo, "apply templates", "openmcp", "[email protected]")
 		if err != nil {
-			return fmt.Errorf("failed to walk template directory: %w", err)
+			return fmt.Errorf("failed to commit changes: %w", err)
 		}
 
-		// Commit the changes
-		commitMsg := "Update deployment repo with template files"
-		_, err = workTree.Commit(commitMsg, &git.CommitOptions{
-			Author: &object.Signature{
-				Name:  "openmcp-bootstrapper",
-				Email: "[email protected]",
-				When:  time.Now(),
-			},
-		})
+		err = deploymentrepo.PushRepo(repo, gitConfig)
 		if err != nil {
-			if !errors.Is(err, git.ErrEmptyCommit) {
-				return fmt.Errorf("failed to commit changes: %w", err)
-			}
-		}
-
-		// Push the changes
-		pushOptions := &git.PushOptions{}
-		if err := gitConfig.ConfigurePushOptions(pushOptions); err != nil {
-			return fmt.Errorf("failed to configure push options: %w", err)
-		}
-		pushOptions.Progress = LogWriter{}
-		err = repo.Push(pushOptions)
-		if err != nil {
-			if !errors.Is(err, git.NoErrAlreadyUpToDate) {
-				return fmt.Errorf("failed to push changes: %w", err)
-			}
+			return fmt.Errorf("failed to push changes to deployment repository: %w", err)
 		}
 
 		return nil
@@ -237,6 +107,8 @@ to quickly create a Cobra application.`,
 func init() {
 	RootCmd.AddCommand(manageDeploymentRepoCmd)
 
+	manageDeploymentRepoCmd.Flags().SortFlags = false
+
 	manageDeploymentRepoCmd.Flags().StringArray("cluster-providers", nil, "List of cluster providers to manage")
 	manageDeploymentRepoCmd.Flags().StringArray("serviceProviders", nil, "List of service providers to manage")
 	manageDeploymentRepoCmd.Flags().StringArray("platformServices", nil, "List of platform services to manage")
@@ -248,21 +120,3 @@ func init() {
 		panic(err)
 	}
 }
-
-func CloneRepo(repoURL, path string, config *gitconfig.Config) (*git.Repository, error) {
-	cloneOptions := &git.CloneOptions{
-		URL:          repoURL,
-		SingleBranch: false,
-	}
-
-	if err := config.ConfigureCloneOptions(cloneOptions); err != nil {
-		return nil, err
-	}
-
-	repo, err := git.PlainClone(path, false, cloneOptions)
-	if err != nil {
-		return nil, fmt.Errorf("failed to clone repository: %w", err)
-	}
-
-	return repo, nil
-}