cli

Documentation

Overview

Package cli contains all definitions pertaining to the user-visible commands of the epinio client. It provides the viper/cobra setup.

Index

• Variables
• func CreateKubeClient(configPath string) kubernetes.Interface
• func Execute()
• func ExitIfError(err error)
• func ExitfIfError(err error, message string)
• func ExitfWithMessage(message string, args ...interface{})
• func NewRootCmd() (*cobra.Command, error)

Variables

var CmdApp = &cobra.Command{
	Use:           "app",
	Aliases:       []string{"apps"},
	Short:         "Epinio application features",
	Long:          `Manage epinio application`,
	SilenceErrors: false,
	Args:          cobra.MinimumNArgs(1),
}

CmdApp implements the command: epinio app

var CmdAppChart = &cobra.Command{
	Use:   "chart",
	Short: "Epinio application chart management",
	Long:  `Manage epinio application charts`,
}

CmdAppChart implements the command: epinio app chart

var CmdAppChartDefault = &cobra.Command{
	Use:               "default [CHARTNAME]",
	Short:             "Set or show app chart default",
	Long:              "Set or show app chart default",
	Args:              cobra.MaximumNArgs(1),
	ValidArgsFunction: matchingChartFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		if len(args) == 1 {
			err := client.ChartDefaultSet(cmd.Context(), args[0])
			if err != nil {
				return errors.Wrap(err, "error setting app chart default")
			}
		} else {
			err := client.ChartDefaultShow(cmd.Context())
			if err != nil {
				return errors.Wrap(err, "error showing app chart default")
			}
		}

		return nil
	},
}

CmdAppChartDefault implements the command: epinio app chart default

var CmdAppChartList = &cobra.Command{
	Use:   "list",
	Short: "List application charts",
	Long:  "List applications charts",
	Args:  cobra.ExactArgs(0),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.ChartList(cmd.Context())
		if err != nil {
			return errors.Wrap(err, "error listing app charts")
		}

		return nil
	},
}

CmdAppChartList implements the command: epinio app chart list

var CmdAppChartShow = &cobra.Command{
	Use:               "show CHARTNAME",
	Short:             "Describe application chart",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingChartFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.ChartShow(cmd.Context(), args[0])
		if err != nil {
			return errors.Wrap(err, "error showing app chart")
		}

		return nil
	},
}

CmdAppChartShow implements the command: epinio app env show

var CmdAppCreate = &cobra.Command{
	Use:   "create NAME",
	Short: "Create just the app, without creating a workload",
	Args:  cobra.ExactArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		m, err := manifest.UpdateICE(models.ApplicationManifest{}, cmd)
		if err != nil {
			return errors.Wrap(err, "unable to get app configuration")
		}

		m, err = manifest.UpdateAppChart(m, cmd)
		if err != nil {
			return errors.Wrap(err, "unable to get app chart")
		}

		m, err = manifest.UpdateRoutes(m, cmd)
		if err != nil {
			return err
		}

		updateRequest := models.NewApplicationUpdateRequest(m)
		err = client.AppCreate(args[0], updateRequest)

		return errors.Wrap(err, "error creating app")
	},
}

CmdAppCreate implements the command: epinio apps create

var CmdAppDelete = &cobra.Command{
	Use:   "delete NAME1 [NAME2 ...]",
	Short: "Deletes one or more applications",
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

		filteredMatches := clicmd.FilteredMatchingFinder(args, toComplete, client.AppsMatching)
		return filteredMatches, cobra.ShellCompDirectiveNoFileComp
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		all, err := cmd.Flags().GetBool("all")
		if err != nil {
			return errors.Wrap(err, "error reading option --all")
		}

		if all && len(args) > 0 {
			return errors.New("Conflict between --all and named applications")
		}
		if !all && len(args) == 0 {
			return errors.New("No applications specified for deletion")
		}

		err = client.Delete(cmd.Context(), args, all)
		if err != nil {
			return errors.Wrap(err, "error deleting app")
		}

		return nil
	},
}

CmdAppDelete implements the command: epinio app delete

var CmdAppEnv = &cobra.Command{
	Use:   "env",
	Short: "Epinio application configuration",
	Long:  `Manage epinio application environment variables`,
}

CmdAppEnv implements the command: epinio app env

