.gitignore

@@ -14,4 +14,4 @@ erl_crash.dump
 /config/*.secret.exs
 .elixir_ls/
 
-persist
+### Elixir Patch ###

lib/todo/cache.ex

@@ -1,25 +1,32 @@
 defmodule Todo.Cache do
-  use DynamicSupervisor
+  use GenServer
 
-  def start_link(init_arg) do
-    IO.puts("Starting #{__MODULE__}")
-
-    DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
+  @impl GenServer
+  def init(_init_args) do
+    Todo.Database.start()
+    {:ok, %{}}
   end
 
-  @impl DynamicSupervisor
-  def init(_) do
-    DynamicSupervisor.init(strategy: :one_for_one)
-  end
+  @impl GenServer
+  def handle_call({:server_process, name}, _from, state) do
+    case Map.fetch(state, name) do
+      {:ok, process} ->
+        {:reply, process, state}
 
-  def server_process(todo_list_name) do
-    case start_child(todo_list_name) do
-      {:ok, pid} -> pid
-      {:error, {:already_started, pid}} -> pid
+      :error ->
+        {:ok, new_process} = Todo.Server.start(name)
+
+        new_state = Map.put(state, name, new_process)
+
+        {:reply, new_process, new_state}
     end
   end
 
-  defp start_child(todo_list_name) do
-    DynamicSupervisor.start_child(__MODULE__, {Todo.Server, todo_list_name})
+  def start() do
+    GenServer.start(__MODULE__, nil)
+  end
+
+  def server_process(pid, name) do
+    GenServer.call(pid, {:server_process, name})
   end
 end

lib/todo/database.ex

@@ -1,50 +1,67 @@
 defmodule Todo.Database do
-  use Supervisor
+  alias Todo.DatabaseWorker
+  use GenServer
 
   @db_folder "./persist"
-  @pool_size 3
+  @num_of_workers 3
 
-  def start_link do
-    Supervisor.start_link(__MODULE__, nil)
-  end
-
-  @impl Supervisor
-  def init(_) do
-    IO.puts("Starting #{__MODULE__}.")
-
-    File.mkdir_p!(@db_folder)
-
-    children = Enum.map(1..@pool_size, &worker_spec/1)
-
-    Supervisor.init(children, strategy: :one_for_one)
-  end
-
-  defp worker_spec(worker_id) do
-    default_worker_spec = {Todo.DatabaseWorker, {@db_folder, worker_id}}
-    Supervisor.child_spec(default_worker_spec, id: worker_id)
-  end
-
-  def child_spec(_) do
-    %{
-      id: __MODULE__,
-      start: {__MODULE__, :start_link, []},
-      type: :supervisor
-    }
+  def start do
+    GenServer.start(__MODULE__, nil, name: __MODULE__)
   end
 
   def store(key, data) do
-    key
-    |> choose_worker()
-    |> Todo.DatabaseWorker.store(key, data)
+    GenServer.cast(__MODULE__, {:store, key, data})
   end
 
   def get(key) do
-    key
-    |> choose_worker()
-    |> Todo.DatabaseWorker.get(key)
+    GenServer.call(__MODULE__, {:get, key})
   end
 
-  defp choose_worker(key) do
-    :erlang.phash2(key, @pool_size) + 1
+  @impl GenServer
+  def init(_) do
+    File.mkdir_p!(@db_folder)
+
+    {:ok, nil, {:continue, :init}}
+  end
+
+  @impl GenServer
+  def handle_continue(:init, nil) do
+    File.mkdir_p!(@db_folder)
+
+    workers =
+      0..(@num_of_workers - 1)
+      |> Enum.map(fn i ->
+        {:ok, pid} = Todo.DatabaseWorker.start(@db_folder)
+        {i, pid}
+      end)
+      |> Map.new()
+
+    IO.inspect(workers)
+    {:noreply, workers}
+  end
+
+  @impl GenServer
+  def handle_cast({:store, key, data}, workers) do
+    workers
+    |> get_worker(key)
+    |> DatabaseWorker.store(key, data)
+
+    {:noreply, workers}
+  end
+
+  @impl GenServer
+  def handle_call({:get, key}, _, workers) do
+    data =
+      workers
+      |> get_worker(key)
+      |> DatabaseWorker.get(key)
+
+    {:reply, data, workers}
+  end
+
+  defp choose_worker(workers, key) do
+    id = :erlang.phash2(key, @num_of_workers)
+
+    Map.fetch!(workers, id)
   end
 end

lib/todo/database_worker.ex

@@ -1,57 +1,48 @@
 defmodule Todo.DatabaseWorker do
   use GenServer
 
-  def start_link({_db_folder, worker_id} = state) do
-    GenServer.start_link(__MODULE__, state, name: via_tuple(worker_id))
+  def start(db_folder) do
+    GenServer.start(__MODULE__, db_folder)
   end
 
-  def store(worker_id, key, data) do
-    worker_id
-    |> via_tuple()
-    |> GenServer.cast({:store, key, data})
+  def store(pid, key, data) do
+    GenServer.cast(pid, {:store, key, data})
   end
 
-  def get(worker_id, key) do
-    worker_id
-    |> via_tuple()
-    |> GenServer.call({:get, key})
-  end
-
-  defp via_tuple(worker_id) do
-    Todo.ProcessRegistry.via_tuple({__MODULE__, worker_id})
+  def get(pid, key) do
+    GenServer.call(pid, {:get, key})
   end
 
   @impl GenServer
-  def init({db_folder, worker_id} = state) do
-    IO.puts("Starting #{__MODULE__} #{worker_id} with db folder #{db_folder}.")
-
-    {:ok, state}
+  def init(db_folder) do
+    {:ok, db_folder}
   end
 
   @impl GenServer
-  def handle_cast({:store, key, data}, {db_folder, _worker_id} = state) do
+  def handle_cast({:store, key, data}, db_folder) do
     {db_folder, key}
     |> file_name()
     |> File.write!(:erlang.term_to_binary(data))
 
-    {:noreply, state}
+    {:noreply, db_folder}
   end
 
   @impl GenServer
-  def handle_call({:get, key}, _, {db_folder, _worker_id} = state) do
+  def handle_call({:get, key}, _, db_folder) do
     data =
       case File.read(file_name({db_folder, key})) do
         {:ok, contents} ->
           :erlang.binary_to_term(contents)
 
-        {:error, :enoent} ->
+        _ ->
           nil
       end
 
-    {:reply, data, state}
+    {:reply, data, db_folder}
   end
 
   def file_name({db_folder, key}) do
     Path.join(db_folder, to_string(key))
   end
+
 end

lib/todo/process_registry.ex

@@ -1,18 +0,0 @@
-defmodule Todo.ProcessRegistry do
-  def start_link do
-    IO.puts("Starting #{__MODULE__}.")
-    Registry.start_link(keys: :unique, name: __MODULE__)
-  end
-
-  def via_tuple(key) do
-    {:via, Registry, {__MODULE__, key}}
-  end
-
-  def child_spec(_) do
-    Supervisor.child_spec(
-      Registry,
-      id: __MODULE__,
-      start: {__MODULE__, :start_link, []}
-    )
-  end
-end

lib/todo/server.ex

@@ -1,12 +1,8 @@
 defmodule Todo.Server do
-  use GenServer, restart: :temporary
+  use GenServer
 
-  def start_link(name) do
-    GenServer.start_link(__MODULE__, name, name: via_tuple(name))
-  end
-
-  def via_tuple(name) do
-    Todo.ProcessRegistry.via_tuple({__MODULE__, name})
+  def start(name) do
+    GenServer.start(__MODULE__, name)
   end
 
   def add(pid, entry) do
@@ -27,8 +23,6 @@ defmodule Todo.Server do
 
   @impl GenServer
   def init(name) do
-    IO.puts("Starting #{__MODULE__} for #{name}.")
-
     {:ok, {name, nil}, {:continue, :init}}
   end
 

lib/todo/system.ex

@@ -1,19 +0,0 @@
-defmodule Todo.System do
-  use Supervisor
-
-  def start_link do
-    Supervisor.start_link(__MODULE__, nil)
-  end
-
-  @impl Supervisor
-  def init(_) do
-    Supervisor.init(
-      [
-        Todo.ProcessRegistry,
-        Todo.Database,
-        Todo.Cache
-      ],
-      strategy: :one_for_one
-    )
-  end
-end