cmd

Documentation

Index

• Variables
• func NewConfig(paths []string, extras []string) types.PlatformConfig
• type KubeTypes
  • func ParseDocumentationFrom(srcs []string) []KubeTypes
• type Pair
• type TestFn

Variables

var APIDocs = &cobra.Command{
	Use:   "api",
	Short: "Generate docs ",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		printAPIDocs(args)
	},
}

var Access = &cobra.Command{
	Use:   "kubeconfig",
	Short: "Generate kubeconfig files",
}

var Apply = &cobra.Command{
	Use:   "apply",
	Short: "Apply a configuration to a resource by filename",
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {

		ns, _ := cmd.Flags().GetString("namespace")
		p := getPlatform(cmd)
		for _, spec := range args {
			data, err := ioutil.ReadFile(spec)
			if err != nil {
				log.Fatalf("Could not read %s: %v", spec, err)
			}
			template, err := text.Template(string(data), p.PlatformConfig)
			if err != nil {
				log.Fatalf("failed to template %s: %v", spec, err)
			}
			if err := p.ApplyText(ns, template); err != nil {
				log.Fatalf("failed to apply %s: %v", spec, err)
			}
		}
	},
}

var Backup = &cobra.Command{
	Use:   "backup",
	Short: "Create new velero backup",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		if _, err := velero.CreateBackup(getPlatform(cmd)); err != nil {
			log.Fatalf("Error creating backup %v", err)
		}
	},
}

var CA = &cobra.Command{
	Use:   "ca",
	Short: "Commands for generating CA certs",
}

var Cleanup = &cobra.Command{
	Use:   "cleanup",
	Short: "Cleanup a cluster and terminate all VM's and resources associated with it",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		if err := provision.Cleanup(getPlatform(cmd)); err != nil {
			log.Fatalf("Failed to cleanup cluster, %s", err)
		}
	},
}

var Config = &cobra.Command{
	Use:   "config",
	Short: "Commands for working with config files",
}

var Conformance = &cobra.Command{
	Use:   "conformance",
	Short: "Run conformance tests using sonobuoy",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		if err := phases.ConformanceTest(getPlatform(cmd), phases.ConformanceTestOptions{
			Certification: certification,
			KubeBench:     kubeBench,
			Quick:         quick,
			Wait:          wait,
			OutputDir:     outputDir,
		}); err != nil {
			log.Fatalf("Failed to run conformance tests: %v", err)
		}
	},
}

var Consul = &cobra.Command{
	Use: "consul",
}

var DB = &cobra.Command{
	Use: "db",
}

var DNS = &cobra.Command{
	Use: "dns",
}

var Deploy = &cobra.Command{
	Use: "deploy",
}

var Exec = &cobra.Command{
	Use:   "exec",
	Short: "Execute a shell command inside pods matching selector",
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {

		command := args[0]
		args = args[1:]
		if len(args) > 0 {
			command = command + " " + strings.Join(args, " ")
		}
		ns, _ := cmd.Flags().GetString("namespace")
		container, _ := cmd.Flags().GetString("container")
		selector, _ := cmd.Flags().GetString("selector")
		p := getPlatform(cmd)
		client, err := p.GetClientset()
		if err != nil {
			log.Fatalf("unable to get clientset: %v", err)
		}

		pods, err := client.CoreV1().Pods(ns).List(metav1.ListOptions{LabelSelector: selector})
		if err != nil {
			log.Fatalf("unable to list pods: %v", err)
		}

		for _, pod := range pods.Items {
			if pod.Status.Phase != v1.PodRunning {
				log.Warnf("Skipping %s in %s phase", pod.Name, pod.Status.Phase)
				continue
			}
			_container := container
			if _container == "" {
				_container = pod.Spec.Containers[0].Name
			}
			stdout, stderr, err := p.ExecutePodf(ns, pod.Name, _container, command)
			if err != nil {
				log.Errorf("[%s/%s] %s %s %v", pod.Name, _container, stdout, stderr, err)
			} else {
				log.Infof("[%s/%s] %s %s", pod.Name, _container, stdout, stderr)
			}
		}
	},
}

var ExecNode = &cobra.Command{
	Use:   "exec-node",
	Short: "Execute a shell command inside host mounted daemonset on each node",
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		command := args[0]
		args = args[1:]
		if len(args) > 0 {
			command = command + " " + strings.Join(args, " ")
		}
		selector, _ := cmd.Flags().GetString("selector")
		p := getPlatform(cmd)
		client, err := p.GetClientset()
		if err != nil {
			log.Fatalf("unable to get clientset: %v", err)
		}

		nodes, err := client.CoreV1().Nodes().List(metav1.ListOptions{
			LabelSelector: selector,
		})
		if err != nil {
			log.Fatalf("unable to list nodes: %v", err)
		}

		for _, node := range nodes.Items {
			stdout, err := p.Executef(node.Name, 60*time.Second, command)
			if err != nil {
				log.Errorf("[%s] %s %v", node.Name, stdout, err)
			} else {
				log.Infof("[%s] %s", node.Name, stdout)
			}
		}
	},
}

