cli

package
v0.11.4 Latest Latest
Warning

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

 Go to latest Published: Aug 9, 2023 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 added in v0.6.2 

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

func ListReleases added in v0.6.2 

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

func Main 

func Main(args []string) int

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

Types

type AppDocsCommand 

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

func (*AppDocsCommand) AutocompleteArgs 

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

func (*AppDocsCommand) AutocompleteFlags 

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

func (AppDocsCommand) Close 

func (c AppDocsCommand) Close() error

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

func (AppDocsCommand) DoApp 

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

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

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

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

func (*AppDocsCommand) Flags 

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

func (*AppDocsCommand) Help 

func (c *AppDocsCommand) Help() string

func (AppDocsCommand) Init 

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

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

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

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 added in v0.5.0 

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

func (*AuthMethodDeleteCommand) AutocompleteArgs added in v0.5.0 

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

func (*AuthMethodDeleteCommand) AutocompleteFlags added in v0.5.0 

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

func (AuthMethodDeleteCommand) Close added in v0.5.0 

func (c AuthMethodDeleteCommand) Close() error

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

func (AuthMethodDeleteCommand) DoApp added in v0.5.0 

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

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

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

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

func (*AuthMethodDeleteCommand) Flags added in v0.5.0 

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

func (*AuthMethodDeleteCommand) Help added in v0.5.0 

func (c *AuthMethodDeleteCommand) Help() string

func (AuthMethodDeleteCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*AuthMethodDeleteCommand) Synopsis added in v0.5.0 

func (c *AuthMethodDeleteCommand) Synopsis() string

type AuthMethodInspectCommand added in v0.5.0 

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

func (*AuthMethodInspectCommand) AutocompleteArgs added in v0.5.0 

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

func (*AuthMethodInspectCommand) AutocompleteFlags added in v0.5.0 

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

func (AuthMethodInspectCommand) Close added in v0.5.0 

func (c AuthMethodInspectCommand) Close() error

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

func (AuthMethodInspectCommand) DoApp added in v0.5.0 

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

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

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

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

func (*AuthMethodInspectCommand) Flags added in v0.5.0 

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

func (*AuthMethodInspectCommand) Help added in v0.5.0 

func (c *AuthMethodInspectCommand) Help() string

func (AuthMethodInspectCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*AuthMethodInspectCommand) Synopsis added in v0.5.0 

func (c *AuthMethodInspectCommand) Synopsis() string

type AuthMethodListCommand added in v0.5.0 

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

func (*AuthMethodListCommand) AutocompleteArgs added in v0.5.0 

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

func (*AuthMethodListCommand) AutocompleteFlags added in v0.5.0 

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

func (AuthMethodListCommand) Close added in v0.5.0 

func (c AuthMethodListCommand) Close() error

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

func (AuthMethodListCommand) DoApp added in v0.5.0 

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

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

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

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

func (*AuthMethodListCommand) Flags added in v0.5.0 

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

func (*AuthMethodListCommand) Help added in v0.5.0 

func (c *AuthMethodListCommand) Help() string

func (AuthMethodListCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*AuthMethodListCommand) Synopsis added in v0.5.0 

func (c *AuthMethodListCommand) Synopsis() string

type AuthMethodSetOIDCCommand added in v0.5.0 

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

func (*AuthMethodSetOIDCCommand) AutocompleteArgs added in v0.5.0 

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

func (*AuthMethodSetOIDCCommand) AutocompleteFlags added in v0.5.0 

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

func (AuthMethodSetOIDCCommand) Close added in v0.5.0 

func (c AuthMethodSetOIDCCommand) Close() error

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

func (AuthMethodSetOIDCCommand) DoApp added in v0.5.0 

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

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

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

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

func (*AuthMethodSetOIDCCommand) Flags added in v0.5.0 

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

func (*AuthMethodSetOIDCCommand) Help added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) Help() string

func (AuthMethodSetOIDCCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*AuthMethodSetOIDCCommand) Synopsis added in v0.5.0 

func (c *AuthMethodSetOIDCCommand) Synopsis() string

type BuildListCommand 

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

func (*BuildListCommand) AutocompleteArgs 

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

func (*BuildListCommand) AutocompleteFlags 

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

func (BuildListCommand) Close 

func (c BuildListCommand) Close() error

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

func (BuildListCommand) DoApp 

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

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

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

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

func (*BuildListCommand) Flags 

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

func (*BuildListCommand) Help 

func (c *BuildListCommand) Help() string

func (BuildListCommand) Init 

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

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

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

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 added in v0.11.2 

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

func (*ConfigDeleteCommand) AutocompleteArgs added in v0.11.2 

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

func (*ConfigDeleteCommand) AutocompleteFlags added in v0.11.2 

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

func (ConfigDeleteCommand) Close added in v0.11.2 

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 added in v0.11.2 

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 added in v0.11.2 

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

func (*ConfigDeleteCommand) Help added in v0.11.2 

func (c *ConfigDeleteCommand) Help() string

func (ConfigDeleteCommand) Init added in v0.11.2 

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 added in v0.11.2 

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

func (*ConfigDeleteCommand) Synopsis added in v0.11.2 

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 added in v0.11.2 

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

func (*ConfigSourceDeleteCommand) AutocompleteArgs added in v0.11.2 

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

func (*ConfigSourceDeleteCommand) AutocompleteFlags added in v0.11.2 

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

func (ConfigSourceDeleteCommand) Close added in v0.11.2 

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 added in v0.11.2 

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 added in v0.11.2 

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

func (*ConfigSourceDeleteCommand) Help added in v0.11.2 

func (c *ConfigSourceDeleteCommand) Help() string

func (ConfigSourceDeleteCommand) Init added in v0.11.2 

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 added in v0.11.2 

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

func (*ConfigSourceDeleteCommand) Synopsis added in v0.11.2 

func (c *ConfigSourceDeleteCommand) Synopsis() string

type ConfigSourceGetCommand added in v0.2.0 

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

