lib/paxos.ex

@@ -1,8 +1,4 @@
 defmodule Utils do
-
-  @min_print_level 0
-
-  
   def safecast(p, m) when p == nil, do: IO.puts('Trying to safecast #{m} with p as nil')
   def safecast(p, m) when is_pid(p), do: send(p, m)
   def safecast(p, m) do
@@ -12,10 +8,6 @@ defmodule Utils do
     end
   end
 
-  def alter_name(name, part) do
-    String.to_atom(Atom.to_string(name) <> part)
-  end
-
   def beb_broadcast(m, dest), do: for(p <- dest, do: safecast(p, m))
 
   def register_name(name, pid, link \\ true) do
@@ -34,21 +26,6 @@ defmodule Utils do
     end
   end
 
-  defmacro create_log(level) do
-    quote do
-      def log(msg) do
-        Utils._log(msg, unquote(level))
-      end
-    end
-  end
-
-  def _log(msg, level) do
-    if (@min_print_level < level) do
-      IO.puts(msg)
-    end
-  end
-  
-
   defmacro or_state(val, do: expr) do
     quote do
       case unquote(val) do
@@ -57,17 +34,6 @@ defmodule Utils do
       end
     end
   end
-
-  defmacro runfn(do: expr) do
-    quote do
-      def run(s) do
-        var!(state) = s
-        run(receive do
-          unquote(expr)
-        end)
-      end
-    end
-  end
 end
 
 #
@@ -81,8 +47,6 @@ defmodule Paxos do
   require Utils
   import Utils
 
-  create_log 0
-
   defmacro set_instmap(do: expr) do
     quote do
       var!(map) = var!(state).instmap[var!(inst)]
@@ -93,21 +57,22 @@ defmodule Paxos do
 
 
   # Starts the Paxos replica with a specific name and some processes
-  def start(name, processes, link \\ false) do
+  def start(name, processes) do
-    log("Starting paxos for #{name}")
+    IO.puts("Starting paxos for #{name}")
 
-    pid = spawn(Paxos, :init, [name, processes])
+    pid = spawn(Paxos, :init, [name, name, processes])
-    register_name(name, pid, link)
+    register_name(name, pid, false)
   end
 
   # Init event must be the first
   # one after the component is created
