cli

package
v0.0.0-...-0a19d84 Latest Latest
Warning

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

 Go to latest Published: Apr 23, 2026 License: MPL-2.0 Imports: 116 Imported by: 0

Documentation

Index

Constants

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

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

Variables

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

Functions

func Commands 

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

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

func GroupedHelpFunc 

func GroupedHelpFunc(f cli.HelpFunc) cli.HelpFunc

func ListDeployments 

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

func ListReleases 

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

func Main 

func Main(args []string) int

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

Types

type AppDocsCommand 

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

func (*AppDocsCommand) AutocompleteArgs 

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

func (*AppDocsCommand) AutocompleteFlags 

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

func (AppDocsCommand) Close 

func (c AppDocsCommand) Close() error

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

func (AppDocsCommand) DoApp 

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

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

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

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

func (*AppDocsCommand) Flags 

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

func (*AppDocsCommand) Help 

func (c *AppDocsCommand) Help() string

func (AppDocsCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*AppDocsCommand) Run 

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

func (*AppDocsCommand) Synopsis 

func (c *AppDocsCommand) Synopsis() string

type ArtifactBuildCommand 

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

func (*ArtifactBuildCommand) AutocompleteArgs 

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

func (*ArtifactBuildCommand) AutocompleteFlags 

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

func (ArtifactBuildCommand) Close 

func (c ArtifactBuildCommand) Close() error

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

func (ArtifactBuildCommand) DoApp 

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

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

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

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

func (*ArtifactBuildCommand) Flags 

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

func (*ArtifactBuildCommand) Help 

func (c *ArtifactBuildCommand) Help() string

func (ArtifactBuildCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ArtifactBuildCommand) Run 

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

func (*ArtifactBuildCommand) Synopsis 

func (c *ArtifactBuildCommand) Synopsis() string

type ArtifactListCommand 

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

func (*ArtifactListCommand) AutocompleteArgs 

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

func (*ArtifactListCommand) AutocompleteFlags 

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

func (ArtifactListCommand) Close 

func (c ArtifactListCommand) Close() error

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

func (ArtifactListCommand) DoApp 

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

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

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

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

func (*ArtifactListCommand) Flags 

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

func (*ArtifactListCommand) Help 

func (c *ArtifactListCommand) Help() string

func (ArtifactListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ArtifactListCommand) Run 

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

func (*ArtifactListCommand) Synopsis 

func (c *ArtifactListCommand) Synopsis() string

type ArtifactPushCommand 

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

func (*ArtifactPushCommand) AutocompleteArgs 

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

func (*ArtifactPushCommand) AutocompleteFlags 

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

func (ArtifactPushCommand) Close 

func (c ArtifactPushCommand) Close() error

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

func (ArtifactPushCommand) DoApp 

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

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

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

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

func (*ArtifactPushCommand) Flags 

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

func (*ArtifactPushCommand) Help 

func (c *ArtifactPushCommand) Help() string

func (ArtifactPushCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ArtifactPushCommand) Run 

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

func (*ArtifactPushCommand) Synopsis 

func (c *ArtifactPushCommand) Synopsis() string

type AuthMethodDeleteCommand 

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

func (*AuthMethodDeleteCommand) AutocompleteArgs 

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

func (*AuthMethodDeleteCommand) AutocompleteFlags 

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

func (AuthMethodDeleteCommand) Close 

func (c AuthMethodDeleteCommand) Close() error

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

func (AuthMethodDeleteCommand) DoApp 

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

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

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

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

func (*AuthMethodDeleteCommand) Flags 

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

func (*AuthMethodDeleteCommand) Help 

func (c *AuthMethodDeleteCommand) Help() string

func (AuthMethodDeleteCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*AuthMethodDeleteCommand) Run 

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

func (*AuthMethodDeleteCommand) Synopsis 

func (c *AuthMethodDeleteCommand) Synopsis() string

type AuthMethodInspectCommand 

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

func (*AuthMethodInspectCommand) AutocompleteArgs 

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

func (*AuthMethodInspectCommand) AutocompleteFlags 

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

func (AuthMethodInspectCommand) Close 

func (c AuthMethodInspectCommand) Close() error

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

func (AuthMethodInspectCommand) DoApp 

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

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

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

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

func (*AuthMethodInspectCommand) Flags 

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

func (*AuthMethodInspectCommand) Help 

func (c *AuthMethodInspectCommand) Help() string

func (AuthMethodInspectCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*AuthMethodInspectCommand) Run 

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

func (*AuthMethodInspectCommand) Synopsis 

func (c *AuthMethodInspectCommand) Synopsis() string

type AuthMethodListCommand 

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

func (*AuthMethodListCommand) AutocompleteArgs 

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

func (*AuthMethodListCommand) AutocompleteFlags 

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

func (AuthMethodListCommand) Close 

func (c AuthMethodListCommand) Close() error

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

func (AuthMethodListCommand) DoApp 

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

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

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

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

func (*AuthMethodListCommand) Flags 

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

func (*AuthMethodListCommand) Help 

func (c *AuthMethodListCommand) Help() string

func (AuthMethodListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*AuthMethodListCommand) Run 

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

func (*AuthMethodListCommand) Synopsis 

func (c *AuthMethodListCommand) Synopsis() string

type AuthMethodSetOIDCCommand 

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

func (*AuthMethodSetOIDCCommand) AutocompleteArgs 

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

func (*AuthMethodSetOIDCCommand) AutocompleteFlags 

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

func (AuthMethodSetOIDCCommand) Close 

func (c AuthMethodSetOIDCCommand) Close() error

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

func (AuthMethodSetOIDCCommand) DoApp 

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

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

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

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

func (*AuthMethodSetOIDCCommand) Flags 

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

func (*AuthMethodSetOIDCCommand) Help 

func (c *AuthMethodSetOIDCCommand) Help() string

func (AuthMethodSetOIDCCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*AuthMethodSetOIDCCommand) Run 

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

func (*AuthMethodSetOIDCCommand) Synopsis 

func (c *AuthMethodSetOIDCCommand) Synopsis() string

type BuildListCommand 

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

func (*BuildListCommand) AutocompleteArgs 

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

func (*BuildListCommand) AutocompleteFlags 

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

func (BuildListCommand) Close 

func (c BuildListCommand) Close() error

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

func (BuildListCommand) DoApp 

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

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

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

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

func (*BuildListCommand) Flags 

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

func (*BuildListCommand) Help 

func (c *BuildListCommand) Help() string

func (BuildListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*BuildListCommand) Run 

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

func (*BuildListCommand) Synopsis 

func (c *BuildListCommand) Synopsis() string

type ConfigDeleteCommand 

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

func (*ConfigDeleteCommand) AutocompleteArgs 

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

func (*ConfigDeleteCommand) AutocompleteFlags 

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

func (ConfigDeleteCommand) Close 

func (c ConfigDeleteCommand) Close() error

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

func (ConfigDeleteCommand) DoApp 

func (c ConfigDeleteCommand) 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 (*ConfigDeleteCommand) Flags 

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

func (*ConfigDeleteCommand) Help 

func (c *ConfigDeleteCommand) Help() string

func (ConfigDeleteCommand) Init 

func (c ConfigDeleteCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ConfigDeleteCommand) Run 

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

func (*ConfigDeleteCommand) Synopsis 

func (c *ConfigDeleteCommand) Synopsis() string

type ConfigGetCommand 

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

func (*ConfigGetCommand) AutocompleteArgs 

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

func (*ConfigGetCommand) AutocompleteFlags 

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

func (ConfigGetCommand) Close 

func (c ConfigGetCommand) Close() error

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

func (ConfigGetCommand) DoApp 

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

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

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

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

func (*ConfigGetCommand) Flags 

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

func (*ConfigGetCommand) Help 

func (c *ConfigGetCommand) Help() string

func (ConfigGetCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ConfigGetCommand) Run 

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

func (*ConfigGetCommand) Synopsis 

func (c *ConfigGetCommand) Synopsis() string

type ConfigSetCommand 

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

func (*ConfigSetCommand) AutocompleteArgs 

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

func (*ConfigSetCommand) AutocompleteFlags 

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

func (ConfigSetCommand) Close 

func (c ConfigSetCommand) Close() error

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

func (ConfigSetCommand) DoApp 

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

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

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

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

func (*ConfigSetCommand) Flags 

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

func (*ConfigSetCommand) Help 

func (c *ConfigSetCommand) Help() string

func (ConfigSetCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ConfigSetCommand) Run 

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

func (*ConfigSetCommand) Synopsis 

func (c *ConfigSetCommand) Synopsis() string

type ConfigSourceDeleteCommand 

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

func (*ConfigSourceDeleteCommand) AutocompleteArgs 

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

func (*ConfigSourceDeleteCommand) AutocompleteFlags 

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

func (ConfigSourceDeleteCommand) Close 

func (c ConfigSourceDeleteCommand) Close() error

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

func (ConfigSourceDeleteCommand) DoApp 

func (c ConfigSourceDeleteCommand) 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 (*ConfigSourceDeleteCommand) Flags 

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

func (*ConfigSourceDeleteCommand) Help 

func (c *ConfigSourceDeleteCommand) Help() string

func (ConfigSourceDeleteCommand) Init 

func (c ConfigSourceDeleteCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ConfigSourceDeleteCommand) Run 

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

func (*ConfigSourceDeleteCommand) Synopsis 

func (c *ConfigSourceDeleteCommand) Synopsis() string

type ConfigSourceGetCommand 

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

func (*ConfigSourceGetCommand) AutocompleteArgs 

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

func (*ConfigSourceGetCommand) AutocompleteFlags 

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

func (ConfigSourceGetCommand) Close 

