Retry failed Home Assistant discovery publishes

Author: nebhale

lib/teslamate/mqtt/pubsub/vehicle_subscriber.ex

@@ -9,6 +9,9 @@ defmodule TeslaMate.Mqtt.PubSub.VehicleSubscriber do
   alias TeslaMate.Vehicles.Vehicle.Summary
   alias TeslaMate.Vehicles
 
+  @discovery_retry_initial_delay :timer.seconds(5)
+  @discovery_retry_max_delay :timer.minutes(5)
+
   defstruct [
     :car_id,
     :last_values,
@@ -17,7 +20,12 @@ defmodule TeslaMate.Mqtt.PubSub.VehicleSubscriber do
     :discovery,
     :discovery_base_url,
     :discovery_prefix,
-    :discovery_device
+    :discovery_device,
+    :discovery_pending_summary,
+    :discovery_pending_device,
+    :discovery_retry_delay,
+    :discovery_retry_timer,
+    :discovery_retry_token
   ]
 
   alias __MODULE__, as: State
@@ -126,33 +134,104 @@ defmodule TeslaMate.Mqtt.PubSub.VehicleSubscriber do
     {:noreply, %{state | last_values: last_values}}
   end
 
+  def handle_info(
+        {:retry_discovery, token},
+        %State{
+          discovery: true,
+          discovery_retry_token: token,
+          discovery_pending_summary: %Summary{} = summary,
+          discovery_pending_device: device
+        } = state
+      ) do
+    state = %{
+      state
+      | discovery_pending_summary: nil,
+        discovery_pending_device: nil,
+        discovery_retry_timer: nil,
+        discovery_retry_token: nil
+    }
+
+    {:noreply, publish_or_schedule_discovery(summary, device, state)}
+  end
+
+  def handle_info({:retry_discovery, _stale_token}, %State{} = state), do: {:noreply, state}
+
   defp maybe_publish_discovery(%Summary{} = summary, %State{discovery: true} = state) do
     opts = discovery_opts(state)
     device = HomeAssistant.device(summary, opts)
 
-    if device == state.discovery_device do
-      state
-    else
-      case publish_discovery(summary, opts, state) do
-        :ok -> %{state | discovery_device: device}
-        {:error, _reason} -> state
-      end
+    cond do
+      device == state.discovery_device ->
+        reset_discovery_retry(state)
+
+      is_reference(state.discovery_retry_timer) ->
+        %{
+          state
+          | discovery_pending_summary: summary,
+            discovery_pending_device: device
+        }
+
+      true ->
+        publish_or_schedule_discovery(summary, device, state)
     end
   end
 
   defp maybe_publish_discovery(%Summary{}, %State{} = state), do: state
 
-  defp publish_discovery(%Summary{} = summary, opts, %State{deps: deps}) do
-    case HomeAssistant.publish(summary, opts, deps.publisher) do
+  defp publish_or_schedule_discovery(%Summary{} = summary, device, %State{} = state) do
+    case publish_discovery(summary, discovery_opts(state), state) do
       :ok ->
-        :ok
+        state
+        |> reset_discovery_retry()
+        |> Map.put(:discovery_device, device)
 
-      {:error, reason} = error ->
-        Logger.warning("MQTT HA discovery publishing failed: #{inspect(reason)}")
-        error
+      {:error, reason} ->
+        schedule_discovery_retry(summary, device, reason, state)
     end
   end
 
+  defp publish_discovery(%Summary{} = summary, opts, %State{deps: deps}) do
+    HomeAssistant.publish(summary, opts, deps.publisher)
+  end
+
+  defp schedule_discovery_retry(%Summary{} = summary, device, reason, %State{} = state) do
+    delay = next_discovery_retry_delay(state.discovery_retry_delay)
+    token = make_ref()
+    timer = Process.send_after(self(), {:retry_discovery, token}, delay)
+
+    Logger.warning(
+      "MQTT HA discovery publishing failed: #{inspect(reason)}; retrying in #{div(delay, 1_000)}s"
+    )
+
+    %{
+      state
+      | discovery_pending_summary: summary,
+        discovery_pending_device: device,
+        discovery_retry_delay: delay,
+        discovery_retry_timer: timer,
+        discovery_retry_token: token
+    }
+  end
+
+  defp next_discovery_retry_delay(nil), do: @discovery_retry_initial_delay
+
+  defp next_discovery_retry_delay(delay) do
+    min(delay * 2, @discovery_retry_max_delay)
+  end
+
+  defp reset_discovery_retry(%State{discovery_retry_timer: timer} = state) do
+    if is_reference(timer), do: Process.cancel_timer(timer)
+
+    %{
+      state
+      | discovery_pending_summary: nil,
+        discovery_pending_device: nil,
+        discovery_retry_delay: nil,
+        discovery_retry_timer: nil,
+        discovery_retry_token: nil
+    }
+  end
+
   defp discovery_opts(%State{} = state) do
     [
       car_id: state.car_id,

test/teslamate/mqtt/pubsub/vehicle_subscriber_test.exs

@@ -52,6 +52,27 @@ defmodule TeslaMate.Mqtt.PubSub.VehicleSubscriberTest do
     )
   end
 
