new logger, rename GDBTable

logger.py

+from .node.logging import CFLog
+
+log = CFLog()

node/cli.py

@@ -2,7 +2,7 @@ from typing import Callable, Protocol, NewType
 
 import traceback
 from CellFrame import AppCliServer
-from DAP.Core import logIt
+from pycfhelpers.logger import log
 from optparse import OptionParser
 
 ReplyId = NewType("ReplyId", int)
@@ -40,4 +40,4 @@ class CFCliCommand:
         try:
             AppCliServer.cmdItemCreate(self.command, callback_wrapper, help_text, "")
         except Exception:
-            logIt.error(f"Error = {traceback.format_exc()}")
+            log.error(f"Error = {traceback.format_exc()}")

node/datums.py

@@ -5,7 +5,7 @@ import json
 import binascii
 from datetime import datetime
 
-from DAP.Core import logIt
+from pycfhelpers.logger import log
 from CellFrame.Common import Datum, DatumTx, DatumToken, DatumDecree, DatumAnchor, DatumEmission
 
 if TYPE_CHECKING:
@@ -31,7 +31,7 @@ class CFDatum:
             self.created_at = datum.tsCreated
         except OSError:
             self.created_at = datetime.fromtimestamp(0)
-            logIt.error(f"Datum [{datum.hash}] has invalid timestamp!")
+            log.error(f"Datum [{datum.hash}] has invalid timestamp!")
         if atom is None and net is None:
             raise AttributeError("A datum without a parent atom requires a net")
         self.atom = atom  # atom == None - datum in mempool
@@ -52,7 +52,7 @@ class SubDatum:
         if sub_datum is None:
             self.hash = parent_datum.hash
             self.type = "CORRUPTED"
-            logIt.error(f"Datum type:{parent_datum.type} hash:{parent_datum.hash} is CORRUPTED")
+            log.error(f"Datum type:{parent_datum.type} hash:{parent_datum.hash} is CORRUPTED")
 
     @property
     def net(self) -> 'CFNet':
@@ -130,7 +130,7 @@ class CFDatumEmission(SubDatum):
             except UnicodeDecodeError:
                 tsd_data = binascii.hexlify(tsd).decode('utf-8')
             except:
-                logIt.error(f"Incorrect TSD data. Skip TSD with type={tsd_type}")
+                log.error(f"Incorrect TSD data. Skip TSD with type={tsd_type}")
                 continue
 
             if tsd_type == TSD.TYPE_DATA:

node/gdb.py

+from typing import Callable
 from CellFrame.Chain import GlobalDB
 
 
+class GDBGroup:
+    def __init__(self, group):
+        self.group = group
 
-class GDBTable:
-    def __init__(self, table):
-        self.table = table
-
-    def set(self, key, value):
-        GlobalDB.set(key, self.table, value)
+    def set(self, key, value) -> bool:
+        return GlobalDB.set(key, self.group, value)
 
     def get(self, key, default=None):
-        return GlobalDB.get(key, self.table) or default
+        return GlobalDB.get(key, self.group) or default
 
     def delete(self, key):
-        GlobalDB.delete(key, self.table)
+        GlobalDB.delete(key, self.group)
 
     def group_list(self):
-        return GlobalDB.grLoad(self.table)
-
-
+        return GlobalDB.grLoad(self.group)
+
+    @staticmethod
+    def add_to_white_list(net_name: str, group_mask: str, callback: Callable, callback_args: list):
+        """
+        group_mask example: "raiden.emission-center.*
+        """
+        GlobalDB.addSyncExtraGroup(net_name, group_mask, callback, callback_args)

node/http/simple.py

 from DAP.Core import AppContext
 from DAP.Network import Server, HttpSimple, HttpCode
-from pycfhelpers.node.logging import CFLog
+from pycfhelpers.logger import log
 
 from typing import Callable
 
@@ -43,7 +43,7 @@ class CFSimpleHTTPRequestHandler:
             http.replyAdd(res)
             response_code.set(code)
         else:
-            CFLog.notice(f"Method {http.action} not supported for {http.urlPath} ")
+            log.notice(f"Method {http.action} not supported for {http.urlPath} ")
             response_code.set(405)
 
 

node/net.py

-from typing import Iterator, Callable
+from typing import Iterator, Callable, Protocol, Literal
 
 import traceback
 
-from DAP.Core import logIt
+from pycfhelpers.logger import log
 from DAP.Crypto import HashFast
 from CellFrame.Network import Net
 from CellFrame.Chain import ChainAtomPtr, Ledger, ChainAddr, Mempool
@@ -32,6 +32,7 @@ class CFNet:
         if not self._origin_net:
             raise RuntimeError(f"No such net: {name}")
 
