packer-cn/provisioner/file/provisioner.go

205 lines
4.7 KiB
Go
Raw Normal View History

package file
import (
"errors"
"fmt"
"io"
2015-05-27 17:50:20 -04:00
"os"
"path/filepath"
"strings"
2015-05-27 17:50:20 -04:00
2017-04-04 16:39:01 -04:00
"github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/helper/config"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
)
2015-05-27 17:50:20 -04:00
type Config struct {
common.PackerConfig `mapstructure:",squash"`
// The local path of the file to upload.
Source string
Sources []string
// The remote path where the local file will be uploaded to.
Destination string
// Direction
Direction string
// False if the sources have to exist.
Generated bool
2015-05-27 17:50:20 -04:00
ctx interpolate.Context
}
type Provisioner struct {
2015-05-27 17:50:20 -04:00
config Config
}
func (p *Provisioner) Prepare(raws ...interface{}) error {
2015-05-27 17:50:20 -04:00
err := config.Decode(&p.config, &config.DecodeOpts{
Interpolate: true,
InterpolateContext: &p.config.ctx,
2015-05-27 17:50:20 -04:00
InterpolateFilter: &interpolate.RenderFilter{
Exclude: []string{},
},
}, raws...)
if err != nil {
return err
}
if p.config.Direction == "" {
p.config.Direction = "upload"
}
2015-05-27 17:50:20 -04:00
var errs *packer.MultiError
if p.config.Direction != "download" && p.config.Direction != "upload" {
errs = packer.MultiErrorAppend(errs,
errors.New("Direction must be one of: download, upload."))
}
if p.config.Source != "" {
p.config.Sources = append(p.config.Sources, p.config.Source)
}
if p.config.Direction == "upload" {
for _, src := range p.config.Sources {
if _, err := os.Stat(src); p.config.Generated == false && err != nil {
errs = packer.MultiErrorAppend(errs,
fmt.Errorf("Bad source '%s': %s", src, err))
}
}
}
if len(p.config.Sources) < 1 {
errs = packer.MultiErrorAppend(errs,
errors.New("Source must be specified."))
}
if p.config.Destination == "" {
errs = packer.MultiErrorAppend(errs,
errors.New("Destination must be specified."))
}
if errs != nil && len(errs.Errors) > 0 {
return errs
}
return nil
}
func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
if p.config.Direction == "download" {
return p.ProvisionDownload(ui, comm)
} else {
return p.ProvisionUpload(ui, comm)
}
}
func (p *Provisioner) ProvisionDownload(ui packer.Ui, comm packer.Communicator) error {
for _, src := range p.config.Sources {
dst := p.config.Destination
ui.Say(fmt.Sprintf("Downloading %s => %s", src, dst))
// ensure destination dir exists. p.config.Destination may either be a file or a dir.
dir := dst
// if it doesn't end with a /, set dir as the parent dir
if !strings.HasSuffix(dst, "/") {
dir = filepath.Dir(dir)
} else if !strings.HasSuffix(src, "/") && !strings.HasSuffix(src, "*") {
dst = filepath.Join(dst, filepath.Base(src))
}
if dir != "" {
err := os.MkdirAll(dir, os.FileMode(0755))
if err != nil {
return err
}
}
// if the src was a dir, download the dir
2017-03-28 21:29:55 -04:00
if strings.HasSuffix(src, "/") || strings.ContainsAny(src, "*?[") {
return comm.DownloadDir(src, dst, nil)
}
f, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
if err != nil {
return err
}
defer f.Close()
// Get a default progress bar
pb := packer.NoopProgressBar{}
2018-09-05 12:31:27 -04:00
pb.Start(0) // TODO: find size ? Remove ?
defer pb.Finish()
// Create MultiWriter for the current progress
pf := io.MultiWriter(f)
// Download the file
if err = comm.Download(src, pf); err != nil {
ui.Error(fmt.Sprintf("Download failed: %s", err))
return err
}
}
return nil
}
func (p *Provisioner) ProvisionUpload(ui packer.Ui, comm packer.Communicator) error {
for _, src := range p.config.Sources {
dst := p.config.Destination
ui.Say(fmt.Sprintf("Uploading %s => %s", src, dst))
info, err := os.Stat(src)
if err != nil {
return err
}
// If we're uploading a directory, short circuit and do that
if info.IsDir() {
return comm.UploadDir(p.config.Destination, src, nil)
}
// We're uploading a file...
f, err := os.Open(src)
if err != nil {
return err
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return err
}
if strings.HasSuffix(dst, "/") {
dst = filepath.Join(dst, filepath.Base(src))
}
// Get a default progress bar
bar := ui.ProgressBar()
bar.Start(info.Size())
defer bar.Finish()
// Create ProxyReader for the current progress
pf := bar.NewProxyReader(f)
// Upload the file
if err = comm.Upload(dst, pf, &fi); err != nil {
if strings.Contains(err.Error(), "Error restoring file") {
ui.Error(fmt.Sprintf("Upload failed: %s; this can occur when "+
"your file destination is a folder without a trailing "+
"slash.", err))
}
ui.Error(fmt.Sprintf("Upload failed: %s", err))
return err
}
}
return nil
}
2013-08-31 02:23:36 -04:00
func (p *Provisioner) Cancel() {
// Just hard quit. It isn't a big deal if what we're doing keeps
// running on the other side.
os.Exit(0)
}