Refactor modules into contexts (#78)

* [WIP] break out a few contexts, start refactoring fast index modules

* [WIP] more contexts, this time around slow indexing and downloads

* [WIP] got all tests passing

* [WIP] Added moduledocs

* Built a genserver to rename old jobs on boot

* Added a module naming check; moved things around

* Fixed specs

lib/pinchflat/boot/data_backfill_worker.ex

@@ -0,0 +1,75 @@
+defmodule Pinchflat.Boot.DataBackfillWorker do
+  @moduledoc false
+
+  use Oban.Worker,
+    queue: :media_local_metadata,
+    unique: [period: :infinity, states: [:available, :scheduled, :retryable]],
+    tags: ["media_item", "media_metadata", "local_metadata", "data_backfill"]
+
+  # This one is going to be a little more self-contained
+  # instead of relying on outside modules for the methods.
+  # That's because, for now, these methods are not intended
+  # to be used elsewhere.
+  #
+  # I'm just trying out that pattern and seeing if I like it better
+  # so this may change.
+  import Ecto.Query, warn: false
+  require Logger
+
+  alias __MODULE__
+  alias Pinchflat.Repo
+  alias Pinchflat.Media.MediaItem
+
+  @doc """
+  Cancels all pending backfill jobs. Useful for ensuring worker runs immediately
+  on app boot.
+
+  Returns {:ok, integer()}
+  """
+  def cancel_pending_backfill_jobs do
+    Oban.Job
+    |> where(worker: "Pinchflat.Boot.DataBackfillWorker")
+    |> Oban.cancel_all_jobs()
+  end
+
+  @impl Oban.Worker
+  @doc """
+  Performs one-off tasks to get data in the right shape.
+  This can be needed when we add new features or change the way
+  we store data. Must be idempotent. All new data should already
+  conform to the expected schema so this should only be needed
+  for existing data. Still runs periodically to be safe.
+
+  Returns :ok
+  """
+  def perform(%Oban.Job{}) do
+    Logger.info("Running data backfill worker")
+    backfill_shorts_data()
+
+    reschedule_backfill()
+
+    :ok
+  end
+
+  defp backfill_shorts_data do
+    query =
+      from(
+        m in MediaItem,
+        where: fragment("? like ?", m.original_url, "%/shorts/%"),
+        where: m.short_form_content == false
+      )
+
+    {count, _} = Repo.update_all(query, set: [short_form_content: true])
+
+    Logger.info("Backfill worker set short_form_content to true for #{count} media items.")
+  end
+
+  defp reschedule_backfill do
+    # Run hourly
+    next_run_in = 60 * 60
+
+    %{}
+    |> DataBackfillWorker.new(schedule_in: next_run_in)
+    |> Repo.insert_unique_job()
+  end
+end

lib/pinchflat/boot/post_job_startup_tasks.ex

@@ -0,0 +1,44 @@
+defmodule Pinchflat.Boot.PostJobStartupTasks do
+  @moduledoc """
+  This module is responsible for running startup tasks on app boot
+  AFTER the job runner has initiallized.
+
+  It's a GenServer because that plays REALLY nicely with the existing
+  Phoenix supervision tree.
+  """
+
+  # restart: :temporary means that this process will never be restarted (ie: will run once and then die)
+  use GenServer, restart: :temporary
+  import Ecto.Query, warn: false
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Boot.DataBackfillWorker
+
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, %{}, opts)
+  end
+
+  @doc """
+  Runs application startup tasks.
+
+  Any code defined here will run every time the application starts. You must
+  make sure that the code is idempotent and safe to run multiple times.
+
+  This is a good place to set up default settings, create initial records, stuff like that.
+  Should be fast - anything with the potential to be slow should be kicked off as a job instead.
+  """
+  @impl true
+  def init(state) do
+    enqueue_backfill_worker()
+
+    {:ok, state}
+  end
+
+  defp enqueue_backfill_worker do
+    DataBackfillWorker.cancel_pending_backfill_jobs()
+
+    %{}
+    |> DataBackfillWorker.new()
+    |> Repo.insert_unique_job()
+  end
+end

lib/pinchflat/boot/pre_job_startup_tasks.ex

@@ -0,0 +1,73 @@
+defmodule Pinchflat.Boot.PreJobStartupTasks do
+  @moduledoc """
+  This module is responsible for running startup tasks on app boot
+  BEFORE the job runner has initiallized.
+
+  It's a GenServer because that plays REALLY nicely with the existing
+  Phoenix supervision tree.
+  """
+
+  # restart: :temporary means that this process will never be restarted (ie: will run once and then die)
+  use GenServer, restart: :temporary
+  import Ecto.Query, warn: false
+  require Logger
+
+  alias Pinchflat.Repo
+  alias Pinchflat.Settings
+
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, %{}, opts)
+  end
+
+  @doc """
+  Runs application startup tasks.
+
+  Any code defined here will run every time the application starts. You must
+  make sure that the code is idempotent and safe to run multiple times.
+
+  This is a good place to set up default settings, create initial records, stuff like that.
+  Should be fast - anything with the potential to be slow should be kicked off as a job instead.
+  """
+  @impl true
+  def init(state) do
+    apply_default_settings()
+    rename_old_job_workers()
+
+    {:ok, state}
+  end
+
+  defp apply_default_settings do
+    Settings.fetch!(:onboarding, true)
+    Settings.fetch!(:pro_enabled, false)
+  end
+
+  # As part of a large refactor, I ended up moving a bunch of workers around. This
+  # is a problem because the workers are stored in the database and the runner
+  # will try to run the OLD jobs. This is also why these tasks run before the job
+  # runner starts up.
+  #
+  # Can be removed after a few months (created: 2024-03-12)
+  defp rename_old_job_workers do
+    # [ [old_name, new_name], ...]
+    rename_map = [
+      ["Pinchflat.Workers.MediaIndexingWorker", "Pinchflat.FastIndexing.MediaIndexingWorker"],
+      ["Pinchflat.Workers.MediaDownloadWorker", "Pinchflat.Downloading.MediaDownloadWorker"],
+      ["Pinchflat.Workers.FilesystemDataWorker", "Pinchflat.Filesystem.FilesystemDataWorker"],
+      ["Pinchflat.Workers.FastIndexingWorker", "Pinchflat.FastIndexing.FastIndexingWorker"],
+      ["Pinchflat.Workers.MediaCollectionIndexingWorker", "Pinchflat.SlowIndexing.MediaCollectionIndexingWorker"],
+      ["Pinchflat.Workers.DataBackfillWorker", "Pinchflat.Boot.DataBackfillWorker"]
+    ]
+
+    jobs_renamed =
+      Enum.reduce(rename_map, 0, fn [old_name, new_name], acc ->
+        {count, _} =
+          Oban.Job
+          |> where(worker: ^old_name)
+          |> Repo.update_all(set: [worker: new_name])
+
+        acc + count
+      end)
+
+    Logger.info("Renamed #{jobs_renamed} old job workers")
+  end
+end