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 NewEpinioCLI() *cobra.Command
- func ServiceBind(cmd *cobra.Command, args []string) error
- func ServiceCreate(cmd *cobra.Command, args []string) error
- func ServiceDelete(cmd *cobra.Command, args []string) error
- func ServiceList(cmd *cobra.Command, args []string) error
- func ServiceShow(cmd *cobra.Command, args []string) error
- func ServiceUnbind(cmd *cobra.Command, args []string) error
- func ServiceUpdate(cmd *cobra.Command, args []string) error
Constants ¶
This section is empty.
Variables ¶
var CmdApp = &cobra.Command{ Use: "app", Aliases: []string{"apps"}, Short: "Epinio application features", Long: `Manage epinio application`, 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]) }, }
CmdApp implements the command: epinio app
var CmdAppCreate = &cobra.Command{ Use: "create NAME", Short: "Create just the app, without creating a workload", Args: cobra.ExactArgs(1), ValidArgsFunction: matchingAppsFinder, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } m, err := manifest.UpdateISE(models.ApplicationManifest{}, cmd) if err != nil { return errors.Wrap(err, "unable to get app configuration") } m, err = manifest.UpdateRoutes(m, cmd) if err != nil { return err } err = client.AppCreate(args[0], m.Configuration) return errors.Wrap(err, "error creating app") }, }
CmdAppCreate implements the command: epinio apps create
var CmdAppDelete = &cobra.Command{ Use: "delete NAME", Short: "Deletes an application", Args: cobra.ExactArgs(1), ValidArgsFunction: matchingAppsFinder, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.Delete(cmd.Context(), args[0]) 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`, 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]) }, }
CmdAppEnv implements the command: epinio app env
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 client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } 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), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } 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, err := client.AppStageID(args[0]) if err != nil { return errors.Wrap(err, "error checking app") } if staging { follow = false } else { stageID = "" } err = client.AppLogs(args[0], stageID, follow, nil) 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 client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.AppManifest(args[0], args[1]) return errors.Wrap(err, "error getting app manifest") }, }
CmdAppManifest implements the command: epinio apps manifest
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 client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } 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.UpdateISE(m, cmd) if err != nil { return err } m, err = manifest.UpdateBSN(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") } } params := usercmd.PushParams{ ApplicationManifest: m, } err = client.Push(cmd.Context(), params) if err != nil { return errors.Wrap(err, "error pushing app to server") } return nil }, }
CmdAppPush implements the command: epinio app push
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 client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } 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 client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } m, err := manifest.UpdateISE(models.ApplicationManifest{}, cmd) if err != nil { return errors.Wrap(err, "unable to get app configuration") } m, err = manifest.UpdateRoutes(m, cmd) if err != nil { return errors.Wrap(err, "unable to update domains") } err = client.AppUpdate(args[0], m.Configuration) 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.ExactValidArgs(1), 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 CmdConfig = &cobra.Command{ Use: "config", Short: "Epinio config management", Long: `Manage the epinio cli configuration`, 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]) }, }
CmdConfig implements the command: epinio config
var CmdConfigColors = &cobra.Command{ Use: "colors BOOL", Short: "Manage colored output", Long: "Enable/Disable colored output", Args: func(cmd *cobra.Command, args []string) error { if len(args) != 1 { return errors.New("requires a boolean argument") } _, err := strconv.ParseBool(args[0]) if err != nil { return errors.New("requires a boolean argument") } return nil }, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true ui := termui.NewUI() theConfig, err := config.Load() if err != nil { return errors.Wrap(err, "failed to load configuration") } ui.Note().WithStringValue("Config", theConfig.Location).Msg("Edit Colorization Flag") colors, err := strconv.ParseBool(args[0]) if err != nil { return errors.Wrap(err, "unexpected bool parsing error") } theConfig.Colors = colors if err := theConfig.Save(); err != nil { return err } ui.Success().WithBoolValue("Colors", theConfig.Colors).Msg("Ok") return nil }, }
CmdConfigColors implements the command: epinio config colors
var CmdConfigShow = &cobra.Command{ Use: "show", Short: "Show the current configuration", Args: cobra.ExactArgs(0), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true ui := termui.NewUI() theConfig, err := config.Load() if err != nil { return errors.Wrap(err, "failed to load configuration") } ui.Note().WithStringValue("Config", theConfig.Location).Msg("Show Configuration") certInfo := color.CyanString("None defined") if theConfig.Certs != "" { certInfo = color.BlueString("Present") } ui.Success(). WithTable("Key", "Value"). WithTableRow("Colorized Output", color.MagentaString("%t", theConfig.Colors)). WithTableRow("Current Namespace", color.CyanString(theConfig.Namespace)). WithTableRow("API User Name", color.BlueString(theConfig.User)). WithTableRow("API Password", color.BlueString(theConfig.Password)). WithTableRow("API Url", color.BlueString(theConfig.API)). WithTableRow("WSS Url", color.BlueString(theConfig.WSS)). WithTableRow("Certificates", certInfo). Msg("Ok") return nil }, }
CmdConfigShow implements the command: epinio config show
var CmdConfigUpdate = &cobra.Command{ Use: "update", Short: "Update the api location & stored credentials", Long: "Update the api location and stored credentials from the current cluster", Args: cobra.ExactArgs(0), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := admincmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.ConfigUpdate(cmd.Context()) if err != nil { return errors.Wrap(err, "failed to update the configuration") } return nil }, }
CmdConfigUpdate implements the command: epinio config update
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 client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } 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), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } 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 }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) > 1 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := usercmd.New() if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
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 client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.EnvShow(cmd.Context(), args[0], args[1]) if err != nil { return errors.Wrap(err, "error accessing app environment") } return nil }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) > 2 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := usercmd.New() if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } if len(args) == 1 { matches := app.EnvMatching(context.Background(), args[0], toComplete) return matches, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
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), ValidArgsFunction: matchingAppsFinder, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.EnvUnset(cmd.Context(), args[0], args[1]) if err != nil { return errors.Wrap(err, "error removing from app environment") } return nil }, }
CmdEnvUnset implements the command: epinio app env unset
var CmdInfo = &cobra.Command{ Use: "info", Short: "Shows information about the Epinio environment", Long: `Shows status and versions for epinio's server-side components.`, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.Info() if err != nil { return errors.Wrap(err, "error retrieving Epinio environment information") } return nil }, }
CmdInfo implements the command: epinio info
var CmdNamespace = &cobra.Command{ Use: "namespace", Aliases: []string{"namespaces"}, Short: "Epinio-controlled namespaces", Long: `Manage epinio-controlled namespaces`, 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]) }, }
CmdNamespace implements the command: epinio namespace
var CmdNamespaceCreate = &cobra.Command{ Use: "create NAME", Short: "Creates an epinio-controlled namespace", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.CreateNamespace(args[0]) if err != nil { return errors.Wrap(err, "error creating epinio-controlled namespace") } return nil }, }
CmdNamespaceCreate implements the command: epinio namespace create
var CmdNamespaceDelete = &cobra.Command{ Use: "delete NAME", Short: "Deletes an epinio-controlled namespace", Args: cobra.ExactArgs(1), ValidArgsFunction: matchingNamespaceFinder, PreRunE: func(cmd *cobra.Command, args []string) error { force, err := cmd.Flags().GetBool("force") if err != nil { return err } if !force { cmd.Printf("You are about to delete namespace %s and everything it includes, i.e. applications, services, etc. Are you sure? (y/n): ", args[0]) if !askConfirmation(cmd) { return errors.New("Cancelled by user") } } return nil }, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.DeleteNamespace(args[0]) if err != nil { return errors.Wrap(err, "error deleting epinio-controlled namespace") } return nil }, }
CmdNamespaceDelete implements the command: epinio namespace delete
var CmdNamespaceList = &cobra.Command{ Use: "list", Short: "Lists all epinio-controlled namespaces", RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.Namespaces() if err != nil { return errors.Wrap(err, "error listing epinio-controlled namespaces") } return nil }, }
CmdNamespaces implements the command: epinio namespace list
var CmdNamespaceShow = &cobra.Command{ Use: "show NAME", Short: "Shows the details of an epinio-controlled namespace", Args: cobra.ExactArgs(1), ValidArgsFunction: matchingNamespaceFinder, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.ShowNamespace(args[0]) if err != nil { return errors.Wrap(err, "error showing epinio-controlled namespace") } return nil }, }
CmdNamespaceShow implements the command: epinio namespace 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 httpServerWg := &sync.WaitGroup{} httpServerWg.Add(1) port := viper.GetInt("port") ui := termui.NewUI() logger := tracelog.NewLogger().WithName("EpinioServer") _, listeningPort, err := server.Start(httpServerWg, port, ui, logger) if err != nil { return errors.Wrap(err, "failed to start server") } ui.Normal().Msg("Epinio version: " + version.Version) ui.Normal().Msg("listening on localhost on port " + listeningPort) httpServerWg.Wait() return nil }, }
CmdServer implements the command: epinio server
var CmdService = &cobra.Command{ Use: "service", Aliases: []string{"services"}, Short: "Epinio service features", Long: `Handle service features with Epinio`, 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]) }, }
CmdService implements the command: epinio service
var CmdServiceBind = &cobra.Command{ Use: "bind NAME APP", Short: "Bind a service to an application", Long: `Bind service by name, to named application.`, Args: cobra.ExactArgs(2), RunE: ServiceBind, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) > 1 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := usercmd.New() if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } if len(args) == 1 { matches := app.AppsMatching(toComplete) return matches, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceBind implements the command: epinio service bind
var CmdServiceCreate = &cobra.Command{ Use: "create NAME (KEY VALUE)...", Short: "Create a service", Long: `Create service by name and key/value dictionary.`, Args: func(cmd *cobra.Command, args []string) error { if len(args) < 3 { return errors.New("Not enough arguments, expected name, key, and value") } if len(args)%2 == 0 { return errors.New("Last Key has no value") } return nil }, RunE: ServiceCreate, }
CmdServiceCreate implements the command: epinio service create
var CmdServiceDelete = &cobra.Command{ Use: "delete NAME", Short: "Delete a service", Long: `Delete service by name.`, Args: cobra.ExactArgs(1), RunE: ServiceDelete, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } epinioClient, err := usercmd.New() if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := epinioClient.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceDelete implements the command: epinio service delete
var CmdServiceList = &cobra.Command{ Use: "list [--all]", Short: "Lists services", Long: "Lists services in the targeted namespace, or all", RunE: ServiceList, }
CmdServiceList implements the command: epinio service list
var CmdServiceShow = &cobra.Command{ Use: "show NAME", Short: "Service information", Long: `Show detailed information of the named service.`, Args: cobra.ExactArgs(1), RunE: ServiceShow, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := usercmd.New() if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceShow implements the command: epinio service show
var CmdServiceUnbind = &cobra.Command{ Use: "unbind NAME APP", Short: "Unbind service from an application", Long: `Unbind service by name, from named application.`, Args: cobra.ExactArgs(2), RunE: ServiceUnbind, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) > 1 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := usercmd.New() if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } if len(args) == 1 { matches := app.AppsMatching(toComplete) return matches, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceUnbind implements the command: epinio service unbind
var CmdServiceUpdate = &cobra.Command{ Use: "update NAME", Short: "Update a service", Long: `Update service by name and change instructions through flags.`, Args: cobra.ExactArgs(1), RunE: ServiceUpdate, }
CmdServiceUpdate implements the command: epinio service create
var CmdTarget = &cobra.Command{ Use: "target [namespace]", Short: "Targets an epinio-controlled namespace.", Args: cobra.MaximumNArgs(1), ValidArgsFunction: matchingNamespaceFinder, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := usercmd.New() if err != nil { return errors.Wrap(err, "error initializing cli") } namespace := "" if len(args) > 0 { namespace = args[0] } err = client.Target(namespace) if err != nil { return errors.Wrap(err, "failed to set target") } return nil }, }
CmdTarget implements the command: epinio target
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 ¶
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 NewEpinioCLI ¶ added in v0.0.19
NewEpinioCLI returns the main `epinio` cli.
func ServiceBind ¶
ServiceBind is the backend of command: epinio service bind
func ServiceCreate ¶
ServiceCreate is the backend of command: epinio service create
func ServiceDelete ¶
ServiceDelete is the backend of command: epinio service delete
func ServiceList ¶
ServiceList is the backend of command: epinio service list
func ServiceShow ¶
ServiceShow is the backend of command: epinio service show
func ServiceUnbind ¶
ServiceUnbind is the backend of command: epinio service unbind
Types ¶
This section is empty.
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
Package admincmd provides the commands of the admin CLI, which deals with installing and configurations
|
Package admincmd provides the commands of the admin CLI, which deals with installing and configurations |
Package logprinter is used to print container log lines in color
|
Package logprinter is used to print container log lines in color |
Package server provides the Epinio http server
|
Package server provides the Epinio http server |
requestctx
Package requestctx provides access to special fields in the http request's context
|
Package requestctx provides access to special fields in the http request's context |
Package usercmd provides Epinio CLI commands for users
|
Package usercmd provides Epinio CLI commands for users |