var CmdAppExec = &cobra.Command{
	Use:               "exec NAME",
	Short:             "creates a shell to the application",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		instance, err := cmd.Flags().GetString("instance")
		if err != nil {
			cmd.SilenceUsage = false
			return errors.Wrap(err, "could not read instance parameter")
		}

		err = client.AppExec(cmd.Context(), args[0], instance)

		return errors.Wrap(err, "error getting a shell to application")
	},
}

CmdAppExec implements the command: epinio apps exec

var CmdAppExport = &cobra.Command{
	Use:               "export NAME [DIRECTORY]",
	Short:             "Export the named application into the directory or flag-specified registry",
	Args:              cobra.MaximumNArgs(2),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		nargs := len(args)
		registry, err := cmd.Flags().GetString("registry")
		if err != nil {
			return errors.Wrap(err, "error reading option --registry")
		}

		if nargs == 1 && registry == "" {
			return errors.New("Neither directory nor registry destination found")
		}
		if nargs == 2 && registry != "" {
			return errors.New("Conflict, both directory and registry destinations found")
		}

		var destination, imageName, chartName, imageTag, chartVersion string
		toRegistry := nargs == 1
		if toRegistry {
			destination = registry
			imageName, err = cmd.Flags().GetString("image-name")
			if err != nil {
				return errors.Wrap(err, "error reading option --image-name")
			}
			chartName, err = cmd.Flags().GetString("chart-name")
			if err != nil {
				return errors.Wrap(err, "error reading option --chart-name")
			}
			imageTag, err = cmd.Flags().GetString("image-tag")
			if err != nil {
				return errors.Wrap(err, "error reading option --image-tag")
			}
			chartVersion, err = cmd.Flags().GetString("chart-version")
			if err != nil {
				return errors.Wrap(err, "error reading option --chart-version")
			}
		} else {
			destination = args[1]
		}

		err = client.AppExport(args[0], toRegistry, models.AppExportRequest{
			Destination:  destination,
			ImageName:    imageName,
			ChartName:    chartName,
			ImageTag:     imageTag,
			ChartVersion: chartVersion,
		})

		return errors.Wrap(err, "error exporting app")
	},
}

CmdAppExport implements the command: epinio apps export

var CmdAppList = &cobra.Command{
	Use:   "list [--all]",
	Short: "Lists applications",
	Long:  "Lists applications in the targeted namespace, or all",
	Args:  cobra.ExactArgs(0),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		all, err := cmd.Flags().GetBool("all")
		if err != nil {
			return errors.Wrap(err, "error reading option --all")
		}

		err = client.Apps(all)

		return errors.Wrap(err, "error listing apps")
	},
}

CmdAppList implements the command: epinio app list

var CmdAppLogs = &cobra.Command{
	Use:               "logs NAME",
	Short:             "Streams the logs of the application",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		follow, err := cmd.Flags().GetBool("follow")
		if err != nil {
			return errors.Wrap(err, "error reading option --follow")
		}

		staging, err := cmd.Flags().GetBool("staging")
		if err != nil {
			return errors.Wrap(err, "error reading option --staging")
		}

		stageID := ""
		if staging {
			stageID, err = client.AppStageID(args[0])
			if err != nil {
				return errors.Wrap(err, "error checking app")
			}
		}

		err = client.AppLogs(args[0], stageID, follow)

		return errors.Wrap(err, "error streaming application logs")
	},
}

CmdAppLogs implements the command: epinio apps logs

var CmdAppManifest = &cobra.Command{
	Use:               "manifest NAME MANIFESTPATH",
	Short:             "Save state of the named application as a manifest",
	Args:              cobra.ExactArgs(2),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.AppManifest(args[0], args[1])

		return errors.Wrap(err, "error getting app manifest")
	},
}

CmdAppManifest implements the command: epinio apps manifest

var CmdAppPortForward = &cobra.Command{
	Use:               "port-forward NAME [LOCAL_PORT:]REMOTE_PORT [...[LOCAL_PORT_N:]REMOTE_PORT_N]",
	Short:             "forward one or more local ports to a pod",
	Args:              cobra.MinimumNArgs(2),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		appName := args[0]
		ports := args[1:]

		err := client.AppPortForward(cmd.Context(), appName, portForwardInstance, portForwardAddress, ports)

		return errors.Wrap(err, "error port forwarding to application")
	},
}

CmdAppPortForward implements the command: epinio apps port-forward

