143 lines
3.7 KiB
Go
143 lines
3.7 KiB
Go
package command
|
|
|
|
import (
|
|
"bufio"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
|
|
kvflag "github.com/hashicorp/packer/helper/flag-kv"
|
|
sliceflag "github.com/hashicorp/packer/helper/flag-slice"
|
|
"github.com/hashicorp/packer/packer"
|
|
"github.com/hashicorp/packer/template"
|
|
)
|
|
|
|
// FlagSetFlags is an enum to define what flags are present in the
|
|
// default FlagSet returned by Meta.FlagSet
|
|
type FlagSetFlags uint
|
|
|
|
const (
|
|
FlagSetNone FlagSetFlags = 0
|
|
FlagSetBuildFilter FlagSetFlags = 1 << iota
|
|
FlagSetVars
|
|
)
|
|
|
|
// Meta contains the meta-options and functionality that nearly every
|
|
// Packer command inherits.
|
|
type Meta struct {
|
|
CoreConfig *packer.CoreConfig
|
|
Ui packer.Ui
|
|
Version string
|
|
|
|
// These are set by command-line flags
|
|
flagVars map[string]string
|
|
}
|
|
|
|
// Core returns the core for the given template given the configured
|
|
// CoreConfig and user variables on this Meta.
|
|
func (m *Meta) Core(tpl *template.Template) (*packer.Core, error) {
|
|
// Copy the config so we don't modify it
|
|
config := *m.CoreConfig
|
|
config.Template = tpl
|
|
config.Variables = m.flagVars
|
|
|
|
// Init the core
|
|
core, err := packer.NewCore(&config)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Error initializing core: %s", err)
|
|
}
|
|
|
|
return core, nil
|
|
}
|
|
|
|
// BuildNames returns the list of builds that are in the given core
|
|
// that we care about taking into account the only and except flags.
|
|
func (m *Meta) BuildNames(c *packer.Core) []string {
|
|
// TODO: test
|
|
|
|
// Filter the "only"
|
|
if len(m.CoreConfig.Only) > 0 {
|
|
// Build a set of all the available names
|
|
nameSet := make(map[string]struct{})
|
|
for _, n := range c.BuildNames() {
|
|
nameSet[n] = struct{}{}
|
|
}
|
|
|
|
// Build our result set which we pre-allocate some sane number
|
|
result := make([]string, 0, len(m.CoreConfig.Only))
|
|
for _, n := range m.CoreConfig.Only {
|
|
if _, ok := nameSet[n]; ok {
|
|
result = append(result, n)
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// Filter the "except"
|
|
if len(m.CoreConfig.Except) > 0 {
|
|
// Build a set of the things we don't want
|
|
nameSet := make(map[string]struct{})
|
|
for _, n := range m.CoreConfig.Except {
|
|
nameSet[n] = struct{}{}
|
|
}
|
|
|
|
// Build our result set which is the names of all builds except
|
|
// those in the given set.
|
|
names := c.BuildNames()
|
|
result := make([]string, 0, len(names))
|
|
for _, n := range names {
|
|
if _, ok := nameSet[n]; !ok {
|
|
result = append(result, n)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// We care about everything
|
|
return c.BuildNames()
|
|
}
|
|
|
|
// FlagSet returns a FlagSet with the common flags that every
|
|
// command implements. The exact behavior of FlagSet can be configured
|
|
// using the flags as the second parameter, for example to disable
|
|
// build settings on the commands that don't handle builds.
|
|
func (m *Meta) FlagSet(n string, fs FlagSetFlags) *flag.FlagSet {
|
|
f := flag.NewFlagSet(n, flag.ContinueOnError)
|
|
|
|
// FlagSetBuildFilter tells us to enable the settings for selecting
|
|
// builds we care about.
|
|
if fs&FlagSetBuildFilter != 0 {
|
|
f.Var((*sliceflag.StringFlag)(&m.CoreConfig.Except), "except", "")
|
|
f.Var((*sliceflag.StringFlag)(&m.CoreConfig.Only), "only", "")
|
|
}
|
|
|
|
// FlagSetVars tells us what variables to use
|
|
if fs&FlagSetVars != 0 {
|
|
f.Var((*kvflag.Flag)(&m.flagVars), "var", "")
|
|
f.Var((*kvflag.FlagJSON)(&m.flagVars), "var-file", "")
|
|
}
|
|
|
|
// Create an io.Writer that writes to our Ui properly for errors.
|
|
// This is kind of a hack, but it does the job. Basically: create
|
|
// a pipe, use a scanner to break it into lines, and output each line
|
|
// to the UI. Do this forever.
|
|
errR, errW := io.Pipe()
|
|
errScanner := bufio.NewScanner(errR)
|
|
go func() {
|
|
for errScanner.Scan() {
|
|
m.Ui.Error(errScanner.Text())
|
|
}
|
|
}()
|
|
f.SetOutput(errW)
|
|
|
|
return f
|
|
}
|
|
|
|
// ValidateFlags should be called after parsing flags to validate the
|
|
// given flags
|
|
func (m *Meta) ValidateFlags() error {
|
|
// TODO
|
|
return nil
|
|
}
|