cli

package
v0.6.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 4, 2021 License: MPL-2.0 Imports: 101 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// EnvLogLevel is the env var to set with the log level.
	EnvLogLevel = "WAYPOINT_LOG_LEVEL"

	// EnvPlain is the env var that can be set to force plain output mode.
	EnvPlain = "WAYPOINT_PLAIN"
)
View Source 
const DefaultURLControlAddress = "https://control.hzn.network"

Variables

View Source 
var (
	// ErrSentinel is a sentinel value that we can return from Init to force an exit.
	ErrSentinel = errors.New("error sentinel")
)
View Source 
var (
	ExposeDocs bool
)

Functions

func Commands 

func Commands(
	ctx context.Context,
	log hclog.Logger,
	logOutput io.Writer,
	opts ...Option,
) (*baseCommand, map[string]cli.CommandFactory)

commands returns the map of commands that can be used to initialize a CLI.

func GroupedHelpFunc 

func GroupedHelpFunc(f cli.HelpFunc) cli.HelpFunc

func ListDeployments added in v0.6.2 

func ListDeployments(c context.Context, client pb.WaypointClient, app string, project string, workspace string) (*pb.UI_ListDeploymentsResponse, error)

func ListReleases added in v0.6.2 

func ListReleases(c context.Context, client pb.WaypointClient, app string, project string, workspace string) (*pb.UI_ListReleasesResponse, error)

func Main 

func Main(args []string) int

Main runs the CLI with the given arguments and returns the exit code. The arguments SHOULD include argv[0] as the program name.

Types

type AppDocsCommand 

type AppDocsCommand struct {
	// contains filtered or unexported fields
}

func (*AppDocsCommand) AutocompleteArgs 

func (c *AppDocsCommand) AutocompleteArgs() complete.Predictor

func (*AppDocsCommand) AutocompleteFlags 

func (c *AppDocsCommand) AutocompleteFlags() complete.Flags

func (AppDocsCommand) Close 

func (c AppDocsCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (AppDocsCommand) DoApp 

func (c AppDocsCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*AppDocsCommand) Flags 

func (c *AppDocsCommand) Flags() *flag.Sets

func (*AppDocsCommand) Help 

func (c *AppDocsCommand) Help() string

func (AppDocsCommand) Init 

func (c AppDocsCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*AppDocsCommand) Run 

func (c *AppDocsCommand) Run(args []string) int

func (*AppDocsCommand) Synopsis 

func (c *AppDocsCommand) Synopsis() string

type ArtifactBuildCommand 

type ArtifactBuildCommand struct {
	// contains filtered or unexported fields
}

func (*ArtifactBuildCommand) AutocompleteArgs 

func (c *ArtifactBuildCommand) AutocompleteArgs() complete.Predictor

func (*ArtifactBuildCommand) AutocompleteFlags 

func (c *ArtifactBuildCommand) AutocompleteFlags() complete.Flags

func (ArtifactBuildCommand) Close 

func (c ArtifactBuildCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ArtifactBuildCommand) DoApp 

func (c ArtifactBuildCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ArtifactBuildCommand) Flags 

func (c *ArtifactBuildCommand) Flags() *flag.Sets

func (*ArtifactBuildCommand) Help 

func (c *ArtifactBuildCommand) Help() string

func (ArtifactBuildCommand) Init 

func (c ArtifactBuildCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ArtifactBuildCommand) Run 

func (c *ArtifactBuildCommand) Run(args []string) int

func (*ArtifactBuildCommand) Synopsis 

func (c *ArtifactBuildCommand) Synopsis() string

type ArtifactListCommand 

type ArtifactListCommand struct {
	// contains filtered or unexported fields
}

func (*ArtifactListCommand) AutocompleteArgs 

func (c *ArtifactListCommand) AutocompleteArgs() complete.Predictor

func (*ArtifactListCommand) AutocompleteFlags 

func (c *ArtifactListCommand) AutocompleteFlags() complete.Flags

func (ArtifactListCommand) Close 

func (c ArtifactListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ArtifactListCommand) DoApp 

func (c ArtifactListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ArtifactListCommand) Flags 

func (c *ArtifactListCommand) Flags() *flag.Sets

func (*ArtifactListCommand) Help 

func (c *ArtifactListCommand) Help() string

func (ArtifactListCommand) Init 

func (c ArtifactListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ArtifactListCommand) Run 

func (c *ArtifactListCommand) Run(args []string) int

func (*ArtifactListCommand) Synopsis 

func (c *ArtifactListCommand) Synopsis() string

type ArtifactPushCommand 

type ArtifactPushCommand struct {
	// contains filtered or unexported fields
}

func (*ArtifactPushCommand) AutocompleteArgs 

func (c *ArtifactPushCommand) AutocompleteArgs() complete.Predictor

func (*ArtifactPushCommand) AutocompleteFlags 

func (c *ArtifactPushCommand) AutocompleteFlags() complete.Flags

func (ArtifactPushCommand) Close 

func (c ArtifactPushCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ArtifactPushCommand) DoApp 

func (c ArtifactPushCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ArtifactPushCommand) Flags 

func (c *ArtifactPushCommand) Flags() *flag.Sets

func (*ArtifactPushCommand) Help 

func (c *ArtifactPushCommand) Help() string

func (ArtifactPushCommand) Init 

func (c ArtifactPushCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ArtifactPushCommand) Run 

func (c *ArtifactPushCommand) Run(args []string) int

func (*ArtifactPushCommand) Synopsis 

func (c *ArtifactPushCommand) Synopsis() string

type AuthMethodDeleteCommand added in v0.5.0 

type AuthMethodDeleteCommand struct {
	// contains filtered or unexported fields
}

func (*AuthMethodDeleteCommand) AutocompleteArgs added in v0.5.0 

func (c *AuthMethodDeleteCommand) AutocompleteArgs() complete.Predictor

func (*AuthMethodDeleteCommand) AutocompleteFlags added in v0.5.0 

func (c *AuthMethodDeleteCommand) AutocompleteFlags() complete.Flags

func (AuthMethodDeleteCommand) Close added in v0.5.0 

func (c AuthMethodDeleteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (AuthMethodDeleteCommand) DoApp added in v0.5.0 

func (c AuthMethodDeleteCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*AuthMethodDeleteCommand) Flags added in v0.5.0 

func (c *AuthMethodDeleteCommand) Flags() *flag.Sets

func (*AuthMethodDeleteCommand) Help added in v0.5.0 

func (c *AuthMethodDeleteCommand) Help() string

func (AuthMethodDeleteCommand) Init added in v0.5.0 

func (c AuthMethodDeleteCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*AuthMethodDeleteCommand) Run added in v0.5.0 

func (c *AuthMethodDeleteCommand) Run(args []string) int

func (*AuthMethodDeleteCommand) Synopsis added in v0.5.0 

func (c *AuthMethodDeleteCommand) Synopsis() string

type AuthMethodInspectCommand added in v0.5.0 

type AuthMethodInspectCommand struct {
	// contains filtered or unexported fields
}

func (*AuthMethodInspectCommand) AutocompleteArgs added in v0.5.0 

func (c *AuthMethodInspectCommand) AutocompleteArgs() complete.Predictor

func (*AuthMethodInspectCommand) AutocompleteFlags added in v0.5.0 

func (c *AuthMethodInspectCommand) AutocompleteFlags() complete.Flags

func (AuthMethodInspectCommand) Close added in v0.5.0 

func (c AuthMethodInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (AuthMethodInspectCommand) DoApp added in v0.5.0 

func (c AuthMethodInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*AuthMethodInspectCommand) Flags added in v0.5.0 

func (c *AuthMethodInspectCommand) Flags() *flag.Sets

func (*AuthMethodInspectCommand) Help added in v0.5.0 

func (c *AuthMethodInspectCommand) Help() string

func (AuthMethodInspectCommand) Init added in v0.5.0 

func (c AuthMethodInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*AuthMethodInspectCommand) Run added in v0.5.0 

func (c *AuthMethodInspectCommand) Run(args []string) int

func (*AuthMethodInspectCommand) Synopsis added in v0.5.0 

func (c *AuthMethodInspectCommand) Synopsis() string

type AuthMethodListCommand added in v0.5.0 

type AuthMethodListCommand struct {
	// contains filtered or unexported fields
}

func (*AuthMethodListCommand) AutocompleteArgs added in v0.5.0 

func (c *AuthMethodListCommand) AutocompleteArgs() complete.Predictor

func (*AuthMethodListCommand) AutocompleteFlags added in v0.5.0 

func (c *AuthMethodListCommand) AutocompleteFlags() complete.Flags

func (AuthMethodListCommand) Close added in v0.5.0 

func (c AuthMethodListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (AuthMethodListCommand) DoApp added in v0.5.0 

func (c AuthMethodListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*AuthMethodListCommand) Flags added in v0.5.0 

func (c *AuthMethodListCommand) Flags() *flag.Sets

func (*AuthMethodListCommand) Help added in v0.5.0 

func (c *AuthMethodListCommand) Help() string

func (AuthMethodListCommand) Init added in v0.5.0 

func (c AuthMethodListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*AuthMethodListCommand) Run added in v0.5.0 

func (c *AuthMethodListCommand) Run(args []string) int

func (*AuthMethodListCommand) Synopsis added in v0.5.0 

func (c *AuthMethodListCommand) Synopsis() string

type AuthMethodSetOIDCCommand added in v0.5.0 

type AuthMethodSetOIDCCommand struct {
	// contains filtered or unexported fields
}

func (*AuthMethodSetOIDCCommand) AutocompleteArgs added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) AutocompleteArgs() complete.Predictor

func (*AuthMethodSetOIDCCommand) AutocompleteFlags added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) AutocompleteFlags() complete.Flags

func (AuthMethodSetOIDCCommand) Close added in v0.5.0 

func (c AuthMethodSetOIDCCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (AuthMethodSetOIDCCommand) DoApp added in v0.5.0 

func (c AuthMethodSetOIDCCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*AuthMethodSetOIDCCommand) Flags added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) Flags() *flag.Sets

func (*AuthMethodSetOIDCCommand) Help added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) Help() string

func (AuthMethodSetOIDCCommand) Init added in v0.5.0 

func (c AuthMethodSetOIDCCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*AuthMethodSetOIDCCommand) Run added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) Run(args []string) int