func (*ConfigSourceGetCommand) AutocompleteArgs added in v0.2.0 

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

func (*ConfigSourceGetCommand) AutocompleteFlags added in v0.2.0 

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

func (ConfigSourceGetCommand) Close added in v0.2.0 

func (c ConfigSourceGetCommand) Close() error

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

func (ConfigSourceGetCommand) DoApp added in v0.2.0 

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

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

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

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

func (*ConfigSourceGetCommand) Flags added in v0.2.0 

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

func (*ConfigSourceGetCommand) Help added in v0.2.0 

func (c *ConfigSourceGetCommand) Help() string

func (ConfigSourceGetCommand) Init added in v0.2.0 

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

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

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

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 added in v0.2.0 

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

func (*ConfigSourceGetCommand) Synopsis added in v0.2.0 

func (c *ConfigSourceGetCommand) Synopsis() string

type ConfigSourceSetCommand added in v0.2.0 

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

func (*ConfigSourceSetCommand) AutocompleteArgs added in v0.2.0 

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

func (*ConfigSourceSetCommand) AutocompleteFlags added in v0.2.0 

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

func (ConfigSourceSetCommand) Close added in v0.2.0 

func (c ConfigSourceSetCommand) Close() error

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

func (ConfigSourceSetCommand) DoApp added in v0.2.0 

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

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

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

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

func (*ConfigSourceSetCommand) Flags added in v0.2.0 

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

func (*ConfigSourceSetCommand) Help added in v0.2.0 

func (c *ConfigSourceSetCommand) Help() string

func (ConfigSourceSetCommand) Init added in v0.2.0 

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

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

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

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 added in v0.2.0 

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

func (*ConfigSourceSetCommand) Synopsis added in v0.2.0 

func (c *ConfigSourceSetCommand) Synopsis() string

type ConfigSyncCommand added in v0.2.0 

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

func (*ConfigSyncCommand) AutocompleteArgs added in v0.2.0 

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

func (*ConfigSyncCommand) AutocompleteFlags added in v0.2.0 

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

func (ConfigSyncCommand) Close added in v0.2.0 

func (c ConfigSyncCommand) Close() error

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

func (ConfigSyncCommand) DoApp added in v0.2.0 

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

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

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

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

func (*ConfigSyncCommand) Flags added in v0.2.0 

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

func (*ConfigSyncCommand) Help added in v0.2.0 

func (c *ConfigSyncCommand) Help() string

func (ConfigSyncCommand) Init added in v0.2.0 

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

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

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

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 added in v0.2.0 

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

func (*ConfigSyncCommand) Synopsis added in v0.2.0 

func (c *ConfigSyncCommand) Synopsis() string

type ContextClearCommand 

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

func (*ContextClearCommand) AutocompleteArgs 

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

func (*ContextClearCommand) AutocompleteFlags 

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

func (ContextClearCommand) Close 

func (c ContextClearCommand) Close() error

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

func (ContextClearCommand) DoApp 

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

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

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

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

func (*ContextClearCommand) Flags 

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

func (*ContextClearCommand) Help 

func (c *ContextClearCommand) Help() string

func (ContextClearCommand) Init 

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

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

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

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 added in v0.3.2 

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

func (*ContextHelpCommand) AutocompleteArgs added in v0.3.2 

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

func (*ContextHelpCommand) AutocompleteFlags added in v0.3.2 

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

func (ContextHelpCommand) Close added in v0.3.2 

func (c ContextHelpCommand) Close() error

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

func (ContextHelpCommand) DoApp added in v0.3.2 

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

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

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

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

func (*ContextHelpCommand) Flags added in v0.3.2 

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

func (*ContextHelpCommand) Help added in v0.3.2 

func (c *ContextHelpCommand) Help() string

func (ContextHelpCommand) Init added in v0.3.2 

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

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

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

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 added in v0.3.2 

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

func (*ContextHelpCommand) Synopsis added in v0.3.2 

func (c *ContextHelpCommand) Synopsis() string

type ContextInspectCommand added in v0.3.2 

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

func (*ContextInspectCommand) AutocompleteArgs added in v0.3.2 

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

func (*ContextInspectCommand) AutocompleteFlags added in v0.3.2 

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

func (ContextInspectCommand) Close added in v0.3.2 

func (c ContextInspectCommand) Close() error

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

func (ContextInspectCommand) DoApp added in v0.3.2 

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

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

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

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

func (*ContextInspectCommand) Flags added in v0.3.2 

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

func (*ContextInspectCommand) Help added in v0.3.2 

func (c *ContextInspectCommand) Help() string

func (ContextInspectCommand) Init added in v0.3.2 

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

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

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

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 added in v0.3.2 

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

func (*ContextInspectCommand) Synopsis added in v0.3.2 

func (c *ContextInspectCommand) Synopsis() string

type ContextListCommand 

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

func (*ContextListCommand) AutocompleteArgs 

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

func (*ContextListCommand) AutocompleteFlags 

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

func (ContextListCommand) Close 

func (c ContextListCommand) Close() error

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

func (ContextListCommand) DoApp 

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

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

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

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

func (*ContextListCommand) Flags 

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

func (*ContextListCommand) Help 

func (c *ContextListCommand) Help() string

func (ContextListCommand) Init 

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

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

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

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 added in v0.6.0 

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

func (*ContextSetCommand) AutocompleteArgs added in v0.6.0 

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

func (*ContextSetCommand) AutocompleteFlags added in v0.6.0 

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

func (ContextSetCommand) Close added in v0.6.0 

func (c ContextSetCommand) Close() error

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

func (ContextSetCommand) DoApp added in v0.6.0 

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

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

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

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

func (*ContextSetCommand) Flags added in v0.6.0 

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

func (*ContextSetCommand) Help added in v0.6.0 

func (c *ContextSetCommand) Help() string

func (ContextSetCommand) Init added in v0.6.0 

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

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

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

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 added in v0.6.0 

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

