Uart handler is so much faster now

VERSION

@@ -1 +1 @@
-2.0.5
+2.0.7

config/prod.exs

@@ -8,8 +8,8 @@ config :uart,
 
 config :fb,
   ro_path: "/root",
-  bot_status_save_file: "/root/botstatus.txt"
-  factory_reset_pin: 21,
+  bot_status_save_file: "/root/botstatus.txt",
+  factory_reset_pin: 21
 
 config :json_rpc,
     transport: MqttMessageHandler

lib/bot_sync/bot_sync.ex

@@ -10,12 +10,11 @@ defmodule BotSync do
   end
 
   def handle_cast(_, %{token: nil, resources: _}) do
-    Logger.debug("Don't have a token yet.")
     spawn fn -> try_to_get_token end
     {:noreply, %{token: nil, resources: nil}}
   end
 
-  def handle_cast(:sync, %{token: token, resources: _}) do
+  def handle_cast(:sync, %{token: token, resources: old}) do
     server = Map.get(token, "unencoded") |> Map.get("iss")
     auth = Map.get(token, "encoded")
 
@@ -27,7 +26,7 @@ defmodule BotSync do
                          headers: _headers,
                          status_code: 200} ->
        RPCMessageHandler.log("Synced")
-       {:noreply, %{token: token, resources: Poison.decode!(body)}}
+       {:noreply, %{token: token, resources: Map.merge(old || %{}, Poison.decode!(body)) }}
      error ->
        Logger.debug("Couldn't get resources: #{error}")
        RPCMessageHandler.log("Couldn't sync: #{error}")
@@ -75,15 +74,20 @@ defmodule BotSync do
     {:reply, regimens, %{token: token, resources: resources}}
   end
 
+  # REALLY BAD LOGIC HERE
   def handle_call({:get_corpus, id}, _from, %{token: token, resources: resources} ) do
-    if Map.get(resources, "corpuses") == nil do
-      server = Map.get(token, "unencoded") |> Map.get("iss")
-      c = get_corpus_from_server(server, id)
-      m = String.to_atom("Elixir.SequenceInstructionSet_"<>"#{id}")
-      m.create_instruction_set(c)
+    case Map.get(resources, "corpuses") do
+      nil ->
+        Logger.debug("Compiling Corpus Instruction Set")
+        RPCMessageHandler.log("Compileing Instruction Set!")
+        server = Map.get(token, "unencoded") |> Map.get("iss")
+        c = get_corpus_from_server(server, id)
+        m = String.to_atom("Elixir.SequenceInstructionSet_"<>"#{id}")
+        m.create_instruction_set(c)
+        {:reply, Module.concat(SiS, "Corpus_#{id}"), %{token: token, resources: Map.put(resources, "corpuses", [c])}}
+      corpuses ->
+        {:reply, Module.concat(SiS, "Corpus_#{id}"), %{token: token, resources: resources}}
     end
-    f = Module.concat(SiS, "Corpus_#{id}")
-    {:reply, f, %{token: token, resources: resources}}
   end
 
   defp get_corpus_from_server(server, id) do

lib/sequence/sequence_manager.ex

@@ -3,6 +3,7 @@ defmodule SequenceManager do
   require Logger
 
   def init(_arge) do
+    Process.flag(:trap_exit, true)
     {:ok, %{current: nil, global_vars: %{}, log: []}}
   end
 
@@ -49,19 +50,39 @@ defmodule SequenceManager do
   # done when there are no more sequences to run.
   def handle_info({:done, pid}, %{current: _, global_vars: globals, log: []}) do
     RPCMessageHandler.log("No more Sequences to run.")
-    GenServer.stop(pid, :normal)
+    if Process.alive? pid do
+      GenServer.stop(pid, :normal)
+    end
     {:noreply, %{current: nil, global_vars: globals, log: []}}
   end
 
   # There is in fact more sequences to run
   def handle_info({:done, pid}, %{current: _current, global_vars: globals, log: more}) do
     RPCMessageHandler.log("Running next sequence")
