fixes

app/data.db

@@ -1 +0,0 @@
-{"/person/aa": [[96867.923655323, 

p2p/api.py

@@ -52,7 +52,7 @@ async def _getdb(self=None,port=PORT_LISTEN):
 
     import os
     if self: self.log(os.getcwd())
-    node = KadServer(storage=HalfForgetfulStorage(fn='../p2p/data.db',log=(self.log if self else print)))
+    node = KadServer(storage=HalfForgetfulStorage()) #fn='../p2p/data.db',log=(self.log if self else print)))
 
     if self: self.log('listening..')
     await node.listen(port)
@@ -84,7 +84,9 @@ class Api(object):
             i = 0
             self._node = await self.connect(port=port)
             while True:
+                #self.log(i)
                 if not i%10: self.log(f'Node status (tick {i}): {self._node}')
+                if i and not i%60: await self.flush()
 
                     # # get some sleep
                     # if self.root.ids.btn1.state != 'down' and i >= 2:
@@ -93,7 +95,7 @@ class Api(object):
                     #     self.root.ids.btn1.trigger_action()
 
                 i += 1
-                await asyncio.sleep(5)
+                await asyncio.sleep(1)
                 # pass
         except asyncio.CancelledError as e:
             self.log('P2P node cancelled', e)
@@ -572,6 +574,14 @@ class Api(object):
     #     event_id=1 if event_id is None else int(event_id) 
     #     return f'/post/{event_id}'
 
+    async def flush(self):
+        self.log('saving back to db file...')
+        node = await self.node
+        node.storage.dump()
+        self.log('DONE saving back to db file...')
+        
+
+
     async def post(self,data,channels = ['earth'], add_profile=True):
         post_id=get_random_id()
         res = await self.set_json('/post/'+post_id, data)
@@ -587,6 +597,7 @@ class Api(object):
         if un: await self.set_json('/posts/author/'+un, post_id)
 
         if res:
+            asyncio.create_task(self.flush())
             return {'success':'Posted! %s' % post_id, 'post_id':post_id}
         return {'error':'Post failed'}
 

p2p/kademlia/storage.py

@@ -3,6 +3,7 @@ from itertools import takewhile
 import operator
 from collections import OrderedDict
 from abc import abstractmethod, ABC
+import asyncio
 
 BSEP_ST = b'||||'
 
@@ -109,26 +110,41 @@ class IStorage(ABC):
 
 
 
-import pickle
+import pickle,os
 class HalfForgetfulStorage(IStorage):
     def __init__(self, fn='dbm.pickle', ttl=604800, log=None):
         """
         By default, max age is a week.
         """
-        self.data = OrderedDict()
         self.fn = fn
         self.ttl = ttl
+        self.log = logger.info
+        self.data = OrderedDict() if not os.path.exists(self.fn) else self.load()
+
+        # import pickledb
+        # self.data = pickledb.load(self.fn,auto_dump=True)
+        #import shelve
+        #self.data = shelve.open(self.fn,flag='cs')
+        
 
     def dump(self):
-        with open(self.fn,'wb') as of:
-            pickle.dump(self.data, of)
+        async def do():
+            self.log('[async!!] dumping %s keys:\n%s...' % (len(self.keys()),self.keys()))
+            with open(self.fn,'wb') as of:
+                pickle.dump(self.data, of)
+        asyncio.create_task(do())
+
+    def load(self):
+        self.log('loading pickle...')
+        with open(self.fn,'rb') as of:
+            return pickle.load(of)
 
     def __setitem__(self, key, value):
         self.set(key,value)
 
     def keys(self): return self.data.keys()
-    def items(self): return self.data.items()
-    def values(self): return self.data.values()
+    def items(self): return [(k,v) for k,v in zip(self.keys(),self.values())]
+    def values(self): return [self.data[k] for k in self.keys()]
 
     def set(self,key,value):
         log(f'HFS.set({key}) -> {value}')
@@ -136,14 +152,15 @@ class HalfForgetfulStorage(IStorage):
         # store
         if key in self.data:
             del self.data[key]
-        self.data[key] = (time.monotonic(), value)
+        
+        newval = (time.monotonic(), value)
+        self.data[key] = newval
+        # self.data.set(key,newval)
 
         # save and prune
-        self.dump()
-        self.cull()
+        # self.dump()
+        # self.cull()
 
-    def keys(self):
-        return self.data.keys()
 
     def cull(self):
         for _, _ in self.iter_older_than(self.ttl):
@@ -154,8 +171,10 @@ class HalfForgetfulStorage(IStorage):
         log(f'HFS.get({key}) -> ?')
         try:
             val=self.data[key]
-            if not incl_time: val=val[1]
+            # val=self.data.get(key)
             log(f'HFS.get({key}) -> {val}')
+            if val is False: raise KeyError
+            if val and not incl_time: val=val[1]
             return val
         except (KeyError,IndexError) as e:
             pass
@@ -177,15 +196,15 @@ class HalfForgetfulStorage(IStorage):
         return list(map(operator.itemgetter(0, 2), matches))
 
     def _triple_iter(self):
-        ikeys = self.data.keys()
-        ibirthday = map(operator.itemgetter(0), self.data.values())
-        ivalues = map(operator.itemgetter(1), self.data.values())
+        ikeys = self.keys()
+        ibirthday = map(operator.itemgetter(0), self.values())
+        ivalues = map(operator.itemgetter(1), self.values())
         return zip(ikeys, ibirthday, ivalues)
 
     def __iter__(self):
         self.cull()
-        ikeys = self.data.keys()
-        ivalues = map(operator.itemgetter(1), self.data.values())
+        ikeys = self.keys()
+        ivalues = map(operator.itemgetter(1), self.values())
         return zip(ikeys, ivalues)