func (*ContextSetCommand) Synopsis added in v0.6.0 

func (c *ContextSetCommand) Synopsis() string

type ContextUseCommand 

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

func (*ContextUseCommand) AutocompleteArgs 

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

func (*ContextUseCommand) AutocompleteFlags 

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

func (ContextUseCommand) Close 

func (c ContextUseCommand) Close() error

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

func (ContextUseCommand) DoApp 

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

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

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

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

func (*ContextUseCommand) Flags 

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

func (*ContextUseCommand) Help 

func (c *ContextUseCommand) Help() string

func (ContextUseCommand) Init 

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

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

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

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 added in v0.3.0 

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

func (*FmtCommand) AutocompleteArgs added in v0.3.0 

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

func (*FmtCommand) AutocompleteFlags added in v0.3.0 

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

func (FmtCommand) Close added in v0.3.0 

func (c FmtCommand) Close() error

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

func (FmtCommand) DoApp added in v0.3.0 

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

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

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

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

func (*FmtCommand) Flags added in v0.3.0 

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

func (*FmtCommand) Help added in v0.3.0 

func (c *FmtCommand) Help() string

func (FmtCommand) Init added in v0.3.0 

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

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

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

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 added in v0.3.0 

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

func (*FmtCommand) Synopsis added in v0.3.0 

func (c *FmtCommand) Synopsis() string

type GetInviteCommand 

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

func (*GetInviteCommand) AutocompleteArgs 

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

func (*GetInviteCommand) AutocompleteFlags 

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

func (GetInviteCommand) Close 

func (c GetInviteCommand) Close() error

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

func (GetInviteCommand) DoApp 

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

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

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

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

func (*GetInviteCommand) Flags 

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

func (*GetInviteCommand) Help 

func (c *GetInviteCommand) Help() string

func (GetInviteCommand) Init 

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

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

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

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 added in v0.8.0 

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

func (JobCancelCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*JobCancelCommand) Help added in v0.8.0 

func (c *JobCancelCommand) Help() string

func (JobCancelCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*JobCancelCommand) Synopsis added in v0.8.0 

func (c *JobCancelCommand) Synopsis() string

type JobGetStreamCommand added in v0.8.0 

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

func (JobGetStreamCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*JobGetStreamCommand) Help added in v0.8.0 

func (c *JobGetStreamCommand) Help() string

func (JobGetStreamCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*JobGetStreamCommand) Synopsis added in v0.8.0 

func (c *JobGetStreamCommand) Synopsis() string

type JobInspectCommand added in v0.8.0 

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

func (JobInspectCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*JobInspectCommand) Help added in v0.8.0 

func (c *JobInspectCommand) Help() string

func (JobInspectCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*JobInspectCommand) Synopsis added in v0.8.0 

func (c *JobInspectCommand) Synopsis() string

type JobListCommand added in v0.8.0 

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

func (JobListCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*JobListCommand) Help added in v0.8.0 

func (c *JobListCommand) Help() string

func (JobListCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*JobListCommand) Synopsis added in v0.8.0 

func (c *JobListCommand) Synopsis() string

type K8SBootstrapCommand added in v0.6.0 

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

func (*K8SBootstrapCommand) AutocompleteArgs added in v0.6.0 

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

func (*K8SBootstrapCommand) AutocompleteFlags added in v0.6.0 

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

func (K8SBootstrapCommand) Close added in v0.6.0 

func (c K8SBootstrapCommand) Close() error

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

func (K8SBootstrapCommand) DoApp added in v0.6.0 

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

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

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

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

func (*K8SBootstrapCommand) Flags added in v0.6.0 

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

func (*K8SBootstrapCommand) Help added in v0.6.0 

func (c *K8SBootstrapCommand) Help() string

func (K8SBootstrapCommand) Init added in v0.6.0 

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

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

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

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 added in v0.6.0 

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

func (*K8SBootstrapCommand) Synopsis added in v0.6.0 

func (c *K8SBootstrapCommand) Synopsis() string

type LoginCommand added in v0.5.0 

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

func (*LoginCommand) AutocompleteArgs added in v0.5.0 

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

func (*LoginCommand) AutocompleteFlags added in v0.5.0 

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

func (LoginCommand) Close added in v0.5.0 

func (c LoginCommand) Close() error

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

func (LoginCommand) DoApp added in v0.5.0 

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

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

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

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

func (*LoginCommand) Flags added in v0.5.0 

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

func (*LoginCommand) Help added in v0.5.0 

func (c *LoginCommand) Help() string

func (LoginCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*LoginCommand) Synopsis added in v0.5.0 

func (c *LoginCommand) Synopsis() string

type LogsCommand 

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

func (*LogsCommand) AutocompleteArgs 

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

func (*LogsCommand) AutocompleteFlags 

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

func (LogsCommand) Close 

func (c LogsCommand) Close() error

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

func (LogsCommand) DoApp 

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

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

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

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

func (*LogsCommand) Flags 

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

func (*LogsCommand) Help 

func (c *LogsCommand) Help() string

func (LogsCommand) Init 

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

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

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

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 added in v0.5.0 

func WithConnectionArg() Option

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

func WithFlags 

func WithFlags(f *flag.Sets) Option

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

func WithMultiAppTargets added in v0.7.0 

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 added in v0.7.0 

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 added in v0.7.0 

func WithNoLocalServer() Option

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

func WithProjectTarget added in v0.7.0 

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 added in v0.7.0 

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 added in v0.10.0 

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

func (*PipelineInspectCommand) AutocompleteArgs added in v0.10.0 

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

func (*PipelineInspectCommand) AutocompleteFlags added in v0.10.0 

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

func (PipelineInspectCommand) Close added in v0.10.0 

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 added in v0.10.0 

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 added in v0.10.0 

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

func (*PipelineInspectCommand) Help added in v0.10.0 

func (c *PipelineInspectCommand) Help() string

func (PipelineInspectCommand) Init added in v0.10.0 

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 added in v0.10.0 

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

