package api import ( "context" "errors" "net/http" "time" "droboticflow/internal/domain" "droboticflow/internal/store" ) // A missing local source is a terminal skip, not a user cancellation or a failed // upload. This endpoint cannot discard an object already acknowledged Uploaded. func (server *server) handleExternalObjectSyncItemSkipMissing(writer http.ResponseWriter, request *http.Request) { target, ok := server.objectSyncStore(writer, request) if !ok { return } item, session, _, ok := server.externalObjectSyncItem(writer, request, target) if !ok { return } switch item.Status { case domain.ObjectSyncItemDiscovered, domain.ObjectSyncItemPlanned, domain.ObjectSyncItemReserved, domain.ObjectSyncItemUploading: before := item.Status item.Status = domain.ObjectSyncItemSkipped item.LastError = "source_missing" item.CoordinatorOwner = "" item.CoordinatorLeaseUntil = time.Time{} item.UpdatedAt = nowISO() saved, err := target.TransitionObjectSyncItem(request.Context(), *item, before) if err != nil { renderObjectSyncError(writer, request, 503, "item_persistence_failed", "Could not persist missing-source skip", true, nil) return } if !saved { current, err := target.GetObjectSyncItem(request.Context(), item.ID) if err != nil || current == nil { renderObjectSyncError(writer, request, 503, "item_lookup_failed", "Could not read the changed item state", true, nil) return } switch current.Status { case domain.ObjectSyncItemDiscovered, domain.ObjectSyncItemPlanned, domain.ObjectSyncItemReserved, domain.ObjectSyncItemUploading: renderObjectSyncError(writer, request, 409, "item_state_changed", "Item changed while recording missing source; retry against current state", true, nil) return default: // In particular, a concurrent upload acknowledgment always wins. renderJSON(writer, http.StatusOK, current) return } } case domain.ObjectSyncItemSkipped: if item.LastError != "source_missing" { renderJSON(writer, http.StatusOK, item) return } default: renderJSON(writer, http.StatusOK, item) return } // Retry lease cleanup even when the skip was already persisted by an earlier // request whose response was lost. The fencing token protects a new holder. if item.LeaseID != "" { if err := target.ReleaseObjectSyncLease(request.Context(), item.LeaseID, session.ID, item.ID, item.FencingToken); err != nil { renderObjectSyncError(writer, request, 503, "lease_release_failed", "Missing source was skipped; lease cleanup must be retried", true, nil) return } } if err := server.cleanupMissingObjectSyncMultipart(request.Context(), target, session, item); err != nil { // Source loss must not block other uploads on a storage cleanup outage. // Keep the persisted staging/upload IDs for the coordinator's normal TTL // staging sweeper. No final object deletion is performed here. writer.Header().Set("X-Drosync-Cleanup", "deferred") } renderJSON(writer, http.StatusOK, item) } func (server *server) cleanupMissingObjectSyncMultipart(ctx context.Context, target store.ObjectSyncStore, session *domain.ObjectSyncSessionRecord, item *domain.ObjectSyncItemRecord) error { if item.UploadMode != "multipart" || item.UploadID == "" || item.StagingKey == "" { return nil } cleanupContext, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) defer cancel() space, err := target.GetObjectSyncSpace(cleanupContext, session.SyncSpaceID) if err != nil { return err } if space == nil { return errors.New("sync space unavailable for multipart cleanup") } browser, closeBrowser, err := server.objectSyncBrowser(cleanupContext, space) if err != nil { return err } defer closeBrowser() return browser.AbortMultipartUpload(cleanupContext, space.Bucket, item.StagingKey, item.UploadID) }