func (c ConfigSourceGetCommand) Close() error

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

func (ConfigSourceGetCommand) DoApp 

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 

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

func (*ConfigSourceGetCommand) Help 

func (c *ConfigSourceGetCommand) Help() string

func (ConfigSourceGetCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ConfigSourceGetCommand) Run 

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

func (*ConfigSourceGetCommand) Synopsis 

func (c *ConfigSourceGetCommand) Synopsis() string

type ConfigSourceSetCommand 

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

func (*ConfigSourceSetCommand) AutocompleteArgs 

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

func (*ConfigSourceSetCommand) AutocompleteFlags 

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

func (ConfigSourceSetCommand) Close 

func (c ConfigSourceSetCommand) Close() error

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

func (ConfigSourceSetCommand) DoApp 

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 

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

func (*ConfigSourceSetCommand) Help 

func (c *ConfigSourceSetCommand) Help() string

func (ConfigSourceSetCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ConfigSourceSetCommand) Run 

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

func (*ConfigSourceSetCommand) Synopsis 

func (c *ConfigSourceSetCommand) Synopsis() string

type ConfigSyncCommand 

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

func (*ConfigSyncCommand) AutocompleteArgs 

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

func (*ConfigSyncCommand) AutocompleteFlags 

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

func (ConfigSyncCommand) Close 

func (c ConfigSyncCommand) Close() error

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

func (ConfigSyncCommand) DoApp 

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 

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

func (*ConfigSyncCommand) Help 

func (c *ConfigSyncCommand) Help() string

func (ConfigSyncCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ConfigSyncCommand) Run 

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

func (*ConfigSyncCommand) Synopsis 

func (c *ConfigSyncCommand) Synopsis() string

type ContextClearCommand 

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

func (*ContextClearCommand) AutocompleteArgs 

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

func (*ContextClearCommand) AutocompleteFlags 

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

func (ContextClearCommand) Close 

func (c ContextClearCommand) Close() error

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

func (ContextClearCommand) DoApp 

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

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

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

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

func (*ContextClearCommand) Flags 

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

func (*ContextClearCommand) Help 

func (c *ContextClearCommand) Help() string

func (ContextClearCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextClearCommand) Run 

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

func (*ContextClearCommand) Synopsis 

func (c *ContextClearCommand) Synopsis() string

type ContextCreateCommand 

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

func (*ContextCreateCommand) AutocompleteArgs 

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

func (*ContextCreateCommand) AutocompleteFlags 

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

func (ContextCreateCommand) Close 

func (c ContextCreateCommand) Close() error

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

func (ContextCreateCommand) DoApp 

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

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

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

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

func (*ContextCreateCommand) Flags 

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

func (*ContextCreateCommand) Help 

func (c *ContextCreateCommand) Help() string

func (ContextCreateCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextCreateCommand) Run 

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

func (*ContextCreateCommand) Synopsis 

func (c *ContextCreateCommand) Synopsis() string

type ContextDeleteCommand 

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

func (*ContextDeleteCommand) AutocompleteArgs 

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

func (*ContextDeleteCommand) AutocompleteFlags 

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

func (ContextDeleteCommand) Close 

func (c ContextDeleteCommand) Close() error

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

func (ContextDeleteCommand) DoApp 

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

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

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

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

func (*ContextDeleteCommand) Flags 

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

func (*ContextDeleteCommand) Help 

func (c *ContextDeleteCommand) Help() string

func (ContextDeleteCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextDeleteCommand) Run 

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

func (*ContextDeleteCommand) Synopsis 

func (c *ContextDeleteCommand) Synopsis() string

type ContextHelpCommand 

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

func (*ContextHelpCommand) AutocompleteArgs 

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

func (*ContextHelpCommand) AutocompleteFlags 

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

func (ContextHelpCommand) Close 

func (c ContextHelpCommand) Close() error

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

func (ContextHelpCommand) DoApp 

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

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

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

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

func (*ContextHelpCommand) Flags 

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

func (*ContextHelpCommand) Help 

func (c *ContextHelpCommand) Help() string

func (ContextHelpCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextHelpCommand) Run 

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

func (*ContextHelpCommand) Synopsis 

func (c *ContextHelpCommand) Synopsis() string

type ContextInspectCommand 

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

func (*ContextInspectCommand) AutocompleteArgs 

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

func (*ContextInspectCommand) AutocompleteFlags 

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

func (ContextInspectCommand) Close 

func (c ContextInspectCommand) Close() error

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

func (ContextInspectCommand) DoApp 

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

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

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

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

func (*ContextInspectCommand) Flags 

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

func (*ContextInspectCommand) Help 

func (c *ContextInspectCommand) Help() string

func (ContextInspectCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextInspectCommand) Run 

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

func (*ContextInspectCommand) Synopsis 

func (c *ContextInspectCommand) Synopsis() string

type ContextListCommand 

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

func (*ContextListCommand) AutocompleteArgs 

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

func (*ContextListCommand) AutocompleteFlags 

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

func (ContextListCommand) Close 

func (c ContextListCommand) Close() error

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

func (ContextListCommand) DoApp 

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

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

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

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

func (*ContextListCommand) Flags 

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

func (*ContextListCommand) Help 

func (c *ContextListCommand) Help() string

func (ContextListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextListCommand) Run 

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

func (*ContextListCommand) Synopsis 

func (c *ContextListCommand) Synopsis() string

type ContextRenameCommand 

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

func (*ContextRenameCommand) AutocompleteArgs 

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

func (*ContextRenameCommand) AutocompleteFlags 

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

func (ContextRenameCommand) Close 

func (c ContextRenameCommand) Close() error

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

func (ContextRenameCommand) DoApp 

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

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

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

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

func (*ContextRenameCommand) Flags 

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

func (*ContextRenameCommand) Help 

func (c *ContextRenameCommand) Help() string

func (ContextRenameCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextRenameCommand) Run 

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

func (*ContextRenameCommand) Synopsis 

func (c *ContextRenameCommand) Synopsis() string

type ContextSetCommand 

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

func (*ContextSetCommand) AutocompleteArgs 

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

func (*ContextSetCommand) AutocompleteFlags 

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

func (ContextSetCommand) Close 

func (c ContextSetCommand) Close() error

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

func (ContextSetCommand) DoApp 

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

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

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

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

func (*ContextSetCommand) Flags 

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

func (*ContextSetCommand) Help 

func (c *ContextSetCommand) Help() string

func (ContextSetCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextSetCommand) Run 

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

func (*ContextSetCommand) Synopsis 

func (c *ContextSetCommand) Synopsis() string

type ContextUseCommand 

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

func (*ContextUseCommand) AutocompleteArgs 

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

func (*ContextUseCommand) AutocompleteFlags 

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

func (ContextUseCommand) Close 

func (c ContextUseCommand) Close() error

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

func (ContextUseCommand) DoApp 

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

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

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

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

func (*ContextUseCommand) Flags 

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

func (*ContextUseCommand) Help 

func (c *ContextUseCommand) Help() string

func (ContextUseCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextUseCommand) Run 

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

func (*ContextUseCommand) Synopsis 

func (c *ContextUseCommand) Synopsis() string

type ContextVerifyCommand 

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

func (*ContextVerifyCommand) AutocompleteArgs 

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

func (*ContextVerifyCommand) AutocompleteFlags 

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

func (ContextVerifyCommand) Close 

func (c ContextVerifyCommand) Close() error

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

func (ContextVerifyCommand) DoApp 

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

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

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

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

func (*ContextVerifyCommand) Flags 

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

func (*ContextVerifyCommand) Help 

func (c *ContextVerifyCommand) Help() string

func (ContextVerifyCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ContextVerifyCommand) Run 

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

func (*ContextVerifyCommand) Synopsis 

func (c *ContextVerifyCommand) Synopsis() string

type DeploymentCreateCommand 

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

func (*DeploymentCreateCommand) AutocompleteArgs 

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

func (*DeploymentCreateCommand) AutocompleteFlags 

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

func (DeploymentCreateCommand) Close 

func (c DeploymentCreateCommand) Close() error

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

func (DeploymentCreateCommand) DoApp 

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

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

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

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

func (*DeploymentCreateCommand) Flags 

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

func (*DeploymentCreateCommand) Help 

func (c *DeploymentCreateCommand) Help() string

func (DeploymentCreateCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*DeploymentCreateCommand) Run 

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

func (*DeploymentCreateCommand) Synopsis 

func (c *DeploymentCreateCommand) Synopsis() string

type DeploymentDestroyCommand 

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

func (*DeploymentDestroyCommand) AutocompleteArgs 

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

func (*DeploymentDestroyCommand) AutocompleteFlags 

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

func (DeploymentDestroyCommand) Close 

func (c DeploymentDestroyCommand) Close() error

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

func (DeploymentDestroyCommand) DoApp 

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

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

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

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

func (*DeploymentDestroyCommand) Flags 

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

func (*DeploymentDestroyCommand) Help 

func (c *DeploymentDestroyCommand) Help() string

func (DeploymentDestroyCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*DeploymentDestroyCommand) Run 

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

func (*DeploymentDestroyCommand) Synopsis 

func (c *DeploymentDestroyCommand) Synopsis() string

type DeploymentListCommand 

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

func (*DeploymentListCommand) AutocompleteArgs 

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

func (*DeploymentListCommand) AutocompleteFlags 

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

func (DeploymentListCommand) Close 

func (c DeploymentListCommand) Close() error

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

func (DeploymentListCommand) DoApp 

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

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

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

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

func (*DeploymentListCommand) Flags 

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

func (*DeploymentListCommand) Help 

func (c *DeploymentListCommand) Help() string

