commands

Documentation

Index

• Variables
• func NewCommand() *cobra.Command

Variables

var GenerateCmd = &cobra.Command{
	Use:   "generate",
	Short: "Generate artifacts",
	Long:  ``,
	PersistentPreRun: func(cmd *cobra.Command, args []string) {

		workDir := generateSetOptions.WorkDir
		outputDir := generateSetOptions.OutputDir

		if _, err := os.Stat(workDir); err == nil {
			logger.Fatalf("Work directory already exists: %s", workDir)
		}

		if err := os.MkdirAll(workDir, os.ModePerm); err != nil {
			logger.Fatalf("Failed to create work directory: %v", err)
		}
		logger.Debugf("Work directory created at: %s", workDir)

		if err := os.MkdirAll(outputDir, os.ModePerm); err != nil {
			logger.Fatalf("Failed to create output directory: %v", err)
		}
	},
	PersistentPostRunE: func(cmd *cobra.Command, args []string) error {

		workDir := generateSetOptions.WorkDir
		if err := os.RemoveAll(workDir); err != nil {
			return fmt.Errorf("Failed to delete work directory: %v", err)
		}
		logger.Debugf("Work directory deleted: %s", workDir)

		if err, ok := cmd.Context().Value("cmdError").(error); ok && err != nil {
			return err
		}
		return nil
	},
}

GenerateCmd is the base sub command

var GenerateDockerLabelsCmd = &cobra.Command{
	Use:   "docker-labels [source-config-uri]",
	Short: "Generate Docker labels from a Kubeit configuration",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		sourceConfigUri := args[0]

		generateErrs, loadFileErrs := generate.GenerateDockerLabels(
			&generateSetOptions,
			sourceConfigUri,
		)

		errorMap := make(map[string][]string)
		if len(loadFileErrs) != 0 {
			for file, errList := range loadFileErrs {
				for _, err := range errList {
					errorMap[file] = append(errorMap[file], fmt.Sprintf("- %v", err))
				}
			}
		}

		for _, err := range generateErrs {
			errorMap["Generate Errors"] = append(
				errorMap["Generate Errors"],
				fmt.Sprintf("- %v", err),
			)
		}

		if len(errorMap) > 0 {
			var formattedErrors []string
			for file, errList := range errorMap {
				formattedErrors = append(formattedErrors,
					fmt.Sprintf("%s:\n  %s", file, strings.Join(errList, "\n  ")))
			}
			finalErr := fmt.Errorf("\n%s", strings.Join(formattedErrors, "\n"))
			cmd.SetContext(context.WithValue(cmd.Context(), cmdErrorKey, finalErr))
			logger.Errorf("Error generating docker labels: %v", finalErr)

		}
	},
}

var GenerateManifestCmd = &cobra.Command{
	Use:   "manifest [source-config-uri]",
	Short: "Generate Kubernetes manifests from a Kubeit configuration",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		generateSetOptions.SourceConfigUri = args[0]

		generateErrs, loadFileErrs := generate.GenerateManifests(&generateSetOptions)

		errorMap := make(map[string][]string)
		if len(loadFileErrs) != 0 {
			for file, errList := range loadFileErrs {
				for _, err := range errList {
					errorMap[file] = append(errorMap[file], fmt.Sprintf("- %v", err))
				}
			}
		}

		for _, err := range generateErrs {
			errorMap["Generate Errors"] = append(
				errorMap["Generate Errors"],
				fmt.Sprintf("- %v", err),
			)
		}

		if len(errorMap) > 0 {
			var formattedErrors []string
			for file, errList := range errorMap {
				formattedErrors = append(formattedErrors,
					fmt.Sprintf("%s:\n  %s", file, strings.Join(errList, "\n  ")))
			}
			finalErr := fmt.Errorf("\n%s", strings.Join(formattedErrors, "\n"))
			cmd.SetContext(context.WithValue(cmd.Context(), cmdErrorKey, finalErr))
			logger.Errorf("Error generating manifests: %v", finalErr)

		}
	},
}

var RootCmd = &cobra.Command{
	Use:   common.KubeitCLIName,
	Short: "CLI tool to generate and manage Kubernetes deployment configurations",
	Long: `Kubeit is a CLI tool designed for service teams to simplify 
the generation and management of Kubernetes deployment configurations. 

It allows teams to define infrastructure in a minimal YAML format 
and transforms it into fully rendered Kubernetes objects.

Use 'kubeit generate' to convert a KubeIt configuration into 
Kubernetes manifests for deployment.`,
}

RootCmd is the base command

var VersionCmd = &cobra.Command{
	Use:   "version",
	Short: "Print the version of Kubeit",
	Run: func(cmd *cobra.Command, args []string) {
		if showLicense {
			fmt.Println(licenseContent)
		}
		bi, ok := debug.ReadBuildInfo()
		if !ok {
			logger.Warnf("Failed to read build info")
			return
		}

		fmt.Printf("Dependencies:\n")

		for _, dep := range bi.Deps {
			if name, ok := depNames[dep.Path]; ok {
				fmt.Printf("    %s: %s (%s)\n", name, dep.Version, dep.Sum)
			}
		}
		fmt.Printf("\n")

		version.PrintBuildInfo()

		fmt.Printf("\n")

		if !showLicense {
			fmt.Printf("For license information, run: kubeit version --%s\n", licenseFlag)
		}
	},
}

VersionCmd provides the version of the tool

Functions

func NewCommand

func NewCommand() *cobra.Command

NewRootCommand returns the root command instead of executing it