droboticflow/internal/api/object_sync_workflows.go

374 lines
13 KiB
Go

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