Compare commits

..

No commits in common. "7ba3b1cd4fa63d719db9a60792871b10679c8cfb" and "1550e896a072869fdd966d511ebc68d1b408ae50" have entirely different histories.

8 changed files with 93 additions and 121 deletions

2
.gitignore vendored
View File

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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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

BIN
persist/a Normal file

Binary file not shown.