refactored p2pool node implementation from p2pool.main to p2pool.node. dedicated...

[p2pool.git] / p2pool / p2p.py

diff --git a/p2pool/p2p.py b/p2pool/p2p.py
index 4cff950..22a731f 100644 (file)
--- a/p2pool/p2p.py
+++ b/p2pool/p2p.py
@@ -2,6 +2,7 @@ from __future__ import division
 
 import math
 import random
+import sys
 import time
 
 from twisted.internet import defer, protocol, reactor
@@ -20,8 +21,8 @@ def fragment(f, **kwargs):
     try:
         return f(**kwargs)
     except p2protocol.TooLong:
-        att(f, **dict((k, v[:len(v)//2]) for k, v in kwargs.iteritems()))
-        return att(f, **dict((k, v[len(v)//2:]) for k, v in kwargs.iteritems()))
+        fragment(f, **dict((k, v[:len(v)//2]) for k, v in kwargs.iteritems()))
+        return fragment(f, **dict((k, v[len(v)//2:]) for k, v in kwargs.iteritems()))
 
 class Protocol(p2protocol.Protocol):
     max_remembered_txs_size = 2500000
@@ -185,7 +186,7 @@ class Protocol(p2protocol.Protocol):
                 assert self.remote_remembered_txs_size <= self.max_remembered_txs_size
                 fragment(self.send_remember_tx, tx_hashes=[x for x in added if x in self.remote_tx_hashes], txs=[after[x] for x in added if x not in self.remote_tx_hashes])
             if removed:
-                self.send_forget_tx(tx_hashes=removed)
+                self.send_forget_tx(tx_hashes=list(removed))
                 self.remote_remembered_txs_size -= sum(len(bitcoin_data.tx_type.pack(before[x])) for x in removed)
         watch_id2 = self.node.mining_txs_var.transitioned.watch(update_remote_view_of_my_mining_txs)
         self.connection_lost_event.watch(lambda: self.node.mining_txs_var.transitioned.unwatch(watch_id2))
@@ -323,11 +324,13 @@ class Protocol(p2protocol.Protocol):
         ('tx_hashes', pack.ListType(pack.IntType(256))),
     ])
     def handle_have_tx(self, tx_hashes):
+        assert self.remote_tx_hashes.isdisjoint(tx_hashes)
         self.remote_tx_hashes.update(tx_hashes)
     message_losing_tx = pack.ComposedType([
         ('tx_hashes', pack.ListType(pack.IntType(256))),
     ])
     def handle_losing_tx(self, tx_hashes):
+        assert self.remote_tx_hashes.issuperset(tx_hashes)
         self.remote_tx_hashes.difference_update(tx_hashes)
     
     
@@ -337,28 +340,41 @@ class Protocol(p2protocol.Protocol):
     ])
     def handle_remember_tx(self, tx_hashes, txs):
         for tx_hash in tx_hashes:
-            if tx_hash not in self.remembered_txs:
-                if tx_hash in self.node.known_txs_var.value:
-                    tx = self.node.known_txs_var.value[tx_hash]
+            if tx_hash in self.remembered_txs:
+                print >>sys.stderr, 'Peer referenced transaction twice, disconnecting'
+                self.transport.loseConnection()
+                return
+            
+            if tx_hash in self.node.known_txs_var.value:
+                tx = self.node.known_txs_var.value[tx_hash]
+            else:
+                for cache in self.known_txs_cache.itervalues():
+                    if tx_hash in cache:
+                        tx = cache[tx_hash]
+                        print 'Transaction rescued from peer latency cache!'
+                        break
                 else:
-                    for cache in self.known_txs_cache.itervalues():
-                        if tx_hash in cache:
-                            tx = cache[tx_hash]
-                            print 'Transaction rescued from peer latency cache!'
-                            break
-                    else:
-                        print >>sys.stderr, 'Peer referenced unknown transaction, disconnecting'
-                        self.transport.loseConnection()
-                        return
-                
-                self.remembered_txs[tx_hash] = tx
-                self.remembered_txs_size += len(bitcoin_data.tx_type.pack(tx))
+                    print >>sys.stderr, 'Peer referenced unknown transaction, disconnecting'
+                    self.transport.loseConnection()
+                    return
+            
+            self.remembered_txs[tx_hash] = tx
+            self.remembered_txs_size += len(bitcoin_data.tx_type.pack(tx))
         new_known_txs = dict(self.node.known_txs_var.value)
+        warned = False
         for tx in txs:
             tx_hash = bitcoin_data.hash256(bitcoin_data.tx_type.pack(tx))
-            if tx_hash not in self.remembered_txs:
-                self.remembered_txs[tx_hash] = tx
-                self.remembered_txs_size += len(bitcoin_data.tx_type.pack(tx))
+            if tx_hash in self.remembered_txs:
+                print >>sys.stderr, 'Peer referenced transaction twice, disconnecting'
+                self.transport.loseConnection()
+                return
+            
+            if tx_hash in self.node.known_txs_var.value and not warned:
+                print 'Peer sent entire transaction that was already received'
+                warned = True
+            
+            self.remembered_txs[tx_hash] = tx
+            self.remembered_txs_size += len(bitcoin_data.tx_type.pack(tx))
             new_known_txs[tx_hash] = tx
         self.node.known_txs_var.set(new_known_txs)
         if self.remembered_txs_size >= self.max_remembered_txs_size:
@@ -536,17 +552,17 @@ class SingleClientFactory(protocol.ReconnectingClientFactory):
         self.node.lost_conn(proto, reason)
 
 class Node(object):
-    def __init__(self, best_share_hash_func, port, net, addr_store={}, connect_addrs=set(), desired_outgoing_conns=10, max_outgoing_attempts=30, max_incoming_conns=50, preferred_storage=1000, traffic_happened=variable.Event(), known_txs_var=variable.Variable({}), mining_txs_var=variable.Variable({})):
+    def __init__(self, best_share_hash_func, port, net, addr_store={}, connect_addrs=set(), desired_outgoing_conns=10, max_outgoing_attempts=30, max_incoming_conns=50, preferred_storage=1000, known_txs_var=variable.Variable({}), mining_txs_var=variable.Variable({})):
         self.best_share_hash_func = best_share_hash_func
         self.port = port
         self.net = net
         self.addr_store = dict(addr_store)
         self.connect_addrs = connect_addrs
         self.preferred_storage = preferred_storage
-        self.traffic_happened = traffic_happened
         self.known_txs_var = known_txs_var
         self.mining_txs_var = mining_txs_var
         
+        self.traffic_happened = variable.Event()
         self.nonce = random.randrange(2**64)
         self.peers = {}
         self.bans = {} # address -> end_time