Cache the versions and sort date chronologically

Author: louiscb

lib/remote_persistent_term.ex

@@ -281,9 +281,9 @@ defmodule RemotePersistentTerm do
       start_meta,
       fn ->
         {status, version} =
-          with {:ok, current_version} <- state.fetcher_mod.current_version(state.fetcher_state),
+          with {:ok, current_version, updated_fetcher_state} <- state.fetcher_mod.current_version(state.fetcher_state),
                true <- state.current_version != current_version,
-               :ok <- download_and_store_term(state, deserialize_fun, put_fun) do
+               :ok <- download_and_store_term(%{state | fetcher_state: updated_fetcher_state}, deserialize_fun, put_fun) do
             {:updated, current_version}
           else
             false ->

lib/remote_persistent_term/fetcher.ex

@@ -20,7 +20,7 @@ defmodule RemotePersistentTerm.Fetcher do
   Check the current version of the remote term. Used to avoid downloading the
   same term multiple times.
   """
-  @callback current_version(state()) :: {:ok, version()} | {:error, term()}
+  @callback current_version(state()) :: {:ok, version(), state()} | {:error, term()}
 
   @doc """
   Download the term from the remote source.

lib/remote_persistent_term/fetcher/http.ex

@@ -66,8 +66,8 @@ defmodule RemotePersistentTerm.Fetcher.Http do
   end
 
   @impl true
-  def current_version(_state) do
-    {:ok, DateTime.utc_now() |> DateTime.to_string()}
+  def current_version(state) do
+    {:ok, DateTime.utc_now() |> DateTime.to_string(), state}
   end
 
   @impl true

lib/remote_persistent_term/fetcher/s3.ex

@@ -15,9 +15,10 @@ defmodule RemotePersistentTerm.Fetcher.S3 do
           key: String.t(),
           region: region,
           failover_buckets: [failover_bucket] | nil,
-          version_id: String.t() | nil
+          version_id: String.t() | nil,
+          versions: [map()] | nil
         }
-  defstruct [:bucket, :key, :region, :failover_buckets, :version_id]
+  defstruct [:bucket, :key, :region, :failover_buckets, :version_id, :versions]
 
   @failover_bucket_schema [
     bucket: [
@@ -92,7 +93,7 @@ defmodule RemotePersistentTerm.Fetcher.S3 do
         message: "Found latest version of object"
       )
 
-      {:ok, etag}
+      {:ok, etag, %{state | versions: versions}}
     else
       {:error, {:unexpected_response, %{body: reason}}} ->
         {:error, reason}
@@ -176,9 +177,11 @@ defmodule RemotePersistentTerm.Fetcher.S3 do
       version_id: state.version_id
     )
 
-    with {:ok, versions} <- list_object_versions(state),
+    versions = if state.versions, do: {:ok, state.versions}, else: list_object_versions(state)
+
+    with {:ok, versions} <- versions,
          {:ok, previous_version} <- find_previous_version(versions, state.version_id) do
-      {:ok, %{state | version_id: previous_version.version_id}}
+      {:ok, %{state | version_id: previous_version.version_id, versions: versions}}
     else
       {:error, reason} ->
         Logger.error(%{
@@ -194,13 +197,7 @@ defmodule RemotePersistentTerm.Fetcher.S3 do
 
   defp find_previous_version(versions, current_version_id) do
     versions
-    |> Enum.sort_by(
-      fn version ->
-        {:ok, datetime, _} = DateTime.from_iso8601(version.last_modified)
-        datetime
-      end,
-      {:desc, DateTime}
-    )
+    |> Enum.sort_by(& &1.last_modified, :desc)
     |> Enum.find(fn version ->
       version.version_id != current_version_id
     end)

lib/remote_persistent_term/fetcher/static.ex

@@ -22,10 +22,10 @@ defmodule RemotePersistentTerm.Fetcher.Static do
       def init(_), do: {:ok, []}
 
       @impl true
-      def current_version(_), do: {:ok, unquote(Keyword.get(opts, :version, "1"))}
+      def current_version(state), do: {:ok, unquote(Keyword.get(opts, :version, "1")), state}
 
       @impl true
-      def download(_), do: {:ok, unquote(Macro.escape(Keyword.fetch!(opts, :data)))}
+      def download(state), do: {:ok, unquote(Macro.escape(Keyword.fetch!(opts, :data)))}
 
       @impl true
       def previous_version(_), do: {:error, :no_previous_version}

test/remote_persistent_term/fetcher/s3_test.exs

@@ -99,7 +99,7 @@ defmodule RemotePersistentTerm.Fetcher.S3Test do
       log =
         capture_log(fn ->
           result = S3.current_version(state)
-          assert {:ok, "current-etag"} = result
+          assert {:ok, "current-etag", _updated_state} = result
         end)
 
       assert log =~ "bucket: \"#{@bucket}\""