feat: add dry run option, version option and shorthand for flags

Author: BoxBoxJason

cmd/main.go

@@ -13,25 +13,23 @@ import (
 	"github.com/spf13/cobra"
 )
 
-type ParserArgs struct {
-	SourceGitlabURL        string
-	SourceGitlabToken      string
-	DestinationGitlabURL   string
-	DestinationGitlabToken string
-	MirrorMapping          utils.MirrorMapping
-	Verbose                bool
-	NoPrompt               bool
-}
+var (
+	version = "dev"
+)
 
 func main() {
-	var args ParserArgs
+	var args utils.ParserArgs
 	var mirrorMappingPath string
 
 	var rootCmd = &cobra.Command{
 		Use:   "gitlab-sync",
 		Short: "Copy and enable mirroring of gitlab projects and groups",
 		Long:  "Fully customizable gitlab repositories and groups mirroring between two (or one) gitlab instances.",
 		Run: func(cmd *cobra.Command, cmdArgs []string) {
+			if args.Version {
+				fmt.Printf("gitlab-sync version: %s\n", version)
+				return
+			}
 
 			utils.SetVerbose(args.Verbose)
 			utils.LogVerbose("Verbose mode enabled")
@@ -56,8 +54,9 @@ func main() {
 				log.Fatalf("Error opening mirror mapping file: %s", err)
 			}
 			utils.LogVerbose("Mirror mapping file parsed successfully")
+			args.MirrorMapping = mapping
 
-			err = mirroring.MirrorGitlabs(args.SourceGitlabURL, args.SourceGitlabToken, args.DestinationGitlabURL, args.DestinationGitlabToken, mapping)
+			err = mirroring.MirrorGitlabs(&args)
 			if err != nil {
 				fmt.Println("Error during mirroring process:")
 				fmt.Println(err)
@@ -66,13 +65,15 @@ func main() {
 		},
 	}
 
+	rootCmd.Flags().BoolVarP(&args.Version, "version", "V", false, "Show version")
 	rootCmd.Flags().StringVar(&args.SourceGitlabURL, "source-url", os.Getenv("SOURCE_GITLAB_URL"), "Source GitLab URL")
 	rootCmd.Flags().StringVar(&args.SourceGitlabToken, "source-token", os.Getenv("SOURCE_GITLAB_TOKEN"), "Source GitLab Token")
 	rootCmd.Flags().StringVar(&args.DestinationGitlabURL, "destination-url", os.Getenv("DESTINATION_GITLAB_URL"), "Destination GitLab URL")
 	rootCmd.Flags().StringVar(&args.DestinationGitlabToken, "destination-token", os.Getenv("DESTINATION_GITLAB_TOKEN"), "Destination GitLab Token")
-	rootCmd.Flags().BoolVar(&args.Verbose, "verbose", false, "Enable verbose output")
-	rootCmd.Flags().BoolVar(&args.NoPrompt, "no-prompt", false, "Disable prompting for missing values")
+	rootCmd.Flags().BoolVarP(&args.Verbose, "verbose", "v", false, "Enable verbose output")
+	rootCmd.Flags().BoolVarP(&args.NoPrompt, "no-prompt", "n", strings.TrimSpace(os.Getenv("NO_PROMPT")) != "", "Disable prompting for missing values")
 	rootCmd.Flags().StringVar(&mirrorMappingPath, "mirror-mapping", os.Getenv("MIRROR_MAPPING"), "Path to the mirror mapping file")
+	rootCmd.Flags().BoolVar(&args.DryRun, "dry-run", false, "Perform a dry run without making any changes")
 
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Println(err)

mirroring/main.go

@@ -1,49 +1,70 @@
 package mirroring
 
 import (
+	"fmt"
+	"log"
 	"path/filepath"
 	"sync"
 
 	"gitlab-sync/utils"
 )
 
-func MirrorGitlabs(sourceGitlabURL string, sourceGitlabToken string, destinationGitlabURL string, destinationGitlabToken string, mirrorMapping *utils.MirrorMapping) error {
-	sourceGitlabInstance, err := newGitlabInstance(sourceGitlabURL, sourceGitlabToken)
+func MirrorGitlabs(gitlabMirrorArgs *utils.ParserArgs) error {
+	sourceGitlabInstance, err := newGitlabInstance(gitlabMirrorArgs.SourceGitlabURL, gitlabMirrorArgs.SourceGitlabToken)
 	if err != nil {
 		return err
 	}
 
-	destinationGitlabInstance, err := newGitlabInstance(destinationGitlabURL, destinationGitlabToken)
+	destinationGitlabInstance, err := newGitlabInstance(gitlabMirrorArgs.DestinationGitlabURL, gitlabMirrorArgs.DestinationGitlabToken)
 	if err != nil {
 		return err
 	}
 
-	sourceProjectFilters, sourceGroupFilters, destinationProjectFilters, destinationGroupFilters := processFilters(mirrorMapping)
+	sourceProjectFilters, sourceGroupFilters, destinationProjectFilters, destinationGroupFilters := processFilters(gitlabMirrorArgs.MirrorMapping)
 
 	wg := sync.WaitGroup{}
 	errCh := make(chan error, 4)
 	wg.Add(2)
 
 	go func() {
 		defer wg.Done()
-		if err := fetchAll(sourceGitlabInstance, sourceProjectFilters, sourceGroupFilters, mirrorMapping, true); err != nil {
+		if err := fetchAll(sourceGitlabInstance, sourceProjectFilters, sourceGroupFilters, gitlabMirrorArgs.MirrorMapping, true); err != nil {
 			errCh <- err
 		}
 	}()
 	go func() {
 		defer wg.Done()
-		if err := fetchAll(destinationGitlabInstance, destinationProjectFilters, destinationGroupFilters, mirrorMapping, false); err != nil {
+		if err := fetchAll(destinationGitlabInstance, destinationProjectFilters, destinationGroupFilters, gitlabMirrorArgs.MirrorMapping, false); err != nil {
 			errCh <- err
 		}
 	}()
 
 	wg.Wait()
 
-	err = createGroups(sourceGitlabInstance, destinationGitlabInstance, mirrorMapping)
+	// In case of dry run, simply print the groups and projects that would be created or updated
+	if gitlabMirrorArgs.DryRun {
+		log.Println("Dry run mode enabled, will not create groups or projects")
+		fmt.Println("Groups that will be created (or updated if they already exist):")
+		for sourceGroupPath, copyOptions := range gitlabMirrorArgs.MirrorMapping.Groups {
+			if sourceGitlabInstance.Groups[sourceGroupPath] != nil {
+				fmt.Printf("  - %s (source gitlab) -> %s (destination gitlab)\n", sourceGroupPath, copyOptions.DestinationPath)
+			}
+		}
+		fmt.Println("Projects that will be created (or updated if they already exist):")
+		for sourceProjectPath, copyOptions := range gitlabMirrorArgs.MirrorMapping.Projects {
+			if sourceGitlabInstance.Projects[sourceProjectPath] != nil {
+				fmt.Printf("  - %s (source gitlab) -> %s (destination gitlab)\n", sourceProjectPath, copyOptions.DestinationPath)
+			}
+		}
+		return nil
+	}
+
+	// Create groups and projects in the destination GitLab instance
+	err = createGroups(sourceGitlabInstance, destinationGitlabInstance, gitlabMirrorArgs.MirrorMapping)
 	if err != nil {
 		errCh <- err
 	}
-	err = createProjects(sourceGitlabInstance, destinationGitlabInstance, mirrorMapping)
+	err = createProjects(sourceGitlabInstance, destinationGitlabInstance, gitlabMirrorArgs.MirrorMapping)
 	if err != nil {
 		errCh <- err
 	}

utils/types.go

@@ -15,6 +15,28 @@ import (
 	"sync"
 )
 
+// ParserArgs defines the command line arguments
+// - source_gitlab_url: the URL of the source GitLab instance
+// - source_gitlab_token: the token for the source GitLab instance
+// - destination_gitlab_url: the URL of the destination GitLab instance
+// - destination_gitlab_token: the token for the destination GitLab instance
+// - mirror_mapping: the path to the JSON file that contains the mapping
+// - verbose: whether to enable verbose logging
+// - no_prompt: whether to disable prompts
+// - dry_run: whether to perform a dry run
+// - version: whether to show the version
+type ParserArgs struct {
+	SourceGitlabURL        string
+	SourceGitlabToken      string
+	DestinationGitlabURL   string
+	DestinationGitlabToken string
+	MirrorMapping          *MirrorMapping
+	Verbose                bool
+	NoPrompt               bool
+	DryRun                 bool
+	Version                bool
+}
+
 // ProjectMirrorOptions defines how the project should be mirrored
 // to the destination GitLab instance
 // - destination_url: the URL of the destination GitLab instance