9f82b75e57
* removed packer.Cache and references since packer.Cache is never used except in the download step. The download step now uses the new func packer.CachePath(targetPath) for this, the behavior is the same. * removed download code from packer that was reimplemented into the go-getter library: progress bar, http download restart, checksuming from file, skip already downloaded files, symlinking, make a download cancellable by context. * on windows if packer is running without symlinking rights and we are getting a local file, the file will be copied instead to avoid errors. * added unit tests for step_download that are now CI tested on windows, mac & linux. * files are now downloaded under cache dir `sha1(filename + "?checksum=" + checksum) + file_extension` * since the output dir is based on the source url and the checksum, when the checksum fails, the file is auto deleted. * a download file is protected and locked by a file lock, * updated docs * updated go modules and vendors
125 lines
2.1 KiB
Go
125 lines
2.1 KiB
Go
package rpc
|
|
|
|
import (
|
|
"io"
|
|
"log"
|
|
"net/rpc"
|
|
|
|
"github.com/hashicorp/packer/packer"
|
|
"github.com/ugorji/go/codec"
|
|
)
|
|
|
|
// Client is the client end that communicates with a Packer RPC server.
|
|
// Establishing a connection is up to the user, the Client can just
|
|
// communicate over any ReadWriteCloser.
|
|
type Client struct {
|
|
mux *muxBroker
|
|
client *rpc.Client
|
|
closeMux bool
|
|
}
|
|
|
|
func NewClient(rwc io.ReadWriteCloser) (*Client, error) {
|
|
mux, err := newMuxBrokerClient(rwc)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
go mux.Run()
|
|
|
|
result, err := newClientWithMux(mux, 0)
|
|
if err != nil {
|
|
mux.Close()
|
|
return nil, err
|
|
}
|
|
|
|
result.closeMux = true
|
|
return result, err
|
|
}
|
|
|
|
func newClientWithMux(mux *muxBroker, streamId uint32) (*Client, error) {
|
|
clientConn, err := mux.Dial(streamId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
h := &codec.MsgpackHandle{
|
|
RawToString: true,
|
|
WriteExt: true,
|
|
}
|
|
clientCodec := codec.GoRpc.ClientCodec(clientConn, h)
|
|
|
|
return &Client{
|
|
mux: mux,
|
|
client: rpc.NewClientWithCodec(clientCodec),
|
|
closeMux: false,
|
|
}, nil
|
|
}
|
|
|
|
func (c *Client) Close() error {
|
|
if err := c.client.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if c.closeMux {
|
|
log.Printf("[WARN] Client is closing mux")
|
|
return c.mux.Close()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Client) Artifact() packer.Artifact {
|
|
return &artifact{
|
|
client: c.client,
|
|
endpoint: DefaultArtifactEndpoint,
|
|
}
|
|
}
|
|
|
|
func (c *Client) Build() packer.Build {
|
|
return &build{
|
|
client: c.client,
|
|
mux: c.mux,
|
|
}
|
|
}
|
|
|
|
func (c *Client) Builder() packer.Builder {
|
|
return &builder{
|
|
client: c.client,
|
|
mux: c.mux,
|
|
}
|
|
}
|
|
|
|
func (c *Client) Communicator() packer.Communicator {
|
|
return &communicator{
|
|
client: c.client,
|
|
mux: c.mux,
|
|
}
|
|
}
|
|
|
|
func (c *Client) Hook() packer.Hook {
|
|
return &hook{
|
|
client: c.client,
|
|
mux: c.mux,
|
|
}
|
|
}
|
|
|
|
func (c *Client) PostProcessor() packer.PostProcessor {
|
|
return &postProcessor{
|
|
client: c.client,
|
|
mux: c.mux,
|
|
}
|
|
}
|
|
|
|
func (c *Client) Provisioner() packer.Provisioner {
|
|
return &provisioner{
|
|
client: c.client,
|
|
mux: c.mux,
|
|
}
|
|
}
|
|
|
|
func (c *Client) Ui() packer.Ui {
|
|
return &Ui{
|
|
client: c.client,
|
|
endpoint: DefaultUiEndpoint,
|
|
}
|
|
}
|