forked from longtao.wu/droboticflow
296 lines
11 KiB
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)
|
|
}
|