var CmdAppPush = &cobra.Command{
	Use:   "push [flags] [PATH_TO_APPLICATION_MANIFEST]",
	Short: "Push an application declared in the specified manifest",
	Args:  cobra.RangeArgs(0, 1),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		wd, err := os.Getwd()
		if err != nil {
			return errors.Wrap(err, "working directory not accessible")
		}

		var manifestPath string

		if len(args) == 1 {
			manifestPath = args[0]
		} else {
			manifestPath = filepath.Join(wd, "epinio.yml")
		}

		m, err := manifest.Get(manifestPath)
		if err != nil {
			cmd.SilenceUsage = false
			return errors.Wrap(err, "Manifest error")
		}

		m, err = manifest.UpdateICE(m, cmd)
		if err != nil {
			return err
		}

		m, err = manifest.UpdateBASN(m, cmd)
		if err != nil {
			return err
		}

		m, err = manifest.UpdateRoutes(m, cmd)
		if err != nil {
			return err
		}

		if m.Name == "" {
			cmd.SilenceUsage = false
			return errors.New("Name required, not found in manifest nor options")
		}

		if m.Origin.Kind == models.OriginNone {
			m.Origin.Kind = models.OriginPath
			m.Origin.Path = wd
		}

		if m.Origin.Kind == models.OriginPath {
			if _, err := os.Stat(m.Origin.Path); err != nil {

				cmd.SilenceUsage = false
				return errors.Wrap(err, "path not accessible")
			}
		}

		err = client.Push(cmd.Context(), m)
		if err != nil {
			return errors.Wrap(err, "error pushing app to server")
		}

		return nil
	},
}

CmdAppPush implements the command: epinio app push

var CmdAppRestage = &cobra.Command{
	Use:               "restage NAME",
	Short:             "Restage the application, then restart, if running and not suppressed",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		norestart, err := cmd.Flags().GetBool("no-restart")
		if err != nil {
			return errors.Wrap(err, "error reading option --no-restart")
		}
		restart := !norestart

		err = client.AppRestage(args[0], restart)

		return errors.Wrap(err, "error restaging app")
	},
}

CmdAppRestage implements the command: epinio app restage

var CmdAppRestart = &cobra.Command{
	Use:               "restart NAME",
	Short:             "Restart the application",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.AppRestart(args[0])

		return errors.Wrap(err, "error restarting app")
	},
}

CmdAppRestart implements the command: epinio app restart

var CmdAppShow = &cobra.Command{
	Use:               "show NAME",
	Short:             "Describe the named application",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.AppShow(args[0])

		return errors.Wrap(err, "error showing app")
	},
}

CmdAppShow implements the command: epinio apps show

var CmdAppUpdate = &cobra.Command{
	Use:               "update NAME",
	Short:             "Update the named application",
	Long:              "Update the running application's attributes (e.g. instances)",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		m, err := manifest.UpdateICE(models.ApplicationManifest{}, cmd)
		if err != nil {
			return errors.Wrap(err, "unable to get app configuration")
		}

		m, err = manifest.UpdateAppChart(m, cmd)
		if err != nil {
			return errors.Wrap(err, "unable to get app chart")
		}

		m, err = manifest.UpdateRoutes(m, cmd)
		if err != nil {
			return errors.Wrap(err, "unable to update domains")
		}

		manifestConfig := m.Configuration
		updateRequest := models.ApplicationUpdateRequest{
			Instances:      manifestConfig.Instances,
			Configurations: manifestConfig.Configurations,
			Environment:    manifestConfig.Environment,
			Routes:         manifestConfig.Routes,
			AppChart:       manifestConfig.AppChart,
			Settings:       manifestConfig.Settings,
		}

		err = client.AppUpdate(args[0], updateRequest)

		return errors.Wrap(err, "error updating the app")
	},
}

CmdAppUpdate implements the command: epinio apps update It scales the named app

