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) }