* repeate sending libp2p request on error\n * delete file with pinata…

… creds on unload\n * fix messages from logs\n * add message types

custom_components/robonomics_report_service/__init__.py

@@ -26,7 +26,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         entry.data[CONF_SENDER_SEED],
     )
     # async_register_frontend(hass)
-    await RWSRegistrationManager(hass, robonomics, entry.data[CONF_EMAIL]).register()
+    await RWSRegistrationManager.register(hass, robonomics, entry.data[CONF_EMAIL])
     ReportService(hass, robonomics).register()
     error_sources_manager = ErrorSourcesManager(hass)
     error_sources_manager.setup_sources()
@@ -49,5 +49,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     :return: True if all unload event were success
     """
     hass.data[DOMAIN][ERROR_SOURCES_MANAGER].remove_sources()
+    await RWSRegistrationManager.delete(hass)
     # async_remove_frontend(hass)
     return True

custom_components/robonomics_report_service/error_sources/sources/logger_handler.py

@@ -37,16 +37,16 @@ def remove(self):
         if self.unsub_timer is not None:
             self.unsub_timer()
 
-    def emit(self, record):
+    def emit(self, record: logging.LogRecord):
         if DOMAIN not in record.name:
             if record.levelname == "ERROR" or record.levelname == "CRITICAL":
-                _LOGGER.debug(f"New error message: {record.msg}")
-                error_msg = f"{record.name} - {record.levelname}: {record.msg}"
+                _LOGGER.debug(f"New error message: {record.message}")
+                error_msg = f"{record.name} - {record.levelname}: {record.message}"
                 asyncio.run_coroutine_threadsafe(
                     self._run_report_service(error_msg, "errors"), self.hass.loop
                 )
             elif record.levelname == "WARNING":
-                self._warning_messages.append(f"{record.name} - {record.levelname}: {record.msg}")
+                self._warning_messages.append(f"{record.name} - {record.levelname}: {record.message}")
 
     async def _send_warnings(self, _ = None) -> None:
         if len(self._warning_messages) > 0:

custom_components/robonomics_report_service/libp2p.py

@@ -25,6 +25,8 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+LIBP2P_LISTEN_ERRORS_PROTOCOL = "/feedback"
+
 
 class LibP2P:
     def __init__(self, hass: HomeAssistant, sender_seed: str, email: str):
@@ -37,14 +39,18 @@ def __init__(self, hass: HomeAssistant, sender_seed: str, email: str):
         self._listen_protocol = f"{LIBP2P_LISTEN_PROTOCOL}/{self.sender_address}"
 
     async def get_and_save_pinata_creds(self) -> bool:
+        _LOGGER.debug(f"Start getting Pinata creds")
         self._pinata_creds_saved = False
+        await self.libp2p_proxy.subscribe_to_protocol_async(
+            LIBP2P_LISTEN_ERRORS_PROTOCOL, self._handle_libp2p_feedback, reconnect=True
+        )
         await self.libp2p_proxy.subscribe_to_protocol_async(
             self._listen_protocol, self._save_pinata_creds, reconnect=True
         )
         await self._send_init_request()
         while not self._pinata_creds_saved:
             await asyncio.sleep(1)
-        _LOGGER.debug("Affter got pinata creds")
+        _LOGGER.debug("After got pinata creds")
         await self.libp2p_proxy.unsubscribe_from_all_protocols()
         return True
 
@@ -66,6 +72,12 @@ async def _save_pinata_creds(self, received_data: tp.Union[str, dict]):
             _LOGGER.debug("Got and saved pinata creds")
         else:
             _LOGGER.error(f"Libp2p message in wrong format: {received_data}")
+
+    async def _handle_libp2p_feedback(self, received_data: tp.Union[str, dict]):
+        _LOGGER.debug(f"Libp2p feedback: {received_data}")
+        if received_data['feedback'] != "ok":
+            await asyncio.sleep(5)
+            await self._send_init_request()
 
     def _decrypt_message(self, encrypted_data: str) -> str:
         return decrypt_message(

custom_components/robonomics_report_service/manifest.json

@@ -3,9 +3,9 @@
     "name": "Robonomics Report Service",
     "config_flow": true,
     "codeowners": ["@pinoutcloud"],
-    "version": "0.1.0-beta-3",
+    "version": "0.1.1",
     "dependencies": ["persistent_notification", "http", "frontend"],
-    "requirements": ["robonomics-interface~=1.6.0", "pinatapy-vourhey==0.1.9", "tenacity==8.2.2", "py-ws-libp2p-proxy==0.1.4"],
+    "requirements": ["robonomics-interface~=1.6.0", "pinatapy-vourhey==0.1.9", "tenacity==8.2.2", "py-ws-libp2p-proxy==0.2.0"],
     "documentation": "https://wiki.robonomics.network/",
     "issue_tracker": "https://github.com/PinoutLTD/rrs-ha-integration/issues"
   }

custom_components/robonomics_report_service/robonomics.py

@@ -33,6 +33,7 @@ def __init__(
             self.sender_seed, crypto_type=KeypairType.ED25519
         )
         self.sender_address: str = self.sender_account.get_address()
+        _LOGGER.debug(f"Sender address: {self.sender_address}")
         self.current_wss: str = ROBONOMICS_WSS[0]
         self.subscriber = None
         self._datalog_queue = deque()

custom_components/robonomics_report_service/rws_registration.py

@@ -1,17 +1,24 @@
 from homeassistant.core import HomeAssistant
+import logging
 
 from .robonomics import Robonomics
 from .libp2p import LibP2P
-from .utils import pinata_creds_exists
+from .utils import pinata_creds_exists, async_remove_store
+from .const import STORAGE_PINATA_CREDS
+
+_LOGGER = logging.getLogger(__name__)
 
 class RWSRegistrationManager:
-    def __init__(self, hass: HomeAssistant, robonomics: Robonomics, email: str) -> None:
-        self.hass = hass
-        self.robonomics = robonomics
-        self.libp2p = LibP2P(hass, self.robonomics.sender_seed, email)
 
-    async def register(self) -> None:
-        if not await pinata_creds_exists(self.hass):
-            await self.libp2p.get_and_save_pinata_creds()
-        await self.robonomics.wait_for_rws()
+    @staticmethod
+    async def register(hass: HomeAssistant, robonomics: Robonomics, email: str) -> None:
+        libp2p = LibP2P(hass, robonomics.sender_seed, email)
+        if not await pinata_creds_exists(hass):
+            await libp2p.get_and_save_pinata_creds()
+        await robonomics.wait_for_rws()
+
+    @staticmethod
+    async def delete(hass: HomeAssistant) -> None:
+        _LOGGER.debug("Remove pinata creds store")
+        await async_remove_store(hass, STORAGE_PINATA_CREDS)
 

custom_components/robonomics_report_service/utils.py

@@ -137,6 +137,11 @@ async def async_load_from_store(hass, key):
     return await _get_store_for_key(hass, key).async_load() or {}
 
 
+async def async_remove_store(hass: HomeAssistant, key: str):
+    """Remove data from store for given key"""
+    await _get_store_for_key(hass, key).async_remove()
+
+
 async def async_save_to_store(hass, key, data):
     """Generate dynamic data to store and save it to the filesystem.