How to use sources from config file that was set via flag?

[plandem]

Hi

Sadly, I cant find how to implement this simple setup:

sources := cli.NewValueSourceChain()
app := &cli.Command{
		EnableShellCompletion:  true,
		UseShortOptionHandling: true,
		Before: func(ctx context.Context, cmd *cli.Command) (context.Context, error) {
			config := cmd.String("config")
			if len(config) > 0 {
				configFile := fmt.Sprintf("%s.yaml", cmd.String("config"))
				if _, err := os.Stat(configFile); os.IsNotExist(err) {
					return ctx, fmt.Errorf("could not load config file: %s", configFile)
				}

				sources.Append(cli.Files(configFile))
				return ctx, nil
			}

			return ctx, nil
		},
		OnUsageError: func(ctx context.Context, cmd *cli.Command, err error, isSubcommand bool) error {
			os.Exit(1)
			return err
		},
		ShellComplete: func(ctx context.Context, cmd *cli.Command) {
			fmt.Fprintf(cmd.Root().Writer, "check\nnotify\nvalidate\n")
		},
		Flags: []cli.Flag{
			&cli.StringFlag{
				Name:    "config",
				Aliases: []string{"c"},
				Usage:   "Load configuration from `FILE`",
			},
		},
		Commands: []*cli.Command{
			{
				Name:   "notify",
				Usage:  "Notify Telegram about updates",
				Flags:  []cli.Flag{
					&cli.StringFlag{
						Name:     "token",
						Required: true,
						Usage:    "`TOKEN` of Telegram's bot",
						//Sources:  altsrc.YAML("notify.telegram-chat", ???), // how to use sources/files from 'Before'?
					},
					&cli.StringFlag{
						Name:     "chat",
						Required: true,
						Usage:    "`ID` of Telegram's chat to send updates",
						//Sources:  altsrc.YAML("notify.telegram-chat", ???),  // how to use sources/files from 'Before'?
					},
				}
				Action: notify.Telegram,
			},

Setup is quite typical, tbh - provide custom config file and use values from it. But from docs, it looks like it may work only with hardcoded names? Any direction? Ofc, I could hack around to get config's file outside from the cli package, but I feel that could miss something and there is a built-in way to achieve it.

Can anybody point me to what direction should I look?

P.S.: v3 of cli

[dearchap]

Yeah it won't work since the sources are evaluated prior to parsing flags. I think this is a case where #1273 would have helped. If you have any suggestions feel free to throw them out way

[dearchap]

What makes you think it is not lazy loaded right now ? These env sources are fetched only when they their associated flag is going to be applied to a flagset prior to parsing . The issue here is say you have an env source for flag foo that depends on another flag (bar say) value and you type the following at the cmdline

'''
--foo something --bar filename
'''

How would you lazy load sources in this case ?

[plandem]

ok, maybe "not lazy loaded" was wrong wording, but what I meant by that:

func YAML(key string, paths ...string) cli.ValueSourceChain {
	vsc := cli.ValueSourceChain{Chain: []cli.ValueSource{}}

	for _, path := range paths {
		vsc.Chain = append(
			vsc.Chain,
			&yamlValueSource{
				file: path,
				key:  key,
				maafsc: mapAnyAnyFileSourceCache{
					file: path,
					f:    yamlUnmarshalFile,
				},
			},
		)
	}

	return vsc
}

This part is not very suitable to be really lazy loaded. Ofc, you do not load values in place, but at the same time, asking for real values (files). By real lazy loading, I mean that no value will be evaluated until its "called".

How would you lazy load sources in this case ?

Ok, I should admit that I'm a new user of this library and could miss some specific of library, but...why dont follow the "cobra/viper" way? Load files and later (when time for specific flag will come) "bind" values.

[plandem]

or if func YAML(key string, paths ...string) would accept, e.g. callbacks instead of names of real files, this could solve probably. We could use something like this:

&cli.StringFlag{
	Name:     "chat",
	Required: true,
	Usage:    "`ID` of Telegram's chat to send updates",
	Sources:  cli.NewValueSourceChain(
		cli.EnvVars("APP_LANG"),
		altsrc.YAML("notify.telegram-chat", func(cmd *cli.Command) string {
			return cmd.String("config")
		}), 
	),
},

[yoo]

Another possibility would be to use pointers. And another point is how to ensure that one flag is parsed before another one. In the order they are defined? Or make the priority explicit.

&cli.StringFlag{
	Name:     "config",
        Priority:   0,
	Usage:    "Config file path",
        Destination: &configFile
},

&cli.StringFlag{
	Name:     "chat",
        Priority:   5 // maybe the default?
	Usage:    "`ID` of Telegram's chat to send updates",
	Sources:  cli.NewValueSourceChain(
		cli.EnvVars("APP_LANG"),
		altsrc.YAML("notify.telegram-chat", &configFile)
	),
},

[dearchap]

Priority parsing makes it more complicated. The PR that I have does away with ordering so you can define flags in any order without issues. The value source needs some customization to be able to have a pointer to value

[mrueg]

I came across this issue when working on a v2 -> v3 migration.
I had a working solution in v2 which allowed me to parse the config value before and then use it to parse the file for further arguments: https://github.com/kovetskiy/mark/blob/master/main.go#L25-L38

Is this not possible with v3 anymore?

[dearchap]

Not directly as in v2 but we have hooks to do this. I was going to put it in the docs but I'm out of town couple of days

[mrueg]

Do you mean using the Before() and After() hooks? An example how this works would be really helpful. :)

[jvilhuber]

Ditto. I could use an example or guidance how to duplicate this behavior which I rely on in v2 for v3.

[jvilhuber]

Ideally, I don't want to have to sprinkle YAML and JSON all over the place. I pull in sub-structs into a larger config struct, and have each sub-struct provide its list or (nested) cli.Flags[]. I thought it was already lots of work to ensure EVERY FLAG had an altsrc.NewStringFlag (etc) wrapped around it, but now I need to add specific 'YAML' and 'JSON' (and whatever else) sources to every cli.Flag, which is even worse.

I just want to be able to load a config file (yaml, json, toml, whatever) and then have urfave/cli use the resulting data regardless of type (yaml, json, whatever). I kind of had this working in v2 with Before functions.

[mikew]

What about if ValueSource.Lookup took the same context/command arguments as FlagBase.Action? I have an adjacent problem where I need to lookup a YAML key based off a positional argument that I think could be solved by that:

type ComplexValueSourceLookup struct {
	key string
}

func (c ComplexValueSourceLookup) String() string {
	return fmt.Sprintf("yaml-path(%s)", c.key)
}

func (c ComplexValueSourceLookup) GoString() string {
	return fmt.Sprintf("&ComplexYamlPath{key:%q}", c.key)
}

func (c ComplexValueSourceLookup) Lookup(ctx context.Context, cmd *cli.Command) (string, bool) {
	endpoint, err := ssh_endpoint.ParseSshEndpoint(cmd.Args().Get(0))
	if err != nil {
		return "", false
	}

	cfg, err := nvrh_config.LoadConfig(nvrh_config.DefaultConfigPath())
	if err != nil {
		return "", false
	}

	serverConfig := cfg.Servers[endpoint.GivenHost]
	value = lookup(c.key, serverConfig)

	if value == "" {
		return "", false
	}

	return value, true
}

//

cli.NewValueSourceChain(ComplexValueSourceLookup{key: "foo.bar"})