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