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