Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use UID instead of MAC or channel for unique_ID in Reolink (#119744)

pull/120119/head^2
starkillerOG 2024-06-21 20:27:30 +02:00 committed by GitHub
parent d6be733287
commit 8b4a5042bb
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 213 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
homeassistant/components/reolink/__init__.py
View File

@ -15,6 +15,7 @@ from homeassistant.const import EVENT_HOMEASSISTANT_STOP, Platform
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
from homeassistant.helpers import device_registry as dr, entity_registry as er
from homeassistant.helpers.device_registry import format_mac
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import DOMAIN
@ -141,8 +142,9 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
firmware_coordinator=firmware_coordinator,
)
cleanup_disconnected_cams(hass, config_entry.entry_id, host)
# first migrate and then cleanup, otherwise entities lost
migrate_entity_ids(hass, config_entry.entry_id, host)
cleanup_disconnected_cams(hass, config_entry.entry_id, host)
await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
@ -173,6 +175,24 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
return unload_ok
def get_device_uid_and_ch(
device: dr.DeviceEntry, host: ReolinkHost
) -> tuple[list[str], int | None]:
"""Get the channel and the split device_uid from a reolink DeviceEntry."""
device_uid = [
dev_id[1].split("_") for dev_id in device.identifiers if dev_id[0] == DOMAIN
][0]
if len(device_uid) < 2:
# NVR itself
ch = None
elif device_uid[1].startswith("ch") and len(device_uid[1]) <= 5:
ch = int(device_uid[1][2:])
else:
ch = host.api.channel_for_uid(device_uid[1])
return (device_uid, ch)
def cleanup_disconnected_cams(
hass: HomeAssistant, config_entry_id: str, host: ReolinkHost
) -> None:
@ -183,17 +203,10 @@ def cleanup_disconnected_cams(
device_reg = dr.async_get(hass)
devices = dr.async_entries_for_config_entry(device_reg, config_entry_id)
for device in devices:
device_id = [
dev_id[1].split("_ch")
for dev_id in device.identifiers
if dev_id[0] == DOMAIN
][0]
(device_uid, ch) = get_device_uid_and_ch(device, host)
if ch is None:
continue # Do not consider the NVR itself
if len(device_id) < 2:
# Do not consider the NVR itself
continue
ch = int(device_id[1])
ch_model = host.api.camera_model(ch)
remove = False
if ch not in host.api.channels:
@ -225,11 +238,54 @@ def migrate_entity_ids(
hass: HomeAssistant, config_entry_id: str, host: ReolinkHost
) -> None:
"""Migrate entity IDs if needed."""
device_reg = dr.async_get(hass)
devices = dr.async_entries_for_config_entry(device_reg, config_entry_id)
ch_device_ids = {}
for device in devices:
(device_uid, ch) = get_device_uid_and_ch(device, host)
if host.api.supported(None, "UID") and device_uid[0] != host.unique_id:
if ch is None:
new_device_id = f"{host.unique_id}"
else:
new_device_id = f"{host.unique_id}_{device_uid[1]}"
new_identifiers = {(DOMAIN, new_device_id)}
device_reg.async_update_device(device.id, new_identifiers=new_identifiers)
if ch is None:
continue # Do not consider the NVR itself
ch_device_ids[device.id] = ch
if host.api.supported(ch, "UID") and device_uid[1] != host.api.camera_uid(ch):
if host.api.supported(None, "UID"):
new_device_id = f"{host.unique_id}_{host.api.camera_uid(ch)}"
else:
new_device_id = f"{device_uid[0]}_{host.api.camera_uid(ch)}"
new_identifiers = {(DOMAIN, new_device_id)}
device_reg.async_update_device(device.id, new_identifiers=new_identifiers)
entity_reg = er.async_get(hass)
entities = er.async_entries_for_config_entry(entity_reg, config_entry_id)
for entity in entities:
# Can be removed in HA 2025.1.0
if entity.domain == "update" and entity.unique_id == host.unique_id:
if entity.domain == "update" and entity.unique_id in [
host.unique_id,
format_mac(host.api.mac_address),
]:
entity_reg.async_update_entity(
entity.entity_id, new_unique_id=f"{host.unique_id}_firmware"
)
continue
if host.api.supported(None, "UID") and not entity.unique_id.startswith(
host.unique_id
):
new_id = f"{host.unique_id}_{entity.unique_id.split("_", 1)[1]}"
entity_reg.async_update_entity(entity.entity_id, new_unique_id=new_id)
if entity.device_id in ch_device_ids:
ch = ch_device_ids[entity.device_id]
id_parts = entity.unique_id.split("_", 2)
if host.api.supported(ch, "UID") and id_parts[1] != host.api.camera_uid(ch):
new_id = f"{host.unique_id}_{host.api.camera_uid(ch)}_{id_parts[2]}"
entity_reg.async_update_entity(entity.entity_id, new_unique_id=new_id)

3
homeassistant/components/reolink/config_flow.py
View File

@ -228,8 +228,9 @@ class ReolinkFlowHandler(ConfigFlow, domain=DOMAIN):
user_input[CONF_PORT] = host.api.port
user_input[CONF_USE_HTTPS] = host.api.use_https
mac_address = format_mac(host.api.mac_address)
existing_entry = await self.async_set_unique_id(
host.unique_id, raise_on_progress=False
mac_address, raise_on_progress=False
)
if existing_entry and self._reauth:
if self.hass.config_entries.async_update_entry(

16
homeassistant/components/reolink/entity.py
View File

@ -112,17 +112,25 @@ class ReolinkChannelCoordinatorEntity(ReolinkHostCoordinatorEntity):
super().__init__(reolink_data, coordinator)
self._channel = channel
self._attr_unique_id = (
f"{self._host.unique_id}_{channel}_{self.entity_description.key}"
)
if self._host.api.supported(channel, "UID"):
self._attr_unique_id = f"{self._host.unique_id}_{self._host.api.camera_uid(channel)}_{self.entity_description.key}"
else:
self._attr_unique_id = (
f"{self._host.unique_id}_{channel}_{self.entity_description.key}"
)
dev_ch = channel
if self._host.api.model in DUAL_LENS_MODELS:
dev_ch = 0
if self._host.api.is_nvr:
if self._host.api.supported(dev_ch, "UID"):
dev_id = f"{self._host.unique_id}_{self._host.api.camera_uid(dev_ch)}"
else:
dev_id = f"{self._host.unique_id}_ch{dev_ch}"
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, f"{self._host.unique_id}_ch{dev_ch}")},
identifiers={(DOMAIN, dev_id)},
via_device=(DOMAIN, self._host.unique_id),
name=self._host.api.camera_name(dev_ch),
model=self._host.api.camera_model(dev_ch),

