1 files changed, 25 insertions, 115 deletions

diff --git a/receivepack/internal/service/execute.go b/receivepack/internal/service/execute.go
index 8febfc79..14468799 100644
--- a/receivepack/internal/service/execute.go
+++ b/receivepack/internal/service/execute.go
@@ -3,8 +3,6 @@ package service
 import (
 	"context"
 	"os"
-
-	"codeberg.org/lindenii/furgit/format/pack/ingest"
 )
 
 // Execute validates one receive-pack request, optionally ingests its pack into
@@ -13,68 +11,23 @@ func (service *Service) Execute(ctx context.Context, req *Request) (*Result, err
 	result := &Result{
 		Commands: make([]CommandResult, 0, len(req.Commands)),
 	}
+
 	var (
 		quarantineName string
 		quarantineRoot *os.Root
 		err            error
 	)
 
-	if req.PackExpected {
-		if req.Pack == nil {
-			result.UnpackError = "missing pack stream"
-			fillCommandErrors(result, req.Commands, "missing pack stream")
-
-			return result, nil
-		}
-
-		if service.opts.ObjectsRoot == nil {
-			result.UnpackError = "objects root not configured"
-			fillCommandErrors(result, req.Commands, "objects root not configured")
-
-			return result, nil
-		}
-
-		quarantineName, quarantineRoot, err = service.createQuarantineRoot()
-		if err != nil {
-			result.UnpackError = err.Error()
-			fillCommandErrors(result, req.Commands, err.Error())
-
-			return result, nil
-		}
+	quarantineName, quarantineRoot, ok := service.ingestQuarantine(result, req.Commands, req)
+	if !ok {
+		return result, nil
+	}
 
+	if quarantineRoot != nil {
 		defer func() {
 			_ = quarantineRoot.Close()
 			_ = service.opts.ObjectsRoot.RemoveAll(quarantineName)
 		}()
-
-		quarantinePackRoot, err := service.openQuarantinePackRoot(quarantineRoot)
-		if err != nil {
-			result.UnpackError = err.Error()
-			fillCommandErrors(result, req.Commands, err.Error())
-
-			return result, nil
-		}
-
-		defer func() {
-			_ = quarantinePackRoot.Close()
-		}()
-
-		ingested, err := ingest.Ingest(
-			req.Pack,
-			quarantinePackRoot,
-			service.opts.Algorithm,
-			true,
-			true,
-			service.opts.ExistingObjects,
-		)
-		if err != nil {
-			result.UnpackError = err.Error()
-			fillCommandErrors(result, req.Commands, err.Error())
-
-			return result, nil
-		}
-
-		result.Ingest = &ingested
 	}
 
 	for _, command := range req.Commands {
@@ -90,75 +43,30 @@ func (service *Service) Execute(ctx context.Context, req *Request) (*Result, err
 		return result, nil
 	}
 
-	allowedCommands := append([]Command(nil), req.Commands...)
-	allowedIndices := make([]int, 0, len(req.Commands))
-	for index := range req.Commands {
-		allowedIndices = append(allowedIndices, index)
-	}
-	rejected := make(map[int]string)
-
-	if service.opts.Hook != nil {
-		quarantinedObjects, err := service.openQuarantinedObjects(quarantineName)
-		if err != nil {
-			fillCommandErrors(result, req.Commands, err.Error())
-
-			return result, nil
-		}
-
-		defer func() {
-			_ = quarantinedObjects.Close()
-		}()
-
-		decisions, err := service.opts.Hook(ctx, HookRequest{
-			Refs:               service.opts.Refs,
-			ExistingObjects:    service.opts.ExistingObjects,
-			QuarantinedObjects: quarantinedObjects,
-			Updates:            buildHookUpdates(req.Commands),
-			PushOptions:        append([]string(nil), req.PushOptions...),
-		})
-		if err != nil {
-			fillCommandErrors(result, req.Commands, err.Error())
-
-			return result, nil
-		}
-
-		if len(decisions) != len(req.Commands) {
-			fillCommandErrors(result, req.Commands, "hook returned wrong number of update decisions")
-
-			return result, nil
-		}
-
-		allowedCommands = allowedCommands[:0]
-		allowedIndices = allowedIndices[:0]
-		for index, decision := range decisions {
-			if decision.Accept {
-				allowedCommands = append(allowedCommands, req.Commands[index])
-				allowedIndices = append(allowedIndices, index)
+	allowedCommands, allowedIndices, rejected, ok, errText := service.runHook(
+		ctx,
+		req,
+		req.Commands,
+		quarantineName,
+	)
+	if !ok {
+		fillCommandErrors(result, req.Commands, errText)
 
-				continue
-			}
+		return result, nil
+	}
 
-			message := decision.Message
+	if req.Atomic && len(rejected) != 0 {
+		result.Commands = make([]CommandResult, 0, len(req.Commands))
+		for index, command := range req.Commands {
+			message := rejected[index]
 			if message == "" {
-				message = "rejected by hook"
+				message = "atomic push rejected by hook"
 			}
 
-			rejected[index] = message
+			result.Commands = append(result.Commands, resultForHookRejection(command, message))
 		}
 
-		if req.Atomic && len(rejected) != 0 {
-			result.Commands = make([]CommandResult, 0, len(req.Commands))
-			for index, command := range req.Commands {
-				message := rejected[index]
-				if message == "" {
-					message = "atomic push rejected by hook"
-				}
-
-				result.Commands = append(result.Commands, resultForHookRejection(command, message))
-			}
-
-			return result, nil
-		}
+		return result, nil
 	}
 
 	if len(allowedCommands) == 0 {
@@ -181,6 +89,7 @@ func (service *Service) Execute(ctx context.Context, req *Request) (*Result, err
 
 	if req.Atomic {
 		subresult := &Result{}
+
 		err := service.applyAtomic(subresult, allowedCommands)
 		if err != nil {
 			return result, err
@@ -193,6 +102,7 @@ func (service *Service) Execute(ctx context.Context, req *Request) (*Result, err
 	}
 
 	subresult := &Result{}
+
 	err = service.applyBatch(subresult, allowedCommands)
 	if err != nil {
 		return result, err