reorg and init integration with hybrid consensus

Author: arcolife

README.md

@@ -4,6 +4,9 @@ Refer to:
 https://arxiv.org/abs/1805.01457
 https://eprint.iacr.org/2016/917.pdf
 
+## Run
+
+Refer to `trueconsensus/README.md` for further instructions
 
 ### Parameterized by following..
 

trueconsensus/fastchain/README.md renamed to trueconsensus/README.md

@@ -6,7 +6,7 @@ This is a `Practical Byzantine Fault Tolerance` implementation of Miguel Castro
 
 #### Configure paths and tunables
 
-Fill up the config files `pbft_logistics.cfg` and `pbft_tunables.yaml` or use defaults.
+Fill up the config files `conf/pbft_logistics.cfg` and `conf/pbft_tunables.yaml` or use defaults.
 
 #### Install dependencies
 
@@ -33,19 +33,22 @@ OR
 Then proceed as follows:
 
 ```
-# generate requests_pb2.py from requests.proto file
-./proto.sh
+# change to folder trueconsensus
+cd trueconsensus/
+
+# generate proto/requests_pb2.py from proto/requests.proto file
+./utils/generate_proto.sh
 
 # generate asymm keypairs
-python make_keys.py
+python -m utils.make_keys
 
 # generate requests
-./generate_requests_dat.py 
+python -m utils.generate_requests_dat
 ```
 
 ### Run
 
-Server: `./server.py`
+Server: `./engine.py`
 
 Client: `./client.py`
 

trueconsensus/fastchain/client.py renamed to trueconsensus/client.py

@@ -11,8 +11,8 @@
 import socks
 # import time
 
-import request_pb2
-from config import client_address, \
+from proto import request_pb2
+from fastchain.config import client_address, \
     client_id, \
     RL, \
     client_logger, \

trueconsensus/fastchain/pbft_logistics.cfg renamed to trueconsensus/conf/pbft_logistics.cfg

@@ -1,5 +1,5 @@
-import proto_message as message
-from config import config_general
+from proto import proto_message as message
+from fastchain.config import config_general
 
 
 class bank:

trueconsensus/fastchain/pbft_tunables.yaml renamed to trueconsensus/conf/pbft_tunables.yaml

@@ -14,19 +14,164 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+import sys
+# import yaml
+import signal
+from datetime import datetime
+import socket
+# from random import random
+from argparse import RawTextHelpFormatter, \
+                ArgumentParser
+
+from threading import Timer, Thread
+
+from fastchain import node
+from fastchain.config import config_yaml, \
+    threading_enabled, \
+    _logger, \
+    N, \
+    RL
+
 from snailchain import SnailChain
-from fastchain.bft import NodeBFT, \
+from fastchain.bft_committee import NodeBFT, \
     ViewChangeInit, \
     LedgerLog, \
-    BFTcommittee, \
-    SubProtoDailyBFT, \
+    BFTcommittee
+
+from fastchain.subprotocol import SubProtoDailyBFT, \
     Mempools
 
+parser = ArgumentParser(formatter_class=RawTextHelpFormatter,
+                        description="""PBFT standalone server demo""")
+
+
+def suicide():
+    # import pdb; pdb.set_trace()
+    # sys.exit()
+    # quit()
+    os.kill(os.getpid(), signal.SIGINT)
+
+
+def signal_handler(event, frame):
+    sys.stdout.write("handling signal: %s\n" % event)
+    sys.stdout.flush()
+    _logger.error("Kill signal (%s) detected. Stopping pbft.." % event)
+    countdown = 3  # seconds
+    if event == signal.SIGINT:
+        print("Committing deliberate suicide in %s seconds" % countdown)
+        t = Timer(countdown, suicide)
+        t.start()
+        sys.exit(130)  # Ctrl-C for bash
+
+
+def init_server(id):
+    global RL
+    try:
+        ip, port = RL[id]
+    except IndexError as E:
+        quit("%s Ran out of replica list. No more server config to try" % E)
+    s = socket.socket()
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    # host = socket.gethostname()
+    host = "0.0.0.0"
+    s.bind((host, port))  # on EC2 we cannot directly bind on public addr
+    s.listen(50)
+    s.setblocking(0)
+    _logger.debug("Server [%s] -- listening on port %s" % (id, port))
+    _logger.debug("IP: %s" % ip)
+    return s
+
+
+class ThreadedExecution(object):
 
-class DailyOffChainConsensus(object):
     def __init__(self):