+        self.address = str(self._origin_net.getCurAddr())
         self.main = CFChain(self, 'main')
         self.zerochain = CFChain(self, 'zerochain')
 
@@ -53,7 +54,7 @@ class CFNet:
     def group_alias(self) -> str:
         return self._origin_net.gdb_group_alias
 
-    def get_ledger(self):
+    def get_ledger(self) -> 'CFLedger':
         return CFLedger(self, self._origin_net.getLedger())
 
     def register_gdbsync_notification_callback(self, callback: Callable, *args, **kwargs):
@@ -71,6 +72,11 @@ class CFNet:
             raise NotImplemented("This state not implemented")
 
 
+class MempoolCallback(Protocol):
+    def __call__(self, op_code: Literal["a", "d"], datum: CFDatum, *args, chain: 'CFChain', **kwargs) -> None:
+        pass
+
+
 class CFChain:
     def __init__(self, net: CFNet, chain_name: str):
         self.net = net
@@ -85,7 +91,7 @@ class CFChain:
         ptr = self._origin_chain.atomIterGetFirst(iterator)
 
         if not ptr:
-            logIt.message("not ptr")
+            log.message("not ptr")
             return []
 
         atom, size = ptr
@@ -115,18 +121,22 @@ class CFChain:
     def get_mempool(self) -> 'CFMempool':
         return CFMempool(self)
 
-    def register_mempool_notification_callback(self, callback, *args, **kwargs):
+    def register_mempool_notification_callback(self, callback: MempoolCallback, *args, **kwargs):
         def callback_wrapper(op_code, group, key, value, *other):
-            logIt.message(f"{other=}")
             try:
-                callback(op_code, group, key, value, *args, chain=self, **kwargs)
+                mempool = CFMempool(self)
+                datum = mempool.get_datum_from_bytes(value)
+                log.message(f"Mempool callback: {datum.hash=} | {key=} | {op_code=}")
+                if datum is None:
+                    raise ValueError(f"Can't extract Datum from Mempool key={key}")
+                callback(op_code, datum, *args, chain=self, **kwargs)
             except Exception:
-                logIt.error(f"Error = {traceback.format_exc()}")
+                log.error(f"Error = {traceback.format_exc()}")
 
         try:
             self._origin_chain.addMempoolNotify(callback_wrapper, ())
         except Exception:
-            logIt.error(f"Error = {traceback.format_exc()}")
+            log.error(f"Error = {traceback.format_exc()}")
 
     def register_atom_notification_callback(self, callback, *args, **kwargs):
         def callback_wrapper(atom: ChainAtomPtr, size, *other):
@@ -139,7 +149,7 @@ class CFChain:
                     raise TypeError(f"Invalid Chain type={self.type}")
                 callback(cf_atom, size, *args, chain=self, **kwargs)
             except Exception:
-                logIt.error(traceback.format_exc())
+                log.error(traceback.format_exc())
 
         self._origin_chain.addAtomNotify(callback_wrapper, ())
 
@@ -193,9 +203,15 @@ class CFMempool:
 
     def get_datums(self) -> list[CFDatum]:
         data = Mempool.list(self.chain.net._origin_net, self.chain._origin_chain)
-        # logIt.message(f"{data.keys()=}")
         return [CFDatum(None, datum, net=self.chain.net) for datum in data.values()]
 
+    def get_datum_from_bytes(self, value: bytes) -> CFDatum | None:
+        datum = Mempool.datumExtract(value)
+        if datum is None:
+            return None
+            # raise ValueError(f"Incorrect bytes={value} to extract to Datum")
+        return CFDatum(None, datum, self.chain.net)
+
     def valid_signs_table(self):
         pass
 

node/notificators.py

 from typing import Literal, Callable
 
-from .net import CFNet
+from .net import CFNet, MempoolCallback
 
 
 class CFNets:
@@ -11,11 +11,11 @@ class CFNets:
         """
         Usage example:
         @CFNets(NETS).mempool_notificator("to_args", chain_name="main", key="to_kwargs")
-        def on_mempool_change(op_code, group, key, value, *args, chain:CFChain, **kwargs):
+        def on_mempool_change(op_code: Literal["a", "d"], datum: CFDatum, *args, chain: 'CFChain', **kwargs):
             pass
         """
 
-        def wrapper(callback: Callable[[], None]):
+        def wrapper(callback: MempoolCallback):
             for net in self.nets:
                 if chain_name == "all":
                     for chain in net.chains:

scripts/mount_interfaces

+#!/bin/sh -e
+
+sudo mount ~/Projects/python-cellframe/dists/interfaces/ ./interfaces/ -obind
\ No newline at end of file