droboticflow/internal/api/object_sync_updates.go

296 lines
11 KiB
Go

package api
import (
"bytes"
"crypto/ed25519"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/url"
"regexp"
"sort"
"strings"
"time"
"droboticflow/internal/domain"
"github.com/go-chi/chi/v5"
versionutil "k8s.io/apimachinery/pkg/util/version"
)
// This ordered immutable payload is shared with the Rust signer. Operational
// rollout policy can change without changing the identity of signed artifacts.
type objectSyncSignedPayload struct {
ManifestVersion int `json:"manifestVersion"`
ID string `json:"id"`
Version string `json:"version"`
Kind string `json:"kind"`
ProtocolVersion string `json:"protocolVersion"`
MinimumServerVersion string `json:"minimumServerVersion"`
MinimumStateSchema int64 `json:"minimumStateSchema"`
MaximumStateSchema int64 `json:"maximumStateSchema"`
Artifacts map[string]string `json:"artifacts"`
SHA256 map[string]string `json:"sha256"`
}
func objectSyncReleasePayload(r domain.ObjectSyncClientReleaseRecord) ([]byte, error) {
p := objectSyncSignedPayload{r.ManifestVersion, r.ID, r.Version, r.Kind, r.ProtocolVersion, r.MinimumServerVersion, r.MinimumStateSchema, r.MaximumStateSchema, r.Artifacts, r.SHA256}
var b bytes.Buffer
e := json.NewEncoder(&b)
e.SetEscapeHTML(false)
if err := e.Encode(p); err != nil {
return nil, err
}
raw := bytes.TrimSuffix(b.Bytes(), []byte("\n"))
raw = bytes.ReplaceAll(raw, []byte(`\u2028`), []byte("\u2028"))
raw = bytes.ReplaceAll(raw, []byte(`\u2029`), []byte("\u2029"))
return raw, nil
}
func parseObjectSyncVersion(v string) (*versionutil.Version, error) {
if strings.HasPrefix(v, "v") || strings.TrimSpace(v) != v {
return nil, errors.New("version must use a full SemVer without a v prefix")
}
parsed, err := versionutil.ParseSemantic(v)
if err != nil {
return nil, fmt.Errorf("invalid semantic version: %w", err)
}
return parsed, nil
}
func validateObjectSyncReleaseMetadata(r domain.ObjectSyncClientReleaseRecord) error {
if r.ManifestVersion != 2 || !regexp.MustCompile(`^[A-Za-z0-9_.-]{1,128}$`).MatchString(r.ID) || r.ProtocolVersion != domain.ObjectSyncProtocolVersion {
return errors.New("manifestVersion=2, explicit id and current protocolVersion are required")
}
if _, err := parseObjectSyncVersion(r.Version); err != nil {
return err
}
if _, err := parseObjectSyncVersion(r.MinimumServerVersion); err != nil {
return fmt.Errorf("minimumServerVersion: %w", err)
}
if r.MinimumStateSchema < 1 || r.MaximumStateSchema < r.MinimumStateSchema {
return errors.New("valid minimumStateSchema/maximumStateSchema bounds are required")
}
if len(r.Artifacts) != len(objectSyncClientPlatforms) || len(r.SHA256) != len(objectSyncClientPlatforms) {
return errors.New("release requires the exact four-platform artifact and checksum matrix")
}
for _, p := range objectSyncClientPlatforms {
for _, char := range r.Artifacts[p] {
if char < 0x21 || char > 0x7e {
return fmt.Errorf("%s URL must be ASCII with percent-encoded paths", p)
}
}
u, err := url.Parse(r.Artifacts[p])
if err != nil || u.Host == "" || u.User != nil {
return fmt.Errorf("invalid %s artifact URL", p)
}
if r.Kind == objectSyncReleaseSigned && u.Scheme != "https" {
return errors.New("signed artifacts require stable HTTPS URLs")
}
if r.Kind == objectSyncReleasePreview && u.Scheme != "bos" {
return errors.New("preview artifacts require BOS references")
}
digest, err := hex.DecodeString(r.SHA256[p])
if err != nil || len(digest) != 32 {
return fmt.Errorf("invalid %s SHA256", p)
}
}
return nil
}
func (server *server) verifyObjectSyncRelease(r domain.ObjectSyncClientReleaseRecord) error {
if err := validateObjectSyncReleaseMetadata(r); err != nil {
return err
}
if r.Kind != objectSyncReleaseSigned {
return nil
}
raw, err := base64.StdEncoding.DecodeString(server.objectSyncUpdateSigningPublicKey)
if err != nil || len(raw) != ed25519.PublicKeySize {
return errors.New("update signing public key is not configured")
}
sig, err := base64.StdEncoding.DecodeString(r.Signature)
if err != nil || len(sig) != ed25519.SignatureSize {
return errors.New("invalid manifest signature")
}
payload, err := objectSyncReleasePayload(r)
if err != nil {
return err
}
if !ed25519.Verify(ed25519.PublicKey(raw), payload, sig) {
return errors.New("invalid manifest signature")
}
return nil
}
func releaseSupportsServer(r domain.ObjectSyncClientReleaseRecord) bool {
minimum, err := parseObjectSyncVersion(r.MinimumServerVersion)
if err != nil {
return false
}
current, _ := parseObjectSyncVersion(objectSyncServerVersion)
return !current.LessThan(minimum)
}
func (server *server) handleExternalObjectSyncReleaseVersion(w http.ResponseWriter, r *http.Request) {
target, ok := server.objectSyncStore(w, r)
if !ok {
return
}
requested := chi.URLParam(r, "version")
if _, err := parseObjectSyncVersion(requested); err != nil {
renderObjectSyncError(w, r, 400, "invalid_version", err.Error(), false, nil)
return
}
principal, _ := currentObjectSyncCredential(r)
platform := principal.Device.Platform + "-" + principal.Device.Architecture
rows, err := target.ListObjectSyncClientReleases(r.Context())
if err != nil {
renderObjectSyncError(w, r, 503, "release_lookup_failed", "Could not read signed release", true, nil)
return
}
for _, item := range rows {
if item.ManifestVersion != 2 || item.Version != requested || item.Kind != objectSyncReleaseSigned {
continue
}
if err := server.verifyObjectSyncRelease(item); err != nil {
renderObjectSyncError(w, r, 409, "release_untrusted", err.Error(), false, nil)
return
}
if item.Artifacts[platform] == "" {
break
}
renderJSON(w, 200, map[string]any{"release": item, "platformKey": platform, "serverVersion": objectSyncServerVersion})
return
}
renderObjectSyncError(w, r, 404, "release_not_found", "A trusted v2 manifest for this exact version is required before updating", false, nil)
}
func (server *server) handleExternalObjectSyncUpdateCheck(w http.ResponseWriter, r *http.Request) {
target, ok := server.objectSyncStore(w, r)
if !ok {
return
}
principal, _ := currentObjectSyncCredential(r)
platform := principal.Device.Platform + "-" + principal.Device.Architecture
current, err := parseObjectSyncVersion(r.URL.Query().Get("currentVersion"))
if err != nil {
renderObjectSyncError(w, r, 400, "invalid_current_version", err.Error(), false, nil)
return
}
pin := strings.TrimSpace(r.URL.Query().Get("targetVersion"))
if pin != "" {
if _, err := parseObjectSyncVersion(pin); err != nil {
renderObjectSyncError(w, r, 400, "invalid_target_version", err.Error(), false, nil)
return
}
}
rows, err := target.ListObjectSyncClientReleases(r.Context())
if err != nil {
renderObjectSyncError(w, r, 503, "update_check_failed", "Could not read release catalogue", true, nil)
return
}
candidates := make([]domain.ObjectSyncClientReleaseRecord, 0)
for _, item := range rows {
candidate, e := parseObjectSyncVersion(item.Version)
if e != nil || !current.LessThan(candidate) || !objectSyncClientReleaseCanAutoUpdate(item) || item.Artifacts[platform] == "" || !releaseSupportsServer(item) || (pin != "" && item.Version != pin) {
continue
}
if err := server.verifyObjectSyncRelease(item); err != nil {
renderObjectSyncError(w, r, 409, "release_untrusted", err.Error(), false, map[string]any{"releaseId": item.ID})
return
}
if !objectSyncDeviceInRollout(principal.Device.ID, item) {
continue
}
candidates = append(candidates, item)
}
sort.Slice(candidates, func(i, j int) bool {
a, _ := parseObjectSyncVersion(candidates[i].Version)
b, _ := parseObjectSyncVersion(candidates[j].Version)
return b.LessThan(a)
})
if len(candidates) == 0 {
renderJSON(w, 200, map[string]any{"updateAvailable": false, "serverVersion": objectSyncServerVersion})
return
}
renderJSON(w, 200, map[string]any{"updateAvailable": true, "release": candidates[0], "platformKey": platform, "serverVersion": objectSyncServerVersion})
}
func objectSyncDeviceInRollout(deviceID string, item domain.ObjectSyncClientReleaseRecord) bool {
sum := sha256.Sum256([]byte(deviceID + ":" + item.Version))
return int(sum[0])*100/256 < item.RolloutPercent
}
func (server *server) handleObjectSyncRollout(w http.ResponseWriter, r *http.Request) {
target, ok := server.objectSyncStore(w, r)
if !ok {
return
}
rows, err := target.ListObjectSyncClientReleases(r.Context())
if err != nil {
renderObjectSyncError(w, r, 503, "release_lookup_failed", "Could not load rollout", true, nil)
return
}
var item *domain.ObjectSyncClientReleaseRecord
for i := range rows {
if rows[i].ID == chi.URLParam(r, "id") {
item = &rows[i]
break
}
}
org := objectSyncManagementPrincipal(r).User.OrganizationID
if item == nil || item.OrganizationID != org || item.Kind != objectSyncReleaseSigned || item.ManifestVersion != 2 {
renderObjectSyncError(w, r, 404, "client_release_not_found", "Current signed release not found", false, nil)
return
}
var input struct {
Channel string `json:"channel"`
RolloutPercent int `json:"rolloutPercent"`
Paused bool `json:"paused"`
ExpectedRevision int64 `json:"expectedRevision"`
}
if !decodeJSON(w, r, &input) {
return
}
order := map[string]int{"canary": 0, "pilot": 1, "stable": 2}
percent := map[string]int{"canary": 5, "pilot": 20, "stable": 100}
next, valid := order[input.Channel]
if !valid || input.RolloutPercent != percent[input.Channel] {
renderObjectSyncError(w, r, 400, "invalid_rollout_stage", "Use canary5, pilot20 or stable100", false, nil)
return
}
if input.ExpectedRevision != item.Revision {
renderObjectSyncError(w, r, 409, "rollout_revision_changed", "Refresh the release before changing policy", false, nil)
return
}
now := time.Now().UTC()
if next > order[item.Channel] {
if next != order[item.Channel]+1 {
renderObjectSyncError(w, r, 409, "rollout_stage_skipped", "Advance one observed stage at a time", false, nil)
return
}
started, e := time.Parse(time.RFC3339Nano, item.StageChangedAt)
if e != nil || item.Paused || now.Before(started.Add(24*time.Hour)) {
renderObjectSyncError(w, r, 409, "rollout_observation_incomplete", "Observe the active current stage for24hours before advancing", true, nil)
return
}
}
if input.Channel != item.Channel || (item.Paused && !input.Paused) {
item.StageChangedAt = now.Format(time.RFC3339Nano)
}
item.Channel = input.Channel
item.RolloutPercent = input.RolloutPercent
item.Paused = input.Paused
saved, changed, err := target.UpdateObjectSyncRollout(r.Context(), *item, input.ExpectedRevision)
if err != nil {
renderObjectSyncError(w, r, 503, "rollout_save_failed", "Could not save rollout", true, nil)
return
}
if !changed {
renderObjectSyncError(w, r, 409, "rollout_revision_changed", "Another policy change won; refresh before retrying", false, nil)
return
}
if !server.requireObjectSyncAudit(w, r, target, domain.ObjectSyncAuditEvent{OrganizationID: org, ActorType: "user", ActorID: objectSyncManagementPrincipal(r).User.ID, RequestID: objectSyncRequestID(r), Action: "client_release.rollout", Target: map[string]any{"releaseId": saved.ID}, After: map[string]any{"channel": saved.Channel, "paused": saved.Paused, "revision": saved.Revision}, Result: "success"}) {
return
}
renderJSON(w, 200, saved)
}