var CmdCompletion = &cobra.Command{
	Use:   "completion [bash|zsh|fish|powershell]",
	Short: "Generate completion script for a shell",
	Long: `To load completions:

Bash:

$ source <(epinio completion bash)

# To load completions for each session, execute once:
Linux:
  $ epinio completion bash > /etc/bash_completion.d/epinio
MacOS:
  $ epinio completion bash > /usr/local/etc/bash_completion.d/epinio

ATTENTION:
    The generated script requires the bash-completion package.
    See https://kubernetes.io/docs/tasks/tools/install-kubectl/#enabling-shell-autocompletion
    for information on how to install and activate it.

Zsh:

# If shell completion is not already enabled in your environment you will need
# to enable it.  You can execute the following once:

$ echo "autoload -U compinit; compinit" >> ~/.zshrc

# To load completions for each session, execute once:
$ epinio completion zsh > "${fpath[1]}/_epinio"

# You will need to start a new shell for this setup to take effect.

Fish:

$ epinio completion fish | source

# To load completions for each session, execute once:
$ epinio completion fish > ~/.config/fish/completions/epinio.fish

Powershell:

PS> epinio completion powershell | Out-String | Invoke-Expression

# To load completions for every new session, run:
PS> epinio completion powershell > epinio.ps1
# and source this file from your powershell profile.
`,
	DisableFlagsInUseLine: true,
	ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
	Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
	RunE: func(cmd *cobra.Command, args []string) error {
		switch args[0] {
		case "bash":
			return cmd.Root().GenBashCompletion(os.Stdout)
		case "zsh":
			return cmd.Root().GenZshCompletion(os.Stdout)
		case "fish":
			return cmd.Root().GenFishCompletion(os.Stdout, true)
		case "powershell":
			return cmd.Root().GenPowerShellCompletion(os.Stdout)
		}
		return errors.New("Internal error: Invalid shell")
	},
}

CmdCompletion represents the completion command

var CmdDebug = &cobra.Command{
	Hidden:        true,
	Use:           "debug",
	Short:         "Dev Tools",
	Long:          `Developer Tools. Hidden From Regular User.`,
	SilenceErrors: true,
	SilenceUsage:  true,
	Args:          cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		if err := cmd.Usage(); err != nil {
			return err
		}
		return fmt.Errorf(`Unknown method "%s"`, args[0])
	},
}

CmdDebug implements the command: epinio debug

var CmdDebugTTY = &cobra.Command{
	Use:   "tty",
	Short: "Running In a Terminal?",
	Long:  `Running In a Terminal?`,
	Args:  cobra.ExactArgs(0),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true
		if isatty.IsTerminal(os.Stdout.Fd()) {
			fmt.Println("Is Terminal")
		} else if isatty.IsCygwinTerminal(os.Stdout.Fd()) {
			fmt.Println("Is Cygwin/MSYS2 Terminal")
		} else {
			fmt.Println("Is Not Terminal")
		}
		return nil
	},
}

CmdDebug implements the command: epinio debug tty

var CmdEnvList = &cobra.Command{
	Use:               "list APPNAME",
	Short:             "Lists application environment",
	Long:              "Lists environment variables of named application",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.EnvList(cmd.Context(), args[0])
		if err != nil {
			return errors.Wrap(err, "error listing app environment")
		}

		return nil
	},
}

CmdEnvList implements the command: epinio app env list

var CmdEnvSet = &cobra.Command{
	Use:               "set APPNAME NAME VALUE",
	Short:             "Extend application environment",
	Long:              "Add or change environment variable of named application",
	Args:              cobra.ExactArgs(3),
	ValidArgsFunction: matchingAppsFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.EnvSet(cmd.Context(), args[0], args[1], args[2])
		if err != nil {
			return errors.Wrap(err, "error setting into app environment")
		}

		return nil
	},
}

CmdEnvSet implements the command: epinio app env set

var CmdEnvShow = &cobra.Command{
	Use:   "show APPNAME NAME",
	Short: "Describe application's environment variable",
	Args:  cobra.ExactArgs(2),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.EnvShow(cmd.Context(), args[0], args[1])
		if err != nil {
			return errors.Wrap(err, "error accessing app environment")
		}

		return nil
	},
	ValidArgsFunction: matchingAppAndVarFinder,
}

CmdEnvShow implements the command: epinio app env show

var CmdEnvUnset = &cobra.Command{
	Use:   "unset APPNAME NAME",
	Short: "Shrink application environment",
	Long:  "Remove environment variable from named application",
	Args:  cobra.ExactArgs(2),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.EnvUnset(cmd.Context(), args[0], args[1])
		if err != nil {
			return errors.Wrap(err, "error removing from app environment")
		}

		return nil
	},
	ValidArgsFunction: matchingAppAndVarFinder,
}

CmdEnvUnset implements the command: epinio app env unset

var CmdExportRegistries = &cobra.Command{
	Use:   "export-registries",
	Short: "List export registries",
	Long:  "List export registries",
	Args:  cobra.ExactArgs(0),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.ExportregistryList(cmd.Context())
		if err != nil {
			return errors.Wrap(err, "error listing export registries")
		}

		return nil
	},
}

