fix farmware, logs, etc

lib/farmbot/bot_state/bot_state.ex

@@ -116,7 +116,9 @@ defmodule Farmbot.BotState do
               sync_status: :sync_now,
             },
             user_env: %{},
-            process_info: %{}
+            process_info: %{
+              farmwares: %{}
+            }
 
   @doc "Get a current pin value."
   def get_pin_value(num) do
@@ -143,6 +145,16 @@ defmodule Farmbot.BotState do
     GenStage.call(__MODULE__, :force_state_push)
   end
 
+  @doc "Register a farmware in the bot's state."
+  def register_farmware(%Farmbot.Farmware{} = fw) do
+    GenStage.call(__MODULE__, {:register_farmware, fw})
+  end
+
+  @doc "Unregister a farmware form the bot's state."
+  def unregister_farmware(%Farmbot.Farmware{} = fw) do
+    GenStage.call(__MODULE__, {:unregister_farmware, fw})
+  end
+
   @doc "Emit an AST."
   def emit(%AST{} = ast) do
     GenStage.call(__MODULE__, {:emit, ast})
@@ -222,6 +234,34 @@ defmodule Farmbot.BotState do
     {:reply, state.location_data.position, [], state}
   end
 
+  def handle_call({:register_farmware, fw}, _, state) do
+    ser_fw_meta = %{
+      min_os_version_major: fw.min_os_version_major,
+      description: fw.meta.description,
+      language: fw.meta.language,
+      version: to_string(fw.version),
+      author: fw.meta.author,
+      zip: fw.zip
+    }
+    ser_fw = %{
+      args: fw.args,
+      executable: fw.executable,
+      meta: ser_fw_meta,
+      name: fw.name,
+      path: Farmbot.Farmware.Installer.install_path(fw),
+      url: fw.url
+    }
+    new_pi = Map.put(state.process_info.farmwares, fw.name, ser_fw)
+    new_state = %{state | process_info: %{farmwares: new_pi}}
+    {:reply, :ok, [new_state], new_state}
+  end
+
+  def handle_call({:unregister_farmware, fw}, _, state) do
+    new_pi = Map.delete(state.process_info.farmware, fw.name)
+    new_state = %{state | process_info: %{farmwares: new_pi}}
+    {:reply, :ok, [new_state], new_state}
+  end
+
   defp do_handle([], state), do: state
 
   defp do_handle([{:config, "settings", key, val} | rest], state) do

lib/farmbot/bot_state/transport/gen_mqtt/client.ex

@@ -80,7 +80,7 @@ defmodule Farmbot.BotState.Transport.GenMQTT.Client do
     {:ok, state}
   end
 
-  def on_publish(["bot", _, "sync", "Log", _], _, state) do
+  def on_publish(["bot", _, "sync", ignore, _], _, state) when ignore in ["Log", "User", "Image"] do
     {:ok, state}
   end
 

lib/farmbot/bot_state/transport/gen_mqtt/gen_mqtt.ex

@@ -39,7 +39,7 @@ defmodule Farmbot.BotState.Transport.GenMQTT do
       if log.module == nil or Module.split(log.module || Elixir.Logger) |> List.first == "Farmbot" do
         location_data = Map.get(old_bot_state || %{}, :location_data, %{position: %{x: -1, y: -1, z: -1}})
         meta = %{type: log.level, x: nil, y: nil, z: nil}
-        log_without_pos = %{meta: meta, channels: log.meta[:channels] || [], message: log.message}
+        log_without_pos = %{created_at: log.time, meta: meta, channels: log.meta[:channels] || [], message: log.message}
         log = add_position_to_log(log_without_pos, location_data)
         Client.push_bot_log(client, log)
       end

lib/farmbot/celery_script/ast/node/data_update.ex

@@ -0,0 +1,67 @@
+defmodule Farmbot.CeleryScript.AST.Arg.Device do
+  @moduledoc false
+  @behaviour Farmbot.CeleryScript.AST.Arg
+
+  def decode(val), do: {:ok, val}
+  def encode(val), do: {:ok, val}
+end
+
+defmodule Farmbot.CeleryScript.AST.Arg.FarmEvents do
+  @moduledoc false
+  @behaviour Farmbot.CeleryScript.AST.Arg
+
+  def decode(val), do: {:ok, val}
+  def encode(val), do: {:ok, val}
+end
+
+defmodule Farmbot.CeleryScript.AST.Arg.Points do
+  @moduledoc false
+  @behaviour Farmbot.CeleryScript.AST.Arg
+
+  def decode(val), do: {:ok, val}
+  def encode(val), do: {:ok, val}
+end
+
+defmodule Farmbot.CeleryScript.AST.Arg.Peripherals do
+  @moduledoc false
+  @behaviour Farmbot.CeleryScript.AST.Arg
+
+  def decode(val), do: {:ok, val}
+  def encode(val), do: {:ok, val}
+end
+
+defmodule Farmbot.CeleryScript.AST.Arg.Regimens do
+  @moduledoc false
+  @behaviour Farmbot.CeleryScript.AST.Arg
+
+  def decode(val), do: {:ok, val}
+  def encode(val), do: {:ok, val}
+end
+
+defmodule Farmbot.CeleryScript.AST.Arg.Tools do
+  @moduledoc false
+  @behaviour Farmbot.CeleryScript.AST.Arg
+
+  def decode(val), do: {:ok, val}
+  def encode(val), do: {:ok, val}
+end
+
+defmodule Farmbot.CeleryScript.AST.Arg.ToolSlots do
+  @moduledoc false
+  @behaviour Farmbot.CeleryScript.AST.Arg
+
+  def decode(val), do: {:ok, val}
+  def encode(val), do: {:ok, val}
+end
+
+
+
+defmodule Farmbot.CeleryScript.AST.Node.DataUpdate do
+  @moduledoc false
+  use Farmbot.CeleryScript.AST.Node
+  allow_args [:value, :device, :farm_events, :points, :peripherals, :regimens, :sequences, :tool_slots, :tools]
+
+  def execute(_, _, env) do
+    {:ok, env}
+  end
+end