+  defp assert_discovery_retry(pid, expected_delay) do
+    state = :sys.get_state(pid)
+
+    assert state.discovery_retry_delay == expected_delay
+    assert is_reference(state.discovery_retry_timer)
+    assert is_reference(state.discovery_retry_token)
+    assert is_integer(Process.read_timer(state.discovery_retry_timer))
+
+    state
+  end
+
+  defp fire_discovery_retry(pid) do
+    state = :sys.get_state(pid)
+
+    assert is_reference(state.discovery_retry_timer)
+    assert is_reference(state.discovery_retry_token)
+    assert is_integer(Process.cancel_timer(state.discovery_retry_timer))
+
+    send(pid, {:retry_discovery, state.discovery_retry_token})
+  end
+
   test "starts before retained topic cleanup completes", %{test: name} do
     vehicles_name = :"vehicles_#{name}"
     {:ok, _pid} = start_supervised({VehiclesMock, name: vehicles_name, pid: self()})
@@ -511,6 +532,71 @@ defmodule TeslaMate.Mqtt.PubSub.VehicleSubscriberTest do
     assert Jason.decode!(payload)["device"]["sw_version"] == "2026.26.1"
   end
 
+  @tag :capture_log
+  test "backs off failed discovery publishes and retries the latest metadata", %{test: name} do
+    topic = "homeassistant/sensor/teslamate_0/display_name/config"
+    error = {:error, :disconnected}
+    responses = %{topic => List.duplicate(error, 7) ++ [:ok, error]}
+
+    log =
+      ExUnit.CaptureLog.capture_log(fn ->
+        {:ok, pid} = start_subscriber(name, 0, nil, responses, discovery: true)
+
+        assert_receive {VehiclesMock, {:subscribe_to_summary, 0}}
+
+        summary = %Summary{healthy: true, display_name: "Foo", model: "3", state: :online}
+        send(pid, summary)
+
+        assert_receive {MqttPublisherMock, {:publish, ^topic, _payload, _opts}}
+
+        state = assert_discovery_retry(pid, :timer.seconds(5))
+        assert state.discovery_pending_summary == summary
+        assert state.discovery_pending_device.model == "Model 3"
+
+        send(pid, %Summary{summary | version: "2026.1"})
+        latest = %Summary{summary | version: "2026.2"}
+        send(pid, latest)
+
+        state = :sys.get_state(pid)
+        assert state.discovery_pending_summary == latest
+        assert state.discovery_pending_device.sw_version == "2026.2"
+        assert state.discovery_retry_delay == :timer.seconds(5)
+
+        refute_receive {MqttPublisherMock, {:publish, ^topic, _payload, _opts}}
+
+        for expected_delay <- [10, 20, 40, 80, 160, 300] do
+          fire_discovery_retry(pid)
+          assert_receive {MqttPublisherMock, {:publish, ^topic, _payload, _opts}}
+          assert_discovery_retry(pid, :timer.seconds(expected_delay))
+        end
+
+        fire_discovery_retry(pid)
+        assert_receive {MqttPublisherMock, {:publish, ^topic, _payload, _opts}}
+
+        state = :sys.get_state(pid)
+        assert state.discovery_device.sw_version == "2026.2"
+        assert state.discovery_pending_summary == nil
+        assert state.discovery_pending_device == nil
+        assert state.discovery_retry_delay == nil
+        assert state.discovery_retry_timer == nil
+        assert state.discovery_retry_token == nil
+
+        drain_discovery_configs()
+
+        send(pid, %Summary{latest | speed: 42})
+        :sys.get_state(pid)
+        refute_receive {MqttPublisherMock, {:publish, ^topic, _payload, _opts}}
+
+        send(pid, %Summary{latest | version: "2026.3"})
+        assert_receive {MqttPublisherMock, {:publish, ^topic, _payload, _opts}}
+        assert_discovery_retry(pid, :timer.seconds(5))
+      end)
+
+    assert length(Regex.scan(~r/MQTT HA discovery publishing failed/, log)) == 8
+    assert log =~ "retrying in 5s"
+    assert log =~ "retrying in 300s"
+  end
+
   test "clears discovery configs when discovery is disabled", %{test: name} do
     {:ok, pid} = start_subscriber(name, 0)