def _run(self):
log.info('waiting for bootstrap')
gevent.sleep(3)
loop_delay = 1
while not self.is_stopped:
#log.info('in loop', num_peers=len(self.peers))
num_peers, min_peers = self.num_peers(
), self.config['p2p']['min_peers']
kademlia_proto = self.app.services.discovery.protocol.kademlia
if num_peers < min_peers:
log.info('missing peers',
num_peers=num_peers,
min_peers=min_peers,
known=len(kademlia_proto.routing))
nodeid = kademlia.random_nodeid()
kademlia_proto.find_node(nodeid) # fixme, should be a task
gevent.sleep(2) # wait for results
neighbours = kademlia_proto.routing.neighbours(nodeid, 1)
node = neighbours[0]
log.info('connecting random', node=node)
local_pubkey = crypto.privtopub(
self.config['node']['privkey_hex'].decode('hex'))
if node.pubkey == local_pubkey:
continue
if node.pubkey in [p.remote_pubkey for p in self.peers]:
continue
self.connect((node.address.ip, node.address.port), node.pubkey)
gevent.sleep(loop_delay)
evt = gevent.event.Event()
evt.wait()
def _run(self):
log.info('waiting for bootstrap')
gevent.sleep(3)
loop_delay = 1
while not self.is_stopped:
#log.info('in loop', num_peers=len(self.peers))
num_peers, min_peers = self.num_peers(), self.config['p2p']['min_peers']
kademlia_proto = self.app.services.discovery.protocol.kademlia
if num_peers < min_peers:
log.info('missing peers', num_peers=num_peers,
min_peers=min_peers, known=len(kademlia_proto.routing))
nodeid = kademlia.random_nodeid()
kademlia_proto.find_node(nodeid) # fixme, should be a task
gevent.sleep(2) # wait for results
neighbours = kademlia_proto.routing.neighbours(nodeid, 1)
node = neighbours[0]
log.info('connecting random', node=node)
local_pubkey = crypto.privtopub(self.config['node']['privkey_hex'].decode('hex'))
if node.pubkey == local_pubkey:
continue
if node.pubkey in [p.remote_pubkey for p in self.peers]:
continue
self.connect((node.address.ip, node.address.tcp_port), node.pubkey)
gevent.sleep(loop_delay)
evt = gevent.event.Event()
evt.wait()
def __init__(self, app):
log.info('PeerManager init')
self.peers = []
self.errors = PeerErrors()
WiredService.__init__(self, app)
# setup nodeid based on privkey
if 'id' not in self.config['p2p']:
self.config['node']['id'] = crypto.privtopub(
self.config['node']['privkey_hex'].decode('hex'))
def __init__(self, app):
log.info('PeerManager init')
self.peers = []
self.errors = PeerErrors()
WiredService.__init__(self, app)
# setup nodeid based on privkey
if 'id' not in self.config['p2p']:
self.config['node']['id'] = crypto.privtopub(
self.config['node']['privkey_hex'].decode('hex'))
def main():
alice_privkey = mk_privkey('secret1')
alice_pubkey = privtopub(alice_privkey)
print len(alice_pubkey), type(alice_pubkey)
alice = LocalNode(alice_pubkey, alice_privkey)
bob_privkey = mk_privkey('secret2')
bob_pubkey = privtopub(bob_privkey)
bob = LocalNode(bob_pubkey, bob_privkey)
def _receivecb(peer, data):
print peer, data
# alice knows bob and connects
node_bob = RemoteNode(bob_pubkey)
peer_alice = Peer(alice, transport=None, receive_cb=_receivecb)
peer_bob = Peer(bob, transport=None, receive_cb=_receivecb)
peer_alice.transport = Transport(sender=peer_alice, receiver=peer_bob)
peer_bob.transport = Transport(sender=peer_bob, receiver=peer_alice)
peer_alice.connect(peer_bob)
def __init__(self, app):
log.info('PeerManager init')
WiredService.__init__(self, app)
self.peers = []
self.errors = PeerErrors(
) if self.config['log_disconnects'] else PeerErrorsBase()
# setup nodeid based on privkey
if 'id' not in self.config['p2p']:
self.config['node']['id'] = crypto.privtopub(
self.config['node']['privkey_hex'].decode('hex'))
self.listen_addr = (self.config['p2p']['listen_host'],
self.config['p2p']['listen_port'])
self.server = StreamServer(self.listen_addr,
handle=self._on_new_connection)
def __init__(self, app):
log.info('PeerManager init')
WiredService.__init__(self, app)
self.peers = []
self.errors = PeerErrors(
) if self.config['log_disconnects'] else PeerErrorsBase()
self.result_dir = self.config["result_dir"] if self.config[
"result_dir"] != "" else self.result_dir
self.prev_routing_table = self.config[
"prev_routing_table"] if self.config[
"prev_routing_table"] != "" else self.prev_routing_table
self.prev_peers = self.config["prev_peers"] if self.config[
"prev_peers"] != "" else self.prev_peers
# setup nodeid based on privkey
print self.config
if 'id' not in self.config['p2p']:
self.config['node']['id'] = crypto.privtopub(
self.config['node']['privkey_hex'].decode('hex'))
self.listen_addr = (self.config['p2p']['listen_host'],
self.config['p2p']['listen_port'])
def _discovery_loop(self):
log.info('waiting for bootstrap')
gevent.sleep(self.discovery_delay)
while not self.is_stopped:
num_peers, min_peers = self.num_peers(
), self.config['p2p']['min_peers']
try:
kademlia_proto = self.app.services.discovery.protocol.kademlia
except AttributeError:
# TODO: Is this the correct thing to do here?
log.error("Discovery service not available.")
break
if num_peers < min_peers:
log.debug('missing peers',
num_peers=num_peers,
min_peers=min_peers,
known=len(kademlia_proto.routing))
nodeid = kademlia.random_nodeid()
kademlia_proto.find_node(nodeid) # fixme, should be a task
gevent.sleep(self.discovery_delay) # wait for results
neighbours = kademlia_proto.routing.neighbours(nodeid, 2)
if not neighbours:
gevent.sleep(self.connect_loop_delay)
continue
node = random.choice(neighbours)
log.debug('connecting random', node=node)
local_pubkey = crypto.privtopub(
self.config['node']['privkey_hex'].decode('hex'))
if node.pubkey == local_pubkey:
continue
if node.pubkey in [p.remote_pubkey for p in self.peers]:
continue
self.connect((node.address.ip, node.address.tcp_port),
node.pubkey)
gevent.sleep(self.connect_loop_delay)
evt = gevent.event.Event()
evt.wait()
num_peers: 10
bootstrap_nodes:
# local bootstrap
# - enode://6ed2fecb28ff17dec8647f08aa4368b57790000e0e9b33a7b91f32c41b6ca9ba21600e9a8c44248ce63a71544388c6745fa291f88f8b81e109ba3da11f7b41b9@127.0.0.1:30303
# go_bootstrap
- enode://6cdd090303f394a1cac34ecc9f7cda18127eafa2a3a06de39f6d920b0e583e062a7362097c7c65ee490a758b442acd5c80c6fce4b148c6a391e946b45131365b@54.169.166.226:30303
# cpp_bootstrap
#- enode://4a44599974518ea5b0f14c31c4463692ac0329cb84851f3435e6d1b18ee4eae4aa495f846a0fa1219bd58035671881d44423876e57db2abd57254d0197da0ebe@5.1.83.226:30303
listen_host: 0.0.0.0
listen_port: 30303
privkey_hex: 65462b0520ef7d3df61b9992ed3bea0c56ead753be7c8b3614e0ce01e4cac41b
"""
if len(sys.argv) == 1:
config = yaml.load(io.BytesIO(sample_config))
pubkey = crypto.privtopub(config['p2p']['privkey_hex'].decode('hex'))
config['p2p']['node_id'] = crypto.sha3(pubkey)
else:
fn = sys.argv[1]
log.info('loading config from', fn=fn)
config = yaml.load(open(fn))
print config
# create app
app = BaseApp(config)
# register services
NodeDiscovery.register_with_app(app)
PeerManager.register_with_app(app)
# JSONRPCServer.register_with_app(app)
def main():
# config
import yaml
import io
import sys
import signal
import gevent
from peermanager import PeerManager
from jsonrpc import JSONRPCServer
from discovery import NodeDiscovery
import slogging
log = slogging.get_logger('app')
slogging.configure(config_string=':debug')
# read config
sample_config = """
p2p:
num_peers: 10
bootstrap_nodes:
# local bootstrap
# - enode://6ed2fecb28ff17dec8647f08aa4368b57790000e0e9b33a7b91f32c41b6ca9ba21600e9a8c44248ce63a71544388c6745fa291f88f8b81e109ba3da11f7b41b9@127.0.0.1:30303
# go_bootstrap
#- enode://6cdd090303f394a1cac34ecc9f7cda18127eafa2a3a06de39f6d920b0e583e062a7362097c7c65ee490a758b442acd5c80c6fce4b148c6a391e946b45131365b@54.169.166.226:30303
# cpp_bootstrap
- enode://4a44599974518ea5b0f14c31c4463692ac0329cb84851f3435e6d1b18ee4eae4aa495f846a0fa1219bd58035671881d44423876e57db2abd57254d0197da0ebe@5.1.83.226:30303
listen_host: 0.0.0.0
listen_port: 30303
node:
privkey_hex: 65462b0520ef7d3df61b9992ed3bea0c56ead753be7c8b3614e0ce01e4cac41b
"""
if len(sys.argv) == 1:
config = yaml.load(io.BytesIO(sample_config))
pubkey = crypto.privtopub(config['node']['privkey_hex'].decode('hex'))
config['node']['id'] = crypto.sha3(pubkey)
else:
fn = sys.argv[1]
log.info('loading config from', fn=fn)
config = yaml.load(open(fn))
# stop on every unhandled exception!
gevent.get_hub().SYSTEM_ERROR = BaseException # (KeyboardInterrupt, SystemExit, SystemError)
print config
# create app
app = BaseApp(config)
# register services
NodeDiscovery.register_with_app(app)
PeerManager.register_with_app(app)
# JSONRPCServer.register_with_app(app)
# start app
app.start()
# wait for interupt
evt = gevent.event.Event()
# gevent.signal(signal.SIGQUIT, gevent.kill) ## killall pattern
gevent.signal(signal.SIGQUIT, evt.set)
gevent.signal(signal.SIGTERM, evt.set)
gevent.signal(signal.SIGINT, evt.set)
evt.wait()
# finally stop
app.stop()
