Implement data validation

doc/uml/network.pu

@@ -3,29 +3,13 @@
 Network -->o Node : Connect to node_received()
 Network -> Node : Starts network discovery
 activate Node
-Node -> QNetworkManager : HTTP GET peering/peers?leaves=true
-create QNetworkReply
-QNetworkManager -> QNetworkReply : Instantiate
-Node <- QNetworkManager : QNetworkReply
-Node -->o QNetworkReply : Connect to finished()
-Network <- Node
-deactivate Node
-... Request is processed ...
-Node <-- QNetworkReply : finished()
-destroy QNetworkReply
+Node -> ucoinpy : HTTP GET peering/peers?leaves=true
 alt "root" hash changed
 loop "for all leaves changed"
 activate Node
-Node -> QNetworkManager : HTTP GET peering/peers/leaf=leaf_hash
-create QNetworkReply
-QNetworkManager -> QNetworkReply : Instantiate
-Node <- QNetworkManager : QNetworkReply
-Node -->o QNetworkReply : Connect to finished()
+Node -> ucoinpy : HTTP GET peering/peers/leaf=leaf_hash
 end
 end
-... Requests is processed ...
-Node <-- QNetworkReply : finished()
-destroy QNetworkReply
 Network <-- Node : node_received()
 ref over Network
 New node is instanciated

doc/uml/requests.pu

 @startuml
 
-QModel -->o "Core Component" : Connect to data_changed()
-QModel -> "Core Component" : Data access
 activate "Core Component"
-"Core Component" -> Community : Request data
-Community -> Cache : Request cache
-ref over Cache
-Data is obsolete
-(new block mined
-since last caching)
+"Core Component" -> BmaAccess : Request data
+BmaAccess -> BmaAccess : Request cache
+ref over BmaAccess
+    Data is obsolete
+    (new block mined
+    since last caching)
 end ref
-Cache -> QNetworkManager : HTTP GET
-create QNetworkReply
-QNetworkManager -> QNetworkReply : Instantiate
-Cache <- QNetworkManager : QNetworkReply
-create ReceiverSlot
-Cache -> ReceiverSlot : Instantiate Slot
-QNetworkReply o<-- ReceiverSlot : Connect to finished()
-Community <- Cache : Cached data
-"Core Component" <- Community : Cached data
-"Core Component" -> "Core Component" : Compute data
-QModel <- "Core Component" : Data
-deactivate "Core Component"
-
-...Network request is processed...
-
-ReceiverSlot <-- QNetworkReply  : finished()
-activate ReceiverSlot
-ReceiverSlot -> Cache : Update cache data
-ReceiverSlot -> "Core Component" : emit data_changed()
-deactivate ReceiverSlot
-destroy ReceiverSlot
-destroy QNetworkReply
-|||
-QModel <-- "Core Component" : data_changed()
-QModel -> "Core Component" : Data access
-activate "Core Component"
-ref over "Core Component", Community
-Community is requested again,
-and last cached data are returned
-No new block mined, so no HTTP GET
-initialized between cache
-and QNetworkManager
+BmaAccess -> ucoinpy : HTTP GET
+alt Rollback
+BmaAccess -> BmaAccess : Find last block number rollbacked
+ref over BmaAccess
+    If the request is a bma/blockchain/Block, we check if the hash answered is the same
+    as our hash, in which case, we know that the rollback didn't reset blocks before
+    this one.
+    Blocks from this one to the current block are considered obsolete
 end ref
-QModel <- "Core Component" : Data
+end
+BmaAccess -> BmaAccess : Update cache data
+
+"Core Component" <- BmaAccess : Return data data
 deactivate "Core Component"
 
 

src/cutecoin/core/net/api/bma/access.py

 from PyQt5.QtCore import QObject, pyqtSlot
 from PyQt5.QtNetwork import QNetworkReply
 from ucoinpy.api import bma
-from ucoinpy.documents import Block, BlockId
 from .....tools.exceptions import NoPeerAvailable
 from ..... import __version__
 import logging
 from aiohttp.errors import ClientError
 import asyncio
 import random
+import jsonschema
 from distutils.version import StrictVersion
 
 
