forked from longtao.wu/droboticflow
374 lines
13 KiB
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)
|
|
}
|