func (DeploymentListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*DeploymentListCommand) Run 

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

func (*DeploymentListCommand) Synopsis 

func (c *DeploymentListCommand) Synopsis() string

type DestroyCommand 

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

func (DestroyCommand) Close 

func (c DestroyCommand) Close() error

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

func (DestroyCommand) DoApp 

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

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

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

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

func (*DestroyCommand) Flags 

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

func (*DestroyCommand) Help 

func (c *DestroyCommand) Help() string

func (DestroyCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*DestroyCommand) Run 

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

func (*DestroyCommand) Synopsis 

func (c *DestroyCommand) Synopsis() string

type DocsCommand 

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

func (DocsCommand) Close 

func (c DocsCommand) Close() error

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

func (DocsCommand) DoApp 

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

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

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

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

func (*DocsCommand) Help 

func (c *DocsCommand) Help() string

func (DocsCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*DocsCommand) Run 

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

func (*DocsCommand) Synopsis 

func (c *DocsCommand) Synopsis() string

type ExchangeInviteCommand 

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

func (*ExchangeInviteCommand) AutocompleteArgs 

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

func (*ExchangeInviteCommand) AutocompleteFlags 

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

func (ExchangeInviteCommand) Close 

func (c ExchangeInviteCommand) Close() error

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

func (ExchangeInviteCommand) DoApp 

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

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

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

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

func (*ExchangeInviteCommand) Flags 

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

func (*ExchangeInviteCommand) Help 

func (c *ExchangeInviteCommand) Help() string

func (ExchangeInviteCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ExchangeInviteCommand) Run 

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

func (*ExchangeInviteCommand) Synopsis 

func (c *ExchangeInviteCommand) Synopsis() string

type ExecCommand 

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

func (*ExecCommand) AutocompleteArgs 

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

func (*ExecCommand) AutocompleteFlags 

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

func (ExecCommand) Close 

func (c ExecCommand) Close() error

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

func (ExecCommand) DoApp 

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

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

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

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

func (*ExecCommand) Flags 

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

func (*ExecCommand) Help 

func (c *ExecCommand) Help() string

func (ExecCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ExecCommand) Run 

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

func (*ExecCommand) Synopsis 

func (c *ExecCommand) Synopsis() string

type FmtCommand 

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

func (*FmtCommand) AutocompleteArgs 

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

func (*FmtCommand) AutocompleteFlags 

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

func (FmtCommand) Close 

func (c FmtCommand) Close() error

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

func (FmtCommand) DoApp 

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 

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

func (*FmtCommand) Help 

func (c *FmtCommand) Help() string

func (FmtCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*FmtCommand) Run 

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

func (*FmtCommand) Synopsis 

func (c *FmtCommand) Synopsis() string

type GetInviteCommand 

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

func (*GetInviteCommand) AutocompleteArgs 

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

func (*GetInviteCommand) AutocompleteFlags 

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

func (GetInviteCommand) Close 

func (c GetInviteCommand) Close() error

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

func (GetInviteCommand) DoApp 

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

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

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

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

func (*GetInviteCommand) Flags 

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

func (*GetInviteCommand) Help 

func (c *GetInviteCommand) Help() string

func (GetInviteCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*GetInviteCommand) Run 

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

func (*GetInviteCommand) Synopsis 

func (c *GetInviteCommand) Synopsis() string

type GetTokenCommand 

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

func (*GetTokenCommand) AutocompleteArgs 

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

func (*GetTokenCommand) AutocompleteFlags 

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

func (GetTokenCommand) Close 

func (c GetTokenCommand) Close() error

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

func (GetTokenCommand) DoApp 

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

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

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

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

func (*GetTokenCommand) Flags 

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

func (*GetTokenCommand) Help 

func (c *GetTokenCommand) Help() string

func (GetTokenCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*GetTokenCommand) Run 

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

func (*GetTokenCommand) Synopsis 

func (c *GetTokenCommand) Synopsis() string

type HasFlags 

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

type HostnameDeleteCommand 

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

func (*HostnameDeleteCommand) AutocompleteArgs 

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

func (*HostnameDeleteCommand) AutocompleteFlags 

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

func (HostnameDeleteCommand) Close 

func (c HostnameDeleteCommand) Close() error

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

func (HostnameDeleteCommand) DoApp 

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

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

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

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

func (*HostnameDeleteCommand) Flags 

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

func (*HostnameDeleteCommand) Help 

func (c *HostnameDeleteCommand) Help() string

func (HostnameDeleteCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*HostnameDeleteCommand) Run 

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

func (*HostnameDeleteCommand) Synopsis 

func (c *HostnameDeleteCommand) Synopsis() string

type HostnameListCommand 

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

func (*HostnameListCommand) AutocompleteArgs 

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

func (*HostnameListCommand) AutocompleteFlags 

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

func (HostnameListCommand) Close 

func (c HostnameListCommand) Close() error

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

func (HostnameListCommand) DoApp 

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

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

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

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

func (*HostnameListCommand) Flags 

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

func (*HostnameListCommand) Help 

func (c *HostnameListCommand) Help() string

func (HostnameListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*HostnameListCommand) Run 

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

func (*HostnameListCommand) Synopsis 

func (c *HostnameListCommand) Synopsis() string

type HostnameRegisterCommand 

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

func (*HostnameRegisterCommand) AutocompleteArgs 

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

func (*HostnameRegisterCommand) AutocompleteFlags 

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

func (HostnameRegisterCommand) Close 

func (c HostnameRegisterCommand) Close() error

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

func (HostnameRegisterCommand) DoApp 

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

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

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

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

func (*HostnameRegisterCommand) Flags 

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

func (*HostnameRegisterCommand) Help 

func (c *HostnameRegisterCommand) Help() string

func (HostnameRegisterCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*HostnameRegisterCommand) Run 

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

func (*HostnameRegisterCommand) Synopsis 

func (c *HostnameRegisterCommand) Synopsis() string

type InitCommand 

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

func (*InitCommand) AutocompleteArgs 

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

func (*InitCommand) AutocompleteFlags 

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

func (InitCommand) Close 

func (c InitCommand) Close() error

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

func (InitCommand) DoApp 

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

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

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

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

func (*InitCommand) Flags 

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

func (*InitCommand) Help 

func (c *InitCommand) Help() string

func (InitCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*InitCommand) Run 

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

func (*InitCommand) Synopsis 

func (c *InitCommand) Synopsis() string

type InstallCommand 

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

func (*InstallCommand) AutocompleteArgs 

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

func (*InstallCommand) AutocompleteFlags 

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

func (InstallCommand) Close 

func (c InstallCommand) Close() error

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

func (InstallCommand) DoApp 

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

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

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

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

func (*InstallCommand) Flags 

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

func (*InstallCommand) Help 

func (c *InstallCommand) Help() string

func (InstallCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*InstallCommand) Run 

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

func (*InstallCommand) Synopsis 

func (c *InstallCommand) Synopsis() string

type JobCancelCommand 

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

func (JobCancelCommand) Close 

func (c JobCancelCommand) Close() error

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

func (JobCancelCommand) DoApp 

func (c JobCancelCommand) 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 (*JobCancelCommand) Flags 

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

func (*JobCancelCommand) Help 

func (c *JobCancelCommand) Help() string

func (JobCancelCommand) Init 

func (c JobCancelCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*JobCancelCommand) Run 

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

func (*JobCancelCommand) Synopsis 

func (c *JobCancelCommand) Synopsis() string

type JobGetStreamCommand 

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

func (JobGetStreamCommand) Close 

func (c JobGetStreamCommand) Close() error

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

func (JobGetStreamCommand) DoApp 

func (c JobGetStreamCommand) 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 (*JobGetStreamCommand) Flags 

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

func (*JobGetStreamCommand) Help 

func (c *JobGetStreamCommand) Help() string

func (JobGetStreamCommand) Init 

func (c JobGetStreamCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*JobGetStreamCommand) Run 

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

func (*JobGetStreamCommand) Synopsis 

func (c *JobGetStreamCommand) Synopsis() string

type JobInspectCommand 

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

func (JobInspectCommand) Close 

func (c JobInspectCommand) Close() error

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

func (JobInspectCommand) DoApp 

func (c JobInspectCommand) 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 (*JobInspectCommand) Flags 

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

func (*JobInspectCommand) Help 

func (c *JobInspectCommand) Help() string

func (JobInspectCommand) Init 

func (c JobInspectCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*JobInspectCommand) Run 

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

func (*JobInspectCommand) Synopsis 

func (c *JobInspectCommand) Synopsis() string

type JobListCommand 

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

func (JobListCommand) Close 

func (c JobListCommand) Close() error

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

func (JobListCommand) DoApp 

func (c JobListCommand) 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 (*JobListCommand) Flags 

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

func (*JobListCommand) Help 

func (c *JobListCommand) Help() string

func (JobListCommand) Init 

func (c JobListCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*JobListCommand) Run 

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

func (*JobListCommand) Synopsis 

func (c *JobListCommand) Synopsis() string

type K8SBootstrapCommand 

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

func (*K8SBootstrapCommand) AutocompleteArgs 

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

func (*K8SBootstrapCommand) AutocompleteFlags 

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

func (K8SBootstrapCommand) Close 

func (c K8SBootstrapCommand) Close() error

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

func (K8SBootstrapCommand) DoApp 

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

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

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

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

func (*K8SBootstrapCommand) Flags 

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

func (*K8SBootstrapCommand) Help 

func (c *K8SBootstrapCommand) Help() string

func (K8SBootstrapCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*K8SBootstrapCommand) Run 

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

func (*K8SBootstrapCommand) Synopsis 

func (c *K8SBootstrapCommand) Synopsis() string