func (*PipelineInspectCommand) Synopsis added in v0.10.0 

func (c *PipelineInspectCommand) Synopsis() string

type PipelineListCommand added in v0.10.0 

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

func (*PipelineListCommand) AutocompleteArgs added in v0.10.0 

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

func (*PipelineListCommand) AutocompleteFlags added in v0.10.0 

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

func (PipelineListCommand) Close added in v0.10.0 

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 added in v0.10.0 

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 added in v0.10.0 

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

func (*PipelineListCommand) Help added in v0.10.0 

func (c *PipelineListCommand) Help() string

func (PipelineListCommand) Init added in v0.10.0 

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 added in v0.10.0 

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

func (*PipelineListCommand) Synopsis added in v0.10.0 

func (c *PipelineListCommand) Synopsis() string

type PipelineRunCommand added in v0.10.0 

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

func (*PipelineRunCommand) AutocompleteArgs added in v0.10.0 

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

func (*PipelineRunCommand) AutocompleteFlags added in v0.10.0 

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

func (PipelineRunCommand) Close added in v0.10.0 

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 added in v0.10.0 

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 added in v0.10.0 

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

func (*PipelineRunCommand) Help added in v0.10.0 

func (c *PipelineRunCommand) Help() string

func (PipelineRunCommand) Init added in v0.10.0 

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 added in v0.10.0 

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

func (*PipelineRunCommand) Synopsis added in v0.10.0 

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 added in v0.4.2 

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

func (*PluginCommand) Help 

func (c *PluginCommand) Help() string

func (PluginCommand) Init 

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

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

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

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 added in v0.3.0 

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

func (*ProjectApplyCommand) AutocompleteArgs added in v0.3.0 

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

func (*ProjectApplyCommand) AutocompleteFlags added in v0.3.0 

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

func (ProjectApplyCommand) Close added in v0.3.0 

func (c ProjectApplyCommand) Close() error

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

func (ProjectApplyCommand) DoApp added in v0.3.0 

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

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

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

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

func (*ProjectApplyCommand) Flags added in v0.3.0 

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

func (*ProjectApplyCommand) Help added in v0.3.0 

func (c *ProjectApplyCommand) Help() string

func (ProjectApplyCommand) Init added in v0.3.0 

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

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

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

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 added in v0.3.0 

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

func (*ProjectApplyCommand) Synopsis added in v0.3.0 

func (c *ProjectApplyCommand) Synopsis() string

type ProjectDestroyCommand added in v0.10.0 

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

func (ProjectDestroyCommand) Close added in v0.10.0 

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 added in v0.10.0 

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 added in v0.10.0 

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

func (*ProjectDestroyCommand) Help added in v0.10.0 

func (c *ProjectDestroyCommand) Help() string

func (ProjectDestroyCommand) Init added in v0.10.0 

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 added in v0.10.0 

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

func (*ProjectDestroyCommand) Synopsis added in v0.10.0 

func (c *ProjectDestroyCommand) Synopsis() string

type ProjectInspectCommand added in v0.5.2 

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

func (*ProjectInspectCommand) AutocompleteArgs added in v0.5.2 

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

func (*ProjectInspectCommand) AutocompleteFlags added in v0.5.2 

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

func (ProjectInspectCommand) Close added in v0.5.2 

func (c ProjectInspectCommand) Close() error

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

func (ProjectInspectCommand) DoApp added in v0.5.2 

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

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

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

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

func (*ProjectInspectCommand) Flags added in v0.5.2 

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

func (*ProjectInspectCommand) FormatProject added in v0.5.2 

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

func (*ProjectInspectCommand) Help added in v0.5.2 

func (c *ProjectInspectCommand) Help() string

func (ProjectInspectCommand) Init added in v0.5.2 

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

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

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

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 added in v0.5.2 

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

func (*ProjectInspectCommand) Synopsis added in v0.5.2 

func (c *ProjectInspectCommand) Synopsis() string

type ProjectListCommand added in v0.3.0 

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

func (*ProjectListCommand) AutocompleteArgs added in v0.3.0 

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

func (*ProjectListCommand) AutocompleteFlags added in v0.3.0 

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

func (ProjectListCommand) Close added in v0.3.0 

func (c ProjectListCommand) Close() error

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

func (ProjectListCommand) DoApp added in v0.3.0 

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

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

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

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

func (*ProjectListCommand) Flags added in v0.3.0 

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

func (*ProjectListCommand) Help added in v0.3.0 

func (c *ProjectListCommand) Help() string

func (ProjectListCommand) Init added in v0.3.0 

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

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

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

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 added in v0.3.0 

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

func (*ProjectListCommand) Synopsis added in v0.3.0 

func (c *ProjectListCommand) Synopsis() string

type ReleaseCreateCommand 

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

func (*ReleaseCreateCommand) AutocompleteArgs 

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

func (*ReleaseCreateCommand) AutocompleteFlags 

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

func (ReleaseCreateCommand) Close 

func (c ReleaseCreateCommand) Close() error

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

func (ReleaseCreateCommand) DoApp 

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

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

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

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

func (*ReleaseCreateCommand) Flags 

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

func (*ReleaseCreateCommand) Help 

func (c *ReleaseCreateCommand) Help() string

func (ReleaseCreateCommand) Init 

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

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

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

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 added in v0.5.2 

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

func (*ReleaseListCommand) AutocompleteArgs added in v0.5.2 

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

func (*ReleaseListCommand) AutocompleteFlags added in v0.5.2 

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

func (ReleaseListCommand) Close added in v0.5.2 

func (c ReleaseListCommand) Close() error

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

func (ReleaseListCommand) DoApp added in v0.5.2 

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

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

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

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

func (*ReleaseListCommand) Flags added in v0.5.2 

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

func (*ReleaseListCommand) Help added in v0.5.2 

func (c *ReleaseListCommand) Help() string

func (ReleaseListCommand) Init added in v0.5.2 

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

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

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

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 added in v0.5.2 

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

