Create repair for configured not loaded agents

Author: MartinHjelmare

homeassistant/components/backup/manager.py

@@ -51,6 +51,10 @@
     LOGGER,
 )
 from .models import AgentBackup, BackupError, BackupManagerError, BaseBackup, Folder
+from .repairs import (
+    create_automatic_backup_agents_not_loaded_issue,
+    delete_automatic_backup_agents_not_loaded_issue,
+)
 from .store import BackupStore
 from .util import (
     AsyncIteratorReader,
@@ -401,6 +405,19 @@ async def _async_reload_backup_agents(self, domain: str) -> None:
                 if isinstance(agent, LocalBackupAgent)
             }
         )
+        if missing_agent_ids := set(self.config.data.create_backup.agent_ids) - set(
+            self.backup_agents
+        ):
+            LOGGER.debug(
+                "Agents %s are configured for automatic backup but are not loaded",
+                missing_agent_ids,
+            )
+            for agent_id in missing_agent_ids:
+                create_automatic_backup_agents_not_loaded_issue(self.hass, agent_id)
+
+        # Remove any issues for agents that are now loaded
+        for agent_id in self.backup_agents:
+            delete_automatic_backup_agents_not_loaded_issue(self.hass, agent_id)
 
     async def _add_platform(
         self,

homeassistant/components/backup/manifest.json

@@ -3,7 +3,7 @@
   "name": "Backup",
   "after_dependencies": ["hassio"],
   "codeowners": ["@home-assistant/core"],
-  "dependencies": ["http", "websocket_api"],
+  "dependencies": ["http", "repairs", "websocket_api"],
   "documentation": "https://www.home-assistant.io/integrations/backup",
   "integration_type": "system",
   "iot_class": "calculated",

homeassistant/components/backup/repairs.py

@@ -0,0 +1,87 @@
+"""Provide repairs for the backup integration."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from homeassistant.components.repairs import ConfirmRepairFlow, RepairsFlow
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.data_entry_flow import FlowResult
+from homeassistant.helpers import issue_registry as ir
+
+from .const import DATA_MANAGER, DOMAIN
+
+AUTOMATIC_BACKUP_AGENTS_NOT_LOADED_ISSUE_ID = "automatic_backup_agents_not_loaded"
+
+
+@callback
+def create_automatic_backup_agents_not_loaded_issue(
+    hass: HomeAssistant, agent_id: str
+) -> None:
+    """Create automatic backup agents not loaded issue."""
+    ir.async_create_issue(
+        hass,
+        DOMAIN,
+        f"{AUTOMATIC_BACKUP_AGENTS_NOT_LOADED_ISSUE_ID}_{agent_id}",
+        data={"agent_id": agent_id},
+        is_fixable=True,
+        learn_more_url="homeassistant://config/backup",
+        severity=ir.IssueSeverity.WARNING,
+        translation_key="automatic_backup_agents_not_loaded",
+        translation_placeholders={"agent_id": agent_id},
+    )
+
+
+@callback
+def delete_automatic_backup_agents_not_loaded_issue(
+    hass: HomeAssistant, agent_id: str
+) -> None:
+    """Delete automatic backup agents not loaded issue."""
+    ir.async_delete_issue(
+        hass, DOMAIN, f"{AUTOMATIC_BACKUP_AGENTS_NOT_LOADED_ISSUE_ID}_{agent_id}"
+    )
+
+
+class AutomaticBackupAgentsNotLoaded(RepairsFlow):
+    """Handler for an issue fixing flow."""
+
+    def __init__(self, agent_id: str) -> None:
+        """Initialize."""
+        self._agent_id = agent_id
+
+    async def async_step_init(
+        self, user_input: dict[str, str] | None = None
+    ) -> FlowResult:
+        """Handle the first step of a fix flow."""
+        return await self.async_step_confirm()
+
+    async def async_step_confirm(
+        self, user_input: dict[str, str] | None = None
+    ) -> FlowResult:
+        """Handle the confirm step of a fix flow."""
+        if user_input is not None:
+            manager = self.hass.data[DATA_MANAGER]
+            configured_agent_ids = set(manager.config.data.create_backup.agent_ids)
+            configured_agent_ids.discard(self._agent_id)
+            await manager.config.update(
+                create_backup={"agent_ids": list(configured_agent_ids)}
+            )
+
+            return self.async_create_entry(title="", data={})
+
+        return self.async_show_form(
+            step_id="confirm", description_placeholders={"agent_id": self._agent_id}
+        )
+
+
+async def async_create_fix_flow(
+    hass: HomeAssistant,
+    issue_id: str,
+    data: dict[str, str | int | float | None] | None,
+) -> RepairsFlow:
+    """Create flow."""
+    if AUTOMATIC_BACKUP_AGENTS_NOT_LOADED_ISSUE_ID in issue_id:
+        assert data
+        agent_id = cast(str, data["agent_id"])
+        return AutomaticBackupAgentsNotLoaded(agent_id=agent_id)
+    return ConfirmRepairFlow()

homeassistant/components/backup/strings.json

@@ -1,5 +1,16 @@
 {
   "issues": {
+    "automatic_backup_agents_not_loaded": {
+      "title": "The backup location {agent_id} is not loaded",
+      "fix_flow": {
+        "step": {
+          "confirm": {
+            "title": "The backup location {agent_id} is not loaded",
+            "description": "The backup location `{agent_id}` is not loaded but is still configured for automatic backups.\n\nTo remove this backup location from configured automatic backups, press the submit button. Closing this dialog will keep the backup location configured but it will not be working until the backup location is loaded successfully again."
+          }
+        }
+      }
+    },
     "automatic_backup_failed_create": {
       "title": "Automatic backup could not be created",
       "description": "The automatic backup could not be created. Please check the logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured."

tests/components/backup/test_repairs.py

@@ -0,0 +1,194 @@
+"""Test the backup repair flows."""
+
+from http import HTTPStatus
+from typing import Any
+from unittest.mock import AsyncMock, Mock
+
+from homeassistant.components.backup import DOMAIN, store
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import issue_registry as ir
+from homeassistant.setup import async_setup_component
+
+from .common import BackupAgentTest, setup_backup_platform
+
+from tests.typing import ClientSessionGenerator, WebSocketGenerator
+
+
+async def test_agents_not_loaded_repair_flow(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    hass_ws_client: WebSocketGenerator,
+    issue_registry: ir.IssueRegistry,
+    hass_storage: dict[str, Any],
+) -> None:
+    """Test desired flow of the fix flow for legacy subscription."""
+    issue_id = "automatic_backup_agents_not_loaded_test.agent"
+    ws_client = await hass_ws_client(hass)
+    hass_storage.update(
+        {
+            "backup": {
+                "data": {
+                    "backups": [],
+                    "config": {
+                        "agents": {},
+                        "create_backup": {
+                            "agent_ids": ["test.agent"],
+                            "include_addons": None,
+                            "include_all_addons": False,
+                            "include_database": False,
+                            "include_folders": None,
+                            "name": None,
+                            "password": None,
+                        },
+                        "retention": {"copies": None, "days": None},
+                        "last_attempted_automatic_backup": None,
+                        "last_completed_automatic_backup": None,
+                        "schedule": {
+                            "days": ["mon"],
+                            "recurrence": "custom_days",
+                            "state": "never",
+                            "time": None,
+                        },
+                    },
+                },
+                "key": DOMAIN,
+                "version": store.STORAGE_VERSION,
+                "minor_version": store.STORAGE_VERSION_MINOR,
+            },
+        }
+    )
+    assert await async_setup_component(hass, DOMAIN, {})
+
+    get_agents_mock = AsyncMock(return_value=[BackupAgentTest("agent", backups=[])])
+    register_listener_mock = Mock()
+
+    await setup_backup_platform(
+        hass,
+        domain="test",
+        platform=Mock(
+            async_get_backup_agents=get_agents_mock,
+            async_register_backup_agents_listener=register_listener_mock,
+        ),
+    )
+    await hass.async_block_till_done()
+
+    reload_backup_agents = register_listener_mock.call_args[1]["listener"]
+
+    client = await hass_client()
+
+    await ws_client.send_json_auto_id({"type": "backup/agents/info"})
+    resp = await ws_client.receive_json()
+    assert resp["result"]["agents"] == [
+        {"agent_id": "backup.local", "name": "local"},
+        {"agent_id": "test.agent", "name": "agent"},
+    ]
+
+    repair_issue = issue_registry.async_get_issue(domain=DOMAIN, issue_id=issue_id)
+    assert not repair_issue
+
+    # Reload the agents with no agents returned.
+
+    get_agents_mock.return_value = []
+    reload_backup_agents()
+    await hass.async_block_till_done()
+
+    await ws_client.send_json_auto_id({"type": "backup/agents/info"})
+    resp = await ws_client.receive_json()
+    assert resp["result"]["agents"] == [
+        {"agent_id": "backup.local", "name": "local"},
+    ]
+
+    repair_issue = issue_registry.async_get_issue(domain=DOMAIN, issue_id=issue_id)
+    assert repair_issue
+
+    # Start the repair flow.
+
+    resp = await client.post(
+        "/api/repairs/issues/fix",
+        json={"handler": DOMAIN, "issue_id": issue_id},
+    )
+
+    assert resp.status == HTTPStatus.OK
+    data = await resp.json()
+
+    flow_id = data["flow_id"]
+    assert data == {
+        "type": "form",
+        "flow_id": flow_id,
+        "handler": DOMAIN,
+        "step_id": "confirm",
+        "data_schema": [],
+        "errors": None,
+        "description_placeholders": {"agent_id": "test.agent"},
+        "last_step": None,
+        "preview": None,
+    }
+
+    # Aborting the flow should not remove the issue and not update the config.
+
+    resp = await client.delete(f"/api/repairs/issues/fix/{flow_id}")
+
+    assert resp.status == HTTPStatus.OK
+    data = await resp.json()
+
+    assert data == {"message": "Flow aborted"}
+
+    resp = await client.get(f"/api/repairs/issues/fix/{flow_id}")
+
+    assert resp.status == HTTPStatus.NOT_FOUND
+    data = await resp.json()
+
+    repair_issue = issue_registry.async_get_issue(domain=DOMAIN, issue_id=issue_id)
+    assert repair_issue
+
+    await ws_client.send_json_auto_id({"type": "backup/config/info"})
+    result = await ws_client.receive_json()
+    assert result["result"]["config"]["create_backup"]["agent_ids"] == ["test.agent"]
+
+    # Start the repair flow again.
+
+    resp = await client.post(
+        "/api/repairs/issues/fix",
+        json={"handler": DOMAIN, "issue_id": issue_id},
+    )
+
+    assert resp.status == HTTPStatus.OK
+    data = await resp.json()
+
+    flow_id = data["flow_id"]
+    assert data == {
+        "type": "form",
+        "flow_id": flow_id,
+        "handler": DOMAIN,
+        "step_id": "confirm",
+        "data_schema": [],
+        "errors": None,
+        "description_placeholders": {"agent_id": "test.agent"},
+        "last_step": None,
+        "preview": None,
+    }
+
+    # Finish the flow.
+
+    resp = await client.post(f"/api/repairs/issues/fix/{flow_id}")
+
+    assert resp.status == HTTPStatus.OK
+    data = await resp.json()
+
+    flow_id = data["flow_id"]
+    assert data == {
+        "type": "create_entry",
+        "flow_id": flow_id,
+        "handler": DOMAIN,
+        "description": None,
+        "description_placeholders": None,
+        "title": "",
+    }
+
+    assert not issue_registry.async_get_issue(
+        domain=DOMAIN, issue_id="automatic_backup_agents_not_loaded"
+    )
+
+    await ws_client.send_json_auto_id({"type": "backup/config/info"})
+    result = await ws_client.receive_json()
+    assert result["result"]["config"]["create_backup"]["agent_ids"] == []