type LoginCommand 

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

func (*LoginCommand) AutocompleteArgs 

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

func (*LoginCommand) AutocompleteFlags 

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

func (LoginCommand) Close 

func (c LoginCommand) Close() error

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

func (LoginCommand) DoApp 

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

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

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

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

func (*LoginCommand) Flags 

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

func (*LoginCommand) Help 

func (c *LoginCommand) Help() string

func (LoginCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*LoginCommand) Run 

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

func (*LoginCommand) Synopsis 

func (c *LoginCommand) Synopsis() string

type LogsCommand 

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

func (*LogsCommand) AutocompleteArgs 

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

func (*LogsCommand) AutocompleteFlags 

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

func (LogsCommand) Close 

func (c LogsCommand) Close() error

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

func (LogsCommand) DoApp 

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

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

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

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

func (*LogsCommand) Flags 

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

func (*LogsCommand) Help 

func (c *LogsCommand) Help() string

func (LogsCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

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 WithConnectionArg 

func WithConnectionArg() Option

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

func WithFlags 

func WithFlags(f *flag.Sets) Option

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

func WithMultiAppTargets 

func WithMultiAppTargets() Option

WithMultiAppTargets configures the CLI to allow this command to run against every app specified by the user - either each application in the project, or the single app specified with the -app flag.

func WithNoClient 

func WithNoClient() Option

WithNoClient configures the CLI to not use a client

func WithNoConfig 

func WithNoConfig() Option

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

func WithNoLocalServer 

func WithNoLocalServer() Option

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

func WithProjectTarget 

func WithProjectTarget() Option

WithProjectTarget configures the CLI to expect a configuration with a project specified, either through a waypoint.hcl file or the -project flag

func WithSingleAppTarget 

func WithSingleAppTarget() Option

WithSingleAppTarget 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 PipelineInspectCommand 

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

func (*PipelineInspectCommand) AutocompleteArgs 

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

func (*PipelineInspectCommand) AutocompleteFlags 

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

func (PipelineInspectCommand) Close 

func (c PipelineInspectCommand) Close() error

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

func (PipelineInspectCommand) DoApp 

func (c PipelineInspectCommand) 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 (*PipelineInspectCommand) Flags 

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

func (*PipelineInspectCommand) Help 

func (c *PipelineInspectCommand) Help() string

func (PipelineInspectCommand) Init 

func (c PipelineInspectCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*PipelineInspectCommand) Run 

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

func (*PipelineInspectCommand) Synopsis 

func (c *PipelineInspectCommand) Synopsis() string

type PipelineListCommand 

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

func (*PipelineListCommand) AutocompleteArgs 

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

func (*PipelineListCommand) AutocompleteFlags 

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

func (PipelineListCommand) Close 

func (c PipelineListCommand) Close() error

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

func (PipelineListCommand) DoApp 

func (c PipelineListCommand) 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 (*PipelineListCommand) Flags 

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

func (*PipelineListCommand) Help 

func (c *PipelineListCommand) Help() string

func (PipelineListCommand) Init 

func (c PipelineListCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*PipelineListCommand) Run 

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

func (*PipelineListCommand) Synopsis 

func (c *PipelineListCommand) Synopsis() string

type PipelineRunCommand 

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

func (*PipelineRunCommand) AutocompleteArgs 

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

func (*PipelineRunCommand) AutocompleteFlags 

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

func (PipelineRunCommand) Close 

func (c PipelineRunCommand) Close() error

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

func (PipelineRunCommand) DoApp 

func (c PipelineRunCommand) 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 (*PipelineRunCommand) Flags 

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

func (*PipelineRunCommand) Help 

func (c *PipelineRunCommand) Help() string

func (PipelineRunCommand) Init 

func (c PipelineRunCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*PipelineRunCommand) Run 

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

func (*PipelineRunCommand) Synopsis 

func (c *PipelineRunCommand) Synopsis() string

type PluginCommand 

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

func (PluginCommand) Close 

func (c PluginCommand) Close() error

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

func (PluginCommand) DoApp 

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

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

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

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

func (*PluginCommand) Flags 

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

func (*PluginCommand) Help 

func (c *PluginCommand) Help() string

func (PluginCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*PluginCommand) Run 

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

func (*PluginCommand) Synopsis 

func (c *PluginCommand) Synopsis() string

type ProjectApplyCommand 

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

func (*ProjectApplyCommand) AutocompleteArgs 

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

func (*ProjectApplyCommand) AutocompleteFlags 

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

func (ProjectApplyCommand) Close 

func (c ProjectApplyCommand) Close() error

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

func (ProjectApplyCommand) DoApp 

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 

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

func (*ProjectApplyCommand) Help 

func (c *ProjectApplyCommand) Help() string

func (ProjectApplyCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectApplyCommand) Run 

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

func (*ProjectApplyCommand) Synopsis 

func (c *ProjectApplyCommand) Synopsis() string

type ProjectDestroyCommand 

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

func (ProjectDestroyCommand) Close 

func (c ProjectDestroyCommand) Close() error

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

func (ProjectDestroyCommand) DoApp 

func (c ProjectDestroyCommand) 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 (*ProjectDestroyCommand) Flags 

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

func (*ProjectDestroyCommand) Help 

func (c *ProjectDestroyCommand) Help() string

func (ProjectDestroyCommand) Init 

func (c ProjectDestroyCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectDestroyCommand) Run 

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

func (*ProjectDestroyCommand) Synopsis 

func (c *ProjectDestroyCommand) Synopsis() string

type ProjectInspectCommand 

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

func (*ProjectInspectCommand) AutocompleteArgs 

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

func (*ProjectInspectCommand) AutocompleteFlags 

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

func (ProjectInspectCommand) Close 

func (c ProjectInspectCommand) Close() error

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

func (ProjectInspectCommand) DoApp 

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

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

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

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

func (*ProjectInspectCommand) Flags 

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

func (*ProjectInspectCommand) FormatProject 

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

func (*ProjectInspectCommand) Help 

func (c *ProjectInspectCommand) Help() string

func (ProjectInspectCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectInspectCommand) Run 

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

func (*ProjectInspectCommand) Synopsis 

func (c *ProjectInspectCommand) Synopsis() string

type ProjectListCommand 

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

func (*ProjectListCommand) AutocompleteArgs 

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

func (*ProjectListCommand) AutocompleteFlags 

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

func (ProjectListCommand) Close 

func (c ProjectListCommand) Close() error

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

func (ProjectListCommand) DoApp 

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 

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

func (*ProjectListCommand) Help 

func (c *ProjectListCommand) Help() string

func (ProjectListCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectListCommand) Run 

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

func (*ProjectListCommand) Synopsis 

func (c *ProjectListCommand) Synopsis() string

type ProjectTemplateCreateCommand 

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

func (*ProjectTemplateCreateCommand) AutocompleteArgs 

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

func (*ProjectTemplateCreateCommand) AutocompleteFlags 

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

func (ProjectTemplateCreateCommand) Close 

func (c ProjectTemplateCreateCommand) Close() error

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

func (ProjectTemplateCreateCommand) DoApp 

func (c ProjectTemplateCreateCommand) 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 (*ProjectTemplateCreateCommand) Flags 

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

func (*ProjectTemplateCreateCommand) Help 

func (c *ProjectTemplateCreateCommand) Help() string

func (ProjectTemplateCreateCommand) Init 

func (c ProjectTemplateCreateCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectTemplateCreateCommand) Run 

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

func (*ProjectTemplateCreateCommand) Synopsis 

func (c *ProjectTemplateCreateCommand) Synopsis() string

type ProjectTemplateDeleteCommand 

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

func (*ProjectTemplateDeleteCommand) AutocompleteArgs 

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

func (*ProjectTemplateDeleteCommand) AutocompleteFlags 

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

func (ProjectTemplateDeleteCommand) Close 

func (c ProjectTemplateDeleteCommand) Close() error

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

func (ProjectTemplateDeleteCommand) DoApp 

func (c ProjectTemplateDeleteCommand) 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 (*ProjectTemplateDeleteCommand) Flags 

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

func (*ProjectTemplateDeleteCommand) Help 

func (c *ProjectTemplateDeleteCommand) Help() string

func (ProjectTemplateDeleteCommand) Init 

func (c ProjectTemplateDeleteCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectTemplateDeleteCommand) Run 

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

func (*ProjectTemplateDeleteCommand) Synopsis 

func (c *ProjectTemplateDeleteCommand) Synopsis() string

type ProjectTemplateInspectCommand 

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

func (*ProjectTemplateInspectCommand) AutocompleteArgs 

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

func (*ProjectTemplateInspectCommand) AutocompleteFlags 

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

func (ProjectTemplateInspectCommand) Close 

func (c ProjectTemplateInspectCommand) Close() error

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

func (ProjectTemplateInspectCommand) DoApp 

func (c ProjectTemplateInspectCommand) 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 (*ProjectTemplateInspectCommand) Flags 

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

func (*ProjectTemplateInspectCommand) Help 

func (c *ProjectTemplateInspectCommand) Help() string

func (ProjectTemplateInspectCommand) Init 

func (c ProjectTemplateInspectCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectTemplateInspectCommand) Run 

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

func (*ProjectTemplateInspectCommand) Synopsis 

func (c *ProjectTemplateInspectCommand) Synopsis() string

type ProjectTemplateListCommand 

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

func (*ProjectTemplateListCommand) AutocompleteArgs 

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

func (*ProjectTemplateListCommand) AutocompleteFlags 

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

func (ProjectTemplateListCommand) Close 

func (c ProjectTemplateListCommand) Close() error

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

func (ProjectTemplateListCommand) DoApp 

func (c ProjectTemplateListCommand) 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 (*ProjectTemplateListCommand) Flags 

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

func (*ProjectTemplateListCommand) Help 

func (c *ProjectTemplateListCommand) Help() string

func (ProjectTemplateListCommand) Init 

func (c ProjectTemplateListCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectTemplateListCommand) Run 

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

func (*ProjectTemplateListCommand) Synopsis 

func (c *ProjectTemplateListCommand) Synopsis() string

type ProjectTemplateUpdateCommand 

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

func (*ProjectTemplateUpdateCommand) AutocompleteArgs 

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

func (*ProjectTemplateUpdateCommand) AutocompleteFlags 

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

func (ProjectTemplateUpdateCommand) Close 

func (c ProjectTemplateUpdateCommand) Close() error

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

func (ProjectTemplateUpdateCommand) DoApp 

func (c ProjectTemplateUpdateCommand) 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 (*ProjectTemplateUpdateCommand) Flags 

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

func (*ProjectTemplateUpdateCommand) Help 

func (c *ProjectTemplateUpdateCommand) Help() string

func (ProjectTemplateUpdateCommand) Init 

func (c ProjectTemplateUpdateCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ProjectTemplateUpdateCommand) Run 

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

func (*ProjectTemplateUpdateCommand) Synopsis 

func (c *ProjectTemplateUpdateCommand) Synopsis() string

type ReleaseCreateCommand 

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

func (*ReleaseCreateCommand) AutocompleteArgs 

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

func (*ReleaseCreateCommand) AutocompleteFlags 

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

func (ReleaseCreateCommand) Close 

func (c ReleaseCreateCommand) Close() error

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

func (ReleaseCreateCommand) DoApp 

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

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

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

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

func (*ReleaseCreateCommand) Flags 

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

func (*ReleaseCreateCommand) Help 

func (c *ReleaseCreateCommand) Help() string

func (ReleaseCreateCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ReleaseCreateCommand) Run 

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

func (*ReleaseCreateCommand) Synopsis 

func (c *ReleaseCreateCommand) Synopsis() string

type ReleaseListCommand 

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

func (*ReleaseListCommand) AutocompleteArgs 

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

func (*ReleaseListCommand) AutocompleteFlags 

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

func (ReleaseListCommand) Close 

func (c ReleaseListCommand) Close() error

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

func (ReleaseListCommand) DoApp 

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

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

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

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

func (*ReleaseListCommand) Flags 

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

func (*ReleaseListCommand) Help 

func (c *ReleaseListCommand) Help() string

func (ReleaseListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ReleaseListCommand) Run 

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

func (*ReleaseListCommand) Synopsis 

func (c *ReleaseListCommand) Synopsis() string

type RunnerAdoptCommand 

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

func (*RunnerAdoptCommand) AutocompleteArgs 

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

func (*RunnerAdoptCommand) AutocompleteFlags 

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

func (RunnerAdoptCommand) Close 

func (c RunnerAdoptCommand) Close() error

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

func (RunnerAdoptCommand) DoApp 

func (c RunnerAdoptCommand) 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 (*RunnerAdoptCommand) Flags 

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

func (*RunnerAdoptCommand) Help 

func (c *RunnerAdoptCommand) Help() string

func (RunnerAdoptCommand) Init 

func (c RunnerAdoptCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerAdoptCommand) Run 

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

func (*RunnerAdoptCommand) Synopsis 

func (c *RunnerAdoptCommand) Synopsis() string

type RunnerAgentCommand 

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

func (*RunnerAgentCommand) AutocompleteArgs 

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

func (*RunnerAgentCommand) AutocompleteFlags 

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

func (RunnerAgentCommand) Close 

func (c RunnerAgentCommand) Close() error

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

func (RunnerAgentCommand) DoApp 

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

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

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

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

func (*RunnerAgentCommand) Flags 

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

func (*RunnerAgentCommand) Help 

func (c *RunnerAgentCommand) Help() string

func (RunnerAgentCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerAgentCommand) Run 

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

func (*RunnerAgentCommand) Synopsis 

func (c *RunnerAgentCommand) Synopsis() string

type RunnerForgetCommand 

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

func (*RunnerForgetCommand) AutocompleteArgs 

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

func (*RunnerForgetCommand) AutocompleteFlags 

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

func (RunnerForgetCommand) Close 

func (c RunnerForgetCommand) Close() error

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

func (RunnerForgetCommand) DoApp 

func (c RunnerForgetCommand) 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 (*RunnerForgetCommand) Flags 

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

func (*RunnerForgetCommand) Help 

func (c *RunnerForgetCommand) Help() string

func (RunnerForgetCommand) Init 

func (c RunnerForgetCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerForgetCommand) Run 

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

func (*RunnerForgetCommand) Synopsis 

func (c *RunnerForgetCommand) Synopsis() string

type RunnerInspectCommand 

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

func (*RunnerInspectCommand) AutocompleteArgs 

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

func (*RunnerInspectCommand) AutocompleteFlags 

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

func (RunnerInspectCommand) Close 

func (c RunnerInspectCommand) Close() error

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

func (RunnerInspectCommand) DoApp 

func (c RunnerInspectCommand) 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 (*RunnerInspectCommand) Flags 

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

func (*RunnerInspectCommand) Help 

func (c *RunnerInspectCommand) Help() string

func (RunnerInspectCommand) Init 

func (c RunnerInspectCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerInspectCommand) Run 

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

func (*RunnerInspectCommand) Synopsis 

func (c *RunnerInspectCommand) Synopsis() string

type RunnerInstallCommand 

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

func (*RunnerInstallCommand) AutocompleteArgs 

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

func (*RunnerInstallCommand) AutocompleteFlags 

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

func (RunnerInstallCommand) Close 

func (c RunnerInstallCommand) Close() error

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

func (RunnerInstallCommand) DoApp 

func (c RunnerInstallCommand) 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 (*RunnerInstallCommand) Flags 

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

func (*RunnerInstallCommand) Help 

func (c *RunnerInstallCommand) Help() string

func (RunnerInstallCommand) Init 

func (c RunnerInstallCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerInstallCommand) Run 

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

func (*RunnerInstallCommand) Synopsis 

func (c *RunnerInstallCommand) Synopsis() string

type RunnerListCommand 

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

func (*RunnerListCommand) AutocompleteArgs 

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

func (*RunnerListCommand) AutocompleteFlags 

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

func (RunnerListCommand) Close 

func (c RunnerListCommand) Close() error

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

func (RunnerListCommand) DoApp 

func (c RunnerListCommand) 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 (*RunnerListCommand) Flags 

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

func (*RunnerListCommand) Help 

func (c *RunnerListCommand) Help() string

func (RunnerListCommand) Init 

func (c RunnerListCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerListCommand) Run 

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

func (*RunnerListCommand) Synopsis 

func (c *RunnerListCommand) Synopsis() string

type RunnerProfileDeleteCommand 

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

func (*RunnerProfileDeleteCommand) AutocompleteArgs 

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

func (*RunnerProfileDeleteCommand) AutocompleteFlags 

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

func (RunnerProfileDeleteCommand) Close 

func (c RunnerProfileDeleteCommand) Close() error

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

func (RunnerProfileDeleteCommand) DoApp 

func (c RunnerProfileDeleteCommand) 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 (*RunnerProfileDeleteCommand) Flags 

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

func (*RunnerProfileDeleteCommand) Help 

func (c *RunnerProfileDeleteCommand) Help() string

func (RunnerProfileDeleteCommand) Init 

func (c RunnerProfileDeleteCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerProfileDeleteCommand) Run 

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

func (*RunnerProfileDeleteCommand) Synopsis 

func (c *RunnerProfileDeleteCommand) Synopsis() string

type RunnerProfileEditCommand 

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

func (*RunnerProfileEditCommand) AutocompleteArgs 

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

func (*RunnerProfileEditCommand) AutocompleteFlags 

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

func (RunnerProfileEditCommand) Close 

func (c RunnerProfileEditCommand) Close() error

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

func (RunnerProfileEditCommand) DoApp 

func (c RunnerProfileEditCommand) 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 (*RunnerProfileEditCommand) Flags 

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

func (*RunnerProfileEditCommand) Help 

func (c *RunnerProfileEditCommand) Help() string

func (RunnerProfileEditCommand) Init 

func (c RunnerProfileEditCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerProfileEditCommand) Run 

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

func (*RunnerProfileEditCommand) Synopsis 

func (c *RunnerProfileEditCommand) Synopsis() string

type RunnerProfileInspectCommand 

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

func (*RunnerProfileInspectCommand) AutocompleteArgs 

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

func (*RunnerProfileInspectCommand) AutocompleteFlags 

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

func (RunnerProfileInspectCommand) Close 

func (c RunnerProfileInspectCommand) Close() error

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

func (RunnerProfileInspectCommand) DoApp 

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

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

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

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

func (*RunnerProfileInspectCommand) Flags 

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

func (*RunnerProfileInspectCommand) Help 

func (c *RunnerProfileInspectCommand) Help() string

func (RunnerProfileInspectCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerProfileInspectCommand) Run 

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

func (*RunnerProfileInspectCommand) Synopsis 

func (c *RunnerProfileInspectCommand) Synopsis() string

type RunnerProfileListCommand 

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

func (*RunnerProfileListCommand) AutocompleteArgs 

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

func (*RunnerProfileListCommand) AutocompleteFlags 

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

func (RunnerProfileListCommand) Close 

func (c RunnerProfileListCommand) Close() error

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

func (RunnerProfileListCommand) DoApp 

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

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

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

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

func (*RunnerProfileListCommand) Flags 

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

func (*RunnerProfileListCommand) Help 

func (c *RunnerProfileListCommand) Help() string

func (RunnerProfileListCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerProfileListCommand) Run 

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

func (*RunnerProfileListCommand) Synopsis 

func (c *RunnerProfileListCommand) Synopsis() string

type RunnerProfileSetCommand 

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

func (*RunnerProfileSetCommand) AutocompleteArgs 

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

func (*RunnerProfileSetCommand) AutocompleteFlags 

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

func (RunnerProfileSetCommand) Close 

func (c RunnerProfileSetCommand) Close() error

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

func (RunnerProfileSetCommand) DoApp 

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

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

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

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

func (*RunnerProfileSetCommand) Flags 

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

func (*RunnerProfileSetCommand) Help 

func (c *RunnerProfileSetCommand) Help() string

func (RunnerProfileSetCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerProfileSetCommand) Run 

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

func (*RunnerProfileSetCommand) Synopsis 

func (c *RunnerProfileSetCommand) Synopsis() string

type RunnerRejectCommand 

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

func (*RunnerRejectCommand) AutocompleteArgs 

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

func (*RunnerRejectCommand) AutocompleteFlags 

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

func (RunnerRejectCommand) Close 

func (c RunnerRejectCommand) Close() error

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

func (RunnerRejectCommand) DoApp 

func (c RunnerRejectCommand) 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 (*RunnerRejectCommand) Flags 

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

func (*RunnerRejectCommand) Help 

func (c *RunnerRejectCommand) Help() string

func (RunnerRejectCommand) Init 

func (c RunnerRejectCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerRejectCommand) Run 

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

func (*RunnerRejectCommand) Synopsis 

func (c *RunnerRejectCommand) Synopsis() string

type RunnerTokenCommand 

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

func (*RunnerTokenCommand) AutocompleteArgs 

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

func (*RunnerTokenCommand) AutocompleteFlags 

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

func (RunnerTokenCommand) Close 

func (c RunnerTokenCommand) Close() error

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

func (RunnerTokenCommand) DoApp 

func (c RunnerTokenCommand) 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 (*RunnerTokenCommand) Flags 

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

func (*RunnerTokenCommand) Help 

func (c *RunnerTokenCommand) Help() string

func (RunnerTokenCommand) Init 

func (c RunnerTokenCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerTokenCommand) Run 

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

func (*RunnerTokenCommand) Synopsis 

func (c *RunnerTokenCommand) Synopsis() string

type RunnerUninstallCommand 

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

func (*RunnerUninstallCommand) AutocompleteArgs 

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

func (*RunnerUninstallCommand) AutocompleteFlags 

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

func (RunnerUninstallCommand) Close 

func (c RunnerUninstallCommand) Close() error

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

func (RunnerUninstallCommand) DoApp 

func (c RunnerUninstallCommand) 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 (*RunnerUninstallCommand) Flags 

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

func (*RunnerUninstallCommand) Help 

func (c *RunnerUninstallCommand) Help() string

func (RunnerUninstallCommand) Init 

func (c RunnerUninstallCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*RunnerUninstallCommand) Run 

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

func (*RunnerUninstallCommand) Synopsis 

func (c *RunnerUninstallCommand) Synopsis() string

type ServerBootstrapCommand 

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

func (*ServerBootstrapCommand) AutocompleteArgs 

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

func (*ServerBootstrapCommand) AutocompleteFlags 

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

func (ServerBootstrapCommand) Close 

func (c ServerBootstrapCommand) Close() error

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

func (ServerBootstrapCommand) DoApp 

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

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

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

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

func (*ServerBootstrapCommand) Flags 

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

func (*ServerBootstrapCommand) Help 

func (c *ServerBootstrapCommand) Help() string

func (ServerBootstrapCommand) Init 

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

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

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

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ServerBootstrapCommand) Run 

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