func (*ReleaseListCommand) Synopsis added in v0.5.2 

func (c *ReleaseListCommand) Synopsis() string

type RunnerAdoptCommand added in v0.8.0 

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

func (*RunnerAdoptCommand) AutocompleteArgs added in v0.8.0 

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

func (*RunnerAdoptCommand) AutocompleteFlags added in v0.8.0 

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

func (RunnerAdoptCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerAdoptCommand) Help added in v0.8.0 

func (c *RunnerAdoptCommand) Help() string

func (RunnerAdoptCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerAdoptCommand) Synopsis added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerForgetCommand) AutocompleteArgs added in v0.8.0 

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

func (*RunnerForgetCommand) AutocompleteFlags added in v0.8.0 

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

func (RunnerForgetCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerForgetCommand) Help added in v0.8.0 

func (c *RunnerForgetCommand) Help() string

func (RunnerForgetCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerForgetCommand) Synopsis added in v0.8.0 

func (c *RunnerForgetCommand) Synopsis() string

type RunnerInspectCommand added in v0.8.0 

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

func (*RunnerInspectCommand) AutocompleteArgs added in v0.8.0 

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

func (*RunnerInspectCommand) AutocompleteFlags added in v0.8.0 

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

func (RunnerInspectCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerInspectCommand) Help added in v0.8.0 

func (c *RunnerInspectCommand) Help() string

func (RunnerInspectCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerInspectCommand) Synopsis added in v0.8.0 

func (c *RunnerInspectCommand) Synopsis() string

type RunnerInstallCommand added in v0.9.0 

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

func (*RunnerInstallCommand) AutocompleteArgs added in v0.9.0 

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

func (*RunnerInstallCommand) AutocompleteFlags added in v0.9.0 

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

func (RunnerInstallCommand) Close added in v0.9.0 

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 added in v0.9.0 

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 added in v0.9.0 

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

func (*RunnerInstallCommand) Help added in v0.9.0 

func (c *RunnerInstallCommand) Help() string

func (RunnerInstallCommand) Init added in v0.9.0 

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 added in v0.9.0 

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

func (*RunnerInstallCommand) Synopsis added in v0.9.0 

func (c *RunnerInstallCommand) Synopsis() string

type RunnerListCommand added in v0.8.0 

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

func (*RunnerListCommand) AutocompleteArgs added in v0.8.0 

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

func (*RunnerListCommand) AutocompleteFlags added in v0.8.0 

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

func (RunnerListCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerListCommand) Help added in v0.8.0 

func (c *RunnerListCommand) Help() string

func (RunnerListCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerListCommand) Synopsis added in v0.8.0 

func (c *RunnerListCommand) Synopsis() string

type RunnerProfileDeleteCommand added in v0.9.0 

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

func (*RunnerProfileDeleteCommand) AutocompleteArgs added in v0.9.0 

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

func (*RunnerProfileDeleteCommand) AutocompleteFlags added in v0.9.0 

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

func (RunnerProfileDeleteCommand) Close added in v0.9.0 

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 added in v0.9.0 

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 added in v0.9.0 

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

func (*RunnerProfileDeleteCommand) Help added in v0.9.0 

func (c *RunnerProfileDeleteCommand) Help() string

func (RunnerProfileDeleteCommand) Init added in v0.9.0 

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 added in v0.9.0 

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

func (*RunnerProfileDeleteCommand) Synopsis added in v0.9.0 

func (c *RunnerProfileDeleteCommand) Synopsis() string

type RunnerProfileEditCommand added in v0.11.1 

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

func (*RunnerProfileEditCommand) AutocompleteArgs added in v0.11.1 

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

func (*RunnerProfileEditCommand) AutocompleteFlags added in v0.11.1 

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

func (RunnerProfileEditCommand) Close added in v0.11.1 

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 added in v0.11.1 

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 added in v0.11.1 

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

func (*RunnerProfileEditCommand) Help added in v0.11.1 

func (c *RunnerProfileEditCommand) Help() string

func (RunnerProfileEditCommand) Init added in v0.11.1 

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 added in v0.11.1 

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

func (*RunnerProfileEditCommand) Synopsis added in v0.11.1 

func (c *RunnerProfileEditCommand) Synopsis() string

type RunnerProfileInspectCommand added in v0.6.0 

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

func (*RunnerProfileInspectCommand) AutocompleteArgs added in v0.6.0 

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

func (*RunnerProfileInspectCommand) AutocompleteFlags added in v0.6.0 

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

func (RunnerProfileInspectCommand) Close added in v0.6.0 

func (c RunnerProfileInspectCommand) Close() error

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

func (RunnerProfileInspectCommand) DoApp added in v0.6.0 

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

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

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

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

func (*RunnerProfileInspectCommand) Flags added in v0.6.0 

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

func (*RunnerProfileInspectCommand) Help added in v0.6.0 

func (c *RunnerProfileInspectCommand) Help() string

func (RunnerProfileInspectCommand) Init added in v0.6.0 

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

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

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

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 added in v0.6.0 

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

func (*RunnerProfileInspectCommand) Synopsis added in v0.6.0 

func (c *RunnerProfileInspectCommand) Synopsis() string

type RunnerProfileListCommand added in v0.6.0 

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

func (*RunnerProfileListCommand) AutocompleteArgs added in v0.6.0 

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

func (*RunnerProfileListCommand) AutocompleteFlags added in v0.6.0 

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

func (RunnerProfileListCommand) Close added in v0.6.0 

func (c RunnerProfileListCommand) Close() error

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

func (RunnerProfileListCommand) DoApp added in v0.6.0 

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

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

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

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

func (*RunnerProfileListCommand) Flags added in v0.6.0 

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

func (*RunnerProfileListCommand) Help added in v0.6.0 

func (c *RunnerProfileListCommand) Help() string

func (RunnerProfileListCommand) Init added in v0.6.0 

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

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

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

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 added in v0.6.0 

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

func (*RunnerProfileListCommand) Synopsis added in v0.6.0 