CmdExportRegistries implements the command: epinio export-registries

var CmdGitconfig = &cobra.Command{
	Use:           "gitconfig",
	Aliases:       []string{"gitconfigs"},
	Short:         "Epinio git configuration management",
	Long:          `Manage git configurations`,
	SilenceErrors: true,
	Args:          cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		if err := cmd.Usage(); err != nil {
			return err
		}
		return fmt.Errorf(`Unknown method "%s"`, args[0])
	},
}

CmdGitconfig implements the command: epinio gitconfig

var CmdGitconfigCreate = &cobra.Command{
	Use:   "create ID URL [flags]",
	Short: "Creates a git configuration",
	Args:  cobra.ExactArgs(2),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		skipssl, err := cmd.Flags().GetBool("skip-ssl")
		if err != nil {
			return errors.Wrap(err, "could not read option --skip-ssl")
		}
		provider, err := cmd.Flags().GetString("git-provider")
		if err != nil {
			return errors.Wrap(err, "could not read option --git-provider")
		}
		if provider == "" {
			provider = "git"
		}
		user, err := cmd.Flags().GetString("username")
		if err != nil {
			return errors.Wrap(err, "could not read option --username")
		}
		password, err := cmd.Flags().GetString("password")
		if err != nil {
			return errors.Wrap(err, "could not read option --password")
		}
		userorg, err := cmd.Flags().GetString("user-org")
		if err != nil {
			return errors.Wrap(err, "could not read option --user-org")
		}
		repository, err := cmd.Flags().GetString("repository")
		if err != nil {
			return errors.Wrap(err, "could not read option --repository")
		}
		certfile, err := cmd.Flags().GetString("cert-file")
		if err != nil {
			return errors.Wrap(err, "could not read option --cert-file")
		}

		id := args[0]
		url := args[1]

		err = client.CreateGitconfig(id, provider, url,
			user, password, userorg, repository, certfile, skipssl)
		if err != nil {
			return errors.Wrap(err, "error creating git configuration")
		}

		return nil
	},
}

CmdGitconfigCreate implements the command: epinio gitconfig create

var CmdGitconfigDelete = &cobra.Command{
	Use:               "delete NAME",
	Short:             "Delete git configurations",
	ValidArgsFunction: matchingGitconfigFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.DeleteGitconfig(args, gGitconfigAllFlag)
		if err != nil {

			if !strings.Contains(err.Error(), "Cancelled") {
				err = errors.Wrap(err, "error deleting git configuration")
			}
			return err
		}

		return nil
	},
}

CmdGitconfigDelete implements the command: epinio gitconfig delete

var CmdGitconfigList = &cobra.Command{
	Use:   "list",
	Short: "Lists all git configurations",
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.Gitconfigs()
		if err != nil {
			return errors.Wrap(err, "error listing git configurations")
		}

		return nil
	},
}

CmdGitconfigs implements the command: epinio gitconfig list

var CmdGitconfigShow = &cobra.Command{
	Use:               "show NAME",
	Short:             "Shows the details of a git configuration",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingGitconfigFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		err := client.ShowGitconfig(args[0])
		if err != nil {
			return errors.Wrap(err, "error showing git configuration")
		}

		return nil
	},
}

CmdGitconfigShow implements the command: epinio gitconfig show

