Apply comment suggestion

Author: Gawor270

lib/ex_webrtc_recorder.ex

@@ -320,14 +320,13 @@ defmodule ExWebRTC.Recorder do
       end)
 
     manifest_diff = to_manifest(state.track_data, track_ids)
-    files_to_upload = Map.put(manifest_diff, "manifest_file", %{location: state.manifest_path})
 
     case state.upload_handler do
       nil ->
         {manifest_diff, nil, state}
 
       handler ->
-        {ref, handler} = S3.UploadHandler.spawn_task(handler, files_to_upload)
+        {ref, handler} = S3.UploadHandler.spawn_task(handler, manifest_diff)
 
         {manifest_diff, ref, %{state | upload_handler: handler}}
     end

lib/ex_webrtc_recorder/s3/upload_handler.ex

@@ -40,27 +40,37 @@ if Code.ensure_loaded?(ExAws.S3) do
     def spawn_task(
           %__MODULE__{bucket_name: bucket_name, s3_config_overrides: s3_config_overrides} =
             handler,
-          files_to_upload
+          manifest
         ) do
       s3_paths =
-        Map.new(files_to_upload, fn {id, %{location: path}} ->
+        Map.new(manifest, fn {id, %{location: path}} ->
           s3_path = path |> Path.basename() |> then(&Path.join(handler.base_path, &1))
 
           {id, s3_path}
         end)
 
       download_manifest =
-        Map.new(files_to_upload, fn {id, object_data} ->
+        Map.new(manifest, fn {id, object_data} ->
           {:ok, location} = Recorder.S3.Utils.to_url(bucket_name, s3_paths[id])
 
           {id, %{object_data | location: location}}
         end)
 
+      manifest_s3_path =
+        Path.join(handler.base_path, "manifest.json")
+
+      Recorder.S3.Utils.upload_manifest(
+        download_manifest,
+        bucket_name,
+        manifest_s3_path,
+        s3_config_overrides
+      )
+
       # FIXME: this links, ideally we should use `async_nolink` instead
       #        but this may require a slight change of the current UploadHandler logic
       task =
         Task.Supervisor.async(ExWebRTC.Recorder.TaskSupervisor, fn ->
-          upload(files_to_upload, bucket_name, s3_paths, s3_config_overrides)
+          upload(manifest, bucket_name, s3_paths, s3_config_overrides)
         end)
 
       {task.ref,
@@ -95,8 +105,8 @@ if Code.ensure_loaded?(ExAws.S3) do
       {result, manifest, %__MODULE__{handler | tasks: tasks}}
     end
 
-    defp upload(files_to_upload, bucket_name, s3_paths, s3_config_overrides) do
-      Map.new(files_to_upload, fn {id, %{location: path}} ->
+    defp upload(manifest, bucket_name, s3_paths, s3_config_overrides) do
+      Map.new(manifest, fn {id, %{location: path}} ->
         %{^id => s3_path} = s3_paths
         Logger.debug("Uploading `#{path}` to bucket `#{bucket_name}`, path `#{s3_path}`")
 

lib/ex_webrtc_recorder/s3/utils.ex

@@ -10,6 +10,18 @@ if Code.ensure_loaded?(ExAws.S3) do
       |> ExAws.request(s3_config)
     end
 
+    @chunk_size 5 * 1024 * 1024
+
+    @spec upload_manifest(Manifest.t(), String.t(), String.t(), keyword()) ::
+            {:ok | :error, term()}
+    def upload_manifest(manifest, s3_bucket_name, s3_path, s3_config \\ []) do
+      manifest
+      |> Jason.encode!()
+      |> ExWebRTC.Utils.chunk(@chunk_size)
+      |> ExAws.S3.upload(s3_bucket_name, s3_path)
+      |> ExAws.request(s3_config)
+    end
+
     @spec fetch_file(String.t(), String.t(), Path.t(), keyword()) :: {:ok | :error, term()}
     def fetch_file(s3_bucket_name, s3_path, output_path, s3_config \\ []) do
       ExAws.S3.download_file(s3_bucket_name, s3_path, output_path)
@@ -67,6 +79,7 @@ else
     @moduledoc false
 
     def upload_file(_, _, _, _ \\ nil), do: error()
+    def upload_manifest(_, _, _, _ \\ nil), do: error()
     def fetch_file(_, _, _, _ \\ nil), do: error()
     def to_url(_, _), do: error()
     def parse_url(_), do: error()