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.