@@ -136,6 +136,10 @@ class BmaAccess(QObject):
     def _update_rollback(self, request, req_args, get_args, data):
         """
         Update the rollback
+
+        If the request is a bma/blockchain/Block, we check if
+        the hash answered is the same as our hash, in which case,
+        we know that the rollback didn't reset blocks before this one
         :param class request: A bma request class calling for data
         :param dict req_args: Arguments to pass to the request constructor
         :param dict get_args: Arguments to pass to the request __get__ method
@@ -240,6 +244,9 @@ class BmaAccess(QObject):
                     tries += 1
                 except asyncio.TimeoutError:
                     tries += 1
+                except jsonschema.ValidationError as e:
+                    logging.debug(str(e))
+                    tries += 1
         if len(nodes) == 0 or json_data is None:
             raise NoPeerAvailable("", len(nodes))
         return json_data
@@ -271,6 +278,9 @@ class BmaAccess(QObject):
                     tries += 1
                 except asyncio.TimeoutError:
                     tries += 1
+                except jsonschema.ValidationError as e:
+                    logging.debug(str(e))
+                    tries += 1
         else:
             raise NoPeerAvailable("", len(nodes))
 

src/cutecoin/core/net/node.py

@@ -14,10 +14,9 @@ import asyncio
 from aiohttp.errors import ClientError
 import logging
 import time
-import json
+import jsonschema
 
-from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot
-from PyQt5.QtNetwork import QNetworkReply, QNetworkRequest
+from PyQt5.QtCore import QObject, pyqtSignal
 
 
 class Node(QObject):
@@ -321,6 +320,9 @@ class Node(QObject):
                 except asyncio.TimeoutError:
                     logging.debug("Timeout error : {0}".format(self.pubkey))
                     self.state = Node.OFFLINE
+                except jsonschema.ValidationError:
+                    logging.debug("Validation error : {0}".format(self.pubkey))
+                    self.state = Node.CORRUPTED
                 finally:
                     self.set_block(block_data)
                     logging.debug("Changed block {0} -> {1}".format(self.block['number'],
@@ -373,6 +375,9 @@ class Node(QObject):
         except asyncio.TimeoutError:
             logging.debug("Timeout error : {0}".format(self.pubkey))
             self.state = Node.OFFLINE
+        except jsonschema.ValidationError:
+            logging.debug("Validation error : {0}".format(self.pubkey))
+            self.state = Node.CORRUPTED
 
     @asyncify
     @asyncio.coroutine
@@ -400,6 +405,9 @@ class Node(QObject):
         except asyncio.TimeoutError:
             logging.debug("Timeout error : {0}".format(self.pubkey))
             self.state = Node.OFFLINE
+        except jsonschema.ValidationError:
+            logging.debug("Validation error : {0}".format(self.pubkey))
+            self.state = Node.CORRUPTED
 
     @asyncify
     @asyncio.coroutine
@@ -435,6 +443,9 @@ class Node(QObject):
         except asyncio.TimeoutError:
             logging.debug("Timeout error : {0}".format(self.pubkey))
             self.state = Node.OFFLINE
+        except jsonschema.ValidationError:
+            logging.debug("Validation error : {0}".format(self.pubkey))
+            self.state = Node.CORRUPTED
 
     @asyncify
     @asyncio.coroutine
@@ -469,6 +480,9 @@ class Node(QObject):
                     except asyncio.TimeoutError:
                         logging.debug("Timeout error : {0}".format(self.pubkey))
                         self.state = Node.OFFLINE
+                    except jsonschema.ValidationError:
+                        logging.debug("Validation error : {0}".format(self.pubkey))
+                        self.state = Node.CORRUPTED
                 self._last_merkle = {'root' : peers_data['root'],
                                      'leaves': peers_data['leaves']}
         except ValueError as e:
@@ -480,6 +494,9 @@ class Node(QObject):
         except asyncio.TimeoutError:
             logging.debug("Timeout error : {0}".format(self.pubkey))
             self.state = Node.OFFLINE
+        except jsonschema.ValidationError:
+            logging.debug("Validation error : {0}".format(self.pubkey))
+            self.state = Node.CORRUPTED
 
     def __str__(self):
         return ','.join([str(self.pubkey), str(self.endpoint.server),

src/cutecoin/core/registry/identity.py

@@ -197,8 +197,6 @@ class Identity(QObject):
         except NoPeerAvailable as e:
             logging.debug(str(e))
             raise MembershipNotFoundError(self.pubkey, community.name)
-        except UnboundLocalError:
-            raise
 
     @asyncio.coroutine
     def published_uid(self, community):

src/cutecoin/gui/identities_tab.py

@@ -5,6 +5,7 @@ Created on 2 févr. 2014
 """
 
 import asyncio
+import logging
 
 from PyQt5.QtCore import Qt, pyqtSignal, QEvent
 from PyQt5.QtGui import QCursor
@@ -186,15 +187,19 @@ class IdentitiesTabWidget(QWidget, Ui_IdentitiesTab):
         text = self.edit_textsearch.text()
         if len(text) < 2:
             return
-        response = yield from self.community.bma_access.future_request(bma.wot.Lookup, {'search': text})
-        identities = []
-        for identity_data in response['results']:
-            identity = yield from self.app.identities_registry.future_find(identity_data['pubkey'], self.community)
-            identities.append(identity)
-
-        self.edit_textsearch.clear()
-        yield from self.refresh_identities(identities)
-        self.busy.hide()
+        try:
+            response = yield from self.community.bma_access.future_request(bma.wot.Lookup, {'search': text})
+            identities = []
+            for identity_data in response['results']:
+                identity = yield from self.app.identities_registry.future_find(identity_data['pubkey'], self.community)
+                identities.append(identity)
+
+            self.edit_textsearch.clear()
+            yield from self.refresh_identities(identities)
+        except ValueError as e:
+            logging.debug(str(e))
+        finally:
+            self.busy.hide()
 
     @once_at_a_time
     @asyncify