-        self.chain = []
-        self._lambda = None
+        pass
+
+    def run(self, ID):
+        sys.stdout.write("run started\n")
+        sys.stdout.flush()
+        socket_obj = init_server(ID)
+        n = node.Node(ID, 0, N)
+        # n.init_keys(N)
+        n.init_replica_map(socket_obj)
+        n.server_loop()
+        sys.stdout.write("run exited\n")
+        sys.stdout.flush()
+
+    def launch(self):
+        threads = []
+        for i in range(N):
+            thread = Thread(target=self.run, args=[i])
+            thread.start()
+            threads.append(thread)
 
-    def preproess(self):
+        for thread in threads:
+            thread.join()
+
+        sys.stdout.write("join completed\n")
+        sys.stdout.flush()
+
+
+class NonThreadedExecution(object):
+    '''
+    Finds sockets that aren't busy and attempts to establish and launch testbed
+    '''
+    def __init__(self):
         pass
+
+    def init_server_socket(self, _id=None):
+        """
+        triggers setup using testbed_config. Increments given server id
+        if that (ip, socket) from Replica List RL is already in use.
+        """
+        global N
+        c = _id
+        while c < N:
+            s = None
+            try:
+                s = init_server(c)
+            except OSError as E:
+                _logger.error("%s -- Server ID: [%s]" % (E, c))
+                c -= 1
+            if s:
+                return s, c
+
+    def launch(self):
+        socket_obj, _id = self.init_server_socket(
+            _id=config_yaml["testbed_config"]["server_id_init"] - 1
+        )
+        n = node.Node(_id, 0, N)
+        # n.init_keys(N)
+        n.init_replica_map(socket_obj)
+        n.server_loop()
+
+
+# def pbft_usage():
+#     parser.add_argument("-n", "--nodes", dest="node_count", action='store',
+#                         help="# of PBFT nodes to be launched")
+#     parser.add_argument("-id", "--node-id", dest="node_id",
+#                         action='store_true',
+#                         help="")
+#     parser.add_argument("-ts", "--tune-settings", dest="tune",
+#                         action='store_true',
+#                         help="")
+
+
+def main():
+    print("Start time: ", datetime.now())
+    print("Threading enabled: ", threading_enabled)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # import pdb; pdb.set_trace()
+    if threading_enabled:
+        ThreadedExecution().launch()
+    else:
+        NonThreadedExecution().launch()
+
+
+if __name__ == "__main__":
+    # import pdb; pdb.set_trace()
+    main()

trueconsensus/dapps/__init__.py

@@ -2,6 +2,5 @@
 Package import structure
 '''
 
-from fastchain.bft import *
+from fastchain.bft_committee import *
 from fastchain.node import *
-

trueconsensus/fastchain/bank.py renamed to trueconsensus/dapps/bank.py

@@ -19,16 +19,20 @@
 import os
 import uuid
 import random
-import ecdsa_sig as sig
 from db.backends.level import LevelDB
 
-from fastchain.config import LAMBDA, config_yaml
+from fastchain import ecdsa_sig as sig
+from fastchain.log_maintainer import LedgerLog
+from fastchain.config import config_yaml
 # from logging import ledger
 
 from fastchain.node import Node
+
 from collections import OrderedDict, \
     defaultdict, \
-    namedtuple
+    namedtuple  # for transaction tuple, use struct?
+
+LAMBDA = config_yaml['bft_committee']['lambda']
 
 
 def generate_block(genesis=True):
@@ -48,6 +52,15 @@ def generate_txns(R, l):
 #     return uuid.uuid4().hex
 
 
+class DailyOffChainConsensus(object):
+    def __init__(self):
+        self.chain = []
+        self._lambda = None
+
+    def preproess(self):
+        pass
+
+
 class NodeBFT(Node):
     '''
     @types:
@@ -67,9 +80,13 @@ class NodeBFT(Node):
     def __init__(self, id=None, type=None):
         self.NodeId = id
         self._type = 'BFTmember'
-        self.new_row = namedtuple('row', ['R','l','txn'])
+        self.new_row = namedtuple('row', ['R', 'l', 'txn'])
+        # TODO: maybe use ctypes.Structure or struct.Struct ?
         self.nonce = 0
 
+    def launch_boot_nodes(self):
+        return
+
     def log_to_snailchain(self):
         return
 
@@ -109,7 +126,6 @@ def call_to_viewchange(self):
         start = time.time()
         while true:
             response = VC.wait_for_reply()
-            if
             if response is not None:
                 break
         return
@@ -162,3 +178,4 @@ def fork_vbft(self):
         pass
 
     def update_mempool_subprotocol(self):
+        pass