cmd

Documentation

Overview

Package cmd contains all the main commands for the `geneos` program

Index

• Constants
• Variables
• func AddInstance(ct *geneos.Component, addCmdExtras instance.SetConfigValues, items []string, ...) (err error)
• func CommandPS(ct *geneos.Component, names []string, params []string)
• func Execute()
• func ImportFiles(ct *geneos.Component, args []string, sources []string) (err error)
• func ParseArgs(command *cobra.Command, args []string) (err error)
• func ParseTypeNames(command *cobra.Command) (ct *geneos.Component, args []string)
• func ParseTypeNamesParams(command *cobra.Command) (ct *geneos.Component, args, params []string)
• func ReloadInstance(i geneos.Instance, _ ...any) (resp *instance.Response)
• func RunE(root *cobra.Command, path []string, args []string) (err error)
• func Set(ct *geneos.Component, args, params []string) (err error)
• func Start(ct *geneos.Component, watchlogs bool, autostart bool, names []string, ...) (err error)

Constants

const (
	CommandGroupConfig      = "config"
	CommandGroupComponents  = "components"
	CommandGroupCredentials = "credentials"
	CommandGroupManage      = "manage"
	CommandGroupOther       = "other"
	CommandGroupProcess     = "process"
	CommandGroupSubsystems  = "subsystems"
	CommandGroupView        = "view"
)

Available command groups for Cobra command set-up. This influences the display of the help text for the top-level `geneos` command.

const (
	AnnotationAliasFor   = "aliasfor"     // mapping alias
	AnnotationComponent  = "ct"           // specific component name
	AnnotationNames      = "names"        // json encoded array of instance names
	AnnotationNeedsHome  = "needshomedir" // "true" or "false"
	AnnotationParams     = "params"       // json encoded array of parameters
	AnnotationReplacedBy = "replacedby"   // deprecated command alias
	AnnotationWildcard   = "wildcard"     // "true", "false" or "explicit" (to match "all")
	AnnotationExpand     = "expand"       // "true" or "false" - pass all names through a path.Match style lookup
)

Annotation types for command behaviour

Variables

var DefaultUserKeyfile = config.KeyFile(
	config.Path("keyfile",
		config.SetAppName(Execname),
		config.SetFileExtension("aes"),
		config.IgnoreWorkingDir()),
)

DefaultUserKeyfile is the path to the user's key file as a config.Keyfile type

var Execname = execname

Execname is the basename, without extension, of the underlying binary used to start the program. The initialising routines evaluate symlinks etc.

initialise to sensible default

var GeneosCmd = &cobra.Command{
	Use:   Execname + " COMMAND [flags] [TYPE] [NAME...] [parameters...]",
	Short: "Take control of your Geneos environments",
	Long:  geneosCmdDescription,
	Example: strings.ReplaceAll(`
geneos init demo -u email@example.com -l
geneos ps
geneos restart
`, "|", "`"),

	Annotations: map[string]string{
		AnnotationNeedsHome: "true",
	},
	CompletionOptions: cobra.CompletionOptions{
		DisableDefaultCmd: true,
	},
	Version:               cordial.VERSION,
	DisableAutoGenTag:     true,
	DisableSuggestions:    true,
	DisableFlagsInUseLine: true,

	PersistentPreRunE: func(command *cobra.Command, args []string) (err error) {

		command.Root().ParseFlags(args)

		if command.Annotations[AnnotationWildcard] == "explicit" {
			rootargs := command.Root().Flags().Args()
			if len(rootargs) == 0 {
				return fmt.Errorf("%w: %q requires at least TYPE or one or more NAME arguments", geneos.ErrInvalidArgs, command.Name())
			}
		}

		// check for AnnotationReplacedBy annotation, warn the user, run the new
		// command later (after prerun) but if the help flag is set
		// output the help for the new command and cleanly exit.
		var realcmd *cobra.Command

		if r, ok := command.Annotations[AnnotationReplacedBy]; ok {
			var newargs []string
			realcmd, newargs, err = command.Root().Find(append(strings.Split(r, " "), args...))
			if err != nil {
				log.Fatal().Err(err).Msg("")
			}
			if realcmd != nil {
				fmt.Printf("*** Please note that the %q command has been replaced by %q\n\n", command.CommandPath(), realcmd.CommandPath())
				command.RunE = func(cmd *cobra.Command, args []string) error {
					realcmd.ParseFlags(newargs)
					ParseArgs(realcmd, newargs)
					return realcmd.RunE(realcmd, realcmd.Flags().Args())
				}
			}
		}

		if r, ok := command.Annotations[AnnotationReplacedBy]; ok {
			var newargs []string
			realcmd, newargs, err = command.Root().Find(append(strings.Split(r, " "), args...))
			if err != nil {
				log.Fatal().Err(err).Msg("")
			}
			if realcmd != nil {
				command.RunE = func(cmd *cobra.Command, args []string) error {
					realcmd.ParseFlags(newargs)
					ParseArgs(realcmd, newargs)
					return realcmd.RunE(realcmd, realcmd.Flags().Args())
				}
			}
		}

		if realcmd != nil {
			if t, _ := command.Flags().GetBool("help"); t {
				command.RunE = nil

				command.Run = func(cmd *cobra.Command, args []string) {
					realcmd.Usage()
				}
				return nil
			}
		}

		if t, _ := command.Flags().GetBool("help"); t {
			command.RunE = nil

			command.Run = func(cmd *cobra.Command, args []string) {
				command.Usage()
			}
			return nil
		}

		if geneos.LocalRoot() == "" && len(geneos.RemoteHosts(false)) == 0 {
			if command.Annotations[AnnotationNeedsHome] == "true" {
				command.SetUsageTemplate(" ")
				return GeneosUnsetError
			}
		}
		if command.Name() == "help" {

			return nil
		}

		return ParseArgs(command, args)
	},
}

