/
provisioner.go
245 lines (212 loc) · 7.5 KB
/
provisioner.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
//go:generate mapstructure-to-hcl2 -type Config
//go:generate struct-markdown
package file
import (
"context"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"github.com/hashicorp/hcl/v2/hcldec"
"github.com/hashicorp/packer-plugin-sdk/common"
packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
"github.com/hashicorp/packer-plugin-sdk/template/config"
"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
)
type Config struct {
common.PackerConfig `mapstructure:",squash"`
// The path to a local file or directory to upload to the
// machine. The path can be absolute or relative. If it is relative, it is
// relative to the working directory when Packer is executed. If this is a
// directory, the existence of a trailing slash is important. Read below on
// uploading directories. Mandatory unless `sources` is set.
Source string `mapstructure:"source" required:"true"`
// A list of sources to upload. This can be used in place of the `source`
// option if you have several files that you want to upload to the same
// place. Note that the destination must be a directory with a trailing
// slash, and that all files listed in `sources` will be uploaded to the
// same directory with their file names preserved.
Sources []string `mapstructure:"sources" required:"false"`
// The path where the file will be uploaded to in the machine. This value
// must be a writable location and any parent directories
// must already exist. If the provisioning user (generally not root) cannot
// write to this directory, you will receive a "Permission Denied" error.
// If the source is a file, it's a good idea to make the destination a file
// as well, but if you set your destination as a directory, at least make
// sure that the destination ends in a trailing slash so that Packer knows
// to use the source's basename in the final upload path. Failure to do so
// may cause Packer to fail on file uploads. If the destination file
// already exists, it will be overwritten.
Destination string `mapstructure:"destination" required:"true"`
// The direction of the file transfer. This defaults to "upload". If it is
// set to "download" then the file "source" in the machine will be
// downloaded locally to "destination"
Direction string `mapstructure:"direction" required:"false"`
// For advanced users only. If true, check the file existence only before
// uploading, rather than upon pre-build validation. This allows users to
// upload files created on-the-fly. This defaults to false. We
// don't recommend using this feature, since it can cause Packer to become
// dependent on system state. We would prefer you generate your files before
// the Packer run, but realize that there are situations where this may be
// unavoidable.
Generated bool `mapstructure:"generated" required:"false"`
ctx interpolate.Context
}
type Provisioner struct {
config Config
}
func (p *Provisioner) ConfigSpec() hcldec.ObjectSpec { return p.config.FlatMapstructure().HCL2Spec() }
func (p *Provisioner) Prepare(raws ...interface{}) error {
err := config.Decode(&p.config, &config.DecodeOpts{
PluginType: "file",
Interpolate: true,
InterpolateContext: &p.config.ctx,
InterpolateFilter: &interpolate.RenderFilter{
Exclude: []string{},
},
}, raws...)
if err != nil {
return err
}
if p.config.Direction == "" {
p.config.Direction = "upload"
}
var errs *packersdk.MultiError
if p.config.Direction != "download" && p.config.Direction != "upload" {
errs = packersdk.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 = packersdk.MultiErrorAppend(errs,
fmt.Errorf("Bad source '%s': %s", src, err))
}
}
}
if len(p.config.Sources) < 1 {
errs = packersdk.MultiErrorAppend(errs,
errors.New("Source must be specified."))
}
if p.config.Destination == "" {
errs = packersdk.MultiErrorAppend(errs,
errors.New("Destination must be specified."))
}
if errs != nil && len(errs.Errors) > 0 {
return errs
}
return nil
}
func (p *Provisioner) Provision(ctx context.Context, ui packersdk.Ui, comm packersdk.Communicator, generatedData map[string]interface{}) error {
if generatedData == nil {
generatedData = make(map[string]interface{})
}
p.config.ctx.Data = generatedData
if p.config.Direction == "download" {
return p.ProvisionDownload(ui, comm)
} else {
return p.ProvisionUpload(ui, comm)
}
}
func (p *Provisioner) ProvisionDownload(ui packersdk.Ui, comm packersdk.Communicator) error {
dst, err := interpolate.Render(p.config.Destination, &p.config.ctx)
if err != nil {
return fmt.Errorf("Error interpolating destination: %s", err)
}
for _, src := range p.config.Sources {
dst := dst
src, err := interpolate.Render(src, &p.config.ctx)
if err != nil {
return fmt.Errorf("Error interpolating source: %s", err)
}
// 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))
}
ui.Say(fmt.Sprintf("Downloading %s => %s", src, dst))
if dir != "" {
err := os.MkdirAll(dir, os.FileMode(0755))
if err != nil {
return err
}
}
// if the src was a dir, download the dir
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()
// 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 packersdk.Ui, comm packersdk.Communicator) error {
dst, err := interpolate.Render(p.config.Destination, &p.config.ctx)
if err != nil {
return fmt.Errorf("Error interpolating destination: %s", err)
}
for _, src := range p.config.Sources {
src, err := interpolate.Render(src, &p.config.ctx)
if err != nil {
return fmt.Errorf("Error interpolating source: %s", err)
}
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() {
if err = comm.UploadDir(dst, src, nil); err != nil {
ui.Error(fmt.Sprintf("Upload failed: %s", err))
return err
}
continue
}
// 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
}
filedst := dst
if strings.HasSuffix(dst, "/") {
filedst = dst + filepath.Base(src)
}
pf := ui.TrackProgress(filepath.Base(src), 0, info.Size(), f)
defer pf.Close()
// Upload the file
if err = comm.Upload(filedst, 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
}