func (c *RunnerProfileListCommand) Synopsis() string

type RunnerProfileSetCommand added in v0.6.0 

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

func (*RunnerProfileSetCommand) AutocompleteArgs added in v0.6.0 

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

func (*RunnerProfileSetCommand) AutocompleteFlags added in v0.6.0 

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

func (RunnerProfileSetCommand) Close added in v0.6.0 

func (c RunnerProfileSetCommand) Close() error

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

func (RunnerProfileSetCommand) DoApp added in v0.6.0 

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

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

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

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

func (*RunnerProfileSetCommand) Flags added in v0.6.0 

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

func (*RunnerProfileSetCommand) Help added in v0.6.0 

func (c *RunnerProfileSetCommand) Help() string

func (RunnerProfileSetCommand) Init added in v0.6.0 

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

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

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

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 added in v0.6.0 

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

func (*RunnerProfileSetCommand) Synopsis added in v0.6.0 

func (c *RunnerProfileSetCommand) Synopsis() string

type RunnerRejectCommand added in v0.8.0 

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

func (*RunnerRejectCommand) AutocompleteArgs added in v0.8.0 

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

func (*RunnerRejectCommand) AutocompleteFlags added in v0.8.0 

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

func (RunnerRejectCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerRejectCommand) Help added in v0.8.0 

func (c *RunnerRejectCommand) Help() string

func (RunnerRejectCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerRejectCommand) Synopsis added in v0.8.0 

func (c *RunnerRejectCommand) Synopsis() string

type RunnerTokenCommand added in v0.8.0 

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

func (*RunnerTokenCommand) AutocompleteArgs added in v0.8.0 

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

func (*RunnerTokenCommand) AutocompleteFlags added in v0.8.0 

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

func (RunnerTokenCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerTokenCommand) Help added in v0.8.0 

func (c *RunnerTokenCommand) Help() string

func (RunnerTokenCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*RunnerTokenCommand) Synopsis added in v0.8.0 

func (c *RunnerTokenCommand) Synopsis() string

type RunnerUninstallCommand added in v0.9.0 

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

func (*RunnerUninstallCommand) AutocompleteArgs added in v0.9.0 

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

func (*RunnerUninstallCommand) AutocompleteFlags added in v0.9.0 

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

func (RunnerUninstallCommand) Close added in v0.9.0 

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 added in v0.9.0 

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 added in v0.9.0 

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

func (*RunnerUninstallCommand) Help added in v0.9.0 

func (c *RunnerUninstallCommand) Help() string

func (RunnerUninstallCommand) Init added in v0.9.0 

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 added in v0.9.0 

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

func (*RunnerUninstallCommand) Synopsis added in v0.9.0 

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 added in v0.8.0 

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

func (*ServerCookieCommand) AutocompleteArgs added in v0.8.0 

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

func (*ServerCookieCommand) AutocompleteFlags added in v0.8.0 

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

func (ServerCookieCommand) Close added in v0.8.0 

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 added in v0.8.0 

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 added in v0.8.0 

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

func (*ServerCookieCommand) Help added in v0.8.0 

func (c *ServerCookieCommand) Help() string

func (ServerCookieCommand) Init added in v0.8.0 

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 added in v0.8.0 

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

func (*ServerCookieCommand) Synopsis added in v0.8.0 

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 added in v0.2.1 

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

func (*ServerUpgradeCommand) AutocompleteArgs added in v0.2.1 

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

func (*ServerUpgradeCommand) AutocompleteFlags added in v0.2.1 

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

func (ServerUpgradeCommand) Close added in v0.2.1 

func (c ServerUpgradeCommand) Close() error

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

func (ServerUpgradeCommand) DoApp added in v0.2.1 

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

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

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

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

func (*ServerUpgradeCommand) Flags added in v0.2.1 

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

func (*ServerUpgradeCommand) Help added in v0.2.1 

func (c *ServerUpgradeCommand) Help() string

func (ServerUpgradeCommand) Init added in v0.2.1 

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

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

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

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 added in v0.2.1 

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

func (*ServerUpgradeCommand) Synopsis added in v0.2.1 

func (c *ServerUpgradeCommand) Synopsis() string

type SnapshotBackupCommand added in v0.2.0 

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

func (*SnapshotBackupCommand) AutocompleteArgs added in v0.2.0 

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

func (*SnapshotBackupCommand) AutocompleteFlags added in v0.2.0 

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

func (SnapshotBackupCommand) Close added in v0.2.0 

func (c SnapshotBackupCommand) Close() error

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

func (SnapshotBackupCommand) DoApp added in v0.2.0 

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

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

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

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

func (*SnapshotBackupCommand) Flags added in v0.2.0 

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

func (*SnapshotBackupCommand) Help added in v0.2.0 

func (c *SnapshotBackupCommand) Help() string

func (SnapshotBackupCommand) Init added in v0.2.0 

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

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

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

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 added in v0.2.0 

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

func (*SnapshotBackupCommand) Synopsis added in v0.2.0 

func (c *SnapshotBackupCommand) Synopsis() string

type SnapshotRestoreCommand added in v0.2.0 

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

func (*SnapshotRestoreCommand) AutocompleteArgs added in v0.2.0 

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

func (*SnapshotRestoreCommand) AutocompleteFlags added in v0.2.0 

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

func (SnapshotRestoreCommand) Close added in v0.2.0 

func (c SnapshotRestoreCommand) Close() error

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

func (SnapshotRestoreCommand) DoApp added in v0.2.0 

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

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

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

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

func (*SnapshotRestoreCommand) Flags added in v0.2.0 

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

func (*SnapshotRestoreCommand) Help added in v0.2.0 

func (c *SnapshotRestoreCommand) Help() string

func (SnapshotRestoreCommand) Init added in v0.2.0 

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

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

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

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 added in v0.2.0 

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

func (*SnapshotRestoreCommand) Synopsis added in v0.2.0 

