     end
   end
 
-  @spec upload(Path.t, map) :: {:ok, any} | {:error, any}
   def upload(file_path, meta) do
     Logger.busy 3, "Image Watcher trying to upload #{file_path}"
-    Farmbot.HTTP.upload_file(file_path, meta)
-    if Process.whereis(Farmbot.System.Updates.SlackUpdater) do
-      Farmbot.System.Updates.SlackUpdater.upload_file(file_path)
+    case Farmbot.HTTP.upload_file(file_path, meta) do
+      {:ok, %{status_code: 200}} -> exit(:normal)
+      {:ok, %{body: body}} -> exit({:http_error, body})
+      {:error, reason} -> exit(reason)
     end
-    File.rm!(file_path)
-    Logger.success 3, "Image Watcher uploaded #{file_path}"
   end
 end

    end
  end

  def handle_info({:EXIT, pid, reason}, state) do
    case state.uploads[pid] do
      nil                   -> {:noreply, state}
      {path, _meta, 6 = ret} ->
        Logger.error 1, "Failed to upload #{path} #{ret} times. Giving up."
        File.rm path
        {:noreply, %{state | uploads: Map.delete(state.uploads, pid)}}
      {path, meta, retries}  ->
        Logger.warn 2, "Failed to upload #{path} #{inspect reason}. Going to retry."
        Process.sleep(1000 * retries)
        new_pid = spawn __MODULE__, :upload, [path, meta]
        new_uploads = state
          |> Map.delete(pid)
          |> Map.put(new_pid, {path, meta, retries + 1})
        {:noreply, %{state | uploads: new_uploads}}
    end
  end

  def handle_info(_, state), do: {:noreply, state}

  # Stolen from
  # https://github.com/phoenixframework/

    File.mkdir_p! @images_path
    :fs_app.start(:normal, [])
    :fs.subscribe()
    {:ok, %{uploads: %{}}}
  end

  def terminate(reason, _state) do
    Logger.debug 3, "Image uploader terminated: #{inspect reason}"
  end

  def handle_info({_pid, {:fs, :file_event}, {path, _}}, state) do
