droboticflow/internal/api/object_sync.go

3016 lines
126 KiB
Go

package api
import (
"bytes"
"context"
"crypto/sha256"
"crypto/subtle"
"encoding/base32"
"encoding/base64"
"encoding/csv"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"maps"
"net/http"
"net/url"
"path"
"sort"
"strconv"
"strings"
"time"
"droboticflow/internal/domain"
"droboticflow/internal/objectsync"
"droboticflow/internal/store"
"github.com/baidubce/bce-sdk-go/bce"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
)
const (
objectSyncCredentialHeader = "X-Drosync-Token"
objectSyncLeaseTTL = 5 * time.Minute
objectSyncSessionTTL = 7 * 24 * time.Hour
objectSyncRecordRetention = 90 * 24 * time.Hour
objectSyncVersionRetention = 365 * 24 * time.Hour
objectSyncIdempotencyTTL = 24 * time.Hour
objectSyncIdempotencyMax = 32 << 20
objectSyncMaxOrgDevices = 500
objectSyncReleaseSigned = "signed"
objectSyncReleasePreview = "preview"
)
// Keep this list in lockstep with drosync_platform::release_platform_key_for.
// S100 devices register as linux/arm64, so their preview artifact must be
// required and exposed alongside the existing desktop targets.
var objectSyncClientPlatforms = []string{"macos-arm64", "windows-x86_64", "linux-x86_64", "linux-arm64"}
func normalizedOrganizationID(value string) string {
if trimmed := strings.TrimSpace(value); trimmed != "" {
return trimmed
}
return domain.DefaultOrganizationID
}
type objectSyncCredentialContextKey struct{}
type objectSyncCredentialPrincipal struct {
Credential domain.ObjectSyncCredentialRecord
Device domain.ObjectSyncDeviceRecord
}
type objectSyncAPIError struct {
Code string `json:"code"`
Message string `json:"message"`
Retryable bool `json:"retryable"`
RequestID string `json:"requestId"`
Details map[string]any `json:"details,omitempty"`
}
func objectSyncRequestID(request *http.Request) string {
if value := strings.TrimSpace(middleware.GetReqID(request.Context())); value != "" {
return value
}
if value := strings.TrimSpace(request.Header.Get("X-Request-ID")); value != "" {
return value
}
return objectSyncNewID("req")
}
func objectSyncNewID(prefix string) string {
token, err := randomURLToken(12)
if err != nil {
sum := sha256.Sum256([]byte(fmt.Sprintf("%s:%d", prefix, time.Now().UnixNano())))
token = hex.EncodeToString(sum[:8])
}
return prefix + "_" + token
}
func renderObjectSyncError(writer http.ResponseWriter, request *http.Request, status int, code, message string, retryable bool, details map[string]any) {
renderJSON(writer, status, objectSyncAPIError{
Code: code,
Message: message,
Retryable: retryable,
RequestID: objectSyncRequestID(request),
Details: details,
})
}
func (server *server) objectSyncStore(writer http.ResponseWriter, request *http.Request) (store.ObjectSyncStore, bool) {
target, ok := store.AsObjectSyncStore(server.store)
if !ok {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "object_sync_store_unavailable", "Object sync storage is unavailable", true, nil)
return nil, false
}
return target, true
}
func (server *server) requireObjectSyncFeature(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if !server.objectSyncEnabled {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "object_sync_disabled", "Object sync is disabled by the server feature flag", false, nil)
return
}
next.ServeHTTP(writer, request)
})
}
func (server *server) objectSyncDistributedRateLimit(limit int64, window time.Duration) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if limit <= 0 || window <= 0 {
next.ServeHTTP(writer, request)
return
}
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
subject := "public:" + server.clientRateLimitKey(request, "drosync")
if principal, authenticated := currentObjectSyncCredential(request); authenticated {
subject = "credential:" + principal.Credential.OrganizationID + ":" + principal.Credential.ID
}
now := time.Now().UTC()
windowStart := now.Truncate(window)
windowEnd := windowStart.Add(window)
sum := sha256.Sum256([]byte(subject + "\x00" + windowStart.Format(time.RFC3339Nano)))
record, allowed, err := target.ConsumeObjectSyncRateLimit(request.Context(), domain.ObjectSyncRateLimitRecord{
ID: hex.EncodeToString(sum[:]),
Subject: subject,
Window: windowStart.Format(time.RFC3339Nano),
ExpiresAt: windowEnd.Add(window),
}, limit)
if err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "rate_limit_store_failed", "Distributed request limiting is temporarily unavailable", true, nil)
return
}
remaining := limit - record.Count
if remaining < 0 {
remaining = 0
}
retryAfter := int64(time.Until(windowEnd).Seconds())
if retryAfter < 1 {
retryAfter = 1
}
writer.Header().Set("RateLimit-Limit", strconv.FormatInt(limit, 10))
writer.Header().Set("RateLimit-Remaining", strconv.FormatInt(remaining, 10))
writer.Header().Set("RateLimit-Reset", strconv.FormatInt(windowEnd.Unix(), 10))
if !allowed {
writer.Header().Set("Retry-After", strconv.FormatInt(retryAfter, 10))
renderObjectSyncError(writer, request, http.StatusTooManyRequests, "rate_limited", "The drosync request limit for this credential or client has been exceeded", true, nil)
return
}
next.ServeHTTP(writer, request)
})
}
}
type objectSyncBufferedResponse struct {
header http.Header
status int
body bytes.Buffer
}
func (writer *objectSyncBufferedResponse) Header() http.Header {
return writer.header
}
func (writer *objectSyncBufferedResponse) WriteHeader(status int) {
if writer.status != 0 {
return
}
writer.status = status
}
func (writer *objectSyncBufferedResponse) Write(body []byte) (int, error) {
if writer.status == 0 {
writer.status = http.StatusOK
}
return writer.body.Write(body)
}
func objectSyncCopyResponse(writer http.ResponseWriter, header http.Header, status int, body []byte) {
for key, values := range header {
for _, value := range values {
writer.Header().Add(key, value)
}
}
if status == 0 {
status = http.StatusOK
}
writer.WriteHeader(status)
_, _ = writer.Write(body)
}
func objectSyncIdempotencySubject(request *http.Request) (string, string, string) {
if principal, ok := currentObjectSyncCredential(request); ok {
return principal.Credential.OrganizationID, principal.Device.ID, "device:" + principal.Credential.ID
}
if principal, ok := currentPrincipal(request); ok {
return principal.User.OrganizationID, principal.User.ID, "user:" + principal.User.ID
}
return "", "", "public"
}
func (server *server) requireObjectSyncIdempotency(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
switch request.Method {
case http.MethodGet, http.MethodHead, http.MethodOptions:
next.ServeHTTP(writer, request)
return
}
key := strings.TrimSpace(request.Header.Get("Idempotency-Key"))
if key == "" || len(key) > 128 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "idempotency_key_required", "Idempotency-Key is required and must be at most 128 characters", false, nil)
return
}
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
body, err := io.ReadAll(io.LimitReader(request.Body, objectSyncIdempotencyMax+1))
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "request_body_read_failed", err.Error(), false, nil)
return
}
if len(body) > objectSyncIdempotencyMax {
renderObjectSyncError(writer, request, http.StatusRequestEntityTooLarge, "request_body_too_large", "The request body exceeds the 32 MiB idempotency limit", false, nil)
return
}
request.Body = io.NopCloser(bytes.NewReader(body))
requestPath := request.URL.EscapedPath()
if request.URL.RawQuery != "" {
requestPath += "?" + request.URL.RawQuery
}
organizationID, actorID, subject := objectSyncIdempotencySubject(request)
requestSum := sha256.Sum256([]byte(request.Method + "\n" + requestPath + "\n" + request.Header.Get("Content-Type") + "\n" + string(body)))
requestDigest := hex.EncodeToString(requestSum[:])
recordSum := sha256.Sum256([]byte(subject + "\n" + request.Method + "\n" + requestPath + "\n" + key))
recordID := hex.EncodeToString(recordSum[:])
now := time.Now().UTC()
record := domain.ObjectSyncIdempotencyRecord{
ID: recordID,
OrganizationID: organizationID,
ActorID: actorID,
Key: key,
RequestMethod: request.Method,
RequestPath: requestPath,
RequestDigest: requestDigest,
State: "processing",
CreatedAt: now.Format(time.RFC3339Nano),
UpdatedAt: now.Format(time.RFC3339Nano),
ExpiresAt: now.Add(objectSyncIdempotencyTTL),
}
existing, created, err := target.BeginObjectSyncIdempotency(request.Context(), record)
if err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_store_failed", err.Error(), true, nil)
return
}
if !created && existing != nil && !existing.ExpiresAt.IsZero() && existing.ExpiresAt.Before(now) {
if err := target.DeleteObjectSyncIdempotency(request.Context(), existing.ID, existing.RequestDigest); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_store_failed", err.Error(), true, nil)
return
}
existing, created, err = target.BeginObjectSyncIdempotency(request.Context(), record)
if err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_store_failed", err.Error(), true, nil)
return
}
}
if !created {
if existing == nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_record_missing", "The idempotency record could not be loaded", true, nil)
return
}
if existing.RequestDigest != requestDigest {
renderObjectSyncError(writer, request, http.StatusConflict, "idempotency_key_reused", "The Idempotency-Key was already used with a different request", false, nil)
return
}
if existing.State != "completed" {
writer.Header().Set("Retry-After", "2")
renderObjectSyncError(writer, request, http.StatusConflict, "idempotency_request_in_progress", "A request with this Idempotency-Key is still being processed", true, nil)
return
}
replayHeader := make(http.Header, len(existing.ResponseHeader)+1)
for name, value := range existing.ResponseHeader {
replayHeader.Set(name, value)
}
replayHeader.Set("Idempotency-Replayed", "true")
objectSyncCopyResponse(writer, replayHeader, existing.ResponseStatus, existing.ResponseBody)
return
}
buffered := &objectSyncBufferedResponse{header: make(http.Header)}
next.ServeHTTP(buffered, request)
if buffered.status >= http.StatusInternalServerError {
_ = target.DeleteObjectSyncIdempotency(request.Context(), record.ID, record.RequestDigest)
objectSyncCopyResponse(writer, buffered.header, buffered.status, buffered.body.Bytes())
return
}
record.State = "completed"
record.ResponseStatus = buffered.status
record.ResponseHeader = make(map[string]string, len(buffered.header))
for name, values := range buffered.header {
record.ResponseHeader[name] = strings.Join(values, ", ")
}
record.ResponseBody = append([]byte(nil), buffered.body.Bytes()...)
record.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
if err := target.CompleteObjectSyncIdempotency(request.Context(), record); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "idempotency_commit_failed", "The operation completed but its replay record could not be committed; query operation status before retrying", true, nil)
return
}
objectSyncCopyResponse(writer, buffered.header, buffered.status, buffered.body.Bytes())
})
}
func objectSyncBearerToken(request *http.Request) string {
if value := strings.TrimSpace(request.Header.Get(objectSyncCredentialHeader)); value != "" {
return value
}
value := strings.TrimSpace(request.Header.Get("Authorization"))
if len(value) > 7 && strings.EqualFold(value[:7], "Bearer ") {
return strings.TrimSpace(value[7:])
}
return ""
}
func (server *server) objectSyncCredentialAuth(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
token := objectSyncBearerToken(request)
if token == "" {
renderObjectSyncError(writer, request, http.StatusUnauthorized, "credential_required", "A drosync device credential is required", false, nil)
return
}
hash := sessionTokenHash(token)
credential, err := target.GetObjectSyncCredentialByTokenHash(request.Context(), hash)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_lookup_failed", err.Error(), true, nil)
return
}
if credential == nil || !credential.Enabled || !objectSyncCredentialTokenMatches(*credential, hash) {
renderObjectSyncError(writer, request, http.StatusUnauthorized, "credential_invalid", "The drosync device credential is invalid or revoked", false, nil)
return
}
deviceID := objectSyncCredentialDeviceIDForToken(*credential, hash)
device, err := target.GetObjectSyncDevice(request.Context(), deviceID)
if err != nil || device == nil || device.Status != "active" {
renderObjectSyncError(writer, request, http.StatusUnauthorized, "device_inactive", "The drosync device is not active", false, nil)
return
}
now := nowISO()
credential.LastUsedAt = now
credential.UpdatedAt = now
device.LastSeenAt = now
device.UpdatedAt = now
_ = target.UpsertObjectSyncCredential(request.Context(), *credential)
_ = target.UpsertObjectSyncDevice(request.Context(), *device)
ctx := context.WithValue(request.Context(), objectSyncCredentialContextKey{}, &objectSyncCredentialPrincipal{
Credential: *credential,
Device: *device,
})
next.ServeHTTP(writer, request.WithContext(ctx))
})
}
func objectSyncCredentialTokenMatches(credential domain.ObjectSyncCredentialRecord, hash string) bool {
if credential.TokenHash != "" && subtle.ConstantTimeCompare([]byte(credential.TokenHash), []byte(hash)) == 1 {
return true
}
for _, candidate := range credential.TokenHashes {
if subtle.ConstantTimeCompare([]byte(candidate), []byte(hash)) == 1 {
return true
}
}
for _, binding := range credential.TokenBindings {
if subtle.ConstantTimeCompare([]byte(binding.TokenHash), []byte(hash)) == 1 {
return true
}
}
return false
}
func objectSyncCredentialDeviceIDForToken(credential domain.ObjectSyncCredentialRecord, hash string) string {
for _, binding := range credential.TokenBindings {
if subtle.ConstantTimeCompare([]byte(binding.TokenHash), []byte(hash)) == 1 {
return binding.DeviceID
}
}
return credential.DeviceID
}
func currentObjectSyncCredential(request *http.Request) (*objectSyncCredentialPrincipal, bool) {
value, ok := request.Context().Value(objectSyncCredentialContextKey{}).(*objectSyncCredentialPrincipal)
return value, ok && value != nil
}
func objectSyncManagementPrincipal(request *http.Request) *authenticatedPrincipal {
if principal, ok := currentPrincipal(request); ok {
return principal
}
return &authenticatedPrincipal{
User: domain.UserRecord{
ID: "legacy-admin",
OrganizationID: domain.DefaultOrganizationID,
Role: domain.UserRoleAdmin,
},
}
}
func objectSyncCredentialScopeFor(credential domain.ObjectSyncCredentialRecord, syncSpaceID string) (*domain.ObjectSyncCredentialScope, bool) {
for index := range credential.Scopes {
if credential.Scopes[index].SyncSpaceID == syncSpaceID {
return &credential.Scopes[index], true
}
}
return nil, false
}
func objectSyncScopeAllows(scope domain.ObjectSyncCredentialScope, action, relativePath string) bool {
if !objectSyncScopeAllowsAction(scope, action) {
return false
}
if len(scope.AllowedRelativePrefixes) == 0 {
return true
}
for _, prefix := range scope.AllowedRelativePrefixes {
normalized := strings.Trim(strings.ReplaceAll(strings.TrimSpace(prefix), "\\", "/"), "/")
if normalized == "" || relativePath == normalized || strings.HasPrefix(relativePath, normalized+"/") {
return true
}
}
return false
}
func objectSyncScopeAllowsAction(scope domain.ObjectSyncCredentialScope, action string) bool {
for _, candidate := range scope.Actions {
if candidate == action || candidate == "*" {
return true
}
}
return false
}
func normalizeObjectSyncRelativePath(value string) (string, error) {
value = strings.TrimSpace(strings.ReplaceAll(value, "\\", "/"))
if value == "" || strings.HasPrefix(value, "/") || strings.ContainsRune(value, '\x00') {
return "", fmt.Errorf("relativePath must be a non-empty relative path")
}
for _, part := range strings.Split(value, "/") {
if part == "" || part == "." || part == ".." {
return "", fmt.Errorf("relativePath contains an invalid path segment")
}
for _, character := range part {
if character < 0x20 || character == 0x7f {
return "", fmt.Errorf("relativePath contains control characters")
}
}
}
if len([]byte(value)) > objectStorageKeyMaxUTF8Bytes {
return "", fmt.Errorf("relativePath exceeds the BOS key size limit")
}
return value, nil
}
func objectSyncTargetKey(space domain.ObjectSyncSpaceRecord, relativePath string) string {
root := strings.Trim(strings.TrimSpace(space.RootPrefix), "/")
if root == "" {
return relativePath
}
return root + "/" + relativePath
}
func objectSyncMetadataValue(metadata map[string]any, key string) string {
for candidate, value := range metadata {
if strings.EqualFold(strings.TrimSpace(candidate), key) {
return strings.TrimSpace(fmt.Sprint(value))
}
}
return ""
}
func objectSyncStagingMatches(result domain.ObjectStorageObjectSummary, item *domain.ObjectSyncItemRecord, session *domain.ObjectSyncSessionRecord) bool {
return strings.TrimSpace(result.ETag) != "" &&
objectSyncMetadataValue(result.Metadata, "drosync-session") == session.ID &&
objectSyncMetadataValue(result.Metadata, "drosync-item") == item.ID &&
objectSyncMetadataValue(result.Metadata, "drosync-sha256") == item.SHA256
}
func sanitizeObjectSyncCredential(item domain.ObjectSyncCredentialRecord) domain.ObjectSyncCredentialRecord {
item.SecretHash = ""
item.TokenHash = ""
item.TokenHashes = nil
item.TokenBindings = nil
return item
}
func (server *server) appendObjectSyncAudit(ctx context.Context, target store.ObjectSyncStore, event domain.ObjectSyncAuditEvent) error {
return objectsync.AppendAudit(ctx, target, event)
}
func (server *server) requireObjectSyncAudit(writer http.ResponseWriter, request *http.Request, target store.ObjectSyncStore, event domain.ObjectSyncAuditEvent) bool {
if err := server.appendObjectSyncAudit(request.Context(), target, event); err != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "audit_persist_failed", "The state change completed but its audit event could not be persisted; query current state before retrying", true, map[string]any{"cause": err.Error()})
return false
}
return true
}
func (server *server) objectSyncBrowser(ctx context.Context, space *domain.ObjectSyncSpaceRecord) (objectSyncStorageBrowser, func(), error) {
connection, err := server.store.GetStorageConnection(ctx, space.ConnectionID)
if err != nil {
return nil, nil, err
}
if connection == nil || normalizedOrganizationID(connection.OrganizationID) != normalizedOrganizationID(space.OrganizationID) {
return nil, nil, fmt.Errorf("storage connection not found in the sync space organization")
}
browser, closeBrowser, err := storageConnectionBrowserResolver(ctx, server.storageConnectionWithResolvedEndpoint(connection))
if err != nil {
return nil, nil, err
}
target, ok := browser.(objectSyncStorageBrowser)
if !ok {
if closeBrowser != nil {
closeBrowser()
}
return nil, nil, fmt.Errorf("storage provider does not implement conditional object sync operations")
}
return target, closeBrowser, nil
}
func isObjectSyncPreconditionFailure(err error) bool {
if err == nil {
return false
}
var serviceError *bce.BceServiceError
return errors.As(err, &serviceError) && serviceError.StatusCode == http.StatusPreconditionFailed
}
func (server *server) handleObjectSyncSpacesList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
items, err := target.ListObjectSyncSpaces(request.Context(), principal.User.OrganizationID)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "spaces_list_failed", err.Error(), true, nil)
return
}
if principal.User.Role == domain.UserRoleDataOperator {
filtered := items[:0]
for _, item := range items {
if objectSyncSpaceAllowsUser(item, principal.User) {
filtered = append(filtered, item)
}
}
items = filtered
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func objectSyncSpaceAllowsUser(space domain.ObjectSyncSpaceRecord, user domain.UserRecord) bool {
if user.Role != domain.UserRoleDataOperator {
return true
}
for _, userID := range space.OperatorUserIDs {
if userID == user.ID {
return true
}
}
return false
}
func (server *server) normalizeObjectSyncOperatorUserIDs(ctx context.Context, organizationID string, values []string) ([]string, error) {
seen := make(map[string]struct{}, len(values))
result := make([]string, 0, len(values))
for _, value := range values {
userID := strings.TrimSpace(value)
if userID == "" {
continue
}
if _, exists := seen[userID]; exists {
continue
}
user, err := server.store.GetUser(ctx, userID)
if err != nil {
return nil, err
}
if user == nil || normalizedOrganizationID(user.OrganizationID) != normalizedOrganizationID(organizationID) || user.Role != domain.UserRoleDataOperator {
return nil, fmt.Errorf("operatorUserIds must refer to data_operator users in this organization")
}
seen[userID] = struct{}{}
result = append(result, userID)
}
return result, nil
}
func (server *server) handleObjectSyncSpaceCreate(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
var input struct {
Name string `json:"name"`
Description string `json:"description"`
ConnectionID string `json:"connectionId"`
Bucket string `json:"bucket"`
RootPrefix string `json:"rootPrefix"`
OperatorUserIDs []string `json:"operatorUserIds"`
Policy *domain.ObjectSyncSpacePolicy `json:"policy"`
}
if !decodeJSON(writer, request, &input) {
return
}
input.Name = strings.TrimSpace(input.Name)
input.ConnectionID = strings.TrimSpace(input.ConnectionID)
input.Bucket = strings.TrimSpace(input.Bucket)
if input.Name == "" || input.ConnectionID == "" || input.Bucket == "" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_space", "name, connectionId and bucket are required", false, nil)
return
}
operatorUserIDs, err := server.normalizeObjectSyncOperatorUserIDs(request.Context(), principal.User.OrganizationID, input.OperatorUserIDs)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_operator_assignment", err.Error(), false, nil)
return
}
connection, err := server.store.GetStorageConnection(request.Context(), input.ConnectionID)
if err != nil || connection == nil || normalizedOrganizationID(connection.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID) {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_storage_connection", "The storage connection is not available in this organization", false, nil)
return
}
policy := domain.DefaultObjectSyncSpacePolicy()
if input.Policy != nil {
policy = *input.Policy
}
policy.AllowDelete = false
policy.DefaultConflictResolution = "keep_both"
now := nowISO()
item := domain.ObjectSyncSpaceRecord{
ID: objectSyncNewID("oss"),
OrganizationID: principal.User.OrganizationID,
OperatorUserIDs: operatorUserIDs,
Name: input.Name,
Description: strings.TrimSpace(input.Description),
ConnectionID: input.ConnectionID,
Bucket: input.Bucket,
RootPrefix: strings.Trim(strings.TrimSpace(input.RootPrefix), "/"),
Mode: "blocked",
Enabled: false,
Policy: policy,
Capability: domain.ObjectSyncCapabilityRecord{
State: domain.ObjectSyncCapabilityUnverified,
},
CreatedBy: principal.User.ID,
UpdatedBy: principal.User.ID,
CreatedAt: now,
UpdatedAt: now,
}
if err := target.UpsertObjectSyncSpace(request.Context(), item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_create_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: item.OrganizationID,
ActorType: "user",
ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request),
Action: "space.create",
Target: map[string]any{"spaceId": item.ID},
Result: "success",
}) {
return
}
renderJSON(writer, http.StatusCreated, item)
}
func (server *server) handleObjectSyncSpaceUpdate(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
item, err := target.GetObjectSyncSpace(request.Context(), chi.URLParam(request, "id"))
if err != nil || item == nil || !server.ensureTenantAccess(writer, request, objectSyncOrganization(item.OrganizationID), "Object sync space") {
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_lookup_failed", err.Error(), true, nil)
}
return
}
var input struct {
Name *string `json:"name"`
Description *string `json:"description"`
Enabled *bool `json:"enabled"`
ExclusivePrefixConfirmed *bool `json:"exclusivePrefixConfirmed"`
AllowForceOverwrite *bool `json:"allowForceOverwrite"`
OperatorUserIDs *[]string `json:"operatorUserIds"`
}
if !decodeJSON(writer, request, &input) {
return
}
wasDrifted := item.Capability.State == domain.ObjectSyncCapabilityDrifted
if input.Name != nil && strings.TrimSpace(*input.Name) != "" {
item.Name = strings.TrimSpace(*input.Name)
}
if input.Description != nil {
item.Description = strings.TrimSpace(*input.Description)
}
if input.OperatorUserIDs != nil {
operatorUserIDs, normalizeErr := server.normalizeObjectSyncOperatorUserIDs(request.Context(), principal.User.OrganizationID, *input.OperatorUserIDs)
if normalizeErr != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_operator_assignment", normalizeErr.Error(), false, nil)
return
}
item.OperatorUserIDs = operatorUserIDs
}
if input.ExclusivePrefixConfirmed != nil {
item.Capability.ExclusivePrefixConfirmed = *input.ExclusivePrefixConfirmed
}
prospectiveState := item.Capability.State
if !wasDrifted {
prospectiveState = domain.ObjectSyncCapabilityUnsupported
if item.Capability.ConditionalCreate {
prospectiveState = domain.ObjectSyncCapabilityCreateOnly
}
if item.Capability.ConditionalCreate &&
item.Capability.ConditionalUpdate &&
item.Capability.ConditionalMultipart &&
item.Capability.ExclusivePrefixConfirmed {
prospectiveState = domain.ObjectSyncCapabilityUpdateEnabled
}
}
if input.AllowForceOverwrite != nil {
if *input.AllowForceOverwrite && prospectiveState != domain.ObjectSyncCapabilityUpdateEnabled {
renderObjectSyncError(writer, request, http.StatusConflict, "force_overwrite_gate_failed", "Force overwrite requires update-enabled capability and exclusive prefix confirmation", false, map[string]any{"state": item.Capability.State})
return
}
item.Policy.AllowForceOverwrite = *input.AllowForceOverwrite
}
if input.Enabled != nil {
if *input.Enabled && prospectiveState != domain.ObjectSyncCapabilityCreateOnly && prospectiveState != domain.ObjectSyncCapabilityUpdateEnabled {
renderObjectSyncError(writer, request, http.StatusConflict, "capability_gate_failed", "The space cannot be enabled before a successful conditional-create probe", false, map[string]any{"state": item.Capability.State})
return
}
item.Enabled = *input.Enabled
}
item.Capability.State = prospectiveState
item.Mode = "blocked"
item.Policy.AllowConditionalUpdate = prospectiveState == domain.ObjectSyncCapabilityUpdateEnabled
if prospectiveState == domain.ObjectSyncCapabilityCreateOnly {
item.Mode = "create_only"
}
if prospectiveState == domain.ObjectSyncCapabilityUpdateEnabled {
item.Mode = "update_enabled"
}
if prospectiveState != domain.ObjectSyncCapabilityUpdateEnabled {
item.Policy.AllowForceOverwrite = false
}
if wasDrifted {
item.Enabled = false
}
item.UpdatedBy = principal.User.ID
item.UpdatedAt = nowISO()
if err := target.UpsertObjectSyncSpace(request.Context(), *item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_update_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: item.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request), Action: "space.update",
Target: map[string]any{"spaceId": item.ID}, Result: "success",
}) {
return
}
renderJSON(writer, http.StatusOK, item)
}
func objectSyncOrganization(value string) string {
return normalizedOrganizationID(value)
}
func (server *server) handleObjectSyncCapabilityProbe(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
space, err := target.GetObjectSyncSpace(request.Context(), chi.URLParam(request, "id"))
if err != nil || space == nil || normalizedOrganizationID(space.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID) {
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Object sync space not found", false, nil)
return
}
wasDrifted := space.Capability.State == domain.ObjectSyncCapabilityDrifted
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "capability_probe_failed", err.Error(), true, nil)
return
}
defer closeBrowser()
probeID := objectSyncNewID("probe")
probePrefix := strings.Trim(strings.TrimSpace(space.RootPrefix), "/")
if probePrefix != "" {
probePrefix += "/"
}
createKey := probePrefix + ".drosync-probe/" + probeID + "/conditional"
copySourceKey := probePrefix + ".drosync-probe/" + probeID + "/copy-source"
copyTargetKey := probePrefix + ".drosync-probe/" + probeID + "/copy-target"
defer func() {
_ = browser.DeleteObject(context.Background(), space.Bucket, createKey)
_ = browser.DeleteObject(context.Background(), space.Bucket, copySourceKey)
_ = browser.DeleteObject(context.Background(), space.Bucket, copyTargetKey)
}()
capability := domain.ObjectSyncCapabilityRecord{State: domain.ObjectSyncCapabilityUnsupported, ProbedAt: nowISO()}
created, err := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("drosync-probe-v1"), "application/octet-stream", "", "*", map[string]string{"drosync-probe": probeID})
if err == nil {
_, repeatErr := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("must-not-overwrite"), "application/octet-stream", "", "*", nil)
capability.ConditionalCreate = isObjectSyncPreconditionFailure(repeatErr)
}
if err == nil && capability.ConditionalCreate {
updated, updateErr := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("drosync-probe-v2"), "application/octet-stream", created.ETag, "", nil)
if updateErr == nil {
_, staleErr := browser.PutObjectConditional(request.Context(), space.Bucket, createKey, []byte("must-not-overwrite"), "application/octet-stream", created.ETag, "", nil)
capability.ConditionalUpdate = isObjectSyncPreconditionFailure(staleErr)
capability.VersionID = strings.TrimSpace(updated.VersionID) != ""
}
_, sourceErr := browser.PutObject(request.Context(), space.Bucket, copySourceKey, []byte("multipart-copy-probe"), "application/octet-stream")
if sourceErr == nil {
published, publishErr := browser.PublishMultipartCopyConditional(request.Context(), space.Bucket, copySourceKey, copyTargetKey, int64(len("multipart-copy-probe")), "", "", "*", map[string]string{"drosync-probe": probeID})
capability.MultipartCopy = publishErr == nil
if publishErr == nil {
_, repeatPublishErr := browser.PublishMultipartCopyConditional(request.Context(), space.Bucket, copySourceKey, copyTargetKey, int64(len("multipart-copy-probe")), "", "", "*", nil)
capability.ConditionalMultipart = isObjectSyncPreconditionFailure(repeatPublishErr)
capability.VersionID = capability.VersionID || strings.TrimSpace(published.VersionID) != ""
}
}
}
if versioning, versionErr := browser.GetBucketVersioning(request.Context(), space.Bucket); versionErr == nil && strings.EqualFold(versioning, "enabled") {
capability.VersionID = true
}
if err != nil {
capability.ProbeError = err.Error()
} else if !capability.ConditionalCreate {
capability.ProbeError = "If-None-Match: * did not reject a duplicate create"
}
capability.ExclusivePrefixConfirmed = space.Capability.ExclusivePrefixConfirmed
if capability.ConditionalCreate {
capability.State = domain.ObjectSyncCapabilityCreateOnly
}
if capability.ConditionalCreate && capability.ConditionalUpdate && capability.ConditionalMultipart && capability.ExclusivePrefixConfirmed {
capability.State = domain.ObjectSyncCapabilityUpdateEnabled
}
if wasDrifted {
capability.State = domain.ObjectSyncCapabilityDrifted
}
space.Capability = capability
space.Mode = "blocked"
space.Enabled = false
if capability.State == domain.ObjectSyncCapabilityCreateOnly {
space.Mode = "create_only"
}
if capability.State == domain.ObjectSyncCapabilityUpdateEnabled {
space.Mode = "update_enabled"
}
space.Policy.AllowConditionalUpdate = capability.State == domain.ObjectSyncCapabilityUpdateEnabled
if capability.State != domain.ObjectSyncCapabilityUpdateEnabled {
space.Policy.AllowForceOverwrite = false
}
space.UpdatedBy = principal.User.ID
space.UpdatedAt = nowISO()
if err := target.UpsertObjectSyncSpace(request.Context(), *space); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "capability_save_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: space.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request), Action: "space.capability_probe",
Target: map[string]any{"spaceId": space.ID}, After: map[string]any{"capability": capability},
Result: "success",
}) {
return
}
renderJSON(writer, http.StatusOK, space)
}
func (server *server) handleObjectSyncReconcileCreate(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
space, err := target.GetObjectSyncSpace(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "space_lookup_failed", err.Error(), true, nil)
return
}
if space == nil || space.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Object sync space not found", false, nil)
return
}
now := nowISO()
item := domain.ObjectSyncReconcileRecord{
ID: objectSyncNewID("osrec"),
OperationID: objectSyncNewID("op"),
OrganizationID: space.OrganizationID,
SyncSpaceID: space.ID,
Status: "pending",
CreatedBy: principal.User.ID,
CreatedAt: now,
UpdatedAt: now,
}
if err := target.UpsertObjectSyncReconcile(request.Context(), item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "reconcile_enqueue_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: space.OrganizationID,
ActorType: "user",
ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request),
Action: "space.reconcile",
Target: map[string]any{"spaceId": space.ID, "operationId": item.OperationID},
Result: "accepted",
}) {
return
}
renderJSON(writer, http.StatusAccepted, item)
}
func (server *server) handleObjectSyncDevicesList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
items, err := target.ListObjectSyncDevices(request.Context(), principal.User.OrganizationID)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "devices_list_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleObjectSyncAuthorizationsList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
items, err := target.ListObjectSyncAuthorizations(request.Context(), principal.User.OrganizationID, strings.TrimSpace(request.URL.Query().Get("status")))
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "authorizations_list_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func normalizeObjectSyncUserCode(value string) string {
return strings.ToUpper(strings.NewReplacer("-", "", " ", "").Replace(strings.TrimSpace(value)))
}
func (server *server) handleObjectSyncAuthorizationLookup(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
code := normalizeObjectSyncUserCode(request.URL.Query().Get("userCode"))
if len(code) < 6 || len(code) > 16 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_user_code", "userCode must contain 6 to 16 base32 characters", false, nil)
return
}
item, err := target.GetObjectSyncAuthorizationByUserCode(request.Context(), code)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "authorization_lookup_failed", err.Error(), true, nil)
return
}
if item == nil ||
(item.OrganizationID != "" && normalizedOrganizationID(item.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID)) {
renderObjectSyncError(writer, request, http.StatusNotFound, "authorization_not_found", "Pairing request not found", false, nil)
return
}
if item.Status != "pending" {
renderObjectSyncError(writer, request, http.StatusConflict, "authorization_not_pending", "Pairing request is no longer pending", false, map[string]any{"status": item.Status})
return
}
if time.Now().UTC().After(item.ExpiresAtTime) {
renderObjectSyncError(writer, request, http.StatusGone, "device_code_expired", "Pairing request expired", false, nil)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleObjectSyncAuthorizationDecision(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
item, err := target.GetObjectSyncAuthorization(request.Context(), chi.URLParam(request, "id"))
if err != nil ||
item == nil ||
item.Status != "pending" ||
(item.OrganizationID != "" && normalizedOrganizationID(item.OrganizationID) != normalizedOrganizationID(principal.User.OrganizationID)) {
renderObjectSyncError(writer, request, http.StatusNotFound, "authorization_not_pending", "Pending device authorization not found", false, nil)
return
}
if time.Now().UTC().After(item.ExpiresAtTime) {
renderObjectSyncError(writer, request, http.StatusGone, "device_code_expired", "Pairing request expired", false, nil)
return
}
var input struct {
Scopes []domain.ObjectSyncCredentialScope `json:"scopes"`
}
if !decodeJSON(writer, request, &input) {
return
}
decision := chi.URLParam(request, "decision")
if decision != "approve" && decision != "deny" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_decision", "Decision must be approve or deny", false, nil)
return
}
if decision == "approve" {
if len(input.Scopes) == 0 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "scopes_required", "At least one approved sync space scope is required", false, nil)
return
}
for _, scope := range input.Scopes {
space, lookupErr := target.GetObjectSyncSpace(request.Context(), scope.SyncSpaceID)
if lookupErr != nil || space == nil || space.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_scope", "An approved scope refers to an unavailable sync space", false, map[string]any{"syncSpaceId": scope.SyncSpaceID})
return
}
}
quotaSum := sha256.Sum256([]byte("device-quota\x00" + principal.User.OrganizationID))
quotaHash := hex.EncodeToString(quotaSum[:])
quotaOwner := objectSyncRequestID(request)
quotaLease, acquired, quotaErr := target.AcquireObjectSyncLease(request.Context(), domain.ObjectSyncLeaseRecord{
OrganizationID: principal.User.OrganizationID,
ResourceHash: quotaHash,
ResourceType: "device_quota",
KeyOrPrefix: principal.User.OrganizationID,
OwnerSessionID: quotaOwner,
OwnerItemID: item.ID,
}, 30*time.Second)
if quotaErr != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "device_quota_unavailable", quotaErr.Error(), true, nil)
return
}
if !acquired {
renderObjectSyncError(writer, request, http.StatusConflict, "device_quota_busy", "Another device approval is being processed; retry this request", true, nil)
return
}
defer func() {
_ = target.ReleaseObjectSyncLease(context.Background(), quotaHash, quotaOwner, item.ID, quotaLease.FencingToken)
}()
existingDevice, lookupErr := target.GetObjectSyncDevice(request.Context(), item.DeviceID)
if lookupErr != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_lookup_failed", lookupErr.Error(), true, nil)
return
}
if existingDevice == nil {
devices, devicesErr := target.ListObjectSyncDevices(request.Context(), principal.User.OrganizationID)
approved, approvedErr := target.ListObjectSyncAuthorizations(request.Context(), principal.User.OrganizationID, "approved")
if devicesErr != nil || approvedErr != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_quota_check_failed", "Could not verify the organization device quota", true, nil)
return
}
distinctDevices := make(map[string]struct{}, len(devices)+len(approved))
for _, device := range devices {
distinctDevices[device.ID] = struct{}{}
}
for _, authorization := range approved {
distinctDevices[authorization.DeviceID] = struct{}{}
}
if _, alreadyCounted := distinctDevices[item.DeviceID]; !alreadyCounted && len(distinctDevices) >= objectSyncMaxOrgDevices {
renderObjectSyncError(writer, request, http.StatusConflict, "device_quota_exceeded", "The organization has reached its 500-device limit", false, map[string]any{"limit": objectSyncMaxOrgDevices})
return
}
}
item.Status = "approved"
item.OrganizationID = principal.User.OrganizationID
item.Scopes = input.Scopes
item.ApprovedBy = principal.User.ID
} else {
item.Status = "denied"
item.OrganizationID = principal.User.OrganizationID
item.ApprovedBy = principal.User.ID
}
item.UpdatedAt = nowISO()
if err := target.UpsertObjectSyncAuthorization(request.Context(), *item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "authorization_update_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: principal.User.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request), Action: "device_authorization." + decision,
Target: map[string]any{"authorizationId": item.ID, "deviceId": item.DeviceID}, Result: "success",
}) {
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleObjectSyncCredentialsList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
items, err := target.ListObjectSyncCredentials(request.Context(), principal.User.OrganizationID)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credentials_list_failed", err.Error(), true, nil)
return
}
for index := range items {
items[index] = sanitizeObjectSyncCredential(items[index])
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleObjectSyncCredentialMutation(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
item, err := target.GetObjectSyncCredential(request.Context(), chi.URLParam(request, "id"))
if err != nil || item == nil || item.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "credential_not_found", "Device credential not found", false, nil)
return
}
action := chi.URLParam(request, "action")
now := nowISO()
response := map[string]any{}
if action == "revoke" {
item.Enabled = false
item.RevokedAt = now
} else if action == "rotate" {
secretToken, secretErr := randomURLToken(32)
if secretErr != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_rotate_failed", secretErr.Error(), true, nil)
return
}
secret := "dss_" + secretToken
secretHash, hashErr := hashObjectSyncSecret(secret)
if hashErr != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_rotate_failed", hashErr.Error(), true, nil)
return
}
placeholder, placeholderErr := randomURLToken(32)
if placeholderErr != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_rotate_failed", placeholderErr.Error(), true, nil)
return
}
if item.AccessKeyID == "" {
item.AccessKeyID = objectSyncNewID("dsk")
}
item.SecretHash = secretHash
item.SecretPreview = objectSyncSecretPreview(secret)
item.TokenHash = sessionTokenHash(placeholder)
item.TokenHashes = nil
item.TokenBindings = nil
item.TokenPreview = item.SecretPreview
item.Enabled = true
item.RevokedAt = ""
response["secret"] = secret
} else {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_credential_action", "Action must be rotate or revoke", false, nil)
return
}
item.UpdatedAt = now
if err := target.UpsertObjectSyncCredential(request.Context(), *item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_update_failed", err.Error(), true, nil)
return
}
response["credential"] = sanitizeObjectSyncCredential(*item)
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: item.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request), Action: "credential." + action,
Target: map[string]any{"credentialId": item.ID, "deviceId": item.DeviceID}, Result: "success",
}) {
return
}
renderJSON(writer, http.StatusOK, response)
}
func (server *server) handleObjectSyncSessionsList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
syncSpaceIDs := []string(nil)
if principal.User.Role == domain.UserRoleDataOperator {
spaces, listErr := target.ListObjectSyncSpaces(request.Context(), principal.User.OrganizationID)
if listErr != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "spaces_list_failed", listErr.Error(), true, nil)
return
}
for _, space := range spaces {
if objectSyncSpaceAllowsUser(space, principal.User) {
syncSpaceIDs = append(syncSpaceIDs, space.ID)
}
}
if len(syncSpaceIDs) == 0 {
renderJSON(writer, http.StatusOK, domain.ObjectSyncSessionPage{Items: []domain.ObjectSyncSessionRecord{}})
return
}
}
page, err := target.ListObjectSyncSessions(request.Context(), domain.ObjectSyncListQuery{
OrganizationID: principal.User.OrganizationID,
SyncSpaceIDs: syncSpaceIDs,
Status: strings.TrimSpace(request.URL.Query().Get("status")),
Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
Limit: objectSyncQueryLimit(request),
})
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "sessions_list_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, page)
}
func objectSyncQueryLimit(request *http.Request) int {
value, _ := strconv.Atoi(strings.TrimSpace(request.URL.Query().Get("limit")))
if value <= 0 {
return 100
}
if value > 1000 {
return 1000
}
return value
}
func (server *server) handleObjectSyncSessionGet(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
item, err := target.GetObjectSyncSession(request.Context(), chi.URLParam(request, "id"))
if err != nil || item == nil {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
return
}
if principal, signedIn := currentPrincipal(request); signedIn && item.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
return
}
if principal, signedIn := currentPrincipal(request); signedIn && principal.User.Role == domain.UserRoleDataOperator {
space, lookupErr := target.GetObjectSyncSpace(request.Context(), item.SyncSpaceID)
if lookupErr != nil || space == nil || !objectSyncSpaceAllowsUser(*space, principal.User) {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
return
}
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleObjectSyncSessionItems(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
session, err := target.GetObjectSyncSession(request.Context(), chi.URLParam(request, "id"))
if err != nil || session == nil {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
return
}
if principal, signedIn := currentPrincipal(request); signedIn && session.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
return
}
if principal, signedIn := currentPrincipal(request); signedIn && principal.User.Role == domain.UserRoleDataOperator {
space, lookupErr := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
if lookupErr != nil || space == nil || !objectSyncSpaceAllowsUser(*space, principal.User) {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
return
}
}
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{
SessionID: session.ID,
Status: strings.TrimSpace(request.URL.Query().Get("status")),
Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
Limit: objectSyncQueryLimit(request),
})
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "items_list_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, page)
}
func (server *server) handleObjectSyncSessionAdminAbort(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
item, err := target.GetObjectSyncSession(request.Context(), chi.URLParam(request, "id"))
if err != nil || item == nil || item.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found", false, nil)
return
}
item.Status = domain.ObjectSyncSessionAborted
item.UpdatedAt = nowISO()
item.CompletedAt = item.UpdatedAt
if err := target.UpsertObjectSyncSession(request.Context(), *item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_abort_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleObjectSyncLeaseForceRelease(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
item, changed, err := target.ForceReleaseObjectSyncLease(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "lease_release_failed", err.Error(), true, nil)
return
}
if item == nil || item.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "lease_not_found", "Lease not found", false, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: item.OrganizationID, ActorType: "user", ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request), Action: "lease.force_release",
Target: map[string]any{"leaseId": item.ID, "key": item.KeyOrPrefix}, Result: "success",
}) {
return
}
renderJSON(writer, http.StatusOK, map[string]any{"lease": item, "released": changed})
}
func (server *server) handleObjectSyncItemForceOverwrite(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
conflict, err := target.GetObjectSyncItem(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "item_lookup_failed", err.Error(), true, nil)
return
}
if conflict == nil || conflict.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "conflict_not_found", "Keep-both conflict item not found", false, nil)
return
}
if conflict.Status != domain.ObjectSyncItemKeptBoth || conflict.LogicalTargetKey == "" || conflict.TargetKey == conflict.LogicalTargetKey {
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_conflicted", "Only a keep-both item with a preserved conflict object can be force-overwritten", false, nil)
return
}
session, err := target.GetObjectSyncSession(request.Context(), conflict.SessionID)
if err != nil || session == nil || session.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Conflict session not found", false, nil)
return
}
space, err := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
if err != nil || space == nil || space.OrganizationID != principal.User.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Conflict sync space not found", false, nil)
return
}
if space.Capability.State != domain.ObjectSyncCapabilityUpdateEnabled ||
!space.Capability.ExclusivePrefixConfirmed ||
!space.Policy.AllowConditionalUpdate ||
!space.Policy.AllowForceOverwrite {
renderObjectSyncError(writer, request, http.StatusForbidden, "force_overwrite_disabled", "Force overwrite is disabled or the update/exclusive-prefix gate is not satisfied", false, nil)
return
}
now := nowISO()
purgeAt := conflict.PurgeAt
if purgeAt.IsZero() {
purgeAt = time.Now().UTC().Add(90 * 24 * time.Hour)
}
forceItem := domain.ObjectSyncItemRecord{
ID: objectSyncNewID("osi"),
OrganizationID: conflict.OrganizationID,
SessionID: conflict.SessionID,
ClientItemID: conflict.ClientItemID + ":force:" + objectSyncNewID("op"),
ManifestPage: conflict.ManifestPage,
RelativePath: conflict.RelativePath,
NormalizedRelativePath: conflict.NormalizedRelativePath,
TargetKey: conflict.LogicalTargetKey,
LogicalTargetKey: conflict.LogicalTargetKey,
SizeBytes: conflict.SizeBytes,
ModifiedAt: conflict.ModifiedAt,
SHA256: conflict.SHA256,
ContentType: conflict.ContentType,
Action: "force_overwrite",
Status: domain.ObjectSyncItemCommitting,
ForceSourceKey: conflict.TargetKey,
ForceActorID: principal.User.ID,
OperationID: objectSyncNewID("op"),
CreatedAt: now,
UpdatedAt: now,
PurgeAt: purgeAt,
}
resourceHash := objectSyncLeaseResourceHash(*space, forceItem.TargetKey)
lease, acquired, err := target.AcquireObjectSyncLease(request.Context(), domain.ObjectSyncLeaseRecord{
ID: "osl_" + resourceHash,
OrganizationID: forceItem.OrganizationID,
ResourceHash: resourceHash,
ResourceType: "object",
ConnectionID: space.ConnectionID,
Bucket: space.Bucket,
KeyOrPrefix: forceItem.TargetKey,
OwnerSessionID: forceItem.SessionID,
OwnerItemID: forceItem.ID,
}, objectSyncLeaseTTL)
if err != nil || !acquired {
status := http.StatusConflict
code := "lease_held"
retryable := true
message := "Another operation currently holds the logical object key"
if err != nil && !errors.Is(err, store.ErrObjectSyncLeaseHeld) {
status = http.StatusInternalServerError
code = "lease_acquire_failed"
message = err.Error()
}
renderObjectSyncError(writer, request, status, code, message, retryable, nil)
return
}
forceItem.LeaseID = lease.ID
forceItem.FencingToken = lease.FencingToken
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{forceItem}); err != nil {
_ = target.ReleaseObjectSyncLease(request.Context(), lease.ID, forceItem.SessionID, forceItem.ID, forceItem.FencingToken)
renderObjectSyncError(writer, request, http.StatusInternalServerError, "force_overwrite_enqueue_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: forceItem.OrganizationID,
ActorType: "user",
ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request),
SessionID: forceItem.SessionID,
ItemID: forceItem.ID,
Action: "item.force_overwrite",
Target: map[string]any{
"conflictItemId": conflict.ID,
"sourceKey": forceItem.ForceSourceKey,
"targetKey": forceItem.TargetKey,
},
Result: "accepted",
}) {
return
}
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": forceItem.OperationID, "item": forceItem})
}
func (server *server) handleObjectSyncReleasesList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
items, err := target.ListObjectSyncReleases(request.Context(), principal.User.OrganizationID)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "releases_list_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleObjectSyncReleaseCreate(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
var input struct {
Name string `json:"name"`
Description string `json:"description"`
SessionIDs []string `json:"sessionIds"`
}
if !decodeJSON(writer, request, &input) {
return
}
if strings.TrimSpace(input.Name) == "" || len(input.SessionIDs) == 0 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_release", "name and sessionIds are required", false, nil)
return
}
releaseSpaceID := ""
seenSessions := make(map[string]struct{}, len(input.SessionIDs))
for _, sessionID := range input.SessionIDs {
if _, duplicate := seenSessions[sessionID]; duplicate {
renderObjectSyncError(writer, request, http.StatusBadRequest, "duplicate_release_session", "sessionIds must not contain duplicates", false, map[string]any{"sessionId": sessionID})
return
}
seenSessions[sessionID] = struct{}{}
session, err := target.GetObjectSyncSession(request.Context(), sessionID)
if err != nil || session == nil || session.OrganizationID != principal.User.OrganizationID || (session.Status != domain.ObjectSyncSessionCompleted && session.Status != domain.ObjectSyncSessionConflicted && session.Status != domain.ObjectSyncSessionPartial) {
renderObjectSyncError(writer, request, http.StatusConflict, "release_session_not_final", "Every release session must be final and belong to the organization", false, map[string]any{"sessionId": sessionID})
return
}
if releaseSpaceID == "" {
releaseSpaceID = session.SyncSpaceID
} else if session.SyncSpaceID != releaseSpaceID {
renderObjectSyncError(writer, request, http.StatusConflict, "release_space_mismatch", "All release sessions must belong to one sync space", false, map[string]any{"sessionId": sessionID, "syncSpaceId": session.SyncSpaceID, "expectedSyncSpaceId": releaseSpaceID})
return
}
}
item := domain.ObjectSyncReleaseRecord{
ID: objectSyncNewID("osr"),
OrganizationID: principal.User.OrganizationID,
SyncSpaceID: releaseSpaceID,
Name: strings.TrimSpace(input.Name),
Description: strings.TrimSpace(input.Description),
SessionIDs: input.SessionIDs,
Status: "pending",
CreatedBy: principal.User.ID,
CreatedAt: nowISO(),
}
if err := target.UpsertObjectSyncRelease(request.Context(), item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "release_create_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: item.OrganizationID,
ActorType: "user",
ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request),
Action: "release.create",
Target: map[string]any{"releaseId": item.ID, "syncSpaceId": item.SyncSpaceID},
After: map[string]any{"sessionIds": item.SessionIDs, "name": item.Name},
Result: "accepted",
}) {
return
}
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": item.ID, "release": item})
}
func (server *server) handleObjectSyncAuditList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
start, end, ok := objectSyncAuditRange(writer, request)
if !ok {
return
}
page, err := target.ListObjectSyncAuditRange(
request.Context(),
principal.User.OrganizationID,
start,
end,
strings.TrimSpace(request.URL.Query().Get("cursor")),
objectSyncQueryLimit(request),
)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "audit_list_failed", err.Error(), true, nil)
return
}
sessionID := strings.TrimSpace(request.URL.Query().Get("sessionId"))
if sessionID != "" {
filtered := page.Items[:0]
for _, item := range page.Items {
if item.SessionID == sessionID {
filtered = append(filtered, item)
}
}
page.Items = filtered
}
renderJSON(writer, http.StatusOK, page)
}
func objectSyncAuditRange(writer http.ResponseWriter, request *http.Request) (string, string, bool) {
start := strings.TrimSpace(request.URL.Query().Get("start"))
end := strings.TrimSpace(request.URL.Query().Get("end"))
if start == "" {
start = time.Now().UTC().Add(-objectSyncVersionRetention).Format(time.RFC3339Nano)
} else if parsed, err := time.Parse(time.RFC3339, start); err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_range", "start must be an RFC3339 timestamp", false, nil)
return "", "", false
} else {
start = parsed.UTC().Format(time.RFC3339Nano)
}
if end == "" {
end = time.Now().UTC().Add(time.Second).Format(time.RFC3339Nano)
} else if parsed, err := time.Parse(time.RFC3339, end); err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_range", "end must be an RFC3339 timestamp", false, nil)
return "", "", false
} else {
end = parsed.UTC().Format(time.RFC3339Nano)
}
if start >= end {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_range", "start must be earlier than end", false, nil)
return "", "", false
}
return start, end, true
}
func (server *server) handleObjectSyncAuditExport(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
start, end, ok := objectSyncAuditRange(writer, request)
if !ok {
return
}
sessionID := strings.TrimSpace(request.URL.Query().Get("sessionId"))
format := strings.ToLower(strings.TrimSpace(request.URL.Query().Get("format")))
if format == "csv" {
writer.Header().Set("Content-Type", "text/csv; charset=utf-8")
writer.Header().Set("Content-Disposition", `attachment; filename="drosync-audit.csv"`)
csvWriter := csv.NewWriter(writer)
_ = csvWriter.Write([]string{"id", "occurredAt", "actorType", "actorId", "action", "result", "sessionId", "itemId", "eventHash", "previousHash"})
cursor := ""
for {
page, err := target.ListObjectSyncAuditRange(request.Context(), principal.User.OrganizationID, start, end, cursor, 1000)
if err != nil {
return
}
for _, item := range page.Items {
if sessionID == "" || item.SessionID == sessionID {
_ = csvWriter.Write([]string{item.ID, item.OccurredAt, item.ActorType, item.ActorID, item.Action, item.Result, item.SessionID, item.ItemID, item.EventHash, item.PreviousHash})
}
}
if page.NextCursor == "" {
break
}
cursor = page.NextCursor
}
csvWriter.Flush()
return
}
if format != "" && format != "ndjson" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_format", "format must be csv or ndjson", false, nil)
return
}
writer.Header().Set("Content-Type", "application/x-ndjson")
writer.Header().Set("Content-Disposition", `attachment; filename="drosync-audit.ndjson"`)
encoder := json.NewEncoder(writer)
cursor := ""
for {
page, err := target.ListObjectSyncAuditRange(request.Context(), principal.User.OrganizationID, start, end, cursor, 1000)
if err != nil {
return
}
for _, item := range page.Items {
if sessionID == "" || item.SessionID == sessionID {
_ = encoder.Encode(item)
}
}
if page.NextCursor == "" {
break
}
cursor = page.NextCursor
}
}
func (server *server) handleObjectSyncAuditSealGet(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
dayUTC := strings.TrimSpace(chi.URLParam(request, "day"))
if _, err := time.Parse("2006-01-02", dayUTC); err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_audit_day", "day must use YYYY-MM-DD", false, nil)
return
}
principal := objectSyncManagementPrincipal(request)
item, err := target.GetObjectSyncAuditSeal(request.Context(), principal.User.OrganizationID, dayUTC)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "audit_seal_lookup_failed", err.Error(), true, nil)
return
}
if item == nil {
renderObjectSyncError(writer, request, http.StatusNotFound, "audit_seal_not_found", "No signed audit seal exists for that UTC day", false, nil)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleObjectSyncClientReleasesList(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
items, err := target.ListObjectSyncClientReleases(request.Context())
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_releases_list_failed", err.Error(), true, nil)
return
}
for index := range items {
items[index] = objectSyncClientReleaseForResponse(items[index])
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func objectSyncClientReleaseKind(item domain.ObjectSyncClientReleaseRecord) string {
if kind := strings.TrimSpace(item.Kind); kind != "" {
return kind
}
return objectSyncReleaseSigned
}
func objectSyncClientReleaseCanAutoUpdate(item domain.ObjectSyncClientReleaseRecord) bool {
return objectSyncClientReleaseKind(item) == objectSyncReleaseSigned &&
!item.Paused &&
item.RolloutPercent > 0 &&
item.ProtocolVersion == domain.ObjectSyncProtocolVersion
}
func objectSyncClientReleaseForResponse(item domain.ObjectSyncClientReleaseRecord) domain.ObjectSyncClientReleaseRecord {
item.Kind = objectSyncClientReleaseKind(item)
if item.Kind != objectSyncReleasePreview {
return item
}
artifacts := make(map[string]string, len(item.Artifacts))
for platform := range item.Artifacts {
artifacts[platform] = "/api/object-sync/client-releases/" + url.PathEscape(item.ID) + "/artifacts/" + url.PathEscape(platform)
}
item.Artifacts = artifacts
return item
}
func validateObjectSyncPreviewArtifacts(input domain.ObjectSyncClientReleaseRecord) error {
for _, platform := range objectSyncClientPlatforms {
source := strings.TrimSpace(input.Artifacts[platform])
digest := strings.TrimSpace(input.SHA256[platform])
if source == "" || digest == "" {
return fmt.Errorf("preview release requires %s artifact and SHA-256", platform)
}
parsed, err := url.Parse(source)
if err != nil || parsed.Scheme != "bos" || parsed.Host == "" || strings.Trim(parsed.Path, "/") == "" {
return fmt.Errorf("%s preview artifact must use bos://connection-id/bucket/object-key", platform)
}
if len(digest) != 64 {
return fmt.Errorf("%s SHA-256 must contain 64 hexadecimal characters", platform)
}
if _, err := hex.DecodeString(digest); err != nil {
return fmt.Errorf("%s SHA-256 must contain 64 hexadecimal characters", platform)
}
}
return nil
}
func (server *server) handleObjectSyncClientReleaseUpsert(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
var input domain.ObjectSyncClientReleaseRecord
if !decodeJSON(writer, request, &input) {
return
}
input.Kind = objectSyncClientReleaseKind(input)
if strings.TrimSpace(input.Version) == "" || len(input.Artifacts) == 0 || len(input.SHA256) == 0 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_release", "version, artifacts and sha256 are required", false, nil)
return
}
if input.Kind != objectSyncReleaseSigned && input.Kind != objectSyncReleasePreview {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_release_kind", "kind must be signed or preview", false, nil)
return
}
if input.Kind == objectSyncReleasePreview {
if err := validateObjectSyncPreviewArtifacts(input); err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_preview_release", err.Error(), false, nil)
return
}
if input.Channel != objectSyncReleasePreview || input.RolloutPercent != 100 || input.Paused {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_preview_release", "preview releases must use channel=preview, rolloutPercent=100 and paused=false", false, nil)
return
}
input.Signature = ""
} else if strings.TrimSpace(input.Signature) == "" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_release", "signed releases require a manifest signature", false, nil)
return
}
if input.RolloutPercent < 0 || input.RolloutPercent > 100 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_rollout_percent", "rolloutPercent must be between 0 and 100", false, nil)
return
}
if input.Kind == objectSyncReleaseSigned {
expectedPercent := map[string]int{"canary": 5, "pilot": 20, "stable": 100}
if value, valid := expectedPercent[input.Channel]; !valid {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_rollout_channel", "channel must be canary, pilot or stable", false, nil)
return
} else if !input.Paused && input.RolloutPercent != value {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_rollout_stage", "An active rollout must use the fixed 5%, 20% or 100% percentage for its channel", false, map[string]any{"expectedPercent": value})
return
}
}
if input.ID == "" {
input.ID = "drosync-" + input.Kind + "-" + input.Version
}
if input.ProtocolVersion == "" {
input.ProtocolVersion = domain.ObjectSyncProtocolVersion
}
now := time.Now().UTC()
input.CreatedAt = now.Format(time.RFC3339Nano)
input.StageChangedAt = input.CreatedAt
items, err := target.ListObjectSyncClientReleases(request.Context())
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_releases_list_failed", err.Error(), true, nil)
return
}
for _, existing := range items {
if existing.ID != input.ID {
continue
}
if existing.Version != input.Version ||
objectSyncClientReleaseKind(existing) != input.Kind ||
existing.ProtocolVersion != input.ProtocolVersion ||
existing.MinimumServerVersion != input.MinimumServerVersion ||
existing.Signature != input.Signature ||
!maps.Equal(existing.Artifacts, input.Artifacts) ||
!maps.Equal(existing.SHA256, input.SHA256) {
renderObjectSyncError(writer, request, http.StatusConflict, "client_release_immutable", "Version, protocol, artifacts, checksums and signature are immutable after registration", false, nil)
return
}
input.CreatedAt = existing.CreatedAt
input.StageChangedAt = existing.StageChangedAt
if input.StageChangedAt == "" {
input.StageChangedAt = existing.CreatedAt
}
stageOrder := map[string]int{"canary": 0, "pilot": 1, "stable": 2}
if input.Kind == objectSyncReleaseSigned && input.Channel != existing.Channel {
if stageOrder[input.Channel] > stageOrder[existing.Channel] {
stageChangedAt, parseErr := time.Parse(time.RFC3339Nano, input.StageChangedAt)
if parseErr != nil {
renderObjectSyncError(writer, request, http.StatusConflict, "rollout_observation_unknown", "The current rollout stage has no valid observation timestamp", false, nil)
return
}
eligibleAt := stageChangedAt.Add(24 * time.Hour)
if now.Before(eligibleAt) {
renderObjectSyncError(writer, request, http.StatusConflict, "rollout_observation_incomplete", "The current rollout stage must be observed for 24 hours before promotion", true, map[string]any{"eligibleAt": eligibleAt.Format(time.RFC3339Nano)})
return
}
}
input.StageChangedAt = now.Format(time.RFC3339Nano)
} else if input.Kind == objectSyncReleaseSigned && existing.Paused && !input.Paused {
// Paused time provides no active-client observation evidence.
input.StageChangedAt = now.Format(time.RFC3339Nano)
}
break
}
if err := target.UpsertObjectSyncClientRelease(request.Context(), input); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_release_save_failed", err.Error(), true, nil)
return
}
principal := objectSyncManagementPrincipal(request)
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: principal.User.OrganizationID,
ActorType: "user",
ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request),
Action: "client_release." + input.Kind,
Target: map[string]any{"releaseId": input.ID, "version": input.Version},
After: map[string]any{"channel": input.Channel, "rolloutPercent": input.RolloutPercent, "paused": input.Paused},
Result: "success",
}) {
return
}
renderJSON(writer, http.StatusOK, objectSyncClientReleaseForResponse(input))
}
func parseObjectSyncPreviewArtifact(source string) (connectionID, bucket, key string, err error) {
parsed, err := url.Parse(strings.TrimSpace(source))
if err != nil || parsed.Scheme != "bos" {
return "", "", "", errors.New("preview artifact source is invalid")
}
connectionID = strings.TrimSpace(parsed.Host)
parts := strings.SplitN(strings.Trim(parsed.Path, "/"), "/", 2)
if connectionID == "" || len(parts) != 2 || strings.TrimSpace(parts[0]) == "" || strings.TrimSpace(parts[1]) == "" {
return "", "", "", errors.New("preview artifact source is incomplete")
}
return connectionID, parts[0], parts[1], nil
}
func (server *server) handleObjectSyncClientReleaseDownload(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
releaseID := chi.URLParam(request, "id")
platform := chi.URLParam(request, "platform")
items, err := target.ListObjectSyncClientReleases(request.Context())
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "client_releases_list_failed", err.Error(), true, nil)
return
}
var selected *domain.ObjectSyncClientReleaseRecord
for index := range items {
if items[index].ID == releaseID {
selected = &items[index]
break
}
}
if selected == nil || objectSyncClientReleaseKind(*selected) != objectSyncReleasePreview {
renderObjectSyncError(writer, request, http.StatusNotFound, "client_release_not_found", "Preview client release was not found", false, nil)
return
}
source := selected.Artifacts[platform]
connectionID, bucket, key, err := parseObjectSyncPreviewArtifact(source)
if err != nil {
renderObjectSyncError(writer, request, http.StatusNotFound, "client_artifact_not_found", "Client artifact was not found", false, nil)
return
}
browser, connection, cleanup, err := server.resolveObjectStorageBrowser(request.Context(), connectionID)
if cleanup != nil {
defer cleanup()
}
if err != nil || browser == nil || connection == nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "client_artifact_storage_failed", "Client artifact storage is unavailable", true, nil)
return
}
if resolved, resolveErr := resolveObjectStorageBucket(connection, bucket); resolveErr != nil || resolved != bucket {
renderObjectSyncError(writer, request, http.StatusNotFound, "client_artifact_not_found", "Client artifact bucket is not available", false, nil)
return
}
summary, err := browser.GetObjectSummary(request.Context(), bucket, key)
if err != nil {
renderObjectSyncError(writer, request, http.StatusNotFound, "client_artifact_not_found", "Client artifact was not found", false, nil)
return
}
writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", path.Base(key)))
writer.Header().Set("Cache-Control", "private, no-store")
requestedRange, hasRange, rangeErr := parseObjectStorageByteRange(request.Header.Get("Range"), summary.SizeBytes)
if rangeErr != nil {
writer.Header().Set("Accept-Ranges", "bytes")
renderObjectSyncError(writer, request, http.StatusRequestedRangeNotSatisfiable, "invalid_range", rangeErr.Error(), false, nil)
return
}
if !hasRange && summary.SizeBytes > 0 {
requestedRange = objectStorageByteRange{start: 0, end: summary.SizeBytes - 1}
}
statusCode := http.StatusOK
if hasRange {
statusCode = http.StatusPartialContent
}
if request.Method == http.MethodHead {
writeObjectStorageRangeHeaders(writer, summary, "application/octet-stream", requestedRange, statusCode)
writer.WriteHeader(statusCode)
return
}
reader, _, err := browser.ReadObjectRange(request.Context(), bucket, key, requestedRange.start, requestedRange.end)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "client_artifact_read_failed", err.Error(), true, nil)
return
}
defer reader.Close()
writeObjectStorageRangeHeaders(writer, summary, "application/octet-stream", requestedRange, statusCode)
writer.WriteHeader(statusCode)
if _, err := io.Copy(writer, reader); err != nil {
fmt.Printf("[api] client release download stream failed: %v\n", err)
}
}
func (server *server) handleExternalObjectSyncAuthorizationCreate(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
var input struct {
DeviceID string `json:"deviceId"`
DeviceName string `json:"deviceName"`
Platform string `json:"platform"`
Architecture string `json:"architecture"`
ClientVersion string `json:"clientVersion"`
}
if !decodeJSON(writer, request, &input) {
return
}
if strings.TrimSpace(input.DeviceID) == "" || strings.TrimSpace(input.DeviceName) == "" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_device", "deviceId and deviceName are required", false, nil)
return
}
deviceCode, err := randomURLToken(32)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "pairing_failed", err.Error(), true, nil)
return
}
codeBytes, _ := randomURLToken(8)
sum := sha256.Sum256([]byte(codeBytes))
userCode := strings.TrimRight(base32.StdEncoding.EncodeToString(sum[:5]), "=")
now := time.Now().UTC()
item := domain.ObjectSyncDeviceAuthorizationRecord{
ID: objectSyncNewID("oda"),
DeviceID: strings.TrimSpace(input.DeviceID),
DeviceName: strings.TrimSpace(input.DeviceName),
Platform: strings.TrimSpace(input.Platform),
Architecture: strings.TrimSpace(input.Architecture),
ClientVersion: strings.TrimSpace(input.ClientVersion),
DeviceCodeHash: sessionTokenHash(deviceCode),
UserCode: userCode,
Status: "pending",
CreatedAt: now.Format(time.RFC3339Nano),
UpdatedAt: now.Format(time.RFC3339Nano),
ExpiresAt: now.Add(15 * time.Minute).Format(time.RFC3339Nano),
ExpiresAtTime: now.Add(15 * time.Minute),
}
if err := target.UpsertObjectSyncAuthorization(request.Context(), item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "pairing_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusCreated, map[string]any{
"deviceCode": deviceCode,
"userCode": userCode,
"verificationUri": "/object-sync?pair=" + userCode,
"expiresIn": 900,
"interval": 5,
})
}
func (server *server) handleExternalObjectSyncAuthorizationPoll(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
var input struct {
DeviceCode string `json:"deviceCode"`
}
if !decodeJSON(writer, request, &input) {
return
}
item, err := target.GetObjectSyncAuthorizationByDeviceCodeHash(request.Context(), sessionTokenHash(strings.TrimSpace(input.DeviceCode)))
if err != nil || item == nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_device_code", "Device code is invalid", false, nil)
return
}
if time.Now().UTC().After(item.ExpiresAtTime) {
renderObjectSyncError(writer, request, http.StatusBadRequest, "device_code_expired", "Device code expired", false, nil)
return
}
switch item.Status {
case "pending":
renderObjectSyncError(writer, request, http.StatusPreconditionRequired, "authorization_pending", "Administrator approval is pending", true, map[string]any{"interval": 5})
return
case "denied":
renderObjectSyncError(writer, request, http.StatusForbidden, "authorization_denied", "Administrator denied this device", false, nil)
return
case "exchanged":
renderObjectSyncError(writer, request, http.StatusGone, "device_code_consumed", "Device code was already exchanged", false, nil)
return
case "approved":
default:
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_authorization_state", "Device authorization is not exchangeable", false, nil)
return
}
token, err := randomURLToken(32)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
return
}
now := nowISO()
device := domain.ObjectSyncDeviceRecord{
ID: item.DeviceID,
OrganizationID: item.OrganizationID,
Name: item.DeviceName,
Platform: item.Platform,
Architecture: item.Architecture,
ClientVersion: item.ClientVersion,
Status: "active",
LastSeenAt: now,
CreatedAt: now,
UpdatedAt: now,
}
credential := domain.ObjectSyncCredentialRecord{
ID: objectSyncNewID("odc"),
OrganizationID: item.OrganizationID,
DeviceID: item.DeviceID,
Name: item.DeviceName,
Enabled: true,
TokenHash: sessionTokenHash(token),
TokenPreview: token[:4] + "…" + token[len(token)-4:],
Scopes: item.Scopes,
CreatedAt: now,
UpdatedAt: now,
}
if err := target.UpsertObjectSyncDevice(request.Context(), device); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_save_failed", err.Error(), true, nil)
return
}
if err := target.UpsertObjectSyncCredential(request.Context(), credential); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
return
}
item.Status = "exchanged"
item.UpdatedAt = now
_ = target.UpsertObjectSyncAuthorization(request.Context(), *item)
renderJSON(writer, http.StatusOK, map[string]any{
"credential": token,
"device": device,
"scopes": credential.Scopes,
})
}
func (server *server) handleExternalObjectSyncCapabilities(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentObjectSyncCredential(request)
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
spaces := make([]domain.ObjectSyncSpaceRecord, 0, len(principal.Credential.Scopes))
for _, scope := range principal.Credential.Scopes {
item, err := target.GetObjectSyncSpace(request.Context(), scope.SyncSpaceID)
if err == nil && item != nil {
spaces = append(spaces, *item)
}
}
renderJSON(writer, http.StatusOK, map[string]any{
"protocolVersion": domain.ObjectSyncProtocolVersion,
"spaces": spaces,
"limits": map[string]any{"manifestPageItems": domain.ObjectSyncDefaultManifestPageMaxItems, "concurrentRequests": 16},
})
}
func (server *server) handleExternalObjectSyncSessionCreate(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentObjectSyncCredential(request)
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
var input struct {
SyncSpaceID string `json:"syncSpaceId"`
MappingID string `json:"mappingId"`
ClientVersion string `json:"clientVersion"`
ProtocolVersion string `json:"protocolVersion"`
}
if !decodeJSON(writer, request, &input) {
return
}
scope, allowed := objectSyncCredentialScopeFor(principal.Credential, input.SyncSpaceID)
if !allowed || !objectSyncScopeAllowsAction(*scope, "plan") {
renderObjectSyncError(writer, request, http.StatusForbidden, "scope_denied", "Credential cannot create sessions in this sync space", false, nil)
return
}
space, err := target.GetObjectSyncSpace(request.Context(), input.SyncSpaceID)
if err != nil || space == nil || space.OrganizationID != principal.Credential.OrganizationID {
renderObjectSyncError(writer, request, http.StatusNotFound, "space_not_found", "Object sync space not found", false, nil)
return
}
if !space.Enabled || (space.Capability.State != domain.ObjectSyncCapabilityCreateOnly && space.Capability.State != domain.ObjectSyncCapabilityUpdateEnabled) {
renderObjectSyncError(writer, request, http.StatusConflict, "space_not_ready", "Object sync space is disabled or has not passed conditional-create probing", false, map[string]any{"state": space.Capability.State})
return
}
if input.ProtocolVersion != "" && input.ProtocolVersion != domain.ObjectSyncProtocolVersion {
renderObjectSyncError(writer, request, http.StatusConflict, "protocol_version_unsupported", "Client protocol version is not supported", false, map[string]any{"supported": domain.ObjectSyncProtocolVersion})
return
}
now := time.Now().UTC()
item := domain.ObjectSyncSessionRecord{
ID: objectSyncNewID("oses"),
OrganizationID: principal.Credential.OrganizationID,
SyncSpaceID: space.ID,
CredentialID: principal.Credential.ID,
DeviceID: principal.Device.ID,
MappingID: strings.TrimSpace(input.MappingID),
ClientVersion: strings.TrimSpace(input.ClientVersion),
ProtocolVersion: domain.ObjectSyncProtocolVersion,
Status: domain.ObjectSyncSessionCollectingManifest,
PolicySnapshot: space.Policy,
CreatedAt: now.Format(time.RFC3339Nano),
UpdatedAt: now.Format(time.RFC3339Nano),
ExpiresAt: now.Add(objectSyncSessionTTL).Format(time.RFC3339Nano),
PurgeAt: now.Add(objectSyncRecordRetention),
}
if err := target.UpsertObjectSyncSession(request.Context(), item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_create_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: item.OrganizationID, ActorType: "device", ActorID: principal.Device.ID,
CredentialID: principal.Credential.ID, DeviceID: principal.Device.ID, SessionID: item.ID,
RequestID: objectSyncRequestID(request), Action: "session.create", Result: "success",
}) {
return
}
renderJSON(writer, http.StatusCreated, item)
}
func (server *server) externalObjectSyncSession(writer http.ResponseWriter, request *http.Request, target store.ObjectSyncStore) (*domain.ObjectSyncSessionRecord, *objectSyncCredentialPrincipal, bool) {
principal, _ := currentObjectSyncCredential(request)
sessionID := chi.URLParam(request, "sessionId")
if sessionID == "" {
sessionID = chi.URLParam(request, "id")
}
session, err := target.GetObjectSyncSession(request.Context(), sessionID)
if err != nil || session == nil || session.CredentialID != principal.Credential.ID || session.DeviceID != principal.Device.ID {
renderObjectSyncError(writer, request, http.StatusNotFound, "session_not_found", "Object sync session not found for this device credential", false, nil)
return nil, principal, false
}
return session, principal, true
}
func (server *server) handleExternalObjectSyncManifestPage(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
session, principal, ok := server.externalObjectSyncSession(writer, request, target)
if !ok {
return
}
if session.Status != domain.ObjectSyncSessionCollectingManifest {
renderObjectSyncError(writer, request, http.StatusConflict, "manifest_closed", "Session is not collecting manifest pages", false, map[string]any{"status": session.Status})
return
}
var input struct {
PageNumber int `json:"pageNumber"`
Final bool `json:"final"`
Items []domain.ObjectSyncManifestItemInput `json:"items"`
}
if !decodeJSON(writer, request, &input) {
return
}
if input.PageNumber <= 0 || len(input.Items) == 0 || len(input.Items) > domain.ObjectSyncDefaultManifestPageMaxItems {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_manifest_page", "pageNumber must be positive and items must contain 1-1000 entries", false, nil)
return
}
space, err := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
if err != nil || space == nil {
renderObjectSyncError(writer, request, http.StatusConflict, "space_not_found", "Session sync space is unavailable", false, nil)
return
}
scope, _ := objectSyncCredentialScopeFor(principal.Credential, session.SyncSpaceID)
now := time.Now().UTC()
items := make([]domain.ObjectSyncItemRecord, 0, len(input.Items))
var pageBytes int64
clientItemIDs := make(map[string]struct{}, len(input.Items))
for _, manifest := range input.Items {
clientItemID := strings.TrimSpace(manifest.ClientItemID)
if clientItemID == "" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_client_item_id", "Manifest clientItemId is required", false, nil)
return
}
if _, exists := clientItemIDs[clientItemID]; exists {
renderObjectSyncError(writer, request, http.StatusBadRequest, "duplicate_client_item_id", "Manifest page contains a duplicate clientItemId", false, map[string]any{"clientItemId": clientItemID})
return
}
clientItemIDs[clientItemID] = struct{}{}
relativePath, pathErr := normalizeObjectSyncRelativePath(manifest.RelativePath)
if pathErr != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_relative_path", pathErr.Error(), false, map[string]any{"clientItemId": manifest.ClientItemID})
return
}
if manifest.Kind != "" && manifest.Kind != "file" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "unsupported_item_kind", "Only regular files are accepted", false, map[string]any{"clientItemId": manifest.ClientItemID})
return
}
if manifest.SizeBytes < 0 || manifest.SizeBytes > session.PolicySnapshot.MaxObjectBytes {
renderObjectSyncError(writer, request, http.StatusRequestEntityTooLarge, "object_too_large", "Manifest item exceeds the sync space object limit", false, map[string]any{"clientItemId": manifest.ClientItemID})
return
}
if decoded, decodeErr := hex.DecodeString(manifest.SHA256); decodeErr != nil || len(decoded) != sha256.Size {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_sha256", "Manifest item SHA-256 must be a 64-character hex digest", false, map[string]any{"clientItemId": clientItemID})
return
}
if scope == nil || !objectSyncScopeAllows(*scope, "create", relativePath) {
renderObjectSyncError(writer, request, http.StatusForbidden, "path_scope_denied", "Manifest path is outside the credential scope", false, map[string]any{"relativePath": relativePath})
return
}
pageBytes += manifest.SizeBytes
items = append(items, domain.ObjectSyncItemRecord{
ID: objectSyncNewID("osi"),
OrganizationID: session.OrganizationID,
SessionID: session.ID,
ClientItemID: clientItemID,
ManifestPage: input.PageNumber,
RelativePath: manifest.RelativePath,
NormalizedRelativePath: relativePath,
TargetKey: objectSyncTargetKey(*space, relativePath),
SizeBytes: manifest.SizeBytes,
ModifiedAt: manifest.ModifiedAt,
SHA256: strings.ToLower(manifest.SHA256),
ContentType: strings.TrimSpace(manifest.ContentType),
ExpectedBase: manifest.LastKnownRemote,
Status: domain.ObjectSyncItemDiscovered,
CreatedAt: now.Format(time.RFC3339Nano),
UpdatedAt: now.Format(time.RFC3339Nano),
PurgeAt: now.Add(objectSyncRecordRetention),
})
}
if session.Counts.Manifest+int64(len(items)) > session.PolicySnapshot.MaxSessionFiles || session.TotalBytes+pageBytes > session.PolicySnapshot.MaxSessionBytes {
renderObjectSyncError(writer, request, http.StatusRequestEntityTooLarge, "session_quota_exceeded", "Manifest exceeds the sync space session quota", false, nil)
return
}
if err := target.UpsertObjectSyncItems(request.Context(), items); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "manifest_save_failed", err.Error(), true, nil)
return
}
session.Counts.Manifest += int64(len(items))
session.TotalBytes += pageBytes
if input.Final {
session.ManifestFinalPage = input.PageNumber
}
session.UpdatedAt = nowISO()
if err := target.UpsertObjectSyncSession(request.Context(), *session); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_update_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusAccepted, map[string]any{"accepted": len(items), "session": session})
}
func (server *server) handleExternalObjectSyncPlan(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
session, _, ok := server.externalObjectSyncSession(writer, request, target)
if !ok {
return
}
if session.Status == domain.ObjectSyncSessionPlanning || session.Status == domain.ObjectSyncSessionPlanned {
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": session.OperationID, "session": session})
return
}
if session.Status != domain.ObjectSyncSessionCollectingManifest || session.ManifestFinalPage <= 0 {
renderObjectSyncError(writer, request, http.StatusConflict, "manifest_incomplete", "A final manifest page is required before planning", false, nil)
return
}
session.Status = domain.ObjectSyncSessionPlanning
session.OperationID = objectSyncNewID("op")
session.UpdatedAt = nowISO()
if err := target.UpsertObjectSyncSession(request.Context(), *session); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "plan_enqueue_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": session.OperationID, "session": session})
}
func (server *server) externalObjectSyncItem(writer http.ResponseWriter, request *http.Request, target store.ObjectSyncStore) (*domain.ObjectSyncItemRecord, *domain.ObjectSyncSessionRecord, *objectSyncCredentialPrincipal, bool) {
principal, _ := currentObjectSyncCredential(request)
item, err := target.GetObjectSyncItem(request.Context(), chi.URLParam(request, "itemId"))
if err != nil || item == nil {
renderObjectSyncError(writer, request, http.StatusNotFound, "item_not_found", "Object sync item not found", false, nil)
return nil, nil, principal, false
}
session, err := target.GetObjectSyncSession(request.Context(), item.SessionID)
if err != nil || session == nil || session.CredentialID != principal.Credential.ID || session.DeviceID != principal.Device.ID {
renderObjectSyncError(writer, request, http.StatusNotFound, "item_not_found", "Object sync item not found for this device credential", false, nil)
return nil, nil, principal, false
}
return item, session, principal, true
}
func objectSyncLeaseResourceHash(space domain.ObjectSyncSpaceRecord, key string) string {
sum := sha256.Sum256([]byte(space.ConnectionID + "\x00" + space.Bucket + "\x00" + key))
return hex.EncodeToString(sum[:])
}
func (server *server) handleExternalObjectSyncItemReserve(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
}
if item.Status == domain.ObjectSyncItemReserved || item.Status == domain.ObjectSyncItemUploading || item.Status == domain.ObjectSyncItemUploaded {
renderJSON(writer, http.StatusOK, item)
return
}
if item.Status != domain.ObjectSyncItemPlanned {
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_reservable", "Item is not in the planned state", false, map[string]any{"status": item.Status})
return
}
space, err := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
if err != nil || space == nil {
renderObjectSyncError(writer, request, http.StatusConflict, "space_not_found", "Session sync space is unavailable", false, nil)
return
}
leaseTemplate := domain.ObjectSyncLeaseRecord{
ID: "osl_" + objectSyncLeaseResourceHash(*space, item.TargetKey),
OrganizationID: session.OrganizationID,
ResourceHash: objectSyncLeaseResourceHash(*space, item.TargetKey),
ResourceType: "object",
ConnectionID: space.ConnectionID,
Bucket: space.Bucket,
KeyOrPrefix: item.TargetKey,
OwnerSessionID: session.ID,
OwnerItemID: item.ID,
}
lease, acquired, err := target.AcquireObjectSyncLease(request.Context(), leaseTemplate, objectSyncLeaseTTL)
if err != nil {
status := http.StatusInternalServerError
code := "lease_acquire_failed"
retryable := true
if errors.Is(err, store.ErrObjectSyncLeaseHeld) {
status = http.StatusConflict
code = "lease_held"
}
renderObjectSyncError(writer, request, status, code, err.Error(), retryable, nil)
return
}
if !acquired {
renderObjectSyncError(writer, request, http.StatusConflict, "lease_held", "Another session currently holds this logical object key", true, nil)
return
}
item.LeaseID = lease.ID
item.FencingToken = lease.FencingToken
item.StagingKey = path.Join(".drosync-internal/staging", session.OrganizationID, session.ID, item.ID)
item.Status = domain.ObjectSyncItemReserved
item.UpdatedAt = nowISO()
session.Status = domain.ObjectSyncSessionRunning
session.LastHeartbeatAt = item.UpdatedAt
session.UpdatedAt = item.UpdatedAt
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item}); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "item_reserve_failed", err.Error(), true, nil)
return
}
_ = target.UpsertObjectSyncSession(request.Context(), *session)
renderJSON(writer, http.StatusOK, map[string]any{"item": item, "lease": lease})
}
func (server *server) handleExternalObjectSyncDirectUpload(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
}
if item.Status != domain.ObjectSyncItemReserved && item.Status != domain.ObjectSyncItemUploading {
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_uploadable", "Item must be reserved before requesting an upload URL", false, nil)
return
}
var input struct {
ContentMD5 string `json:"contentMd5"`
}
if !decodeJSON(writer, request, &input) {
return
}
if decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(input.ContentMD5)); err != nil || len(decoded) != 16 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_content_md5", "contentMd5 must be a base64-encoded 128-bit MD5 digest", false, nil)
return
}
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_prepare_failed", err.Error(), true, nil)
return
}
defer closeBrowser()
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
if !ok {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind upload integrity headers", false, nil)
return
}
metadata := map[string]string{"drosync-session": session.ID, "drosync-item": item.ID, "drosync-sha256": item.SHA256}
result, err := boundBrowser.PresignPutObjectBound(request.Context(), space.Bucket, item.StagingKey, item.ContentType, input.ContentMD5, item.SizeBytes, metadata, objectStoragePresignDefaultExpires)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_prepare_failed", err.Error(), true, nil)
return
}
item.UploadMode = "direct"
item.Status = domain.ObjectSyncItemUploading
item.UpdatedAt = nowISO()
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
renderJSON(writer, http.StatusOK, map[string]any{
"upload": result,
"required": map[string]any{
"sizeBytes": item.SizeBytes,
"sha256": item.SHA256,
"contentMd5": input.ContentMD5,
"metadata": metadata,
},
})
}
func (server *server) handleExternalObjectSyncMultipartInitiate(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
}
if item.Status != domain.ObjectSyncItemReserved && item.Status != domain.ObjectSyncItemUploading {
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_uploadable", "Item must be reserved before initiating multipart upload", false, nil)
return
}
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
if item.UploadMode == "multipart" && item.UploadID != "" {
renderJSON(writer, http.StatusOK, map[string]any{
"bucket": space.Bucket,
"key": item.StagingKey,
"uploadId": item.UploadID,
"expiresAt": time.Now().UTC().Add(time.Duration(objectStoragePresignDefaultExpires) * time.Second).Format(time.RFC3339),
"uploadedParts": nonNilObjectSyncUploadedParts(item.UploadedParts),
"resumed": true,
})
return
}
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_initiate_failed", err.Error(), true, nil)
return
}
defer closeBrowser()
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
if !ok {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind multipart metadata", false, nil)
return
}
result, err := boundBrowser.InitiateMultipartUploadBound(request.Context(), space.Bucket, item.StagingKey, item.ContentType, map[string]string{
"drosync-session": session.ID,
"drosync-item": item.ID,
"drosync-sha256": item.SHA256,
}, objectStoragePresignDefaultExpires)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_initiate_failed", err.Error(), true, nil)
return
}
item.UploadMode = "multipart"
item.UploadID = result.UploadID
item.Status = domain.ObjectSyncItemUploading
item.UpdatedAt = nowISO()
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
renderJSON(writer, http.StatusCreated, map[string]any{
"bucket": result.Bucket,
"key": result.Key,
"uploadId": result.UploadID,
"expiresAt": result.ExpiresAt,
"uploadedParts": nonNilObjectSyncUploadedParts(item.UploadedParts),
"resumed": false,
})
}
func nonNilObjectSyncUploadedParts(parts []domain.ObjectStorageMultipartUploadPart) []domain.ObjectStorageMultipartUploadPart {
if parts == nil {
return []domain.ObjectStorageMultipartUploadPart{}
}
return parts
}
func (server *server) handleExternalObjectSyncMultipartPartURL(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
}
var input struct {
PartNumber int `json:"partNumber"`
ContentMD5 string `json:"contentMd5"`
SizeBytes int64 `json:"sizeBytes"`
}
if !decodeJSON(writer, request, &input) {
return
}
if item.UploadMode != "multipart" || item.UploadID == "" || input.PartNumber <= 0 || input.PartNumber > 10_000 || input.SizeBytes <= 0 || input.SizeBytes > item.SizeBytes {
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "A valid active multipart upload and partNumber are required", false, nil)
return
}
if decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(input.ContentMD5)); err != nil || len(decoded) != 16 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_content_md5", "contentMd5 must be a base64-encoded 128-bit MD5 digest", false, nil)
return
}
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "part_url_failed", err.Error(), true, nil)
return
}
defer closeBrowser()
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
if !ok {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind multipart integrity headers", false, nil)
return
}
result, err := boundBrowser.PresignMultipartUploadPartBound(request.Context(), space.Bucket, item.StagingKey, item.UploadID, input.PartNumber, input.ContentMD5, input.SizeBytes, objectStoragePresignDefaultExpires)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "part_url_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, result)
}
func (server *server) handleExternalObjectSyncMultipartPartCheckpoint(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
item, _, _, ok := server.externalObjectSyncItem(writer, request, target)
if !ok {
return
}
var input domain.ObjectStorageMultipartUploadPart
if !decodeJSON(writer, request, &input) {
return
}
input.ETag = strings.Trim(strings.TrimSpace(input.ETag), `"`)
if item.UploadMode != "multipart" || item.UploadID == "" || item.Status != domain.ObjectSyncItemUploading {
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "A multipart upload must be active before checkpointing a part", false, nil)
return
}
if input.PartNumber < 1 || input.PartNumber > 10_000 || input.ETag == "" || input.SizeBytes <= 0 || input.SizeBytes > item.SizeBytes {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_multipart_part", "partNumber, eTag, and sizeBytes are required", false, nil)
return
}
replaced := false
for index := range item.UploadedParts {
if item.UploadedParts[index].PartNumber == input.PartNumber {
item.UploadedParts[index] = input
replaced = true
break
}
}
if !replaced {
item.UploadedParts = append(item.UploadedParts, input)
}
sort.Slice(item.UploadedParts, func(left int, right int) bool {
return item.UploadedParts[left].PartNumber < item.UploadedParts[right].PartNumber
})
item.UpdatedAt = nowISO()
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item}); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "multipart_checkpoint_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"itemId": item.ID, "part": input})
}
func (server *server) handleExternalObjectSyncMultipartComplete(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
}
var input struct {
Parts []domain.ObjectStorageMultipartUploadPart `json:"parts"`
}
if !decodeJSON(writer, request, &input) {
return
}
if item.UploadMode != "multipart" || item.UploadID == "" || len(input.Parts) == 0 {
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "A valid active multipart upload and parts are required", false, nil)
return
}
if item.Status != domain.ObjectSyncItemUploading && item.Status != domain.ObjectSyncItemUploaded {
renderObjectSyncError(writer, request, http.StatusConflict, "multipart_not_active", "The multipart upload is not awaiting completion", false, map[string]any{"status": item.Status})
return
}
normalizedParts, err := normalizeObjectStorageMultipartParts(input.Parts)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_multipart_parts", err.Error(), false, nil)
return
}
input.Parts = normalizedParts
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_complete_failed", err.Error(), true, nil)
return
}
defer closeBrowser()
if item.Status == domain.ObjectSyncItemUploaded {
result, lookupErr := browser.GetObjectSummary(request.Context(), space.Bucket, item.StagingKey)
if lookupErr != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_complete_query_failed", lookupErr.Error(), true, nil)
return
}
if result.SizeBytes != item.SizeBytes || !objectSyncStagingMatches(result, item, session) {
renderObjectSyncError(writer, request, http.StatusConflict, "staging_verification_failed", "The previously completed staging object no longer matches the manifest", false, nil)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item, "resumed": true})
return
}
boundBrowser, ok := browser.(objectSyncBoundUploadBrowser)
if !ok {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_binding_unsupported", "Storage provider cannot bind multipart metadata", false, nil)
return
}
result, err := boundBrowser.CompleteMultipartUploadBound(request.Context(), space.Bucket, item.StagingKey, item.UploadID, input.Parts, map[string]string{
"drosync-session": session.ID,
"drosync-item": item.ID,
"drosync-sha256": item.SHA256,
})
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "multipart_complete_failed", err.Error(), true, nil)
return
}
if result.SizeBytes != item.SizeBytes {
renderObjectSyncError(writer, request, http.StatusConflict, "staging_size_mismatch", "Completed staging object size does not match the manifest", false, map[string]any{"expected": item.SizeBytes, "actual": result.SizeBytes})
return
}
if !objectSyncStagingMatches(result, item, session) {
renderObjectSyncError(writer, request, http.StatusConflict, "staging_metadata_mismatch", "Completed staging object is missing the bound drosync metadata or ETag", false, nil)
return
}
item.UploadedParts = input.Parts
item.Status = domain.ObjectSyncItemUploaded
item.UpdatedAt = nowISO()
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item})
}
func (server *server) handleExternalObjectSyncDirectUploadComplete(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
}
if item.UploadMode != "direct" || (item.Status != domain.ObjectSyncItemUploading && item.Status != domain.ObjectSyncItemUploaded) {
renderObjectSyncError(writer, request, http.StatusConflict, "direct_upload_not_active", "A direct upload is not active for this item", false, nil)
return
}
space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID)
browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_verify_failed", err.Error(), true, nil)
return
}
defer closeBrowser()
result, err := browser.GetObjectSummary(request.Context(), space.Bucket, item.StagingKey)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadGateway, "upload_verify_failed", err.Error(), true, nil)
return
}
if result.SizeBytes != item.SizeBytes {
renderObjectSyncError(writer, request, http.StatusConflict, "staging_size_mismatch", "Staging object size does not match the manifest", false, map[string]any{"expected": item.SizeBytes, "actual": result.SizeBytes})
return
}
if !objectSyncStagingMatches(result, item, session) {
renderObjectSyncError(writer, request, http.StatusConflict, "staging_metadata_mismatch", "Staging object is missing the bound drosync metadata or ETag", false, nil)
return
}
if item.Status == domain.ObjectSyncItemUploaded {
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item, "resumed": true})
return
}
item.Status = domain.ObjectSyncItemUploaded
item.UpdatedAt = nowISO()
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
renderJSON(writer, http.StatusOK, map[string]any{"object": result, "item": item})
}
func (server *server) handleExternalObjectSyncHeartbeat(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
}
if item.LeaseID == "" {
renderObjectSyncError(writer, request, http.StatusConflict, "lease_missing", "Item has no active lease", false, nil)
return
}
renewed, err := target.RenewObjectSyncLease(request.Context(), item.LeaseID, session.ID, item.ID, item.FencingToken, objectSyncLeaseTTL)
if err != nil || !renewed {
renderObjectSyncError(writer, request, http.StatusConflict, "lease_lost", "Lease was lost or its fencing token is stale", false, nil)
return
}
session.LastHeartbeatAt = nowISO()
session.UpdatedAt = session.LastHeartbeatAt
_ = target.UpsertObjectSyncSession(request.Context(), *session)
renderJSON(writer, http.StatusOK, map[string]any{"renewed": true, "fencingToken": item.FencingToken})
}
func (server *server) handleExternalObjectSyncItemAbort(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
}
if item.UploadMode == "multipart" && item.UploadID != "" {
if space, _ := target.GetObjectSyncSpace(request.Context(), session.SyncSpaceID); space != nil {
if browser, closeBrowser, err := server.objectSyncBrowser(request.Context(), space); err == nil {
_ = browser.AbortMultipartUpload(request.Context(), space.Bucket, item.StagingKey, item.UploadID)
closeBrowser()
}
}
}
if item.LeaseID != "" {
_ = target.ReleaseObjectSyncLease(request.Context(), item.LeaseID, session.ID, item.ID, item.FencingToken)
}
item.Status = domain.ObjectSyncItemAborted
item.UpdatedAt = nowISO()
_ = target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item})
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleExternalObjectSyncCommit(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
item, _, _, ok := server.externalObjectSyncItem(writer, request, target)
if !ok {
return
}
if item.Status == domain.ObjectSyncItemCommitting || item.Status == domain.ObjectSyncItemCommitted || item.Status == domain.ObjectSyncItemKeptBoth {
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": item.OperationID, "item": item})
return
}
if item.Status != domain.ObjectSyncItemUploaded {
renderObjectSyncError(writer, request, http.StatusConflict, "item_not_committable", "Item must be uploaded before commit", false, nil)
return
}
item.Status = domain.ObjectSyncItemCommitting
item.OperationID = objectSyncNewID("op")
item.UpdatedAt = nowISO()
if err := target.UpsertObjectSyncItems(request.Context(), []domain.ObjectSyncItemRecord{*item}); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "commit_enqueue_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusAccepted, map[string]any{"operationId": item.OperationID, "item": item})
}
func (server *server) handleExternalObjectSyncSessionStatus(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
session, _, ok := server.externalObjectSyncSession(writer, request, target)
if !ok {
return
}
renderJSON(writer, http.StatusOK, session)
}
func (server *server) handleExternalObjectSyncSessionItems(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
session, _, ok := server.externalObjectSyncSession(writer, request, target)
if !ok {
return
}
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{
SessionID: session.ID,
Status: strings.TrimSpace(request.URL.Query().Get("status")),
Cursor: strings.TrimSpace(request.URL.Query().Get("cursor")),
Limit: objectSyncQueryLimit(request),
})
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "items_list_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, page)
}
func (server *server) handleExternalObjectSyncSessionFinish(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
session, _, ok := server.externalObjectSyncSession(writer, request, target)
if !ok {
return
}
action := chi.URLParam(request, "action")
if action == "abort" {
session.Status = domain.ObjectSyncSessionAborted
cursor := ""
for {
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{SessionID: session.ID, Cursor: cursor, Limit: 1000})
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_abort_failed", err.Error(), true, nil)
return
}
updates := make([]domain.ObjectSyncItemRecord, 0, len(page.Items))
for _, item := range page.Items {
switch item.Status {
case domain.ObjectSyncItemCommitted, domain.ObjectSyncItemKeptBoth, domain.ObjectSyncItemUnchanged, domain.ObjectSyncItemSkipped, domain.ObjectSyncItemDenied, domain.ObjectSyncItemFailed, domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired:
continue
default:
item.Status = domain.ObjectSyncItemAborted
item.UpdatedAt = nowISO()
updates = append(updates, item)
}
}
if err := target.UpsertObjectSyncItems(request.Context(), updates); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_abort_failed", err.Error(), true, nil)
return
}
if page.NextCursor == "" {
break
}
cursor = page.NextCursor
}
} else if action == "complete" {
counts := domain.ObjectSyncSessionCounts{Manifest: session.Counts.Manifest}
cursor := ""
for {
page, err := target.ListObjectSyncItems(request.Context(), domain.ObjectSyncListQuery{SessionID: session.ID, Cursor: cursor, Limit: 1000})
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_finalize_failed", err.Error(), true, nil)
return
}
for _, item := range page.Items {
switch item.Status {
case domain.ObjectSyncItemCommitted:
counts.Committed++
case domain.ObjectSyncItemKeptBoth:
counts.KeptBoth++
counts.Committed++
case domain.ObjectSyncItemUnchanged:
counts.Unchanged++
case domain.ObjectSyncItemSkipped:
counts.Skipped++
case domain.ObjectSyncItemDenied:
counts.Denied++
case domain.ObjectSyncItemFailed:
counts.Failed++
case domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired:
counts.Failed++
default:
renderObjectSyncError(writer, request, http.StatusConflict, "session_items_active", "Session still has active items", true, map[string]any{"itemId": item.ID, "status": item.Status})
return
}
switch item.Action {
case "create":
counts.Create++
case "update":
counts.Update++
}
}
if page.NextCursor == "" {
break
}
cursor = page.NextCursor
}
session.Counts = counts
switch {
case session.Counts.Failed > 0 || session.Counts.Denied > 0:
session.Status = domain.ObjectSyncSessionPartial
case session.Counts.KeptBoth > 0:
session.Status = domain.ObjectSyncSessionConflicted
default:
session.Status = domain.ObjectSyncSessionCompleted
}
} else {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_session_action", "Action must be complete or abort", false, nil)
return
}
session.UpdatedAt = nowISO()
session.CompletedAt = session.UpdatedAt
if err := target.UpsertObjectSyncSession(request.Context(), *session); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "session_finalize_failed", err.Error(), true, nil)
return
}
renderJSON(writer, http.StatusOK, session)
}
func (server *server) handleExternalObjectSyncUpdateCheck(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal, _ := currentObjectSyncCredential(request)
items, err := target.ListObjectSyncClientReleases(request.Context())
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "update_check_failed", err.Error(), true, nil)
return
}
platformKey := principal.Device.Platform + "-" + principal.Device.Architecture
currentVersion := strings.TrimSpace(request.URL.Query().Get("currentVersion"))
if currentVersion == "" || len(currentVersion) > 128 {
renderObjectSyncError(writer, request, http.StatusBadRequest, "current_version_required", "currentVersion is required and must be at most 128 characters", false, nil)
return
}
for _, item := range items {
if !objectSyncClientReleaseCanAutoUpdate(item) {
continue
}
if currentVersion != "" && item.Version == currentVersion {
continue
}
if _, exists := item.Artifacts[platformKey]; !exists {
continue
}
sum := sha256.Sum256([]byte(principal.Device.ID + ":" + item.Version))
bucket := int(sum[0]) * 100 / 256
if bucket >= item.RolloutPercent {
continue
}
renderJSON(writer, http.StatusOK, map[string]any{"updateAvailable": true, "release": item, "platformKey": platformKey})
return
}
renderJSON(writer, http.StatusOK, map[string]any{"updateAvailable": false})
}