Fix entering sync state (#142)

* Fix entering sync state

* Fix

Author: droserasprout

src/dipdup/datasources/tzkt/datasource.py

@@ -779,8 +779,8 @@ async def _on_head_message(self, message: List[Dict[str, Any]]) -> None:
     async def set_head_from_http(self) -> None:
         """Set block from `get_head_block` HTTP method for indexes to use the same level during initial sync"""
         if self._head:
-            self._logger.warning('Attempt to set head twice')
-            return
+            raise RuntimeError('Head is already set')
+
         block = await self.get_head_block()
         self._head, created = await Head.get_or_create(
             name=self._http._url,

src/dipdup/index.py

@@ -21,9 +21,7 @@
 from dipdup.context import DipDupContext
 from dipdup.datasources.tzkt.datasource import BigMapFetcher, OperationFetcher, TzktDatasource
 from dipdup.exceptions import ConfigInitializationException, InvalidDataError, ReindexingReason
-from dipdup.models import BigMapData, BigMapDiff, Head, HeadBlockData
-from dipdup.models import Index as IndexState
-from dipdup.models import IndexStatus, OperationData, Origination, Transaction
+from dipdup.models import BigMapData, BigMapDiff, HeadBlockData, IndexStatus, OperationData, Origination, Transaction
 from dipdup.utils import FormattedLogger
 from dipdup.utils.database import in_global_transaction
 
@@ -52,30 +50,27 @@ def state(self) -> models.Index:
             raise RuntimeError('Index state is not initialized')
         return self._state
 
-    async def initialize_state(self, state: Optional[IndexState] = None) -> None:
-        if not self._state:
-            if not state:
-                state, _ = await models.Index.get_or_create(
-                    name=self._config.name,
-                    type=self._config.kind,
-                    defaults=dict(
-                        level=self._config.first_level,
-                        config_hash=self._config.hash(),
-                        template=self._config.parent.name if self._config.parent else None,
-                        template_values=self._config.template_values,
-                    ),
-                )
-
-            self._state = state
+    async def initialize_state(self) -> None:
+        if self._state:
+            raise RuntimeError('Index state is already initialized')
+
+        self._state, _ = await models.Index.get_or_create(
+            name=self._config.name,
+            type=self._config.kind,
+            defaults=dict(
+                level=self._config.first_level,
+                config_hash=self._config.hash(),
+                template=self._config.parent.name if self._config.parent else None,
+                template_values=self._config.template_values,
+            ),
+        )
 
         # NOTE: No need to check hashes of indexes which are not synchronized.
         head = await self.state.head
-        if not head or self.state.level != head.level:
-            return
-
-        block = await self._datasource.get_block(self.state.level)
-        if head.hash != block.hash:
-            await self._ctx.reindex(ReindexingReason.BLOCK_HASH_MISMATCH)
+        if head and self.state.status == IndexStatus.REALTIME:
+            block = await self._datasource.get_block(head.level)
+            if head.hash != block.hash:
+                await self._ctx.reindex(ReindexingReason.BLOCK_HASH_MISMATCH)
 
     async def process(self) -> None:
         # NOTE: `--oneshot` flag implied
@@ -113,12 +108,10 @@ async def _process_queue(self) -> None:
     async def _enter_sync_state(self, last_level: int) -> Optional[int]:
         if self.state.status == IndexStatus.ONESHOT:
             return None
-        # FIXME: I'm not sure if this is a good way to check if index is in sync
-        # TODO: Move to model class
-        elif self.state.status == IndexStatus.REALTIME and isinstance(self.state.head, Head):
-            self.state.head.level
-        else:
-            first_level = self.state.level
+
+        head = await self.state.head
+        # FIXME: Use Head when postponed WS init will be reversed
+        first_level = self.state.level
 
         if first_level == last_level:
             return None

src/dipdup/models.py

@@ -317,7 +317,6 @@ async def update_status(
 
         if head:
             self.head = head
-            self.head_id = head.pk if head else None
 
         self.status = status
         await self.save()