func (*ServerBootstrapCommand) Synopsis 

func (c *ServerBootstrapCommand) Synopsis() string

type ServerConfigSetCommand 

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

func (*ServerConfigSetCommand) AutocompleteArgs 

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

func (*ServerConfigSetCommand) AutocompleteFlags 

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

func (ServerConfigSetCommand) Close 

func (c ServerConfigSetCommand) Close() error

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

func (ServerConfigSetCommand) DoApp 

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

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

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ServerConfigSetCommand) Flags 

func (c *ServerConfigSetCommand) Flags() *flag.Sets

func (*ServerConfigSetCommand) Help 

func (c *ServerConfigSetCommand) Help() string

func (ServerConfigSetCommand) Init 

func (c ServerConfigSetCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ServerConfigSetCommand) Run 

func (c *ServerConfigSetCommand) Run(args []string) int

func (*ServerConfigSetCommand) Synopsis 

func (c *ServerConfigSetCommand) Synopsis() string

type ServerCookieCommand 

type ServerCookieCommand struct {
	// contains filtered or unexported fields
}

func (*ServerCookieCommand) AutocompleteArgs 

func (c *ServerCookieCommand) AutocompleteArgs() complete.Predictor

func (*ServerCookieCommand) AutocompleteFlags 

func (c *ServerCookieCommand) AutocompleteFlags() complete.Flags

