Skip to content

Modern Docker Management, Designed for Everyone

7.8 KB
Raw Blame
package upload

import (
	"bytes"
	"context"
	"encoding/json/v2"
	"errors"
	"io"
	"log/slog"
	"net/http"
	"strings"

	"github.com/danielgtaylor/huma/v2"
	"github.com/danielgtaylor/huma/v2/adapters/humaecho"
	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/getarcaneapp/arcane/types/v2/upload"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil"
)

// UploadHandler provides the Huma-based chunked upload-session endpoints.
type UploadHandler struct {
	uploadService *UploadService
}

type CreateUploadSessionInput struct {
	EnvironmentID string `path:"id"`
	Kind          string `path:"kind" enum:"image,volume-backup,build-workspace"`
	Body          upload.CreateSessionRequest
}

type UploadChunkInput struct {
	EnvironmentID string `path:"id"`
	Kind          string `path:"kind" enum:"image,volume-backup,build-workspace"`
	UploadID      string `path:"uploadId"`
	Index         int    `path:"index"`
	RawBody       []byte `contentType:"application/octet-stream"`
}

type GetUploadSessionInput struct {
	EnvironmentID string `path:"id"`
	Kind          string `path:"kind" enum:"image,volume-backup,build-workspace"`
	UploadID      string `path:"uploadId"`
}

type DeleteUploadSessionInput struct {
	EnvironmentID string `path:"id"`
	Kind          string `path:"kind" enum:"image,volume-backup,build-workspace"`
	UploadID      string `path:"uploadId"`
}

// SessionHTTPError maps upload-session errors to HTTP errors for this package
// and the domain endpoints that consume sessions. It returns nil for errors
// that are not upload-session errors.
func SessionHTTPError(err error) error {
	switch {
	case errors.Is(err, common.ErrUploadSessionNotFound):
		return huma.Error404NotFound(err.Error())
	case errors.Is(err, common.ErrUploadSessionIncomplete):
		return huma.Error409Conflict(err.Error())
	case errors.Is(err, common.ErrUploadKindMismatch):
		return huma.Error400BadRequest(err.Error())
	case errors.Is(err, common.ErrUploadChunkInvalid), errors.Is(err, common.ErrUploadSessionInvalid):
		return huma.Error422UnprocessableEntity(err.Error())
	}
	return nil
}

// requireUploadPermissionInternal enforces the kind-derived permission for the
// target environment. Registration cannot use middleware.RegisterWithPermission
// because the required permission depends on the {kind} path parameter; the
// manager-side proxy applies the same mapping for remote environments.
func requireUploadPermissionInternal(ctx context.Context, kind, environmentID string) error {
	perm, known := authz.UploadKindPermission(kind)
	if !known {
		return huma.Error403Forbidden("permission denied: unknown upload kind " + kind)
	}
	ps, _ := middleware.PermissionsFromContext(ctx)
	if !ps.Allows(perm, environmentID) {
		return huma.Error403Forbidden("permission denied: " + perm)
	}
	return nil
}

func sessionResponseInternal(session *upload.Session) *handlerutil.Out[upload.Session] {
	return &handlerutil.Out[upload.Session]{
		Body: base.ApiResponse[upload.Session]{
			Success: true,
			Data:    *session,
		},
	}
}

func (h *UploadHandler) CreateSession(ctx context.Context, input *CreateUploadSessionInput) (*handlerutil.Out[upload.Session], error) {
	if err := requireUploadPermissionInternal(ctx, input.Kind, input.EnvironmentID); err != nil {
		return nil, err
	}
	session, err := h.uploadService.CreateSession(ctx, input.Kind, input.Body)
	if err != nil {
		if httpErr := SessionHTTPError(err); httpErr != nil {
			return nil, httpErr
		}
		return nil, huma.Error500InternalServerError(err.Error())
	}
	return sessionResponseInternal(session), nil
}

func (h *UploadHandler) UploadChunk(ctx context.Context, input *UploadChunkInput) (*handlerutil.Out[upload.Session], error) {
	if err := requireUploadPermissionInternal(ctx, input.Kind, input.EnvironmentID); err != nil {
		return nil, err
	}
	session, err := h.uploadService.WriteChunk(ctx, input.Kind, input.UploadID, input.Index, input.RawBody)
	if err != nil {
		if httpErr := SessionHTTPError(err); httpErr != nil {
			return nil, httpErr
		}
		return nil, huma.Error500InternalServerError(err.Error())
	}
	return sessionResponseInternal(session), nil
}

