Documentation ¶
Index ¶
- Constants
- Variables
- func CreateKubeClient(configPath string) kubernetes.Interface
- func DisableGoogle(cmd *cobra.Command, args []string) error
- func DisableInCluster(cmd *cobra.Command, args []string) error
- func EnableGoogle(cmd *cobra.Command, args []string) error
- func EnableInCluster(cmd *cobra.Command, args []string) error
- func Execute()
- func ExitIfError(err error)
- func ExitfIfError(err error, message string)
- func ExitfWithMessage(message string, args ...interface{})
- func InstallDeployment(cmd *cobra.Command, deployment kubernetes.Deployment, ...) error
- func NewEpinioCLI() *cobra.Command
- func ServiceBind(cmd *cobra.Command, args []string) error
- func ServiceCreate(cmd *cobra.Command, args []string) error
- func ServiceCreateCustom(cmd *cobra.Command, args []string) error
- func ServiceDelete(cmd *cobra.Command, args []string) error
- func ServiceList(cmd *cobra.Command, args []string) error
- func ServiceListClasses(cmd *cobra.Command, args []string) error
- func ServiceListPlans(cmd *cobra.Command, args []string) error
- func ServiceShow(cmd *cobra.Command, args []string) error
- func ServiceUnbind(cmd *cobra.Command, args []string) error
- func Uninstall(cmd *cobra.Command, args []string) error
- func UninstallDeployment(cmd *cobra.Command, deployment kubernetes.Deployment, successMessage string) error
Constants ¶
const (
DefaultOrganization = "workspace"
)
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 { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
CmdApp implements the `epinio app` command
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 client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.AppCreate(args[0]) if err != nil { return errors.Wrap(err, "error creating app") } return nil }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdAppCreate implements the epinio `apps create` command
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 { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
CmdAppEnv implements the `epinio app env` command ensemble
var CmdAppList = &cobra.Command{ Use: "list", Short: "Lists all applications", Args: cobra.ExactArgs(0), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.Apps() if err != nil { return errors.Wrap(err, "error listing apps") } return nil }, }
CmdAppList implements the epinio `apps list` command
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 := clients.NewEpinioClient(cmd.Context()) 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) if err != nil { return errors.Wrap(err, "error streaming application logs") } return nil }, }
CmdAppLogs implements the epinio `apps logs` command
var CmdAppShow = &cobra.Command{ Use: "show NAME", Short: "Describe the named application", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.AppShow(args[0]) if err != nil { return errors.Wrap(err, "error showing app") } return nil }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdAppShow implements the epinio `apps show` command
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), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } i, err := instances(cmd) if err != nil { return errors.Wrap(err, "trouble with instances") } if i == nil { d := v1.DefaultInstances i = &d } err = client.AppUpdate(args[0], *i) if err != nil { return errors.Wrap(err, "error updating the app") } return nil }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdAppUpdate is used by the epinio `apps update` command to scale a single 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), Run: func(cmd *cobra.Command, args []string) { switch args[0] { case "bash": cmd.Root().GenBashCompletion(os.Stdout) case "zsh": cmd.Root().GenZshCompletion(os.Stdout) case "fish": cmd.Root().GenFishCompletion(os.Stdout, true) case "powershell": cmd.Root().GenPowerShellCompletion(os.Stdout) } }, }
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 { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
CmdConfig implements the `epinio config` command
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 }, Run: func(cmd *cobra.Command, args []string) { fmt.Println("Hello, World!") }, 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") } colors, err := strconv.ParseBool(args[0]) if err != nil { return errors.Wrap(err, "unexpected bool parsing error") } theConfig.Colors = colors theConfig.Save() ui.Success().WithBoolValue("Colors", theConfig.Colors).Msg("Ok") return nil }, }
CmdConfigColors implements the `epinio config colors` command
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") } 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 Organization", color.CyanString(theConfig.Org)). 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 `epinio config show` command
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 := clients.NewEpinioClient(cmd.Context()) 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 `epinio config update` 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 { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
CmdDebug implements the epinio debug command
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 epinio debug command
var CmdDeleteApp = &cobra.Command{ Use: "delete NAME", Short: "Deletes an application", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) 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 }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdDeleteApp implements the epinio delete command
var CmdDisable = &cobra.Command{ Use: "disable", Short: "disable Epinio features", Long: `disable Epinio features which where enabled with "epinio enable"`, SilenceErrors: true, SilenceUsage: true, Args: cobra.MinimumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
var CmdDisableGoogle = &cobra.Command{ Use: "services-google", Short: "disable Google Cloud service in Epinio", Long: `disable Google Cloud services in Epinio which will disable the provisioning of those services. Doesn't delete already provisioned services by default.`, Args: cobra.ExactArgs(0), RunE: DisableGoogle, }
var CmdDisableInCluster = &cobra.Command{ Use: "services-incluster", Short: "disable in-cluster services in Epinio", Long: `disable in-cluster services in Epinio which will disable provisioning services on the same cluster as Epinio. Doesn't delete already provisioned services by default.`, Args: cobra.ExactArgs(0), RunE: DisableInCluster, }
TODO: Implement a flag to also delete provisioned services [TBD]
var CmdEnable = &cobra.Command{ Use: "enable", Short: "enable Epinio features", Long: `enable Epinio features that are not enabled by default`, SilenceErrors: true, SilenceUsage: true, Args: cobra.MinimumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
var CmdEnableGoogle = &cobra.Command{ Use: "services-google", Short: "enable Google Cloud services in Epinio", Long: `enable Google Cloud services in Epinio which allows provisioning those kind of services.`, Args: cobra.ExactArgs(0), RunE: EnableGoogle, }
var CmdEnableInCluster = &cobra.Command{ Use: "services-incluster", Short: "enable in-cluster services in Epinio", Long: `enable in-cluster services in Epinio which allows provisioning services which run on the same cluster as Epinio. Should be used mostly for development.`, Args: cobra.ExactArgs(0), RunE: EnableInCluster, }
var CmdEnvList = &cobra.Command{ Use: "list APPNAME", Short: "Lists application environment", Long: "Lists environment variables of named application", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) 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 }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdEnvList implements the `epinio apps env list` command
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 := clients.NewEpinioClient(cmd.Context()) 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 := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdEnvSet implements the epinio `apps env set` command
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 := clients.NewEpinioClient(cmd.Context()) 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 := clients.NewEpinioClient(context.Background()) 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(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdEnvShow implements the epinio `apps env show` command
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 client, err := clients.NewEpinioClient(cmd.Context()) 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 }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdEnvUnset implements the epinio `apps env unset` command
var CmdInfo = &cobra.Command{ Use: "info", Short: "Shows information about the Epinio environment", Long: `Shows status and version for Kubernetes, Gitea, Tekton and Eirini.`, RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) 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 epinio info command
var CmdInstall = &cobra.Command{ Use: "install", Short: "install Epinio in your configured kubernetes cluster", Long: `install Epinio PaaS in your configured kubernetes cluster`, Args: cobra.ExactArgs(0), RunE: install, }
var CmdInstallCertManager = &cobra.Command{ Use: "install-cert-manager", Short: "install Epinio's cert-manager in your configured kubernetes cluster", Long: `install Epinio cert-manager controller in your configured kubernetes cluster`, Args: cobra.ExactArgs(0), RunE: installCertManager, }
var CmdInstallIngress = &cobra.Command{ Use: "install-ingress", Short: "install Epinio's Ingress in your configured kubernetes cluster", Long: `install Epinio Ingress controller in your configured kubernetes cluster`, Args: cobra.ExactArgs(0), RunE: installIngress, }
var CmdOrg = &cobra.Command{ Use: "org", Aliases: []string{"orgs"}, Short: "Epinio organizations", Long: `Manage epinio organizations`, SilenceErrors: true, SilenceUsage: true, Args: cobra.MinimumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
CmdOrg implements the `epinio org` command
var CmdOrgCreate = &cobra.Command{ Use: "create NAME", Short: "Creates an organization", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.CreateOrg(args[0]) if err != nil { return errors.Wrap(err, "error creating org") } return nil }, }
CmdOrgCreate implements the epinio `orgs create` command
var CmdOrgDelete = &cobra.Command{ Use: "delete NAME", Short: "Deletes an organization", Args: cobra.ExactArgs(1), 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 organization %s and everything included in it (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 := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.DeleteOrg(args[0]) if err != nil { return errors.Wrap(err, "error deleting org") } return nil }, }
CmdOrgDelete implements the epinio `orgs delete` command
var CmdOrgList = &cobra.Command{ Use: "list", Short: "Lists all organizations", RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } err = client.Orgs() if err != nil { return errors.Wrap(err, "error listing orgs") } return nil }, }
CmdOrgs implements the epinio `orgs list` command
var CmdPush = &cobra.Command{ Use: "push NAME [URL|PATH_TO_APPLICATION_SOURCES]", Short: "Push an application from the specified directory, or the current working directory", Args: cobra.RangeArgs(1, 2), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } gitRevision, err := cmd.Flags().GetString("git") if err != nil { return errors.Wrap(err, "could not read option --git") } dockerImageURL, err := cmd.Flags().GetString("docker-image-url") if err != nil { return errors.Wrap(err, "could not read option --docker-image-url") } if gitRevision != "" && dockerImageURL != "" { return errors.Wrap(err, "cannot use both, git and docker image url") } builderImage, err := cmd.Flags().GetString("builder-image") if err != nil { return errors.Wrap(err, "could not read option --builder-image") } var path string if len(args) == 1 { if gitRevision != "" { cmd.SilenceUsage = false return errors.New("app name or git repository url missing") } path, err = os.Getwd() if err != nil { return errors.Wrap(err, "working directory not accessible") } } else { path = args[1] } if dockerImageURL != "" { path = "" } if gitRevision == "" && dockerImageURL == "" { if _, err := os.Stat(path); err != nil { cmd.SilenceUsage = false return errors.Wrap(err, "path not accessible") } } i, err := instances(cmd) if err != nil { return errors.Wrap(err, "trouble with instances") } params := clients.PushParams{ Name: args[0], Instances: i, GitRev: gitRevision, Docker: dockerImageURL, Path: path, BuilderImage: builderImage, } services, err := cmd.Flags().GetStringSlice("bind") if err != nil { return errors.Wrap(err, "failed to read option --bind") } params.Services = services err = client.Push(cmd.Context(), params) if err != nil { return errors.Wrap(err, "error pushing app to server") } return nil }, }
CmdPush implements the epinio push command
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.NewServerLogger() _, listeningPort, err := startEpinioServer(httpServerWg, port, ui, logger) if err != nil { return errors.Wrap(err, "failed to start server") } ui.Normal().Msg("listening on localhost on port " + listeningPort) httpServerWg.Wait() return nil }, }
CmdServer implements the epinio server command
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 { cmd.Usage() return fmt.Errorf(`Unknown method "%s"`, args[0]) }, }
CmdService implements the epinio service command
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 := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } if len(args) == 1 { matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceBind implements the epinio service bind command
var CmdServiceCreate = &cobra.Command{ Use: "create NAME CLASS PLAN", Short: "Create a service", Long: `Create service by name, class, plan, and optional json data.`, Args: func(cmd *cobra.Command, args []string) error { if len(args) < 3 { return errors.New("Not enough arguments, expected name, class, plan") } return nil }, RunE: ServiceCreate, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) > 2 { return nil, cobra.ShellCompDirectiveNoFileComp } if len(args) == 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } if len(args) == 2 { matches := app.ServicePlanMatching(context.Background(), args[1], toComplete) return matches, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceClassMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceCreate implements the epinio service create command
var CmdServiceCreateCustom = &cobra.Command{ Use: "create-custom NAME (KEY VALUE)...", Short: "Create a custom service", Long: `Create custom 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: ServiceCreateCustom, }
CmdServiceCreateCustom implements the epinio service create-custom command
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 } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceDelete implements the epinio service delete command
var CmdServiceList = &cobra.Command{ Use: "list", Short: "Lists all services", RunE: ServiceList, }
CmdServiceList implements the epinio service list command
var CmdServiceListClasses = &cobra.Command{ Use: "list-classes", Short: "Lists the available service classes", RunE: ServiceListClasses, }
CmdServiceListClasses implements the epinio service classes command
var CmdServiceListPlans = &cobra.Command{ Use: "list-plans CLASS", Short: "Lists all plans provided by the named service class", Args: cobra.ExactArgs(1), RunE: ServiceListPlans, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceClassMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceListPlans implements the epinio service plans command
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 := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceShow implements the epinio service show command
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 := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } if len(args) == 1 { matches := app.AppsMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp } matches := app.ServiceMatching(context.Background(), toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdServiceUnbind implements the epinio service unbind command
var CmdTarget = &cobra.Command{ Use: "target [org]", Short: "Targets an organization in Epinio.", Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cmd.SilenceUsage = true client, err := clients.NewEpinioClient(cmd.Context()) if err != nil { return errors.Wrap(err, "error initializing cli") } org := "" if len(args) > 0 { org = args[0] } err = client.Target(org) if err != nil { return errors.Wrap(err, "failed to set target") } return nil }, ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { if len(args) != 0 { return nil, cobra.ShellCompDirectiveNoFileComp } app, err := clients.NewEpinioClient(context.Background()) if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } matches := app.OrgsMatching(toComplete) return matches, cobra.ShellCompDirectiveNoFileComp }, }
CmdTarget implements the epinio target command
Functions ¶
func CreateKubeClient ¶
func CreateKubeClient(configPath string) kubernetes.Interface
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)
func ExitfIfError ¶
func ExitfWithMessage ¶
func ExitfWithMessage(message string, args ...interface{})
func InstallDeployment ¶
func InstallDeployment(cmd *cobra.Command, deployment kubernetes.Deployment, opts kubernetes.InstallationOptions, successMessage string) error
func NewEpinioCLI ¶ added in v0.0.19
NewEpinioCLI returns the `epinio` cli.
func ServiceBind ¶
ServiceBind implements the epinio service bind command
func ServiceCreate ¶
ServiceCreate implements the epinio service create command
func ServiceCreateCustom ¶
ServiceCreateCustom implements the epinio service create-custom command
func ServiceDelete ¶
ServiceDelete implements the epinio service delete command
func ServiceList ¶
ServiceList implements the epinio service list command
func ServiceListClasses ¶
ServiceListClasses implements the epinio service list-classes command
func ServiceListPlans ¶
ServiceListPlans implements the epinio service list-plans command
func ServiceShow ¶
ServiceShow implements the epinio service show command
func ServiceUnbind ¶
ServiceUnbind implements the epinio service unbind command
func UninstallDeployment ¶
func UninstallDeployment(cmd *cobra.Command, deployment kubernetes.Deployment, successMessage string) error
Types ¶
This section is empty.
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
Package clients contains all the CLI commands for the client
|
Package clients contains all the CLI commands for the client |
gitea
Package gitea deals with using gitea as a store for pushed applications and their deployment info
|
Package gitea deals with using gitea as a store for pushed applications and their deployment info |
Package logprinter is used to print container log lines in color
|
Package logprinter is used to print container log lines in color |