func (ServerCookieCommand) Close 

func (c ServerCookieCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ServerCookieCommand) DoApp 

func (c ServerCookieCommand) 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 (*ServerCookieCommand) Flags 

func (c *ServerCookieCommand) Flags() *flag.Sets

func (*ServerCookieCommand) Help 

func (c *ServerCookieCommand) Help() string

func (ServerCookieCommand) Init 

func (c ServerCookieCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ServerCookieCommand) Run 

func (c *ServerCookieCommand) Run(args []string) int

func (*ServerCookieCommand) Synopsis 

func (c *ServerCookieCommand) Synopsis() string

type ServerRunCommand 

type ServerRunCommand struct {
	// contains filtered or unexported fields
}

func (*ServerRunCommand) AutocompleteArgs 

func (c *ServerRunCommand) AutocompleteArgs() complete.Predictor

func (*ServerRunCommand) AutocompleteFlags 

func (c *ServerRunCommand) AutocompleteFlags() complete.Flags

func (ServerRunCommand) Close 

func (c ServerRunCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ServerRunCommand) DoApp 

func (c ServerRunCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*ServerRunCommand) Flags 

func (c *ServerRunCommand) Flags() *flag.Sets

func (*ServerRunCommand) Help 

func (c *ServerRunCommand) Help() string

func (ServerRunCommand) Init 

func (c ServerRunCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ServerRunCommand) Run 

func (c *ServerRunCommand) Run(args []string) int

func (*ServerRunCommand) Synopsis 

func (c *ServerRunCommand) Synopsis() string

type ServerUpgradeCommand 

type ServerUpgradeCommand struct {
	// contains filtered or unexported fields
}

func (*ServerUpgradeCommand) AutocompleteArgs 

func (c *ServerUpgradeCommand) AutocompleteArgs() complete.Predictor

func (*ServerUpgradeCommand) AutocompleteFlags 

func (c *ServerUpgradeCommand) AutocompleteFlags() complete.Flags

func (ServerUpgradeCommand) Close 

