cli

package
v0.3.1 Latest Latest
Warning

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

 Go to latest Published: Apr 20, 2021 License: MPL-2.0 Imports: 85 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 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 defered 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 defered 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 defered 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 defered 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 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 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 defered 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 defered 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 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 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 defered 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 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 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 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 defered 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) 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 defered 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 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 defered 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 defered 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 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 defered 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 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 defered 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 defered 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 defered 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 defered 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 defered 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 defered 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 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 defered 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 defered 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 defered 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 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 defered 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

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.