metadata db load fixes

src/dexorder/bin/backfill_ohlc.py

@@ -44,8 +44,8 @@ async def main():
         log.error('backfill requires a memcache server')
     await memcache.connect()
     redis_state = RedisState([recent_ohlcs])  # NOTE: ONLY the ohlc's are pushed to Redis.  We do not want to touch anything else.
+    db.connect()
     if db:
-        db.connect()
         db_state = DbState(BlockData.by_opt('db'))
         with db.session:
             state = await db_state.load()

src/dexorder/bin/main.py

@@ -1,7 +1,7 @@
 import logging
 from asyncio import CancelledError
 
-from dexorder import db, blockchain
+from dexorder import db, blockchain, config
 from dexorder.base.chain import current_chain
 from dexorder.bin.executable import execute
 from dexorder.blockstate import current_blockstate
@@ -78,8 +78,8 @@ async def main():
     if memcache:
         await memcache.connect()
         redis_state = RedisState(BlockData.by_opt('redis'))
+    db.connect()
     if db:
-        db.connect()
         db_state = DbState(BlockData.by_opt('db'))
         with db.session:
             state = await db_state.load()

src/dexorder/database/__init__.py

@@ -45,9 +45,10 @@ class Db:
     def __init__(self, db_url_config_key='db_url'):
         self.kv = Kv()
         self.db_url_config_key = db_url_config_key
+        self.connected = False
 
     def __bool__(self):
-        return bool(config.db_url)
+        return self.connected
 
     def transaction(self) -> SessionTransaction:
         """
@@ -95,9 +96,16 @@ class Db:
     # noinspection PyShadowingNames
     def connect(self, url=None, migrate=True, reconnect=False, dump_sql=None):
         if _engine.get() is not None and not reconnect:
-            return
+            return None
         if url is None:
-            url = config[self.db_url_config_key]
+            url = config.get(self.db_url_config_key)
+        if not url:
+            # noinspection PyTypeChecker
+            _engine.set(None)
+            # noinspection PyTypeChecker
+            _session.set(None)
+            self.connected = False
+            return None
         if dump_sql is None:
             dump_sql = config.dump_sql
         engine = sqlalchemy.create_engine(url, echo=dump_sql, json_serializer=json.dumps, json_deserializer=json.loads)
@@ -109,7 +117,8 @@ class Db:
         for row in result:
             log.info(f'{url} database revision {row[0]}')
             _engine.set(engine)
-            return db
+            self.connected = True
+            return self
         raise Exception(f'{url} database version not found')
 
 db = Db()

src/dexorder/pools.py

@@ -35,10 +35,11 @@ async def load_pool(address: str) -> OldPoolDict:
     found = None
     chain_id = current_chain.get().id
     # todo other exchanges
-    pool = db.session.get(Pool, (chain_id, address))
-    if pool is not None:
-        return OldPoolDict(type='Pool', chain=chain_id, address=address, exchange=pool.exchange.value,
-                           base=pool.base, quote=pool.quote, fee=pool.fee, decimals=pool.decimals)
+    if db:
+        pool = db.session.get(Pool, (chain_id, address))
+        if pool is not None:
+            return OldPoolDict(type='Pool', chain=chain_id, address=address, exchange=pool.exchange.value,
+                               base=pool.base, quote=pool.quote, fee=pool.fee, decimals=pool.decimals)
     try:
         v3 = UniswapV3Pool(address)
         t0, t1 = await asyncio.gather(v3.token0(), v3.token1())

src/dexorder/tokens.py

@@ -29,11 +29,12 @@ async def get_token(address) -> Optional[OldTokenDict]:
 async def load_token(address: str) -> Optional[OldTokenDict]:
     contract = ERC20(address)
     chain_id = current_chain.get().id
-    token = db.session.get(Token, (chain_id, address))
-    if token is not None:
-        return OldTokenDict(type='Token', chain=chain_id, address=address,
-                            name=token.name, symbol=token.symbol, decimals=token.decimals,
-                            approved=token.approved)
+    if db:
+        token = db.session.get(Token, (chain_id, address))
+        if token is not None:
+            return OldTokenDict(type='Token', chain=chain_id, address=address,
+                                name=token.name, symbol=token.symbol, decimals=token.decimals,
+                                approved=token.approved)
     async def get_string_or_bytes32(func_name):
         try:
             result = await getattr(contract, func_name)()