Updates to the code base to unify some stuff.

ll-ruoti · ll-ruoti · commit d7f8cf9f96aa · 2018-06-18T16:27:16.000-04:00
diff --git a/build.py b/build.py
@@ -0,0 +1,59 @@
+import logging
+from pynt import task
+import sys
+
+sys.path.append('.')
+from simulation_settings import SimulationSettings, TopologySelection
+
+# Setup logging.
+logging.basicConfig(level=logging.DEBUG)
+
+
+def runSimulation(settings, graph):
+    """Execute a single run of the simulation.
+
+    Arguments:
+        settings {SimulationSettings} -- Settings for the simulation.
+        graph {networkx.Graph} -- Graph of the miners.
+    """
+
+    for node in graph.nodes:
+        pass
+        #graph.nodes[node]['miner'] = settings.protocol.getMinerClass()()
+
+    return None
+
+
+@task()
+def run(file='sim.json'):
+    simulation_settings = SimulationSettings(file)
+    graph = simulation_settings.topology.generateMinerGraph()
+    output = runSimulation(simulation_settings, graph)
+    # TODO: Record this output
+
+
+@task()
+def runMonteCarlo(file='sim.json'):
+    simulation_settings = SimulationSettings(file)
+    if simulation_settings.topology_selection == TopologySelection.GENERATE_ONCE:
+        single_graph = simulation_settings.topology.generateMinerGraph()
+
+    for i in range(0, simulation_settings.number_of_executions):
+        # thread
+        if simulation_settings.topology_selection == TopologySelection.GENERATE_EACH_TIME:
+            graph = simulation_settings.topology.generateMinerGraph()
+        else:
+            graph = single_graph.copy()
+
+        # colate output
+        output = runSimulation(simulation_settings, graph)
+
+
+@task()
+def analyze(input='./out/data'):
+    # TODO
+    pass
+
+
+# Sets the default task
+__DEFAULT__ = run
diff --git a/distribution.py b/distribution.py
@@ -0,0 +1,56 @@
+from enum import Enum
+from numpy import random
+from pprint import pformat
+
+
+class DistributionType(Enum):
+    """Types of distributions to sample from.
+    """
+    UNIFORM = 1,
+    GAUSSIAN = 2,
+    LAPLACIAN = 3
+
+
+class Distribution:
+    def __init__(self, settings):
+        """Parses the settings in the value parameter.
+
+        Arguments:
+            settings {dict} -- The setings for the distribution.
+        """
+        self.distribution_type = DistributionType[settings['type']]
+        if self.distribution_type == DistributionType.UNIFORM:
+            self.low = settings['low']
+            self.high = settings['high']
+        elif self.distribution_type == DistributionType.GAUSSIAN or self.distribution_type == DistributionType.LAPLACIAN:
+            self.average = settings['average']
+            self.standard_deviation = settings['standardDeviation']
+        else:
+            raise NotImplementedError("Distribution type not yet implemented")
+
+    def sample(self, size=None):
+        """Samples from the distribution
+
+        Keyword Arguments:
+            size {int or tuple of ints} -- Output shape. If the given shape is, e.g., (m, n, k), then m * n * k samples are drawn.
+            If size is None (default), a single value is returned if loc and scale are both scalars. Otherwise,
+            np.broadcast(loc, scale).size samples are drawn. (default: {None})
+
+        Returns:
+            ndarray or scalar -- Drawn samples from the parameterized distribution.
+        """
+
+        if self.distribution_type == DistributionType.UNIFORM:
+            return random.uniform(self.low, self.high, size)
+        elif self.distribution_type == DistributionType.GAUSSIAN:
+            return random.normal(self.average, self.standard_deviation, size)
+        elif self.distribution_type == DistributionType.LAPLACIAN:
+            return random.laplace(self.average, self.standard_deviation, size)
+        else:
+            raise NotImplementedError("Distribution type not yet implemented")
+
+    def __str__(self):
+        return pformat(self.__dict__, indent=12)
+
+    def __repr__(self):
+        return pformat(self.__dict__, indent=12)
diff --git a/protocol_settings.py b/protocol_settings.py
@@ -0,0 +1,52 @@
+from enum import Enum
+import json
+from pprint import pformat
+
+import protocols
+
+
+class ProtocolType(Enum):
+    """The various protocol types supported by this framework.
+    """
+    BITCOIN = 1
+    IOTA = 2
+
+
+class ProtocolSettings:
+    def __init__(self, value):
+        """Parses the settings in the value parameter.
+
+        Arguments:
+            value {str|dict} -- If a string, it is a pointer to a JSON-encoded file containing the settings. If a dict, then it is the settings.
+        """
+        if type(value) is str:
+            # Treat the value as a file locator.
+            with open(value, 'r') as settingsFile:
+                data = json.load(settingsFile)
+        else:
+            data = value
+
+        self.protocol_type = ProtocolType[data['type']]
+        if self.protocol_type == ProtocolType.BITCOIN:
+            self.accept_depth = data['acceptDepth']
+            self.transaction_generation_probability = data['transactionGenerationProbability']
+        elif self.protocol_type == ProtocolType.IOTA:
+            self.transaction_generation_probability = data['transactionGenerationProbability']
+        else:
+            raise NotImplementedError("Selected protocol type is not implemented")
+
+    def getMinerClass(self):
+        """Gets the appropriate class for creating miners based on the protocol type.
+        """
+        if self.protocol_type == ProtocolType.BITCOIN:
+            return protocols.bitcoin.Bitcoin
+        elif self.protocol_type == ProtocolType.IOTA:
+            return protocols.iota.Iota
+        else:
+            raise NotImplementedError("Selected protocol type is not implemented")
+
+    def __str__(self):
+        return pformat(self.__dict__, indent=8)
+
+    def __repr__(self):
+        return pformat(self.__dict__, indent=8)
diff --git a/protocols/__init__.py b/protocols/__init__.py
@@ -0,0 +1,6 @@
+import os
+for module in os.listdir(os.path.dirname(__file__)):
+    if module == '__init__.py' or module[-3:] != '.py':
+        continue
+    __import__(module[:-3], locals(), globals())
+del module
diff --git a/protocols/bitcoin.py b/protocols/bitcoin.py
diff --git a/protocols/iota.py b/protocols/iota.py
diff --git a/readme.md b/readme.md
@@ -0,0 +1,2 @@
+## Installation
+This project uses virtualenv (.venv). Packages are stored in requirements.txt and can be installed using `pip install -r requirements.txt`
diff --git a/requirements.txt b/requirements.txt
@@ -0,0 +1,25 @@
+astroid==1.6.5
+autopep8==1.3.5
+backports.functools-lru-cache==1.5
+configparser==3.5.0
+cycler==0.10.0
+decorator==4.3.0
+enum34==1.1.6
+futures==3.2.0
+isort==4.3.4
+kiwisolver==1.0.1
+lazy-object-proxy==1.3.1
+matplotlib==2.2.2
+mccabe==0.6.1
+networkx==2.1
+numpy==1.14.5
+pycodestyle==2.4.0
+pylint==1.9.2
+pynt==0.8.1
+pyparsing==2.2.0
+python-dateutil==2.7.3
+pytz==2018.4
+singledispatch==3.4.0.3
+six==1.11.0
+subprocess32==3.5.2
+wrapt==1.10.11
diff --git a/sim.json b/sim.json
@@ -1,8 +1,22 @@
-{    
-    "numMiners" : 200,
-    "txGenProb" : 0.00019,
-    "maxTx" : 55,
-    "bitcoinAcceptDepth" : 6,
-    "protocol" : "iota",
-    "outFile" : "out.p"
+{
+    "numberOfExecutions": 20,
+    "topologySelection": "GENERATE_ONCE", 
+    "terminationCondition": "NUMBER_OF_GENERATED_TRANSACTIONS",
+    "terminationValue": 50,
+
+    "topology": {
+        "type": "GEOMETRIC_UNIFORM_DELAY",
+        "radius": 0.125,
+        "numberOfMiners": 200,
+        "networkDelay": {
+            "type": "GAUSSIAN",
+            "average": 5,
+            "standardDeviation": 1.3
+        }
+    },
+    "protocol": {
+        "type": "BITCOIN",
+        "acceptDepth": 6,
+        "transactionGenerationProbability": 0.0001667
+    }
 }
diff --git a/sim.py b/sim.py
@@ -43,6 +43,7 @@ def runSim(g, o):
             o.txGenProb = -1
         anyHaveMsg = bool([True for i in g.nodes if g.nodes[i]['miner'].queue])
         if o.txGenProb <= 0 and not anyHaveMsg:  # run until no miners have messages
+
             break
         o.tick += 1
 
diff --git a/simulation_settings.py b/simulation_settings.py
@@ -0,0 +1,45 @@
+from enum import Enum
+import json
+from pprint import pformat
+
+from protocol_settings import ProtocolSettings
+from topology_settings import TopologySettings
+
+
+class TopologySelection(Enum):
+    """Enumeration of the possible topology selection.
+    """
+    GENERATE_ONCE = 1
+    GENERATE_EACH_TIME = 2
+
+
+class TerminationCondition(Enum):
+    """Enumeration tracking when an individual simulation terminates.
+    """
+    NUMBER_OF_GENERATED_TRANSACTIONS = 1,
+    NUMBER_OF_TIME_TICKS = 2
+
+
+class SimulationSettings:
+    """Handles loading simulation settings information from a file.
+    """
+
+    def __init__(self, fname):
+        with open(fname, 'r') as settingsFile:
+            data = json.load(settingsFile)
+
+        # Load settings.
+        self.number_of_executions = data['numberOfExecutions']
+        self.topology_selection = TopologySelection[data['topologySelection']]
+        self.termination_condition = TerminationCondition[data['terminationCondition']]
+        self.termination_value = data['terminationValue']
+
+        # Load the other settings objects
+        self.topology = TopologySettings(data['topology'])
+        self.protocol = ProtocolSettings(data['protocol'])
+
+    def __str__(self):
+        return pformat(self.__dict__, indent=4)
+
+    def __repr__(self):
+        return pformat(self.__dict__, indent=4)
diff --git a/topology_settings.py b/topology_settings.py
@@ -0,0 +1,71 @@
+from enum import Enum
+import json
+import networkx
+from pprint import pformat
+
+from distribution import Distribution
+
+class TopologyType(Enum):
+    """Types of miner topologies.
+    """
+    STATIC = 1,  # Load the topology from a file.
+    GEOMETRIC_UNIFORM_DELAY = 2,
+    LOBSTER_UNIFORM_DELAY = 3  # TODO: Toy example that should eventually be removed.
+    # TODO: Add appropraite types
+
+
+class TopologySettings:
+    def __init__(self, value):
+        """Parses the settings in the value parameter.
+
+        Arguments:
+            value {str|dict} -- If a string, it is a pointer to a JSON-encoded file containing the settings. If a dict, then it is the settings.
+        """
+        if type(value) is str:
+            # Treat the value as a file locator.
+            with open(value, 'r') as settingsFile:
+                data = json.load(settingsFile)
+        else:
+            data = value
+
+        self.topology_type = TopologyType[data['type']]
+        if self.topology_type == TopologyType.STATIC:
+            raise NotImplementedError("Static topologies are not yet implemented")
+        else:
+            self.number_of_miners = data['numberOfMiners']
+
+            if self.topology_type == TopologyType.GEOMETRIC_UNIFORM_DELAY or self.topology_type == TopologyType.LOBSTER_UNIFORM_DELAY:
+                # Graphs with uniform delays for message transmission.
+                self.network_delay = Distribution(data['networkDelay'])
+
+                if self.topology_type == TopologyType.GEOMETRIC_UNIFORM_DELAY:
+                    self.radius = data['radius']
+                elif self.topology_type == TopologyType.LOBSTER_UNIFORM_DELAY:
+                    self.p1 = data['p1']
+                    self.p2 = data['p2']
+            else:
+                raise NotImplementedError("Selected topology type is not implemented.")
+
+    def generateMinerGraph(self):
+        """Generates a miner graph based on the settings in this object.
+        """
+        if self.topology_type == TopologyType.STATIC:
+            raise NotImplementedError("Static topologies are not yet implemented")
+        else:
+            if self.topology_type == TopologyType.GEOMETRIC_UNIFORM_DELAY or self.topology_type == TopologyType.LOBSTER_UNIFORM_DELAY:
+                # Graphs with uniform delays for message transmission.
+                if self.topology_type == TopologyType.GEOMETRIC_UNIFORM_DELAY:
+                    graph = networkx.random_geometric_graph(self.number_of_miners, self.radius)
+                elif self.topology_type == TopologyType.LOBSTER_UNIFORM_DELAY:
+                    graph = networkx.random_lobster(self.number_of_miners, self.p1, self.p2)
+
+                for edge in graph.edges:
+                    graph.edges[edge]['network_delay'] = self.network_delay
+            else:
+                raise NotImplementedError("Selected topology type is not implemented.")
+
+    def __str__(self):
+        return pformat(self.__dict__, indent=8)
+
+    def __repr__(self):
+        return pformat(self.__dict__, indent=8)

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+## Installation`
	`2`	+This project uses virtualenv (.venv). Packages are stored in requirements.txt and can be installed using `pip install -r requirements.txt`