class SynoApi: """Class to interface with Synology DSM API.""" def __init__(self, hass: HomeAssistantType, entry: ConfigEntry): """Initialize the API wrapper class.""" self._hass = hass self._entry = entry # DSM APIs self.dsm: SynologyDSM = None self.information: SynoDSMInformation = None self.network: SynoDSMNetwork = None self.security: SynoCoreSecurity = None self.storage: SynoStorage = None self.utilisation: SynoCoreUtilization = None self.surveillance_station: SynoSurveillanceStation = None # Should we fetch them self._fetching_entities = {} self._with_security = True self._with_storage = True self._with_utilisation = True self._with_information = True self._with_surveillance_station = True self._unsub_dispatcher = None @property def signal_sensor_update(self) -> str: """Event specific per Synology DSM entry to signal updates in sensors.""" return f"{DOMAIN}-{self.information.serial}-sensor-update" async def async_setup(self): """Start interacting with the NAS.""" self.dsm = SynologyDSM( self._entry.data[CONF_HOST], self._entry.data[CONF_PORT], self._entry.data[CONF_USERNAME], self._entry.data[CONF_PASSWORD], self._entry.data[CONF_SSL], timeout=self._entry.options.get(CONF_TIMEOUT), device_token=self._entry.data.get("device_token"), ) await self._hass.async_add_executor_job(self.dsm.discover_apis) self._with_surveillance_station = bool( self.dsm.apis.get(SynoSurveillanceStation.CAMERA_API_KEY)) self._async_setup_api_requests() await self._hass.async_add_executor_job( self._fetch_device_configuration) await self.async_update() self._unsub_dispatcher = async_track_time_interval( self._hass, self.async_update, timedelta(minutes=self._entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)), ) @callback def subscribe(self, api_key, unique_id): """Subscribe an entity from API fetches.""" if api_key not in self._fetching_entities: self._fetching_entities[api_key] = set() self._fetching_entities[api_key].add(unique_id) @callback def unsubscribe() -> None: """Unsubscribe an entity from API fetches (when disable).""" self._fetching_entities[api_key].remove(unique_id) return unsubscribe @callback def _async_setup_api_requests(self): """Determine if we should fetch each API, if one entity needs it.""" # Entities not added yet, fetch all if not self._fetching_entities: return # Determine if we should fetch an API self._with_security = bool( self._fetching_entities.get(SynoCoreSecurity.API_KEY)) self._with_storage = bool( self._fetching_entities.get(SynoStorage.API_KEY)) self._with_utilisation = bool( self._fetching_entities.get(SynoCoreUtilization.API_KEY)) self._with_information = bool( self._fetching_entities.get(SynoDSMInformation.API_KEY)) self._with_surveillance_station = bool( self._fetching_entities.get( SynoSurveillanceStation.CAMERA_API_KEY)) # Reset not used API, information is not reset since it's used in device_info if not self._with_security: self.dsm.reset(self.security) self.security = None if not self._with_storage: self.dsm.reset(self.storage) self.storage = None if not self._with_utilisation: self.dsm.reset(self.utilisation) self.utilisation = None if not self._with_surveillance_station: self.dsm.reset(self.surveillance_station) self.surveillance_station = None def _fetch_device_configuration(self): """Fetch initial device config.""" self.information = self.dsm.information self.information.update() self.network = self.dsm.network self.network.update() if self._with_security: self.security = self.dsm.security if self._with_storage: self.storage = self.dsm.storage if self._with_utilisation: self.utilisation = self.dsm.utilisation if self._with_surveillance_station: self.surveillance_station = self.dsm.surveillance_station async def async_unload(self): """Stop interacting with the NAS and prepare for removal from hass.""" self._unsub_dispatcher() async def async_update(self, now=None): """Update function for updating API information.""" self._async_setup_api_requests() await self._hass.async_add_executor_job(self.dsm.update, self._with_information) async_dispatcher_send(self._hass, self.signal_sensor_update)
class SynoApi: """Class to interface with Synology DSM API.""" def __init__(self, hass: HomeAssistantType, entry: ConfigEntry): """Initialize the API wrapper class.""" self._hass = hass self._entry = entry # DSM APIs self.dsm: SynologyDSM = None self.information: SynoDSMInformation = None self.network: SynoDSMNetwork = None self.security: SynoCoreSecurity = None self.storage: SynoStorage = None self.surveillance_station: SynoSurveillanceStation = None self.system: SynoCoreSystem = None self.upgrade: SynoCoreUpgrade = None self.utilisation: SynoCoreUtilization = None # Should we fetch them self._fetching_entities = {} self._with_information = True self._with_security = True self._with_storage = True self._with_surveillance_station = True self._with_system = True self._with_upgrade = True self._with_utilisation = True self._unsub_dispatcher = None @property def signal_sensor_update(self) -> str: """Event specific per Synology DSM entry to signal updates in sensors.""" return f"{DOMAIN}-{self.information.serial}-sensor-update" async def async_setup(self): """Start interacting with the NAS.""" # init SynologyDSM object and login self.dsm = SynologyDSM( self._entry.data[CONF_HOST], self._entry.data[CONF_PORT], self._entry.data[CONF_USERNAME], self._entry.data[CONF_PASSWORD], self._entry.data[CONF_SSL], self._entry.data[CONF_VERIFY_SSL], timeout=self._entry.options.get(CONF_TIMEOUT), device_token=self._entry.data.get("device_token"), ) await self._hass.async_add_executor_job(self.dsm.login) # check if surveillance station is used self._with_surveillance_station = bool( self.dsm.apis.get(SynoSurveillanceStation.CAMERA_API_KEY)) _LOGGER.debug( "SynoAPI.async_setup() - self._with_surveillance_station:%s", self._with_surveillance_station, ) self._async_setup_api_requests() await self._hass.async_add_executor_job( self._fetch_device_configuration) await self.async_update() self._unsub_dispatcher = async_track_time_interval( self._hass, self.async_update, timedelta(minutes=self._entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)), ) @callback def subscribe(self, api_key, unique_id): """Subscribe an entity from API fetches.""" _LOGGER.debug("SynoAPI.subscribe() - api_key:%s, unique_id:%s", api_key, unique_id) if api_key not in self._fetching_entities: self._fetching_entities[api_key] = set() self._fetching_entities[api_key].add(unique_id) @callback def unsubscribe() -> None: """Unsubscribe an entity from API fetches (when disable).""" self._fetching_entities[api_key].remove(unique_id) return unsubscribe @callback def _async_setup_api_requests(self): """Determine if we should fetch each API, if one entity needs it.""" _LOGGER.debug( "SynoAPI._async_setup_api_requests() - self._fetching_entities:%s", self._fetching_entities, ) # Entities not added yet, fetch all if not self._fetching_entities: _LOGGER.debug( "SynoAPI._async_setup_api_requests() - Entities not added yet, fetch all" ) return # Determine if we should fetch an API self._with_security = bool( self._fetching_entities.get(SynoCoreSecurity.API_KEY)) self._with_storage = bool( self._fetching_entities.get(SynoStorage.API_KEY)) self._with_system = bool( self._fetching_entities.get(SynoCoreSystem.API_KEY)) self._with_upgrade = bool( self._fetching_entities.get(SynoCoreUpgrade.API_KEY)) self._with_utilisation = bool( self._fetching_entities.get(SynoCoreUtilization.API_KEY)) self._with_information = bool( self._fetching_entities.get(SynoDSMInformation.API_KEY)) self._with_surveillance_station = bool( self.dsm.apis.get(SynoSurveillanceStation.CAMERA_API_KEY)) # Reset not used API, information is not reset since it's used in device_info if not self._with_security: _LOGGER.debug( "SynoAPI._async_setup_api_requests() - disable security") self.dsm.reset(self.security) self.security = None if not self._with_storage: _LOGGER.debug( "SynoAPI._async_setup_api_requests() - disable storage") self.dsm.reset(self.storage) self.storage = None if not self._with_system: _LOGGER.debug( "SynoAPI._async_setup_api_requests() - disable system") self.dsm.reset(self.system) self.system = None if not self._with_upgrade: _LOGGER.debug( "SynoAPI._async_setup_api_requests() - disable upgrade") self.dsm.reset(self.upgrade) self.upgrade = None if not self._with_utilisation: _LOGGER.debug( "SynoAPI._async_setup_api_requests() - disable utilisation") self.dsm.reset(self.utilisation) self.utilisation = None if not self._with_surveillance_station: _LOGGER.debug( "SynoAPI._async_setup_api_requests() - disable surveillance_station" ) self.dsm.reset(self.surveillance_station) self.surveillance_station = None def _fetch_device_configuration(self): """Fetch initial device config.""" self.information = self.dsm.information self.network = self.dsm.network self.network.update() if self._with_security: _LOGGER.debug( "SynoAPI._fetch_device_configuration() - fetch security") self.security = self.dsm.security if self._with_storage: _LOGGER.debug( "SynoAPI._fetch_device_configuration() - fetch storage") self.storage = self.dsm.storage if self._with_upgrade: _LOGGER.debug( "SynoAPI._fetch_device_configuration() - fetch upgrade") self.upgrade = self.dsm.upgrade if self._with_system: _LOGGER.debug( "SynoAPI._fetch_device_configuration() - fetch system") self.system = self.dsm.system if self._with_utilisation: _LOGGER.debug( "SynoAPI._fetch_device_configuration() - fetch utilisation") self.utilisation = self.dsm.utilisation if self._with_surveillance_station: _LOGGER.debug( "SynoAPI._fetch_device_configuration() - fetch surveillance_station" ) self.surveillance_station = self.dsm.surveillance_station async def async_reboot(self): """Reboot NAS.""" if not self.system: _LOGGER.debug("SynoAPI.async_reboot() - System API not ready: %s", self) return await self._hass.async_add_executor_job(self.system.reboot) async def async_shutdown(self): """Shutdown NAS.""" if not self.system: _LOGGER.debug( "SynoAPI.async_shutdown() - System API not ready: %s", self) return await self._hass.async_add_executor_job(self.system.shutdown) async def async_unload(self): """Stop interacting with the NAS and prepare for removal from hass.""" self._unsub_dispatcher() async def async_update(self, now=None): """Update function for updating API information.""" _LOGGER.debug("SynoAPI.async_update()") self._async_setup_api_requests() try: await self._hass.async_add_executor_job(self.dsm.update, self._with_information) except (SynologyDSMLoginFailedException, SynologyDSMRequestException) as err: _LOGGER.warning( "async_update - connection error during update, fallback by reloading the entry" ) _LOGGER.debug("SynoAPI.async_update() - exception: %s", err) await self._hass.config_entries.async_reload(self._entry.entry_id) return async_dispatcher_send(self._hass, self.signal_sensor_update)
class SynoApi: """Class to interface with Synology DSM API.""" def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None: """Initialize the API wrapper class.""" self._hass = hass self._entry = entry if entry.data.get(CONF_SSL): self.config_url = f"https://{entry.data[CONF_HOST]}:{entry.data[CONF_PORT]}" else: self.config_url = f"http://{entry.data[CONF_HOST]}:{entry.data[CONF_PORT]}" self.initialized = False # DSM APIs self.dsm: SynologyDSM = None self.information: SynoDSMInformation = None self.network: SynoDSMNetwork = None self.security: SynoCoreSecurity = None self.storage: SynoStorage = None self.surveillance_station: SynoSurveillanceStation = None self.system: SynoCoreSystem = None self.upgrade: SynoCoreUpgrade = None self.utilisation: SynoCoreUtilization = None # Should we fetch them self._fetching_entities: dict[str, set[str]] = {} self._with_information = True self._with_security = True self._with_storage = True self._with_surveillance_station = True self._with_system = True self._with_upgrade = True self._with_utilisation = True async def async_setup(self) -> None: """Start interacting with the NAS.""" self.dsm = SynologyDSM( self._entry.data[CONF_HOST], self._entry.data[CONF_PORT], self._entry.data[CONF_USERNAME], self._entry.data[CONF_PASSWORD], self._entry.data[CONF_SSL], self._entry.data[CONF_VERIFY_SSL], timeout=self._entry.options.get(CONF_TIMEOUT), device_token=self._entry.data.get(CONF_DEVICE_TOKEN), ) await self._hass.async_add_executor_job(self.dsm.login) # check if surveillance station is used self._with_surveillance_station = bool( self.dsm.apis.get(SynoSurveillanceStation.CAMERA_API_KEY) ) _LOGGER.debug( "State of Surveillance_station during setup of '%s': %s", self._entry.unique_id, self._with_surveillance_station, ) self._async_setup_api_requests() await self._hass.async_add_executor_job(self._fetch_device_configuration) await self.async_update() self.initialized = True @callback def subscribe(self, api_key: str, unique_id: str) -> Callable[[], None]: """Subscribe an entity to API fetches.""" _LOGGER.debug("Subscribe new entity: %s", unique_id) if api_key not in self._fetching_entities: self._fetching_entities[api_key] = set() self._fetching_entities[api_key].add(unique_id) @callback def unsubscribe() -> None: """Unsubscribe an entity from API fetches (when disable).""" _LOGGER.debug("Unsubscribe entity: %s", unique_id) self._fetching_entities[api_key].remove(unique_id) if len(self._fetching_entities[api_key]) == 0: self._fetching_entities.pop(api_key) return unsubscribe @callback def _async_setup_api_requests(self) -> None: """Determine if we should fetch each API, if one entity needs it.""" # Entities not added yet, fetch all if not self._fetching_entities: _LOGGER.debug( "Entities not added yet, fetch all for '%s'", self._entry.unique_id ) return # surveillance_station is updated by own coordinator self.dsm.reset(self.surveillance_station) # Determine if we should fetch an API self._with_system = bool(self.dsm.apis.get(SynoCoreSystem.API_KEY)) self._with_security = bool( self._fetching_entities.get(SynoCoreSecurity.API_KEY) ) self._with_storage = bool(self._fetching_entities.get(SynoStorage.API_KEY)) self._with_upgrade = bool(self._fetching_entities.get(SynoCoreUpgrade.API_KEY)) self._with_utilisation = bool( self._fetching_entities.get(SynoCoreUtilization.API_KEY) ) self._with_information = bool( self._fetching_entities.get(SynoDSMInformation.API_KEY) ) # Reset not used API, information is not reset since it's used in device_info if not self._with_security: _LOGGER.debug( "Disable security api from being updated for '%s'", self._entry.unique_id, ) self.dsm.reset(self.security) self.security = None if not self._with_storage: _LOGGER.debug( "Disable storage api from being updatedf or '%s'", self._entry.unique_id ) self.dsm.reset(self.storage) self.storage = None if not self._with_system: _LOGGER.debug( "Disable system api from being updated for '%s'", self._entry.unique_id ) self.dsm.reset(self.system) self.system = None if not self._with_upgrade: _LOGGER.debug( "Disable upgrade api from being updated for '%s'", self._entry.unique_id ) self.dsm.reset(self.upgrade) self.upgrade = None if not self._with_utilisation: _LOGGER.debug( "Disable utilisation api from being updated for '%s'", self._entry.unique_id, ) self.dsm.reset(self.utilisation) self.utilisation = None def _fetch_device_configuration(self) -> None: """Fetch initial device config.""" self.information = self.dsm.information self.network = self.dsm.network self.network.update() if self._with_security: _LOGGER.debug("Enable security api updates for '%s'", self._entry.unique_id) self.security = self.dsm.security if self._with_storage: _LOGGER.debug("Enable storage api updates for '%s'", self._entry.unique_id) self.storage = self.dsm.storage if self._with_upgrade: _LOGGER.debug("Enable upgrade api updates for '%s'", self._entry.unique_id) self.upgrade = self.dsm.upgrade if self._with_system: _LOGGER.debug("Enable system api updates for '%s'", self._entry.unique_id) self.system = self.dsm.system if self._with_utilisation: _LOGGER.debug( "Enable utilisation api updates for '%s'", self._entry.unique_id ) self.utilisation = self.dsm.utilisation if self._with_surveillance_station: _LOGGER.debug( "Enable surveillance_station api updates for '%s'", self._entry.unique_id, ) self.surveillance_station = self.dsm.surveillance_station async def async_reboot(self) -> None: """Reboot NAS.""" try: await self._hass.async_add_executor_job(self.system.reboot) except (SynologyDSMLoginFailedException, SynologyDSMRequestException) as err: _LOGGER.error( "Reboot of '%s' not possible, please try again later", self._entry.unique_id, ) _LOGGER.debug("Exception:%s", err) async def async_shutdown(self) -> None: """Shutdown NAS.""" try: await self._hass.async_add_executor_job(self.system.shutdown) except (SynologyDSMLoginFailedException, SynologyDSMRequestException) as err: _LOGGER.error( "Shutdown of '%s' not possible, please try again later", self._entry.unique_id, ) _LOGGER.debug("Exception:%s", err) async def async_unload(self) -> None: """Stop interacting with the NAS and prepare for removal from hass.""" try: await self._hass.async_add_executor_job(self.dsm.logout) except (SynologyDSMAPIErrorException, SynologyDSMRequestException) as err: _LOGGER.debug( "Logout from '%s' not possible:%s", self._entry.unique_id, err ) async def async_update(self, now: timedelta | None = None) -> None: """Update function for updating API information.""" _LOGGER.debug("Start data update for '%s'", self._entry.unique_id) self._async_setup_api_requests() try: await self._hass.async_add_executor_job( self.dsm.update, self._with_information ) except (SynologyDSMLoginFailedException, SynologyDSMRequestException) as err: if not self.initialized: raise err _LOGGER.warning( "Connection error during update, fallback by reloading the entry" ) _LOGGER.debug( "Connection error during update of '%s' with exception: %s", self._entry.unique_id, err, ) await self._hass.config_entries.async_reload(self._entry.entry_id) return
class SynoApi: """Class to interface with Synology DSM API.""" def __init__(self, hass: HomeAssistantType, entry: ConfigEntry): """Initialize the API wrapper class.""" self._hass = hass self._entry = entry # DSM APIs self.dsm: SynologyDSM = None self.information: SynoDSMInformation = None self.network: SynoDSMNetwork = None self.security: SynoCoreSecurity = None self.storage: SynoStorage = None self.surveillance_station: SynoSurveillanceStation = None self.system: SynoCoreSystem = None self.upgrade: SynoCoreUpgrade = None self.utilisation: SynoCoreUtilization = None # Should we fetch them self._fetching_entities = {} self._with_information = True self._with_security = True self._with_storage = True self._with_surveillance_station = True self._with_system = True self._with_upgrade = True self._with_utilisation = True async def async_setup(self): """Start interacting with the NAS.""" self.dsm = SynologyDSM( self._entry.data[CONF_HOST], self._entry.data[CONF_PORT], self._entry.data[CONF_USERNAME], self._entry.data[CONF_PASSWORD], self._entry.data[CONF_SSL], self._entry.data[CONF_VERIFY_SSL], timeout=self._entry.options.get(CONF_TIMEOUT), device_token=self._entry.data.get(CONF_DEVICE_TOKEN), ) await self._hass.async_add_executor_job(self.dsm.login) # check if surveillance station is used self._with_surveillance_station = bool( self.dsm.apis.get(SynoSurveillanceStation.CAMERA_API_KEY) ) _LOGGER.debug( "SynoAPI.async_setup() - self._with_surveillance_station:%s", self._with_surveillance_station, ) self._setup_api_requests() await self._hass.async_add_executor_job(self._fetch_device_configuration) await self.async_update() @callback def subscribe(self, api_key, unique_id): """Subscribe an entity to API fetches.""" _LOGGER.debug( "SynoAPI.subscribe() - api_key:%s, unique_id:%s", api_key, unique_id ) if api_key not in self._fetching_entities: self._fetching_entities[api_key] = set() self._fetching_entities[api_key].add(unique_id) @callback def unsubscribe() -> None: """Unsubscribe an entity from API fetches (when disable).""" _LOGGER.debug( "SynoAPI.unsubscribe() - api_key:%s, unique_id:%s", api_key, unique_id ) self._fetching_entities[api_key].remove(unique_id) if len(self._fetching_entities[api_key]) == 0: self._fetching_entities.pop(api_key) return unsubscribe @callback def _setup_api_requests(self): """Determine if we should fetch each API, if one entity needs it.""" # Entities not added yet, fetch all if not self._fetching_entities: _LOGGER.debug( "SynoAPI._setup_api_requests() - Entities not added yet, fetch all" ) return # Determine if we should fetch an API self._with_system = bool(self.dsm.apis.get(SynoCoreSystem.API_KEY)) self._with_surveillance_station = bool( self.dsm.apis.get(SynoSurveillanceStation.CAMERA_API_KEY) ) or bool(self.dsm.apis.get(SynoSurveillanceStation.HOME_MODE_API_KEY)) self._with_security = bool( self._fetching_entities.get(SynoCoreSecurity.API_KEY) ) self._with_storage = bool(self._fetching_entities.get(SynoStorage.API_KEY)) self._with_upgrade = bool(self._fetching_entities.get(SynoCoreUpgrade.API_KEY)) self._with_utilisation = bool( self._fetching_entities.get(SynoCoreUtilization.API_KEY) ) self._with_information = bool( self._fetching_entities.get(SynoDSMInformation.API_KEY) ) # Reset not used API, information is not reset since it's used in device_info if not self._with_security: _LOGGER.debug("SynoAPI._setup_api_requests() - disable security") self.dsm.reset(self.security) self.security = None if not self._with_storage: _LOGGER.debug("SynoAPI._setup_api_requests() - disable storage") self.dsm.reset(self.storage) self.storage = None if not self._with_system: _LOGGER.debug("SynoAPI._setup_api_requests() - disable system") self.dsm.reset(self.system) self.system = None if not self._with_upgrade: _LOGGER.debug("SynoAPI._setup_api_requests() - disable upgrade") self.dsm.reset(self.upgrade) self.upgrade = None if not self._with_utilisation: _LOGGER.debug("SynoAPI._setup_api_requests() - disable utilisation") self.dsm.reset(self.utilisation) self.utilisation = None if not self._with_surveillance_station: _LOGGER.debug( "SynoAPI._setup_api_requests() - disable surveillance_station" ) self.dsm.reset(self.surveillance_station) self.surveillance_station = None def _fetch_device_configuration(self): """Fetch initial device config.""" self.information = self.dsm.information self.network = self.dsm.network self.network.update() if self._with_security: _LOGGER.debug("SynoAPI._fetch_device_configuration() - fetch security") self.security = self.dsm.security if self._with_storage: _LOGGER.debug("SynoAPI._fetch_device_configuration() - fetch storage") self.storage = self.dsm.storage if self._with_upgrade: _LOGGER.debug("SynoAPI._fetch_device_configuration() - fetch upgrade") self.upgrade = self.dsm.upgrade if self._with_system: _LOGGER.debug("SynoAPI._fetch_device_configuration() - fetch system") self.system = self.dsm.system if self._with_utilisation: _LOGGER.debug("SynoAPI._fetch_device_configuration() - fetch utilisation") self.utilisation = self.dsm.utilisation if self._with_surveillance_station: _LOGGER.debug( "SynoAPI._fetch_device_configuration() - fetch surveillance_station" ) self.surveillance_station = self.dsm.surveillance_station async def async_reboot(self): """Reboot NAS.""" try: await self._hass.async_add_executor_job(self.system.reboot) except (SynologyDSMLoginFailedException, SynologyDSMRequestException) as err: _LOGGER.error("Reboot not possible, please try again later") _LOGGER.debug("Exception:%s", err) async def async_shutdown(self): """Shutdown NAS.""" try: await self._hass.async_add_executor_job(self.system.shutdown) except (SynologyDSMLoginFailedException, SynologyDSMRequestException) as err: _LOGGER.error("Shutdown not possible, please try again later") _LOGGER.debug("Exception:%s", err) async def async_unload(self): """Stop interacting with the NAS and prepare for removal from hass.""" try: await self._hass.async_add_executor_job(self.dsm.logout) except (SynologyDSMAPIErrorException, SynologyDSMRequestException) as err: _LOGGER.debug("Logout not possible:%s", err) async def async_update(self, now=None): """Update function for updating API information.""" _LOGGER.debug("SynoAPI.async_update()") self._setup_api_requests() try: await self._hass.async_add_executor_job( self.dsm.update, self._with_information ) except (SynologyDSMLoginFailedException, SynologyDSMRequestException) as err: _LOGGER.warning( "async_update - connection error during update, fallback by reloading the entry" ) _LOGGER.debug("SynoAPI.async_update() - exception: %s", err) await self._hass.config_entries.async_reload(self._entry.entry_id) return