lib/farmbot/farmware/farmware.ex

@@ -109,7 +109,7 @@ defmodule Farmbot.Farmware do
 
   defmodule Meta do
     @moduledoc "Metadata about a Farmware."
-    defstruct [:author, :language,:description]
+    defstruct [:author, :language, :description]
   end
 
   defstruct [

lib/farmbot/farmware/installer/installer.ex

@@ -82,6 +82,9 @@ defmodule Farmbot.Farmware.Installer do
            finish_install(farmware, json_map)
          else
            {:error, {name, version, :already_installed}} ->
+            #  v = Version.parse!(version)
+             {:ok, fw} = Farmbot.Farmware.lookup(name, version |> to_string())
+             Farmbot.BotState.register_farmware(fw)
              Logger.info 1, "Farmware #{name} - #{version} is already installed."
              :ok
            {:ok, %{status_code: code, body: body}} ->
@@ -103,7 +106,8 @@ defmodule Farmbot.Farmware.Installer do
     Logger.warn 2, "Uninstalling farmware: #{inspect fw}"
     install_path = install_path(fw)
     case File.rm_rf(install_path) do
-      {:ok, _} -> :ok
+      {:ok, _} ->
+        Farmbot.BotState.unregister_farmware(fw)
       {:error, _} = err -> err
     end
   end
@@ -143,11 +147,12 @@ defmodule Farmbot.Farmware.Installer do
     zip_url = fw.zip
     with {:ok, ^zip_path} <- HTTP.download_file(zip_url, zip_path),
          :ok <- unzip(fw, zip_path),
-         {:ok, json} <- Poison.encode(json_map)
-         do
-           manifest_path = Path.join(install_path(fw), "manifest.json")
-           File.write(manifest_path,json)
-         end
+         {:ok, json} <- Poison.encode(json_map),
+         manifest_path <- Path.join(install_path(fw), "manifest.json"),
+         :ok <- File.write(manifest_path, json)
+    do
+      Farmbot.BotState.register_farmware(fw)
+    end
   end
 
   defp unzip(%Farmware{} = fw, zip_path) do

lib/farmbot/http/http.ex

@@ -90,7 +90,7 @@ defmodule Farmbot.HTTP do
   @doc "Upload a file to FB storage."
   def upload_file(path, meta \\ nil) do
     if File.exists?(path) do
-      GenServer.call(__MODULE__, {:upload_file, path, meta})
+      GenServer.call(__MODULE__, {:upload_file, {path, meta}})
     else
       {:error, "#{path} not found"}
     end

lib/farmbot/http/httpoison_adapter.ex

@@ -68,9 +68,8 @@ defmodule Farmbot.HTTP.HTTPoisonAdapter do
   defp finish_upload({:ok, %Response{status_code: code}}, http, atch_url, meta) when is_2xx(code) do
     with {:ok, body} <- Poison.encode(%{"attachment_url" => atch_url, "meta" => meta}) do
       case request(http, :post, "/api/images", body, [], []) do
-        {:ok, %Response{status_code: code}} when is_2xx(code) ->
-          # debug_log("#{atch_url} should exist shortly.")
-          :ok
+        {:ok, %Response{status_code: code} = resp} when is_2xx(code) ->
+          {:ok, resp}
 
         {:ok, %Response{} = response} ->
           {:error, response}

lib/farmbot/logger/logger.ex

@@ -88,7 +88,7 @@ defmodule Farmbot.Logger do
   end
 
   def handle_cast({:dispatch_log, {env, level, verbosity, message, meta}}, state) do
-    time = :os.system_time()
+    time = :os.system_time(:seconds)
     fun = case env.function do
       {fun, ar} -> "#{fun}/#{ar}"
       nil -> "no_function"

mix.exs

@@ -117,7 +117,7 @@ defmodule Farmbot.Mixfile do
         {:nerves_network, "~> 0.3", github: "nerves-project/nerves_network", override: true},
         # {:dhcp_server, path: "/home/connor/oss/elixir/nerves/dhcp_server", override: true},
         {:dhcp_server, github: "nerves-project/dhcp_server", branch: "elixirize-go!", override: true},
-        {:nerves_init_gadget, github: "nerves-project/nerves_init_gadget", branch: "dhcp", only: :dev},
+        # {:nerves_init_gadget, github: "nerves-project/nerves_init_gadget", branch: "dhcp", only: :dev},
         # {:nerves_init_gadget, path: "/home/connor/oss/elixir/nerves/nerves_init_gadget", branch: "dhcp", only: :dev},
       ]
   end