Add bulk retry by failure code

Author: mjc

lib/reencodarr/media.ex

@@ -1105,6 +1105,84 @@ defmodule Reencodarr.Media do
     end
   end
 
+  @doc """
+  Lists distinct unresolved failure codes for videos currently in the failed state.
+
+  Intended for operator bulk-retry actions in the failures UI.
+  """
+  @spec list_failed_video_failure_codes(non_neg_integer()) :: [
+          %{code: String.t(), count: integer()}
+        ]
+  def list_failed_video_failure_codes(limit \\ 12) do
+    from(v in Video,
+      join: f in VideoFailure,
+      on: f.video_id == v.id,
+      where: v.state == :failed and f.resolved == false and not is_nil(f.failure_code),
+      group_by: f.failure_code,
+      order_by: [desc: count(f.id), asc: f.failure_code],
+      limit: ^limit,
+      select: %{code: f.failure_code, count: count(f.id)}
+    )
+    |> Repo.all()
+  end
+
+  @doc """
+  Retries failed videos whose unresolved failures include the given failure code.
+
+  Videos are moved back to `:needs_analysis`, their bitrate is cleared to force
+  re-analysis, and all unresolved failure records for those videos are resolved.
+  """
+  @spec retry_failed_videos_by_failure_code(String.t()) :: %{
+          videos_retried: integer(),
+          failures_resolved: integer()
+        }
+  def retry_failed_videos_by_failure_code(failure_code) when is_binary(failure_code) do
+    trimmed_code = String.trim(failure_code)
+
+    if trimmed_code == "" do
+      %{videos_retried: 0, failures_resolved: 0}
+    else
+      write_transaction(
+        fn ->
+          video_ids =
+            from(v in Video,
+              join: f in VideoFailure,
+              on: f.video_id == v.id,
+              where:
+                v.state == :failed and f.resolved == false and f.failure_code == ^trimmed_code,
+              group_by: v.id,
+              order_by: [asc: v.id],
+              select: v.id
+            )
+            |> Repo.all()
+
+          videos_retried_count = length(video_ids)
+
+          now = DateTime.utc_now()
+
+          {failures_resolved_count, _} =
+            from(f in VideoFailure,
+              where: f.video_id in ^video_ids and f.resolved == false
+            )
+            |> Repo.update_all(set: [resolved: true, resolved_at: now])
+
+          from(v in Video, where: v.id in ^video_ids)
+          |> Repo.update_all(set: [state: :needs_analysis, bitrate: nil, updated_at: now])
+
+          %{
+            videos_retried: videos_retried_count,
+            failures_resolved: failures_resolved_count
+          }
+        end,
+        label: :media_retry_failed_videos_by_failure_code
+      )
+      |> case do
+        {:ok, result} -> result
+        {:error, _reason} -> %{videos_retried: 0, failures_resolved: 0}
+      end
+    end
+  end
+
   # Consolidated shared logic for video deletion
   defp delete_videos_by_ids(video_ids) do
     deleted_videos = fetch_dashboard_video_snapshots_by_ids(video_ids)

lib/reencodarr_web/live/failures_live.ex

@@ -108,6 +108,20 @@ defmodule ReencodarrWeb.FailuresLive do
     {:noreply, put_flash(socket, :info, "All failed videos have been reset")}
   end
 
+  @impl true
+  def handle_event("retry_failure_code", %{"code" => failure_code}, socket) do
+    result = Media.retry_failed_videos_by_failure_code(failure_code)
+
+    socket = load_failures_data(socket)
+
+    {:noreply,
+     put_flash(
+       socket,
+       :info,
+       "Queued retry for #{result.videos_retried} failed videos with #{failure_code}"
+     )}
+  end
+
   @impl true
   def handle_event("toggle_details", %{"video_id" => video_id}, socket) do
     video_id = Parsers.parse_int(video_id)
@@ -392,6 +406,33 @@ defmodule ReencodarrWeb.FailuresLive do
               </div>
             </div>
           </div>
+
+          <%= if @failure_code_actions != [] do %>
+            <div class="bg-gray-800 rounded-lg shadow-lg p-4 border border-gray-700">
+              <div class="flex flex-col gap-3">
+                <div>
+                  <h2 class="text-sm font-semibold text-white">Retry By Error Code</h2>
+                  <p class="text-xs text-gray-400">
+                    Retry all failed videos whose unresolved failures include the selected code by sending them back to analysis.
+                  </p>
+                </div>
+                <div class="flex flex-wrap gap-2">
+                  <%= for action <- @failure_code_actions do %>
+                    <button
+                      phx-click="retry_failure_code"
+                      phx-value-code={action.code}
+                      class="inline-flex items-center gap-2 rounded-lg border border-gray-600 bg-gray-750 px-3 py-2 text-xs font-medium text-gray-200 transition-colors hover:bg-gray-700"
+                    >
+                      <span>{action.code}</span>
+                      <span class="rounded bg-gray-900 px-1.5 py-0.5 text-[11px] text-gray-300">
+                        {action.count}
+                      </span>
+                    </button>
+                  <% end %>
+                </div>
+              </div>
+            </div>
+          <% end %>
           
     <!-- Failed Videos Table -->
           <div class="bg-gray-800 rounded-lg shadow-lg overflow-hidden border border-gray-700">
@@ -741,6 +782,7 @@ defmodule ReencodarrWeb.FailuresLive do
     |> assign(:video_failures, %{})
     |> assign(:failure_stats, %{recent_count: 0})
     |> assign(:failure_patterns, [])