GeneosCmd represents the base command when called without any subcommands

var GeneosUnsetError = errors.New(strings.ReplaceAll(`Geneos location not set.

You can do one of the following:
* Run |geneos config set geneos=/PATH| (where |/PATH| is the location of the Geneos installation)
* Run |geneos init| or |geneos init /PATH| to initialise an installation
  * There are also variations on the |init| command, please see help for the command
* Set the |GENEOS_HOME| or |ITRS_HOME| environment variables, either once or in your |.profile|:
  * |export GENEOS_HOME=/PATH|

`, "|", "`"))

var Hostname string

Hostname is the cmd package global host selected ny the `--host`/`-H` option

var RunPlaceholder = func(command *cobra.Command, args []string) {}

RunPlaceholder is an empty function for commands that have to run but no do anything

Used to allow PersistentPreRun to check for aliases for legacy commands

var UserKeyFile config.KeyFile

UserKeyFile is the path to the user's key file. It starts as DefaultUserKeyFile but can be changed.

Functions

func AddInstance

func AddInstance(ct *geneos.Component, addCmdExtras instance.SetConfigValues, items []string, names ...string) (err error)

AddInstance add an instance of component type ct the the optional extra configuration values addCmdExtras

func CommandPS

func CommandPS(ct *geneos.Component, names []string, params []string)

CommandPS writes running instance information to STDOUT

XXX relies on global flags

func Execute

func Execute()

Execute adds all child commands to the root command and sets flags appropriately. This is called by main.main(). It only needs to happen once to the RootCmd.

func ImportFiles

func ImportFiles(ct *geneos.Component, args []string, sources []string) (err error)

ImportFiles add a file to an instance, from local or URL overwrites without asking - use case is license files, setup files etc. backup / history track older files (date/time?) no restart or reload of components?

func ParseArgs

func ParseArgs(command *cobra.Command, args []string) (err error)

ParseArgs does the heavy lifting of sorting out non-flag command line ares for the various commands.

given a list of args (after command has been seen), check if first arg is a component type and de-dup the names. A name of "all" will will override the rest and result in a lookup being done

args with an '=' should be checked and only allowed if there are names?

support glob style wildcards for instance names - allow through, let loopCommand* deal with them

process command args in a standard way flags will have been handled by another function before this one any args with '=' are treated as parameters

a bare argument with a '@' prefix means all instance of type on a host

func ParseTypeNames

func ParseTypeNames(command *cobra.Command) (ct *geneos.Component, args []string)

ParseTypeNames parses the ct, args and params set by ParseArgs in a Pre run and returns the ct and a slice of names. Parameters are ignored.

func ParseTypeNamesParams

func ParseTypeNamesParams(command *cobra.Command) (ct *geneos.Component, args, params []string)

ParseTypeNamesParams parses the ct, args and params set by ParseArgs in a Pre run and returns the ct and a slice of names and a slice of params.

func ReloadInstance

func ReloadInstance(i geneos.Instance, _ ...any) (resp *instance.Response)

func RunE

func RunE(root *cobra.Command, path []string, args []string) (err error)

RunE runs a command in a sub-package to avoid import loops. It is named to align with the cobra struct member of the same name.

The caller must have:

DisableFlagParsing: true,

set in their command struct for flags to work. Then hook this function like this in the command struct:

RunE: func(command *cobra.Command, args []string) (err error) {
     return RunE(command.Root(), []string{"host", "ls"}, args)
},

func Set

func Set(ct *geneos.Component, args, params []string) (err error)

func Start

func Start(ct *geneos.Component, watchlogs bool, autostart bool, names []string, params []string) (err error)

Start is a single entrypoint for multiple commands to start instances. ct is the component type, nil means all. watchlogs is a flag to, well, watch logs while autostart is a flag to indicate if Start() is being called as part of a group of instances - this is for use by autostart checking.