mirror of
https://github.com/hashicorp/packer.git
synced 2026-02-28 04:21:10 -05:00
bb2384c56a
When packer validate is invoked, it does not try to evaluate the datasources before attempting to decide if the template is valid. In many cases, this works, but sometimes it will fail as the value is unknown by the validation code. Since the validation code for all the elements of a Packer template is left to be implemented by plugins, we cannot rely on checking for unknown values everywhere, especially since the unknown references are replaced automatically by a value of the right type for the configuration expected. So, in order for such configurations to be validable, we add an extra option to packer validate, that will let users evaluate the datasources from a template.
133 lines
3.4 KiB
Go
133 lines
3.4 KiB
Go
package command
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/packer/packer"
|
|
|
|
"github.com/posener/complete"
|
|
)
|
|
|
|
type ValidateCommand struct {
|
|
Meta
|
|
}
|
|
|
|
func (c *ValidateCommand) Run(args []string) int {
|
|
ctx, cleanup := handleTermInterrupt(c.Ui)
|
|
defer cleanup()
|
|
|
|
cfg, ret := c.ParseArgs(args)
|
|
if ret != 0 {
|
|
return ret
|
|
}
|
|
|
|
return c.RunContext(ctx, cfg)
|
|
}
|
|
|
|
func (c *ValidateCommand) ParseArgs(args []string) (*ValidateArgs, int) {
|
|
var cfg ValidateArgs
|
|
|
|
flags := c.Meta.FlagSet("validate", FlagSetBuildFilter|FlagSetVars)
|
|
flags.Usage = func() { c.Ui.Say(c.Help()) }
|
|
cfg.AddFlagSets(flags)
|
|
if err := flags.Parse(args); err != nil {
|
|
return &cfg, 1
|
|
}
|
|
|
|
args = flags.Args()
|
|
if len(args) != 1 {
|
|
flags.Usage()
|
|
return &cfg, 1
|
|
}
|
|
cfg.Path = args[0]
|
|
return &cfg, 0
|
|
}
|
|
|
|
func (c *ValidateCommand) RunContext(ctx context.Context, cla *ValidateArgs) int {
|
|
// By default we want to inform users of undeclared variables when validating but not during build time.
|
|
cla.MetaArgs.WarnOnUndeclaredVar = true
|
|
if cla.NoWarnUndeclaredVar {
|
|
cla.MetaArgs.WarnOnUndeclaredVar = false
|
|
}
|
|
|
|
packerStarter, ret := c.GetConfig(&cla.MetaArgs)
|
|
if ret != 0 {
|
|
return 1
|
|
}
|
|
|
|
// If we're only checking syntax, then we're done already
|
|
if cla.SyntaxOnly {
|
|
c.Ui.Say("Syntax-only check passed. Everything looks okay.")
|
|
return 0
|
|
}
|
|
|
|
diags := packerStarter.Initialize(packer.InitializeOptions{
|
|
SkipDatasourcesExecution: !cla.EvaluateDatasources,
|
|
})
|
|
ret = writeDiags(c.Ui, nil, diags)
|
|
if ret != 0 {
|
|
return ret
|
|
}
|
|
|
|
_, _, diags = packerStarter.GetBuilds(packer.GetBuildsOptions{
|
|
Only: cla.Only,
|
|
Except: cla.Except,
|
|
})
|
|
|
|
fixerDiags := packerStarter.FixConfig(packer.FixConfigOptions{
|
|
Mode: packer.Diff,
|
|
})
|
|
diags = append(diags, fixerDiags...)
|
|
|
|
ret = writeDiags(c.Ui, nil, diags)
|
|
if ret == 0 {
|
|
c.Ui.Say("The configuration is valid.")
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
func (*ValidateCommand) Help() string {
|
|
helpText := `
|
|
Usage: packer validate [options] TEMPLATE
|
|
|
|
Checks the template is valid by parsing the template and also
|
|
checking the configuration with the various builders, provisioners, etc.
|
|
|
|
If it is not valid, the errors will be shown and the command will exit
|
|
with a non-zero exit status. If it is valid, it will exit with a zero
|
|
exit status.
|
|
|
|
Options:
|
|
|
|
-syntax-only Only check syntax. Do not verify config of the template.
|
|
-except=foo,bar,baz Validate all builds other than these.
|
|
-only=foo,bar,baz Validate only these builds.
|
|
-machine-readable Produce machine-readable output.
|
|
-var 'key=value' Variable for templates, can be used multiple times.
|
|
-var-file=path JSON or HCL2 file containing user variables, can be used multiple times.
|
|
-no-warn-undeclared-var Disable warnings for user variable files containing undeclared variables.
|
|
`
|
|
|
|
return strings.TrimSpace(helpText)
|
|
}
|
|
|
|
func (*ValidateCommand) Synopsis() string {
|
|
return "check that a template is valid"
|
|
}
|
|
|
|
func (*ValidateCommand) AutocompleteArgs() complete.Predictor {
|
|
return complete.PredictNothing
|
|
}
|
|
|
|
func (*ValidateCommand) AutocompleteFlags() complete.Flags {
|
|
return complete.Flags{
|
|
"-syntax-only": complete.PredictNothing,
|
|
"-except": complete.PredictNothing,
|
|
"-only": complete.PredictNothing,
|
|
"-var": complete.PredictNothing,
|
|
"-machine-readable": complete.PredictNothing,
|
|
"-var-file": complete.PredictNothing,
|
|
}
|
|
}
|