Sulu 3.x: Configuring a maximum upload size for chunked media uploads

Answer the Question First

To cap the overall size of a chunked upload in Sulu 3.x you can add a custom configuration option, validate it in the upload controller, and abort the upload when the limit is exceeded. The bundle already fires a sulu_media.upload_chunk event for each chunk, so a listener can keep a running total and trigger MediaUploadManager::abortUpload($uploadId) when the configured maximum is reached. Cleanup of orphaned temporary files is handled by that abort method. For graceful cancellation and per request timeouts you can rely on Symfony 6’s Messenger component to schedule a delayed abort after a configurable threshold.

Step by Step Implementation

1. Add a custom config key

   // config/packages/sulu_media.yaml
   sulu_media:
       max_file_size: 104857600   # 100 MiB, adjust as needed
   

2. Inject the value into the upload controller

   // src/Controller/MediaUploadController.php
   public function __construct(private int $maxFileSize) {}
   
   public function upload(Request $request): JsonResponse
   {
       $uploadId = $request->request->get('uploadId');
       $chunkSize = $request->request->getInt('chunkSize');
       $totalSize = $request->request->getInt('totalSize');
   
       if ($totalSize > $this->maxFileSize) {
           throw new BadRequestHttpException('Upload exceeds maximum allowed size');
       }
       // ... existing chunk handling logic
   }

3. Register a listener for sulu_media.upload_chunk

   // src/EventListener/UploadChunkListener.php
   public function onUploadChunk(UploadChunkEvent $event): void
   {
       $uploadId = $event->getUploadId();
       $size = $event->getChunkSize();
       $total = $this->session->get("upload_{$uploadId}_total", 0) + $size;
       if ($total > $this->maxFileSize) {
           $this->mediaUploadManager->abortUpload($uploadId);
           throw new BadRequestHttpException('Upload aborted: size limit exceeded');
       }
       $this->session->set("upload_{$uploadId}_total", $total);
   }

4. Graceful cancellation route (optional)

   // src/Controller/MediaUploadController.php
   public function cancel(string $uploadId): JsonResponse
   {
       $this->mediaUploadManager->abortUpload($uploadId);
       return new JsonResponse(['status' => 'canceled']);
   }

5. Timeout via Messenger

   // config/services.yaml
   services:
       App\MessageHandler\UploadTimeoutHandler:
           tags:
               - { name: messenger.message_handler, on_error: 'retry' }
   
   // src/Message/UploadTimeout.php
   class UploadTimeout
   {
       public function __construct(private string $uploadId, private int $delaySeconds){ }
   }
   
   // src/MessageHandler/UploadTimeoutHandler.php
   public function __invoke(UploadTimeout $message): void
   {
       $this->mediaUploadManager->abortUpload($message->uploadId);
   }
   
   // In the upload controller, after receiving the first chunk
   $delay = 3600; // 1 hour
   $dispatcher->dispatch(new UploadTimeout($uploadId, $delay));
   

Verification Checklist

• Upload a file just below the configured limit – should succeed.
• Upload a file just above – should return 400 and trigger cleanup.
• Trigger the cancel route while a large file is in progress – the temp folder disappears.
• Measure a large upload exceeding the Messenger based timeout – the abort handler runs and the upload is removed.

Missing Diagnostic Detail

To fine tune the timeout strategy, could you share the typical maximum upload duration you expect in your environment? This will help decide whether a Messenger delay or PHP’s max_execution_time is more appropriate.

Key Takeaways

• Custom config + controller validation is the cleanest way to enforce a per file cap.
• Use the existing sulu_media.upload_chunk event to track cumulative size.
• Invoke MediaUploadManager::abortUpload() for immediate cleanup.
• Messenger based timeouts avoid killing the whole request and guarantee cleanup.