-    GenServer.stop(pid, :normal)
+    if Process.alive? pid do
+      GenServer.stop(pid, :normal)
+    end
     seq = List.last(more)
     {:ok, new_pid} = SequencerVM.start_link(seq)
     {:noreply,  %{current: new_pid, global_vars: globals, log: more -- [seq]}}
   end
 
+  def handle_info({:EXIT, pid, :normal}, state) do
+    {:noreply, state}
+  end
+
+  def handle_info({:EXIT, pid, reason}, state) do
+    msg = "#{inspect pid} died of unnatural causes: #{inspect reason}"
+    Logger.debug(msg)
+    RPCMessageHandler.log(msg)
+    if state.current == pid do
+      handle_info({:done, pid}, state)
+    else
+      Logger.debug("Sequence Hypervisor has been currupted. ")
+      :fail
+    end
+  end
+
   def do_sequence(seq) when is_map(seq) do
     huh = GenServer.call(__MODULE__, {:add, seq})
     RPCMessageHandler.log(huh)

lib/sequence/sequencer.ex

@@ -98,14 +98,14 @@ defmodule SequencerVM do
   end
 
   def terminate(:normal, state) do
-    RPCMessageHandler.log("Sequence Finished without errors!", "success_toast")
+    RPCMessageHandler.log("Sequence Finished without errors!", ["success_toast", "ticker"])
     GenServer.stop(state.instruction_set, :normal)
   end
 
   def terminate(reason, state) do
     Logger.debug("VM Died: #{inspect reason}")
+    RPCMessageHandler.log("Sequence Finished with errors! #{inspect reason}", "error_toast")
     GenServer.stop(state.instruction_set, :normal)
     IO.inspect state
   end
-
 end

lib/serial/gcode_message_handler.ex

@@ -15,21 +15,11 @@ defmodule NewHandler do
     {:noreply, state}
   end
 
-  def handle_cast({:idle}, %{nerves: nerves, current: _, log: []}) do
-    {:noreply, %{nerves: nerves, current: nil, log: []}}
-  end
-
-  def handle_cast({:idle}, %{nerves: nerves, current: _, log: log}) do
-    {nextstr, pid} = List.first(log)
-    Nerves.UART.write(nerves, nextstr)
-    {:noreply, %{nerves: nerves, current: {nextstr, pid}, log: log -- [{nextstr, pid}] }}
-  end
-
   def handle_cast({:idle}, state) do
-    {:noreply, state}
+    {:noreply, %{nerves: state.nerves, current: nil, log: []}}
   end
 
-  def handle_cast({:done}, %{nerves: nerves, current: {current_str, pid}, log: log}) do
+  def handle_cast({:done}, %{nerves: nerves, current: {_current_str, pid}, log: log}) do
     # Logger.debug("Done with #{inspect {current_str, pid}}")
     send(pid, :done)
     case List.first(log) do
@@ -88,7 +78,9 @@ defmodule NewHandler do
     {:noreply, state}
   end
 
+  # If we arent waiting on anything right now. (current is nil and log is empty)
   def handle_call({:send, message, caller}, _from, %{ nerves: nerves, current: nil, log: [] }) do
+    Nerves.UART.write(nerves, message)
     {:reply, :sending, %{nerves: nerves, current: {message, caller}, log: [{message, caller}]} }
   end
 

lib/serial/uart_handler.ex

@@ -67,6 +67,10 @@ defmodule UartHandler do
     {:noreply, state}
   end
 
+  def handle_info({:EXIT, _pid, :normal}, state) do
+    {:noreply, state}
+  end
+
   def handle_info({:EXIT, pid, reason}, state) do
     Logger.debug("EXIT IN #{inspect pid}: #{inspect reason}")
     {:noreply, state}