droboticflow/internal/api/object_sync_missing.go

99 lines
3.8 KiB
Go

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