var CmdServer = &cobra.Command{
	Use:   "server",
	Short: "Starts the Epinio server.",
	Long:  "This command starts the Epinio server. `epinio install` ensures the server is running inside your cluster. Normally you don't need to run this command manually.",
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true
		logger := tracelog.NewLogger().WithName("EpinioServer")

		cpuRequest := viper.GetString("staging-resource-cpu")
		if cpuRequest != "" {
			_, err := resource.ParseQuantity(cpuRequest)
			if err != nil {
				return errors.Wrap(err, "bad cpu request for staging job")
			}
		}
		memoryRequest := viper.GetString("staging-resource-memory")
		if memoryRequest != "" {
			_, err := resource.ParseQuantity(memoryRequest)
			if err != nil {
				return errors.Wrap(err, "bad memory request for staging job")
			}
		}
		diskRequest := viper.GetString("staging-resource-disk")
		if diskRequest != "" {
			_, err := resource.ParseQuantity(diskRequest)
			if err != nil {
				return errors.Wrap(err, "bad disk size request for staging job")
			}
		}

		handler, err := server.NewHandler(logger)
		if err != nil {
			return errors.Wrap(err, "error creating handler")
		}

		port := viper.GetInt("port")
		listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
		if err != nil {
			return errors.Wrap(err, "error creating listener")
		}

		ui := termui.NewUI()
		ui.Normal().Msg("Epinio version: " + version.Version)
		listeningPort := strconv.Itoa(listener.Addr().(*net.TCPAddr).Port)
		ui.Normal().Msg("listening on localhost on port " + listeningPort)

		trackingDisabled := viper.GetBool("disable-tracking")
		upgradeResponderAddress := viper.GetString("upgrade-responder-address")
		logger.Info("Checking upgrade-responder tracking", "disabled", trackingDisabled, "upgradeResponderAddress", upgradeResponderAddress)

		if !trackingDisabled {
			checker, err := upgraderesponder.NewChecker(context.Background(), logger, upgradeResponderAddress)
			if err != nil {
				return errors.Wrap(err, "error creating listener")
			}

			checker.Start()
			defer checker.Stop()
		}

		return startServerGracefully(listener, handler)
	},
}

CmdServer implements the command: epinio server

var CmdServiceBind = &cobra.Command{
	Use:               "bind SERVICENAME APPNAME",
	Short:             "Bind a service SERVICENAME to an Epinio app APPNAME",
	Args:              cobra.ExactArgs(2),
	ValidArgsFunction: findServiceApp,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		serviceName := args[0]
		appName := args[1]

		err := client.ServiceBind(serviceName, appName)
		return errors.Wrap(err, "error binding service")
	},
}

var CmdServiceCatalog = &cobra.Command{
	Use:               "catalog [NAME]",
	Short:             "Lists all available Epinio catalog services, or show the details of the specified one",
	ValidArgsFunction: matchingCatalogFinder,
	Args:              cobra.MaximumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		if len(args) == 0 {
			err := client.ServiceCatalog()
			return errors.Wrap(err, "error listing Epinio catalog services")
		}

		if len(args) == 1 {
			serviceName := args[0]
			err := client.ServiceCatalogShow(cmd.Context(), serviceName)
			return errors.Wrap(err, fmt.Sprintf("error showing %s Epinio catalog service", serviceName))
		}

		return nil
	},
}

var CmdServiceCreate = &cobra.Command{
	Use:               "create CATALOGSERVICENAME SERVICENAME",
	Short:             "Create a service SERVICENAME of an Epinio catalog service CATALOGSERVICENAME",
	Args:              cobra.ExactArgs(2),
	ValidArgsFunction: matchingCatalogFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		wait, err := cmd.Flags().GetBool("wait")
		if err != nil {
			return errors.Wrap(err, "error reading option --wait")
		}

		cvAssignments, err := cmd.Flags().GetStringSlice("chart-value")
		if err != nil {
			return errors.Wrap(err, "failed to read option --chart-value")
		}
		chartValues := models.ChartValueSettings{}
		for _, assignment := range cvAssignments {
			pieces := strings.SplitN(assignment, "=", 2)
			if len(pieces) < 2 {
				return errors.New("Bad --chart-value `" + assignment + "`, expected `name=value` as value")
			}
			chartValues[pieces[0]] = pieces[1]
		}

		catalogServiceName := args[0]
		serviceName := args[1]

		err = client.ServiceCreate(catalogServiceName, serviceName, wait, chartValues)
		return errors.Wrap(err, "error creating service")
	},
}

var CmdServiceDelete = &cobra.Command{
	Use:   "delete SERVICENAME1 [SERVICENAME2 ...]",
	Short: "Delete one or more services",
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

		client.API.DisableVersionWarning()

		matches := clicmd.FilteredMatchingFinder(args, toComplete, client.ServiceMatching)
		return matches, cobra.ShellCompDirectiveNoFileComp
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		unbind, err := cmd.Flags().GetBool("unbind")
		if err != nil {
			return errors.Wrap(err, "error reading option --unbind")
		}

		all, err := cmd.Flags().GetBool("all")
		if err != nil {
			return errors.Wrap(err, "error reading option --all")
		}

		if all && len(args) > 0 {
			return errors.New("Conflict between --all and named services")
		}
		if !all && len(args) == 0 {
			return errors.New("No services specified for deletion")
		}

		err = client.ServiceDelete(args, unbind, all)
		return errors.Wrap(err, "error deleting service")
	},
}

