238 lines
7.4 KiB
Go
238 lines
7.4 KiB
Go
// The googlecompute package contains a packer.Builder implementation that
|
|
// builds images for Google Compute Engine.
|
|
package googlecompute
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
|
|
"github.com/mitchellh/multistep"
|
|
"github.com/mitchellh/packer/common"
|
|
"github.com/mitchellh/packer/packer"
|
|
)
|
|
|
|
// The unique ID for this builder.
|
|
const BuilderId = "packer.googlecompute"
|
|
|
|
// Builder represents a Packer Builder.
|
|
type Builder struct {
|
|
config config
|
|
runner multistep.Runner
|
|
}
|
|
|
|
// config holds the googlecompute builder configuration settings.
|
|
type config struct {
|
|
BucketName string `mapstructure:"bucket_name"`
|
|
ClientSecretsFile string `mapstructure:"client_secrets_file"`
|
|
ImageName string `mapstructure:"image_name"`
|
|
ImageDescription string `mapstructure:"image_description"`
|
|
MachineType string `mapstructure:"machine_type"`
|
|
Metadata map[string]string `mapstructure:"metadata"`
|
|
Network string `mapstructure:"network"`
|
|
Passphrase string `mapstructure:"passphrase"`
|
|
PrivateKeyFile string `mapstructure:"private_key_file"`
|
|
ProjectId string `mapstructure:"project_id"`
|
|
SourceImage string `mapstructure:"source_image"`
|
|
SSHUsername string `mapstructure:"ssh_username"`
|
|
SSHPort uint `mapstructure:"ssh_port"`
|
|
RawSSHTimeout string `mapstructure:"ssh_timeout"`
|
|
RawStateTimeout string `mapstructure:"state_timeout"`
|
|
Tags []string `mapstructure:"tags"`
|
|
Zone string `mapstructure:"zone"`
|
|
clientSecrets *clientSecrets
|
|
common.PackerConfig `mapstructure:",squash"`
|
|
instanceName string
|
|
privateKeyBytes []byte
|
|
sshTimeout time.Duration
|
|
stateTimeout time.Duration
|
|
tpl *packer.ConfigTemplate
|
|
}
|
|
|
|
// Prepare processes the build configuration parameters.
|
|
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
|
|
// Load the packer config.
|
|
md, err := common.DecodeConfig(&b.config, raws...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b.config.tpl, err = packer.NewConfigTemplate()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b.config.tpl.UserVars = b.config.PackerUserVars
|
|
|
|
errs := common.CheckUnusedConfig(md)
|
|
// Collect errors if any.
|
|
if err := common.CheckUnusedConfig(md); err != nil {
|
|
return nil, err
|
|
}
|
|
// Set defaults.
|
|
if b.config.Network == "" {
|
|
b.config.Network = "default"
|
|
}
|
|
if b.config.ImageDescription == "" {
|
|
b.config.ImageDescription = "Created by Packer"
|
|
}
|
|
if b.config.ImageName == "" {
|
|
// Default to packer-{{ unix timestamp (utc) }}
|
|
b.config.ImageName = "packer-{{timestamp}}"
|
|
}
|
|
if b.config.MachineType == "" {
|
|
b.config.MachineType = "n1-standard-1"
|
|
}
|
|
if b.config.RawSSHTimeout == "" {
|
|
b.config.RawSSHTimeout = "5m"
|
|
}
|
|
if b.config.RawStateTimeout == "" {
|
|
b.config.RawStateTimeout = "5m"
|
|
}
|
|
if b.config.SSHUsername == "" {
|
|
b.config.SSHUsername = "root"
|
|
}
|
|
if b.config.SSHPort == 0 {
|
|
b.config.SSHPort = 22
|
|
}
|
|
// Process Templates
|
|
templates := map[string]*string{
|
|
"bucket_name": &b.config.BucketName,
|
|
"client_secrets_file": &b.config.ClientSecretsFile,
|
|
"image_name": &b.config.ImageName,
|
|
"image_description": &b.config.ImageDescription,
|
|
"machine_type": &b.config.MachineType,
|
|
"network": &b.config.Network,
|
|
"passphrase": &b.config.Passphrase,
|
|
"private_key_file": &b.config.PrivateKeyFile,
|
|
"project_id": &b.config.ProjectId,
|
|
"source_image": &b.config.SourceImage,
|
|
"ssh_username": &b.config.SSHUsername,
|
|
"ssh_timeout": &b.config.RawSSHTimeout,
|
|
"state_timeout": &b.config.RawStateTimeout,
|
|
"zone": &b.config.Zone,
|
|
}
|
|
for n, ptr := range templates {
|
|
var err error
|
|
*ptr, err = b.config.tpl.Process(*ptr, nil)
|
|
if err != nil {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, fmt.Errorf("Error processing %s: %s", n, err))
|
|
}
|
|
}
|
|
// Process required parameters.
|
|
if b.config.BucketName == "" {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, errors.New("a bucket_name must be specified"))
|
|
}
|
|
if b.config.ClientSecretsFile == "" {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, errors.New("a client_secrets_file must be specified"))
|
|
}
|
|
if b.config.PrivateKeyFile == "" {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, errors.New("a private_key_file must be specified"))
|
|
}
|
|
if b.config.ProjectId == "" {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, errors.New("a project_id must be specified"))
|
|
}
|
|
if b.config.SourceImage == "" {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, errors.New("a source_image must be specified"))
|
|
}
|
|
if b.config.Zone == "" {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, errors.New("a zone must be specified"))
|
|
}
|
|
// Process timeout settings.
|
|
sshTimeout, err := time.ParseDuration(b.config.RawSSHTimeout)
|
|
if err != nil {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, fmt.Errorf("Failed parsing ssh_timeout: %s", err))
|
|
}
|
|
b.config.sshTimeout = sshTimeout
|
|
stateTimeout, err := time.ParseDuration(b.config.RawStateTimeout)
|
|
if err != nil {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, fmt.Errorf("Failed parsing state_timeout: %s", err))
|
|
}
|
|
b.config.stateTimeout = stateTimeout
|
|
// Load the client secrets file.
|
|
cs, err := loadClientSecrets(b.config.ClientSecretsFile)
|
|
if err != nil {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, fmt.Errorf("Failed parsing client secrets file: %s", err))
|
|
}
|
|
b.config.clientSecrets = cs
|
|
// Load the private key.
|
|
b.config.privateKeyBytes, err = processPrivateKeyFile(b.config.PrivateKeyFile, b.config.Passphrase)
|
|
if err != nil {
|
|
errs = packer.MultiErrorAppend(
|
|
errs, fmt.Errorf("Failed loading private key file: %s", err))
|
|
}
|
|
// Check for any errors.
|
|
if errs != nil && len(errs.Errors) > 0 {
|
|
return nil, errs
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// Run executes a googlecompute Packer build and returns a packer.Artifact
|
|
// representing a GCE machine image.
|
|
func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
|
|
// Initialize the Google Compute Engine API.
|
|
client, err := New(b.config.ProjectId, b.config.Zone, b.config.clientSecrets, b.config.privateKeyBytes)
|
|
if err != nil {
|
|
log.Println("Failed to create the Google Compute Engine client.")
|
|
return nil, err
|
|
}
|
|
// Set up the state.
|
|
state := new(multistep.BasicStateBag)
|
|
state.Put("config", b.config)
|
|
state.Put("client", client)
|
|
state.Put("hook", hook)
|
|
state.Put("ui", ui)
|
|
// Build the steps.
|
|
steps := []multistep.Step{
|
|
new(stepCreateSSHKey),
|
|
new(stepCreateInstance),
|
|
new(stepInstanceInfo),
|
|
&common.StepConnectSSH{
|
|
SSHAddress: sshAddress,
|
|
SSHConfig: sshConfig,
|
|
SSHWaitTimeout: 5 * time.Minute,
|
|
},
|
|
new(common.StepProvision),
|
|
new(stepUpdateGsutil),
|
|
new(stepCreateImage),
|
|
new(stepUploadImage),
|
|
new(stepRegisterImage),
|
|
}
|
|
// Run the steps.
|
|
if b.config.PackerDebug {
|
|
b.runner = &multistep.DebugRunner{
|
|
Steps: steps,
|
|
PauseFn: common.MultistepDebugFn(ui),
|
|
}
|
|
} else {
|
|
b.runner = &multistep.BasicRunner{Steps: steps}
|
|
}
|
|
b.runner.Run(state)
|
|
// Report any errors.
|
|
if rawErr, ok := state.GetOk("error"); ok {
|
|
return nil, rawErr.(error)
|
|
}
|
|
if _, ok := state.GetOk("image_name"); !ok {
|
|
log.Println("Failed to find image_name in state. Bug?")
|
|
return nil, nil
|
|
}
|
|
artifact := &Artifact{
|
|
imageName: state.Get("image_name").(string),
|
|
client: client,
|
|
}
|
|
return artifact, nil
|
|
}
|
|
|
|
// Cancel.
|
|
func (b *Builder) Cancel() {}
|