// The packer package contains the core components of Packer. package packer import ( "errors" "fmt" "log" "os" "sort" "strings" ) // The function type used to lookup Builder implementations. type BuilderFunc func(name string) (Builder, error) // The function type used to lookup Command implementations. type CommandFunc func(name string) (Command, error) // The function type used to lookup Hook implementations. type HookFunc func(name string) (Hook, error) // The function type used to lookup Provisioner implementations. type ProvisionerFunc func(name string) (Provisioner, error) // ComponentFinder is a struct that contains the various function // pointers necessary to look up components of Packer such as builders, // commands, etc. type ComponentFinder struct { Builder BuilderFunc Command CommandFunc Hook HookFunc Provisioner ProvisionerFunc } // The environment interface provides access to the configuration and // state of a single Packer run. // // It allows for things such as executing CLI commands, getting the // list of available builders, and more. type Environment interface { Builder(string) (Builder, error) Cli([]string) (int, error) Hook(string) (Hook, error) Provisioner(string) (Provisioner, error) Ui() Ui } // An implementation of an Environment that represents the Packer core // environment. type coreEnvironment struct { commands []string components ComponentFinder ui Ui } // This struct configures new environments. type EnvironmentConfig struct { Commands []string Components ComponentFinder Ui Ui } // DefaultEnvironmentConfig returns a default EnvironmentConfig that can // be used to create a new enviroment with NewEnvironment with sane defaults. func DefaultEnvironmentConfig() *EnvironmentConfig { config := &EnvironmentConfig{} config.Commands = make([]string, 0) config.Ui = &ReaderWriterUi{os.Stdin, os.Stdout} return config } // This creates a new environment func NewEnvironment(config *EnvironmentConfig) (resultEnv Environment, err error) { if config == nil { err = errors.New("config must be given to initialize environment") return } env := &coreEnvironment{} env.commands = config.Commands env.components = config.Components env.ui = config.Ui // We want to make sure the components have valid function pointers. // If a function pointer was not given, we assume that the function // will just return a nil component. if env.components.Builder == nil { env.components.Builder = func(string) (Builder, error) { return nil, nil } } if env.components.Command == nil { env.components.Command = func(string) (Command, error) { return nil, nil } } if env.components.Hook == nil { env.components.Hook = func(string) (Hook, error) { return nil, nil } } if env.components.Provisioner == nil { env.components.Provisioner = func(string) (Provisioner, error) { return nil, nil } } resultEnv = env return } // Returns a builder of the given name that is registered with this // environment. func (e *coreEnvironment) Builder(name string) (b Builder, err error) { b, err = e.components.Builder(name) if err != nil { return } if b == nil { err = fmt.Errorf("No builder returned for name: %s", name) } return } // Returns a hook of the given name that is registered with this // environment. func (e *coreEnvironment) Hook(name string) (h Hook, err error) { h, err = e.components.Hook(name) if err != nil { return } if h == nil { err = fmt.Errorf("No hook returned for name: %s", name) } return } // Returns a provisioner for the given name that is registered with this // environment. func (e *coreEnvironment) Provisioner(name string) (p Provisioner, err error) { p, err = e.components.Provisioner(name) if err != nil { return } if p == nil { err = fmt.Errorf("No provisioner returned for name: %s", name) } return } // Executes a command as if it was typed on the command-line interface. // The return value is the exit code of the command. func (e *coreEnvironment) Cli(args []string) (result int, err error) { log.Printf("Environment.Cli: %#v\n", args) if len(args) == 0 || args[0] == "--help" || args[0] == "-h" { e.printHelp() return 1, nil } version := args[0] == "version" if !version { for _, arg := range args { if arg == "--version" || arg == "-v" { version = true break } } } var command Command if version { command = new(versionCommand) } if command == nil { command, err = e.components.Command(args[0]) if err != nil { return } // If we still don't have a command, show the help. if command == nil { log.Printf("Environment.CLI: command not found: %s\n", args[0]) e.printHelp() return 1, nil } } log.Printf("Executing command: %s\n", args[0]) return command.Run(e, args[1:]), nil } // Prints the CLI help to the UI. func (e *coreEnvironment) printHelp() { // Created a sorted slice of the map keys and record the longest // command name so we can better format the output later. i := 0 maxKeyLen := 0 for _, command := range e.commands { if len(command) > maxKeyLen { maxKeyLen = len(command) } i++ } // Sort the keys sort.Strings(e.commands) e.ui.Say("usage: packer [--version] [--help] []\n\n") e.ui.Say("Available commands are:\n") for _, key := range e.commands { var synopsis string command, err := e.components.Command(key) if err != nil { synopsis = fmt.Sprintf("Error loading command: %s", err.Error()) } else if command == nil { continue } else { synopsis = command.Synopsis() } // Pad the key with spaces so that they're all the same width key = fmt.Sprintf("%v%v", key, strings.Repeat(" ", maxKeyLen-len(key))) // Output the command and the synopsis e.ui.Say(" %v %v\n", key, synopsis) } } // Returns the UI for the environment. The UI is the interface that should // be used for all communication with the outside world. func (e *coreEnvironment) Ui() Ui { return e.ui }