package api import ( "context" "crypto/sha256" "encoding/csv" "encoding/hex" "encoding/json" "fmt" "io" "net/http" "os" "strconv" "strings" "time" "droboticflow/internal/domain" "github.com/go-chi/chi/v5" ) var objectSyncExportSlots = make(chan struct{}, 2) func objectSyncPageQuery(r *http.Request, org string) domain.ObjectSyncListQuery { return domain.ObjectSyncListQuery{OrganizationID: org, Cursor: strings.TrimSpace(r.URL.Query().Get("cursor")), Limit: objectSyncQueryLimit(r), Status: r.URL.Query().Get("status"), SessionID: r.URL.Query().Get("sessionId"), Action: r.URL.Query().Get("action"), Result: r.URL.Query().Get("result")} } func (server *server) handleObjectSyncReconcilesList(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } p := objectSyncManagementPrincipal(r) page, err := s.ListObjectSyncReconciles(r.Context(), objectSyncPageQuery(r, p.User.OrganizationID)) if err != nil { renderObjectSyncError(w, r, 503, "reconciles_lookup_failed", "Could not read reconciliation tasks", true, nil) return } renderJSON(w, 200, page) } func (server *server) handleObjectSyncReconcileGet(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } v, err := s.GetObjectSyncReconcile(r.Context(), chi.URLParam(r, "id")) if err != nil { renderObjectSyncError(w, r, 503, "reconcile_lookup_failed", "Could not read task", true, nil) return } if v == nil || v.OrganizationID != objectSyncManagementPrincipal(r).User.OrganizationID { renderObjectSyncError(w, r, 404, "reconcile_not_found", "Task not found", false, nil) return } renderJSON(w, 200, v) } func (server *server) handleObjectSyncReconcileRetry(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } org := objectSyncManagementPrincipal(r).User.OrganizationID id := chi.URLParam(r, "id") v, err := s.GetObjectSyncReconcile(r.Context(), id) if err != nil { renderObjectSyncError(w, r, 503, "reconcile_lookup_failed", "Could not read task before retry", true, nil) return } if v == nil || v.OrganizationID != org { renderObjectSyncError(w, r, 404, "reconcile_not_found", "Task not found", false, nil) return } if v.Status == "pending" || v.Status == "running" { renderJSON(w, 202, v) return } saved, err := s.RetryObjectSyncReconcile(r.Context(), org, id) if err != nil { renderObjectSyncError(w, r, 503, "reconcile_retry_failed", "Could not enqueue retry", true, nil) return } if !saved { renderObjectSyncError(w, r, 409, "reconcile_not_retryable", "Only a failed task can be retried", false, nil) return } v, err = s.GetObjectSyncReconcile(r.Context(), id) if err != nil { renderObjectSyncError(w, r, 503, "reconcile_lookup_failed", "Retry queued; refresh task status", true, nil) return } renderJSON(w, 202, v) } func (server *server) handleObjectSyncReleaseGet(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } v, err := s.GetObjectSyncRelease(r.Context(), chi.URLParam(r, "id")) if err != nil { renderObjectSyncError(w, r, 503, "release_lookup_failed", "Could not read release", true, nil) return } if v == nil || v.OrganizationID != objectSyncManagementPrincipal(r).User.OrganizationID { renderObjectSyncError(w, r, 404, "release_not_found", "Release not found", false, nil) return } renderJSON(w, 200, v) } func (server *server) handleObjectSyncReleaseRetry(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } org := objectSyncManagementPrincipal(r).User.OrganizationID id := chi.URLParam(r, "id") v, err := s.GetObjectSyncRelease(r.Context(), id) if err != nil { renderObjectSyncError(w, r, 503, "release_lookup_failed", "Could not read task before retry", true, nil) return } if v == nil || v.OrganizationID != org { renderObjectSyncError(w, r, 404, "release_not_found", "Release not found", false, nil) return } if v.Status == "pending" { renderJSON(w, 202, map[string]any{"operationId": id, "release": v}) return } saved, err := s.RetryObjectSyncRelease(r.Context(), org, id) if err != nil { renderObjectSyncError(w, r, 503, "release_retry_failed", "Could not enqueue retry", true, nil) return } if !saved { renderObjectSyncError(w, r, 409, "release_not_retryable", "Only a failed release can be retried", false, nil) return } v, err = s.GetObjectSyncRelease(r.Context(), id) if err != nil { renderObjectSyncError(w, r, 503, "release_lookup_failed", "Retry queued; refresh release status", true, nil) return } renderJSON(w, 202, map[string]any{"operationId": id, "release": v}) } func (server *server) handleObjectSyncItemGet(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } v, err := s.GetObjectSyncItem(r.Context(), chi.URLParam(r, "id")) p := objectSyncManagementPrincipal(r) if err != nil { renderObjectSyncError(w, r, 503, "item_lookup_failed", "Could not read item", true, nil) return } if v == nil || v.OrganizationID != p.User.OrganizationID { renderObjectSyncError(w, r, 404, "item_not_found", "Item not found", false, nil) return } if p.User.Role == domain.UserRoleDataOperator { session, e := s.GetObjectSyncSession(r.Context(), v.SessionID) if e != nil || session == nil { renderObjectSyncError(w, r, 404, "item_not_found", "Item not found", false, nil) return } space, e := s.GetObjectSyncSpace(r.Context(), session.SyncSpaceID) if e != nil || space == nil || !objectSyncSpaceAllowsUser(*space, p.User) { renderObjectSyncError(w, r, 404, "item_not_found", "Item not found", false, nil) return } } renderJSON(w, 200, v) } func beginObjectSyncExport(w http.ResponseWriter, r *http.Request) (func(), bool) { select { case objectSyncExportSlots <- struct{}{}: return func() { <-objectSyncExportSlots }, true default: w.Header().Set("Retry-After", "5") renderObjectSyncError(w, r, 503, "export_busy", "Two exports are already running; retry shortly", true, nil) return nil, false } } func serveObjectSyncSpool(w http.ResponseWriter, r *http.Request, file *os.File, contentType, name, digest string, count int64) error { stat, err := file.Stat() if err != nil { return err } if _, err = file.Seek(0, io.SeekStart); err != nil { return err } w.Header().Set("Content-Type", contentType) w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", name)) w.Header().Set("Content-Length", strconv.FormatInt(stat.Size(), 10)) w.Header().Set("X-Content-SHA256", digest) w.Header().Set("X-Record-Count", strconv.FormatInt(count, 10)) w.Header().Set("Cache-Control", "private, no-store") _, err = io.Copy(w, file) return err } func csvSafe(value string) string { if len(value) > 0 && strings.ContainsRune("=+-@\t\r", rune(value[0])) { return "'" + value } return value } func (server *server) handleObjectSyncAuditExport(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } start, end, ok := objectSyncAuditRange(w, r) if !ok { return } format := r.URL.Query().Get("format") if format == "" { format = "ndjson" } if format != "csv" && format != "ndjson" { renderObjectSyncError(w, r, 400, "invalid_audit_format", "format must be csv or ndjson", false, nil) return } release, ok := beginObjectSyncExport(w, r) if !ok { return } defer release() file, err := os.CreateTemp("", "drosync-audit-*.tmp") if err != nil { renderObjectSyncError(w, r, 503, "audit_export_failed", "Could not create export spool", true, nil) return } defer os.Remove(file.Name()) defer file.Close() ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute) defer cancel() q := objectSyncPageQuery(r, objectSyncManagementPrincipal(r).User.OrganizationID) q.Cursor = "" q.Limit = 1000 hash := sha256.New() output := io.MultiWriter(file, hash) encoder := json.NewEncoder(output) csvOut := csv.NewWriter(output) if format == "csv" { err = csvOut.Write([]string{"id", "occurredAt", "actorType", "actorId", "action", "result", "sessionId", "itemId", "eventHash", "previousHash"}) } var count int64 for err == nil { var page domain.ObjectSyncAuditPage page, err = s.ListObjectSyncAuditRange(ctx, q.OrganizationID, start, end, q) if err != nil { break } for _, v := range page.Items { if format == "csv" { row := []string{v.ID, v.OccurredAt, v.ActorType, v.ActorID, v.Action, v.Result, v.SessionID, v.ItemID, v.EventHash, v.PreviousHash} for i := range row { row[i] = csvSafe(row[i]) } err = csvOut.Write(row) } else { err = encoder.Encode(v) } if err != nil { break } count++ } if err != nil || page.NextCursor == "" { break } q.Cursor = page.NextCursor } if format == "csv" { csvOut.Flush() if err == nil { err = csvOut.Error() } } if err != nil { renderObjectSyncError(w, r, 503, "audit_export_failed", "Audit export was not completed; no partial file was returned", true, nil) return } contentType := "application/x-ndjson" if format == "csv" { contentType = "text/csv; charset=utf-8" } if err := serveObjectSyncSpool(w, r, file, contentType, "drosync-audit."+format, hex.EncodeToString(hash.Sum(nil)), count); err != nil { // Content-Length lets clients detect an interrupted transfer. return } } func (server *server) handleObjectSyncReleaseManifest(w http.ResponseWriter, r *http.Request) { s, ok := server.objectSyncStore(w, r) if !ok { return } release, err := s.GetObjectSyncRelease(r.Context(), chi.URLParam(r, "id")) if err != nil { renderObjectSyncError(w, r, 503, "release_lookup_failed", "Could not read release", true, nil) return } if release == nil || release.OrganizationID != objectSyncManagementPrincipal(r).User.OrganizationID { renderObjectSyncError(w, r, 404, "release_not_found", "Release not found", false, nil) return } if release.Status != "published" || release.ManifestKey == "" || len(release.ManifestSHA256) != 64 { renderObjectSyncError(w, r, 409, "release_not_published", "Release has no verified published manifest", false, nil) return } free, ok := beginObjectSyncExport(w, r) if !ok { return } defer free() space, err := s.GetObjectSyncSpace(r.Context(), release.SyncSpaceID) if err != nil || space == nil { renderObjectSyncError(w, r, 503, "release_space_unavailable", "Release space unavailable", true, nil) return } ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute) defer cancel() browser, closeBrowser, err := server.objectSyncBrowser(ctx, space) if err != nil { renderObjectSyncError(w, r, 503, "manifest_unavailable", "Manifest storage unavailable", true, nil) return } defer closeBrowser() head, err := browser.GetObjectSummary(ctx, space.Bucket, release.ManifestKey) if err != nil || head.SizeBytes <= 0 { renderObjectSyncError(w, r, 503, "manifest_unavailable", "Manifest unavailable", true, nil) return } source, _, err := browser.ReadObjectRange(ctx, space.Bucket, release.ManifestKey, 0, head.SizeBytes-1) if err != nil { renderObjectSyncError(w, r, 503, "manifest_unavailable", "Manifest read failed", true, nil) return } defer source.Close() file, err := os.CreateTemp("", "drosync-manifest-*.tmp") if err != nil { renderObjectSyncError(w, r, 503, "manifest_unavailable", "Manifest spool unavailable", true, nil) return } defer os.Remove(file.Name()) defer file.Close() hash := sha256.New() n, err := io.Copy(io.MultiWriter(file, hash), io.LimitReader(source, head.SizeBytes+1)) digest := hex.EncodeToString(hash.Sum(nil)) if err != nil || n != head.SizeBytes || !strings.EqualFold(digest, release.ManifestSHA256) { renderObjectSyncError(w, r, 502, "manifest_integrity_failed", "Manifest is truncated or does not match the release SHA256", true, nil) return } _ = serveObjectSyncSpool(w, r, file, "application/x-ndjson", "drosync-release-"+release.ID+".ndjson", digest, release.ObjectCount) } func (server *server) handleExternalObjectSyncSessionsList(w http.ResponseWriter, r *http.Request) { target, ok := server.objectSyncStore(w, r) if !ok { return } principal, _ := currentObjectSyncCredential(r) query := domain.ObjectSyncListQuery{OrganizationID: principal.Credential.OrganizationID, CredentialID: principal.Credential.ID, DeviceID: principal.Device.ID, MappingID: r.URL.Query().Get("mappingId"), ActiveOnly: r.URL.Query().Get("activeOnly") == "true", Cursor: r.URL.Query().Get("cursor"), Limit: objectSyncQueryLimit(r)} if space := r.URL.Query().Get("syncSpaceId"); space != "" { query.SyncSpaceIDs = []string{space} } page, err := target.ListObjectSyncSessions(r.Context(), query) if err != nil { renderObjectSyncError(w, r, 503, "session_list_failed", "Could not discover owned sessions", true, nil) return } renderJSON(w, 200, page) }