-  def init(name, processes) do
+  def init(name, parent, processes) do
     EventualLeaderElector.start(name, processes)
     EagerReliableBroadcast.start(name, processes)
 
     state = %{
       name: name,
+      parent: parent,
       processes: processes,
       leader: nil,
       instmap: %{},
@@ -150,25 +115,27 @@ defmodule Paxos do
     end
   end
 
-  runfn do
+  def run(state) do
+    run(
+      receive do
         {:ele_trust, proc} ->
-      log("#{state.name} - #{proc} is leader")
+          IO.puts("#{state.name} - #{proc} is leader")
 
           Enum.reduce(Map.keys(state.instmap), %{state | leader: proc}, fn inst, st ->
             prepare(st, inst)
           end)
 
         {:propose, inst, value, pid_to_inform, action} ->
-      log("#{state.name} - Propose #{inspect(inst)} with action #{inspect(action)}")
+          IO.puts("#{state.name} - Propose #{inspect(inst)} with action #{inspect(action)}")
 
           cond do
             has_finished(state, inst, true) ->
-          log("#{state.name} - Has already decided for #{inspect(inst)} sending #{inspect(state.decided[inst])}")
+              IO.puts("#{state.name} - Has already decided for #{inspect(inst)} sending #{inspect(state.decided[inst])}")
               send(pid_to_inform, {:decision, inst, state.decided[inst]})
               state
 
             action == :increase_ballot_number ->
-          log("#{state.name} - Got request to increase ballot number for inst #{inst}")
+              IO.puts("#{state.name} - Got request to increase ballot number for inst #{inst}")
               state = has_or_create(state, inst)
 
               set_instmap do
@@ -216,7 +183,7 @@ defmodule Paxos do
           end
 
         {:rb_deliver, proc, {:prepare, proc, inst, ballot}} ->
-      log("#{state.name} - prepare from #{proc}")
+          IO.puts("#{state.name} - prepare from #{proc}")
 
           cond do
             has_finished(state, inst) ->
@@ -251,7 +218,7 @@ defmodule Paxos do
           end
 
         {:nack, inst, ballot} ->
-      log("#{state.name} - nack #{inspect(inst)} #{inspect(ballot)}")
+          IO.puts("#{state.name} - nack #{inspect(inst)} #{inspect(ballot)}")
 
           cond do
             has_finished(state, inst) ->
@@ -282,7 +249,7 @@ defmodule Paxos do
               state
 
             true ->
-          log("#{state.name} - got information to send abort")
+              IO.puts("#{state.name} - got information to send abort")
 
               if Map.has_key?(state.instmap, inst) and state.instmap[inst].pid_to_inform != nil do
                 send(state.instmap[inst].pid_to_inform, {:abort, inst})
@@ -292,7 +259,7 @@ defmodule Paxos do
           end
 
         {:prepared, inst, ballot, accepted_ballot, accepted_value} ->
-      log(
+          IO.puts(
             "#{state.name} - prepared #{inspect(inst)} #{inspect(ballot)} #{inspect(accepted_ballot)} #{inspect(accepted_value)}"
           )
 
@@ -310,7 +277,7 @@ defmodule Paxos do
               prepared(state, inst)
 
             Ballot.compare(ballot, &>/2, state.instmap[inst].ballot) ->
-          log("#{state.name} - Probably recieved this before preare came to self sending with delay")
+              IO.puts("#{state.name} - Probably recieved this before preare came to self sending with delay")
               Process.send_after(self(), {:prepared, inst, ballot, accepted_ballot, accepted_value}, 100)
               state
 
@@ -327,7 +294,7 @@ defmodule Paxos do
               state = has_or_create(state, inst)
 
               if Ballot.compare(ballot, &>=/2, state.instmap[inst].ballot) do
-            log("#{state.name} - accept #{inspect(inst)} #{inspect(ballot)} #{inspect(value)}")
+                IO.puts("#{state.name} - accept #{inspect(inst)} #{inspect(ballot)} #{inspect(value)}")
             
                 safecast(proc, {:accepted, inst, ballot})
 
@@ -339,14 +306,14 @@ defmodule Paxos do
                   } 
                 end
               else
-            log("#{state.name} -> #{proc} nack")
+                IO.puts("#{state.name} -> #{proc} nack")
                 safecast(proc, {:nack, inst, ballot})
                 state
               end
           end
 
         {:accepted, inst, ballot} ->
-      log("#{state.name} - accepted #{inspect(inst)} #{inspect(ballot)}")
+          IO.puts("#{state.name} - accepted #{inspect(inst)} #{inspect(ballot)}")
 
           cond do
             has_finished(state, inst) ->
@@ -366,19 +333,19 @@ defmodule Paxos do
           end
 
         {:get_value, inst, pid_to_inform} ->
-      # log("#{state.name} get_value")
+          # IO.puts("#{state.name} get_value")
           if  has_finished(state, inst, true) do
-          safecast(pid_to_inform, {:get_value_res, inst, state.decided[inst]})
+              send(pid_to_inform, {:get_value_res_actual, inst, state.decided[inst]})
           end
           state
 
         {:rb_deliver, _, {:decide, inst, value}} ->
-      log("#{state.name} - decided #{inspect(inst)} #{inspect(value)}")
+          IO.puts("#{state.name} - decided #{inspect(inst)} #{inspect(value)}")
 
           or_state not has_finished(state, inst) do
             if Map.has_key?(state.instmap, inst) != nil and
                  state.instmap[inst].pid_to_inform != nil do
-          safecast(state.instmap[inst].pid_to_inform, {:decision, inst, value})
+              send(state.instmap[inst].pid_to_inform, {:decision, inst, value})
             end
 
             %{ state |
@@ -387,6 +354,8 @@ defmodule Paxos do
             }
           end
       end
+    )
+  end
 
   #
   # Puts process in the preapre state
@@ -410,7 +379,7 @@ defmodule Paxos do
 
       true ->
         ballot = Ballot.inc(state.instmap[inst].ballot)
-        log("#{state.name} - sending all prepare #{inst} #{inspect(ballot)}")
+        IO.puts("#{state.name} - sending all prepare #{inst} #{inspect(ballot)}")
         EagerReliableBroadcast.broadcast(state.name, {:prepare, state.name, inst, ballot})
 
         set_instmap do 
@@ -484,7 +453,7 @@ defmodule Paxos do
       value = state.instmap[inst].ballot_value
 
       if state.instmap[inst].action == :kill_before_decision do
-        log("#{state.name} - Leader has action to die before decision #{inspect({:decide, inst, value})}")
+        IO.puts("#{state.name} - Leader has action to die before decision #{inspect({:decide, inst, value})}")
         Process.exit(self(), :kill)
       end
 
@@ -541,7 +510,10 @@ defmodule Paxos do
   def get_decision_loop(input) do
     {_, t} = input
     receive do
-      {:get_value_res, inst, v} ->
+      {:get_value_res, inst} ->
+        check_and_apply(nil, inst, input, &get_decision_loop/1)
+
+      {:get_value_res_actual, inst, v} ->
         check_and_apply(v, inst, input, &get_decision_loop/1)
 
       x ->
@@ -599,22 +571,26 @@ defmodule EagerReliableBroadcast do
   require Utils
   import Utils
   
+  def get_rb_name(name) do
+    String.to_atom(Atom.to_string(name) <> "_rb")
+  end
+
   def get_non_rb_name(name) do
     String.to_atom(String.replace(Atom.to_string(name), "_rb", ""))
   end
 
   def start(name, processes) do
     pid = spawn(EagerReliableBroadcast, :init, [name, processes])
-    register_name(alter_name(name, "_rb"), pid)
+    register_name(get_rb_name(name), pid)
   end
 
   # Init event must be the first
   # one after the component is created
   def init(parent, processes) do
     state = %{
-      name: alter_name(parent, "_rb"),
+      name: get_rb_name(parent),
       parent: parent,
-      processes: Enum.map(processes, fn name -> alter_name(name, "_rb") end),
+      processes: Enum.map(processes, fn name -> get_rb_name(name) end),
       # Use this data structure to remember IDs of the delivered messages
       delivered: %{},
       # Use this variable to remember the last sequence number used to identify a message
@@ -624,7 +600,9 @@ defmodule EagerReliableBroadcast do
     run(state)
   end
 
-  runfn do
+  def run(state) do
+    run(
+      receive do
         # Handle the broadcast request event
         {:broadcast, m} ->
           data_msg = {:data, state.name, state.seq_no, m}
@@ -648,11 +626,13 @@ defmodule EagerReliableBroadcast do
             end
           end
       end
+    )
+  end
 
   #############
   # Interface #
   #############
-  def broadcast(name, m), do: safecast(alter_name(name, "_rb"), {:broadcast, m})
+  def broadcast(name, m), do: safecast(get_rb_name(name), {:broadcast, m})
 end
 
 #
@@ -663,8 +643,12 @@ defmodule EventualLeaderElector do
   require Utils
   import Utils
   
+  def getEleName(name) do
+    String.to_atom(Atom.to_string(name) <> "_ele")
+  end
+
   def start(name, processes) do
-    new_name = alter_name(name, "_ele")
+    new_name = getEleName(name)
     pid = spawn(EventualLeaderElector, :init, [new_name, name, processes])
 
     register_name(new_name, pid)
@@ -673,7 +657,7 @@ defmodule EventualLeaderElector do
   # Init event must be the first
   # one after the component is created
   def init(name, parent, processes) do
-    processes = Enum.map(processes, fn name -> alter_name(name, "_ele") end)
+    processes = Enum.map(processes, fn name -> getEleName(name) end)
 
     state = %{
       name: name,
@@ -696,7 +680,9 @@ defmodule EventualLeaderElector do
     state
   end
 
-  runfn do
+  def run(state) do
+    run(
+      receive do
         {:heartbeat_request, name, seq} ->
           safecast(name, {:heartbeat, state.parent, seq})
           state
@@ -718,4 +704,6 @@ defmodule EventualLeaderElector do
 
           request_heartbeats(state)
       end
+    )
+  end
 end

lib/server.ex

@@ -1,161 +0,0 @@
-defmodule ServerMacros do
-
-  def create_create_loop(name, do: match_exp, else: process_exp) do
-    function_name = :"#{name}_loop"
-
-    ast1 = quote do
-      {:timeout} -> :timeout
-    end
-    ast2 = quote do
-      value ->
-        Process.send_after(self(), value, 100)
-        unquote(function_name)(v)
-    end
-
-    ast3 = ast1 ++ match_exp ++ ast2
-    
-    quote do
-      def unquote(function_name)(v) do
-        var!(v) = v
-        unquote(process_exp)
-        receive do
-          unquote(ast3)
-        end
-      end
-    end
-  end
-
-  def create_create_loop(name, do: exp) do
-    create_create_loop(name, do: exp, else: nil)
-  end
-
-  defmacro create_loop(name, clauses) do
-  	create_create_loop(name, clauses)
-  end
-
-  defmacro try_propose(val, do: ready, else: recal_do) do
-    ast1 = quote do
-      {:timeout} ->  unquote(recal_do)
-      {:abort} ->   unquote(recal_do)
-    end
-    ast2 = quote do
-      {:decision, v} ->
-        var!(state) = apply_game(var!(state), v)
-        unquote(recal_do)
-
-      v ->
-        raise "Unknown message on try_propose #{inspect(v)}"
-    end
-
-    ast3 = ast1 ++ ready ++ ast2
-
-    quote do
-      v = Paxos.propose(var!(state).paxos, var!(state).instance, unquote(val), 1000)
-      case v do
-        unquote(ast3)
-      end
-    end
-  end
-
-end
-
-defmodule Server do
-  require ServerMacros
-  import ServerMacros
-  require Utils
-  import Utils
-
-  create_log 2
-
-  def start(name, participants) do
-    log("starting server")
-
-    pid = spawn(Server, :init, [name, participants])
-    register_name(name, pid, false)
-  end
-
-  def init(name, participants) do
-    paxos = Paxos.start(alter_name(name, "_paxos"), Enum.map(participants, fn name -> alter_name(name, "_paxos") end))
-    state = %{
-      name: name,
-      procs: participants,
-      games: %{},
-      paxos: paxos,
-      instance: 0,
-    }
-
-    run(state)
-  end
-
-  runfn do
-    {:start_game, participants, pid_to_inform} ->
-      {state, game_id} = try_to_create_game(state, participants)
-      safecast(pid_to_inform, {:start_game_ans, game_id})
-      state
-  end
-
-  def try_to_create_game(state, participants) do
-    game_ids = Map.keys(state.games)
-    new_game_id = Enum.at(Enum.sort(game_ids), length(game_ids) - 1) + 1
-
-    # TODO: randomize game state
-    new_game_state = [1, 1]
-    # TODO: randomize Initial hand value
-    hand = Enum.reduce(participants, %{}, fn p, acc -> Map.put(acc, p, 1) end)
-
-    try_propose {:start_game, new_game_id, participants, new_game_state, hand}
-    do
-      {:decision, {:start_game, ^new_game_id, ^participants, ^new_game_state, ^hand}} ->
-        state = apply_game(state, {:start_game, new_game_id, participants, new_game_state, hand})
-        {state, new_game_id}
-    else
-      try_to_create_game(state, participants)
-    end
-  end
-
-  #
-  # Apply Game States
-  #
-
-  def apply_game(state, {:start_game, game_id, participants, new_game_state, hand}) do
-    if state.name in participants do
-      %{state | games: Map.put(state.games, game_id, %{
-        game_state: new_game_state,
-        participants: participants,
-        hand: hand[state.name]
-      })}
-    else
-      %{state | games: Map.put(state.games, game_id, :not_playing_in_it)}
-    end
-  end
-
-  def apply_game(state, _), do: raise :do_not_know_how_to_apply_game_state
-
-  ############
-  # Interface 
-  ############
-
-  create_loop :start_game do
-     {:start_game, game_id} ->
-       log("Started a game #{game_id}")
-  end
-  
-  def start_game(name, participants) do
-    safecast(name, {:start_game, participants, self()})
-    start_game_loop(nil)
-  end
-
-  ############
-  # Debug 
-  ############
-
-  def spinup(number_of_participants) do
-    procs = Enum.to_list(0..number_of_participants) |> Enum.map(fn n -> :"p#{n}" end)
-    Enum.map(procs, fn proc -> Server.start(proc, procs) end)
-  end
-
-  def kill (pids) do
-    pids |> Enum.map(fn m -> Process.exit(m, :kill) end)
-  end
-
-end

lib/test.ex

@@ -1,23 +1,9 @@
 defmodule Test do
 
-  defmacro createfuncBase(name, do: do_exp, else: else_exp) do
+  defmacro createfuncBase(name) do
-      b1 = quote do
+      quote do
-        false -> unquote(else_exp)
+        def unquote(name)(true), do: true
       end
-
-      b2 = b1 ++ do_exp
-      
-      t = quote do
-        def test(v) do
-          case v do
-            unquote(b2)
-          end
-        end
-      end
-
-      IO.puts("test #{inspect(t)}")
-      
-      t
   end
 
 end
@@ -25,7 +11,7 @@ end
 defmodule Test2 do
   require Test
 
-  Test.createfuncBase :lol do 
+  def test(), do: false
-    true -> :test
+
-  else :test1 end
+  Test.createfuncBase(:test)
 end