update

Author: reshnm

cmd/manageDeploymentRepo.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"errors"
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
 	"time"
@@ -21,6 +22,13 @@ const (
 	FlagGitConfig = "git-config"
 )
 
+type LogWriter struct{}
+
+func (w LogWriter) Write(p []byte) (n int, err error) {
+	log.Print(string(p))
+	return len(p), nil
+}
+
 // manageDeploymentRepoCmd represents the manageDeploymentRepo command
 var manageDeploymentRepoCmd = &cobra.Command{
 	Use:   "manageDeploymentRepo",
@@ -31,16 +39,20 @@ 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.`,
-	Args: cobra.ExactArgs(3),
+	Args: cobra.ExactArgs(4),
 	ArgAliases: []string{
+		"componentLocation",
+		"templateDirectory",
 		"deploymentRepository",
 		"deploymentRepositoryBranch",
-		"templateDirectory",
 	},
 	RunE: func(cmd *cobra.Command, args []string) error {
-		deploymentRepository := args[0]
-		deploymentRepositoryBranch := args[1]
-		templateDirectory := args[2]
+		//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())
 
 		gitConfig, err := gitconfig.ParseConfig(cmd.Flag(FlagGitConfig).Value.String())
 		if err != nil {
@@ -51,37 +63,49 @@ to quickly create a Cobra application.`,
 		}
 
 		cloneOptions := &git.CloneOptions{
-			URL: deploymentRepository,
+			URL:      deploymentRepository,
+			Progress: LogWriter{},
 		}
 		if err := gitConfig.ConfigureCloneOptions(cloneOptions); err != nil {
 			return err
 		}
 
-		repo, tmpDir, err := CloneRepo(deploymentRepository, gitConfig)
-		fmt.Printf("Cloned repository to temporary directory: %s\n", tmpDir)
+		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)
 		if err != nil {
 			return fmt.Errorf("failed to clone 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)
+				_, _ = fmt.Fprintf(os.Stderr, "failed to remove temporary directory %s: %v\n", path, err)
 			}
 		}(tmpDir)
 
-		// Check if branch exists
+		// Check if branch exists (local or remote)
 		branchExists := false
-		branches, err := repo.Branches()
+		references, err := repo.References()
 		if err != nil {
-			return fmt.Errorf("failed to list branches: %w", err)
+			return fmt.Errorf("failed to list references: %w", err)
 		}
-		branchRefName := plumbing.NewBranchReferenceName(deploymentRepositoryBranch)
-		branches.ForEach(func(ref *plumbing.Reference) error {
-			if ref.Name() == branchRefName {
+		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
+		}
 
 		workTree, err := repo.Worktree()
 		if err != nil {
@@ -90,9 +114,9 @@ to quickly create a Cobra application.`,
 
 		if !branchExists {
 			// Create and checkout new branch
-			fmt.Printf("Branch %s does not exist. Creating...\n", deploymentRepositoryBranch)
+			log.Printf("Branch %s does not exist. Creating...\n", deploymentRepositoryBranch)
 			err = workTree.Checkout(&git.CheckoutOptions{
-				Branch: branchRefName,
+				Branch: localRef,
 				Create: true,
 			})
 			if err != nil {
@@ -101,8 +125,9 @@ to quickly create a Cobra application.`,
 
 			pushOptions := &git.PushOptions{
 				RefSpecs: []config.RefSpec{
-					config.RefSpec(branchRefName + ":" + branchRefName),
+					config.RefSpec(localRef + ":" + localRef),
 				},
+				Progress: LogWriter{},
 			}
 
 			if err := gitConfig.ConfigurePushOptions(pushOptions); err != nil {
@@ -117,7 +142,7 @@ to quickly create a Cobra application.`,
 		} else {
 			// Checkout existing branch
 			err = workTree.Checkout(&git.CheckoutOptions{
-				Branch: branchRefName,
+				Branch: remoteRef,
 			})
 			if err != nil {
 				return fmt.Errorf("failed to checkout branch: %w", err)
@@ -145,7 +170,7 @@ to quickly create a Cobra application.`,
 			}
 			if !d.IsDir() {
 				// Process the file (path)
-				fmt.Printf("Found file: %s\n", 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)
@@ -197,6 +222,7 @@ to quickly create a Cobra application.`,
 		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) {
@@ -211,31 +237,32 @@ to quickly create a Cobra application.`,
 func init() {
 	RootCmd.AddCommand(manageDeploymentRepoCmd)
 
-	manageDeploymentRepoCmd.PersistentFlags().StringP("ocm-config", "", "", "ocm configuration file")
-	manageDeploymentRepoCmd.Flags().StringP(FlagGitConfig, "", "", "Git configuration file")
+	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")
+
+	manageDeploymentRepoCmd.Flags().String("ocm-config", "", "ocm configuration file")
+	manageDeploymentRepoCmd.Flags().String(FlagGitConfig, "", "Git configuration file")
+
 	if err := manageDeploymentRepoCmd.MarkFlagRequired(FlagGitConfig); err != nil {
 		panic(err)
 	}
 }
 
-func CloneRepo(repoURL string, config *gitconfig.Config) (*git.Repository, string, error) {
+func CloneRepo(repoURL, path string, config *gitconfig.Config) (*git.Repository, error) {
 	cloneOptions := &git.CloneOptions{
-		URL: repoURL,
+		URL:          repoURL,
+		SingleBranch: false,
 	}
 
 	if err := config.ConfigureCloneOptions(cloneOptions); err != nil {
-		return nil, "", err
-	}
-
-	tmpDir, err := os.MkdirTemp("", "deployment-repo-")
-	if err != nil {
-		return nil, "", fmt.Errorf("failed to create temp dir: %w", err)
+		return nil, err
 	}
 
-	repo, err := git.PlainClone(tmpDir, false, cloneOptions)
+	repo, err := git.PlainClone(path, false, cloneOptions)
 	if err != nil {
-		return nil, tmpDir, fmt.Errorf("failed to clone repository: %w", err)
+		return nil, fmt.Errorf("failed to clone repository: %w", err)
 	}
 
-	return repo, tmpDir, nil
+	return repo, nil
 }