finally figured this

p2p/kad.py

@@ -19,108 +19,6 @@ log.setLevel(logging.DEBUG)
 PROXY_ADDR = ('0.0.0.0',8368)
 
 
-
-class HalfForgetfulStorage(ForgetfulStorage):
-    def __init__(self, fn='data.db', ttl=604800, log=print):
-        """
-        By default, max age is a week.
-        """
-        self.fn=fn
-        self.log=log
-        #from sqlitedict import SqliteDict
-        #self.data = SqliteDict(self.fn, autocommit=True)
-        
-        #import h5py
-        #self.data = h5py.File(self.fn,'a')
-        # if not os.path.exists(self.fn):
-        #     self.data={}
-        # else:
-        #     with open(self.fn,'rb') as f:
-        #         self.data=pickle.load(f)
-        # import shelve
-        # self.data = shelve.open(self.fn,'a')
-        import pickledb
-        self.data = pickledb.load(self.fn,False)
-        # stop
-        # raise Exception(str([fn, type(self.data), self.data]))
-        # stop
-
-
-        #print('>> loaded %s keys' % len(self.data))
-
-        #self.data = pickle.open('sto.dat','rb') #,writeback=True)
-        # self.data = self.store.get('OrderedDict',OrderedDict())
-        self.ttl = ttl
-
-    def cull(self):
-        pass
-
-    def keys(self):
-        return self.data.getall()
-
-    def __len__(self):
-        return len(self.keys())
-
-    def __setitem__(self, key, value):
-        # try:
-        #     sofar=self.data.get(key)
-        # except (KeyError,ValueError) as e:
-        #     sofar = []
-        sofar = self.data.get(key)
-        if not sofar: sofar=[]
-        print('SOFAR',sofar)
-        #sofar = [sofar] if sofar and type(sofar)!=list else []
-        print('SOFAR',sofar)
-        newdat = (time.monotonic(), value)
-        newval = sofar + [newdat]
-        print('NEWVAL',newval)
-        #del self.data[key]
-        #self.data[key]=newval
-        
-        self.data.set(key,newval)
-        self.data.dump()
-        
-        print('VALUE IS NOW'+str(self.data.get(key)))
-        #self.write()
-
-    def set(key,value):
-        self[key]=value
-
-    def write(self):
-        pass
-        #with open(self.fn,'wb') as f:
-        #    pickle.dump(self.data, f)
-
-    def get(self, key, default=None):
-        # self.cull()
-        # print('looking for key: ', key)
-        # if key in self.data:
-        #     val=list(self[key])
-        #     # print('...found it! = %s' % val)
-        #     return self[key]
-        # return default
-        stop
-        return self[key]
-
-    def __getitem__(self, key):
-        # print(f'??!?\n{key}\n{self.data[key]}')
-        # return self.data[key][1]
-        # (skip time part of tuple)
-        val=[]
-        try:
-            val=self.data.get(key)
-            self.log('VALLLL',val)
-        except KeyError:
-            pass
-        if type(val)!=list: val=[val]
-        data_list = val
-        self.log('data_list =',data_list)
-        return [dat for dat in data_list]
-        
-        #return data_list
-
-
-
 """UDP proxy server."""
 
 import asyncio
@@ -236,9 +134,11 @@ class KadProtocol(KademliaProtocol):
 class KadServer(Server):
     protocol_class = KadProtocol # KadProtocol #KademliaProtocol
 
-    def __init__(self, *x, **y):
-        super().__init__(*x,**y)
-        log.info(f'Storage has {len(self.storage.data)} keys')
+    # def __init__(self, *x, **y):
+    #     self.storage = y['storage']
+    #     # raise Exception(str(self.storage))
+    #     super().__init__(*x,**y)
+    #     log.info(f'Storage has {len(self.storage.data)} keys')
 
     def __repr__(self):
         repr = f"""

p2p/kademlia/network.py

@@ -8,7 +8,7 @@ import logging
 
 from kademlia.protocol import KademliaProtocol
 from kademlia.utils import digest
-from kademlia.storage import ForgetfulStorage
+from kademlia.storage import HalfForgetfulStorage
 from kademlia.node import Node
 from kademlia.crawling import ValueSpiderCrawl
 from kademlia.crawling import NodeSpiderCrawl
@@ -38,7 +38,7 @@ class Server:
         """
         self.ksize = ksize
         self.alpha = alpha
-        self.storage = storage or ForgetfulStorage()
+        self.storage = HalfForgetfulStorage() #storage or ForgetfulStorage()
         self.node = Node(node_id or digest(random.getrandbits(255)))
         self.transport = None
         self.protocol = None

p2p/kademlia/storage.py

@@ -4,6 +4,10 @@ import operator
 from collections import OrderedDict
 from abc import abstractmethod, ABC
 
+def xprint(*xx):
+    raise Exception('\n'.join(str(x) for x in xx)) 
+
+
 
 class IStorage(ABC):
     """
@@ -92,3 +96,80 @@ class ForgetfulStorage(IStorage):
         ikeys = self.data.keys()
         ivalues = map(operator.itemgetter(1), self.data.values())
         return zip(ikeys, ivalues)
+
+
+
+
+
+
+
+
+
+
+
+class HalfForgetfulStorage(ForgetfulStorage):
+    def __init__(self, fn='data.db', ttl=604800, log=print):
+        """
+        By default, max age is a week.
+        """
+        self.fn=fn
+        self.log=log
+        
+        import pickledb
+        self.data = pickledb.load(self.fn,False)
+        self.ttl = ttl
+
+    def iter_older_than(self, seconds_old):
+        return []
+
+    def cull(self):
+        pass
+
+    def keys(self):
+        return self.data.getall()
+
+    def __len__(self):
+        return len(self.keys())
+
+    def __setitem__(self, key, value):
+        stop
+        self.set(key,value)
+
+    def set(self, key,value):# try:
+        sofar = self.data.get(key)
+        if not sofar: sofar=[]
+        xprint('SOFAR',sofar)
+        #sofar = [sofar] if sofar and type(sofar)!=list else []
+        print('SOFAR',sofar)
+        newdat = (time.monotonic(), value)
+        newval = sofar + [newdat]
+        print('NEWVAL',newval)
+        #del self.data[key]
+        #self.data[key]=newval
+        
+        self.data.set(key,newval)
+        self.data.dump()
+        
+        print('VALUE IS NOW'+str(self.data.get(key)))
+
+
+    def get(self, key, default=None):
+        # print(f'??!?\n{key}\n{self.data[key]}')
+        # return self.data[key][1]
+        # (skip time part of tuple)
+        val=[]
+        try:
+            val=self.data.get(key)
+            self.log('VALLLL',val)
+        except KeyError:
+            pass
+        if type(val)!=list: val=[val]
+        data_list = val
+        self.log('data_list =',data_list)
+        return [dat for dat in data_list]
+
+
+    def __getitem__(self, key):
+        return self.get(key)
+        
+        #return data_list