this repo has no description
Fix name/node order
+25
-22
+5
-5
lib/construct/scheduler.ex
+5
-5
lib/construct/scheduler.ex
···
248
248
249
249
case node == from_node do
250
250
true ->
251
-
case ProcRegistry.register(state.proc_registry, pid, node, name) do
251
+
case ProcRegistry.register(state.proc_registry, pid, name, node) do
252
252
:ok -> {:reply, :ok, state}
253
253
{:error, _error} -> {:reply, :error, state}
254
254
end
···
260
260
def handle_call({:whereis, from_pid, name}, _from, %State{} = state) do
261
261
{:ok, %ProcState{node: node}} = ProcStore.fetch_state(state.proc_store, from_pid)
262
262
263
-
case ProcRegistry.whereis(state.proc_registry, node, name) do
263
+
case ProcRegistry.whereis(state.proc_registry, name, node) do
264
264
{:ok, pid} -> {:reply, pid, state}
265
265
{:error, :not_found} -> {:reply, nil, state}
266
266
end
···
512
512
# TODO: for local names, send/2 actually raises if the name is not registered
513
513
name when is_atom(name) ->
514
514
# TODO: use node from sender
515
-
case ProcRegistry.whereis(state.proc_registry, :nonode, name) do
515
+
case ProcRegistry.whereis(state.proc_registry, name, :nonode) do
516
516
{:ok, pid} -> pid
517
517
{:error, :not_found} -> nil
518
518
end
519
519
520
-
{node, name} when is_atom(node) and is_atom(name) ->
521
-
case ProcRegistry.whereis(state.proc_registry, node, name) do
520
+
{name, node} when is_atom(name) and is_atom(node) ->
521
+
case ProcRegistry.whereis(state.proc_registry, name, node) do
522
522
{:ok, pid} -> pid
523
523
{:error, :not_found} -> nil
524
524
end
+12
-12
lib/construct/scheduler/proc_registry.ex
+12
-12
lib/construct/scheduler/proc_registry.ex
···
7
7
end
8
8
9
9
@spec register(t, pid, atom, atom) :: :ok | {:error, :name_already_registered | :pid_already_registered}
10
-
def register(table, pid, node, name) when is_pid(pid) and is_atom(node) and is_atom(name) do
11
-
case whereis(table, node, name) do
10
+
def register(table, pid, name, node) when is_pid(pid) and is_atom(name) and is_atom(node) do
11
+
case whereis(table, name, node) do
12
12
{:error, :not_found} ->
13
13
case :ets.lookup(table, pid) do
14
14
[] ->
15
-
:ets.insert(table, {{node, name}, pid})
16
-
:ets.insert(table, {pid, {node, name}})
15
+
:ets.insert(table, {{name, node}, pid})
16
+
:ets.insert(table, {pid, {name, node}})
17
17
:ok
18
18
19
19
[{^pid, _value}] -> {:error, :pid_already_registered}
···
24
24
end
25
25
26
26
@spec whereis(t, atom, atom) :: {:ok, pid} | {:error, :not_found}
27
-
def whereis(table, node, name) when is_atom(node) and is_atom(name) do
28
-
case :ets.lookup(table, {node, name}) do
29
-
[{{^node, ^name}, pid}] -> {:ok, pid}
27
+
def whereis(table, name, node) when is_atom(name) and is_atom(node) do
28
+
case :ets.lookup(table, {name, node}) do
29
+
[{{^name, ^node}, pid}] -> {:ok, pid}
30
30
[] -> {:error, :not_found}
31
31
end
32
32
end
33
33
34
34
@spec unregister(t, atom, atom) :: :ok | :error
35
-
def unregister(table, node, name) when is_atom(node) and is_atom(name) do
36
-
case whereis(table, node, name) do
35
+
def unregister(table, name, node) when is_atom(name) and is_atom(node) do
36
+
case whereis(table, name, node) do
37
37
{:ok, pid} ->
38
-
:ets.delete(table, {node, name})
38
+
:ets.delete(table, {name, node})
39
39
:ets.delete(table, pid)
40
40
:ok
41
41
···
47
47
@spec remove_process(t, pid) :: :ok | :error
48
48
def remove_process(table, pid) when is_pid(pid) do
49
49
case :ets.lookup(table, pid) do
50
-
[{pid, {node, name}}] ->
51
-
:ets.delete(table, {node, name})
50
+
[{pid, {name, node}}] ->
51
+
:ets.delete(table, {name, node})
52
52
:ets.delete(table, pid)
53
53
:ok
54
54
+5
-2
lib/hobbes.ex
+5
-2
lib/hobbes.ex
···
21
21
defp init_distributed_cluster(num_coordinators) do
22
22
coordinators =
23
23
Enum.map(0..(num_coordinators - 1), fn i ->
24
-
{String.to_atom("node#{i}"), String.to_atom("coordinator-#{i}")}
24
+
{
25
+
String.to_atom("coordinator-#{i}"),
26
+
String.to_atom("node#{i}"),
27
+
}
25
28
end)
26
29
27
30
coordinators
28
31
|> Enum.with_index()
29
-
|> Enum.each(fn {{node, _name}, i} ->
32
+
|> Enum.each(fn {{_name, node}, i} ->
30
33
config = [
31
34
cluster: "cluster",
32
35
coordinators: coordinators,
+3
-3
test/hobbes_test.exs
+3
-3
test/hobbes_test.exs
···
261
261
262
262
SimServer.sleep(1_000)
263
263
264
-
assert {:error, {:not_primary, {_, :"coordinator-0"}}} = Coordinator.write(c2, "foo", "bar")
265
-
assert {:error, {:not_primary, {_, :"coordinator-0"}}} = Coordinator.write(c3, "foo", "bar")
264
+
assert {:error, {:not_primary, {:"coordinator-0", _}}} = Coordinator.write(c2, "foo", "bar")
265
+
assert {:error, {:not_primary, {:"coordinator-0", _}}} = Coordinator.write(c3, "foo", "bar")
266
266
267
267
assert {:ok, _} = Coordinator.write(c1, "foo", "bar")
268
268
assert {:ok, _} = Coordinator.write(c1, "hello", "world")
···
274
274
275
275
SimServer.sleep(3_000)
276
276
277
-
assert {:error, {:not_primary, {_, :"coordinator-1"}}} = Coordinator.read(c3, "foo")
277
+
assert {:error, {:not_primary, {:"coordinator-1", _}}} = Coordinator.read(c3, "foo")
278
278
279
279
assert {:ok, "bar"} = Coordinator.read(c2, "foo")
280
280