+    |> assign(:failure_code_actions, [])
     |> assign(:total_count, 0)
     |> assign(:total_pages, 0)
   end
@@ -763,6 +805,7 @@ defmodule ReencodarrWeb.FailuresLive do
     # Get failure statistics and patterns
     failure_stats = Media.get_failure_statistics(days_back: 7)
     failure_patterns = Media.get_common_failure_patterns(5)
+    failure_code_actions = Media.list_failed_video_failure_codes()
 
     # Calculate pagination info
     total_pages = ceil(total_count / per_page)
@@ -773,6 +816,7 @@ defmodule ReencodarrWeb.FailuresLive do
     |> assign(:video_failures, video_failures)
     |> assign(:failure_stats, summarize_failure_stats(failure_stats))
     |> assign(:failure_patterns, failure_patterns)
+    |> assign(:failure_code_actions, failure_code_actions)
     |> assign(:total_count, total_count)
     |> assign(:total_pages, total_pages)
   end

test/reencodarr/media_test.exs

@@ -1173,6 +1173,70 @@ defmodule Reencodarr.MediaTest do
       assert reloaded1.state == :needs_analysis
       assert reloaded2.state == :needs_analysis
     end
+
+    test "list_failed_video_failure_codes/1 groups unresolved failure codes for failed videos" do
+      {:ok, exit_143} = Fixtures.video_fixture(%{state: :failed})
+      {:ok, timeout} = Fixtures.video_fixture(%{state: :failed})
+      {:ok, resolved_video} = Fixtures.video_fixture(%{state: :failed})
+
+      Media.record_video_failure(exit_143, :encoding, :resource_exhaustion,
+        code: "EXIT_143",
+        message: "Killed"
+      )
+
+      Media.record_video_failure(timeout, :encoding, :timeout,
+        code: "TIMEOUT",
+        message: "Timed out"
+      )
+
+      Media.record_video_failure(resolved_video, :encoding, :resource_exhaustion,
+        code: "EXIT_143",
+        message: "Should be excluded because it is resolved"
+      )
+
+      Media.resolve_video_failures(resolved_video.id)
+
+      assert Media.list_failed_video_failure_codes()
+             |> Enum.map(& &1.code) == ["EXIT_143", "TIMEOUT"]
+    end
+
+    test "retry_failed_videos_by_failure_code/1 retries matching failed videos only" do
+      {:ok, exit_143_a} = Fixtures.video_fixture(%{state: :failed, bitrate: 5_000_000})
+      {:ok, exit_143_b} = Fixtures.video_fixture(%{state: :failed, bitrate: 6_000_000})
+      {:ok, timeout} = Fixtures.video_fixture(%{state: :failed, bitrate: 7_000_000})
+
+      Media.record_video_failure(exit_143_a, :encoding, :resource_exhaustion,
+        code: "EXIT_143",
+        message: "Killed"
+      )
+
+      Media.record_video_failure(exit_143_b, :encoding, :resource_exhaustion,
+        code: "EXIT_143",
+        message: "Killed again"
+      )
+
+      Media.record_video_failure(timeout, :encoding, :timeout,
+        code: "TIMEOUT",
+        message: "Timed out"
+      )
+
+      result = Media.retry_failed_videos_by_failure_code("EXIT_143")
+
+      assert result.videos_retried == 2
+      assert result.failures_resolved == 2
+
+      assert Media.get_video!(exit_143_a.id).state == :needs_analysis
+      assert Media.get_video!(exit_143_b.id).state == :needs_analysis
+      assert Media.get_video!(timeout.id).state == :failed
+
+      assert Media.get_video!(exit_143_a.id).bitrate == nil
+      assert Media.get_video!(exit_143_b.id).bitrate == nil
+      assert Media.get_video!(timeout.id).bitrate == 7_000_000
+
+      assert Media.get_video_failures(exit_143_a.id) == []
+      assert Media.get_video_failures(exit_143_b.id) == []
+      assert length(Media.get_video_failures(timeout.id)) == 1
+    end
   end
 
   describe "test helpers" do

test/reencodarr_web/live/failures_live_test.exs

@@ -157,6 +157,42 @@ defmodule ReencodarrWeb.FailuresLiveTest do
     end
   end
 
+  describe "retry_failure_code event" do
+    test "renders retry-by-code actions and retries matching failures", %{conn: conn} do
+      {:ok, exit_143_video} =
+        Fixtures.video_fixture(%{path: "/media/exit_143_video.mkv", state: :failed})
+
+      {:ok, timeout_video} =
+        Fixtures.video_fixture(%{path: "/media/timeout_video.mkv", state: :failed})
+
+      Media.record_video_failure(exit_143_video, :encoding, :resource_exhaustion,
+        code: "EXIT_143",
+        message: "Killed"
+      )
+
+      Media.record_video_failure(timeout_video, :encoding, :timeout,
+        code: "TIMEOUT",
+        message: "Timed out"
+      )
+
+      {:ok, view, _} = live(conn, ~p"/failures")
+      html = loaded_html(view)
+
+      assert html =~ "Retry By Error Code"
+      assert html =~ "EXIT_143"
+      assert html =~ "TIMEOUT"
+
+      html =
+        view
+        |> element("button[phx-click='retry_failure_code'][phx-value-code='EXIT_143']")
+        |> render_click()
+
+      assert html =~ "Failures"
+      assert Media.get_video!(exit_143_video.id).state == :needs_analysis
+      assert Media.get_video!(timeout_video.id).state == :failed
+    end
+  end
+
   # ---------------------------------------------------------------------------
   # Row interactions (requires at least one failure in DB)
   # ---------------------------------------------------------------------------