func (h *UploadHandler) GetSession(ctx context.Context, input *GetUploadSessionInput) (*handlerutil.Out[upload.Session], error) {
	if err := requireUploadPermissionInternal(ctx, input.Kind, input.EnvironmentID); err != nil {
		return nil, err
	}
	session, err := h.uploadService.GetSession(ctx, input.Kind, input.UploadID)
	if err != nil {
		if httpErr := SessionHTTPError(err); httpErr != nil {
			return nil, httpErr
		}
		return nil, huma.Error500InternalServerError(err.Error())
	}
	return sessionResponseInternal(session), nil
}

func (h *UploadHandler) DeleteSession(ctx context.Context, input *DeleteUploadSessionInput) (*handlerutil.Out[base.MessageResponse], error) {
	if err := requireUploadPermissionInternal(ctx, input.Kind, input.EnvironmentID); err != nil {
		return nil, err
	}
	if err := h.uploadService.DeleteSession(ctx, input.Kind, input.UploadID); err != nil {
		if httpErr := SessionHTTPError(err); httpErr != nil {
			return nil, httpErr
		}
		return nil, huma.Error500InternalServerError(err.Error())
	}
	return handlerutil.MessageOutput("Upload session deleted", ""), nil
}

// LegacyMultipartMiddleware converts a deprecated multipart/form-data request
// into a complete upload session and rewrites the request into the JSON
// {"uploadId"} form, so clients predating chunked uploads keep working. It
// runs after authentication (a huma global middleware) but before the
// operation's permission middleware, so it enforces the kind permission
// itself to avoid staging files for unauthorized callers.
//
// This compatibility path is deprecated for API consumers; delete this
// middleware when multipart upload support is removed.
func LegacyMultipartMiddleware(api huma.API, service *UploadService, kind string) huma.Middlewares {
	return huma.Middlewares{func(ctx huma.Context, next func(huma.Context)) {
		if !strings.HasPrefix(ctx.Header("Content-Type"), "multipart/form-data") {
			next(ctx)
			return
		}
		writeErr := func(status int, message string) {
			if err := huma.WriteErr(api, ctx, status, message); err != nil {
				slog.WarnContext(ctx.Context(), "failed to write legacy upload error response", "error", err)
			}
		}
		if err := requireUploadPermissionInternal(ctx.Context(), kind, authz.EnvIDFromPath(ctx.URL().Path)); err != nil {
			writeErr(http.StatusForbidden, "permission denied")
			return
		}

		request := humaecho.Unwrap(ctx).Request()
		if err := request.ParseMultipartForm(32 << 10); err != nil {
			writeErr(http.StatusBadRequest, "Invalid multipart form: "+err.Error())
			return
		}
		defer func() { _ = request.MultipartForm.RemoveAll() }()
		file, header, err := request.FormFile("file")
		if err != nil {
			writeErr(http.StatusBadRequest, "No file uploaded")
			return
		}
		defer func() { _ = file.Close() }()

		slog.WarnContext(ctx.Context(), "Deprecated multipart upload used; migrate to chunked upload sessions",
			"kind", kind, "path", ctx.URL().Path, "filename", header.Filename, "size", header.Size)

		session, err := service.IngestSession(ctx.Context(), kind, header.Filename, header.Size, file)
		if err != nil {
			if httpErr := SessionHTTPError(err); httpErr != nil {
				if statusErr, ok := errors.AsType[huma.StatusError](httpErr); ok {
					writeErr(statusErr.GetStatus(), statusErr.Error())
					return
				}
			}
			writeErr(http.StatusInternalServerError, err.Error())
			return
		}

		payload, err := json.Marshal(upload.ConsumeRequest{UploadID: session.ID})
		if err != nil {
			writeErr(http.StatusInternalServerError, err.Error())
			return
		}
		request.Body = io.NopCloser(bytes.NewReader(payload))
		request.ContentLength = int64(len(payload))
		request.Header.Set("Content-Type", "application/json")
		next(ctx)
	}}
}