Exemple #1
0
def run_node():

    nodeReg = OrderedDict([
        ('Alpha', ('127.0.0.1', 8001)),
        ('Beta', ('127.0.0.1', 8003)),
        ('Gamma', ('127.0.0.1', 8005)),
        ('Delta', ('127.0.0.1', 8007))])

    # the first argument should be the node name
    try:
        nodeName = sys.argv[1]
    except IndexError:
        names = list(nodeReg.keys())
        print("Please supply a node name (one of {}) as the first argument.".
              format(", ".join(names)))
        print("For example:")
        print("    {} {}".format(sys.argv[0], names[0]))
        return

    with Looper(debug=False) as looper:
        # Nodes persist keys when bootstrapping to other nodes and reconnecting
        # using an ephemeral temporary directory when proving a concept is a
        # nice way to keep things tidy.
        with TemporaryDirectory() as tmpdir:
            node = Node(nodeName, nodeReg, basedirpath=tmpdir)

            # see simple_client.py
            joe_verkey = b'cffbb88a142be2f62d1b408818e21a2f' \
                         b'887c4442ae035a260d4cc2ec28ae24d6'
            node.clientAuthNr.addClient("Joe", joe_verkey)

            looper.add(node)
            node.startKeySharing()
            looper.run()
def testNodesConnectWhenTheyAllStartAtOnce():
    with TemporaryDirectory() as td:
        with Looper() as looper:
            nodes = []
            for name in nodeReg:
                node = Node(name, nodeReg, basedirpath=td)
                looper.add(node)
                node.startKeySharing()
                nodes.append(node)
            looper.run(checkNodesConnected(nodes))
Exemple #3
0
 def newNode(self, nodeName):
     if nodeName in self.nodes:
         print("Node {} already exists.\n".format(nodeName))
         return
     if nodeName == "all":
         names = set(self.nodeReg.keys()) - set(self.nodes.keys())
     elif nodeName not in self.nodeReg:
         tokens = [(Token.Error, "Invalid node name '{}'. ".format(nodeName))]
         self.printTokens(tokens)
         self.showValidNodes()
         return
     else:
         names = [nodeName]
     for name in names:
         node = Node(name, self.nodeReg, basedirpath=self.tmpdir)
         self.nodes[name] = node
         self.looper.add(node)
         node.startKeySharing()
         for client in self.clients.values():
             self.bootstrapClientKey(client, node)
def testNodesComingUpAtDifferentTimes():
    console = getConsole()
    console.reinit(flushy=True, verbosity=console.Wordage.verbose)
    with TemporaryDirectory() as td:
        print("temporary directory: {}".format(td))
        with Looper() as looper:
            nodes = []

            names = list(nodeReg.keys())
            shuffle(names)
            waits = [randint(1, 10) for _ in names]
            rwaits = [randint(1, 10) for _ in names]

            for i, name in enumerate(names):
                node = Node(name, nodeReg, basedirpath=td)
                looper.add(node)
                node.startKeySharing()
                nodes.append(node)
                looper.runFor(waits[i])
            looper.run(checkNodesConnected(nodes,
                                           overrideTimeout=10))
            print("connects")
            print("node order: {}".format(names))
            print("waits: {}".format(waits))

            for n in nodes:
                n.stop()
            for i, n in enumerate(nodes):
                n.start()
                looper.runFor(rwaits[i])
            looper.runFor(3)
            looper.run(checkNodesConnected(nodes,
                                           overrideTimeout=10))
            print("reconnects")
            print("node order: {}".format(names))
            print("rwaits: {}".format(rwaits))
Exemple #5
0
    with Looper(debug=False) as looper:

        """
        A node registry is a dictionary of Node names and their IP addresses
        and port numbers.
        """
        nodeReg = {
            'Alpha': ('127.0.0.1', 7560),
            'Beta': ('127.0.0.1', 7562),
            'Gamma': ('127.0.0.1', 7564),
            'Delta': ('127.0.0.1', 7566)}

        """
        Create a node called Alpha
        """
        alpha = Node('Alpha', nodeReg, basedirpath=tmpdir)

        """
        Add the Alpha node to the looper, so it can be serviced.
        """
        looper.add(alpha)

        """
        Start key sharing among nodes. Key sharing is a way to bootstrap a
        consensus pool when you don't want to manually construct keys
        beforehand. See the github wiki for more details on key sharing.
        """
        alpha.startKeySharing()

        """
        Do the same process for the other nodes. Ordinarily, we would never have
 def create(name):
     node = Node(name, nodeReg, basedirpath=td)
     looper.add(node)
     node.startKeySharing()
     nodes.append(node)