func (c *SnapshotRestoreCommand) Synopsis() string

type StatusCommand added in v0.5.0 

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

func (*StatusCommand) AutocompleteArgs added in v0.5.0 

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

func (*StatusCommand) AutocompleteFlags added in v0.5.0 

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

func (StatusCommand) Close added in v0.5.0 

func (c StatusCommand) Close() error

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

func (StatusCommand) DoApp added in v0.5.0 

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

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

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

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

func (*StatusCommand) Flags added in v0.5.0 

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

func (*StatusCommand) FormatAppStatus added in v0.5.0 

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

func (*StatusCommand) FormatProjectAppStatus added in v0.5.0 

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

FormatProjectAppStatus formats all applications inside a project

func (*StatusCommand) FormatProjectStatus added in v0.5.0 

func (c *StatusCommand) FormatProjectStatus() error

FormatProjectStatus formats all known projects into a table

func (*StatusCommand) FormatStatusReportComplete added in v0.5.0 

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

func (*StatusCommand) Help added in v0.5.0 

func (c *StatusCommand) Help() string

func (StatusCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.2 

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 added in v0.5.0 

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

func (*StatusCommand) Synopsis added in v0.5.0 

func (c *StatusCommand) Synopsis() string

type TaskCancelCommand added in v0.9.0 

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

func (TaskCancelCommand) Close added in v0.9.0 

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 added in v0.9.0 

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 added in v0.9.0 

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

func (*TaskCancelCommand) Help added in v0.9.0 

func (c *TaskCancelCommand) Help() string

func (TaskCancelCommand) Init added in v0.9.0 

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 added in v0.9.0 

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

func (*TaskCancelCommand) Synopsis added in v0.9.0 

func (c *TaskCancelCommand) Synopsis() string

type TaskInspectCommand added in v0.9.0 

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

func (TaskInspectCommand) Close added in v0.9.0 

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 added in v0.9.0 

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 added in v0.9.0 

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

func (*TaskInspectCommand) FormatJob added in v0.9.0 

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 added in v0.9.0 

func (c *TaskInspectCommand) Help() string

func (TaskInspectCommand) Init added in v0.9.0 

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 added in v0.9.0 

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

func (*TaskInspectCommand) Synopsis added in v0.9.0 

func (c *TaskInspectCommand) Synopsis() string

type TaskListCommand added in v0.9.0 

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

func (TaskListCommand) Close added in v0.9.0 

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 added in v0.9.0 

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 added in v0.9.0 

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

func (*TaskListCommand) Help added in v0.9.0 

func (c *TaskListCommand) Help() string

func (TaskListCommand) Init added in v0.9.0 

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 added in v0.9.0 

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

func (*TaskListCommand) Synopsis added in v0.9.0 

func (c *TaskListCommand) Synopsis() string

type TriggerApplyCommand added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerApplyCommand) AutocompleteFlags added in v0.7.0 

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

func (TriggerApplyCommand) Close added in v0.7.0 

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 added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerApplyCommand) Help added in v0.7.0 

func (c *TriggerApplyCommand) Help() string

func (TriggerApplyCommand) Init added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerApplyCommand) Synopsis added in v0.7.0 

func (c *TriggerApplyCommand) Synopsis() string

type TriggerDeleteCommand added in v0.7.0 

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

func (*TriggerDeleteCommand) AutocompleteArgs added in v0.7.0 

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

func (*TriggerDeleteCommand) AutocompleteFlags added in v0.7.0 

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

func (TriggerDeleteCommand) Close added in v0.7.0 

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 added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerDeleteCommand) Help added in v0.7.0 

func (c *TriggerDeleteCommand) Help() string

func (TriggerDeleteCommand) Init added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerDeleteCommand) Synopsis added in v0.7.0 

func (c *TriggerDeleteCommand) Synopsis() string

type TriggerInspectCommand added in v0.7.0 

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

func (*TriggerInspectCommand) AutocompleteArgs added in v0.7.0 

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

func (*TriggerInspectCommand) AutocompleteFlags added in v0.7.0 

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

func (TriggerInspectCommand) Close added in v0.7.0 

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 added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerInspectCommand) Help added in v0.7.0 

func (c *TriggerInspectCommand) Help() string

func (TriggerInspectCommand) Init added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerInspectCommand) Synopsis added in v0.7.0 

func (c *TriggerInspectCommand) Synopsis() string

type TriggerListCommand added in v0.7.0 

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

func (*TriggerListCommand) AutocompleteArgs added in v0.7.0 

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

func (*TriggerListCommand) AutocompleteFlags added in v0.7.0 

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

func (TriggerListCommand) Close added in v0.7.0 

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 added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerListCommand) Help added in v0.7.0 

func (c *TriggerListCommand) Help() string

func (TriggerListCommand) Init added in v0.7.0 

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 added in v0.7.0 

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

func (*TriggerListCommand) Synopsis added in v0.7.0 

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 added in v0.2.1 

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

func (*UninstallCommand) AutocompleteArgs added in v0.2.1 

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

func (*UninstallCommand) AutocompleteFlags added in v0.2.1 

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

func (UninstallCommand) Close added in v0.2.1 

func (c UninstallCommand) Close() error

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

func (UninstallCommand) DoApp added in v0.2.1 

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

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

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

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

func (*UninstallCommand) Flags added in v0.2.1 

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

func (*UninstallCommand) Help added in v0.2.1 

func (c *UninstallCommand) Help() string

func (UninstallCommand) Init added in v0.2.1 

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

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

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

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 added in v0.2.1 

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

func (*UninstallCommand) Synopsis added in v0.2.1 

func (c *UninstallCommand) Synopsis() string

type UpCommand 

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

func (UpCommand) Close 

func (c UpCommand) Close() error

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

func (UpCommand) DoApp 

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

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

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

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

func (*UpCommand) Flags 

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

func (*UpCommand) Help 

func (c *UpCommand) Help() string

func (UpCommand) Init 

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

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

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

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 added in v0.5.0 

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