func (c ServerUpgradeCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (ServerUpgradeCommand) DoApp 

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 

func (c *ServerUpgradeCommand) Flags() *flag.Sets

func (*ServerUpgradeCommand) Help 

func (c *ServerUpgradeCommand) Help() string

func (ServerUpgradeCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*ServerUpgradeCommand) Run 

func (c *ServerUpgradeCommand) Run(args []string) int

func (*ServerUpgradeCommand) Synopsis 

func (c *ServerUpgradeCommand) Synopsis() string

type SnapshotBackupCommand 

type SnapshotBackupCommand struct {
	// contains filtered or unexported fields
}

func (*SnapshotBackupCommand) AutocompleteArgs 

func (c *SnapshotBackupCommand) AutocompleteArgs() complete.Predictor

func (*SnapshotBackupCommand) AutocompleteFlags 

func (c *SnapshotBackupCommand) AutocompleteFlags() complete.Flags

func (SnapshotBackupCommand) Close 

func (c SnapshotBackupCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (SnapshotBackupCommand) DoApp 

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 

func (c *SnapshotBackupCommand) Flags() *flag.Sets

func (*SnapshotBackupCommand) Help 

func (c *SnapshotBackupCommand) Help() string

func (SnapshotBackupCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*SnapshotBackupCommand) Run 

func (c *SnapshotBackupCommand) Run(args []string) int

func (*SnapshotBackupCommand) Synopsis 

func (c *SnapshotBackupCommand) Synopsis() string

type SnapshotRestoreCommand 

type SnapshotRestoreCommand struct {
	// contains filtered or unexported fields
}

func (*SnapshotRestoreCommand) AutocompleteArgs 

func (c *SnapshotRestoreCommand) AutocompleteArgs() complete.Predictor

func (*SnapshotRestoreCommand) AutocompleteFlags 

func (c *SnapshotRestoreCommand) AutocompleteFlags() complete.Flags

func (SnapshotRestoreCommand) Close 

func (c SnapshotRestoreCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (SnapshotRestoreCommand) DoApp 

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 

func (c *SnapshotRestoreCommand) Flags() *flag.Sets

func (*SnapshotRestoreCommand) Help 

func (c *SnapshotRestoreCommand) Help() string

func (SnapshotRestoreCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*SnapshotRestoreCommand) Run 

func (c *SnapshotRestoreCommand) Run(args []string) int

func (*SnapshotRestoreCommand) Synopsis 

func (c *SnapshotRestoreCommand) Synopsis() string

type StatusCommand 

type StatusCommand struct {
	// contains filtered or unexported fields
}

func (*StatusCommand) AutocompleteArgs 

func (c *StatusCommand) AutocompleteArgs() complete.Predictor

func (*StatusCommand) AutocompleteFlags 

func (c *StatusCommand) AutocompleteFlags() complete.Flags

func (StatusCommand) Close 

func (c StatusCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (StatusCommand) DoApp 

func (c StatusCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*StatusCommand) Flags 

func (c *StatusCommand) Flags() *flag.Sets

func (*StatusCommand) FormatAppStatus 

func (c *StatusCommand) FormatAppStatus(projectTarget string, appTarget string) error

func (*StatusCommand) FormatProjectAppStatus 

func (c *StatusCommand) FormatProjectAppStatus(projectTarget string) error

FormatProjectAppStatus formats all applications inside a project

func (*StatusCommand) FormatProjectStatus 

func (c *StatusCommand) FormatProjectStatus() error

FormatProjectStatus formats all known projects into a table

func (*StatusCommand) FormatStatusReportComplete 

func (c *StatusCommand) FormatStatusReportComplete(
	statusReport *pb.StatusReport,
) (string, string, error)

func (*StatusCommand) Help 

func (c *StatusCommand) Help() string

func (StatusCommand) Init 

func (c StatusCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*StatusCommand) RefreshApplicationStatus 

func (c *StatusCommand) RefreshApplicationStatus() error

RefreshApplicationStatus takes a project and application target and generates a list of applications to refresh the status on. If all projects are requested to be refreshed, the CLI will do its best to honor the request. However, if a project is local and the CLI was not invoked inside that project dir, the CLI won't be able to refresh that project's application statuses.

func (*StatusCommand) Run 

func (c *StatusCommand) Run(args []string) int

func (*StatusCommand) Synopsis 

func (c *StatusCommand) Synopsis() string

type TaskCancelCommand 

type TaskCancelCommand struct {
	// contains filtered or unexported fields
}

func (TaskCancelCommand) Close 

func (c TaskCancelCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (TaskCancelCommand) DoApp 

func (c TaskCancelCommand) 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 (*TaskCancelCommand) Flags 

func (c *TaskCancelCommand) Flags() *flag.Sets

func (*TaskCancelCommand) Help 

func (c *TaskCancelCommand) Help() string

func (TaskCancelCommand) Init 

func (c TaskCancelCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*TaskCancelCommand) Run 

func (c *TaskCancelCommand) Run(args []string) int

func (*TaskCancelCommand) Synopsis 

func (c *TaskCancelCommand) Synopsis() string

type TaskInspectCommand 

type TaskInspectCommand struct {
	// contains filtered or unexported fields
}

func (TaskInspectCommand) Close 

func (c TaskInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (TaskInspectCommand) DoApp 

func (c TaskInspectCommand) 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 (*TaskInspectCommand) Flags 

func (c *TaskInspectCommand) Flags() *flag.Sets

func (*TaskInspectCommand) FormatJob 

func (c *TaskInspectCommand) FormatJob(job *pb.Job) error

FormatJob takes a Job proto message and formats it into something nicer to read to the user.

func (*TaskInspectCommand) Help 

func (c *TaskInspectCommand) Help() string

func (TaskInspectCommand) Init 

func (c TaskInspectCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*TaskInspectCommand) Run 

func (c *TaskInspectCommand) Run(args []string) int

func (*TaskInspectCommand) Synopsis 

func (c *TaskInspectCommand) Synopsis() string

type TaskListCommand 

type TaskListCommand struct {
	// contains filtered or unexported fields
}

func (TaskListCommand) Close 

func (c TaskListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (TaskListCommand) DoApp 

func (c TaskListCommand) 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 (*TaskListCommand) Flags 

func (c *TaskListCommand) Flags() *flag.Sets

func (*TaskListCommand) Help 

func (c *TaskListCommand) Help() string

func (TaskListCommand) Init 

func (c TaskListCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*TaskListCommand) Run 

func (c *TaskListCommand) Run(args []string) int

func (*TaskListCommand) Synopsis 

func (c *TaskListCommand) Synopsis() string

type TriggerApplyCommand 

type TriggerApplyCommand struct {

	// if true, this command will update the trigger. Set by invoking
	// `trigger update` as opposed to `trigger create`.
	Update bool
	// contains filtered or unexported fields
}

func (*TriggerApplyCommand) AutocompleteArgs 

func (c *TriggerApplyCommand) AutocompleteArgs() complete.Predictor

func (*TriggerApplyCommand) AutocompleteFlags 

func (c *TriggerApplyCommand) AutocompleteFlags() complete.Flags

func (TriggerApplyCommand) Close 

func (c TriggerApplyCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (TriggerApplyCommand) DoApp 

func (c TriggerApplyCommand) 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 (*TriggerApplyCommand) Flags 

func (c *TriggerApplyCommand) Flags() *flag.Sets

func (*TriggerApplyCommand) Help 

func (c *TriggerApplyCommand) Help() string

func (TriggerApplyCommand) Init 

func (c TriggerApplyCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*TriggerApplyCommand) Run 

func (c *TriggerApplyCommand) Run(args []string) int

func (*TriggerApplyCommand) Synopsis 

func (c *TriggerApplyCommand) Synopsis() string

type TriggerDeleteCommand 

type TriggerDeleteCommand struct {
	// contains filtered or unexported fields
}

func (*TriggerDeleteCommand) AutocompleteArgs 

func (c *TriggerDeleteCommand) AutocompleteArgs() complete.Predictor

func (*TriggerDeleteCommand) AutocompleteFlags 

func (c *TriggerDeleteCommand) AutocompleteFlags() complete.Flags

func (TriggerDeleteCommand) Close 

func (c TriggerDeleteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (TriggerDeleteCommand) DoApp 

func (c TriggerDeleteCommand) 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 (*TriggerDeleteCommand) Flags 

func (c *TriggerDeleteCommand) Flags() *flag.Sets

func (*TriggerDeleteCommand) Help 

func (c *TriggerDeleteCommand) Help() string

func (TriggerDeleteCommand) Init 

func (c TriggerDeleteCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*TriggerDeleteCommand) Run 

func (c *TriggerDeleteCommand) Run(args []string) int

func (*TriggerDeleteCommand) Synopsis 

func (c *TriggerDeleteCommand) Synopsis() string

type TriggerInspectCommand 

type TriggerInspectCommand struct {
	// contains filtered or unexported fields
}

func (*TriggerInspectCommand) AutocompleteArgs 

func (c *TriggerInspectCommand) AutocompleteArgs() complete.Predictor

func (*TriggerInspectCommand) AutocompleteFlags 

func (c *TriggerInspectCommand) AutocompleteFlags() complete.Flags

func (TriggerInspectCommand) Close 

func (c TriggerInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (TriggerInspectCommand) DoApp 

func (c TriggerInspectCommand) 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 (*TriggerInspectCommand) Flags 

func (c *TriggerInspectCommand) Flags() *flag.Sets

func (*TriggerInspectCommand) Help 

func (c *TriggerInspectCommand) Help() string

func (TriggerInspectCommand) Init 

func (c TriggerInspectCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*TriggerInspectCommand) Run 

func (c *TriggerInspectCommand) Run(args []string) int

func (*TriggerInspectCommand) Synopsis 

func (c *TriggerInspectCommand) Synopsis() string

type TriggerListCommand 

type TriggerListCommand struct {
	// contains filtered or unexported fields
}

func (*TriggerListCommand) AutocompleteArgs 

func (c *TriggerListCommand) AutocompleteArgs() complete.Predictor

func (*TriggerListCommand) AutocompleteFlags 

func (c *TriggerListCommand) AutocompleteFlags() complete.Flags

func (TriggerListCommand) Close 

func (c TriggerListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (TriggerListCommand) DoApp 

func (c TriggerListCommand) 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 (*TriggerListCommand) Flags 

func (c *TriggerListCommand) Flags() *flag.Sets

func (*TriggerListCommand) Help 

func (c *TriggerListCommand) Help() string

func (TriggerListCommand) Init 

func (c TriggerListCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*TriggerListCommand) Run 

func (c *TriggerListCommand) Run(args []string) int

func (*TriggerListCommand) Synopsis 

func (c *TriggerListCommand) Synopsis() string

type UICommand 

type UICommand struct {
	// contains filtered or unexported fields
}

func (*UICommand) AutocompleteArgs 

func (c *UICommand) AutocompleteArgs() complete.Predictor

func (*UICommand) AutocompleteFlags 

func (c *UICommand) AutocompleteFlags() complete.Flags

func (UICommand) Close 

func (c UICommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UICommand) DoApp 

func (c UICommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UICommand) Flags 

func (c *UICommand) Flags() *flag.Sets

func (*UICommand) Help 

func (c *UICommand) Help() string

func (UICommand) Init 

func (c UICommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*UICommand) Run 

func (c *UICommand) Run(args []string) int

func (*UICommand) Synopsis 

func (c *UICommand) Synopsis() string

type UninstallCommand 

type UninstallCommand struct {
	// contains filtered or unexported fields
}

func (*UninstallCommand) AutocompleteArgs 

func (c *UninstallCommand) AutocompleteArgs() complete.Predictor

func (*UninstallCommand) AutocompleteFlags 

func (c *UninstallCommand) AutocompleteFlags() complete.Flags

func (UninstallCommand) Close 

func (c UninstallCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UninstallCommand) DoApp 

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 

func (c *UninstallCommand) Flags() *flag.Sets

func (*UninstallCommand) Help 

func (c *UninstallCommand) Help() string

func (UninstallCommand) Init 

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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*UninstallCommand) Run 

func (c *UninstallCommand) Run(args []string) int

func (*UninstallCommand) Synopsis 

func (c *UninstallCommand) Synopsis() string

type UpCommand 

type UpCommand struct {
	// contains filtered or unexported fields
}

func (UpCommand) Close 

func (c UpCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UpCommand) DoApp 

func (c UpCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UpCommand) Flags 

func (c *UpCommand) Flags() *flag.Sets

func (*UpCommand) Help 

func (c *UpCommand) Help() string

func (UpCommand) Init 

func (c UpCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*UpCommand) Run 

func (c *UpCommand) Run(args []string) int

func (*UpCommand) Synopsis 

func (c *UpCommand) Synopsis() string

type UserInspectCommand 

type UserInspectCommand struct {
	// contains filtered or unexported fields
}

func (*UserInspectCommand) AutocompleteArgs 

func (c *UserInspectCommand) AutocompleteArgs() complete.Predictor

func (*UserInspectCommand) AutocompleteFlags 

func (c *UserInspectCommand) AutocompleteFlags() complete.Flags

func (UserInspectCommand) Close 

func (c UserInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserInspectCommand) DoApp 

func (c UserInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserInspectCommand) Flags 

func (c *UserInspectCommand) Flags() *flag.Sets

func (*UserInspectCommand) Help 

func (c *UserInspectCommand) Help() string

func (UserInspectCommand) Init 

func (c UserInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*UserInspectCommand) Run 

func (c *UserInspectCommand) Run(args []string) int

func (*UserInspectCommand) Synopsis 

func (c *UserInspectCommand) Synopsis() string

type UserInviteCommand 

type UserInviteCommand struct {
	// contains filtered or unexported fields
}

func (*UserInviteCommand) AutocompleteArgs 

func (c *UserInviteCommand) AutocompleteArgs() complete.Predictor

func (*UserInviteCommand) AutocompleteFlags 

func (c *UserInviteCommand) AutocompleteFlags() complete.Flags

func (UserInviteCommand) Close 

func (c UserInviteCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserInviteCommand) DoApp 

func (c UserInviteCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserInviteCommand) Flags 

func (c *UserInviteCommand) Flags() *flag.Sets

func (*UserInviteCommand) Help 

func (c *UserInviteCommand) Help() string

func (UserInviteCommand) Init 

func (c UserInviteCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*UserInviteCommand) Run 

func (c *UserInviteCommand) Run(args []string) int

func (*UserInviteCommand) Synopsis 

func (c *UserInviteCommand) Synopsis() string

type UserModifyCommand 

type UserModifyCommand struct {
	// contains filtered or unexported fields
}

func (*UserModifyCommand) AutocompleteArgs 

func (c *UserModifyCommand) AutocompleteArgs() complete.Predictor

func (*UserModifyCommand) AutocompleteFlags 

func (c *UserModifyCommand) AutocompleteFlags() complete.Flags

func (UserModifyCommand) Close 

func (c UserModifyCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserModifyCommand) DoApp 

func (c UserModifyCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserModifyCommand) Flags 

func (c *UserModifyCommand) Flags() *flag.Sets

func (*UserModifyCommand) Help 

func (c *UserModifyCommand) Help() string

func (UserModifyCommand) Init 

func (c UserModifyCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*UserModifyCommand) Run 

func (c *UserModifyCommand) Run(args []string) int

func (*UserModifyCommand) Synopsis 

func (c *UserModifyCommand) Synopsis() string

type UserTokenCommand 

type UserTokenCommand struct {
	// contains filtered or unexported fields
}

func (*UserTokenCommand) AutocompleteArgs 

func (c *UserTokenCommand) AutocompleteArgs() complete.Predictor

func (*UserTokenCommand) AutocompleteFlags 

func (c *UserTokenCommand) AutocompleteFlags() complete.Flags

func (UserTokenCommand) Close 

func (c UserTokenCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (UserTokenCommand) DoApp 

func (c UserTokenCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*UserTokenCommand) Flags 

func (c *UserTokenCommand) Flags() *flag.Sets

func (*UserTokenCommand) Help 

func (c *UserTokenCommand) Help() string

func (UserTokenCommand) Init 

func (c UserTokenCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*UserTokenCommand) Run 

func (c *UserTokenCommand) Run(args []string) int

func (*UserTokenCommand) Synopsis 

func (c *UserTokenCommand) Synopsis() string

type VersionCommand 

type VersionCommand struct {
	VersionInfo *version.VersionInfo
	// contains filtered or unexported fields
}

func (*VersionCommand) AutocompleteArgs 

func (c *VersionCommand) AutocompleteArgs() complete.Predictor

func (*VersionCommand) AutocompleteFlags 

func (c *VersionCommand) AutocompleteFlags() complete.Flags

func (VersionCommand) Close 

func (c VersionCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (VersionCommand) DoApp 

func (c VersionCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*VersionCommand) Flags 

func (c *VersionCommand) Flags() *flag.Sets

func (*VersionCommand) Help 

func (c *VersionCommand) Help() string

func (VersionCommand) Init 

func (c VersionCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*VersionCommand) Run 

func (c *VersionCommand) Run(args []string) int

func (*VersionCommand) Synopsis 

func (c *VersionCommand) Synopsis() string

type WorkspaceCreateCommand 

type WorkspaceCreateCommand struct {
	// contains filtered or unexported fields
}

func (*WorkspaceCreateCommand) AutocompleteArgs 

func (c *WorkspaceCreateCommand) AutocompleteArgs() complete.Predictor

func (*WorkspaceCreateCommand) AutocompleteFlags 

func (c *WorkspaceCreateCommand) AutocompleteFlags() complete.Flags

func (WorkspaceCreateCommand) Close 

func (c WorkspaceCreateCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (WorkspaceCreateCommand) DoApp 

func (c WorkspaceCreateCommand) 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 (*WorkspaceCreateCommand) Flags 

func (c *WorkspaceCreateCommand) Flags() *flag.Sets

func (*WorkspaceCreateCommand) Help 

func (c *WorkspaceCreateCommand) Help() string

func (WorkspaceCreateCommand) Init 

func (c WorkspaceCreateCommand) 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.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*WorkspaceCreateCommand) Run 

func (c *WorkspaceCreateCommand) Run(args []string) int

func (*WorkspaceCreateCommand) Synopsis 

func (c *WorkspaceCreateCommand) Synopsis() string

type WorkspaceInspectCommand 

type WorkspaceInspectCommand struct {
	// contains filtered or unexported fields
}

func (*WorkspaceInspectCommand) AutocompleteArgs 

func (c *WorkspaceInspectCommand) AutocompleteArgs() complete.Predictor

func (*WorkspaceInspectCommand) AutocompleteFlags 

func (c *WorkspaceInspectCommand) AutocompleteFlags() complete.Flags

func (WorkspaceInspectCommand) Close 

func (c WorkspaceInspectCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (WorkspaceInspectCommand) DoApp 

func (c WorkspaceInspectCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*WorkspaceInspectCommand) Flags 

func (c *WorkspaceInspectCommand) Flags() *flag.Sets

func (*WorkspaceInspectCommand) Help 

func (c *WorkspaceInspectCommand) Help() string

func (WorkspaceInspectCommand) Init 

func (c WorkspaceInspectCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*WorkspaceInspectCommand) Run 

func (c *WorkspaceInspectCommand) Run(args []string) int

func (*WorkspaceInspectCommand) Synopsis 

func (c *WorkspaceInspectCommand) Synopsis() string

type WorkspaceListCommand 

type WorkspaceListCommand struct {
	// contains filtered or unexported fields
}

func (*WorkspaceListCommand) AutocompleteArgs 

func (c *WorkspaceListCommand) AutocompleteArgs() complete.Predictor

func (*WorkspaceListCommand) AutocompleteFlags 

func (c *WorkspaceListCommand) AutocompleteFlags() complete.Flags

func (WorkspaceListCommand) Close 

func (c WorkspaceListCommand) Close() error

Close cleans up any resources that the command created. This should be deferred by any CLI command that embeds baseCommand in the Run command.

func (WorkspaceListCommand) DoApp 

func (c WorkspaceListCommand) DoApp(ctx context.Context, f func(context.Context, *clientpkg.App) error) error

DoApp calls the callback for each app. This lets you execute logic in an app-specific context safely. This automatically handles any parallelization, waiting, and error handling. Your code should be thread-safe.

If any error is returned, the caller should just exit. The error handling including messaging to the user is handled by this function call.

If you want to early exit all the running functions, you should use the callback closure properties to cancel the passed in context. This will stop any remaining callbacks and exit early.

func (*WorkspaceListCommand) Flags 

func (c *WorkspaceListCommand) Flags() *flag.Sets

func (*WorkspaceListCommand) Help 

func (c *WorkspaceListCommand) Help() string

func (WorkspaceListCommand) Init 

func (c WorkspaceListCommand) Init(opts ...Option) error

Init initializes the command by parsing flags, parsing the configuration, setting up the project, etc. You can control what is done by using the options.

Init should be called FIRST within the Run function implementation. Many options will affect behavior of other functions that can be called later.

In broad strokes, Init populates fields on the baseCommand by doing the following:

  • Parse flags
  • Parse input variables
  • Creates a project client
  • Triggers creation of the in-memory server (if necessary)
  • Starts a local runner (if necessary)
  • Attempts to find a waypoint.hcl config file, and parse it
  • Determines which project/apps are being targeted, by looking at the -project and -app flags, the local config, the waypoint server.

func (*WorkspaceListCommand) Run 

func (c *WorkspaceListCommand) Run(args []string) int

func (*WorkspaceListCommand) Synopsis 

func (c *WorkspaceListCommand) Synopsis() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.