droboticflow/internal/api/object_sync.go

2842 lines
123 KiB
Go

package api
import (
"bytes"
"context"
"crypto/md5"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"errors"
"fmt"
"io"
"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 {
TokenHash string
Binding domain.ObjectSyncCredentialTokenBinding
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)
})
}
// Data uploads use BOS directly. Protect control work independently per device,
// and reserve capacity for heartbeats/cancellation even during a metadata burst.
func objectSyncBudgetClass(request *http.Request) string {
if strings.HasSuffix(request.URL.Path, "/heartbeat") || strings.HasSuffix(request.URL.Path, "/abort") {
return "liveness"
}
if request.Method == http.MethodGet || request.Method == http.MethodHead {
return "read"
}
return "write"
}
func (server *server) objectSyncControlRateLimit(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
limit := int64(server.objectSyncControlRequestsPerMinute)
if limit <= 0 {
limit = 6000
}
switch objectSyncBudgetClass(request) {
case "read":
limit = 1200
case "liveness":
limit = 120
}
server.objectSyncDistributedRateLimit(limit, time.Minute)(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 + ":device:" + principal.Device.ID + ":" + objectSyncBudgetClass(request)
}
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 budget for this device and operation class 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)}
// Finish the bounded control mutation and its replay receipt even if the
// caller disconnects after the effect committed. Data PUTs bypass this API.
mutationCtx, cancelMutation := context.WithTimeout(context.WithoutCancel(request.Context()), time.Minute)
next.ServeHTTP(buffered, request.WithContext(mutationCtx))
cancelMutation()
receiptCtx, cancelReceipt := context.WithTimeout(context.WithoutCancel(request.Context()), 10*time.Second)
defer cancelReceipt()
// Failed attempts are not committed outcomes. In particular, retryable
// 409 lease contention must be re-evaluated after the owner releases it.
if buffered.status >= http.StatusBadRequest {
_ = target.DeleteObjectSyncIdempotency(receiptCtx, 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(receiptCtx, 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
}
binding, _ := objectSyncCredentialBindingForToken(*credential, hash)
if binding.Pending && request.URL.Path != "/api/external/object-sync/capabilities" && request.URL.Path != "/api/external/object-sync/auth/activate" {
renderObjectSyncError(writer, request, http.StatusForbidden, "credential_activation_required", "Persist and activate the pending credential before transfer operations", false, nil)
return
}
deviceID := binding.DeviceID
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.TouchObjectSyncCredential(request.Context(), credential.ID)
_ = target.UpsertObjectSyncDevice(request.Context(), *device)
ctx := context.WithValue(request.Context(), objectSyncCredentialContextKey{}, &objectSyncCredentialPrincipal{
TokenHash: hash, Binding: binding,
Credential: *credential,
Device: *device,
})
next.ServeHTTP(writer, request.WithContext(ctx))
})
}
func objectSyncCredentialBindingForToken(credential domain.ObjectSyncCredentialRecord, hash string) (domain.ObjectSyncCredentialTokenBinding, bool) {
for _, binding := range credential.TokenBindings {
if subtle.ConstantTimeCompare([]byte(binding.TokenHash), []byte(hash)) != 1 {
continue
}
if binding.Pending {
expiry, err := time.Parse(time.RFC3339Nano, binding.ExpiresAt)
if err != nil || !expiry.After(time.Now()) {
return binding, false
}
}
return binding, true
}
return domain.ObjectSyncCredentialTokenBinding{}, false
}
func objectSyncCredentialTokenMatches(credential domain.ObjectSyncCredentialRecord, hash string) bool {
_, ok := objectSyncCredentialBindingForToken(credential, hash)
return ok
}
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 {
principal, _ := currentPrincipal(request)
return principal
}
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 len(item.MD5Sum) == 32 && strings.TrimSpace(result.ETag) != "" &&
objectSyncMetadataValue(result.Metadata, "drosync-session") == session.ID &&
objectSyncMetadataValue(result.Metadata, "drosync-item") == item.ID &&
objectSyncMetadataValue(result.Metadata, "drosync-md5sum") == item.MD5Sum
}
func sanitizeObjectSyncCredential(item domain.ObjectSyncCredentialRecord) domain.ObjectSyncCredentialRecord {
item.SecretHash = ""
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")
}
if err := connection.CheckStoragePath(space.Bucket, space.RootPrefix, true); err != nil {
return nil, nil, err
}
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
}
if err := connection.CheckStoragePath(input.Bucket, input.RootPrefix, true); err != nil {
renderError(writer, http.StatusForbidden, err)
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) 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
}
item.SecretHash = secretHash
item.SecretPreview = objectSyncSecretPreview(secret)
item.TokenBindings = nil
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}, 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,
DeviceID: strings.TrimSpace(request.URL.Query().Get("deviceId")),
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
}
if err := refreshObjectSyncSessionCounts(request.Context(), target, page.Items); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_progress_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, page)
}
// Session counts are read on demand. Item commits do not rescan the
// entire session or write overlapping count snapshots from different workers.
func refreshObjectSyncSessionCounts(ctx context.Context, target store.ObjectSyncStore, sessions []domain.ObjectSyncSessionRecord) error {
ids := make([]string, 0, len(sessions))
for _, session := range sessions {
if session.Status != domain.ObjectSyncSessionCollectingManifest && session.Status != domain.ObjectSyncSessionPlanning {
ids = append(ids, session.ID)
}
}
if len(ids) == 0 {
return nil
}
summaries, err := target.SummarizeObjectSyncItems(ctx, ids)
if err != nil {
return err
}
for index := range sessions {
if summary, ok := summaries[sessions[index].ID]; ok {
manifest := sessions[index].Counts.Manifest
sessions[index].Counts = summary.Counts
sessions[index].Counts.Manifest = manifest
}
}
return nil
}
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
}
}
items := []domain.ObjectSyncSessionRecord{*item}
if err := refreshObjectSyncSessionCounts(request.Context(), target, items); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_progress_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, items[0])
}
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")),
Action: strings.TrimSpace(request.URL.Query().Get("action")),
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) 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(), principal.User.OrganizationID, 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,
MD5Sum: conflict.MD5Sum,
ContentType: conflict.ContentType,
Action: "force_overwrite",
Status: domain.ObjectSyncItemCommitting,
CommitRequestedAt: nowISO(),
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.ListObjectSyncReleasesPage(request.Context(), objectSyncPageQuery(request, principal.User.OrganizationID))
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "releases_list_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, 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, objectSyncPageQuery(request, principal.User.OrganizationID))
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "audit_list_failed", err.Error(), true, nil)
return
}
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) 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
}
active := make([]domain.ObjectSyncClientReleaseRecord, 0, len(items))
for _, item := range items {
if item.ManifestVersion == 2 {
active = append(active, item)
}
}
items = active
for index := range items {
items[index] = objectSyncClientReleaseForResponse(items[index])
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func objectSyncClientReleaseKind(item domain.ObjectSyncClientReleaseRecord) string {
return strings.TrimSpace(item.Kind)
}
func objectSyncClientReleaseCanAutoUpdate(item domain.ObjectSyncClientReleaseRecord) bool {
return objectSyncClientReleaseKind(item) == objectSyncReleaseSigned &&
item.ManifestVersion == 2 && !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(w http.ResponseWriter, r *http.Request) {
target, ok := server.objectSyncStore(w, r)
if !ok {
return
}
var input domain.ObjectSyncClientReleaseRecord
if !decodeJSON(w, r, &input) {
return
}
if input.Kind != objectSyncReleaseSigned && input.Kind != objectSyncReleasePreview {
renderObjectSyncError(w, r, 400, "invalid_client_release_kind", "Explicit signed or preview kind is required", false, nil)
return
}
if err := validateObjectSyncReleaseMetadata(input); err != nil {
renderObjectSyncError(w, r, 400, "invalid_client_release", err.Error(), false, nil)
return
}
if input.Kind == objectSyncReleaseSigned {
if input.Channel != "canary" || input.RolloutPercent != 5 || input.Paused {
renderObjectSyncError(w, r, 409, "initial_rollout_stage_required", "Register at canary 5%; use the rollout endpoint for policy changes", false, nil)
return
}
if server.objectSyncUpdateSigningPublicKey == "" {
renderObjectSyncError(w, r, 503, "update_signing_not_configured", "Configure the trusted update public key before registration", false, nil)
return
}
if err := server.verifyObjectSyncRelease(input); err != nil {
renderObjectSyncError(w, r, 400, "invalid_manifest_signature", err.Error(), false, nil)
return
}
} else {
if input.Channel != "preview" || input.RolloutPercent != 100 || input.Paused || input.Signature != "" {
renderObjectSyncError(w, r, 400, "invalid_preview_release", "Preview registration requires preview/100/unpaused and no signature", false, nil)
return
}
for _, source := range input.Artifacts {
connectionID, bucket, _, err := parseObjectSyncPreviewArtifact(source)
if err != nil {
renderObjectSyncError(w, r, 400, "invalid_preview_release", err.Error(), false, nil)
return
}
connection, err := server.store.GetStorageConnection(r.Context(), connectionID)
if err != nil || connection == nil || normalizedOrganizationID(connection.OrganizationID) != objectSyncManagementPrincipal(r).User.OrganizationID {
renderObjectSyncError(w, r, 403, "artifact_connection_denied", "Preview artifacts must use a connection in this organization", false, nil)
return
}
if _, err := resolveObjectStorageBucket(connection, bucket); err != nil {
renderObjectSyncError(w, r, 400, "artifact_bucket_denied", "Artifact bucket is outside the selected connection", false, nil)
return
}
}
}
input.OrganizationID = objectSyncManagementPrincipal(r).User.OrganizationID
input.Revision = 1
input.CreatedAt = nowISO()
input.StageChangedAt = input.CreatedAt
stored, created, err := target.CreateObjectSyncClientRelease(r.Context(), input)
if errors.Is(err, store.ErrObjectSyncReleaseVersionExists) {
renderObjectSyncError(w, r, 409, "release_version_exists", "Use the registered ID; a new ID cannot bypass rollout observation", false, nil)
return
}
if err != nil {
renderObjectSyncError(w, r, 503, "client_release_save_failed", "Release registration failed", true, nil)
return
}
if !created {
left, _ := objectSyncReleasePayload(*stored)
right, _ := objectSyncReleasePayload(input)
if stored.OrganizationID != input.OrganizationID {
renderObjectSyncError(w, r, 404, "client_release_not_found", "Release not found", false, nil)
return
}
if !bytes.Equal(left, right) || stored.Signature != input.Signature {
renderObjectSyncError(w, r, 409, "client_release_immutable", "Registered artifact metadata is immutable", false, nil)
return
}
}
if !server.requireObjectSyncAudit(w, r, target, domain.ObjectSyncAuditEvent{OrganizationID: input.OrganizationID, ActorType: "user", ActorID: objectSyncManagementPrincipal(r).User.ID, RequestID: objectSyncRequestID(r), Action: "client_release." + input.Kind, Target: map[string]any{"releaseId": stored.ID, "version": stored.Version}, Result: "success"}) {
return
}
renderJSON(w, 200, objectSyncClientReleaseForResponse(*stored))
}
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) 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,
"features": map[string]bool{"sessionHeartbeat": true, "previewSessions": true, "credentialActivation": true, "metadataRecovery": true, "safeClean": true, "orderedUploadPages": true, "directUploadCommit": true,
"missingFileSkip": true},
"serverVersion": objectSyncServerVersion,
"stateSchemaMinimum": 7, "stateSchemaMaximum": 7,
"scopes": principal.Credential.Scopes,
"credentialId": principal.Credential.ID, "deviceId": principal.Device.ID,
"credentialActivated": !principal.Binding.Pending, "activationId": principal.Binding.ActivationID,
"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"`
Preview bool `json:"preview"`
}
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),
Preview: input.Preview,
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.MD5Sum); decodeErr != nil || len(decoded) != md5.Size {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_md5sum", "Manifest item MD5 must be a 32-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,
MD5Sum: strings.ToLower(manifest.MD5Sum),
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 saved, err := target.TransitionObjectSyncSession(request.Context(), *session, domain.ObjectSyncSessionCollectingManifest); err != nil || !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "session_state_changed", "Session changed while its manifest was being saved", false, 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 saved, err := target.TransitionObjectSyncSession(request.Context(), *session, domain.ObjectSyncSessionCollectingManifest); err != nil || !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "session_state_changed", "Session changed before planning could be queued", false, 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 {
renderObjectSyncError(writer, request, 503, "item_lookup_failed", "Could not read item state", true, nil)
return nil, nil, principal, false
}
if item == nil || item.OrganizationID != principal.Credential.OrganizationID {
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 {
renderObjectSyncError(writer, request, 503, "session_lookup_failed", "Could not read session state", true, nil)
return nil, nil, principal, false
}
if session == nil || session.OrganizationID != principal.Credential.OrganizationID || 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
}
if request.Method != http.MethodGet && (session.Status == domain.ObjectSyncSessionCompleted || session.Status == domain.ObjectSyncSessionPartial || session.Status == domain.ObjectSyncSessionConflicted || session.Status == domain.ObjectSyncSessionAborted || session.Status == domain.ObjectSyncSessionExpired || session.Status == domain.ObjectSyncSessionFailed) {
renderObjectSyncError(writer, request, http.StatusConflict, "session_closed", "Session is no longer active", false, nil)
return nil, nil, principal, false
}
if session.Preview && request.Method != http.MethodGet && !strings.HasSuffix(request.URL.Path, "/abort") {
renderObjectSyncError(writer, request, http.StatusConflict, "preview_read_only", "Preview sessions cannot reserve, upload or commit file bytes", false, nil)
return nil, nil, principal, false
}
return item, session, principal, true
}
// Persist the terminal session before releasing leases so new client operations
// cannot extend an aborted session. Retrying abort also retries lease cleanup.
func abortObjectSyncSession(ctx context.Context, target store.ObjectSyncStore, session *domain.ObjectSyncSessionRecord) error {
if session.Status == domain.ObjectSyncSessionCompleted || session.Status == domain.ObjectSyncSessionPartial || session.Status == domain.ObjectSyncSessionConflicted {
return nil
}
previousStatus := session.Status
session.Status = domain.ObjectSyncSessionAborted
session.CoordinatorOwner = ""
session.CoordinatorLeaseUntil = time.Time{}
session.UpdatedAt = nowISO()
session.CompletedAt = session.UpdatedAt
if saved, err := target.TransitionObjectSyncSession(ctx, *session, previousStatus); err != nil {
return err
} else if !saved {
current, err := target.GetObjectSyncSession(ctx, session.ID)
if err != nil {
return err
}
if current == nil {
return fmt.Errorf("session disappeared during abort")
}
if err := abortObjectSyncSession(ctx, target, current); err != nil {
return err
}
*session = *current
return nil
}
cursor := ""
for {
page, err := target.ListObjectSyncItems(ctx, domain.ObjectSyncListQuery{SessionID: session.ID, Cursor: cursor, Limit: 1000})
if err != nil {
return err
}
updates := make([]domain.ObjectSyncItemRecord, 0, len(page.Items))
for _, item := range page.Items {
if item.LeaseID != "" {
if err := target.ReleaseObjectSyncLease(ctx, item.LeaseID, session.ID, item.ID, item.FencingToken); err != nil {
return err
}
}
switch item.Status {
case domain.ObjectSyncItemCommitted, domain.ObjectSyncItemKeptBoth, domain.ObjectSyncItemUnchanged, domain.ObjectSyncItemSkipped, domain.ObjectSyncItemDenied, domain.ObjectSyncItemFailed, domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired:
continue
}
item.Status = domain.ObjectSyncItemAborted
item.CoordinatorOwner = ""
item.CoordinatorLeaseUntil = time.Time{}
item.UpdatedAt = nowISO()
updates = append(updates, item)
}
if err := target.AbortObjectSyncItems(ctx, updates); err != nil {
return err
}
if page.NextCursor == "" {
return nil
}
cursor = page.NextCursor
}
}
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
}
connection, connectionErr := server.store.GetStorageConnection(request.Context(), space.ConnectionID)
if connectionErr != nil || connection == nil {
renderObjectSyncError(writer, request, http.StatusConflict, "storage_unavailable", "Storage connection is unavailable", false, nil)
return
}
if err := connection.CheckStoragePath(space.Bucket, item.TargetKey, false); err != nil {
renderError(writer, http.StatusForbidden, err)
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 = item.TargetKey
item.Status = domain.ObjectSyncItemReserved
item.UpdatedAt = nowISO()
session.Status = domain.ObjectSyncSessionRunning
session.LastHeartbeatAt = item.UpdatedAt
session.UpdatedAt = item.UpdatedAt
if saved, err := target.TransitionObjectSyncItem(request.Context(), *item, domain.ObjectSyncItemPlanned); err != nil || !saved {
releaseErr := target.ReleaseObjectSyncLease(request.Context(), item.LeaseID, session.ID, item.ID, item.FencingToken)
if err != nil || releaseErr != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "item_reserve_failed", "Unable to persist reservation or release its lease", true, nil)
} else {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed while reserving", false, nil)
}
return
}
if touched, err := target.TouchObjectSyncSession(request.Context(), session.ID, true); err != nil || !touched {
releaseErr := target.ReleaseObjectSyncLease(request.Context(), item.LeaseID, session.ID, item.ID, item.FencingToken)
item.Status = domain.ObjectSyncItemAborted
item.CoordinatorOwner = ""
item.CoordinatorLeaseUntil = time.Time{}
_, cleanupErr := target.TransitionObjectSyncItem(request.Context(), *item, domain.ObjectSyncItemReserved)
if err != nil || releaseErr != nil || cleanupErr != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "reservation_cleanup_failed", "Unable to confirm reservation cleanup", true, nil)
} else {
renderObjectSyncError(writer, request, http.StatusConflict, "session_closed", "Session is no longer active", false, nil)
}
return
}
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
}
previousItemStatus := item.Status
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-md5sum": item.MD5Sum, "drosync-fence": fmt.Sprintf("%d", item.FencingToken)}
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()
if saved, err := target.TransitionObjectSyncItem(request.Context(), *item, previousItemStatus); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "item_persistence_failed", "Unable to persist item state", true, nil)
return
} else if !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed while this request was in flight", false, nil)
return
}
renderJSON(writer, http.StatusOK, map[string]any{
"upload": result,
"required": map[string]any{
"sizeBytes": item.SizeBytes,
"md5sum": item.MD5Sum,
"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
}
previousItemStatus := item.Status
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-md5sum": item.MD5Sum,
"drosync-fence": fmt.Sprintf("%d", item.FencingToken),
}, 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()
saved, saveErr := target.TransitionObjectSyncItem(request.Context(), *item, previousItemStatus)
if saveErr != nil {
// A write can succeed before a derived-cache write fails. Never abort
// an upload whose persistence outcome is still unknown.
persisted, readErr := target.GetObjectSyncItem(request.Context(), item.ID)
if readErr != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "multipart_persistence_unconfirmed", "Multipart initialization persistence is unconfirmed; retry to recover it", true, nil)
return
}
if persisted != nil && persisted.UploadID == result.UploadID {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "multipart_persistence_unconfirmed", "Multipart upload was stored but its progress update failed; retry to resume it", true, nil)
return
}
}
if saveErr != nil || !saved {
// The upload was created by this request but never became its stored
// upload. Clean this exact ID even if cancellation ended the request.
cleanupContext, cancelCleanup := context.WithTimeout(context.WithoutCancel(request.Context()), 30*time.Second)
cleanupErr := browser.AbortMultipartUpload(cleanupContext, space.Bucket, item.StagingKey, result.UploadID)
cancelCleanup()
if cleanupErr != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "multipart_cleanup_failed", "Multipart initialization lost its state transition and remote cleanup failed", true, nil)
} else if saveErr != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "item_persistence_failed", "Unable to persist item state", true, nil)
} else {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed during multipart initialization", false, nil)
}
return
}
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
}
previousItemStatus := item.Status
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 saved, err := target.TransitionObjectSyncItem(request.Context(), *item, previousItemStatus); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "multipart_checkpoint_failed", err.Error(), true, nil)
return
} else if !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed while this request was in flight", false, 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
}
if item.UploadMode != "multipart" {
renderObjectSyncError(writer, request, 409, "upload_mode_mismatch", "Use the completion endpoint for the active upload mode", false, nil)
return
}
if item.Status == domain.ObjectSyncItemCommitted || item.Status == domain.ObjectSyncItemCommitting {
renderJSON(writer, http.StatusOK, map[string]any{"item": item, "resumed": true})
return
}
previousItemStatus := item.Status
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
}
server.finalizeVerifiedDirect(request.Context(), item, result)
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-md5sum": item.MD5Sum,
"drosync-fence": fmt.Sprintf("%d", item.FencingToken),
})
if err != nil {
// Completion can succeed remotely before the response or local state
// write is lost. Adopt only this item's exact bound object.
recovered, lookupErr := browser.GetObjectSummary(request.Context(), space.Bucket, item.StagingKey)
if lookupErr != nil || recovered.SizeBytes != item.SizeBytes || !objectSyncStagingMatches(recovered, item, session) {
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_complete_failed", err.Error(), true, nil)
return
}
result = recovered
}
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()
if saved, err := target.TransitionObjectSyncItem(request.Context(), *item, previousItemStatus); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "item_persistence_failed", "Unable to persist item state", true, nil)
return
} else if !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed while this request was in flight", false, nil)
return
}
server.finalizeVerifiedDirect(request.Context(), item, result)
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" {
renderObjectSyncError(writer, request, 409, "upload_mode_mismatch", "Use the completion endpoint for the active upload mode", false, nil)
return
}
if item.Status == domain.ObjectSyncItemCommitted || item.Status == domain.ObjectSyncItemCommitting {
renderJSON(writer, http.StatusOK, map[string]any{"item": item, "resumed": true})
return
}
previousItemStatus := item.Status
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 {
server.finalizeVerifiedDirect(request.Context(), item, result)
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item, "resumed": true})
return
}
item.Status = domain.ObjectSyncItemUploaded
item.UpdatedAt = nowISO()
if saved, err := target.TransitionObjectSyncItem(request.Context(), *item, previousItemStatus); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "item_persistence_failed", "Unable to persist item state", true, nil)
return
} else if !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed while this request was in flight", false, nil)
return
}
server.finalizeVerifiedDirect(request.Context(), item, result)
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
}
switch item.Status {
case domain.ObjectSyncItemReserved, domain.ObjectSyncItemUploading, domain.ObjectSyncItemUploaded, domain.ObjectSyncItemCommitting:
default:
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_active", "Only active leased items may send heartbeats", false, nil)
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
if touched, err := target.TouchObjectSyncSession(request.Context(), session.ID, false); err != nil || !touched {
renderObjectSyncError(writer, request, http.StatusConflict, "session_closed", "Session is no longer active", false, nil)
return
}
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
}
switch item.Status {
case domain.ObjectSyncItemCommitted, domain.ObjectSyncItemKeptBoth, domain.ObjectSyncItemUnchanged, domain.ObjectSyncItemSkipped, domain.ObjectSyncItemDenied, domain.ObjectSyncItemFailed, domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired:
renderJSON(writer, http.StatusOK, item)
return
}
previousItemStatus := item.Status
item.Status = domain.ObjectSyncItemAborted
item.CoordinatorOwner = ""
item.CoordinatorLeaseUntil = time.Time{}
item.UpdatedAt = nowISO()
if saved, err := target.TransitionObjectSyncItem(request.Context(), *item, previousItemStatus); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "item_persistence_failed", "Unable to persist item state", true, nil)
return
} else if !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed before cancellation; query its current status", true, nil)
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)
}
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
}
previousItemStatus := item.Status
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.CommitRequestedAt = nowISO()
item.OperationID = objectSyncNewID("op")
item.UpdatedAt = nowISO()
if saved, err := target.TransitionObjectSyncItem(request.Context(), *item, previousItemStatus); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "commit_enqueue_failed", err.Error(), true, nil)
return
} else if !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "item_state_changed", "Item changed while this request was in flight", false, 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
}
summaries, err := target.SummarizeObjectSyncItems(request.Context(), []string{session.ID})
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_progress_failed", err.Error(), true, nil)
return
}
summary := summaries[session.ID]
manifestCount := session.Counts.Manifest
session.Counts = summary.Counts
session.Counts.Manifest = manifestCount
renderJSON(writer, http.StatusOK, struct {
*domain.ObjectSyncSessionRecord
Progress struct {
TotalItems int64 `json:"totalItems"`
TerminalItems int64 `json:"terminalItems"`
} `json:"progress"`
}{session, struct {
TotalItems int64 `json:"totalItems"`
TerminalItems int64 `json:"terminalItems"`
}{summary.TotalItems, summary.TerminalItems}})
}
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
}
if request.URL.Query().Get("view") != "manifest" || request.URL.Query().Has("status") || request.URL.Query().Has("action") {
renderObjectSyncError(writer, request, 400, "manifest_view_required", "Use view=manifest without status/action filters for resumable device metadata", false, nil)
return
}
if order := request.URL.Query().Get("order"); order != "" && order != "capture_time" {
renderObjectSyncError(writer, request, 400, "invalid_manifest_order", "Use order=capture_time for chronological pages", false, nil)
return
}
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{
SessionID: session.ID,
OrderByCaptureTime: request.URL.Query().Get("order") == "capture_time",
ManifestOnly: true,
Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
Limit: objectSyncQueryLimit(request),
})
if errors.Is(err, store.ErrObjectSyncCaptureCursor) {
renderObjectSyncError(writer, request, 400, "invalid_capture_cursor", err.Error(), false, nil)
return
}
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "items_list_failed", err.Error(), true, nil)
return
}
items := make([]objectSyncDeviceItem, 0, len(page.Items))
for _, item := range page.Items {
items = append(items, deviceMetadata(item))
}
writer.Header().Set("Cache-Control", "no-store")
renderJSON(writer, http.StatusOK, map[string]any{"items": items, "nextCursor": page.NextCursor})
}
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
}
previousStatus := session.Status
action := chi.URLParam(request, "action")
if action == "heartbeat" {
switch session.Status {
case domain.ObjectSyncSessionCompleted, domain.ObjectSyncSessionPartial, domain.ObjectSyncSessionConflicted,
domain.ObjectSyncSessionAborted, domain.ObjectSyncSessionExpired, domain.ObjectSyncSessionFailed:
renderObjectSyncError(writer, request, http.StatusConflict, "session_closed", "Session is no longer active", false, nil)
return
}
if err := target.RenewObjectSyncSessionLeases(request.Context(), session.ID, 5*time.Minute); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "session_heartbeat_failed", "Unable to renew session leases", true, nil)
return
}
renderJSON(writer, http.StatusOK, session)
return
}
if action == "abort" {
if err := abortObjectSyncSession(request.Context(), target, session); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_abort_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, session)
return
} else if action == "complete" {
if session.Status == domain.ObjectSyncSessionCompleted || session.Status == domain.ObjectSyncSessionPartial || session.Status == domain.ObjectSyncSessionConflicted {
renderJSON(writer, http.StatusOK, session)
return
}
if session.Status == domain.ObjectSyncSessionAborted || session.Status == domain.ObjectSyncSessionExpired || session.Status == domain.ObjectSyncSessionFailed {
renderObjectSyncError(writer, request, http.StatusConflict, "session_closed", "Session is no longer active", false, nil)
return
}
summaries, err := target.ReconcileObjectSyncItems(request.Context(), []string{session.ID})
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_finalize_failed", err.Error(), true, nil)
return
}
summary := summaries[session.ID]
if summary.TotalItems != summary.TerminalItems {
renderObjectSyncError(writer, request, http.StatusConflict, "session_items_active", "Session still has active items", true, map[string]any{"totalItems": summary.TotalItems, "terminalItems": summary.TerminalItems})
return
}
if summary.TotalItems < session.Counts.Manifest {
renderObjectSyncError(writer, request, http.StatusConflict, "session_manifest_incomplete", "Session has fewer items than its manifest", false, nil)
return
}
manifestCount := session.Counts.Manifest
session.Counts = summary.Counts
session.Counts.Manifest = manifestCount
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, abort or heartbeat", false, nil)
return
}
session.UpdatedAt = nowISO()
session.CompletedAt = session.UpdatedAt
if saved, err := target.TransitionObjectSyncSession(request.Context(), *session, previousStatus); err != nil || !saved {
renderObjectSyncError(writer, request, http.StatusConflict, "session_state_changed", "Session changed during finalization", false, nil)
return
}
renderJSON(writer, http.StatusOK, session)
}