var CmdServiceList = &cobra.Command{
	Use:   "list",
	Short: "List all the services in the targeted namespace",
	Args:  cobra.ExactArgs(0),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		all, err := cmd.Flags().GetBool("all")
		if err != nil {
			return errors.Wrap(err, "error reading option --all")
		}

		if all {
			err = client.ServiceListAll()
		} else {
			err = client.ServiceList()
		}

		return errors.Wrap(err, "error listing services")
	},
}

var CmdServicePortForward = &cobra.Command{
	Use:               "port-forward SERVICENAME [LOCAL_PORT] [...[LOCAL_PORT_N]]",
	Short:             "forward one or more local ports to a service SERVICENAME",
	Args:              cobra.MinimumNArgs(2),
	ValidArgsFunction: matchingServiceFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		serviceName := args[0]
		ports := args[1:]

		err := client.ServicePortForward(cmd.Context(), serviceName, servicePortForwardAddress, ports)

		return errors.Wrap(err, "error port forwarding to service")
	},
}

CmdServicePortForward implements the command: epinio service port-forward

var CmdServiceShow = &cobra.Command{
	Use:               "show SERVICENAME",
	Short:             "Show details of a service SERVICENAME",
	Args:              cobra.ExactArgs(1),
	ValidArgsFunction: matchingServiceFinder,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		serviceName := args[0]

		err := client.ServiceShow(serviceName)
		return errors.Wrap(err, "error showing service")
	},
}

var CmdServiceUnbind = &cobra.Command{
	Use:               "unbind SERVICENAME APPNAME",
	Short:             "Unbinds a service SERVICENAME from an Epinio app APPNAME",
	Args:              cobra.ExactArgs(2),
	ValidArgsFunction: findServiceApp,
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		serviceName := args[0]
		appName := args[1]

		err := client.ServiceUnbind(serviceName, appName)
		return errors.Wrap(err, "error unbinding service")
	},
}

var CmdServiceUpdate = &cobra.Command{
	Use:   "update NAME [flags]",
	Short: "Update a service",
	Long:  `Update service by name and change instructions through flags.`,
	Args:  cobra.ExactArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		cmd.SilenceUsage = true

		wait, err := cmd.Flags().GetBool("wait")
		if err != nil {
			return errors.Wrap(err, "error reading option --wait")
		}

		removedKeys, err := changeGetUnset(cmd)
		if err != nil {
			return err
		}

		kvAssignments, err := cmd.Flags().GetStringSlice("set")
		if err != nil {
			return errors.Wrap(err, "failed to read option --set")
		}

		assignments := map[string]string{}
		for _, assignment := range kvAssignments {
			pieces := strings.Split(assignment, "=")
			if len(pieces) != 2 {
				return errors.New("Bad --set assignment `" + assignment + "`, expected `name=value` as value")
			}
			assignments[pieces[0]] = pieces[1]
		}

		err = client.ServiceUpdate(args[0], wait, removedKeys, assignments)
		if err != nil {
			return errors.Wrap(err, "error creating service")
		}

		return nil
	},
	ValidArgsFunction: matchingServiceFinder,
}

CmdServiceUpdate implements the command: epinio service update

var CmdServices = &cobra.Command{
	Use:           "service",
	Aliases:       []string{"services"},
	Short:         "Epinio service management",
	Long:          `Manage the epinio services`,
	SilenceErrors: false,
	Args:          cobra.ExactArgs(1),
}

CmdServices implements the command: epinio services

Functions

func CreateKubeClient

func CreateKubeClient(configPath string) kubernetes.Interface

CreateKubeClient returns a client for access to kubernetes It is currently not used

func Execute

func Execute()

Execute executes the root command. This is called by main.main(). It only needs to happen once to the rootCmd.

func ExitIfError

func ExitIfError(err error)

ExitIfError is a short form of ExitfIfError, with a standard message It is currently not used

func ExitfIfError

func ExitfIfError(err error, message string)

ExitfIfError stops the application with an error exit code, after printing error and message, if there is an error.

func ExitfWithMessage

func ExitfWithMessage(message string, args ...interface{})

ExitfWithMessage stops the application with an error exit code, after formatting and printing the message. It is currently not used

func NewRootCmd

func NewRootCmd() (*cobra.Command, error)

NewRootCmd returns the rootCmd, that is the main `epinio` cli.