128 lines
3.3 KiB
Go
128 lines
3.3 KiB
Go
package common
|
|
|
|
import (
|
|
"crypto/tls"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/hashicorp/packer-plugin-sdk/multistep"
|
|
"github.com/hashicorp/packer-plugin-sdk/packer"
|
|
xsclient "github.com/terra-farm/go-xen-api-client"
|
|
)
|
|
|
|
func appendQuery(urlstring, k, v string) (string, error) {
|
|
u, err := url.Parse(urlstring)
|
|
if err != nil {
|
|
return "", fmt.Errorf("Unable to parse URL '%s': %s", urlstring, err.Error())
|
|
}
|
|
m := u.Query()
|
|
m.Add(k, v)
|
|
u.RawQuery = m.Encode()
|
|
return u.String(), err
|
|
}
|
|
|
|
func HTTPUpload(import_url string, fh *os.File, state multistep.StateBag) (result string, err error) {
|
|
ui := state.Get("ui").(packer.Ui)
|
|
c := state.Get("client").(*Connection)
|
|
|
|
task, err := c.client.Task.Create(c.session, "packer-task", "Packer task")
|
|
if err != nil {
|
|
err = fmt.Errorf("Unable to create task: %s", err.Error())
|
|
return
|
|
}
|
|
defer c.client.Task.Destroy(c.session, task)
|
|
|
|
import_task_url, err := appendQuery(import_url, "task_id", string(task))
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Get file length
|
|
fstat, err := fh.Stat()
|
|
if err != nil {
|
|
err = fmt.Errorf("Unable to stat '%s': %s", fh.Name(), err.Error())
|
|
return
|
|
}
|
|
fileLength := fstat.Size()
|
|
|
|
// Define a new transport which allows self-signed certs
|
|
tr := &http.Transport{
|
|
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
|
}
|
|
|
|
// Create a client
|
|
httpClient := &http.Client{Transport: tr}
|
|
|
|
// Create request and download file
|
|
request, err := http.NewRequest("PUT", import_task_url, fh)
|
|
request.ContentLength = fileLength
|
|
|
|
ui.Say(fmt.Sprintf("PUT '%s'", import_task_url))
|
|
|
|
resp, err := httpClient.Do(request) // Do closes fh for us, according to docs
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
err = fmt.Errorf("PUT request got non-200 status code: %s", resp.Status)
|
|
return
|
|
}
|
|
|
|
logIteration := 0
|
|
err = InterruptibleWait{
|
|
Predicate: func() (bool, error) {
|
|
status, err := c.client.Task.GetStatus(c.session, task)
|
|
if err != nil {
|
|
return false, fmt.Errorf("Failed to get task status: %s", err.Error())
|
|
}
|
|
switch status {
|
|
case xsclient.TaskStatusTypePending:
|
|
progress, err := c.client.Task.GetProgress(c.session, task)
|
|
if err != nil {
|
|
return false, fmt.Errorf("Failed to get progress: %s", err.Error())
|
|
}
|
|
logIteration = logIteration + 1
|
|
if logIteration%5 == 0 {
|
|
log.Printf("Upload %.0f%% complete", progress*100)
|
|
}
|
|
return false, nil
|
|
case xsclient.TaskStatusTypeSuccess:
|
|
return true, nil
|
|
case xsclient.TaskStatusTypeFailure:
|
|
errorInfo, err := c.client.Task.GetErrorInfo(c.session, task)
|
|
if err != nil {
|
|
errorInfo = []string{fmt.Sprintf("furthermore, failed to get error info: %s", err.Error())}
|
|
}
|
|
return false, fmt.Errorf("Task failed: %s", errorInfo)
|
|
case xsclient.TaskStatusTypeCancelling, xsclient.TaskStatusTypeCancelled:
|
|
return false, fmt.Errorf("Task cancelled")
|
|
default:
|
|
return false, fmt.Errorf("Unknown task status %v", status)
|
|
}
|
|
},
|
|
PredicateInterval: 1 * time.Second,
|
|
Timeout: 24 * time.Hour,
|
|
}.Wait(state)
|
|
|
|
resp.Body.Close()
|
|
|
|
if err != nil {
|
|
err = fmt.Errorf("Error uploading: %s", err.Error())
|
|
return
|
|
}
|
|
|
|
result, err = c.client.Task.GetResult(c.session, task)
|
|
if err != nil {
|
|
err = fmt.Errorf("Error getting result: %s", err.Error())
|
|
return
|
|
}
|
|
|
|
log.Printf("Upload complete")
|
|
return
|
|
}
|