func (*AuthMethodSetOIDCCommand) Synopsis added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) Synopsis() string

type BuildListCommand 

type BuildListCommand struct {
	// contains filtered or unexported fields
}

func (*BuildListCommand) AutocompleteArgs 

func (c *BuildListCommand) AutocompleteArgs() complete.Predictor

func (*BuildListCommand) AutocompleteFlags 

func (c *BuildListCommand) AutocompleteFlags() complete.Flags

func (BuildListCommand) Close 

func (c BuildListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (BuildListCommand) DoApp 

func (c BuildListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*BuildListCommand) Flags 

func (c *BuildListCommand) Flags() *flag.Sets

func (*BuildListCommand) Help 

func (c *BuildListCommand) Help() string

func (BuildListCommand) Init 

func (c BuildListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*BuildListCommand) Run 

func (c *BuildListCommand) Run(args []string) int

func (*BuildListCommand) Synopsis 

func (c *BuildListCommand) Synopsis() string

type ConfigGetCommand 

type ConfigGetCommand struct {
	// contains filtered or unexported fields
}

func (*ConfigGetCommand) AutocompleteArgs 

func (c *ConfigGetCommand) AutocompleteArgs() complete.Predictor

func (*ConfigGetCommand) AutocompleteFlags 

func (c *ConfigGetCommand) AutocompleteFlags() complete.Flags

func (ConfigGetCommand) Close 

func (c ConfigGetCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ConfigGetCommand) DoApp 

func (c ConfigGetCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ConfigGetCommand) Flags 

func (c *ConfigGetCommand) Flags() *flag.Sets

func (*ConfigGetCommand) Help 

func (c *ConfigGetCommand) Help() string

func (ConfigGetCommand) Init 

func (c ConfigGetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ConfigGetCommand) Run 

func (c *ConfigGetCommand) Run(args []string) int

func (*ConfigGetCommand) Synopsis 

func (c *ConfigGetCommand) Synopsis() string

type ConfigSetCommand 

type ConfigSetCommand struct {
	// contains filtered or unexported fields
}

func (*ConfigSetCommand) AutocompleteArgs 

func (c *ConfigSetCommand) AutocompleteArgs() complete.Predictor

func (*ConfigSetCommand) AutocompleteFlags 

func (c *ConfigSetCommand) AutocompleteFlags() complete.Flags

func (ConfigSetCommand) Close 

func (c ConfigSetCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ConfigSetCommand) DoApp 

func (c ConfigSetCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ConfigSetCommand) Flags 

func (c *ConfigSetCommand) Flags() *flag.Sets

func (*ConfigSetCommand) Help 

func (c *ConfigSetCommand) Help() string

func (ConfigSetCommand) Init 

func (c ConfigSetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ConfigSetCommand) Run 

func (c *ConfigSetCommand) Run(args []string) int

func (*ConfigSetCommand) Synopsis 

func (c *ConfigSetCommand) Synopsis() string

type ConfigSourceGetCommand added in v0.2.0 

type ConfigSourceGetCommand struct {
	// contains filtered or unexported fields
}

func (*ConfigSourceGetCommand) AutocompleteArgs added in v0.2.0 

func (c *ConfigSourceGetCommand) AutocompleteArgs() complete.Predictor

func (*ConfigSourceGetCommand) AutocompleteFlags added in v0.2.0 

func (c *ConfigSourceGetCommand) AutocompleteFlags() complete.Flags

func (ConfigSourceGetCommand) Close added in v0.2.0 

func (c ConfigSourceGetCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ConfigSourceGetCommand) DoApp added in v0.2.0 

func (c ConfigSourceGetCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ConfigSourceGetCommand) Flags added in v0.2.0 

func (c *ConfigSourceGetCommand) Flags() *flag.Sets

func (*ConfigSourceGetCommand) Help added in v0.2.0 

func (c *ConfigSourceGetCommand) Help() string

func (ConfigSourceGetCommand) Init added in v0.2.0 

func (c ConfigSourceGetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ConfigSourceGetCommand) Run added in v0.2.0 

func (c *ConfigSourceGetCommand) Run(args []string) int

func (*ConfigSourceGetCommand) Synopsis added in v0.2.0 

func (c *ConfigSourceGetCommand) Synopsis() string

type ConfigSourceSetCommand added in v0.2.0 

type ConfigSourceSetCommand struct {
	// contains filtered or unexported fields
}

func (*ConfigSourceSetCommand) AutocompleteArgs added in v0.2.0 

func (c *ConfigSourceSetCommand) AutocompleteArgs() complete.Predictor

func (*ConfigSourceSetCommand) AutocompleteFlags added in v0.2.0 

func (c *ConfigSourceSetCommand) AutocompleteFlags() complete.Flags

func (ConfigSourceSetCommand) Close added in v0.2.0 

func (c ConfigSourceSetCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ConfigSourceSetCommand) DoApp added in v0.2.0 

func (c ConfigSourceSetCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ConfigSourceSetCommand) Flags added in v0.2.0 

func (c *ConfigSourceSetCommand) Flags() *flag.Sets

func (*ConfigSourceSetCommand) Help added in v0.2.0 

func (c *ConfigSourceSetCommand) Help() string

func (ConfigSourceSetCommand) Init added in v0.2.0 

func (c ConfigSourceSetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ConfigSourceSetCommand) Run added in v0.2.0 

func (c *ConfigSourceSetCommand) Run(args []string) int

func (*ConfigSourceSetCommand) Synopsis added in v0.2.0 

func (c *ConfigSourceSetCommand) Synopsis() string

type ConfigSyncCommand added in v0.2.0 

type ConfigSyncCommand struct {
	// contains filtered or unexported fields
}

func (*ConfigSyncCommand) AutocompleteArgs added in v0.2.0 

func (c *ConfigSyncCommand) AutocompleteArgs() complete.Predictor

func (*ConfigSyncCommand) AutocompleteFlags added in v0.2.0 

func (c *ConfigSyncCommand) AutocompleteFlags() complete.Flags

func (ConfigSyncCommand) Close added in v0.2.0 

func (c ConfigSyncCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ConfigSyncCommand) DoApp added in v0.2.0 

func (c ConfigSyncCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ConfigSyncCommand) Flags added in v0.2.0 

func (c *ConfigSyncCommand) Flags() *flag.Sets

func (*ConfigSyncCommand) Help added in v0.2.0 

func (c *ConfigSyncCommand) Help() string

func (ConfigSyncCommand) Init added in v0.2.0 

func (c ConfigSyncCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ConfigSyncCommand) Run added in v0.2.0 

func (c *ConfigSyncCommand) Run(args []string) int

func (*ConfigSyncCommand) Synopsis added in v0.2.0 

func (c *ConfigSyncCommand) Synopsis() string

type ContextClearCommand 

type ContextClearCommand struct {
	// contains filtered or unexported fields
}

func (*ContextClearCommand) AutocompleteArgs 

func (c *ContextClearCommand) AutocompleteArgs() complete.Predictor

func (*ContextClearCommand) AutocompleteFlags 

func (c *ContextClearCommand) AutocompleteFlags() complete.Flags

func (ContextClearCommand) Close 

func (c ContextClearCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextClearCommand) DoApp 

func (c ContextClearCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextClearCommand) Flags 

func (c *ContextClearCommand) Flags() *flag.Sets

func (*ContextClearCommand) Help 

func (c *ContextClearCommand) Help() string

func (ContextClearCommand) Init 

func (c ContextClearCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextClearCommand) Run 

func (c *ContextClearCommand) Run(args []string) int

func (*ContextClearCommand) Synopsis 

func (c *ContextClearCommand) Synopsis() string

type ContextCreateCommand 

type ContextCreateCommand struct {
	// contains filtered or unexported fields
}

func (*ContextCreateCommand) AutocompleteArgs 

func (c *ContextCreateCommand) AutocompleteArgs() complete.Predictor

func (*ContextCreateCommand) AutocompleteFlags 

func (c *ContextCreateCommand) AutocompleteFlags() complete.Flags

func (ContextCreateCommand) Close 

func (c ContextCreateCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextCreateCommand) DoApp 

func (c ContextCreateCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextCreateCommand) Flags 

func (c *ContextCreateCommand) Flags() *flag.Sets

func (*ContextCreateCommand) Help 

func (c *ContextCreateCommand) Help() string

func (ContextCreateCommand) Init 

func (c ContextCreateCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextCreateCommand) Run 

func (c *ContextCreateCommand) Run(args []string) int

func (*ContextCreateCommand) Synopsis 

func (c *ContextCreateCommand) Synopsis() string

type ContextDeleteCommand 

type ContextDeleteCommand struct {
	// contains filtered or unexported fields
}

func (*ContextDeleteCommand) AutocompleteArgs 

func (c *ContextDeleteCommand) AutocompleteArgs() complete.Predictor

func (*ContextDeleteCommand) AutocompleteFlags 

func (c *ContextDeleteCommand) AutocompleteFlags() complete.Flags

func (ContextDeleteCommand) Close 

func (c ContextDeleteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextDeleteCommand) DoApp 

func (c ContextDeleteCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextDeleteCommand) Flags 

func (c *ContextDeleteCommand) Flags() *flag.Sets

func (*ContextDeleteCommand) Help 

func (c *ContextDeleteCommand) Help() string

func (ContextDeleteCommand) Init 

func (c ContextDeleteCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextDeleteCommand) Run 

func (c *ContextDeleteCommand) Run(args []string) int

func (*ContextDeleteCommand) Synopsis 

func (c *ContextDeleteCommand) Synopsis() string

type ContextHelpCommand added in v0.3.2 

type ContextHelpCommand struct {
	SynopsisText string
	HelpText     string
	// contains filtered or unexported fields
}

func (*ContextHelpCommand) AutocompleteArgs added in v0.3.2 

func (c *ContextHelpCommand) AutocompleteArgs() complete.Predictor

func (*ContextHelpCommand) AutocompleteFlags added in v0.3.2 

func (c *ContextHelpCommand) AutocompleteFlags() complete.Flags

func (ContextHelpCommand) Close added in v0.3.2 

func (c ContextHelpCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextHelpCommand) DoApp added in v0.3.2 

func (c ContextHelpCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextHelpCommand) Flags added in v0.3.2 

func (c *ContextHelpCommand) Flags() *flag.Sets

func (*ContextHelpCommand) Help added in v0.3.2 

func (c *ContextHelpCommand) Help() string

func (ContextHelpCommand) Init added in v0.3.2 

func (c ContextHelpCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextHelpCommand) Run added in v0.3.2 

func (c *ContextHelpCommand) Run(args []string) int

func (*ContextHelpCommand) Synopsis added in v0.3.2 

func (c *ContextHelpCommand) Synopsis() string

type ContextInspectCommand added in v0.3.2 

type ContextInspectCommand struct {
	// contains filtered or unexported fields
}

func (*ContextInspectCommand) AutocompleteArgs added in v0.3.2 

func (c *ContextInspectCommand) AutocompleteArgs() complete.Predictor

func (*ContextInspectCommand) AutocompleteFlags added in v0.3.2 

func (c *ContextInspectCommand) AutocompleteFlags() complete.Flags

func (ContextInspectCommand) Close added in v0.3.2 

func (c ContextInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextInspectCommand) DoApp added in v0.3.2 

func (c ContextInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextInspectCommand) Flags added in v0.3.2 

func (c *ContextInspectCommand) Flags() *flag.Sets

func (*ContextInspectCommand) Help added in v0.3.2 

func (c *ContextInspectCommand) Help() string

func (ContextInspectCommand) Init added in v0.3.2 

func (c ContextInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextInspectCommand) Run added in v0.3.2 

func (c *ContextInspectCommand) Run(args []string) int

func (*ContextInspectCommand) Synopsis added in v0.3.2 

func (c *ContextInspectCommand) Synopsis() string

type ContextListCommand 

type ContextListCommand struct {
	// contains filtered or unexported fields
}

func (*ContextListCommand) AutocompleteArgs 

func (c *ContextListCommand) AutocompleteArgs() complete.Predictor

func (*ContextListCommand) AutocompleteFlags 

func (c *ContextListCommand) AutocompleteFlags() complete.Flags

func (ContextListCommand) Close 

func (c ContextListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextListCommand) DoApp 

func (c ContextListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextListCommand) Flags 

func (c *ContextListCommand) Flags() *flag.Sets

func (*ContextListCommand) Help 

func (c *ContextListCommand) Help() string

func (ContextListCommand) Init 

func (c ContextListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextListCommand) Run 

func (c *ContextListCommand) Run(args []string) int

func (*ContextListCommand) Synopsis 

func (c *ContextListCommand) Synopsis() string

type ContextRenameCommand 

type ContextRenameCommand struct {
	// contains filtered or unexported fields
}

func (*ContextRenameCommand) AutocompleteArgs 

func (c *ContextRenameCommand) AutocompleteArgs() complete.Predictor

func (*ContextRenameCommand) AutocompleteFlags 

func (c *ContextRenameCommand) AutocompleteFlags() complete.Flags

func (ContextRenameCommand) Close 

func (c ContextRenameCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextRenameCommand) DoApp 

func (c ContextRenameCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextRenameCommand) Flags 

func (c *ContextRenameCommand) Flags() *flag.Sets

func (*ContextRenameCommand) Help 

func (c *ContextRenameCommand) Help() string

func (ContextRenameCommand) Init 

func (c ContextRenameCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextRenameCommand) Run 

func (c *ContextRenameCommand) Run(args []string) int

func (*ContextRenameCommand) Synopsis 

func (c *ContextRenameCommand) Synopsis() string

type ContextSetCommand added in v0.6.0 

type ContextSetCommand struct {
	// contains filtered or unexported fields
}

func (*ContextSetCommand) AutocompleteArgs added in v0.6.0 

func (c *ContextSetCommand) AutocompleteArgs() complete.Predictor

func (*ContextSetCommand) AutocompleteFlags added in v0.6.0 

func (c *ContextSetCommand) AutocompleteFlags() complete.Flags

func (ContextSetCommand) Close added in v0.6.0 

func (c ContextSetCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextSetCommand) DoApp added in v0.6.0 

func (c ContextSetCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextSetCommand) Flags added in v0.6.0 

func (c *ContextSetCommand) Flags() *flag.Sets

func (*ContextSetCommand) Help added in v0.6.0 

func (c *ContextSetCommand) Help() string

func (ContextSetCommand) Init added in v0.6.0 

func (c ContextSetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextSetCommand) Run added in v0.6.0 

func (c *ContextSetCommand) Run(args []string) int

func (*ContextSetCommand) Synopsis added in v0.6.0 

func (c *ContextSetCommand) Synopsis() string

type ContextUseCommand 

type ContextUseCommand struct {
	// contains filtered or unexported fields
}

func (*ContextUseCommand) AutocompleteArgs 

func (c *ContextUseCommand) AutocompleteArgs() complete.Predictor

func (*ContextUseCommand) AutocompleteFlags 

func (c *ContextUseCommand) AutocompleteFlags() complete.Flags

func (ContextUseCommand) Close 

func (c ContextUseCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextUseCommand) DoApp 

func (c ContextUseCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextUseCommand) Flags 

func (c *ContextUseCommand) Flags() *flag.Sets

func (*ContextUseCommand) Help 

func (c *ContextUseCommand) Help() string

func (ContextUseCommand) Init 

func (c ContextUseCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextUseCommand) Run 

func (c *ContextUseCommand) Run(args []string) int

func (*ContextUseCommand) Synopsis 

func (c *ContextUseCommand) Synopsis() string

type ContextVerifyCommand 

type ContextVerifyCommand struct {
	// contains filtered or unexported fields
}

func (*ContextVerifyCommand) AutocompleteArgs 

func (c *ContextVerifyCommand) AutocompleteArgs() complete.Predictor

func (*ContextVerifyCommand) AutocompleteFlags 

func (c *ContextVerifyCommand) AutocompleteFlags() complete.Flags

func (ContextVerifyCommand) Close 

func (c ContextVerifyCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ContextVerifyCommand) DoApp 

func (c ContextVerifyCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ContextVerifyCommand) Flags 

func (c *ContextVerifyCommand) Flags() *flag.Sets

func (*ContextVerifyCommand) Help 

func (c *ContextVerifyCommand) Help() string

func (ContextVerifyCommand) Init 

func (c ContextVerifyCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ContextVerifyCommand) Run 

func (c *ContextVerifyCommand) Run(args []string) int

func (*ContextVerifyCommand) Synopsis 

func (c *ContextVerifyCommand) Synopsis() string

type DeploymentCreateCommand 

type DeploymentCreateCommand struct {
	// contains filtered or unexported fields
}

func (*DeploymentCreateCommand) AutocompleteArgs 

func (c *DeploymentCreateCommand) AutocompleteArgs() complete.Predictor

func (*DeploymentCreateCommand) AutocompleteFlags 

func (c *DeploymentCreateCommand) AutocompleteFlags() complete.Flags

func (DeploymentCreateCommand) Close 

func (c DeploymentCreateCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (DeploymentCreateCommand) DoApp 

func (c DeploymentCreateCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*DeploymentCreateCommand) Flags 

func (c *DeploymentCreateCommand) Flags() *flag.Sets

func (*DeploymentCreateCommand) Help 

func (c *DeploymentCreateCommand) Help() string

func (DeploymentCreateCommand) Init 

func (c DeploymentCreateCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*DeploymentCreateCommand) Run 

func (c *DeploymentCreateCommand) Run(args []string) int

func (*DeploymentCreateCommand) Synopsis 

func (c *DeploymentCreateCommand) Synopsis() string

type DeploymentDestroyCommand 

type DeploymentDestroyCommand struct {
	// contains filtered or unexported fields
}

func (*DeploymentDestroyCommand) AutocompleteArgs 

func (c *DeploymentDestroyCommand) AutocompleteArgs() complete.Predictor

func (*DeploymentDestroyCommand) AutocompleteFlags 

func (c *DeploymentDestroyCommand) AutocompleteFlags() complete.Flags

func (DeploymentDestroyCommand) Close 

func (c DeploymentDestroyCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (DeploymentDestroyCommand) DoApp 

func (c DeploymentDestroyCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*DeploymentDestroyCommand) Flags 

func (c *DeploymentDestroyCommand) Flags() *flag.Sets

func (*DeploymentDestroyCommand) Help 

func (c *DeploymentDestroyCommand) Help() string

func (DeploymentDestroyCommand) Init 

func (c DeploymentDestroyCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*DeploymentDestroyCommand) Run 

func (c *DeploymentDestroyCommand) Run(args []string) int

func (*DeploymentDestroyCommand) Synopsis 

func (c *DeploymentDestroyCommand) Synopsis() string

type DeploymentListCommand 

type DeploymentListCommand struct {
	// contains filtered or unexported fields
}

func (*DeploymentListCommand) AutocompleteArgs 

func (c *DeploymentListCommand) AutocompleteArgs() complete.Predictor

func (*DeploymentListCommand) AutocompleteFlags 

func (c *DeploymentListCommand) AutocompleteFlags() complete.Flags

func (DeploymentListCommand) Close 

func (c DeploymentListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (DeploymentListCommand) DoApp 

func (c DeploymentListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*DeploymentListCommand) Flags 

func (c *DeploymentListCommand) Flags() *flag.Sets

func (*DeploymentListCommand) Help 

func (c *DeploymentListCommand) Help() string

func (DeploymentListCommand) Init 

func (c DeploymentListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*DeploymentListCommand) Run 

func (c *DeploymentListCommand) Run(args []string) int

func (*DeploymentListCommand) Synopsis 

func (c *DeploymentListCommand) Synopsis() string

type DestroyCommand 

type DestroyCommand struct {
	// contains filtered or unexported fields
}

func (DestroyCommand) Close 

func (c DestroyCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (DestroyCommand) DoApp 

func (c DestroyCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*DestroyCommand) Flags 

func (c *DestroyCommand) Flags() *flag.Sets

func (*DestroyCommand) Help 

func (c *DestroyCommand) Help() string

func (DestroyCommand) Init 

func (c DestroyCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*DestroyCommand) Run 

func (c *DestroyCommand) Run(args []string) int

func (*DestroyCommand) Synopsis 

func (c *DestroyCommand) Synopsis() string

type DocsCommand 

type DocsCommand struct {
	// contains filtered or unexported fields
}

func (DocsCommand) Close 

func (c DocsCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (DocsCommand) DoApp 

func (c DocsCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*DocsCommand) Help 

func (c *DocsCommand) Help() string

func (DocsCommand) Init 

func (c DocsCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*DocsCommand) Run 

func (c *DocsCommand) Run(args []string) int

func (*DocsCommand) Synopsis 

func (c *DocsCommand) Synopsis() string

type ExchangeInviteCommand 

type ExchangeInviteCommand struct {
	// contains filtered or unexported fields
}

func (*ExchangeInviteCommand) AutocompleteArgs 

func (c *ExchangeInviteCommand) AutocompleteArgs() complete.Predictor

func (*ExchangeInviteCommand) AutocompleteFlags 

func (c *ExchangeInviteCommand) AutocompleteFlags() complete.Flags

func (ExchangeInviteCommand) Close 

func (c ExchangeInviteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ExchangeInviteCommand) DoApp 

func (c ExchangeInviteCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ExchangeInviteCommand) Flags 

func (c *ExchangeInviteCommand) Flags() *flag.Sets

func (*ExchangeInviteCommand) Help 

func (c *ExchangeInviteCommand) Help() string

func (ExchangeInviteCommand) Init 

func (c ExchangeInviteCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ExchangeInviteCommand) Run 

func (c *ExchangeInviteCommand) Run(args []string) int

func (*ExchangeInviteCommand) Synopsis 

func (c *ExchangeInviteCommand) Synopsis() string

type ExecCommand 

type ExecCommand struct {
	// contains filtered or unexported fields
}

func (*ExecCommand) AutocompleteArgs 

func (c *ExecCommand) AutocompleteArgs() complete.Predictor

func (*ExecCommand) AutocompleteFlags 

func (c *ExecCommand) AutocompleteFlags() complete.Flags

func (ExecCommand) Close 

func (c ExecCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ExecCommand) DoApp 

func (c ExecCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ExecCommand) Flags 

func (c *ExecCommand) Flags() *flag.Sets

func (*ExecCommand) Help 

func (c *ExecCommand) Help() string

func (ExecCommand) Init 

func (c ExecCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ExecCommand) Run 

func (c *ExecCommand) Run(args []string) int

func (*ExecCommand) Synopsis 

func (c *ExecCommand) Synopsis() string

type FmtCommand added in v0.3.0 

type FmtCommand struct {
	// contains filtered or unexported fields
}

func (*FmtCommand) AutocompleteArgs added in v0.3.0 

func (c *FmtCommand) AutocompleteArgs() complete.Predictor

func (*FmtCommand) AutocompleteFlags added in v0.3.0 

func (c *FmtCommand) AutocompleteFlags() complete.Flags

func (FmtCommand) Close added in v0.3.0 

func (c FmtCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (FmtCommand) DoApp added in v0.3.0 

func (c FmtCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*FmtCommand) Flags added in v0.3.0 

func (c *FmtCommand) Flags() *flag.Sets

func (*FmtCommand) Help added in v0.3.0 

func (c *FmtCommand) Help() string

func (FmtCommand) Init added in v0.3.0 

func (c FmtCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*FmtCommand) Run added in v0.3.0 

func (c *FmtCommand) Run(args []string) int

func (*FmtCommand) Synopsis added in v0.3.0 

func (c *FmtCommand) Synopsis() string

type GetInviteCommand 

type GetInviteCommand struct {
	// contains filtered or unexported fields
}

func (*GetInviteCommand) AutocompleteArgs 

func (c *GetInviteCommand) AutocompleteArgs() complete.Predictor

func (*GetInviteCommand) AutocompleteFlags 

func (c *GetInviteCommand) AutocompleteFlags() complete.Flags

func (GetInviteCommand) Close 

func (c GetInviteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (GetInviteCommand) DoApp 

func (c GetInviteCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*GetInviteCommand) Flags 

func (c *GetInviteCommand) Flags() *flag.Sets

func (*GetInviteCommand) Help 

func (c *GetInviteCommand) Help() string

func (GetInviteCommand) Init 

func (c GetInviteCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*GetInviteCommand) Run 

func (c *GetInviteCommand) Run(args []string) int

func (*GetInviteCommand) Synopsis 

func (c *GetInviteCommand) Synopsis() string

type GetTokenCommand 

type GetTokenCommand struct {
	// contains filtered or unexported fields
}

func (*GetTokenCommand) AutocompleteArgs 

func (c *GetTokenCommand) AutocompleteArgs() complete.Predictor

func (*GetTokenCommand) AutocompleteFlags 

func (c *GetTokenCommand) AutocompleteFlags() complete.Flags

func (GetTokenCommand) Close 

func (c GetTokenCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (GetTokenCommand) DoApp 

func (c GetTokenCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*GetTokenCommand) Flags 

func (c *GetTokenCommand) Flags() *flag.Sets

func (*GetTokenCommand) Help 

func (c *GetTokenCommand) Help() string

func (GetTokenCommand) Init 

func (c GetTokenCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*GetTokenCommand) Run 

func (c *GetTokenCommand) Run(args []string) int

func (*GetTokenCommand) Synopsis 

func (c *GetTokenCommand) Synopsis() string

type HasFlags 

type HasFlags interface {
	Flags() *flag.Sets
}

type HostnameDeleteCommand 

type HostnameDeleteCommand struct {
	// contains filtered or unexported fields
}

func (*HostnameDeleteCommand) AutocompleteArgs 

func (c *HostnameDeleteCommand) AutocompleteArgs() complete.Predictor

func (*HostnameDeleteCommand) AutocompleteFlags 

func (c *HostnameDeleteCommand) AutocompleteFlags() complete.Flags

func (HostnameDeleteCommand) Close 

func (c HostnameDeleteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (HostnameDeleteCommand) DoApp 

func (c HostnameDeleteCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*HostnameDeleteCommand) Flags 

func (c *HostnameDeleteCommand) Flags() *flag.Sets

func (*HostnameDeleteCommand) Help 

func (c *HostnameDeleteCommand) Help() string

func (HostnameDeleteCommand) Init 

func (c HostnameDeleteCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*HostnameDeleteCommand) Run 

func (c *HostnameDeleteCommand) Run(args []string) int

func (*HostnameDeleteCommand) Synopsis 

func (c *HostnameDeleteCommand) Synopsis() string

type HostnameListCommand 

type HostnameListCommand struct {
	// contains filtered or unexported fields
}

func (*HostnameListCommand) AutocompleteArgs 

func (c *HostnameListCommand) AutocompleteArgs() complete.Predictor

func (*HostnameListCommand) AutocompleteFlags 

func (c *HostnameListCommand) AutocompleteFlags() complete.Flags

func (HostnameListCommand) Close 

func (c HostnameListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (HostnameListCommand) DoApp 

func (c HostnameListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*HostnameListCommand) Flags 

func (c *HostnameListCommand) Flags() *flag.Sets

func (*HostnameListCommand) Help 

func (c *HostnameListCommand) Help() string

func (HostnameListCommand) Init 

func (c HostnameListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*HostnameListCommand) Run 

func (c *HostnameListCommand) Run(args []string) int

func (*HostnameListCommand) Synopsis 

func (c *HostnameListCommand) Synopsis() string

type HostnameRegisterCommand 

type HostnameRegisterCommand struct {
	// contains filtered or unexported fields
}

func (*HostnameRegisterCommand) AutocompleteArgs 

func (c *HostnameRegisterCommand) AutocompleteArgs() complete.Predictor

func (*HostnameRegisterCommand) AutocompleteFlags 

func (c *HostnameRegisterCommand) AutocompleteFlags() complete.Flags

func (HostnameRegisterCommand) Close 

func (c HostnameRegisterCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (HostnameRegisterCommand) DoApp 

func (c HostnameRegisterCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*HostnameRegisterCommand) Flags 

func (c *HostnameRegisterCommand) Flags() *flag.Sets

func (*HostnameRegisterCommand) Help 

func (c *HostnameRegisterCommand) Help() string

func (HostnameRegisterCommand) Init 

func (c HostnameRegisterCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*HostnameRegisterCommand) Run 

func (c *HostnameRegisterCommand) Run(args []string) int

func (*HostnameRegisterCommand) Synopsis 

func (c *HostnameRegisterCommand) Synopsis() string

type InitCommand 

type InitCommand struct {
	// contains filtered or unexported fields
}

func (*InitCommand) AutocompleteArgs 

func (c *InitCommand) AutocompleteArgs() complete.Predictor

func (*InitCommand) AutocompleteFlags 

func (c *InitCommand) AutocompleteFlags() complete.Flags

func (InitCommand) Close 

func (c InitCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (InitCommand) DoApp 

func (c InitCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*InitCommand) Flags 

func (c *InitCommand) Flags() *flag.Sets

func (*InitCommand) Help 

func (c *InitCommand) Help() string

func (InitCommand) Init 

func (c InitCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*InitCommand) Run 

func (c *InitCommand) Run(args []string) int

func (*InitCommand) Synopsis 

func (c *InitCommand) Synopsis() string

type InstallCommand 

type InstallCommand struct {
	// contains filtered or unexported fields
}

func (*InstallCommand) AutocompleteArgs 

func (c *InstallCommand) AutocompleteArgs() complete.Predictor

func (*InstallCommand) AutocompleteFlags 

func (c *InstallCommand) AutocompleteFlags() complete.Flags

func (InstallCommand) Close 

func (c InstallCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (InstallCommand) DoApp 

func (c InstallCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*InstallCommand) Flags 

func (c *InstallCommand) Flags() *flag.Sets

func (*InstallCommand) Help 

func (c *InstallCommand) Help() string

func (InstallCommand) Init 

func (c InstallCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*InstallCommand) Run 

func (c *InstallCommand) Run(args []string) int

func (*InstallCommand) Synopsis 

func (c *InstallCommand) Synopsis() string

type K8SBootstrapCommand added in v0.6.0 

type K8SBootstrapCommand struct {
	// contains filtered or unexported fields
}

func (*K8SBootstrapCommand) AutocompleteArgs added in v0.6.0 

func (c *K8SBootstrapCommand) AutocompleteArgs() complete.Predictor

func (*K8SBootstrapCommand) AutocompleteFlags added in v0.6.0 

func (c *K8SBootstrapCommand) AutocompleteFlags() complete.Flags

func (K8SBootstrapCommand) Close added in v0.6.0 

func (c K8SBootstrapCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (K8SBootstrapCommand) DoApp added in v0.6.0 

func (c K8SBootstrapCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*K8SBootstrapCommand) Flags added in v0.6.0 

func (c *K8SBootstrapCommand) Flags() *flag.Sets

func (*K8SBootstrapCommand) Help added in v0.6.0 

func (c *K8SBootstrapCommand) Help() string

func (K8SBootstrapCommand) Init added in v0.6.0 

func (c K8SBootstrapCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*K8SBootstrapCommand) Run added in v0.6.0 

func (c *K8SBootstrapCommand) Run(args []string) int

func (*K8SBootstrapCommand) Synopsis added in v0.6.0 

func (c *K8SBootstrapCommand) Synopsis() string

type LoginCommand added in v0.5.0 

type LoginCommand struct {
	// contains filtered or unexported fields
}

func (*LoginCommand) AutocompleteArgs added in v0.5.0 

func (c *LoginCommand) AutocompleteArgs() complete.Predictor

func (*LoginCommand) AutocompleteFlags added in v0.5.0 

func (c *LoginCommand) AutocompleteFlags() complete.Flags

func (LoginCommand) Close added in v0.5.0 

func (c LoginCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (LoginCommand) DoApp added in v0.5.0 

func (c LoginCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*LoginCommand) Flags added in v0.5.0 

func (c *LoginCommand) Flags() *flag.Sets

func (*LoginCommand) Help added in v0.5.0 

func (c *LoginCommand) Help() string

func (LoginCommand) Init added in v0.5.0 

func (c LoginCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*LoginCommand) Run added in v0.5.0 

func (c *LoginCommand) Run(args []string) int

func (*LoginCommand) Synopsis added in v0.5.0 

func (c *LoginCommand) Synopsis() string

type LogsCommand 

type LogsCommand struct {
	// contains filtered or unexported fields
}

func (*LogsCommand) AutocompleteArgs 

func (c *LogsCommand) AutocompleteArgs() complete.Predictor

func (*LogsCommand) AutocompleteFlags 

func (c *LogsCommand) AutocompleteFlags() complete.Flags

func (LogsCommand) Close 

func (c LogsCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (LogsCommand) DoApp 

func (c LogsCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*LogsCommand) Flags 

func (c *LogsCommand) Flags() *flag.Sets

func (*LogsCommand) Help 

func (c *LogsCommand) Help() string

func (LogsCommand) Init 

func (c LogsCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*LogsCommand) Run 

func (c *LogsCommand) Run(args []string) int

func (*LogsCommand) Synopsis 

func (c *LogsCommand) Synopsis() string

type Option 

type Option func(c *baseConfig)

Option is used to configure Init on baseCommand.

func WithArgs 

func WithArgs(args []string) Option

WithArgs sets the arguments to the command that are used for parsing. Remaining arguments can be accessed using your flag set and asking for Args. Example: c.Flags().Args().

func WithClient 

func WithClient(v bool) Option

WithClient configures the CLI to initialize a client.

func WithConfig 

func WithConfig(optional bool) Option

WithConfig configures the CLI to find and load any project configuration. If optional is true, no error will be shown if a config can't be found.

func WithConnectionArg added in v0.5.0 

func WithConnectionArg() Option

WithConnectionArg parses the first argument in the CLI as connection info if it exists. This parses it according to the clicontext.Config.FromURL method.

func WithFlags 

func WithFlags(f *flag.Sets) Option

WithFlags sets the flags that are supported by this command. This MUST be set otherwise a panic will happen. This is usually set by just calling the Flags function on your command implementation.

func WithMultipleApp added in v0.6.0 

func WithMultipleApp() Option

WithMultipleApp configures the CLI to expect a configuration with one or more apps defined in a project. The option will prioritize a value provided to the -project flag.

func WithNoAutoServer added in v0.3.0 

func WithNoAutoServer() Option

WithNoAutoServer configures the CLI to not automatically spin up an in-memory server for this command.

func WithNoConfig 

func WithNoConfig() Option

WithNoConfig configures the CLI to not expect any project configuration. This will not read any configuration files.

func WithOptionalApp added in v0.5.2 

func WithOptionalApp() Option

WithOptionalApp configures the CLI to work with or without an explicit project config locally. It also allows for operations on multiple apps inside a project.

func WithSingleApp 

func WithSingleApp() Option

WithSingleApp configures the CLI to expect a configuration with one or more apps defined but a single app targeted with `-app`. If only a single app exists, it is implicitly the target. Zero apps is an error.

func WithUI 

func WithUI(ui terminal.UI) Option

WithUI configures the CLI to use a specific UI implementation

type PluginCommand 

type PluginCommand struct {
	// contains filtered or unexported fields
}

func (PluginCommand) Close 

func (c PluginCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (PluginCommand) DoApp 

func (c PluginCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*PluginCommand) Flags added in v0.4.2 

func (c *PluginCommand) Flags() *flag.Sets

func (*PluginCommand) Help 

func (c *PluginCommand) Help() string

func (PluginCommand) Init 

func (c PluginCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*PluginCommand) Run 

func (c *PluginCommand) Run(args []string) int

func (*PluginCommand) Synopsis 

func (c *PluginCommand) Synopsis() string

type ProjectApplyCommand added in v0.3.0 

type ProjectApplyCommand struct {
	// contains filtered or unexported fields
}

func (*ProjectApplyCommand) AutocompleteArgs added in v0.3.0 

func (c *ProjectApplyCommand) AutocompleteArgs() complete.Predictor

func (*ProjectApplyCommand) AutocompleteFlags added in v0.3.0 

func (c *ProjectApplyCommand) AutocompleteFlags() complete.Flags

func (ProjectApplyCommand) Close added in v0.3.0 

func (c ProjectApplyCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ProjectApplyCommand) DoApp added in v0.3.0 

func (c ProjectApplyCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ProjectApplyCommand) Flags added in v0.3.0 

func (c *ProjectApplyCommand) Flags() *flag.Sets

func (*ProjectApplyCommand) Help added in v0.3.0 

func (c *ProjectApplyCommand) Help() string

func (ProjectApplyCommand) Init added in v0.3.0 

func (c ProjectApplyCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ProjectApplyCommand) Run added in v0.3.0 

func (c *ProjectApplyCommand) Run(args []string) int

func (*ProjectApplyCommand) Synopsis added in v0.3.0 

func (c *ProjectApplyCommand) Synopsis() string

type ProjectInspectCommand added in v0.5.2 

type ProjectInspectCommand struct {
	// contains filtered or unexported fields
}

func (*ProjectInspectCommand) AutocompleteArgs added in v0.5.2 

func (c *ProjectInspectCommand) AutocompleteArgs() complete.Predictor

func (*ProjectInspectCommand) AutocompleteFlags added in v0.5.2 

func (c *ProjectInspectCommand) AutocompleteFlags() complete.Flags

func (ProjectInspectCommand) Close added in v0.5.2 

func (c ProjectInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ProjectInspectCommand) DoApp added in v0.5.2 

func (c ProjectInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ProjectInspectCommand) Flags added in v0.5.2 

func (c *ProjectInspectCommand) Flags() *flag.Sets

func (*ProjectInspectCommand) FormatProject added in v0.5.2 

func (c *ProjectInspectCommand) FormatProject(projectTarget string) error

func (*ProjectInspectCommand) Help added in v0.5.2 

func (c *ProjectInspectCommand) Help() string

func (ProjectInspectCommand) Init added in v0.5.2 

func (c ProjectInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ProjectInspectCommand) Run added in v0.5.2 

func (c *ProjectInspectCommand) Run(args []string) int

func (*ProjectInspectCommand) Synopsis added in v0.5.2 

func (c *ProjectInspectCommand) Synopsis() string

type ProjectListCommand added in v0.3.0 

type ProjectListCommand struct {
	// contains filtered or unexported fields
}

func (*ProjectListCommand) AutocompleteArgs added in v0.3.0 

func (c *ProjectListCommand) AutocompleteArgs() complete.Predictor

func (*ProjectListCommand) AutocompleteFlags added in v0.3.0 

func (c *ProjectListCommand) AutocompleteFlags() complete.Flags

func (ProjectListCommand) Close added in v0.3.0 

func (c ProjectListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ProjectListCommand) DoApp added in v0.3.0 

func (c ProjectListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ProjectListCommand) Flags added in v0.3.0 

func (c *ProjectListCommand) Flags() *flag.Sets

func (*ProjectListCommand) Help added in v0.3.0 

func (c *ProjectListCommand) Help() string

func (ProjectListCommand) Init added in v0.3.0 

func (c ProjectListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ProjectListCommand) Run added in v0.3.0 

func (c *ProjectListCommand) Run(args []string) int

func (*ProjectListCommand) Synopsis added in v0.3.0 

func (c *ProjectListCommand) Synopsis() string

type ReleaseCreateCommand 

type ReleaseCreateCommand struct {
	// contains filtered or unexported fields
}

func (*ReleaseCreateCommand) AutocompleteArgs 

func (c *ReleaseCreateCommand) AutocompleteArgs() complete.Predictor

func (*ReleaseCreateCommand) AutocompleteFlags 

func (c *ReleaseCreateCommand) AutocompleteFlags() complete.Flags

func (ReleaseCreateCommand) Close 

func (c ReleaseCreateCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ReleaseCreateCommand) DoApp 

func (c ReleaseCreateCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ReleaseCreateCommand) Flags 

func (c *ReleaseCreateCommand) Flags() *flag.Sets

func (*ReleaseCreateCommand) Help 

func (c *ReleaseCreateCommand) Help() string

func (ReleaseCreateCommand) Init 

func (c ReleaseCreateCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ReleaseCreateCommand) Run 

func (c *ReleaseCreateCommand) Run(args []string) int

func (*ReleaseCreateCommand) Synopsis 

func (c *ReleaseCreateCommand) Synopsis() string

type ReleaseListCommand added in v0.5.2 

type ReleaseListCommand struct {
	// contains filtered or unexported fields
}

func (*ReleaseListCommand) AutocompleteArgs added in v0.5.2 

func (c *ReleaseListCommand) AutocompleteArgs() complete.Predictor

func (*ReleaseListCommand) AutocompleteFlags added in v0.5.2 

func (c *ReleaseListCommand) AutocompleteFlags() complete.Flags

func (ReleaseListCommand) Close added in v0.5.2 

func (c ReleaseListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ReleaseListCommand) DoApp added in v0.5.2 

func (c ReleaseListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ReleaseListCommand) Flags added in v0.5.2 

func (c *ReleaseListCommand) Flags() *flag.Sets

func (*ReleaseListCommand) Help added in v0.5.2 

func (c *ReleaseListCommand) Help() string

func (ReleaseListCommand) Init added in v0.5.2 

func (c ReleaseListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ReleaseListCommand) Run added in v0.5.2 

func (c *ReleaseListCommand) Run(args []string) int

func (*ReleaseListCommand) Synopsis added in v0.5.2 

func (c *ReleaseListCommand) Synopsis() string

type RunnerAgentCommand 

type RunnerAgentCommand struct {
	// contains filtered or unexported fields
}

func (*RunnerAgentCommand) AutocompleteArgs 

func (c *RunnerAgentCommand) AutocompleteArgs() complete.Predictor

func (*RunnerAgentCommand) AutocompleteFlags 

func (c *RunnerAgentCommand) AutocompleteFlags() complete.Flags

func (RunnerAgentCommand) Close 

func (c RunnerAgentCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (RunnerAgentCommand) DoApp 

func (c RunnerAgentCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*RunnerAgentCommand) Flags 

func (c *RunnerAgentCommand) Flags() *flag.Sets

func (*RunnerAgentCommand) Help 

func (c *RunnerAgentCommand) Help() string

func (RunnerAgentCommand) Init 

func (c RunnerAgentCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*RunnerAgentCommand) Run 

func (c *RunnerAgentCommand) Run(args []string) int

func (*RunnerAgentCommand) Synopsis 

func (c *RunnerAgentCommand) Synopsis() string

type RunnerProfileInspectCommand added in v0.6.0 

type RunnerProfileInspectCommand struct {
	// contains filtered or unexported fields
}

func (*RunnerProfileInspectCommand) AutocompleteArgs added in v0.6.0 

func (c *RunnerProfileInspectCommand) AutocompleteArgs() complete.Predictor

func (*RunnerProfileInspectCommand) AutocompleteFlags added in v0.6.0 

func (c *RunnerProfileInspectCommand) AutocompleteFlags() complete.Flags

func (RunnerProfileInspectCommand) Close added in v0.6.0 

func (c RunnerProfileInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (RunnerProfileInspectCommand) DoApp added in v0.6.0 

func (c RunnerProfileInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*RunnerProfileInspectCommand) Flags added in v0.6.0 

func (c *RunnerProfileInspectCommand) Flags() *flag.Sets

func (*RunnerProfileInspectCommand) Help added in v0.6.0 

func (c *RunnerProfileInspectCommand) Help() string

func (RunnerProfileInspectCommand) Init added in v0.6.0 

func (c RunnerProfileInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*RunnerProfileInspectCommand) Run added in v0.6.0 

func (c *RunnerProfileInspectCommand) Run(args []string) int

func (*RunnerProfileInspectCommand) Synopsis added in v0.6.0 

func (c *RunnerProfileInspectCommand) Synopsis() string

type RunnerProfileListCommand added in v0.6.0 

type RunnerProfileListCommand struct {
	// contains filtered or unexported fields
}

func (*RunnerProfileListCommand) AutocompleteArgs added in v0.6.0 

func (c *RunnerProfileListCommand) AutocompleteArgs() complete.Predictor

func (*RunnerProfileListCommand) AutocompleteFlags added in v0.6.0 

func (c *RunnerProfileListCommand) AutocompleteFlags() complete.Flags

func (RunnerProfileListCommand) Close added in v0.6.0 

func (c RunnerProfileListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (RunnerProfileListCommand) DoApp added in v0.6.0 

func (c RunnerProfileListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*RunnerProfileListCommand) Flags added in v0.6.0 

func (c *RunnerProfileListCommand) Flags() *flag.Sets

func (*RunnerProfileListCommand) Help added in v0.6.0 

func (c *RunnerProfileListCommand) Help() string

func (RunnerProfileListCommand) Init added in v0.6.0 

func (c RunnerProfileListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*RunnerProfileListCommand) Run added in v0.6.0 

func (c *RunnerProfileListCommand) Run(args []string) int

func (*RunnerProfileListCommand) Synopsis added in v0.6.0 

func (c *RunnerProfileListCommand) Synopsis() string

type RunnerProfileSetCommand added in v0.6.0 

type RunnerProfileSetCommand struct {
	// contains filtered or unexported fields
}

func (*RunnerProfileSetCommand) AutocompleteArgs added in v0.6.0 

func (c *RunnerProfileSetCommand) AutocompleteArgs() complete.Predictor

func (*RunnerProfileSetCommand) AutocompleteFlags added in v0.6.0 

func (c *RunnerProfileSetCommand) AutocompleteFlags() complete.Flags

func (RunnerProfileSetCommand) Close added in v0.6.0 

func (c RunnerProfileSetCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (RunnerProfileSetCommand) DoApp added in v0.6.0 

func (c RunnerProfileSetCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*RunnerProfileSetCommand) Flags added in v0.6.0 

func (c *RunnerProfileSetCommand) Flags() *flag.Sets

func (*RunnerProfileSetCommand) Help added in v0.6.0 

func (c *RunnerProfileSetCommand) Help() string

func (RunnerProfileSetCommand) Init added in v0.6.0 

func (c RunnerProfileSetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*RunnerProfileSetCommand) Run added in v0.6.0 

func (c *RunnerProfileSetCommand) Run(args []string) int

func (*RunnerProfileSetCommand) Synopsis added in v0.6.0 

func (c *RunnerProfileSetCommand) Synopsis() string

type ServerBootstrapCommand 

type ServerBootstrapCommand struct {
	// contains filtered or unexported fields
}

func (*ServerBootstrapCommand) AutocompleteArgs 

func (c *ServerBootstrapCommand) AutocompleteArgs() complete.Predictor

func (*ServerBootstrapCommand) AutocompleteFlags 

func (c *ServerBootstrapCommand) AutocompleteFlags() complete.Flags

func (ServerBootstrapCommand) Close 

func (c ServerBootstrapCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ServerBootstrapCommand) DoApp 

func (c ServerBootstrapCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ServerBootstrapCommand) Flags 

func (c *ServerBootstrapCommand) Flags() *flag.Sets

func (*ServerBootstrapCommand) Help 

func (c *ServerBootstrapCommand) Help() string

func (ServerBootstrapCommand) Init 

func (c ServerBootstrapCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ServerBootstrapCommand) Run 

func (c *ServerBootstrapCommand) Run(args []string) int

func (*ServerBootstrapCommand) Synopsis 

func (c *ServerBootstrapCommand) Synopsis() string

type ServerConfigSetCommand 

type ServerConfigSetCommand struct {
	// contains filtered or unexported fields
}

func (*ServerConfigSetCommand) AutocompleteArgs 

func (c *ServerConfigSetCommand) AutocompleteArgs() complete.Predictor

func (*ServerConfigSetCommand) AutocompleteFlags 

func (c *ServerConfigSetCommand) AutocompleteFlags() complete.Flags

func (ServerConfigSetCommand) Close 

func (c ServerConfigSetCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ServerConfigSetCommand) DoApp 

func (c ServerConfigSetCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ServerConfigSetCommand) Flags 

func (c *ServerConfigSetCommand) Flags() *flag.Sets

func (*ServerConfigSetCommand) Help 

func (c *ServerConfigSetCommand) Help() string

func (ServerConfigSetCommand) Init 

func (c ServerConfigSetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ServerConfigSetCommand) Run 

func (c *ServerConfigSetCommand) Run(args []string) int

func (*ServerConfigSetCommand) Synopsis 

func (c *ServerConfigSetCommand) Synopsis() string

type ServerRunCommand 

type ServerRunCommand struct {
	// contains filtered or unexported fields
}

func (*ServerRunCommand) AutocompleteArgs 

func (c *ServerRunCommand) AutocompleteArgs() complete.Predictor

func (*ServerRunCommand) AutocompleteFlags 

func (c *ServerRunCommand) AutocompleteFlags() complete.Flags

func (ServerRunCommand) Close 

func (c ServerRunCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ServerRunCommand) DoApp 

func (c ServerRunCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ServerRunCommand) Flags 

func (c *ServerRunCommand) Flags() *flag.Sets

func (*ServerRunCommand) Help 

func (c *ServerRunCommand) Help() string

func (ServerRunCommand) Init 

func (c ServerRunCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ServerRunCommand) Run 

func (c *ServerRunCommand) Run(args []string) int

func (*ServerRunCommand) Synopsis 

func (c *ServerRunCommand) Synopsis() string

type ServerUpgradeCommand added in v0.2.1 

type ServerUpgradeCommand struct {
	// contains filtered or unexported fields
}

func (*ServerUpgradeCommand) AutocompleteArgs added in v0.2.1 

func (c *ServerUpgradeCommand) AutocompleteArgs() complete.Predictor

func (*ServerUpgradeCommand) AutocompleteFlags added in v0.2.1 

func (c *ServerUpgradeCommand) AutocompleteFlags() complete.Flags

func (ServerUpgradeCommand) Close added in v0.2.1 

func (c ServerUpgradeCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ServerUpgradeCommand) DoApp added in v0.2.1 

func (c ServerUpgradeCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ServerUpgradeCommand) Flags added in v0.2.1 

func (c *ServerUpgradeCommand) Flags() *flag.Sets

func (*ServerUpgradeCommand) Help added in v0.2.1 

func (c *ServerUpgradeCommand) Help() string

func (ServerUpgradeCommand) Init added in v0.2.1 

func (c ServerUpgradeCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*ServerUpgradeCommand) Run added in v0.2.1 

func (c *ServerUpgradeCommand) Run(args []string) int

func (*ServerUpgradeCommand) Synopsis added in v0.2.1 

func (c *ServerUpgradeCommand) Synopsis() string

type SnapshotBackupCommand added in v0.2.0 

type SnapshotBackupCommand struct {
	// contains filtered or unexported fields
}

func (*SnapshotBackupCommand) AutocompleteArgs added in v0.2.0 

func (c *SnapshotBackupCommand) AutocompleteArgs() complete.Predictor

func (*SnapshotBackupCommand) AutocompleteFlags added in v0.2.0 

func (c *SnapshotBackupCommand) AutocompleteFlags() complete.Flags

func (SnapshotBackupCommand) Close added in v0.2.0 

func (c SnapshotBackupCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (SnapshotBackupCommand) DoApp added in v0.2.0 

func (c SnapshotBackupCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*SnapshotBackupCommand) Flags added in v0.2.0 

func (c *SnapshotBackupCommand) Flags() *flag.Sets

func (*SnapshotBackupCommand) Help added in v0.2.0 

func (c *SnapshotBackupCommand) Help() string

func (SnapshotBackupCommand) Init added in v0.2.0 

func (c SnapshotBackupCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*SnapshotBackupCommand) Run added in v0.2.0 

func (c *SnapshotBackupCommand) Run(args []string) int

func (*SnapshotBackupCommand) Synopsis added in v0.2.0 

func (c *SnapshotBackupCommand) Synopsis() string

type SnapshotRestoreCommand added in v0.2.0 

type SnapshotRestoreCommand struct {
	// contains filtered or unexported fields
}

func (*SnapshotRestoreCommand) AutocompleteArgs added in v0.2.0 

func (c *SnapshotRestoreCommand) AutocompleteArgs() complete.Predictor

func (*SnapshotRestoreCommand) AutocompleteFlags added in v0.2.0 

func (c *SnapshotRestoreCommand) AutocompleteFlags() complete.Flags

func (SnapshotRestoreCommand) Close added in v0.2.0 

func (c SnapshotRestoreCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (SnapshotRestoreCommand) DoApp added in v0.2.0 

func (c SnapshotRestoreCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*SnapshotRestoreCommand) Flags added in v0.2.0 

func (c *SnapshotRestoreCommand) Flags() *flag.Sets

func (*SnapshotRestoreCommand) Help added in v0.2.0 

func (c *SnapshotRestoreCommand) Help() string

func (SnapshotRestoreCommand) Init added in v0.2.0 

func (c SnapshotRestoreCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*SnapshotRestoreCommand) Run added in v0.2.0 

func (c *SnapshotRestoreCommand) Run(args []string) int

func (*SnapshotRestoreCommand) Synopsis added in v0.2.0 

func (c *SnapshotRestoreCommand) Synopsis() string

type StatusCommand added in v0.5.0 

type StatusCommand struct {
	// contains filtered or unexported fields
}

func (*StatusCommand) AutocompleteArgs added in v0.5.0 

func (c *StatusCommand) AutocompleteArgs() complete.Predictor

func (*StatusCommand) AutocompleteFlags added in v0.5.0 

func (c *StatusCommand) AutocompleteFlags() complete.Flags

func (StatusCommand) Close added in v0.5.0 

func (c StatusCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (StatusCommand) DoApp added in v0.5.0 

func (c StatusCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*StatusCommand) Flags added in v0.5.0 

func (c *StatusCommand) Flags() *flag.Sets

func (*StatusCommand) FormatAppStatus added in v0.5.0 

func (c *StatusCommand) FormatAppStatus(projectTarget string, appTarget string) error

func (*StatusCommand) FormatProjectAppStatus added in v0.5.0 

func (c *StatusCommand) FormatProjectAppStatus(projectTarget string) error

FormatProjectAppStatus formats all applications inside a project

func (*StatusCommand) FormatProjectStatus added in v0.5.0 

func (c *StatusCommand) FormatProjectStatus() error

FormatProjectStatus formats all known projects into a table

func (*StatusCommand) FormatStatusReportComplete added in v0.5.0 

func (c *StatusCommand) FormatStatusReportComplete(
	statusReport *pb.StatusReport,
) (string, string, error)

func (*StatusCommand) Help added in v0.5.0 

func (c *StatusCommand) Help() string

func (StatusCommand) Init added in v0.5.0 

func (c StatusCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*StatusCommand) RefreshApplicationStatus added in v0.5.2 

func (c *StatusCommand) RefreshApplicationStatus(projectTarget, appTarget string) error

RefreshApplicationStatus takes a project and application target and generates a list of applications to refresh the status on. If all projects are requested to be refreshed, the CLI will do its best to honor the request. However if a project is local and the CLI was not invoked inside that project dir, the CLI won't be able to refresh that project's application statuses.

func (*StatusCommand) Run added in v0.5.0 

func (c *StatusCommand) Run(args []string) int

func (*StatusCommand) Synopsis added in v0.5.0 

func (c *StatusCommand) Synopsis() string

type UICommand 

type UICommand struct {
	// contains filtered or unexported fields
}

func (*UICommand) AutocompleteArgs 

func (c *UICommand) AutocompleteArgs() complete.Predictor

func (*UICommand) AutocompleteFlags 

func (c *UICommand) AutocompleteFlags() complete.Flags

func (UICommand) Close 

func (c UICommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UICommand) DoApp 

func (c UICommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UICommand) Flags 

func (c *UICommand) Flags() *flag.Sets

func (*UICommand) Help 

func (c *UICommand) Help() string

func (UICommand) Init 

func (c UICommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*UICommand) Run 

func (c *UICommand) Run(args []string) int

func (*UICommand) Synopsis 

func (c *UICommand) Synopsis() string

type UninstallCommand added in v0.2.1 

type UninstallCommand struct {
	// contains filtered or unexported fields
}

func (*UninstallCommand) AutocompleteArgs added in v0.2.1 

func (c *UninstallCommand) AutocompleteArgs() complete.Predictor

func (*UninstallCommand) AutocompleteFlags added in v0.2.1 

func (c *UninstallCommand) AutocompleteFlags() complete.Flags

func (UninstallCommand) Close added in v0.2.1 

func (c UninstallCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UninstallCommand) DoApp added in v0.2.1 

func (c UninstallCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UninstallCommand) Flags added in v0.2.1 

func (c *UninstallCommand) Flags() *flag.Sets

func (*UninstallCommand) Help added in v0.2.1 

func (c *UninstallCommand) Help() string

func (UninstallCommand) Init added in v0.2.1 

func (c UninstallCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*UninstallCommand) Run added in v0.2.1 

func (c *UninstallCommand) Run(args []string) int

func (*UninstallCommand) Synopsis added in v0.2.1 

func (c *UninstallCommand) Synopsis() string

type UpCommand 

type UpCommand struct {
	// contains filtered or unexported fields
}

func (UpCommand) Close 

func (c UpCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UpCommand) DoApp 

func (c UpCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UpCommand) Flags 

func (c *UpCommand) Flags() *flag.Sets

func (*UpCommand) Help 

func (c *UpCommand) Help() string

func (UpCommand) Init 

func (c UpCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*UpCommand) Run 

func (c *UpCommand) Run(args []string) int

func (*UpCommand) Synopsis 

func (c *UpCommand) Synopsis() string

type UserInspectCommand added in v0.5.0 

type UserInspectCommand struct {
	// contains filtered or unexported fields
}

func (*UserInspectCommand) AutocompleteArgs added in v0.5.0 

func (c *UserInspectCommand) AutocompleteArgs() complete.Predictor

func (*UserInspectCommand) AutocompleteFlags added in v0.5.0 

func (c *UserInspectCommand) AutocompleteFlags() complete.Flags

func (UserInspectCommand) Close added in v0.5.0 

func (c UserInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserInspectCommand) DoApp added in v0.5.0 

func (c UserInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserInspectCommand) Flags added in v0.5.0 

func (c *UserInspectCommand) Flags() *flag.Sets

func (*UserInspectCommand) Help added in v0.5.0 

func (c *UserInspectCommand) Help() string

func (UserInspectCommand) Init added in v0.5.0 

func (c UserInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*UserInspectCommand) Run added in v0.5.0 

func (c *UserInspectCommand) Run(args []string) int

func (*UserInspectCommand) Synopsis added in v0.5.0 

func (c *UserInspectCommand) Synopsis() string

type UserInviteCommand added in v0.5.0 

type UserInviteCommand struct {
	// contains filtered or unexported fields
}

func (*UserInviteCommand) AutocompleteArgs added in v0.5.0 

func (c *UserInviteCommand) AutocompleteArgs() complete.Predictor

func (*UserInviteCommand) AutocompleteFlags added in v0.5.0 

func (c *UserInviteCommand) AutocompleteFlags() complete.Flags

func (UserInviteCommand) Close added in v0.5.0 

func (c UserInviteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserInviteCommand) DoApp added in v0.5.0 

func (c UserInviteCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserInviteCommand) Flags added in v0.5.0 

func (c *UserInviteCommand) Flags() *flag.Sets

func (*UserInviteCommand) Help added in v0.5.0 

func (c *UserInviteCommand) Help() string

func (UserInviteCommand) Init added in v0.5.0 

func (c UserInviteCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*UserInviteCommand) Run added in v0.5.0 

func (c *UserInviteCommand) Run(args []string) int

func (*UserInviteCommand) Synopsis added in v0.5.0 

func (c *UserInviteCommand) Synopsis() string

type UserModifyCommand added in v0.5.0 

type UserModifyCommand struct {
	// contains filtered or unexported fields
}

func (*UserModifyCommand) AutocompleteArgs added in v0.5.0 

func (c *UserModifyCommand) AutocompleteArgs() complete.Predictor

func (*UserModifyCommand) AutocompleteFlags added in v0.5.0 

func (c *UserModifyCommand) AutocompleteFlags() complete.Flags

func (UserModifyCommand) Close added in v0.5.0 

func (c UserModifyCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserModifyCommand) DoApp added in v0.5.0 

func (c UserModifyCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserModifyCommand) Flags added in v0.5.0 

func (c *UserModifyCommand) Flags() *flag.Sets

func (*UserModifyCommand) Help added in v0.5.0 

func (c *UserModifyCommand) Help() string

func (UserModifyCommand) Init added in v0.5.0 

func (c UserModifyCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*UserModifyCommand) Run added in v0.5.0 

func (c *UserModifyCommand) Run(args []string) int

func (*UserModifyCommand) Synopsis added in v0.5.0 

func (c *UserModifyCommand) Synopsis() string

type UserTokenCommand added in v0.5.0 

type UserTokenCommand struct {
	// contains filtered or unexported fields
}

func (*UserTokenCommand) AutocompleteArgs added in v0.5.0 

func (c *UserTokenCommand) AutocompleteArgs() complete.Predictor

func (*UserTokenCommand) AutocompleteFlags added in v0.5.0 

func (c *UserTokenCommand) AutocompleteFlags() complete.Flags

func (UserTokenCommand) Close added in v0.5.0 

func (c UserTokenCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserTokenCommand) DoApp added in v0.5.0 

func (c UserTokenCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserTokenCommand) Flags added in v0.5.0 

func (c *UserTokenCommand) Flags() *flag.Sets

func (*UserTokenCommand) Help added in v0.5.0 

func (c *UserTokenCommand) Help() string

func (UserTokenCommand) Init added in v0.5.0 

func (c UserTokenCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*UserTokenCommand) Run added in v0.5.0 

func (c *UserTokenCommand) Run(args []string) int

func (*UserTokenCommand) Synopsis added in v0.5.0 

func (c *UserTokenCommand) Synopsis() string

type VersionCommand 

type VersionCommand struct {
	VersionInfo *version.VersionInfo
	// contains filtered or unexported fields
}

func (*VersionCommand) AutocompleteArgs 

func (c *VersionCommand) AutocompleteArgs() complete.Predictor

func (*VersionCommand) AutocompleteFlags 

func (c *VersionCommand) AutocompleteFlags() complete.Flags

func (VersionCommand) Close 

func (c VersionCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (VersionCommand) DoApp 

func (c VersionCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*VersionCommand) Flags 

func (c *VersionCommand) Flags() *flag.Sets

func (*VersionCommand) Help 

func (c *VersionCommand) Help() string

func (VersionCommand) Init 

func (c VersionCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*VersionCommand) Run 

func (c *VersionCommand) Run(args []string) int

func (*VersionCommand) Synopsis 

func (c *VersionCommand) Synopsis() string

type WorkspaceInspectCommand added in v0.6.0 

type WorkspaceInspectCommand struct {
	// contains filtered or unexported fields
}

func (*WorkspaceInspectCommand) AutocompleteArgs added in v0.6.0 

func (c *WorkspaceInspectCommand) AutocompleteArgs() complete.Predictor

func (*WorkspaceInspectCommand) AutocompleteFlags added in v0.6.0 

func (c *WorkspaceInspectCommand) AutocompleteFlags() complete.Flags

func (WorkspaceInspectCommand) Close added in v0.6.0 

func (c WorkspaceInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (WorkspaceInspectCommand) DoApp added in v0.6.0 

func (c WorkspaceInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*WorkspaceInspectCommand) Flags added in v0.6.0 

func (c *WorkspaceInspectCommand) Flags() *flag.Sets

func (*WorkspaceInspectCommand) Help added in v0.6.0 

func (c *WorkspaceInspectCommand) Help() string

func (WorkspaceInspectCommand) Init added in v0.6.0 

func (c WorkspaceInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*WorkspaceInspectCommand) Run added in v0.6.0 

func (c *WorkspaceInspectCommand) Run(args []string) int

func (*WorkspaceInspectCommand) Synopsis added in v0.6.0 

func (c *WorkspaceInspectCommand) Synopsis() string

type WorkspaceListCommand added in v0.6.0 

type WorkspaceListCommand struct {
	// contains filtered or unexported fields
}

func (*WorkspaceListCommand) AutocompleteArgs added in v0.6.0 

func (c *WorkspaceListCommand) AutocompleteArgs() complete.Predictor

func (*WorkspaceListCommand) AutocompleteFlags added in v0.6.0 

func (c *WorkspaceListCommand) AutocompleteFlags() complete.Flags

func (WorkspaceListCommand) Close added in v0.6.0 

func (c WorkspaceListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (WorkspaceListCommand) DoApp added in v0.6.0 

func (c WorkspaceListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*WorkspaceListCommand) Flags added in v0.6.0 

func (c *WorkspaceListCommand) Flags() *flag.Sets

func (*WorkspaceListCommand) Help added in v0.6.0 

func (c *WorkspaceListCommand) Help() string

func (WorkspaceListCommand) Init added in v0.6.0 

func (c WorkspaceListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

func (*WorkspaceListCommand) Run added in v0.6.0 

func (c *WorkspaceListCommand) Run(args []string) int

func (*WorkspaceListCommand) Synopsis added in v0.6.0 

func (c *WorkspaceListCommand) Synopsis() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.