forked from longtao.wu/droboticflow
3016 lines
126 KiB
Go
3016 lines
126 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"crypto/subtle"
|
|
"encoding/base32"
|
|
"encoding/base64"
|
|
"encoding/csv"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"maps"
|
|
"net/http"
|
|
"net/url"
|
|
"path"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/objectsync"
|
|
"droboticflow/internal/store"
|
|
|
|
"github.com/baidubce/bce-sdk-go/bce"
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-chi/chi/v5/middleware"
|
|
)
|
|
|
|
const (
|
|
objectSyncCredentialHeader = "X-Drosync-Token"
|
|
objectSyncLeaseTTL = 5 * time.Minute
|
|
objectSyncSessionTTL = 7 * 24 * time.Hour
|
|
objectSyncRecordRetention = 90 * 24 * time.Hour
|
|
objectSyncVersionRetention = 365 * 24 * time.Hour
|
|
objectSyncIdempotencyTTL = 24 * time.Hour
|
|
objectSyncIdempotencyMax = 32 << 20
|
|
objectSyncMaxOrgDevices = 500
|
|
objectSyncReleaseSigned = "signed"
|
|
objectSyncReleasePreview = "preview"
|
|
)
|
|
|
|
// Keep this list in lockstep with drosync_platform::release_platform_key_for.
|
|
// S100 devices register as linux/arm64, so their preview artifact must be
|
|
// required and exposed alongside the existing desktop targets.
|
|
var objectSyncClientPlatforms = []string{"macos-arm64", "windows-x86_64", "linux-x86_64", "linux-arm64"}
|
|
|
|
func normalizedOrganizationID(value string) string {
|
|
if trimmed := strings.TrimSpace(value); trimmed != "" {
|
|
return trimmed
|
|
}
|
|
return domain.DefaultOrganizationID
|
|
}
|
|
|
|
type objectSyncCredentialContextKey struct{}
|
|
|
|
type objectSyncCredentialPrincipal struct {
|
|
Credential domain.ObjectSyncCredentialRecord
|
|
Device domain.ObjectSyncDeviceRecord
|
|
}
|
|
|
|
type objectSyncAPIError struct {
|
|
Code string `json:"code"`
|
|
Message string `json:"message"`
|
|
Retryable bool `json:"retryable"`
|
|
RequestID string `json:"requestId"`
|
|
Details map[string]any `json:"details,omitempty"`
|
|
}
|
|
|
|
func objectSyncRequestID(request *http.Request) string {
|
|
if value := strings.TrimSpace(middleware.GetReqID(request.Context())); value != "" {
|
|
return value
|
|
}
|
|
if value := strings.TrimSpace(request.Header.Get("X-Request-ID")); value != "" {
|
|
return value
|
|
}
|
|
return objectSyncNewID("req")
|
|
}
|
|
|
|
func objectSyncNewID(prefix string) string {
|
|
token, err := randomURLToken(12)
|
|
if err != nil {
|
|
sum := sha256.Sum256([]byte(fmt.Sprintf("%s:%d", prefix, time.Now().UnixNano())))
|
|
token = hex.EncodeToString(sum[:8])
|
|
}
|
|
return prefix + "_" + token
|
|
}
|
|
|
|
func renderObjectSyncError(writer http.ResponseWriter, request *http.Request, status int, code, message string, retryable bool, details map[string]any) {
|
|
renderJSON(writer, status, objectSyncAPIError{
|
|
Code: code,
|
|
Message: message,
|
|
Retryable: retryable,
|
|
RequestID: objectSyncRequestID(request),
|
|
Details: details,
|
|
})
|
|
}
|
|
|
|
func (server *server) objectSyncStore(writer http.ResponseWriter, request *http.Request) (store.ObjectSyncStore, bool) {
|
|
target, ok := store.AsObjectSyncStore(server.store)
|
|
if !ok {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "object_sync_store_unavailable", "Object sync storage is unavailable", true, nil)
|
|
return nil, false
|
|
}
|
|
return target, true
|
|
}
|
|
|
|
func (server *server) requireObjectSyncFeature(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
if !server.objectSyncEnabled {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "object_sync_disabled", "Object sync is disabled by the server feature flag", false, nil)
|
|
return
|
|
}
|
|
next.ServeHTTP(writer, request)
|
|
})
|
|
}
|
|
|
|
func (server *server) objectSyncDistributedRateLimit(limit int64, window time.Duration) func(http.Handler) http.Handler {
|
|
return func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
if limit <= 0 || window <= 0 {
|
|
next.ServeHTTP(writer, request)
|
|
return
|
|
}
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
subject := "public:" + server.clientRateLimitKey(request, "drosync")
|
|
if principal, authenticated := currentObjectSyncCredential(request); authenticated {
|
|
subject = "credential:" + principal.Credential.OrganizationID + ":" + principal.Credential.ID
|
|
}
|
|
now := time.Now().UTC()
|
|
windowStart := now.Truncate(window)
|
|
windowEnd := windowStart.Add(window)
|
|
sum := sha256.Sum256([]byte(subject + "\x00" + windowStart.Format(time.RFC3339Nano)))
|
|
record, allowed, err := target.ConsumeObjectSyncRateLimit(request.Context(), domain.ObjectSyncRateLimitRecord{
|
|
ID: hex.EncodeToString(sum[:]),
|
|
Subject: subject,
|
|
Window: windowStart.Format(time.RFC3339Nano),
|
|
ExpiresAt: windowEnd.Add(window),
|
|
}, limit)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "rate_limit_store_failed", "Distributed request limiting is temporarily unavailable", true, nil)
|
|
return
|
|
}
|
|
remaining := limit - record.Count
|
|
if remaining < 0 {
|
|
remaining = 0
|
|
}
|
|
retryAfter := int64(time.Until(windowEnd).Seconds())
|
|
if retryAfter < 1 {
|
|
retryAfter = 1
|
|
}
|
|
writer.Header().Set("RateLimit-Limit", strconv.FormatInt(limit, 10))
|
|
writer.Header().Set("RateLimit-Remaining", strconv.FormatInt(remaining, 10))
|
|
writer.Header().Set("RateLimit-Reset", strconv.FormatInt(windowEnd.Unix(), 10))
|
|
if !allowed {
|
|
writer.Header().Set("Retry-After", strconv.FormatInt(retryAfter, 10))
|
|
renderObjectSyncError(writer, request, http.StatusTooManyRequests, "rate_limited", "The drosync request limit for this credential or client has been exceeded", true, nil)
|
|
return
|
|
}
|
|
next.ServeHTTP(writer, request)
|
|
})
|
|
}
|
|
}
|
|
|
|
type objectSyncBufferedResponse struct {
|
|
header http.Header
|
|
status int
|
|
body bytes.Buffer
|
|
}
|
|
|
|
func (writer *objectSyncBufferedResponse) Header() http.Header {
|
|
return writer.header
|
|
}
|
|
|
|
func (writer *objectSyncBufferedResponse) WriteHeader(status int) {
|
|
if writer.status != 0 {
|
|
return
|
|
}
|
|
writer.status = status
|
|
}
|
|
|
|
func (writer *objectSyncBufferedResponse) Write(body []byte) (int, error) {
|
|
if writer.status == 0 {
|
|
writer.status = http.StatusOK
|
|
}
|
|
return writer.body.Write(body)
|
|
}
|
|
|
|
func objectSyncCopyResponse(writer http.ResponseWriter, header http.Header, status int, body []byte) {
|
|
for key, values := range header {
|
|
for _, value := range values {
|
|
writer.Header().Add(key, value)
|
|
}
|
|
}
|
|
if status == 0 {
|
|
status = http.StatusOK
|
|
}
|
|
writer.WriteHeader(status)
|
|
_, _ = writer.Write(body)
|
|
}
|
|
|
|
func objectSyncIdempotencySubject(request *http.Request) (string, string, string) {
|
|
if principal, ok := currentObjectSyncCredential(request); ok {
|
|
return principal.Credential.OrganizationID, principal.Device.ID, "device:" + principal.Credential.ID
|
|
}
|
|
if principal, ok := currentPrincipal(request); ok {
|
|
return principal.User.OrganizationID, principal.User.ID, "user:" + principal.User.ID
|
|
}
|
|
return "", "", "public"
|
|
}
|
|
|
|
func (server *server) requireObjectSyncIdempotency(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
switch request.Method {
|
|
case http.MethodGet, http.MethodHead, http.MethodOptions:
|
|
next.ServeHTTP(writer, request)
|
|
return
|
|
}
|
|
key := strings.TrimSpace(request.Header.Get("Idempotency-Key"))
|
|
if key == "" || len(key) > 128 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "idempotency_key_required", "Idempotency-Key is required and must be at most 128 characters", false, nil)
|
|
return
|
|
}
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
body, err := io.ReadAll(io.LimitReader(request.Body, objectSyncIdempotencyMax+1))
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "request_body_read_failed", err.Error(), false, nil)
|
|
return
|
|
}
|
|
if len(body) > objectSyncIdempotencyMax {
|
|
renderObjectSyncError(writer, request, http.StatusRequestEntityTooLarge, "request_body_too_large", "The request body exceeds the 32 MiB idempotency limit", false, nil)
|
|
return
|
|
}
|
|
request.Body = io.NopCloser(bytes.NewReader(body))
|
|
requestPath := request.URL.EscapedPath()
|
|
if request.URL.RawQuery != "" {
|
|
requestPath += "?" + request.URL.RawQuery
|
|
}
|
|
organizationID, actorID, subject := objectSyncIdempotencySubject(request)
|
|
requestSum := sha256.Sum256([]byte(request.Method + "\n" + requestPath + "\n" + request.Header.Get("Content-Type") + "\n" + string(body)))
|
|
requestDigest := hex.EncodeToString(requestSum[:])
|
|
recordSum := sha256.Sum256([]byte(subject + "\n" + request.Method + "\n" + requestPath + "\n" + key))
|
|
recordID := hex.EncodeToString(recordSum[:])
|
|
now := time.Now().UTC()
|
|
record := domain.ObjectSyncIdempotencyRecord{
|
|
ID: recordID,
|
|
OrganizationID: organizationID,
|
|
ActorID: actorID,
|
|
Key: key,
|
|
RequestMethod: request.Method,
|
|
RequestPath: requestPath,
|
|
RequestDigest: requestDigest,
|
|
State: "processing",
|
|
CreatedAt: now.Format(time.RFC3339Nano),
|
|
UpdatedAt: now.Format(time.RFC3339Nano),
|
|
ExpiresAt: now.Add(objectSyncIdempotencyTTL),
|
|
}
|
|
existing, created, err := target.BeginObjectSyncIdempotency(request.Context(), record)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_store_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !created && existing != nil && !existing.ExpiresAt.IsZero() && existing.ExpiresAt.Before(now) {
|
|
if err := target.DeleteObjectSyncIdempotency(request.Context(), existing.ID, existing.RequestDigest); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_store_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
existing, created, err = target.BeginObjectSyncIdempotency(request.Context(), record)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_store_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
}
|
|
if !created {
|
|
if existing == nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_record_missing", "The idempotency record could not be loaded", true, nil)
|
|
return
|
|
}
|
|
if existing.RequestDigest != requestDigest {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "idempotency_key_reused", "The Idempotency-Key was already used with a different request", false, nil)
|
|
return
|
|
}
|
|
if existing.State != "completed" {
|
|
writer.Header().Set("Retry-After", "2")
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "idempotency_request_in_progress", "A request with this Idempotency-Key is still being processed", true, nil)
|
|
return
|
|
}
|
|
replayHeader := make(http.Header, len(existing.ResponseHeader)+1)
|
|
for name, value := range existing.ResponseHeader {
|
|
replayHeader.Set(name, value)
|
|
}
|
|
replayHeader.Set("Idempotency-Replayed", "true")
|
|
objectSyncCopyResponse(writer, replayHeader, existing.ResponseStatus, existing.ResponseBody)
|
|
return
|
|
}
|
|
buffered := &objectSyncBufferedResponse{header: make(http.Header)}
|
|
next.ServeHTTP(buffered, request)
|
|
if buffered.status >= http.StatusInternalServerError {
|
|
_ = target.DeleteObjectSyncIdempotency(request.Context(), record.ID, record.RequestDigest)
|
|
objectSyncCopyResponse(writer, buffered.header, buffered.status, buffered.body.Bytes())
|
|
return
|
|
}
|
|
record.State = "completed"
|
|
record.ResponseStatus = buffered.status
|
|
record.ResponseHeader = make(map[string]string, len(buffered.header))
|
|
for name, values := range buffered.header {
|
|
record.ResponseHeader[name] = strings.Join(values, ", ")
|
|
}
|
|
record.ResponseBody = append([]byte(nil), buffered.body.Bytes()...)
|
|
record.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
|
|
if err := target.CompleteObjectSyncIdempotency(request.Context(), record); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_commit_failed", "The operation completed but its replay record could not be committed; query operation status before retrying", true, nil)
|
|
return
|
|
}
|
|
objectSyncCopyResponse(writer, buffered.header, buffered.status, buffered.body.Bytes())
|
|
})
|
|
}
|
|
|
|
func objectSyncBearerToken(request *http.Request) string {
|
|
if value := strings.TrimSpace(request.Header.Get(objectSyncCredentialHeader)); value != "" {
|
|
return value
|
|
}
|
|
value := strings.TrimSpace(request.Header.Get("Authorization"))
|
|
if len(value) > 7 && strings.EqualFold(value[:7], "Bearer ") {
|
|
return strings.TrimSpace(value[7:])
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (server *server) objectSyncCredentialAuth(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
token := objectSyncBearerToken(request)
|
|
if token == "" {
|
|
renderObjectSyncError(writer, request, http.StatusUnauthorized, "credential_required", "A drosync device credential is required", false, nil)
|
|
return
|
|
}
|
|
hash := sessionTokenHash(token)
|
|
credential, err := target.GetObjectSyncCredentialByTokenHash(request.Context(), hash)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_lookup_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if credential == nil || !credential.Enabled || !objectSyncCredentialTokenMatches(*credential, hash) {
|
|
renderObjectSyncError(writer, request, http.StatusUnauthorized, "credential_invalid", "The drosync device credential is invalid or revoked", false, nil)
|
|
return
|
|
}
|
|
deviceID := objectSyncCredentialDeviceIDForToken(*credential, hash)
|
|
device, err := target.GetObjectSyncDevice(request.Context(), deviceID)
|
|
if err != nil || device == nil || device.Status != "active" {
|
|
renderObjectSyncError(writer, request, http.StatusUnauthorized, "device_inactive", "The drosync device is not active", false, nil)
|
|
return
|
|
}
|
|
now := nowISO()
|
|
credential.LastUsedAt = now
|
|
credential.UpdatedAt = now
|
|
device.LastSeenAt = now
|
|
device.UpdatedAt = now
|
|
_ = target.UpsertObjectSyncCredential(request.Context(), *credential)
|
|
_ = target.UpsertObjectSyncDevice(request.Context(), *device)
|
|
ctx := context.WithValue(request.Context(), objectSyncCredentialContextKey{}, &objectSyncCredentialPrincipal{
|
|
Credential: *credential,
|
|
Device: *device,
|
|
})
|
|
next.ServeHTTP(writer, request.WithContext(ctx))
|
|
})
|
|
}
|
|
|
|
func objectSyncCredentialTokenMatches(credential domain.ObjectSyncCredentialRecord, hash string) bool {
|
|
if credential.TokenHash != "" && subtle.ConstantTimeCompare([]byte(credential.TokenHash), []byte(hash)) == 1 {
|
|
return true
|
|
}
|
|
for _, candidate := range credential.TokenHashes {
|
|
if subtle.ConstantTimeCompare([]byte(candidate), []byte(hash)) == 1 {
|
|
return true
|
|
}
|
|
}
|
|
for _, binding := range credential.TokenBindings {
|
|
if subtle.ConstantTimeCompare([]byte(binding.TokenHash), []byte(hash)) == 1 {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func objectSyncCredentialDeviceIDForToken(credential domain.ObjectSyncCredentialRecord, hash string) string {
|
|
for _, binding := range credential.TokenBindings {
|
|
if subtle.ConstantTimeCompare([]byte(binding.TokenHash), []byte(hash)) == 1 {
|
|
return binding.DeviceID
|
|
}
|
|
}
|
|
return credential.DeviceID
|
|
}
|
|
|
|
func currentObjectSyncCredential(request *http.Request) (*objectSyncCredentialPrincipal, bool) {
|
|
value, ok := request.Context().Value(objectSyncCredentialContextKey{}).(*objectSyncCredentialPrincipal)
|
|
return value, ok && value != nil
|
|
}
|
|
|
|
func objectSyncManagementPrincipal(request *http.Request) *authenticatedPrincipal {
|
|
if principal, ok := currentPrincipal(request); ok {
|
|
return principal
|
|
}
|
|
return &authenticatedPrincipal{
|
|
User: domain.UserRecord{
|
|
ID: "legacy-admin",
|
|
OrganizationID: domain.DefaultOrganizationID,
|
|
Role: domain.UserRoleAdmin,
|
|
},
|
|
}
|
|
}
|
|
|
|
func objectSyncCredentialScopeFor(credential domain.ObjectSyncCredentialRecord, syncSpaceID string) (*domain.ObjectSyncCredentialScope, bool) {
|
|
for index := range credential.Scopes {
|
|
if credential.Scopes[index].SyncSpaceID == syncSpaceID {
|
|
return &credential.Scopes[index], true
|
|
}
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
func objectSyncScopeAllows(scope domain.ObjectSyncCredentialScope, action, relativePath string) bool {
|
|
if !objectSyncScopeAllowsAction(scope, action) {
|
|
return false
|
|
}
|
|
if len(scope.AllowedRelativePrefixes) == 0 {
|
|
return true
|
|
}
|
|
for _, prefix := range scope.AllowedRelativePrefixes {
|
|
normalized := strings.Trim(strings.ReplaceAll(strings.TrimSpace(prefix), "\\", "/"), "/")
|
|
if normalized == "" || relativePath == normalized || strings.HasPrefix(relativePath, normalized+"/") {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func objectSyncScopeAllowsAction(scope domain.ObjectSyncCredentialScope, action string) bool {
|
|
for _, candidate := range scope.Actions {
|
|
if candidate == action || candidate == "*" {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func normalizeObjectSyncRelativePath(value string) (string, error) {
|
|
value = strings.TrimSpace(strings.ReplaceAll(value, "\\", "/"))
|
|
if value == "" || strings.HasPrefix(value, "/") || strings.ContainsRune(value, '\x00') {
|
|
return "", fmt.Errorf("relativePath must be a non-empty relative path")
|
|
}
|
|
for _, part := range strings.Split(value, "/") {
|
|
if part == "" || part == "." || part == ".." {
|
|
return "", fmt.Errorf("relativePath contains an invalid path segment")
|
|
}
|
|
for _, character := range part {
|
|
if character < 0x20 || character == 0x7f {
|
|
return "", fmt.Errorf("relativePath contains control characters")
|
|
}
|
|
}
|
|
}
|
|
if len([]byte(value)) > objectStorageKeyMaxUTF8Bytes {
|
|
return "", fmt.Errorf("relativePath exceeds the BOS key size limit")
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func objectSyncTargetKey(space domain.ObjectSyncSpaceRecord, relativePath string) string {
|
|
root := strings.Trim(strings.TrimSpace(space.RootPrefix), "/")
|
|
if root == "" {
|
|
return relativePath
|
|
}
|
|
return root + "/" + relativePath
|
|
}
|
|
|
|
func objectSyncMetadataValue(metadata map[string]any, key string) string {
|
|
for candidate, value := range metadata {
|
|
if strings.EqualFold(strings.TrimSpace(candidate), key) {
|
|
return strings.TrimSpace(fmt.Sprint(value))
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func objectSyncStagingMatches(result domain.ObjectStorageObjectSummary, item *domain.ObjectSyncItemRecord, session *domain.ObjectSyncSessionRecord) bool {
|
|
return strings.TrimSpace(result.ETag) != "" &&
|
|
objectSyncMetadataValue(result.Metadata, "drosync-session") == session.ID &&
|
|
objectSyncMetadataValue(result.Metadata, "drosync-item") == item.ID &&
|
|
objectSyncMetadataValue(result.Metadata, "drosync-sha256") == item.SHA256
|
|
}
|
|
|
|
func sanitizeObjectSyncCredential(item domain.ObjectSyncCredentialRecord) domain.ObjectSyncCredentialRecord {
|
|
item.SecretHash = ""
|
|
item.TokenHash = ""
|
|
item.TokenHashes = nil
|
|
item.TokenBindings = nil
|
|
return item
|
|
}
|
|
|
|
func (server *server) appendObjectSyncAudit(ctx context.Context, target store.ObjectSyncStore, event domain.ObjectSyncAuditEvent) error {
|
|
return objectsync.AppendAudit(ctx, target, event)
|
|
}
|
|
|
|
func (server *server) requireObjectSyncAudit(writer http.ResponseWriter, request *http.Request, target store.ObjectSyncStore, event domain.ObjectSyncAuditEvent) bool {
|
|
if err := server.appendObjectSyncAudit(request.Context(), target, event); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "audit_persist_failed", "The state change completed but its audit event could not be persisted; query current state before retrying", true, map[string]any{"cause": err.Error()})
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (server *server) objectSyncBrowser(ctx context.Context, space *domain.ObjectSyncSpaceRecord) (objectSyncStorageBrowser, func(), error) {
|
|
connection, err := server.store.GetStorageConnection(ctx, space.ConnectionID)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if connection == nil || normalizedOrganizationID(connection.OrganizationID) != normalizedOrganizationID(space.OrganizationID) {
|
|
return nil, nil, fmt.Errorf("storage connection not found in the sync space organization")
|
|
}
|
|
browser, closeBrowser, err := storageConnectionBrowserResolver(ctx, server.storageConnectionWithResolvedEndpoint(connection))
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
target, ok := browser.(objectSyncStorageBrowser)
|
|
if !ok {
|
|
if closeBrowser != nil {
|
|
closeBrowser()
|
|
}
|
|
return nil, nil, fmt.Errorf("storage provider does not implement conditional object sync operations")
|
|
}
|
|
return target, closeBrowser, nil
|
|
}
|
|
|
|
func isObjectSyncPreconditionFailure(err error) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
var serviceError *bce.BceServiceError
|
|
return errors.As(err, &serviceError) && serviceError.StatusCode == http.StatusPreconditionFailed
|
|
}
|
|
|
|
func (server *server) handleObjectSyncSpacesList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
items, err := target.ListObjectSyncSpaces(request.Context(), principal.User.OrganizationID)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "spaces_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if principal.User.Role == domain.UserRoleDataOperator {
|
|
filtered := items[:0]
|
|
for _, item := range items {
|
|
if objectSyncSpaceAllowsUser(item, principal.User) {
|
|
filtered = append(filtered, item)
|
|
}
|
|
}
|
|
items = filtered
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func objectSyncSpaceAllowsUser(space domain.ObjectSyncSpaceRecord, user domain.UserRecord) bool {
|
|
if user.Role != domain.UserRoleDataOperator {
|
|
return true
|
|
}
|
|
for _, userID := range space.OperatorUserIDs {
|
|
if userID == user.ID {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (server *server) normalizeObjectSyncOperatorUserIDs(ctx context.Context, organizationID string, values []string) ([]string, error) {
|
|
seen := make(map[string]struct{}, len(values))
|
|
result := make([]string, 0, len(values))
|
|
for _, value := range values {
|
|
userID := strings.TrimSpace(value)
|
|
if userID == "" {
|
|
continue
|
|
}
|
|
if _, exists := seen[userID]; exists {
|
|
continue
|
|
}
|
|
user, err := server.store.GetUser(ctx, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if user == nil || normalizedOrganizationID(user.OrganizationID) != normalizedOrganizationID(organizationID) || user.Role != domain.UserRoleDataOperator {
|
|
return nil, fmt.Errorf("operatorUserIds must refer to data_operator users in this organization")
|
|
}
|
|
seen[userID] = struct{}{}
|
|
result = append(result, userID)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (server *server) handleObjectSyncSpaceCreate(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
var input struct {
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
ConnectionID string `json:"connectionId"`
|
|
Bucket string `json:"bucket"`
|
|
RootPrefix string `json:"rootPrefix"`
|
|
OperatorUserIDs []string `json:"operatorUserIds"`
|
|
Policy *domain.ObjectSyncSpacePolicy `json:"policy"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
input.Name = strings.TrimSpace(input.Name)
|
|
input.ConnectionID = strings.TrimSpace(input.ConnectionID)
|
|
input.Bucket = strings.TrimSpace(input.Bucket)
|
|
if input.Name == "" || input.ConnectionID == "" || input.Bucket == "" {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_space", "name, connectionId and bucket are required", false, nil)
|
|
return
|
|
}
|
|
operatorUserIDs, err := server.normalizeObjectSyncOperatorUserIDs(request.Context(), principal.User.OrganizationID, input.OperatorUserIDs)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_operator_assignment", err.Error(), false, nil)
|
|
return
|
|
}
|
|
connection, err := server.store.GetStorageConnection(request.Context(), input.ConnectionID)
|
|
if err != nil || connection == nil || normalizedOrganizationID(connection.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID) {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_storage_connection", "The storage connection is not available in this organization", false, nil)
|
|
return
|
|
}
|
|
policy := domain.DefaultObjectSyncSpacePolicy()
|
|
if input.Policy != nil {
|
|
policy = *input.Policy
|
|
}
|
|
policy.AllowDelete = false
|
|
policy.DefaultConflictResolution = "keep_both"
|
|
now := nowISO()
|
|
item := domain.ObjectSyncSpaceRecord{
|
|
ID: objectSyncNewID("oss"),
|
|
OrganizationID: principal.User.OrganizationID,
|
|
OperatorUserIDs: operatorUserIDs,
|
|
Name: input.Name,
|
|
Description: strings.TrimSpace(input.Description),
|
|
ConnectionID: input.ConnectionID,
|
|
Bucket: input.Bucket,
|
|
RootPrefix: strings.Trim(strings.TrimSpace(input.RootPrefix), "/"),
|
|
Mode: "blocked",
|
|
Enabled: false,
|
|
Policy: policy,
|
|
Capability: domain.ObjectSyncCapabilityRecord{
|
|
State: domain.ObjectSyncCapabilityUnverified,
|
|
},
|
|
CreatedBy: principal.User.ID,
|
|
UpdatedBy: principal.User.ID,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := target.UpsertObjectSyncSpace(request.Context(), item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_create_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: item.OrganizationID,
|
|
ActorType: "user",
|
|
ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request),
|
|
Action: "space.create",
|
|
Target: map[string]any{"spaceId": item.ID},
|
|
Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, item)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncSpaceUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
item, err := target.GetObjectSyncSpace(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil || item == nil || !server.ensureTenantAccess(writer, request, objectSyncOrganization(item.OrganizationID), "Object sync space") {
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_lookup_failed", err.Error(), true, nil)
|
|
}
|
|
return
|
|
}
|
|
var input struct {
|
|
Name *string `json:"name"`
|
|
Description *string `json:"description"`
|
|
Enabled *bool `json:"enabled"`
|
|
ExclusivePrefixConfirmed *bool `json:"exclusivePrefixConfirmed"`
|
|
AllowForceOverwrite *bool `json:"allowForceOverwrite"`
|
|
OperatorUserIDs *[]string `json:"operatorUserIds"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
wasDrifted := item.Capability.State == domain.ObjectSyncCapabilityDrifted
|
|
if input.Name != nil && strings.TrimSpace(*input.Name) != "" {
|
|
item.Name = strings.TrimSpace(*input.Name)
|
|
}
|
|
if input.Description != nil {
|
|
item.Description = strings.TrimSpace(*input.Description)
|
|
}
|
|
if input.OperatorUserIDs != nil {
|
|
operatorUserIDs, normalizeErr := server.normalizeObjectSyncOperatorUserIDs(request.Context(), principal.User.OrganizationID, *input.OperatorUserIDs)
|
|
if normalizeErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_operator_assignment", normalizeErr.Error(), false, nil)
|
|
return
|
|
}
|
|
item.OperatorUserIDs = operatorUserIDs
|
|
}
|
|
if input.ExclusivePrefixConfirmed != nil {
|
|
item.Capability.ExclusivePrefixConfirmed = *input.ExclusivePrefixConfirmed
|
|
}
|
|
prospectiveState := item.Capability.State
|
|
if !wasDrifted {
|
|
prospectiveState = domain.ObjectSyncCapabilityUnsupported
|
|
if item.Capability.ConditionalCreate {
|
|
prospectiveState = domain.ObjectSyncCapabilityCreateOnly
|
|
}
|
|
if item.Capability.ConditionalCreate &&
|
|
item.Capability.ConditionalUpdate &&
|
|
item.Capability.ConditionalMultipart &&
|
|
item.Capability.ExclusivePrefixConfirmed {
|
|
prospectiveState = domain.ObjectSyncCapabilityUpdateEnabled
|
|
}
|
|
}
|
|
if input.AllowForceOverwrite != nil {
|
|
if *input.AllowForceOverwrite && prospectiveState != domain.ObjectSyncCapabilityUpdateEnabled {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "force_overwrite_gate_failed", "Force overwrite requires update-enabled capability and exclusive prefix confirmation", false, map[string]any{"state": item.Capability.State})
|
|
return
|
|
}
|
|
item.Policy.AllowForceOverwrite = *input.AllowForceOverwrite
|
|
}
|
|
if input.Enabled != nil {
|
|
if *input.Enabled && prospectiveState != domain.ObjectSyncCapabilityCreateOnly && prospectiveState != domain.ObjectSyncCapabilityUpdateEnabled {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "capability_gate_failed", "The space cannot be enabled before a successful conditional-create probe", false, map[string]any{"state": item.Capability.State})
|
|
return
|
|
}
|
|
item.Enabled = *input.Enabled
|
|
}
|
|
item.Capability.State = prospectiveState
|
|
item.Mode = "blocked"
|
|
item.Policy.AllowConditionalUpdate = prospectiveState == domain.ObjectSyncCapabilityUpdateEnabled
|
|
if prospectiveState == domain.ObjectSyncCapabilityCreateOnly {
|
|
item.Mode = "create_only"
|
|
}
|
|
if prospectiveState == domain.ObjectSyncCapabilityUpdateEnabled {
|
|
item.Mode = "update_enabled"
|
|
}
|
|
if prospectiveState != domain.ObjectSyncCapabilityUpdateEnabled {
|
|
item.Policy.AllowForceOverwrite = false
|
|
}
|
|
if wasDrifted {
|
|
item.Enabled = false
|
|
}
|
|
item.UpdatedBy = principal.User.ID
|
|
item.UpdatedAt = nowISO()
|
|
if err := target.UpsertObjectSyncSpace(request.Context(), *item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_update_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: item.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request), Action: "space.update",
|
|
Target: map[string]any{"spaceId": item.ID}, Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func objectSyncOrganization(value string) string {
|
|
return normalizedOrganizationID(value)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncCapabilityProbe(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
space, err := target.GetObjectSyncSpace(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil || space == nil || normalizedOrganizationID(space.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID) {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Object sync space not found", false, nil)
|
|
return
|
|
}
|
|
wasDrifted := space.Capability.State == domain.ObjectSyncCapabilityDrifted
|
|
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "capability_probe_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
defer closeBrowser()
|
|
probeID := objectSyncNewID("probe")
|
|
probePrefix := strings.Trim(strings.TrimSpace(space.RootPrefix), "/")
|
|
if probePrefix != "" {
|
|
probePrefix += "/"
|
|
}
|
|
createKey := probePrefix + ".drosync-probe/" + probeID + "/conditional"
|
|
copySourceKey := probePrefix + ".drosync-probe/" + probeID + "/copy-source"
|
|
copyTargetKey := probePrefix + ".drosync-probe/" + probeID + "/copy-target"
|
|
defer func() {
|
|
_ = browser.DeleteObject(context.Background(), space.Bucket, createKey)
|
|
_ = browser.DeleteObject(context.Background(), space.Bucket, copySourceKey)
|
|
_ = browser.DeleteObject(context.Background(), space.Bucket, copyTargetKey)
|
|
}()
|
|
capability := domain.ObjectSyncCapabilityRecord{State: domain.ObjectSyncCapabilityUnsupported, ProbedAt: nowISO()}
|
|
created, err := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("drosync-probe-v1"), "application/octet-stream", "", "*", map[string]string{"drosync-probe": probeID})
|
|
if err == nil {
|
|
_, repeatErr := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("must-not-overwrite"), "application/octet-stream", "", "*", nil)
|
|
capability.ConditionalCreate = isObjectSyncPreconditionFailure(repeatErr)
|
|
}
|
|
if err == nil && capability.ConditionalCreate {
|
|
updated, updateErr := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("drosync-probe-v2"), "application/octet-stream", created.ETag, "", nil)
|
|
if updateErr == nil {
|
|
_, staleErr := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("must-not-overwrite"), "application/octet-stream", created.ETag, "", nil)
|
|
capability.ConditionalUpdate = isObjectSyncPreconditionFailure(staleErr)
|
|
capability.VersionID = strings.TrimSpace(updated.VersionID) != ""
|
|
}
|
|
_, sourceErr := browser.PutObject(request.Context(), space.Bucket, copySourceKey, []byte("multipart-copy-probe"), "application/octet-stream")
|
|
if sourceErr == nil {
|
|
published, publishErr := browser.PublishMultipartCopyConditional(request.Context(), space.Bucket, copySourceKey, copyTargetKey, int64(len("multipart-copy-probe")), "", "", "*", map[string]string{"drosync-probe": probeID})
|
|
capability.MultipartCopy = publishErr == nil
|
|
if publishErr == nil {
|
|
_, repeatPublishErr := browser.PublishMultipartCopyConditional(request.Context(), space.Bucket, copySourceKey, copyTargetKey, int64(len("multipart-copy-probe")), "", "", "*", nil)
|
|
capability.ConditionalMultipart = isObjectSyncPreconditionFailure(repeatPublishErr)
|
|
capability.VersionID = capability.VersionID || strings.TrimSpace(published.VersionID) != ""
|
|
}
|
|
}
|
|
}
|
|
if versioning, versionErr := browser.GetBucketVersioning(request.Context(), space.Bucket); versionErr == nil && strings.EqualFold(versioning, "enabled") {
|
|
capability.VersionID = true
|
|
}
|
|
if err != nil {
|
|
capability.ProbeError = err.Error()
|
|
} else if !capability.ConditionalCreate {
|
|
capability.ProbeError = "If-None-Match: * did not reject a duplicate create"
|
|
}
|
|
capability.ExclusivePrefixConfirmed = space.Capability.ExclusivePrefixConfirmed
|
|
if capability.ConditionalCreate {
|
|
capability.State = domain.ObjectSyncCapabilityCreateOnly
|
|
}
|
|
if capability.ConditionalCreate && capability.ConditionalUpdate && capability.ConditionalMultipart && capability.ExclusivePrefixConfirmed {
|
|
capability.State = domain.ObjectSyncCapabilityUpdateEnabled
|
|
}
|
|
if wasDrifted {
|
|
capability.State = domain.ObjectSyncCapabilityDrifted
|
|
}
|
|
space.Capability = capability
|
|
space.Mode = "blocked"
|
|
space.Enabled = false
|
|
if capability.State == domain.ObjectSyncCapabilityCreateOnly {
|
|
space.Mode = "create_only"
|
|
}
|
|
if capability.State == domain.ObjectSyncCapabilityUpdateEnabled {
|
|
space.Mode = "update_enabled"
|
|
}
|
|
space.Policy.AllowConditionalUpdate = capability.State == domain.ObjectSyncCapabilityUpdateEnabled
|
|
if capability.State != domain.ObjectSyncCapabilityUpdateEnabled {
|
|
space.Policy.AllowForceOverwrite = false
|
|
}
|
|
space.UpdatedBy = principal.User.ID
|
|
space.UpdatedAt = nowISO()
|
|
if err := target.UpsertObjectSyncSpace(request.Context(), *space); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "capability_save_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: space.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request), Action: "space.capability_probe",
|
|
Target: map[string]any{"spaceId": space.ID}, After: map[string]any{"capability": capability},
|
|
Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, space)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncReconcileCreate(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
space, err := target.GetObjectSyncSpace(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_lookup_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if space == nil || space.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Object sync space not found", false, nil)
|
|
return
|
|
}
|
|
now := nowISO()
|
|
item := domain.ObjectSyncReconcileRecord{
|
|
ID: objectSyncNewID("osrec"),
|
|
OperationID: objectSyncNewID("op"),
|
|
OrganizationID: space.OrganizationID,
|
|
SyncSpaceID: space.ID,
|
|
Status: "pending",
|
|
CreatedBy: principal.User.ID,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := target.UpsertObjectSyncReconcile(request.Context(), item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "reconcile_enqueue_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: space.OrganizationID,
|
|
ActorType: "user",
|
|
ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request),
|
|
Action: "space.reconcile",
|
|
Target: map[string]any{"spaceId": space.ID, "operationId": item.OperationID},
|
|
Result: "accepted",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusAccepted, item)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncDevicesList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
items, err := target.ListObjectSyncDevices(request.Context(), principal.User.OrganizationID)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "devices_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleObjectSyncAuthorizationsList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
items, err := target.ListObjectSyncAuthorizations(request.Context(), principal.User.OrganizationID, strings.TrimSpace(request.URL.Query().Get("status")))
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "authorizations_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func normalizeObjectSyncUserCode(value string) string {
|
|
return strings.ToUpper(strings.NewReplacer("-", "", " ", "").Replace(strings.TrimSpace(value)))
|
|
}
|
|
|
|
func (server *server) handleObjectSyncAuthorizationLookup(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
code := normalizeObjectSyncUserCode(request.URL.Query().Get("userCode"))
|
|
if len(code) < 6 || len(code) > 16 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_user_code", "userCode must contain 6 to 16 base32 characters", false, nil)
|
|
return
|
|
}
|
|
item, err := target.GetObjectSyncAuthorizationByUserCode(request.Context(), code)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "authorization_lookup_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if item == nil ||
|
|
(item.OrganizationID != "" && normalizedOrganizationID(item.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID)) {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "authorization_not_found", "Pairing request not found", false, nil)
|
|
return
|
|
}
|
|
if item.Status != "pending" {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "authorization_not_pending", "Pairing request is no longer pending", false, map[string]any{"status": item.Status})
|
|
return
|
|
}
|
|
if time.Now().UTC().After(item.ExpiresAtTime) {
|
|
renderObjectSyncError(writer, request, http.StatusGone, "device_code_expired", "Pairing request expired", false, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncAuthorizationDecision(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
item, err := target.GetObjectSyncAuthorization(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil ||
|
|
item == nil ||
|
|
item.Status != "pending" ||
|
|
(item.OrganizationID != "" && normalizedOrganizationID(item.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID)) {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "authorization_not_pending", "Pending device authorization not found", false, nil)
|
|
return
|
|
}
|
|
if time.Now().UTC().After(item.ExpiresAtTime) {
|
|
renderObjectSyncError(writer, request, http.StatusGone, "device_code_expired", "Pairing request expired", false, nil)
|
|
return
|
|
}
|
|
var input struct {
|
|
Scopes []domain.ObjectSyncCredentialScope `json:"scopes"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
decision := chi.URLParam(request, "decision")
|
|
if decision != "approve" && decision != "deny" {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_decision", "Decision must be approve or deny", false, nil)
|
|
return
|
|
}
|
|
if decision == "approve" {
|
|
if len(input.Scopes) == 0 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "scopes_required", "At least one approved sync space scope is required", false, nil)
|
|
return
|
|
}
|
|
for _, scope := range input.Scopes {
|
|
space, lookupErr := target.GetObjectSyncSpace(request.Context(), scope.SyncSpaceID)
|
|
if lookupErr != nil || space == nil || space.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_scope", "An approved scope refers to an unavailable sync space", false, map[string]any{"syncSpaceId": scope.SyncSpaceID})
|
|
return
|
|
}
|
|
}
|
|
quotaSum := sha256.Sum256([]byte("device-quota\x00" + principal.User.OrganizationID))
|
|
quotaHash := hex.EncodeToString(quotaSum[:])
|
|
quotaOwner := objectSyncRequestID(request)
|
|
quotaLease, acquired, quotaErr := target.AcquireObjectSyncLease(request.Context(), domain.ObjectSyncLeaseRecord{
|
|
OrganizationID: principal.User.OrganizationID,
|
|
ResourceHash: quotaHash,
|
|
ResourceType: "device_quota",
|
|
KeyOrPrefix: principal.User.OrganizationID,
|
|
OwnerSessionID: quotaOwner,
|
|
OwnerItemID: item.ID,
|
|
}, 30*time.Second)
|
|
if quotaErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "device_quota_unavailable", quotaErr.Error(), true, nil)
|
|
return
|
|
}
|
|
if !acquired {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "device_quota_busy", "Another device approval is being processed; retry this request", true, nil)
|
|
return
|
|
}
|
|
defer func() {
|
|
_ = target.ReleaseObjectSyncLease(context.Background(), quotaHash, quotaOwner, item.ID, quotaLease.FencingToken)
|
|
}()
|
|
existingDevice, lookupErr := target.GetObjectSyncDevice(request.Context(), item.DeviceID)
|
|
if lookupErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_lookup_failed", lookupErr.Error(), true, nil)
|
|
return
|
|
}
|
|
if existingDevice == nil {
|
|
devices, devicesErr := target.ListObjectSyncDevices(request.Context(), principal.User.OrganizationID)
|
|
approved, approvedErr := target.ListObjectSyncAuthorizations(request.Context(), principal.User.OrganizationID, "approved")
|
|
if devicesErr != nil || approvedErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_quota_check_failed", "Could not verify the organization device quota", true, nil)
|
|
return
|
|
}
|
|
distinctDevices := make(map[string]struct{}, len(devices)+len(approved))
|
|
for _, device := range devices {
|
|
distinctDevices[device.ID] = struct{}{}
|
|
}
|
|
for _, authorization := range approved {
|
|
distinctDevices[authorization.DeviceID] = struct{}{}
|
|
}
|
|
if _, alreadyCounted := distinctDevices[item.DeviceID]; !alreadyCounted && len(distinctDevices) >= objectSyncMaxOrgDevices {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "device_quota_exceeded", "The organization has reached its 500-device limit", false, map[string]any{"limit": objectSyncMaxOrgDevices})
|
|
return
|
|
}
|
|
}
|
|
item.Status = "approved"
|
|
item.OrganizationID = principal.User.OrganizationID
|
|
item.Scopes = input.Scopes
|
|
item.ApprovedBy = principal.User.ID
|
|
} else {
|
|
item.Status = "denied"
|
|
item.OrganizationID = principal.User.OrganizationID
|
|
item.ApprovedBy = principal.User.ID
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := target.UpsertObjectSyncAuthorization(request.Context(), *item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "authorization_update_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: principal.User.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request), Action: "device_authorization." + decision,
|
|
Target: map[string]any{"authorizationId": item.ID, "deviceId": item.DeviceID}, Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncCredentialsList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
items, err := target.ListObjectSyncCredentials(request.Context(), principal.User.OrganizationID)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credentials_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
for index := range items {
|
|
items[index] = sanitizeObjectSyncCredential(items[index])
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleObjectSyncCredentialMutation(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
item, err := target.GetObjectSyncCredential(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil || item == nil || item.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "credential_not_found", "Device credential not found", false, nil)
|
|
return
|
|
}
|
|
action := chi.URLParam(request, "action")
|
|
now := nowISO()
|
|
response := map[string]any{}
|
|
if action == "revoke" {
|
|
item.Enabled = false
|
|
item.RevokedAt = now
|
|
} else if action == "rotate" {
|
|
secretToken, secretErr := randomURLToken(32)
|
|
if secretErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_rotate_failed", secretErr.Error(), true, nil)
|
|
return
|
|
}
|
|
secret := "dss_" + secretToken
|
|
secretHash, hashErr := hashObjectSyncSecret(secret)
|
|
if hashErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_rotate_failed", hashErr.Error(), true, nil)
|
|
return
|
|
}
|
|
placeholder, placeholderErr := randomURLToken(32)
|
|
if placeholderErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_rotate_failed", placeholderErr.Error(), true, nil)
|
|
return
|
|
}
|
|
if item.AccessKeyID == "" {
|
|
item.AccessKeyID = objectSyncNewID("dsk")
|
|
}
|
|
item.SecretHash = secretHash
|
|
item.SecretPreview = objectSyncSecretPreview(secret)
|
|
item.TokenHash = sessionTokenHash(placeholder)
|
|
item.TokenHashes = nil
|
|
item.TokenBindings = nil
|
|
item.TokenPreview = item.SecretPreview
|
|
item.Enabled = true
|
|
item.RevokedAt = ""
|
|
response["secret"] = secret
|
|
} else {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_credential_action", "Action must be rotate or revoke", false, nil)
|
|
return
|
|
}
|
|
item.UpdatedAt = now
|
|
if err := target.UpsertObjectSyncCredential(request.Context(), *item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_update_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
response["credential"] = sanitizeObjectSyncCredential(*item)
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: item.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request), Action: "credential." + action,
|
|
Target: map[string]any{"credentialId": item.ID, "deviceId": item.DeviceID}, Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, response)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncSessionsList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
syncSpaceIDs := []string(nil)
|
|
if principal.User.Role == domain.UserRoleDataOperator {
|
|
spaces, listErr := target.ListObjectSyncSpaces(request.Context(), principal.User.OrganizationID)
|
|
if listErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "spaces_list_failed", listErr.Error(), true, nil)
|
|
return
|
|
}
|
|
for _, space := range spaces {
|
|
if objectSyncSpaceAllowsUser(space, principal.User) {
|
|
syncSpaceIDs = append(syncSpaceIDs, space.ID)
|
|
}
|
|
}
|
|
if len(syncSpaceIDs) == 0 {
|
|
renderJSON(writer, http.StatusOK, domain.ObjectSyncSessionPage{Items: []domain.ObjectSyncSessionRecord{}})
|
|
return
|
|
}
|
|
}
|
|
page, err := target.ListObjectSyncSessions(request.Context(), domain.ObjectSyncListQuery{
|
|
OrganizationID: principal.User.OrganizationID,
|
|
SyncSpaceIDs: syncSpaceIDs,
|
|
Status: strings.TrimSpace(request.URL.Query().Get("status")),
|
|
Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
|
|
Limit: objectSyncQueryLimit(request),
|
|
})
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "sessions_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, page)
|
|
}
|
|
|
|
func objectSyncQueryLimit(request *http.Request) int {
|
|
value, _ := strconv.Atoi(strings.TrimSpace(request.URL.Query().Get("limit")))
|
|
if value <= 0 {
|
|
return 100
|
|
}
|
|
if value > 1000 {
|
|
return 1000
|
|
}
|
|
return value
|
|
}
|
|
|
|
func (server *server) handleObjectSyncSessionGet(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, err := target.GetObjectSyncSession(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil || item == nil {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
|
|
return
|
|
}
|
|
if principal, signedIn := currentPrincipal(request); signedIn && item.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
|
|
return
|
|
}
|
|
if principal, signedIn := currentPrincipal(request); signedIn && principal.User.Role == domain.UserRoleDataOperator {
|
|
space, lookupErr := target.GetObjectSyncSpace(request.Context(), item.SyncSpaceID)
|
|
if lookupErr != nil || space == nil || !objectSyncSpaceAllowsUser(*space, principal.User) {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
|
|
return
|
|
}
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncSessionItems(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
session, err := target.GetObjectSyncSession(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil || session == nil {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
|
|
return
|
|
}
|
|
if principal, signedIn := currentPrincipal(request); signedIn && session.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
|
|
return
|
|
}
|
|
if principal, signedIn := currentPrincipal(request); signedIn && principal.User.Role == domain.UserRoleDataOperator {
|
|
space, lookupErr := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
if lookupErr != nil || space == nil || !objectSyncSpaceAllowsUser(*space, principal.User) {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
|
|
return
|
|
}
|
|
}
|
|
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{
|
|
SessionID: session.ID,
|
|
Status: strings.TrimSpace(request.URL.Query().Get("status")),
|
|
Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
|
|
Limit: objectSyncQueryLimit(request),
|
|
})
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "items_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, page)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncSessionAdminAbort(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
item, err := target.GetObjectSyncSession(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil || item == nil || item.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
|
|
return
|
|
}
|
|
item.Status = domain.ObjectSyncSessionAborted
|
|
item.UpdatedAt = nowISO()
|
|
item.CompletedAt = item.UpdatedAt
|
|
if err := target.UpsertObjectSyncSession(request.Context(), *item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_abort_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncLeaseForceRelease(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
item, changed, err := target.ForceReleaseObjectSyncLease(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "lease_release_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if item == nil || item.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "lease_not_found", "Lease not found", false, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: item.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request), Action: "lease.force_release",
|
|
Target: map[string]any{"leaseId": item.ID, "key": item.KeyOrPrefix}, Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"lease": item, "released": changed})
|
|
}
|
|
|
|
func (server *server) handleObjectSyncItemForceOverwrite(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
conflict, err := target.GetObjectSyncItem(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "item_lookup_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if conflict == nil || conflict.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "conflict_not_found", "Keep-both conflict item not found", false, nil)
|
|
return
|
|
}
|
|
if conflict.Status != domain.ObjectSyncItemKeptBoth || conflict.LogicalTargetKey == "" || conflict.TargetKey == conflict.LogicalTargetKey {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_conflicted", "Only a keep-both item with a preserved conflict object can be force-overwritten", false, nil)
|
|
return
|
|
}
|
|
session, err := target.GetObjectSyncSession(request.Context(), conflict.SessionID)
|
|
if err != nil || session == nil || session.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Conflict session not found", false, nil)
|
|
return
|
|
}
|
|
space, err := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
if err != nil || space == nil || space.OrganizationID != principal.User.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Conflict sync space not found", false, nil)
|
|
return
|
|
}
|
|
if space.Capability.State != domain.ObjectSyncCapabilityUpdateEnabled ||
|
|
!space.Capability.ExclusivePrefixConfirmed ||
|
|
!space.Policy.AllowConditionalUpdate ||
|
|
!space.Policy.AllowForceOverwrite {
|
|
renderObjectSyncError(writer, request, http.StatusForbidden, "force_overwrite_disabled", "Force overwrite is disabled or the update/exclusive-prefix gate is not satisfied", false, nil)
|
|
return
|
|
}
|
|
now := nowISO()
|
|
purgeAt := conflict.PurgeAt
|
|
if purgeAt.IsZero() {
|
|
purgeAt = time.Now().UTC().Add(90 * 24 * time.Hour)
|
|
}
|
|
forceItem := domain.ObjectSyncItemRecord{
|
|
ID: objectSyncNewID("osi"),
|
|
OrganizationID: conflict.OrganizationID,
|
|
SessionID: conflict.SessionID,
|
|
ClientItemID: conflict.ClientItemID + ":force:" + objectSyncNewID("op"),
|
|
ManifestPage: conflict.ManifestPage,
|
|
RelativePath: conflict.RelativePath,
|
|
NormalizedRelativePath: conflict.NormalizedRelativePath,
|
|
TargetKey: conflict.LogicalTargetKey,
|
|
LogicalTargetKey: conflict.LogicalTargetKey,
|
|
SizeBytes: conflict.SizeBytes,
|
|
ModifiedAt: conflict.ModifiedAt,
|
|
SHA256: conflict.SHA256,
|
|
ContentType: conflict.ContentType,
|
|
Action: "force_overwrite",
|
|
Status: domain.ObjectSyncItemCommitting,
|
|
ForceSourceKey: conflict.TargetKey,
|
|
ForceActorID: principal.User.ID,
|
|
OperationID: objectSyncNewID("op"),
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
PurgeAt: purgeAt,
|
|
}
|
|
resourceHash := objectSyncLeaseResourceHash(*space, forceItem.TargetKey)
|
|
lease, acquired, err := target.AcquireObjectSyncLease(request.Context(), domain.ObjectSyncLeaseRecord{
|
|
ID: "osl_" + resourceHash,
|
|
OrganizationID: forceItem.OrganizationID,
|
|
ResourceHash: resourceHash,
|
|
ResourceType: "object",
|
|
ConnectionID: space.ConnectionID,
|
|
Bucket: space.Bucket,
|
|
KeyOrPrefix: forceItem.TargetKey,
|
|
OwnerSessionID: forceItem.SessionID,
|
|
OwnerItemID: forceItem.ID,
|
|
}, objectSyncLeaseTTL)
|
|
if err != nil || !acquired {
|
|
status := http.StatusConflict
|
|
code := "lease_held"
|
|
retryable := true
|
|
message := "Another operation currently holds the logical object key"
|
|
if err != nil && !errors.Is(err, store.ErrObjectSyncLeaseHeld) {
|
|
status = http.StatusInternalServerError
|
|
code = "lease_acquire_failed"
|
|
message = err.Error()
|
|
}
|
|
renderObjectSyncError(writer, request, status, code, message, retryable, nil)
|
|
return
|
|
}
|
|
forceItem.LeaseID = lease.ID
|
|
forceItem.FencingToken = lease.FencingToken
|
|
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{forceItem}); err != nil {
|
|
_ = target.ReleaseObjectSyncLease(request.Context(), lease.ID, forceItem.SessionID, forceItem.ID, forceItem.FencingToken)
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "force_overwrite_enqueue_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: forceItem.OrganizationID,
|
|
ActorType: "user",
|
|
ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request),
|
|
SessionID: forceItem.SessionID,
|
|
ItemID: forceItem.ID,
|
|
Action: "item.force_overwrite",
|
|
Target: map[string]any{
|
|
"conflictItemId": conflict.ID,
|
|
"sourceKey": forceItem.ForceSourceKey,
|
|
"targetKey": forceItem.TargetKey,
|
|
},
|
|
Result: "accepted",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": forceItem.OperationID, "item": forceItem})
|
|
}
|
|
|
|
func (server *server) handleObjectSyncReleasesList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
items, err := target.ListObjectSyncReleases(request.Context(), principal.User.OrganizationID)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "releases_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleObjectSyncReleaseCreate(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
var input struct {
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
SessionIDs []string `json:"sessionIds"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(input.Name) == "" || len(input.SessionIDs) == 0 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_release", "name and sessionIds are required", false, nil)
|
|
return
|
|
}
|
|
releaseSpaceID := ""
|
|
seenSessions := make(map[string]struct{}, len(input.SessionIDs))
|
|
for _, sessionID := range input.SessionIDs {
|
|
if _, duplicate := seenSessions[sessionID]; duplicate {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "duplicate_release_session", "sessionIds must not contain duplicates", false, map[string]any{"sessionId": sessionID})
|
|
return
|
|
}
|
|
seenSessions[sessionID] = struct{}{}
|
|
session, err := target.GetObjectSyncSession(request.Context(), sessionID)
|
|
if err != nil || session == nil || session.OrganizationID != principal.User.OrganizationID || (session.Status != domain.ObjectSyncSessionCompleted && session.Status != domain.ObjectSyncSessionConflicted && session.Status != domain.ObjectSyncSessionPartial) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "release_session_not_final", "Every release session must be final and belong to the organization", false, map[string]any{"sessionId": sessionID})
|
|
return
|
|
}
|
|
if releaseSpaceID == "" {
|
|
releaseSpaceID = session.SyncSpaceID
|
|
} else if session.SyncSpaceID != releaseSpaceID {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "release_space_mismatch", "All release sessions must belong to one sync space", false, map[string]any{"sessionId": sessionID, "syncSpaceId": session.SyncSpaceID, "expectedSyncSpaceId": releaseSpaceID})
|
|
return
|
|
}
|
|
}
|
|
item := domain.ObjectSyncReleaseRecord{
|
|
ID: objectSyncNewID("osr"),
|
|
OrganizationID: principal.User.OrganizationID,
|
|
SyncSpaceID: releaseSpaceID,
|
|
Name: strings.TrimSpace(input.Name),
|
|
Description: strings.TrimSpace(input.Description),
|
|
SessionIDs: input.SessionIDs,
|
|
Status: "pending",
|
|
CreatedBy: principal.User.ID,
|
|
CreatedAt: nowISO(),
|
|
}
|
|
if err := target.UpsertObjectSyncRelease(request.Context(), item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "release_create_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: item.OrganizationID,
|
|
ActorType: "user",
|
|
ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request),
|
|
Action: "release.create",
|
|
Target: map[string]any{"releaseId": item.ID, "syncSpaceId": item.SyncSpaceID},
|
|
After: map[string]any{"sessionIds": item.SessionIDs, "name": item.Name},
|
|
Result: "accepted",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": item.ID, "release": item})
|
|
}
|
|
|
|
func (server *server) handleObjectSyncAuditList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
start, end, ok := objectSyncAuditRange(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
page, err := target.ListObjectSyncAuditRange(
|
|
request.Context(),
|
|
principal.User.OrganizationID,
|
|
start,
|
|
end,
|
|
strings.TrimSpace(request.URL.Query().Get("cursor")),
|
|
objectSyncQueryLimit(request),
|
|
)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "audit_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
sessionID := strings.TrimSpace(request.URL.Query().Get("sessionId"))
|
|
if sessionID != "" {
|
|
filtered := page.Items[:0]
|
|
for _, item := range page.Items {
|
|
if item.SessionID == sessionID {
|
|
filtered = append(filtered, item)
|
|
}
|
|
}
|
|
page.Items = filtered
|
|
}
|
|
renderJSON(writer, http.StatusOK, page)
|
|
}
|
|
|
|
func objectSyncAuditRange(writer http.ResponseWriter, request *http.Request) (string, string, bool) {
|
|
start := strings.TrimSpace(request.URL.Query().Get("start"))
|
|
end := strings.TrimSpace(request.URL.Query().Get("end"))
|
|
if start == "" {
|
|
start = time.Now().UTC().Add(-objectSyncVersionRetention).Format(time.RFC3339Nano)
|
|
} else if parsed, err := time.Parse(time.RFC3339, start); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_range", "start must be an RFC3339 timestamp", false, nil)
|
|
return "", "", false
|
|
} else {
|
|
start = parsed.UTC().Format(time.RFC3339Nano)
|
|
}
|
|
if end == "" {
|
|
end = time.Now().UTC().Add(time.Second).Format(time.RFC3339Nano)
|
|
} else if parsed, err := time.Parse(time.RFC3339, end); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_range", "end must be an RFC3339 timestamp", false, nil)
|
|
return "", "", false
|
|
} else {
|
|
end = parsed.UTC().Format(time.RFC3339Nano)
|
|
}
|
|
if start >= end {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_range", "start must be earlier than end", false, nil)
|
|
return "", "", false
|
|
}
|
|
return start, end, true
|
|
}
|
|
|
|
func (server *server) handleObjectSyncAuditExport(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
start, end, ok := objectSyncAuditRange(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
sessionID := strings.TrimSpace(request.URL.Query().Get("sessionId"))
|
|
format := strings.ToLower(strings.TrimSpace(request.URL.Query().Get("format")))
|
|
if format == "csv" {
|
|
writer.Header().Set("Content-Type", "text/csv; charset=utf-8")
|
|
writer.Header().Set("Content-Disposition", `attachment; filename="drosync-audit.csv"`)
|
|
csvWriter := csv.NewWriter(writer)
|
|
_ = csvWriter.Write([]string{"id", "occurredAt", "actorType", "actorId", "action", "result", "sessionId", "itemId", "eventHash", "previousHash"})
|
|
cursor := ""
|
|
for {
|
|
page, err := target.ListObjectSyncAuditRange(request.Context(), principal.User.OrganizationID, start, end, cursor, 1000)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, item := range page.Items {
|
|
if sessionID == "" || item.SessionID == sessionID {
|
|
_ = csvWriter.Write([]string{item.ID, item.OccurredAt, item.ActorType, item.ActorID, item.Action, item.Result, item.SessionID, item.ItemID, item.EventHash, item.PreviousHash})
|
|
}
|
|
}
|
|
if page.NextCursor == "" {
|
|
break
|
|
}
|
|
cursor = page.NextCursor
|
|
}
|
|
csvWriter.Flush()
|
|
return
|
|
}
|
|
if format != "" && format != "ndjson" {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_format", "format must be csv or ndjson", false, nil)
|
|
return
|
|
}
|
|
writer.Header().Set("Content-Type", "application/x-ndjson")
|
|
writer.Header().Set("Content-Disposition", `attachment; filename="drosync-audit.ndjson"`)
|
|
encoder := json.NewEncoder(writer)
|
|
cursor := ""
|
|
for {
|
|
page, err := target.ListObjectSyncAuditRange(request.Context(), principal.User.OrganizationID, start, end, cursor, 1000)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, item := range page.Items {
|
|
if sessionID == "" || item.SessionID == sessionID {
|
|
_ = encoder.Encode(item)
|
|
}
|
|
}
|
|
if page.NextCursor == "" {
|
|
break
|
|
}
|
|
cursor = page.NextCursor
|
|
}
|
|
}
|
|
|
|
func (server *server) handleObjectSyncAuditSealGet(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
dayUTC := strings.TrimSpace(chi.URLParam(request, "day"))
|
|
if _, err := time.Parse("2006-01-02", dayUTC); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_day", "day must use YYYY-MM-DD", false, nil)
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
item, err := target.GetObjectSyncAuditSeal(request.Context(), principal.User.OrganizationID, dayUTC)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "audit_seal_lookup_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if item == nil {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "audit_seal_not_found", "No signed audit seal exists for that UTC day", false, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleObjectSyncClientReleasesList(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
items, err := target.ListObjectSyncClientReleases(request.Context())
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_releases_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
for index := range items {
|
|
items[index] = objectSyncClientReleaseForResponse(items[index])
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func objectSyncClientReleaseKind(item domain.ObjectSyncClientReleaseRecord) string {
|
|
if kind := strings.TrimSpace(item.Kind); kind != "" {
|
|
return kind
|
|
}
|
|
return objectSyncReleaseSigned
|
|
}
|
|
|
|
func objectSyncClientReleaseCanAutoUpdate(item domain.ObjectSyncClientReleaseRecord) bool {
|
|
return objectSyncClientReleaseKind(item) == objectSyncReleaseSigned &&
|
|
!item.Paused &&
|
|
item.RolloutPercent > 0 &&
|
|
item.ProtocolVersion == domain.ObjectSyncProtocolVersion
|
|
}
|
|
|
|
func objectSyncClientReleaseForResponse(item domain.ObjectSyncClientReleaseRecord) domain.ObjectSyncClientReleaseRecord {
|
|
item.Kind = objectSyncClientReleaseKind(item)
|
|
if item.Kind != objectSyncReleasePreview {
|
|
return item
|
|
}
|
|
artifacts := make(map[string]string, len(item.Artifacts))
|
|
for platform := range item.Artifacts {
|
|
artifacts[platform] = "/api/object-sync/client-releases/" + url.PathEscape(item.ID) + "/artifacts/" + url.PathEscape(platform)
|
|
}
|
|
item.Artifacts = artifacts
|
|
return item
|
|
}
|
|
|
|
func validateObjectSyncPreviewArtifacts(input domain.ObjectSyncClientReleaseRecord) error {
|
|
for _, platform := range objectSyncClientPlatforms {
|
|
source := strings.TrimSpace(input.Artifacts[platform])
|
|
digest := strings.TrimSpace(input.SHA256[platform])
|
|
if source == "" || digest == "" {
|
|
return fmt.Errorf("preview release requires %s artifact and SHA-256", platform)
|
|
}
|
|
parsed, err := url.Parse(source)
|
|
if err != nil || parsed.Scheme != "bos" || parsed.Host == "" || strings.Trim(parsed.Path, "/") == "" {
|
|
return fmt.Errorf("%s preview artifact must use bos://connection-id/bucket/object-key", platform)
|
|
}
|
|
if len(digest) != 64 {
|
|
return fmt.Errorf("%s SHA-256 must contain 64 hexadecimal characters", platform)
|
|
}
|
|
if _, err := hex.DecodeString(digest); err != nil {
|
|
return fmt.Errorf("%s SHA-256 must contain 64 hexadecimal characters", platform)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (server *server) handleObjectSyncClientReleaseUpsert(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
var input domain.ObjectSyncClientReleaseRecord
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
input.Kind = objectSyncClientReleaseKind(input)
|
|
if strings.TrimSpace(input.Version) == "" || len(input.Artifacts) == 0 || len(input.SHA256) == 0 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_release", "version, artifacts and sha256 are required", false, nil)
|
|
return
|
|
}
|
|
if input.Kind != objectSyncReleaseSigned && input.Kind != objectSyncReleasePreview {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_release_kind", "kind must be signed or preview", false, nil)
|
|
return
|
|
}
|
|
if input.Kind == objectSyncReleasePreview {
|
|
if err := validateObjectSyncPreviewArtifacts(input); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_preview_release", err.Error(), false, nil)
|
|
return
|
|
}
|
|
if input.Channel != objectSyncReleasePreview || input.RolloutPercent != 100 || input.Paused {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_preview_release", "preview releases must use channel=preview, rolloutPercent=100 and paused=false", false, nil)
|
|
return
|
|
}
|
|
input.Signature = ""
|
|
} else if strings.TrimSpace(input.Signature) == "" {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_release", "signed releases require a manifest signature", false, nil)
|
|
return
|
|
}
|
|
if input.RolloutPercent < 0 || input.RolloutPercent > 100 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_rollout_percent", "rolloutPercent must be between 0 and 100", false, nil)
|
|
return
|
|
}
|
|
if input.Kind == objectSyncReleaseSigned {
|
|
expectedPercent := map[string]int{"canary": 5, "pilot": 20, "stable": 100}
|
|
if value, valid := expectedPercent[input.Channel]; !valid {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_rollout_channel", "channel must be canary, pilot or stable", false, nil)
|
|
return
|
|
} else if !input.Paused && input.RolloutPercent != value {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_rollout_stage", "An active rollout must use the fixed 5%, 20% or 100% percentage for its channel", false, map[string]any{"expectedPercent": value})
|
|
return
|
|
}
|
|
}
|
|
if input.ID == "" {
|
|
input.ID = "drosync-" + input.Kind + "-" + input.Version
|
|
}
|
|
if input.ProtocolVersion == "" {
|
|
input.ProtocolVersion = domain.ObjectSyncProtocolVersion
|
|
}
|
|
now := time.Now().UTC()
|
|
input.CreatedAt = now.Format(time.RFC3339Nano)
|
|
input.StageChangedAt = input.CreatedAt
|
|
items, err := target.ListObjectSyncClientReleases(request.Context())
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_releases_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
for _, existing := range items {
|
|
if existing.ID != input.ID {
|
|
continue
|
|
}
|
|
if existing.Version != input.Version ||
|
|
objectSyncClientReleaseKind(existing) != input.Kind ||
|
|
existing.ProtocolVersion != input.ProtocolVersion ||
|
|
existing.MinimumServerVersion != input.MinimumServerVersion ||
|
|
existing.Signature != input.Signature ||
|
|
!maps.Equal(existing.Artifacts, input.Artifacts) ||
|
|
!maps.Equal(existing.SHA256, input.SHA256) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "client_release_immutable", "Version, protocol, artifacts, checksums and signature are immutable after registration", false, nil)
|
|
return
|
|
}
|
|
input.CreatedAt = existing.CreatedAt
|
|
input.StageChangedAt = existing.StageChangedAt
|
|
if input.StageChangedAt == "" {
|
|
input.StageChangedAt = existing.CreatedAt
|
|
}
|
|
stageOrder := map[string]int{"canary": 0, "pilot": 1, "stable": 2}
|
|
if input.Kind == objectSyncReleaseSigned && input.Channel != existing.Channel {
|
|
if stageOrder[input.Channel] > stageOrder[existing.Channel] {
|
|
stageChangedAt, parseErr := time.Parse(time.RFC3339Nano, input.StageChangedAt)
|
|
if parseErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "rollout_observation_unknown", "The current rollout stage has no valid observation timestamp", false, nil)
|
|
return
|
|
}
|
|
eligibleAt := stageChangedAt.Add(24 * time.Hour)
|
|
if now.Before(eligibleAt) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "rollout_observation_incomplete", "The current rollout stage must be observed for 24 hours before promotion", true, map[string]any{"eligibleAt": eligibleAt.Format(time.RFC3339Nano)})
|
|
return
|
|
}
|
|
}
|
|
input.StageChangedAt = now.Format(time.RFC3339Nano)
|
|
} else if input.Kind == objectSyncReleaseSigned && existing.Paused && !input.Paused {
|
|
// Paused time provides no active-client observation evidence.
|
|
input.StageChangedAt = now.Format(time.RFC3339Nano)
|
|
}
|
|
break
|
|
}
|
|
if err := target.UpsertObjectSyncClientRelease(request.Context(), input); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_release_save_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
principal := objectSyncManagementPrincipal(request)
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: principal.User.OrganizationID,
|
|
ActorType: "user",
|
|
ActorID: principal.User.ID,
|
|
RequestID: objectSyncRequestID(request),
|
|
Action: "client_release." + input.Kind,
|
|
Target: map[string]any{"releaseId": input.ID, "version": input.Version},
|
|
After: map[string]any{"channel": input.Channel, "rolloutPercent": input.RolloutPercent, "paused": input.Paused},
|
|
Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, objectSyncClientReleaseForResponse(input))
|
|
}
|
|
|
|
func parseObjectSyncPreviewArtifact(source string) (connectionID, bucket, key string, err error) {
|
|
parsed, err := url.Parse(strings.TrimSpace(source))
|
|
if err != nil || parsed.Scheme != "bos" {
|
|
return "", "", "", errors.New("preview artifact source is invalid")
|
|
}
|
|
connectionID = strings.TrimSpace(parsed.Host)
|
|
parts := strings.SplitN(strings.Trim(parsed.Path, "/"), "/", 2)
|
|
if connectionID == "" || len(parts) != 2 || strings.TrimSpace(parts[0]) == "" || strings.TrimSpace(parts[1]) == "" {
|
|
return "", "", "", errors.New("preview artifact source is incomplete")
|
|
}
|
|
return connectionID, parts[0], parts[1], nil
|
|
}
|
|
|
|
func (server *server) handleObjectSyncClientReleaseDownload(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
releaseID := chi.URLParam(request, "id")
|
|
platform := chi.URLParam(request, "platform")
|
|
items, err := target.ListObjectSyncClientReleases(request.Context())
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_releases_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
var selected *domain.ObjectSyncClientReleaseRecord
|
|
for index := range items {
|
|
if items[index].ID == releaseID {
|
|
selected = &items[index]
|
|
break
|
|
}
|
|
}
|
|
if selected == nil || objectSyncClientReleaseKind(*selected) != objectSyncReleasePreview {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "client_release_not_found", "Preview client release was not found", false, nil)
|
|
return
|
|
}
|
|
source := selected.Artifacts[platform]
|
|
connectionID, bucket, key, err := parseObjectSyncPreviewArtifact(source)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "client_artifact_not_found", "Client artifact was not found", false, nil)
|
|
return
|
|
}
|
|
browser, connection, cleanup, err := server.resolveObjectStorageBrowser(request.Context(), connectionID)
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
if err != nil || browser == nil || connection == nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "client_artifact_storage_failed", "Client artifact storage is unavailable", true, nil)
|
|
return
|
|
}
|
|
if resolved, resolveErr := resolveObjectStorageBucket(connection, bucket); resolveErr != nil || resolved != bucket {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "client_artifact_not_found", "Client artifact bucket is not available", false, nil)
|
|
return
|
|
}
|
|
summary, err := browser.GetObjectSummary(request.Context(), bucket, key)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "client_artifact_not_found", "Client artifact was not found", false, nil)
|
|
return
|
|
}
|
|
writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", path.Base(key)))
|
|
writer.Header().Set("Cache-Control", "private, no-store")
|
|
requestedRange, hasRange, rangeErr := parseObjectStorageByteRange(request.Header.Get("Range"), summary.SizeBytes)
|
|
if rangeErr != nil {
|
|
writer.Header().Set("Accept-Ranges", "bytes")
|
|
renderObjectSyncError(writer, request, http.StatusRequestedRangeNotSatisfiable, "invalid_range", rangeErr.Error(), false, nil)
|
|
return
|
|
}
|
|
if !hasRange && summary.SizeBytes > 0 {
|
|
requestedRange = objectStorageByteRange{start: 0, end: summary.SizeBytes - 1}
|
|
}
|
|
statusCode := http.StatusOK
|
|
if hasRange {
|
|
statusCode = http.StatusPartialContent
|
|
}
|
|
if request.Method == http.MethodHead {
|
|
writeObjectStorageRangeHeaders(writer, summary, "application/octet-stream", requestedRange, statusCode)
|
|
writer.WriteHeader(statusCode)
|
|
return
|
|
}
|
|
reader, _, err := browser.ReadObjectRange(request.Context(), bucket, key, requestedRange.start, requestedRange.end)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "client_artifact_read_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
defer reader.Close()
|
|
writeObjectStorageRangeHeaders(writer, summary, "application/octet-stream", requestedRange, statusCode)
|
|
writer.WriteHeader(statusCode)
|
|
if _, err := io.Copy(writer, reader); err != nil {
|
|
fmt.Printf("[api] client release download stream failed: %v\n", err)
|
|
}
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncAuthorizationCreate(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
var input struct {
|
|
DeviceID string `json:"deviceId"`
|
|
DeviceName string `json:"deviceName"`
|
|
Platform string `json:"platform"`
|
|
Architecture string `json:"architecture"`
|
|
ClientVersion string `json:"clientVersion"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(input.DeviceID) == "" || strings.TrimSpace(input.DeviceName) == "" {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_device", "deviceId and deviceName are required", false, nil)
|
|
return
|
|
}
|
|
deviceCode, err := randomURLToken(32)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "pairing_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
codeBytes, _ := randomURLToken(8)
|
|
sum := sha256.Sum256([]byte(codeBytes))
|
|
userCode := strings.TrimRight(base32.StdEncoding.EncodeToString(sum[:5]), "=")
|
|
now := time.Now().UTC()
|
|
item := domain.ObjectSyncDeviceAuthorizationRecord{
|
|
ID: objectSyncNewID("oda"),
|
|
DeviceID: strings.TrimSpace(input.DeviceID),
|
|
DeviceName: strings.TrimSpace(input.DeviceName),
|
|
Platform: strings.TrimSpace(input.Platform),
|
|
Architecture: strings.TrimSpace(input.Architecture),
|
|
ClientVersion: strings.TrimSpace(input.ClientVersion),
|
|
DeviceCodeHash: sessionTokenHash(deviceCode),
|
|
UserCode: userCode,
|
|
Status: "pending",
|
|
CreatedAt: now.Format(time.RFC3339Nano),
|
|
UpdatedAt: now.Format(time.RFC3339Nano),
|
|
ExpiresAt: now.Add(15 * time.Minute).Format(time.RFC3339Nano),
|
|
ExpiresAtTime: now.Add(15 * time.Minute),
|
|
}
|
|
if err := target.UpsertObjectSyncAuthorization(request.Context(), item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "pairing_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, map[string]any{
|
|
"deviceCode": deviceCode,
|
|
"userCode": userCode,
|
|
"verificationUri": "/object-sync?pair=" + userCode,
|
|
"expiresIn": 900,
|
|
"interval": 5,
|
|
})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncAuthorizationPoll(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
var input struct {
|
|
DeviceCode string `json:"deviceCode"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
item, err := target.GetObjectSyncAuthorizationByDeviceCodeHash(request.Context(), sessionTokenHash(strings.TrimSpace(input.DeviceCode)))
|
|
if err != nil || item == nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_device_code", "Device code is invalid", false, nil)
|
|
return
|
|
}
|
|
if time.Now().UTC().After(item.ExpiresAtTime) {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "device_code_expired", "Device code expired", false, nil)
|
|
return
|
|
}
|
|
switch item.Status {
|
|
case "pending":
|
|
renderObjectSyncError(writer, request, http.StatusPreconditionRequired, "authorization_pending", "Administrator approval is pending", true, map[string]any{"interval": 5})
|
|
return
|
|
case "denied":
|
|
renderObjectSyncError(writer, request, http.StatusForbidden, "authorization_denied", "Administrator denied this device", false, nil)
|
|
return
|
|
case "exchanged":
|
|
renderObjectSyncError(writer, request, http.StatusGone, "device_code_consumed", "Device code was already exchanged", false, nil)
|
|
return
|
|
case "approved":
|
|
default:
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_authorization_state", "Device authorization is not exchangeable", false, nil)
|
|
return
|
|
}
|
|
token, err := randomURLToken(32)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
now := nowISO()
|
|
device := domain.ObjectSyncDeviceRecord{
|
|
ID: item.DeviceID,
|
|
OrganizationID: item.OrganizationID,
|
|
Name: item.DeviceName,
|
|
Platform: item.Platform,
|
|
Architecture: item.Architecture,
|
|
ClientVersion: item.ClientVersion,
|
|
Status: "active",
|
|
LastSeenAt: now,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
credential := domain.ObjectSyncCredentialRecord{
|
|
ID: objectSyncNewID("odc"),
|
|
OrganizationID: item.OrganizationID,
|
|
DeviceID: item.DeviceID,
|
|
Name: item.DeviceName,
|
|
Enabled: true,
|
|
TokenHash: sessionTokenHash(token),
|
|
TokenPreview: token[:4] + "…" + token[len(token)-4:],
|
|
Scopes: item.Scopes,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if err := target.UpsertObjectSyncDevice(request.Context(), device); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_save_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if err := target.UpsertObjectSyncCredential(request.Context(), credential); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
item.Status = "exchanged"
|
|
item.UpdatedAt = now
|
|
_ = target.UpsertObjectSyncAuthorization(request.Context(), *item)
|
|
renderJSON(writer, http.StatusOK, map[string]any{
|
|
"credential": token,
|
|
"device": device,
|
|
"scopes": credential.Scopes,
|
|
})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncCapabilities(writer http.ResponseWriter, request *http.Request) {
|
|
principal, _ := currentObjectSyncCredential(request)
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
spaces := make([]domain.ObjectSyncSpaceRecord, 0, len(principal.Credential.Scopes))
|
|
for _, scope := range principal.Credential.Scopes {
|
|
item, err := target.GetObjectSyncSpace(request.Context(), scope.SyncSpaceID)
|
|
if err == nil && item != nil {
|
|
spaces = append(spaces, *item)
|
|
}
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{
|
|
"protocolVersion": domain.ObjectSyncProtocolVersion,
|
|
"spaces": spaces,
|
|
"limits": map[string]any{"manifestPageItems": domain.ObjectSyncDefaultManifestPageMaxItems, "concurrentRequests": 16},
|
|
})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncSessionCreate(writer http.ResponseWriter, request *http.Request) {
|
|
principal, _ := currentObjectSyncCredential(request)
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
var input struct {
|
|
SyncSpaceID string `json:"syncSpaceId"`
|
|
MappingID string `json:"mappingId"`
|
|
ClientVersion string `json:"clientVersion"`
|
|
ProtocolVersion string `json:"protocolVersion"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
scope, allowed := objectSyncCredentialScopeFor(principal.Credential, input.SyncSpaceID)
|
|
if !allowed || !objectSyncScopeAllowsAction(*scope, "plan") {
|
|
renderObjectSyncError(writer, request, http.StatusForbidden, "scope_denied", "Credential cannot create sessions in this sync space", false, nil)
|
|
return
|
|
}
|
|
space, err := target.GetObjectSyncSpace(request.Context(), input.SyncSpaceID)
|
|
if err != nil || space == nil || space.OrganizationID != principal.Credential.OrganizationID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Object sync space not found", false, nil)
|
|
return
|
|
}
|
|
if !space.Enabled || (space.Capability.State != domain.ObjectSyncCapabilityCreateOnly && space.Capability.State != domain.ObjectSyncCapabilityUpdateEnabled) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "space_not_ready", "Object sync space is disabled or has not passed conditional-create probing", false, map[string]any{"state": space.Capability.State})
|
|
return
|
|
}
|
|
if input.ProtocolVersion != "" && input.ProtocolVersion != domain.ObjectSyncProtocolVersion {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "protocol_version_unsupported", "Client protocol version is not supported", false, map[string]any{"supported": domain.ObjectSyncProtocolVersion})
|
|
return
|
|
}
|
|
now := time.Now().UTC()
|
|
item := domain.ObjectSyncSessionRecord{
|
|
ID: objectSyncNewID("oses"),
|
|
OrganizationID: principal.Credential.OrganizationID,
|
|
SyncSpaceID: space.ID,
|
|
CredentialID: principal.Credential.ID,
|
|
DeviceID: principal.Device.ID,
|
|
MappingID: strings.TrimSpace(input.MappingID),
|
|
ClientVersion: strings.TrimSpace(input.ClientVersion),
|
|
ProtocolVersion: domain.ObjectSyncProtocolVersion,
|
|
Status: domain.ObjectSyncSessionCollectingManifest,
|
|
PolicySnapshot: space.Policy,
|
|
CreatedAt: now.Format(time.RFC3339Nano),
|
|
UpdatedAt: now.Format(time.RFC3339Nano),
|
|
ExpiresAt: now.Add(objectSyncSessionTTL).Format(time.RFC3339Nano),
|
|
PurgeAt: now.Add(objectSyncRecordRetention),
|
|
}
|
|
if err := target.UpsertObjectSyncSession(request.Context(), item); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_create_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
|
|
OrganizationID: item.OrganizationID, ActorType: "device", ActorID: principal.Device.ID,
|
|
CredentialID: principal.Credential.ID, DeviceID: principal.Device.ID, SessionID: item.ID,
|
|
RequestID: objectSyncRequestID(request), Action: "session.create", Result: "success",
|
|
}) {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, item)
|
|
}
|
|
|
|
func (server *server) externalObjectSyncSession(writer http.ResponseWriter, request *http.Request, target store.ObjectSyncStore) (*domain.ObjectSyncSessionRecord, *objectSyncCredentialPrincipal, bool) {
|
|
principal, _ := currentObjectSyncCredential(request)
|
|
sessionID := chi.URLParam(request, "sessionId")
|
|
if sessionID == "" {
|
|
sessionID = chi.URLParam(request, "id")
|
|
}
|
|
session, err := target.GetObjectSyncSession(request.Context(), sessionID)
|
|
if err != nil || session == nil || session.CredentialID != principal.Credential.ID || session.DeviceID != principal.Device.ID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found for this device credential", false, nil)
|
|
return nil, principal, false
|
|
}
|
|
return session, principal, true
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncManifestPage(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
session, principal, ok := server.externalObjectSyncSession(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if session.Status != domain.ObjectSyncSessionCollectingManifest {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "manifest_closed", "Session is not collecting manifest pages", false, map[string]any{"status": session.Status})
|
|
return
|
|
}
|
|
var input struct {
|
|
PageNumber int `json:"pageNumber"`
|
|
Final bool `json:"final"`
|
|
Items []domain.ObjectSyncManifestItemInput `json:"items"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
if input.PageNumber <= 0 || len(input.Items) == 0 || len(input.Items) > domain.ObjectSyncDefaultManifestPageMaxItems {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_manifest_page", "pageNumber must be positive and items must contain 1-1000 entries", false, nil)
|
|
return
|
|
}
|
|
space, err := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
if err != nil || space == nil {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "space_not_found", "Session sync space is unavailable", false, nil)
|
|
return
|
|
}
|
|
scope, _ := objectSyncCredentialScopeFor(principal.Credential, session.SyncSpaceID)
|
|
now := time.Now().UTC()
|
|
items := make([]domain.ObjectSyncItemRecord, 0, len(input.Items))
|
|
var pageBytes int64
|
|
clientItemIDs := make(map[string]struct{}, len(input.Items))
|
|
for _, manifest := range input.Items {
|
|
clientItemID := strings.TrimSpace(manifest.ClientItemID)
|
|
if clientItemID == "" {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_item_id", "Manifest clientItemId is required", false, nil)
|
|
return
|
|
}
|
|
if _, exists := clientItemIDs[clientItemID]; exists {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "duplicate_client_item_id", "Manifest page contains a duplicate clientItemId", false, map[string]any{"clientItemId": clientItemID})
|
|
return
|
|
}
|
|
clientItemIDs[clientItemID] = struct{}{}
|
|
relativePath, pathErr := normalizeObjectSyncRelativePath(manifest.RelativePath)
|
|
if pathErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_relative_path", pathErr.Error(), false, map[string]any{"clientItemId": manifest.ClientItemID})
|
|
return
|
|
}
|
|
if manifest.Kind != "" && manifest.Kind != "file" {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "unsupported_item_kind", "Only regular files are accepted", false, map[string]any{"clientItemId": manifest.ClientItemID})
|
|
return
|
|
}
|
|
if manifest.SizeBytes < 0 || manifest.SizeBytes > session.PolicySnapshot.MaxObjectBytes {
|
|
renderObjectSyncError(writer, request, http.StatusRequestEntityTooLarge, "object_too_large", "Manifest item exceeds the sync space object limit", false, map[string]any{"clientItemId": manifest.ClientItemID})
|
|
return
|
|
}
|
|
if decoded, decodeErr := hex.DecodeString(manifest.SHA256); decodeErr != nil || len(decoded) != sha256.Size {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_sha256", "Manifest item SHA-256 must be a 64-character hex digest", false, map[string]any{"clientItemId": clientItemID})
|
|
return
|
|
}
|
|
if scope == nil || !objectSyncScopeAllows(*scope, "create", relativePath) {
|
|
renderObjectSyncError(writer, request, http.StatusForbidden, "path_scope_denied", "Manifest path is outside the credential scope", false, map[string]any{"relativePath": relativePath})
|
|
return
|
|
}
|
|
pageBytes += manifest.SizeBytes
|
|
items = append(items, domain.ObjectSyncItemRecord{
|
|
ID: objectSyncNewID("osi"),
|
|
OrganizationID: session.OrganizationID,
|
|
SessionID: session.ID,
|
|
ClientItemID: clientItemID,
|
|
ManifestPage: input.PageNumber,
|
|
RelativePath: manifest.RelativePath,
|
|
NormalizedRelativePath: relativePath,
|
|
TargetKey: objectSyncTargetKey(*space, relativePath),
|
|
SizeBytes: manifest.SizeBytes,
|
|
ModifiedAt: manifest.ModifiedAt,
|
|
SHA256: strings.ToLower(manifest.SHA256),
|
|
ContentType: strings.TrimSpace(manifest.ContentType),
|
|
ExpectedBase: manifest.LastKnownRemote,
|
|
Status: domain.ObjectSyncItemDiscovered,
|
|
CreatedAt: now.Format(time.RFC3339Nano),
|
|
UpdatedAt: now.Format(time.RFC3339Nano),
|
|
PurgeAt: now.Add(objectSyncRecordRetention),
|
|
})
|
|
}
|
|
if session.Counts.Manifest+int64(len(items)) > session.PolicySnapshot.MaxSessionFiles || session.TotalBytes+pageBytes > session.PolicySnapshot.MaxSessionBytes {
|
|
renderObjectSyncError(writer, request, http.StatusRequestEntityTooLarge, "session_quota_exceeded", "Manifest exceeds the sync space session quota", false, nil)
|
|
return
|
|
}
|
|
if err := target.UpsertObjectSyncItems(request.Context(), items); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "manifest_save_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
session.Counts.Manifest += int64(len(items))
|
|
session.TotalBytes += pageBytes
|
|
if input.Final {
|
|
session.ManifestFinalPage = input.PageNumber
|
|
}
|
|
session.UpdatedAt = nowISO()
|
|
if err := target.UpsertObjectSyncSession(request.Context(), *session); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_update_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusAccepted, map[string]any{"accepted": len(items), "session": session})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncPlan(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
session, _, ok := server.externalObjectSyncSession(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if session.Status == domain.ObjectSyncSessionPlanning || session.Status == domain.ObjectSyncSessionPlanned {
|
|
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": session.OperationID, "session": session})
|
|
return
|
|
}
|
|
if session.Status != domain.ObjectSyncSessionCollectingManifest || session.ManifestFinalPage <= 0 {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "manifest_incomplete", "A final manifest page is required before planning", false, nil)
|
|
return
|
|
}
|
|
session.Status = domain.ObjectSyncSessionPlanning
|
|
session.OperationID = objectSyncNewID("op")
|
|
session.UpdatedAt = nowISO()
|
|
if err := target.UpsertObjectSyncSession(request.Context(), *session); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "plan_enqueue_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": session.OperationID, "session": session})
|
|
}
|
|
|
|
func (server *server) externalObjectSyncItem(writer http.ResponseWriter, request *http.Request, target store.ObjectSyncStore) (*domain.ObjectSyncItemRecord, *domain.ObjectSyncSessionRecord, *objectSyncCredentialPrincipal, bool) {
|
|
principal, _ := currentObjectSyncCredential(request)
|
|
item, err := target.GetObjectSyncItem(request.Context(), chi.URLParam(request, "itemId"))
|
|
if err != nil || item == nil {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "item_not_found", "Object sync item not found", false, nil)
|
|
return nil, nil, principal, false
|
|
}
|
|
session, err := target.GetObjectSyncSession(request.Context(), item.SessionID)
|
|
if err != nil || session == nil || session.CredentialID != principal.Credential.ID || session.DeviceID != principal.Device.ID {
|
|
renderObjectSyncError(writer, request, http.StatusNotFound, "item_not_found", "Object sync item not found for this device credential", false, nil)
|
|
return nil, nil, principal, false
|
|
}
|
|
return item, session, principal, true
|
|
}
|
|
|
|
func objectSyncLeaseResourceHash(space domain.ObjectSyncSpaceRecord, key string) string {
|
|
sum := sha256.Sum256([]byte(space.ConnectionID + "\x00" + space.Bucket + "\x00" + key))
|
|
return hex.EncodeToString(sum[:])
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncItemReserve(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if item.Status == domain.ObjectSyncItemReserved || item.Status == domain.ObjectSyncItemUploading || item.Status == domain.ObjectSyncItemUploaded {
|
|
renderJSON(writer, http.StatusOK, item)
|
|
return
|
|
}
|
|
if item.Status != domain.ObjectSyncItemPlanned {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_reservable", "Item is not in the planned state", false, map[string]any{"status": item.Status})
|
|
return
|
|
}
|
|
space, err := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
if err != nil || space == nil {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "space_not_found", "Session sync space is unavailable", false, nil)
|
|
return
|
|
}
|
|
leaseTemplate := domain.ObjectSyncLeaseRecord{
|
|
ID: "osl_" + objectSyncLeaseResourceHash(*space, item.TargetKey),
|
|
OrganizationID: session.OrganizationID,
|
|
ResourceHash: objectSyncLeaseResourceHash(*space, item.TargetKey),
|
|
ResourceType: "object",
|
|
ConnectionID: space.ConnectionID,
|
|
Bucket: space.Bucket,
|
|
KeyOrPrefix: item.TargetKey,
|
|
OwnerSessionID: session.ID,
|
|
OwnerItemID: item.ID,
|
|
}
|
|
lease, acquired, err := target.AcquireObjectSyncLease(request.Context(), leaseTemplate, objectSyncLeaseTTL)
|
|
if err != nil {
|
|
status := http.StatusInternalServerError
|
|
code := "lease_acquire_failed"
|
|
retryable := true
|
|
if errors.Is(err, store.ErrObjectSyncLeaseHeld) {
|
|
status = http.StatusConflict
|
|
code = "lease_held"
|
|
}
|
|
renderObjectSyncError(writer, request, status, code, err.Error(), retryable, nil)
|
|
return
|
|
}
|
|
if !acquired {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "lease_held", "Another session currently holds this logical object key", true, nil)
|
|
return
|
|
}
|
|
item.LeaseID = lease.ID
|
|
item.FencingToken = lease.FencingToken
|
|
item.StagingKey = path.Join(".drosync-internal/staging", session.OrganizationID, session.ID, item.ID)
|
|
item.Status = domain.ObjectSyncItemReserved
|
|
item.UpdatedAt = nowISO()
|
|
session.Status = domain.ObjectSyncSessionRunning
|
|
session.LastHeartbeatAt = item.UpdatedAt
|
|
session.UpdatedAt = item.UpdatedAt
|
|
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item}); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "item_reserve_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
_ = target.UpsertObjectSyncSession(request.Context(), *session)
|
|
renderJSON(writer, http.StatusOK, map[string]any{"item": item, "lease": lease})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncDirectUpload(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if item.Status != domain.ObjectSyncItemReserved && item.Status != domain.ObjectSyncItemUploading {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_uploadable", "Item must be reserved before requesting an upload URL", false, nil)
|
|
return
|
|
}
|
|
var input struct {
|
|
ContentMD5 string `json:"contentMd5"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
if decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(input.ContentMD5)); err != nil || len(decoded) != 16 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_content_md5", "contentMd5 must be a base64-encoded 128-bit MD5 digest", false, nil)
|
|
return
|
|
}
|
|
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_prepare_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
defer closeBrowser()
|
|
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
|
|
if !ok {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind upload integrity headers", false, nil)
|
|
return
|
|
}
|
|
metadata := map[string]string{"drosync-session": session.ID, "drosync-item": item.ID, "drosync-sha256": item.SHA256}
|
|
result, err := boundBrowser.PresignPutObjectBound(request.Context(), space.Bucket, item.StagingKey, item.ContentType, input.ContentMD5, item.SizeBytes, metadata, objectStoragePresignDefaultExpires)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_prepare_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
item.UploadMode = "direct"
|
|
item.Status = domain.ObjectSyncItemUploading
|
|
item.UpdatedAt = nowISO()
|
|
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
|
|
renderJSON(writer, http.StatusOK, map[string]any{
|
|
"upload": result,
|
|
"required": map[string]any{
|
|
"sizeBytes": item.SizeBytes,
|
|
"sha256": item.SHA256,
|
|
"contentMd5": input.ContentMD5,
|
|
"metadata": metadata,
|
|
},
|
|
})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncMultipartInitiate(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if item.Status != domain.ObjectSyncItemReserved && item.Status != domain.ObjectSyncItemUploading {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_uploadable", "Item must be reserved before initiating multipart upload", false, nil)
|
|
return
|
|
}
|
|
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
if item.UploadMode == "multipart" && item.UploadID != "" {
|
|
renderJSON(writer, http.StatusOK, map[string]any{
|
|
"bucket": space.Bucket,
|
|
"key": item.StagingKey,
|
|
"uploadId": item.UploadID,
|
|
"expiresAt": time.Now().UTC().Add(time.Duration(objectStoragePresignDefaultExpires) * time.Second).Format(time.RFC3339),
|
|
"uploadedParts": nonNilObjectSyncUploadedParts(item.UploadedParts),
|
|
"resumed": true,
|
|
})
|
|
return
|
|
}
|
|
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_initiate_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
defer closeBrowser()
|
|
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
|
|
if !ok {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind multipart metadata", false, nil)
|
|
return
|
|
}
|
|
result, err := boundBrowser.InitiateMultipartUploadBound(request.Context(), space.Bucket, item.StagingKey, item.ContentType, map[string]string{
|
|
"drosync-session": session.ID,
|
|
"drosync-item": item.ID,
|
|
"drosync-sha256": item.SHA256,
|
|
}, objectStoragePresignDefaultExpires)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_initiate_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
item.UploadMode = "multipart"
|
|
item.UploadID = result.UploadID
|
|
item.Status = domain.ObjectSyncItemUploading
|
|
item.UpdatedAt = nowISO()
|
|
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
|
|
renderJSON(writer, http.StatusCreated, map[string]any{
|
|
"bucket": result.Bucket,
|
|
"key": result.Key,
|
|
"uploadId": result.UploadID,
|
|
"expiresAt": result.ExpiresAt,
|
|
"uploadedParts": nonNilObjectSyncUploadedParts(item.UploadedParts),
|
|
"resumed": false,
|
|
})
|
|
}
|
|
|
|
func nonNilObjectSyncUploadedParts(parts []domain.ObjectStorageMultipartUploadPart) []domain.ObjectStorageMultipartUploadPart {
|
|
if parts == nil {
|
|
return []domain.ObjectStorageMultipartUploadPart{}
|
|
}
|
|
return parts
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncMultipartPartURL(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
var input struct {
|
|
PartNumber int `json:"partNumber"`
|
|
ContentMD5 string `json:"contentMd5"`
|
|
SizeBytes int64 `json:"sizeBytes"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
if item.UploadMode != "multipart" || item.UploadID == "" || input.PartNumber <= 0 || input.PartNumber > 10_000 || input.SizeBytes <= 0 || input.SizeBytes > item.SizeBytes {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "A valid active multipart upload and partNumber are required", false, nil)
|
|
return
|
|
}
|
|
if decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(input.ContentMD5)); err != nil || len(decoded) != 16 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_content_md5", "contentMd5 must be a base64-encoded 128-bit MD5 digest", false, nil)
|
|
return
|
|
}
|
|
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "part_url_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
defer closeBrowser()
|
|
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
|
|
if !ok {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind multipart integrity headers", false, nil)
|
|
return
|
|
}
|
|
result, err := boundBrowser.PresignMultipartUploadPartBound(request.Context(), space.Bucket, item.StagingKey, item.UploadID, input.PartNumber, input.ContentMD5, input.SizeBytes, objectStoragePresignDefaultExpires)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "part_url_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, result)
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncMultipartPartCheckpoint(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, _, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
var input domain.ObjectStorageMultipartUploadPart
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
input.ETag = strings.Trim(strings.TrimSpace(input.ETag), `"`)
|
|
if item.UploadMode != "multipart" || item.UploadID == "" || item.Status != domain.ObjectSyncItemUploading {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "A multipart upload must be active before checkpointing a part", false, nil)
|
|
return
|
|
}
|
|
if input.PartNumber < 1 || input.PartNumber > 10_000 || input.ETag == "" || input.SizeBytes <= 0 || input.SizeBytes > item.SizeBytes {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_multipart_part", "partNumber, eTag, and sizeBytes are required", false, nil)
|
|
return
|
|
}
|
|
replaced := false
|
|
for index := range item.UploadedParts {
|
|
if item.UploadedParts[index].PartNumber == input.PartNumber {
|
|
item.UploadedParts[index] = input
|
|
replaced = true
|
|
break
|
|
}
|
|
}
|
|
if !replaced {
|
|
item.UploadedParts = append(item.UploadedParts, input)
|
|
}
|
|
sort.Slice(item.UploadedParts, func(left int, right int) bool {
|
|
return item.UploadedParts[left].PartNumber < item.UploadedParts[right].PartNumber
|
|
})
|
|
item.UpdatedAt = nowISO()
|
|
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item}); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "multipart_checkpoint_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"itemId": item.ID, "part": input})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncMultipartComplete(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
var input struct {
|
|
Parts []domain.ObjectStorageMultipartUploadPart `json:"parts"`
|
|
}
|
|
if !decodeJSON(writer, request, &input) {
|
|
return
|
|
}
|
|
if item.UploadMode != "multipart" || item.UploadID == "" || len(input.Parts) == 0 {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "A valid active multipart upload and parts are required", false, nil)
|
|
return
|
|
}
|
|
if item.Status != domain.ObjectSyncItemUploading && item.Status != domain.ObjectSyncItemUploaded {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "The multipart upload is not awaiting completion", false, map[string]any{"status": item.Status})
|
|
return
|
|
}
|
|
normalizedParts, err := normalizeObjectStorageMultipartParts(input.Parts)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_multipart_parts", err.Error(), false, nil)
|
|
return
|
|
}
|
|
input.Parts = normalizedParts
|
|
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_complete_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
defer closeBrowser()
|
|
if item.Status == domain.ObjectSyncItemUploaded {
|
|
result, lookupErr := browser.GetObjectSummary(request.Context(), space.Bucket, item.StagingKey)
|
|
if lookupErr != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_complete_query_failed", lookupErr.Error(), true, nil)
|
|
return
|
|
}
|
|
if result.SizeBytes != item.SizeBytes || !objectSyncStagingMatches(result, item, session) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "staging_verification_failed", "The previously completed staging object no longer matches the manifest", false, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item, "resumed": true})
|
|
return
|
|
}
|
|
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
|
|
if !ok {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind multipart metadata", false, nil)
|
|
return
|
|
}
|
|
result, err := boundBrowser.CompleteMultipartUploadBound(request.Context(), space.Bucket, item.StagingKey, item.UploadID, input.Parts, map[string]string{
|
|
"drosync-session": session.ID,
|
|
"drosync-item": item.ID,
|
|
"drosync-sha256": item.SHA256,
|
|
})
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_complete_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if result.SizeBytes != item.SizeBytes {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "staging_size_mismatch", "Completed staging object size does not match the manifest", false, map[string]any{"expected": item.SizeBytes, "actual": result.SizeBytes})
|
|
return
|
|
}
|
|
if !objectSyncStagingMatches(result, item, session) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "staging_metadata_mismatch", "Completed staging object is missing the bound drosync metadata or ETag", false, nil)
|
|
return
|
|
}
|
|
item.UploadedParts = input.Parts
|
|
item.Status = domain.ObjectSyncItemUploaded
|
|
item.UpdatedAt = nowISO()
|
|
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
|
|
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncDirectUploadComplete(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if item.UploadMode != "direct" || (item.Status != domain.ObjectSyncItemUploading && item.Status != domain.ObjectSyncItemUploaded) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "direct_upload_not_active", "A direct upload is not active for this item", false, nil)
|
|
return
|
|
}
|
|
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
|
|
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_verify_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
defer closeBrowser()
|
|
result, err := browser.GetObjectSummary(request.Context(), space.Bucket, item.StagingKey)
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_verify_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if result.SizeBytes != item.SizeBytes {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "staging_size_mismatch", "Staging object size does not match the manifest", false, map[string]any{"expected": item.SizeBytes, "actual": result.SizeBytes})
|
|
return
|
|
}
|
|
if !objectSyncStagingMatches(result, item, session) {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "staging_metadata_mismatch", "Staging object is missing the bound drosync metadata or ETag", false, nil)
|
|
return
|
|
}
|
|
if item.Status == domain.ObjectSyncItemUploaded {
|
|
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item, "resumed": true})
|
|
return
|
|
}
|
|
item.Status = domain.ObjectSyncItemUploaded
|
|
item.UpdatedAt = nowISO()
|
|
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
|
|
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncHeartbeat(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if item.LeaseID == "" {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "lease_missing", "Item has no active lease", false, nil)
|
|
return
|
|
}
|
|
renewed, err := target.RenewObjectSyncLease(request.Context(), item.LeaseID, session.ID, item.ID, item.FencingToken, objectSyncLeaseTTL)
|
|
if err != nil || !renewed {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "lease_lost", "Lease was lost or its fencing token is stale", false, nil)
|
|
return
|
|
}
|
|
session.LastHeartbeatAt = nowISO()
|
|
session.UpdatedAt = session.LastHeartbeatAt
|
|
_ = target.UpsertObjectSyncSession(request.Context(), *session)
|
|
renderJSON(writer, http.StatusOK, map[string]any{"renewed": true, "fencingToken": item.FencingToken})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncItemAbort(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, session, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if item.UploadMode == "multipart" && item.UploadID != "" {
|
|
if space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID); space != nil {
|
|
if browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space); err == nil {
|
|
_ = browser.AbortMultipartUpload(request.Context(), space.Bucket, item.StagingKey, item.UploadID)
|
|
closeBrowser()
|
|
}
|
|
}
|
|
}
|
|
if item.LeaseID != "" {
|
|
_ = target.ReleaseObjectSyncLease(request.Context(), item.LeaseID, session.ID, item.ID, item.FencingToken)
|
|
}
|
|
item.Status = domain.ObjectSyncItemAborted
|
|
item.UpdatedAt = nowISO()
|
|
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncCommit(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, _, _, ok := server.externalObjectSyncItem(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
if item.Status == domain.ObjectSyncItemCommitting || item.Status == domain.ObjectSyncItemCommitted || item.Status == domain.ObjectSyncItemKeptBoth {
|
|
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": item.OperationID, "item": item})
|
|
return
|
|
}
|
|
if item.Status != domain.ObjectSyncItemUploaded {
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_committable", "Item must be uploaded before commit", false, nil)
|
|
return
|
|
}
|
|
item.Status = domain.ObjectSyncItemCommitting
|
|
item.OperationID = objectSyncNewID("op")
|
|
item.UpdatedAt = nowISO()
|
|
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item}); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "commit_enqueue_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": item.OperationID, "item": item})
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncSessionStatus(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
session, _, ok := server.externalObjectSyncSession(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, session)
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncSessionItems(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
session, _, ok := server.externalObjectSyncSession(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{
|
|
SessionID: session.ID,
|
|
Status: strings.TrimSpace(request.URL.Query().Get("status")),
|
|
Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
|
|
Limit: objectSyncQueryLimit(request),
|
|
})
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "items_list_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, page)
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncSessionFinish(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
session, _, ok := server.externalObjectSyncSession(writer, request, target)
|
|
if !ok {
|
|
return
|
|
}
|
|
action := chi.URLParam(request, "action")
|
|
if action == "abort" {
|
|
session.Status = domain.ObjectSyncSessionAborted
|
|
cursor := ""
|
|
for {
|
|
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{SessionID: session.ID, Cursor: cursor, Limit: 1000})
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_abort_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
updates := make([]domain.ObjectSyncItemRecord, 0, len(page.Items))
|
|
for _, item := range page.Items {
|
|
switch item.Status {
|
|
case domain.ObjectSyncItemCommitted, domain.ObjectSyncItemKeptBoth, domain.ObjectSyncItemUnchanged, domain.ObjectSyncItemSkipped, domain.ObjectSyncItemDenied, domain.ObjectSyncItemFailed, domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired:
|
|
continue
|
|
default:
|
|
item.Status = domain.ObjectSyncItemAborted
|
|
item.UpdatedAt = nowISO()
|
|
updates = append(updates, item)
|
|
}
|
|
}
|
|
if err := target.UpsertObjectSyncItems(request.Context(), updates); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_abort_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
if page.NextCursor == "" {
|
|
break
|
|
}
|
|
cursor = page.NextCursor
|
|
}
|
|
} else if action == "complete" {
|
|
counts := domain.ObjectSyncSessionCounts{Manifest: session.Counts.Manifest}
|
|
cursor := ""
|
|
for {
|
|
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{SessionID: session.ID, Cursor: cursor, Limit: 1000})
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_finalize_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
for _, item := range page.Items {
|
|
switch item.Status {
|
|
case domain.ObjectSyncItemCommitted:
|
|
counts.Committed++
|
|
case domain.ObjectSyncItemKeptBoth:
|
|
counts.KeptBoth++
|
|
counts.Committed++
|
|
case domain.ObjectSyncItemUnchanged:
|
|
counts.Unchanged++
|
|
case domain.ObjectSyncItemSkipped:
|
|
counts.Skipped++
|
|
case domain.ObjectSyncItemDenied:
|
|
counts.Denied++
|
|
case domain.ObjectSyncItemFailed:
|
|
counts.Failed++
|
|
case domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired:
|
|
counts.Failed++
|
|
default:
|
|
renderObjectSyncError(writer, request, http.StatusConflict, "session_items_active", "Session still has active items", true, map[string]any{"itemId": item.ID, "status": item.Status})
|
|
return
|
|
}
|
|
switch item.Action {
|
|
case "create":
|
|
counts.Create++
|
|
case "update":
|
|
counts.Update++
|
|
}
|
|
}
|
|
if page.NextCursor == "" {
|
|
break
|
|
}
|
|
cursor = page.NextCursor
|
|
}
|
|
session.Counts = counts
|
|
switch {
|
|
case session.Counts.Failed > 0 || session.Counts.Denied > 0:
|
|
session.Status = domain.ObjectSyncSessionPartial
|
|
case session.Counts.KeptBoth > 0:
|
|
session.Status = domain.ObjectSyncSessionConflicted
|
|
default:
|
|
session.Status = domain.ObjectSyncSessionCompleted
|
|
}
|
|
} else {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_session_action", "Action must be complete or abort", false, nil)
|
|
return
|
|
}
|
|
session.UpdatedAt = nowISO()
|
|
session.CompletedAt = session.UpdatedAt
|
|
if err := target.UpsertObjectSyncSession(request.Context(), *session); err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_finalize_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, session)
|
|
}
|
|
|
|
func (server *server) handleExternalObjectSyncUpdateCheck(writer http.ResponseWriter, request *http.Request) {
|
|
target, ok := server.objectSyncStore(writer, request)
|
|
if !ok {
|
|
return
|
|
}
|
|
principal, _ := currentObjectSyncCredential(request)
|
|
items, err := target.ListObjectSyncClientReleases(request.Context())
|
|
if err != nil {
|
|
renderObjectSyncError(writer, request, http.StatusInternalServerError, "update_check_failed", err.Error(), true, nil)
|
|
return
|
|
}
|
|
platformKey := principal.Device.Platform + "-" + principal.Device.Architecture
|
|
currentVersion := strings.TrimSpace(request.URL.Query().Get("currentVersion"))
|
|
if currentVersion == "" || len(currentVersion) > 128 {
|
|
renderObjectSyncError(writer, request, http.StatusBadRequest, "current_version_required", "currentVersion is required and must be at most 128 characters", false, nil)
|
|
return
|
|
}
|
|
for _, item := range items {
|
|
if !objectSyncClientReleaseCanAutoUpdate(item) {
|
|
continue
|
|
}
|
|
if currentVersion != "" && item.Version == currentVersion {
|
|
continue
|
|
}
|
|
if _, exists := item.Artifacts[platformKey]; !exists {
|
|
continue
|
|
}
|
|
sum := sha256.Sum256([]byte(principal.Device.ID + ":" + item.Version))
|
|
bucket := int(sum[0]) * 100 / 256
|
|
if bucket >= item.RolloutPercent {
|
|
continue
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"updateAvailable": true, "release": item, "platformKey": platformKey})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"updateAvailable": false})
|
|
}
|