package worker
import (
"bytes"
"context"
"crypto/tls"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/http"
"github.com/google/uuid"
"github.com/osbuild/osbuild-composer/internal/common"
"github.com/osbuild/osbuild-composer/internal/distro"
"github.com/osbuild/osbuild-composer/internal/target"
)
type Client struct {
client *http.Client
scheme string
hostname string
}
type Job struct {
Id uuid.UUID
Manifest distro.Manifest
Targets []*target.Target
}
func NewClient(address string, conf *tls.Config) *Client {
client := &http.Client{
Transport: &http.Transport{
TLSClientConfig: conf,
},
}
var scheme string
// Use https if the TLS configuration is present, otherwise use http.
if conf != nil {
scheme = "https"
} else {
scheme = "http"
}
return &Client{client, scheme, address}
}
func NewClientUnix(path string) *Client {
client := &http.Client{
Transport: &http.Transport{
DialContext: func(context context.Context, network, addr string) (net.Conn, error) {
return net.Dial("unix", path)
},
},
}
return &Client{client, "http", "localhost"}
}
func (c *Client) AddJob() (*Job, error) {
var b bytes.Buffer
err := json.NewEncoder(&b).Encode(addJobRequest{})
if err != nil {
panic(err)
}
response, err := c.client.Post(c.createURL("/job-queue/v1/jobs"), "application/json", &b)
if err != nil {
return nil, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusCreated {
var er errorResponse
_ = json.NewDecoder(response.Body).Decode(&er)
return nil, fmt.Errorf("couldn't create job, got %d: %s", response.StatusCode, er.Message)
}
var jr addJobResponse
err = json.NewDecoder(response.Body).Decode(&jr)
if err != nil {
return nil, err
}
return &Job{
jr.Id,
jr.Manifest,
jr.Targets,
}, nil
}
func (c *Client) JobCanceled(job *Job) bool {
response, err := c.client.Get(c.createURL("/job-queue/v1/jobs/" + job.Id.String()))
if err != nil {
return true
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return true
}
var jr jobResponse
err = json.NewDecoder(response.Body).Decode(&jr)
if err != nil {
return true
}
return jr.Canceled
}
func (c *Client) UpdateJob(job *Job, status common.ImageBuildState, result *common.ComposeResult) error {
var b bytes.Buffer
err := json.NewEncoder(&b).Encode(&updateJobRequest{status, result})
if err != nil {
panic(err)
}
urlPath := fmt.Sprintf("/job-queue/v1/jobs/%s", job.Id)
url := c.createURL(urlPath)
req, err := http.NewRequest("PATCH", url, &b)
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
response, err := c.client.Do(req)
if err != nil {
return err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return errors.New("error setting job status")
}
return nil
}
func (c *Client) UploadImage(job uuid.UUID, name string, reader io.Reader) error {
url := c.createURL(fmt.Sprintf("/job-queue/v1/jobs/%s/artifacts/%s", job, name))
_, err := c.client.Post(url, "application/octet-stream", reader)
return err
}
func (c *Client) createURL(path string) string {
return c.scheme + "://" + c.hostname + path
}