5
homeassistant/components/reolink/host.py
View File

@ -191,7 +191,10 @@ class ReolinkHost:
else:
ir.async_delete_issue(self._hass, DOMAIN, "enable_port")
self._unique_id = format_mac(self._api.mac_address)
if self._api.supported(None, "UID"):
self._unique_id = self._api.uid
else:
self._unique_id = format_mac(self._api.mac_address)
if self._onvif_push_supported:
try:

10
homeassistant/components/reolink/media_source.py
View File

@ -164,10 +164,14 @@ class ReolinkVODMediaSource(MediaSource):
continue
device = device_reg.async_get(entity.device_id)
ch = entity.unique_id.split("_")[1]
if ch in channels or device is None:
ch_id = entity.unique_id.split("_")[1]
if ch_id in channels or device is None:
continue
channels.append(ch)
channels.append(ch_id)
ch: int | str = ch_id
if len(ch_id) > 3:
ch = host.api.channel_for_uid(ch_id)
if (
host.api.api_version("recReplay", int(ch)) < 1

2
homeassistant/components/reolink/switch.py
View File

@ -330,8 +330,6 @@ class ReolinkNVRSwitchEntity(ReolinkHostCoordinatorEntity, SwitchEntity):
self.entity_description = entity_description
super().__init__(reolink_data)
self._attr_unique_id = f"{self._host.unique_id}_{entity_description.key}"
@property
def is_on(self) -> bool:
"""Return true if switch is on."""

4
tests/components/reolink/conftest.py
View File

@ -29,6 +29,7 @@ TEST_MAC = "aa:bb:cc:dd:ee:ff"
TEST_MAC2 = "ff:ee:dd:cc:bb:aa"
DHCP_FORMATTED_MAC = "aabbccddeeff"
TEST_UID = "ABC1234567D89EFG"
TEST_UID_CAM = "DEF7654321D89GHT"
TEST_PORT = 1234
TEST_NVR_NAME = "test_reolink_name"
TEST_NVR_NAME2 = "test2_reolink_name"
@ -86,7 +87,8 @@ def reolink_connect_class() -> Generator[MagicMock]:
host_mock.camera_name.return_value = TEST_NVR_NAME
host_mock.camera_hardware_version.return_value = "IPC_00001"
host_mock.camera_sw_version.return_value = "v1.1.0.0.0.0000"
host_mock.camera_uid.return_value = TEST_UID
host_mock.camera_uid.return_value = TEST_UID_CAM
host_mock.channel_for_uid.return_value = 0
host_mock.get_encoding.return_value = "h264"
host_mock.firmware_update_available.return_value = False
host_mock.session_active = True

121
tests/components/reolink/test_init.py
View File

@ -20,7 +20,14 @@ from homeassistant.helpers import (
from homeassistant.setup import async_setup_component
from homeassistant.util.dt import utcnow
from .conftest import TEST_CAM_MODEL, TEST_HOST_MODEL, TEST_MAC, TEST_NVR_NAME
from .conftest import (
TEST_CAM_MODEL,
TEST_HOST_MODEL,
TEST_MAC,
TEST_NVR_NAME,
TEST_UID,
TEST_UID_CAM,
)
from tests.common import MockConfigEntry, async_fire_time_changed
@ -178,17 +185,104 @@ async def test_cleanup_disconnected_cams(
assert sorted(device_models) == sorted(expected_models)
@pytest.mark.parametrize(
(
"original_id",
"new_id",
"original_dev_id",
"new_dev_id",
"domain",
"support_uid",
"support_ch_uid",
),
[
(
TEST_MAC,
f"{TEST_MAC}_firmware",
f"{TEST_MAC}",
f"{TEST_MAC}",
Platform.UPDATE,
False,
False,
),
(
TEST_MAC,
f"{TEST_UID}_firmware",
f"{TEST_MAC}",
f"{TEST_UID}",
Platform.UPDATE,
True,
False,
),
(
f"{TEST_MAC}_0_record_audio",
f"{TEST_UID}_0_record_audio",
f"{TEST_MAC}_ch0",
f"{TEST_UID}_ch0",
Platform.SWITCH,
True,
False,
),
(
f"{TEST_MAC}_0_record_audio",
f"{TEST_MAC}_{TEST_UID_CAM}_record_audio",
f"{TEST_MAC}_ch0",
f"{TEST_MAC}_{TEST_UID_CAM}",
Platform.SWITCH,
False,
True,
),
(
f"{TEST_MAC}_0_record_audio",
f"{TEST_UID}_{TEST_UID_CAM}_record_audio",
f"{TEST_MAC}_ch0",
f"{TEST_UID}_{TEST_UID_CAM}",
Platform.SWITCH,
True,
True,
),
(
f"{TEST_UID}_0_record_audio",
f"{TEST_UID}_{TEST_UID_CAM}_record_audio",
f"{TEST_UID}_ch0",
f"{TEST_UID}_{TEST_UID_CAM}",
Platform.SWITCH,
True,
True,
),
],
)
async def test_migrate_entity_ids(
hass: HomeAssistant,
config_entry: MockConfigEntry,
reolink_connect: MagicMock,
entity_registry: er.EntityRegistry,
device_registry: dr.DeviceRegistry,
original_id: str,
new_id: str,
original_dev_id: str,
new_dev_id: str,
domain: Platform,
support_uid: bool,
support_ch_uid: bool,
) -> None:
"""Test entity ids that need to be migrated."""
def mock_supported(ch, capability):
if capability == "UID" and ch is None:
return support_uid
if capability == "UID":
return support_ch_uid
return True
reolink_connect.channels = [0]
original_id = f"{TEST_MAC}"
new_id = f"{TEST_MAC}_firmware"
domain = Platform.UPDATE
reolink_connect.supported = mock_supported
dev_entry = device_registry.async_get_or_create(
identifiers={(const.DOMAIN, original_dev_id)},
config_entry_id=config_entry.entry_id,
disabled_by=None,
)
entity_registry.async_get_or_create(
domain=domain,
@ -197,11 +291,21 @@ async def test_migrate_entity_ids(
config_entry=config_entry,
suggested_object_id=original_id,
disabled_by=None,
device_id=dev_entry.id,
)
assert entity_registry.async_get_entity_id(domain, const.DOMAIN, original_id)
assert entity_registry.async_get_entity_id(domain, const.DOMAIN, new_id) is None
assert device_registry.async_get_device(
identifiers={(const.DOMAIN, original_dev_id)}
)
if new_dev_id != original_dev_id:
assert (
device_registry.async_get_device(identifiers={(const.DOMAIN, new_dev_id)})
is None
)
# setup CH 0 and host entities/device
with patch("homeassistant.components.reolink.PLATFORMS", [domain]):
assert await hass.config_entries.async_setup(config_entry.entry_id)
@ -212,6 +316,15 @@ async def test_migrate_entity_ids(
)
assert entity_registry.async_get_entity_id(domain, const.DOMAIN, new_id)
if new_dev_id != original_dev_id:
assert (
device_registry.async_get_device(
identifiers={(const.DOMAIN, original_dev_id)}
)
is None
)
assert device_registry.async_get_device(identifiers={(const.DOMAIN, new_dev_id)})
async def test_no_repair_issue(
hass: HomeAssistant, config_entry: MockConfigEntry, issue_registry: ir.IssueRegistry