Move config options used by watcher and responder to the constructor

pisa/pisad.py

@@ -7,7 +7,16 @@ from common.logger import Logger
 from pisa.api import API
 from pisa.watcher import Watcher
 from pisa.builder import Builder
-from pisa.conf import BTC_NETWORK, PISA_SECRET_KEY
+from pisa.conf import (
+    BTC_NETWORK,
+    FEED_PROTOCOL,
+    FEED_ADDR,
+    FEED_PORT,
+    MAX_APPOINTMENTS,
+    EXPIRY_DELTA,
+    MIN_TO_SELF_DELAY,
+    PISA_SECRET_KEY,
+)
 from pisa.responder import Responder
 from pisa.db_manager import DBManager
 from pisa.block_processor import BlockProcessor
@@ -52,7 +61,9 @@ if __name__ == "__main__":
             with open(PISA_SECRET_KEY, "rb") as key_file:
                 secret_key_der = key_file.read()
 
-            watcher = Watcher(db_manager, secret_key_der)
+            pisa_config = load_config(conf)
+
+            watcher = Watcher(db_manager, secret_key_der, config=pisa_config)
 
             if len(watcher_appointments_data) == 0 and len(responder_trackers_data) == 0:
                 logger.info("Fresh bootstrap")
@@ -65,7 +76,7 @@ if __name__ == "__main__":
                 last_block_responder = db_manager.load_last_block_hash_responder()
 
                 # FIXME: 32-reorgs-offline dropped txs are not used at this point.
-                responder = Responder(db_manager)
+                responder = Responder(db_manager, pisa_config)
                 last_common_ancestor_responder = None
                 missed_blocks_responder = None
 

pisa/responder.py

@@ -135,13 +135,14 @@ class Responder:
 
     """
 
-    def __init__(self, db_manager):
+    def __init__(self, db_manager, config):
         self.trackers = dict()
         self.tx_tracker_map = dict()
         self.unconfirmed_txs = []
         self.missed_confirmations = dict()
         self.asleep = True
         self.block_queue = Queue()
+        self.config = config
         self.zmq_subscriber = None
         self.db_manager = db_manager
 
@@ -271,7 +272,7 @@ class Responder:
         from ``bitcoind``. Block ids are received trough the ``block_queue``.
         """
 
-        self.zmq_subscriber = ZMQSubscriber(parent="Responder")
+        self.zmq_subscriber = ZMQSubscriber(self.config, parent="Responder")
         self.zmq_subscriber.handle(self.block_queue)
 
     def do_watch(self):

pisa/utils/zmq_subscriber.py

@@ -8,12 +8,14 @@ from pisa.conf import FEED_PROTOCOL, FEED_ADDR, FEED_PORT
 class ZMQSubscriber:
     """ Adapted from https://github.com/bitcoin/bitcoin/blob/master/contrib/zmq/zmq_sub.py"""
 
-    def __init__(self, parent):
+    def __init__(self, config, parent):
         self.zmqContext = zmq.Context()
         self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)
         self.zmqSubSocket.setsockopt(zmq.RCVHWM, 0)
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashblock")
-        self.zmqSubSocket.connect("%s://%s:%s" % (FEED_PROTOCOL, FEED_ADDR, FEED_PORT))
+        self.zmqSubSocket.connect(
+            "%s://%s:%s" % (config.get("FEED_PROTOCOL"), config.get("FEED_ADDR"), config.get("FEED_PORT"))
+        )
         self.logger = Logger("ZMQSubscriber-{}".format(parent))
 
         self.terminate = False

pisa/watcher.py

@@ -10,7 +10,6 @@ from pisa.cleaner import Cleaner
 from pisa.responder import Responder
 from pisa.block_processor import BlockProcessor
 from pisa.utils.zmq_subscriber import ZMQSubscriber
-from pisa.conf import EXPIRY_DELTA, MAX_APPOINTMENTS
 
 logger = Logger("Watcher")
 
@@ -58,18 +57,18 @@ class Watcher:
 
     """
 
-    def __init__(self, db_manager, sk_der, responder=None, max_appointments=MAX_APPOINTMENTS):
+    def __init__(self, db_manager, sk_der, config, responder=None):
         self.appointments = dict()
         self.locator_uuid_map = dict()
         self.asleep = True
         self.block_queue = Queue()
-        self.max_appointments = max_appointments
+        self.config = config
         self.zmq_subscriber = None
         self.db_manager = db_manager
         self.signing_key = Cryptographer.load_private_key_der(sk_der)
 
         if not isinstance(responder, Responder):
-            self.responder = Responder(db_manager)
+            self.responder = Responder(db_manager, self.config)
 
     @staticmethod
     def compute_locator(tx_id):
@@ -115,7 +114,7 @@ class Watcher:
 
         """
 
-        if len(self.appointments) < self.max_appointments:
+        if len(self.appointments) < self.config.get("MAX_APPOINTMENTS"):
             uuid = uuid4().hex
             self.appointments[uuid] = appointment
 
@@ -157,7 +156,7 @@ class Watcher:
         trough the ``block_queue``.
         """
 
-        self.zmq_subscriber = ZMQSubscriber(parent="Watcher")
+        self.zmq_subscriber = ZMQSubscriber(self.config, parent="Watcher")
         self.zmq_subscriber.handle(self.block_queue)
 
     def do_watch(self):
@@ -182,7 +181,7 @@ class Watcher:
                 expired_appointments = [
                     uuid
                     for uuid, appointment in self.appointments.items()
-                    if block["height"] > appointment.end_time + EXPIRY_DELTA
+                    if block["height"] > appointment.end_time + self.config.get("EXPIRY_DELTA")
                 ]
 
                 Cleaner.delete_expired_appointment(