event loop, node address management

Author: kylegibson

bitcoin.py

@@ -66,7 +66,25 @@ def initialize_configuration():
 	if options.nodes:
 		options.irc = ""
 		options.dns = ""
-		options.add_nodes = []
+		options.add_nodes = ""
+
+	nodes = []
+	for node in options.nodes.split(","):
+		if not node:
+			continue
+		ip, port = node.split(":")
+		nodes.append((ip, int(port)))
+
+	for node in options.add_nodes.split(","):
+		if not node:
+			continue
+		ip, port = node.split(":")
+		nodes.append((ip, int(port)))
+
+	irc = None
+	if options.irc:
+		irc_ip, irc_port = options.irc.split(":")
+		irc = (irc_ip, int(irc_port))
 
 	config = {
 		"boot" : time.time(),
@@ -80,15 +98,13 @@ def initialize_configuration():
 		"local_port" : options.port,
 		"external_ip" : options.external_ip,
 		"irc_timeout" : options.irc_timeout,
-		"dns_seed" : options.dns.split(","),
+		"dns_seed" : options.dns.split(",") if options.dns else [],
 		"genesis_hash" : genesis_hash,
 		"event_loop_sleep" : 0.01,
 		"event_loop_timeout" : 10,
-		"nodes" : options.nodes + options.add_nodes,
+		"nodes" : nodes,
+		"irc" : irc,
 	}
-	if options.irc:
-		irc_ip, irc_port = options.irc.split(":")
-		config["irc"] = (irc_ip, int(irc_port))
 
 	return config
 

context.py

@@ -24,7 +24,9 @@ def __init__(self, config):
 		self.nodes = set()
 
 	def get_dns_nodes(self):
-		for host in hosts:
+		for host in self.config["dns_seed"]:
+			if not host:
+				continue
 			ips = socket.gethostbyname_ex(host)[2]
 			for ip in ips:
 				yield ip
@@ -38,34 +40,60 @@ def get_external_ip_using_http(self):
 
 	def seed_dns_nodes(self):
 		for ip in self.get_dns_nodes():
+			if not ip:
+				continue
 			self.add_node_address((ip, config["default_port"]))
 
 	def event_loop(self):
-		seeder = None
-		state = 1
-		if self.config.get("irc", None) is not None:
-			seeder = irc.BIRCSeeder(self)
-			state = 0
-
+		bootstrap = True
+		birc = None
+		uptime_wait = 1
+		if self.config.get("irc", None):
+			birc = irc.BIRCSeeder(self)
+			uptime_wait = 10
+
+		nodes = []
+		if self.config["nodes"]:
+			for node in self.config["nodes"]:
+				self.add_node_address(node)
+
+		uptime = self.get_uptime()
+		delta = 0
 		while True:
 			asyncore.loop(timeout=self.config["event_loop_timeout"],count=1)
 			time.sleep(self.config["event_loop_sleep"])
-			if state == 0:
-				if seeder: 
-					if self.config.get("external_ip", None) and len(self.addresses[1]) > 0:
-						state = 2
-					elif self.get_uptime() > self.config["irc_timeout"]:
-						logging.error("IRC failed to get external IP or nodes within %s seconds", self.get_uptime())
-						state = 1
-			elif state == 1:
-				self.set_external_ip(self.get_external_ip_using_http())
-				self.seed_dns_nodes()
-				state = 2
-			elif state == 2:
+			delta += self.get_uptime() - uptime
+			uptime = self.get_uptime()
+			if bootstrap and uptime > uptime_wait and delta > 1:
+				delta = 0
+				eip = self.config.get("external_ip", None)
+				naddr = len(self.addresses[1])
+				if eip and naddr > 0:
+					bootstrap = False
+					continue
+				if birc and uptime > self.config["irc_timeout"]:
+					logging.error("IRC failed to get external IP or nodes within %s seconds, falling back", uptime)
+					birc.close()
+					birc = None
+				if not birc:
+					if self.config.get("dns_seed"):
+						logging.debug("seeding using dns")
+						self.seed_dns_nodes()
+					if not eip:
+						ip = self.get_external_ip_using_http()
+						self.set_external_ip(ip)
+					bootstrap = False
+			elif not bootstrap and delta > 1:
 				if len(self.nodes) < self.config["maxconnections"]:
-					self.create_node_connection()
+					if len(self.addresses[0]) > 0:
+						self.create_node_connection()
+					elif len(self.addresses[1]) == 0:
+						logging.error("No addresses available")
+						time.sleep(5)
 
 	def create_node_connection(self):
+		if len(self.addresses[0]) == 0:
+			return
 		addr = self.addresses[0].pop()
 		node = net.BConnection(addr, self) 
 		self.nodes.add(node)
@@ -76,8 +104,12 @@ def add_node_address(self, addr):
 			self.addresses[1].add(addr)
 
 	def set_external_ip(self, ip):
+		logging.debug("got external ip %s", ip)
 		self.config["external_ip"] = ip
 
+	def get_external_address(self):
+		return self.config["external_ip"]
+
 	def get_last_block(self):
 		return len(self.blocks)
 

net.py

@@ -44,6 +44,13 @@ def reset_incoming_data(self):
 	def handle_connect(self):
 		logging.debug("connected to node %s", self.addr)
 
+	def handle_expt(self):
+		if not self.connected:
+			logging.debug("connection refused to %s", self.addr)
+		else:
+			logging.exception()
+		self.close()
+
 	def found_terminator(self):
 		logging.debug("received packet %s", len(self.incoming_data))
 		if callable(self.incoming_handler):
@@ -56,7 +63,7 @@ def found_terminator(self):
 				self.close()
 			return
 		network, command, paylen = self.unpack_incoming_header()
-		if network != self.content.config["network"]:
+		if network != self.context.config["network"]:
 			logging.error("received garbage from %s", connection.addr)
 			self.close()
 			return
@@ -91,7 +98,7 @@ def push_version(self):
 				self.addr[0], self.addr[1])
 		local = self.context.parser.pack_address(
 				self.context.config["services"],
-				self.context.config["external_ip"], 
+				self.context.get_external_address(),
 				self.context.config["local_port"])
 		data = struct.pack("<iQQ26s26sQxL", 
 				self.context.config["version"], 
@@ -107,9 +114,9 @@ def pop_version(self):
 		if self.remote:
 			return 
 		self.incoming_handler = None
-		(pack,), data = self.context.parser.unpack("<iQQ26s26sQxL", self.incoming_data)
+		result, data = self.context.parser.unpack("<iQQ26s26sQxL", self.incoming_data)
 		self.incoming_data = data
-		version, services, timestamp, remote, local, nonce, last = pack
+		version, services, timestamp, remote, local, nonce, last = result
 		logging.debug("pop_version %s %s %s %s %s", version, services, timestamp, nonce, last)
 		if nonce == self.context.config["nonce"] and nonce > 1:
 			logging.error("Connected to self, disconnecting")