Refactor peering views into separate module

denyhosts_server/main.py

@@ -30,6 +30,7 @@
 
 import views
 import debug_views
+import peering_views
 import models
 import controllers
 import config
@@ -156,6 +157,10 @@ def start_listening():
     # /RPC2
     xmlrpc_root.putChild('RPC2', main_xmlrpc_handler)
 
+    # Peering handler
+    p = peering_views.PeeringServer(main_xmlrpc_handler)
+    main_xmlrpc_handler.putSubHandler('peering', p)
+
     # xmlrpc debug handler
     if config.enable_debug_methods:
         d = debug_views.DebugServer(main_xmlrpc_handler)

denyhosts_server/peering.py

@@ -41,7 +41,6 @@
 def send_update(client_ip, timestamp, hosts):
     for peer in config.peers:
         logging.debug("Sending update to peer {}".format(peer))
-        logging.debug("peer: {}".format(peer))
         data = {
             "client_ip": client_ip,
             "timestamp": timestamp,
@@ -53,7 +52,7 @@ def send_update(client_ip, timestamp, hosts):
 
         try:
             server = yield deferToThread(ServerProxy, peer)
-            yield deferToThread(server.peering_update, _own_key.pk.encode('hex'), base64)
+            yield deferToThread(server.peering.update, _own_key.pk.encode('hex'), base64)
         except:
             logging.warning("Unable to send update to peer {}".format(peer))
 
@@ -165,7 +164,7 @@ def bootstrap_from(peer_url):
     please_base64 = crypted.encode('base64')
 
     server = yield deferToThread(ServerProxy, peer_url)
-    remote_schema = yield server.peering_schema_version(_own_key.pk.encode('hex'), please_base64)
+    remote_schema = yield server.peering.schema_version(_own_key.pk.encode('hex'), please_base64)
 
     print("Initializing database...")
     yield database.clean_database()
@@ -177,7 +176,7 @@ def bootstrap_from(peer_url):
 
     logging.debug("Remote database schema: {}; local schema: {}".format(remote_schema, local_schema))
 
-    hosts = yield deferToThread(server.peering_all_hosts, _own_key.pk.encode('hex'), please_base64)
+    hosts = yield deferToThread(server.peering.all_hosts, _own_key.pk.encode('hex'), please_base64)
 
     #logging.debug("Hosts from peer: {}".format(hosts))
     print("Copying data of {} hosts from peer".format(len(hosts)), end="")
@@ -194,7 +193,7 @@ def bootstrap_from(peer_url):
 
         crypted = _peer_boxes[peer_url].encrypt(host_ip)
         base64 = crypted.encode('base64')
-        response = yield deferToThread(server.peering_all_reports_for_host, _own_key.pk.encode('hex'), base64)
+        response = yield deferToThread(server.peering.all_reports_for_host, _own_key.pk.encode('hex'), base64)
         #logging.debug("All reports response: {}".format(response))
 
         for r in response:
@@ -205,7 +204,7 @@ def bootstrap_from(peer_url):
         print("Copying {} table from peer...".format(table))
         crypted = _peer_boxes[peer_url].encrypt(table)
         base64 = crypted.encode('base64')
-        rows = yield deferToThread(server.peering_dump_table, _own_key.pk.encode('hex'), base64)
+        rows = yield deferToThread(server.peering.dump_table, _own_key.pk.encode('hex'), base64)
         for row in rows:
             database.bootstrap_table(table, row)
 

denyhosts_server/peering_views.py

@@ -0,0 +1,135 @@
+
+#    denyhosts sync server
+#    Copyright (C) 2015-2016 Jan-Pascal van Best <janpascal@vanbest.org>
+
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as published
+#    by the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import time
+import logging
+import random
+
+from twisted.web import server, xmlrpc, error
+from twisted.web.resource import Resource
+from twisted.web.xmlrpc import withRequest
+from twisted.internet.defer import inlineCallbacks, returnValue
+from twisted.internet import reactor
+from twisted.python import log
+
+import models
+from models import Cracker, Report
+import config
+import controllers
+import utils
+import stats
+import peering
+
+class PeeringServer(xmlrpc.XMLRPC):
+    """
+    Peering xmlrpc methods
+    """
+
+    @withRequest
+    @inlineCallbacks
+    def xmlrpc_update(self, request, key, update):
+        try:
+            logging.info("update({}, {})".format(key, update))
+            key = key.decode('hex')
+            update = update.decode('base64')
+            yield peering.handle_update(key, update)
+        except xmlrpc.Fault, e:
+            raise e
+        except Exception, e:
+            log.err(_why="Exception in update")
+            raise xmlrpc.Fault(105, "Error in update({},{})".format(key, update))
+        returnValue(0)
+
+    @withRequest
+    @inlineCallbacks
+    def xmlrpc_schema_version(self, request, key, please):
+        try:
+            logging.info("schema_version({}, {})".format(key, please))
+            key = key.decode('hex')
+            please = please.decode('base64')
+            result = yield peering.handle_schema_version(key, please)
+            returnValue(result)
+        except xmlrpc.Fault, e:
+            raise e
+        except Exception, e:
+            log.err(_why="Exception in schema_version")
+            raise xmlrpc.Fault(106, "Error in schema_version({},{})".format(key, please))
+
+    @withRequest
+    @inlineCallbacks
+    def xmlrpc_all_hosts(self, request, key, please):
+        try:
+            logging.info("all_hosts({}, {})".format(key, please))
+            key = key.decode('hex')
+            please = please.decode('base64')
+            result = yield peering.handle_all_hosts(key, please)
+            returnValue(result)
+        except xmlrpc.Fault, e:
+            raise e
+        except Exception, e:
+            log.err(_why="Exception in all_hosts")
+            raise xmlrpc.Fault(106, "Error in all_hosts({},{})".format(key, please))
+
+    @withRequest
+    @inlineCallbacks
+    def xmlrpc_all_reports_for_host(self, request, key, host):
+        try:
+            logging.info("all_reports_for_hos({}, {})".format(key, host))
+            key = key.decode('hex')
+            host = host.decode('base64')
+            result = yield peering.handle_all_reports_for_host(key, host)
+            returnValue(result)
+        except xmlrpc.Fault, e:
+            raise e
+        except Exception, e:
+            log.err(_why="Exception in all_updates_for_host")
+            raise xmlrpc.Fault(107, "Error in all_updates_for_host({},{})".format(key, host))
+
+    @withRequest
+    @inlineCallbacks
+    def xmlrpc_dump_table(self, request, key, host):
+        try:
+            logging.info("dump_table({}, {})".format(key, host))
+            key = key.decode('hex')
+            host = host.decode('base64')
+            result = yield peering.handle_dump_table(key, host)
+            returnValue(result)
+        except xmlrpc.Fault, e:
+            raise e
+        except Exception, e:
+            log.err(_why="Exception in dump_table")
+            raise xmlrpc.Fault(106, "Error in dump_table({},{})".format(key, host))
+
+    @withRequest
+    @inlineCallbacks
+    def xmlrpc_list_peers(self, request, key, please):
+        try:
+            logging.info("Received list_peers call")
+            logging.info("list_peers({}, {})".format(key, please))
+            key = key.decode('hex')
+            please = please.decode('base64')
+            result = peering.list_peers(key, please)
+            yield
+            returnValue(result)
+        except xmlrpc.Fault, e:
+            raise e
+        except Exception, e:
+            log.err(_why="Exception in list_peers")
+            raise xmlrpc.Fault(108, "Error in list_peers({},{})".format(key, please))
+        returnValue(0)
+
+# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4

denyhosts_server/views.py

@@ -62,99 +62,6 @@ def xmlrpc_add_hosts(self, request, hosts):
 
         returnValue(0)
 
-    @withRequest
-    @inlineCallbacks
-    def xmlrpc_peering_update(self, request, key, update):
-        try:
-            logging.info("peering_update({}, {})".format(key, update))
-            key = key.decode('hex')
-            update = update.decode('base64')
-            yield peering.handle_update(key, update)
-        except xmlrpc.Fault, e:
-            raise e
-        except Exception, e:
-            log.err(_why="Exception in peering_update")
-            raise xmlrpc.Fault(105, "Error in peering_update({},{})".format(key, update))
-        returnValue(0)
-
-    @withRequest
-    @inlineCallbacks
-    def xmlrpc_peering_schema_version(self, request, key, please):
-        try:
-            logging.info("peering_schema_version({}, {})".format(key, please))
-            key = key.decode('hex')
-            please = please.decode('base64')
-            result = yield peering.handle_schema_version(key, please)
-            returnValue(result)
-        except xmlrpc.Fault, e:
-            raise e
-        except Exception, e:
-            log.err(_why="Exception in peering_schema_version")
-            raise xmlrpc.Fault(106, "Error in peering_schema_version({},{})".format(key, please))
-
-    @withRequest
-    @inlineCallbacks
-    def xmlrpc_peering_all_hosts(self, request, key, please):
-        try:
-            logging.info("peering_all_hosts({}, {})".format(key, please))
-            key = key.decode('hex')
-            please = please.decode('base64')
-            result = yield peering.handle_all_hosts(key, please)
-            returnValue(result)
-        except xmlrpc.Fault, e:
-            raise e
-        except Exception, e:
-            log.err(_why="Exception in peering_all_hosts")
-            raise xmlrpc.Fault(106, "Error in peering_all_hosts({},{})".format(key, please))
-
-    @withRequest
-    @inlineCallbacks
-    def xmlrpc_peering_all_reports_for_host(self, request, key, host):
-        try:
-            logging.info("peering_all_reports_for_hos({}, {})".format(key, host))
-            key = key.decode('hex')
-            host = host.decode('base64')
-            result = yield peering.handle_all_reports_for_host(key, host)
-            returnValue(result)
-        except xmlrpc.Fault, e:
-            raise e
-        except Exception, e:
-            log.err(_why="Exception in peering_all_updates_for_host")
-            raise xmlrpc.Fault(107, "Error in peering_all_updates_for_host({},{})".format(key, host))
-
-    @withRequest
-    @inlineCallbacks
-    def xmlrpc_peering_dump_table(self, request, key, host):
-        try:
-            logging.info("peering_dump_table({}, {})".format(key, host))
-            key = key.decode('hex')
-            host = host.decode('base64')
-            result = yield peering.handle_dump_table(key, host)
-            returnValue(result)
-        except xmlrpc.Fault, e:
-            raise e
-        except Exception, e:
-            log.err(_why="Exception in peering_dump_table")
-            raise xmlrpc.Fault(106, "Error in peering_dump_table({},{})".format(key, host))
-
-    @withRequest
-    @inlineCallbacks
-    def xmlrpc_list_peers(self, request, key, please):
-        try:
-            logging.info("Received list_peers call")
-            logging.info("list_peers({}, {})".format(key, please))
-            key = key.decode('hex')
-            please = please.decode('base64')
-            result = peering.list_peers(key, please)
-            yield
-            returnValue(result)
-        except xmlrpc.Fault, e:
-            raise e
-        except Exception, e:
-            log.err(_why="Exception in peering_list_peers")
-            raise xmlrpc.Fault(108, "Error in peering_list_peers({},{})".format(key, please))
-        returnValue(0)
-
     @withRequest
     @inlineCallbacks
     def xmlrpc_get_new_hosts(self, request, timestamp, threshold, hosts_added, resiliency):

tests/sim_clients.py

@@ -3,9 +3,24 @@
 import time
 import threading
 import random
+import ipaddr
+
+def is_valid_ip_address(ip_address):
+    try:
+        ip = ipaddr.IPAddress(ip_address)
+    except:
+        return False
+    if (ip.is_reserved or ip.is_private or ip.is_loopback or
+        ip.is_unspecified or ip.is_multicast or
+        ip.is_link_local):
+        return False
+    return True
 
 def random_ip_address():
-    return ".".join(map(str, (random.randint(0, 255) for _ in range(4))))
+    while True:
+        ip = ".".join(map(str, (random.randint(0, 255) for _ in range(4))))
+        if is_valid_ip_address(ip):
+            return ip
 
 server = 'http://localhost:9911'