cmd

Documentation

Index

• Variables
• func GetConfig(cmd *cobra.Command, args []string) *types.Config
• func GetConfigWithImage(cmd *cobra.Command, args []string, image Image) *types.Config
• type Image
  • func (i Image) GetURL() string

Variables

var (
	Apply = cobra.Command{
		Use:   "apply",
		Short: "Apply the configuration to the local machine or remote machines over SSH",
		Args:  cobra.MinimumNArgs(0),
		Run: func(cmd *cobra.Command, args []string) {
			cfg := GetConfig(cmd, args)

			var remoteHosts []string
			if inventory, _ := cmd.Flags().GetString("inventory"); inventory != "" {
				remoteHosts = ansible.ParseInventory(inventory)
				port, _ := cmd.Flags().GetInt("port")
				cmd, err := cfg.ToBash()
				if err != nil {
					panic(err)
				}
				for _, host := range remoteHosts {
					ansible.ExecuteRemoteCommand(cmd, host, port)
				}
			} else {
				runLocal(cfg)
			}

		},
	}
)

var (
	CloudInit = cobra.Command{
		Use:   "cloud-init",
		Short: "Exports the configuration in cloud-init format",
		Args:  cobra.MinimumNArgs(0),

		Run: func(cmd *cobra.Command, args []string) {

			cfg := GetConfig(cmd, args)
			var userdata string
			if base64, _ := cmd.Flags().GetBool("base64"); base64 {
				cfg.Extra.FileEncoding = "base64"
				userdata = cfg.ToCloudInit().String()
			} else {
				userdata = cfg.ToCloudInit().String()
			}

			if iso, _ := cmd.Flags().GetBool("iso"); iso {
				hostname, _ := cmd.Flags().GetString("hostname")
				path, err := cloudinit.CreateISO(hostname, userdata)
				if err != nil {
					log.Fatalf("%+v", err)
				}
				fmt.Println(path)
			} else {
				fmt.Println(userdata)
			}
		},
	}
)

var IMAGE_CACHE string // nolint: golint

var (
	//Images command
	Images = cobra.Command{
		Use: "images",
		PersistentPreRun: func(cmd *cobra.Command, args []string) {
			driverName, _ = cmd.Flags().GetString("driver")
			outputDir, _ = cmd.Flags().GetString("output-dir")
			outputFilename, _ = cmd.Flags().GetString("output-filename")
			outputFormat, _ = cmd.Flags().GetString("output-format")
			resize, _ = cmd.Flags().GetString("resize")
			image, _ = cmd.Flags().GetString("image")
			inline, _ = cmd.Flags().GetBool("inline")
			captureLogs, _ = cmd.Flags().GetString("capture-logs")
			imageVersion := ""
			if strings.Contains(image, ":") {
				imageVersion = strings.Split(image, ":")[1]
				image = strings.Split(image, ":")[0]
			}

			if val, ok := images[image]; ok {
				alias = &val
				alias.Version = imageVersion
				log.Infof("%s is an alias for %s", image, alias)
				image = alias.GetURL()
			}
			cfg = GetConfig(cmd, args)
			if driverName != "" {
				var ok bool
				if driver, ok = drivers[driverName]; !ok {
					log.Fatalf("Invalid driver name: %s ", driverName)
				}
			}
			cfg.Context.CaptureLogs = captureLogs
		},
	}
)

var (
	Minify = cobra.Command{
		Use:   "minify",
		Short: "Resolve all lookups and dependencies and export a single config file",
		Args:  cobra.MinimumNArgs(0),
		Run: func(cmd *cobra.Command, args []string) {
			cfg := GetConfig(cmd, args)
			fs, commands, err := cfg.ApplyPhases()
			if err != nil {
				log.Fatalf("Error applying phases %s\n", err)
			}

			if primitive {
				data, _ := yaml.Marshal(map[string]interface{}{
					"filesystem": fs,
					"commands":   commands,
				})
				fmt.Println(string(data))
			} else if bash {
				if out, err := cfg.ToBash(); err != nil {
					log.Fatalf("Error converting to bas: %v", err)
				} else {
					fmt.Println(out)
				}
			} else {
				data, _ := yaml.Marshal(cfg)
				fmt.Println(string(data))

			}
		},
	}
)

var (
	//Verify command
	Verify = cobra.Command{
		Use:   "verify",
		Short: "Verify that the configuration has been applied correctly and is in a healthy state",
		Args:  cobra.MinimumNArgs(0),
		Run: func(cmd *cobra.Command, args []string) {
			cfg := GetConfig(cmd, args)
			_, _, err := cfg.ApplyPhases()
			if err != nil {
				log.Error(err)
			}
			verifier := types.VerifyResults{}
			if !cfg.Verify(&verifier) {
				verifier.Done()
				os.Exit(1)
			}
			verifier.Done()
		},
	}
)

Functions

func GetConfig

func GetConfig(cmd *cobra.Command, args []string) *types.Config

func GetConfigWithImage

func GetConfigWithImage(cmd *cobra.Command, args []string, image Image) *types.Config

Types

type Image

type Image struct {
	Alias          string
	URL            string
	Tags           []types.Flag
	Version        string
	DefaultVersion string
}

func (Image) GetURL

func (i Image) GetURL() string