var Harbor = &cobra.Command{
	Use:   "harbor",
	Short: "Commmands for deploying and interacting with harbor",
}

Harbor is the parent command for interactor with the harbor docker registry

var Images = &cobra.Command{
	Use:   "images",
	Short: "Commands for working with docker images",
}

var Logs = &cobra.Command{
	Use:   "logs",
	Short: "Retrieve and export logs from ElasticSearch",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		kql, _ := cmd.Flags().GetString("query")
		pod, _ := cmd.Flags().GetString("pod")
		count, _ := cmd.Flags().GetInt("count")
		namespace, _ := cmd.Flags().GetString("namespace")
		cluster, _ := cmd.Flags().GetString("cluster")
		since, _ := cmd.Flags().GetString("since")
		from, _ := cmd.Flags().GetString("from")
		to, _ := cmd.Flags().GetString("to")
		timestamps, _ := cmd.Flags().GetBool("timestamps")
		if err := elastic.ExportLogs(getPlatform(cmd), elastic.Query{
			Pod:        pod,
			Count:      count,
			Cluster:    cluster,
			Namespace:  namespace,
			Since:      since,
			Query:      kql,
			From:       from,
			Timestamps: timestamps,
			To:         to,
		}); err != nil {
			log.Fatalf("Failed to export logs, %s", err)
		}
	},
}

var MachineImages = &cobra.Command{
	Use:     "machine-images",
	Aliases: []string{"vm"},
	Short:   "Commands for working with machine images",
}

var NSX = &cobra.Command{
	Use:   "nsx",
	Short: "Commands for interacting with NSX clusters",
}

var Opa = &cobra.Command{
	Use: "opa",
}

var Provision = &cobra.Command{
	Use:   "provision",
	Short: "Commands for provisioning clusters and VMs",
}

var Render = &cobra.Command{
	Use:   "render",
	Short: "Generate kubeconfig files",
	Run: func(cmd *cobra.Command, args []string) {
		base := getConfig(cmd)
		data, _ := yaml.Marshal(base)
		fmt.Println(string(data))
	},
}

var Report = &cobra.Command{
	Use: "report",
}

var Rolling = &cobra.Command{
	Use: "rolling",
}

var RollingRestart = &cobra.Command{
	Use:   "restart",
	Short: "Rolling restart of all nodes",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		if err := provision.RollingRestart(getPlatform(cmd), rollingOpts); err != nil {
			log.Fatalf("Failed to restart nodes, %s", err)
		}
	},
}

var RollingUpdate = &cobra.Command{
	Use:   "update",
	Short: "Rolling update of all nodes",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		if err := provision.RollingUpdate(getPlatform(cmd), rollingOpts); err != nil {
			log.Fatalf("Failed to update nodes %s", err)
		}
	},
}

var Snapshot = &cobra.Command{
	Use:   "snapshot",
	Short: "Take a snapshot of the running system",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		opts.Namespaces = args
		if err := snapshot.Take(getPlatform(cmd), opts); err != nil {
			log.Fatalf("Failed to get cluster snapshot, %s", err)
		}
	},
}

var Status = &cobra.Command{
	Use:   "status",
	Short: "Print the status of the cluster and each node",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		if err := provision.Status(getPlatform(cmd)); err != nil {
			log.Fatalf("Failed to get cluster status, %s", err)
		}
	},
}

var Test = &cobra.Command{
	Use: "test",
}

var Upgrade = &cobra.Command{
	Use:   "upgrade",
	Short: "Upgrade the core platform components to their latest versions",
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
	},
}

var Vault = &cobra.Command{
	Use:   "vault",
	Short: "Commands for working with vault",
}

Functions

func NewConfig

func NewConfig(paths []string, extras []string) types.PlatformConfig

Types

type KubeTypes

type KubeTypes []Pair

KubeTypes is an array to represent all available types in a parsed file. [0] is for the type itself

func ParseDocumentationFrom

func ParseDocumentationFrom(srcs []string) []KubeTypes

ParseDocumentationFrom gets all types' documentation and returns them as an array. Each type is again represented as an array (we have to use arrays as we need to be sure for the order of the fields). This function returns fields and struct definitions that have no documentation as {name, ""}.

type Pair

type Pair struct {
	Name, Doc, Type string
	Mandatory       bool
}

Pair of strings. We keed the name of fields and the doc

type TestFn

type TestFn func(p *platform.Platform, test *console.TestResults)