func (*UserInspectCommand) AutocompleteArgs added in v0.5.0 

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

func (*UserInspectCommand) AutocompleteFlags added in v0.5.0 

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

func (UserInspectCommand) Close added in v0.5.0 

func (c UserInspectCommand) Close() error

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

func (UserInspectCommand) DoApp added in v0.5.0 

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

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

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

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

func (*UserInspectCommand) Flags added in v0.5.0 

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

func (*UserInspectCommand) Help added in v0.5.0 

func (c *UserInspectCommand) Help() string

func (UserInspectCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*UserInspectCommand) Synopsis added in v0.5.0 

func (c *UserInspectCommand) Synopsis() string

type UserInviteCommand added in v0.5.0 

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

func (*UserInviteCommand) AutocompleteArgs added in v0.5.0 

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

func (*UserInviteCommand) AutocompleteFlags added in v0.5.0 

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

func (UserInviteCommand) Close added in v0.5.0 

func (c UserInviteCommand) Close() error

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

func (UserInviteCommand) DoApp added in v0.5.0 

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

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

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

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

func (*UserInviteCommand) Flags added in v0.5.0 

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

func (*UserInviteCommand) Help added in v0.5.0 

func (c *UserInviteCommand) Help() string

func (UserInviteCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*UserInviteCommand) Synopsis added in v0.5.0 

func (c *UserInviteCommand) Synopsis() string

type UserModifyCommand added in v0.5.0 

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

func (*UserModifyCommand) AutocompleteArgs added in v0.5.0 

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

func (*UserModifyCommand) AutocompleteFlags added in v0.5.0 

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

func (UserModifyCommand) Close added in v0.5.0 

func (c UserModifyCommand) Close() error

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

func (UserModifyCommand) DoApp added in v0.5.0 

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

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

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

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

func (*UserModifyCommand) Flags added in v0.5.0 

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

func (*UserModifyCommand) Help added in v0.5.0 

func (c *UserModifyCommand) Help() string

func (UserModifyCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*UserModifyCommand) Synopsis added in v0.5.0 

func (c *UserModifyCommand) Synopsis() string

type UserTokenCommand added in v0.5.0 

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

func (*UserTokenCommand) AutocompleteArgs added in v0.5.0 

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

func (*UserTokenCommand) AutocompleteFlags added in v0.5.0 

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

func (UserTokenCommand) Close added in v0.5.0 

func (c UserTokenCommand) Close() error

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

func (UserTokenCommand) DoApp added in v0.5.0 

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

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

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

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

func (*UserTokenCommand) Flags added in v0.5.0 

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

func (*UserTokenCommand) Help added in v0.5.0 

func (c *UserTokenCommand) Help() string

func (UserTokenCommand) Init added in v0.5.0 

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

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

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

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 added in v0.5.0 

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

func (*UserTokenCommand) Synopsis added in v0.5.0 

func (c *UserTokenCommand) Synopsis() string

type VersionCommand 

type VersionCommand struct {
	VersionInfo *version.VersionInfo
	// contains filtered or unexported fields
}

func (*VersionCommand) AutocompleteArgs 

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

func (*VersionCommand) AutocompleteFlags 

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

func (VersionCommand) Close 

func (c VersionCommand) Close() error

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

func (VersionCommand) DoApp 

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

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

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

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

func (*VersionCommand) Flags 

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

func (*VersionCommand) Help 

func (c *VersionCommand) Help() string

func (VersionCommand) Init 

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

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

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

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 added in v0.7.0 

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

func (*WorkspaceCreateCommand) AutocompleteArgs added in v0.7.0 

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

func (*WorkspaceCreateCommand) AutocompleteFlags added in v0.7.0 

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

func (WorkspaceCreateCommand) Close added in v0.7.0 

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 added in v0.7.0 

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 added in v0.7.0 

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

func (*WorkspaceCreateCommand) Help added in v0.7.0 

func (c *WorkspaceCreateCommand) Help() string

func (WorkspaceCreateCommand) Init added in v0.7.0 

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 added in v0.7.0 

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

func (*WorkspaceCreateCommand) Synopsis added in v0.7.0 

func (c *WorkspaceCreateCommand) Synopsis() string

type WorkspaceInspectCommand added in v0.6.0 

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

func (*WorkspaceInspectCommand) AutocompleteArgs added in v0.6.0 

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

func (*WorkspaceInspectCommand) AutocompleteFlags added in v0.6.0 

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

func (WorkspaceInspectCommand) Close added in v0.6.0 

func (c WorkspaceInspectCommand) Close() error

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

func (WorkspaceInspectCommand) DoApp added in v0.6.0 

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

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

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

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

func (*WorkspaceInspectCommand) Flags added in v0.6.0 

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

func (*WorkspaceInspectCommand) Help added in v0.6.0 

func (c *WorkspaceInspectCommand) Help() string

func (WorkspaceInspectCommand) Init added in v0.6.0 

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

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

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

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 added in v0.6.0 

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

func (*WorkspaceInspectCommand) Synopsis added in v0.6.0 

func (c *WorkspaceInspectCommand) Synopsis() string

type WorkspaceListCommand added in v0.6.0 

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

func (*WorkspaceListCommand) AutocompleteArgs added in v0.6.0 

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

func (*WorkspaceListCommand) AutocompleteFlags added in v0.6.0 

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

func (WorkspaceListCommand) Close added in v0.6.0 

func (c WorkspaceListCommand) Close() error

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

func (WorkspaceListCommand) DoApp added in v0.6.0 

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

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

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

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

func (*WorkspaceListCommand) Flags added in v0.6.0 

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

func (*WorkspaceListCommand) Help added in v0.6.0 

func (c *WorkspaceListCommand) Help() string

func (WorkspaceListCommand) Init added in v0.6.0 

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

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

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

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 added in v0.6.0 

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

func (*WorkspaceListCommand) Synopsis added in v0.6.0 

func (c *WorkspaceListCommand) Synopsis() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.