0
0
package guestimagerelease
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/xml"
"errors"
"fmt"
"io"
"net/http"
"slices"
"strconv"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/guestimage"
)
const (
MaxManifest = 64 << 10
ClientTimeout = 30 * time.Second
)
type Options struct {
Base string
Target string
Version string
Commit string
ManifestSHA256 string
Client *http.Client
}
const (
LatestRef = "main/latest"
ContentPrefix = "guest-images"
)
func ContentKey(target, manifestSHA256 string) string {
return ContentPrefix + "/" + target + "/" + manifestSHA256
}
var (
ErrNotPublished = errors.New("guestimagerelease: no published guest image")
errUnreadable = errors.New("guestimagerelease: a candidate could not be read")
ErrPinMismatch = errors.New("guestimagerelease: every published guest image differs from this build's pin")
)
func Source(ctx context.Context, o Options) (string, error) {
if o.Base == "" {
return "", errors.New("guestimagerelease: no base to download a guest image from")
}
if o.Target == "" {
return "", errors.New("guestimagerelease: this host has no guest image target")
}
if o.ManifestSHA256 == "" {
return "", errors.New("guestimagerelease: no pinned sha256 for the manifest, so a candidate cannot be matched against this build; pass the pin in versions.json")
}
base := strings.TrimSuffix(o.Base, "/")
client := o.Client
if client == nil {
client = &http.Client{Timeout: ClientTimeout}
}
refs := make([]string, 0, 4)
add := func(ref string) {
if slices.Contains(refs, ref) {
return
}
refs = append(refs, ref)
}
if o.Version != "" {
add("releases/" + o.Version)
}
if o.Commit != "" {
add("main/" + o.Commit)
}
add(LatestRef)
tried := make([]string, 0, len(refs)+1)
mismatched := make([]string, 0, len(refs)+1)
unreadable := make([]string, 0, len(refs)+1)
refSource := func(ref string) string {
return base + "/" + ref + "/guest-image/" + o.Target
}
try := func(src string) (string, bool, error) {
manifest := src + "/" + guestimage.ManifestName
ok, err := published(ctx, client, manifest)
if err != nil {
if errors.Is(err, errUnreadable) {
unreadable = append(unreadable, src)
return src, false, nil
}
return "", false, err
}
if !ok {
tried = append(tried, src)
return src, false, nil
}
match, err := manifestMatches(ctx, client, manifest, o.ManifestSHA256)
if err != nil {
if errors.Is(err, errUnreadable) {
unreadable = append(unreadable, src)
return src, false, nil
}
return "", false, err
}
if !match {
mismatched = append(mismatched, src)
return src, false, nil
}
return src, true, nil
}
src, matched, err := try(base + "/" + ContentKey(o.Target, o.ManifestSHA256))
if err != nil {
return "", err
}
if matched {
return src, nil
}
for _, ref := range refs {
src, matched, err := try(refSource(ref))
if err != nil {
return "", err
}
if matched {
return src, nil
}
}
newest, listErr := newestRelease(ctx, client, base)
if listErr == nil && newest != "" {
if ref := "releases/" + newest; !slices.Contains(refs, ref) {
src, matched, err := try(refSource(ref))
if err != nil {
return "", err
}
if matched {
return src, nil
}
}
}
looked := ""
if len(tried) > 0 {
looked = ", tried " + strings.Join(tried, ", ")
}
unread := ""
if len(unreadable) > 0 {
unread = ", and these answered that they could not be read: " + strings.Join(unreadable, ", ")
}
absent := ""
if len(tried) > 0 {
absent = "; absent at " + strings.Join(tried, ", ")
}
unlisted := ""
if listErr != nil {
unlisted = fmt.Sprintf(", and the list of releases at %s could not be read: %v", base, listErr)
}
if len(mismatched) > 0 {
return "", fmt.Errorf("%w (%s): published but different at %s%s%s%s", ErrPinMismatch, o.ManifestSHA256,
strings.Join(mismatched, ", "), absent, unread, unlisted)
}
if len(unreadable) > 0 {
return "", fmt.Errorf("%w for target %s%s%s%s", ErrNotPublished, o.Target, looked, unread, unlisted)
}
if listErr != nil {
return "", fmt.Errorf("%w for target %s%s, and the list of releases at %s could not be read: %w",
ErrNotPublished, o.Target, looked, base, listErr)
}
return "", fmt.Errorf("%w for target %s%s", ErrNotPublished, o.Target, looked)
}
func manifestMatches(ctx context.Context, client *http.Client, url, want string) (bool, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return false, err
}
resp, err := client.Do(req)
if err != nil {
return false, fmt.Errorf("guestimagerelease: %s: %w", url, err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return false, fmt.Errorf("%w: %s answered %s", errUnreadable, url, resp.Status)
}
h := sha256.New()
if _, err := io.Copy(h, io.LimitReader(resp.Body, MaxManifest)); err != nil {
return false, fmt.Errorf("guestimagerelease: reading %s: %w", url, err)
}
return hex.EncodeToString(h.Sum(nil)) == want, nil
}
func newestRelease(ctx context.Context, client *http.Client, base string) (string, error) {
url := base + "/?list-type=2&prefix=releases/&delimiter=/"
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return "", err
}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("guestimagerelease: %s: %w", url, err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("guestimagerelease: %s answered %s", url, resp.Status)
}
var list struct {
Common []struct {
Prefix string `xml:"Prefix"`
} `xml:"CommonPrefixes"`
}
if err := xml.NewDecoder(io.LimitReader(resp.Body, 1<<20)).Decode(&list); err != nil {
return "", fmt.Errorf("guestimagerelease: reading the listing of %s: %w", base, err)
}
newest := ""
for _, p := range list.Common {
v := strings.TrimSuffix(strings.TrimPrefix(p.Prefix, "releases/"), "/")
if !strings.HasPrefix(v, "v") {
continue
}
if newest == "" || compareVersion(v, newest) > 0 {
newest = v
}
}
return newest, nil
}
func compareVersion(a, b string) int {
an, ap := splitVersion(a)
bn, bp := splitVersion(b)
for i := range 3 {
if an[i] != bn[i] {
return sign(an[i] - bn[i])
}
}
switch {
case ap == "" && bp == "":
return 0
case ap == "":
return 1
case bp == "":
return -1
}
pa, na := splitPre(ap)
pb, nb := splitPre(bp)
if pa != pb {
if pa < pb {
return -1
}
return 1
}
return sign(na - nb)
}
func splitVersion(v string) ([3]int, string) {
v = strings.TrimPrefix(v, "v")
pre := ""
if i := strings.IndexAny(v, "-+"); i >= 0 {
v, pre = v[:i], v[i+1:]
}
var out [3]int
for i, part := range strings.SplitN(v, ".", 3) {
n, err := strconv.Atoi(part)
if err == nil {
out[i] = n
}
}
return out, pre
}
func splitPre(s string) (string, int) {
i := 0
for i < len(s) && (s[i] < '0' || s[i] > '9') {
i++
}
n, _ := strconv.Atoi(s[i:])
return s[:i], n
}
func sign(n int) int {
switch {
case n < 0:
return -1
case n > 0:
return 1
}
return 0
}
func published(ctx context.Context, client *http.Client, url string) (bool, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)
if err != nil {
return false, err
}
resp, err := client.Do(req)
if err != nil {
return false, fmt.Errorf("guestimagerelease: %s: %w", url, err)
}
defer resp.Body.Close()
io.Copy(io.Discard, resp.Body)
switch resp.StatusCode {
case http.StatusOK:
return true, nil
case http.StatusNotFound:
return false, nil
case http.StatusForbidden:
return false, fmt.Errorf("%w: %s answered %s, so the object may be present but unreadable", errUnreadable, url, resp.Status)
}
return false, fmt.Errorf("%w: %s answered %s", errUnreadable, url, resp.Status)
}