def buildProtocol(self, addr):
print(f"building new protocol for addr: {addr}")
self.leader.AddKnownAddress(
Address(f"{addr.host}:{addr.port}"))
p = NeoNode(incoming_client=True)
p.factory = self
return p
def conn_setup(node: NeoNode):
# at this point we should have a fully connected node, so lets try to simulate a connection lost by the other side
with self.assertLogHandler('network', 10) as log:
node.connectionLost(failure.Failure(error.ConnectionDone()))
self.assertTrue(
"disconnected normally with reason" in log.output[-1])
self.assertNotIn(self.addr, self.leader.DEAD_ADDRS)
self.assertIn(self.addr, self.leader.KNOWN_ADDRS)
self.assertNotIn(self.addr, self.leader.Peers)
self.assertFalse(node.has_tasks_running())
def conn_setup(node: NeoNode):
# at this point we should have a fully connected node, so lets try to simulate a connection lost by the other side
with self.assertLogHandler('network', 10) as log:
# setup last_connection, to indicate we've lost connection before
node.address.last_connection = Address.Now(
) # returns a timestamp of utcnow()
# now lose the connection
node.connectionLost(failure.Failure(error.ConnectionLost()))
self.assertIn("second connection lost within 5 minutes",
log.output[-1])
self.assertIn(str(error.ConnectionLost()), log.output[-2])
self.assertIn(self.addr, self.leader.DEAD_ADDRS)
self.assertNotIn(self.addr, self.leader.KNOWN_ADDRS)
self.assertNotIn(self.addr, self.leader.Peers)
self.assertFalse(node.has_tasks_running())
def test_getpeers(self):
# Given this is an isolated environment and there is no peers
# lets simulate that at least some addresses are known
node = NodeLeader.Instance()
node.ADDRS = ["127.0.0.1:20333", "127.0.0.2:20334"]
test_node = NeoNode()
test_node.host = "127.0.0.1"
test_node.port = 20333
node.Peers.append(test_node)
req = self._gen_rpc_req("getpeers", params=[])
mock_req = mock_request(json.dumps(req).encode("utf-8"))
res = json.loads(self.app.home(mock_req))
self.assertEqual(len(node.Peers), len(res['result']['connected']))
self.assertEqual(len(res['result']['unconnected']),
len(node.ADDRS) - len(node.Peers))
# To avoid messing up the next tests
node.Peers = []
node.ADDRS = []
def test_getpeers(self):
# Given this is an isolated environment and there is no peers
# lets simulate that at least some addresses are known
node = NodeLeader.Instance()
node.ADDRS = ["127.0.0.1:20333", "127.0.0.2:20334"]
test_node = NeoNode()
test_node.host = "127.0.0.1"
test_node.port = 20333
node.Peers.append(test_node)
req = self._gen_rpc_req("getpeers", params=[])
mock_req = mock_request(json.dumps(req).encode("utf-8"))
res = json.loads(self.app.home(mock_req))
self.assertEqual(len(node.Peers), len(res['result']['connected']))
self.assertEqual(len(res['result']['unconnected']),
len(node.ADDRS) - len(node.Peers))
# To avoid messing up the next tests
node.Peers = []
node.ADDRS = []
def conn_setup(node: NeoNode):
with self.assertLogHandler('network', 10) as log:
# setup last_connection, to indicate we've lost connection before
node.address.last_connection = Address.Now(
) # returns a timestamp of utcnow()
# setup the heartbeat data to have last happened 25 seconds ago
# if we disconnect now we should get a premature disconnect
node.start_outstanding_data_request[
HEARTBEAT_BLOCKS] = Address.Now() - 25
# now lose the connection
node.connectionLost(failure.Failure(error.ConnectionLost()))
self.assertIn("Premature disconnect", log.output[-2])
self.assertIn(str(error.ConnectionLost()), log.output[-1])
self.assertIn(self.addr, self.leader.DEAD_ADDRS)
self.assertNotIn(self.addr, self.leader.KNOWN_ADDRS)
self.assertNotIn(self.addr, self.leader.Peers)
self.assertFalse(node.has_tasks_running())
def test_handle_message(self, mock):
node = NeoNode()
node.endpoint = Endpoint('hello.com', 1234)
node.host = node.endpoint.host
node.port = node.endpoint.port
payload = VersionPayload(10234, 1234, 'version')
message = Message('version', payload=payload)
stream = StreamManager.GetStream()
writer = BinaryWriter(stream)
message.Serialize(writer)
out = stream.getvalue()
print("OUT %s " % out)
out1 = out[0:10]
out2 = out[10:20]
out3 = out[20:]
node.dataReceived(out1)
node.dataReceived(out2)
self.assertEqual(node.buffer_in, out1 + out2)
# import pdb
# pdb.set_trace()
self.assertEqual(node.bytes_in, 20)
mock.assert_not_called()
node.dataReceived(out3)
self.assertEqual(node.bytes_in, len(out))
# mock.assert_called_with(message)
mock.assert_called_once()
def SetupConnection(self, addr, endpoint=None):
if len(self.Peers
) + self.peers_connecting < settings.CONNECTED_PEER_MAX:
try:
host, port = addr.split(':')
if endpoint:
point = endpoint
else:
point = TCP4ClientEndpoint(self.reactor,
host,
int(port),
timeout=5)
self.peers_connecting += 1
d = connectProtocol(point, NeoNode()) # type: Deferred
d.addErrback(self.clientConnectionFailed, addr)
return d
except Exception as e:
logger.error(f"Setup connection with with {e}")
def test_data_received(self, mock):
node = NeoNode()
node.endpoint = Endpoint('hello.com', 1234)
node.host = node.endpoint.host
node.port = node.endpoint.port
payload = VersionPayload(10234, 1234, 'version')
message = Message('version', payload=payload)
stream = StreamManager.GetStream()
writer = BinaryWriter(stream)
message.Serialize(writer)
out = stream.getvalue()
node.dataReceived(out)
mock.assert_called_once()
self.assertEqual(node.Version.Nonce, payload.Nonce)
def test_handle_message(self, mock):
node = NeoNode()
node.endpoint = Endpoint('hello.com', 1234)
node.host = node.endpoint.host
node.port = node.endpoint.port
payload = VersionPayload(10234, 1234, 'version')
message = Message('version', payload=payload)
stream = StreamManager.GetStream()
writer = BinaryWriter(stream)
message.Serialize(writer)
out = stream.getvalue()
print("OUT %s " % out)
out1 = out[0:10]
out2 = out[10:20]
out3 = out[20:]
node.dataReceived(out1)
node.dataReceived(out2)
self.assertEqual(node.buffer_in, out1 + out2)
# import pdb
# pdb.set_trace()
self.assertEqual(node.bytes_in, 20)
mock.assert_not_called()
node.dataReceived(out3)
self.assertEqual(node.bytes_in, len(out))
# mock.assert_called_with(message)
mock.assert_called_once()
def test_data_received(self, mock):
node = NeoNode()
node.endpoint = Endpoint('hello.com', 1234)
node.host = node.endpoint.host
node.port = node.endpoint.port
payload = VersionPayload(10234, 1234, 'version')
message = Message('version', payload=payload)
stream = StreamManager.GetStream()
writer = BinaryWriter(stream)
message.Serialize(writer)
out = stream.getvalue()
node.dataReceived(out)
mock.assert_called_once()
self.assertEqual(node.Version.Nonce, payload.Nonce)
def buildProtocol(self, addr):
return NeoNode(self)
def mock_connect_tcp(host, port, factory, timeout=120):
node = NeoNode()
node.endpoint = Endpoint(host, port)
leader.AddConnectedPeer(node)
return node
def test_peer_adding(self):
leader = NodeLeader.Instance()
Blockchain.Default()._block_cache = {'hello': 1}
def mock_call_later(delay, method, *args):
method(*args)
def mock_connect_tcp(host, port, factory, timeout=120):
node = NeoNode()
node.endpoint = Endpoint(host, port)
leader.AddConnectedPeer(node)
return node
def mock_disconnect(peer):
return True
def mock_send_msg(node, message):
return True
settings.set_max_peers(len(settings.SEED_LIST))
with patch('twisted.internet.reactor.connectTCP', mock_connect_tcp):
with patch('twisted.internet.reactor.callLater', mock_call_later):
with patch('neo.Network.NeoNode.NeoNode.Disconnect',
mock_disconnect):
with patch(
'neo.Network.NeoNode.NeoNode.SendSerializedMessage',
mock_send_msg):
leader.Start()
self.assertEqual(len(leader.Peers),
len(settings.SEED_LIST))
# now test adding another
leader.RemoteNodePeerReceived('hello.com', 1234, 6)
# it shouldnt add anything so it doesnt go over max connected peers
self.assertEqual(len(leader.Peers),
len(settings.SEED_LIST))
# test adding peer
peer = NeoNode()
peer.endpoint = Endpoint('hellloo.com', 12344)
leader.ADDRS.append('hellloo.com:12344')
leader.AddConnectedPeer(peer)
self.assertEqual(len(leader.Peers),
len(settings.SEED_LIST))
# now get a peer
peer = leader.Peers[0]
leader.RemoveConnectedPeer(peer)
self.assertEqual(len(leader.Peers),
len(settings.SEED_LIST) - 1)
self.assertEqual(len(leader.ADDRS),
len(settings.SEED_LIST))
# now test adding another
leader.RemoteNodePeerReceived('hello.com', 1234, 6)
self.assertEqual(len(leader.Peers),
len(settings.SEED_LIST))
# now if we remove all peers, it should restart
peers = leader.Peers[:]
for peer in peers:
leader.RemoveConnectedPeer(peer)
# test reset
leader.ResetBlockRequestsAndCache()
self.assertEqual(Blockchain.Default()._block_cache, {})
def buildProtocol(self, addr):
return NeoNode(self.incoming)
def SetupConnection(self, host, port):
self.__log.debug("Setting up connection! %s %s " % (host, port))
point = TCP4ClientEndpoint(reactor, host, int(port))
d = connectProtocol(point, NeoNode(NeoFactory))
d.addCallbacks(self.onProtocolConnected, errback=self.onProtocolError)
reactor.callLater(5, d.cancel)
def test_peer_adding(self):
leader = NodeLeader.Instance()
Blockchain.Default()._block_cache = {'hello': 1}
def mock_call_later(delay, method, *args):
method(*args)
def mock_connect_tcp(host, port, factory):
node = NeoNode()
node.endpoint = Endpoint(host, port)
leader.AddConnectedPeer(node)
return node
def mock_disconnect(peer):
return True
def mock_send_msg(node, message):
return True
settings.set_max_peers(len(settings.SEED_LIST))
with patch('twisted.internet.reactor.connectTCP', mock_connect_tcp):
with patch('twisted.internet.reactor.callLater', mock_call_later):
with patch('neo.Network.NeoNode.NeoNode.Disconnect', mock_disconnect):
with patch('neo.Network.NeoNode.NeoNode.SendSerializedMessage', mock_send_msg):
leader.Start()
self.assertEqual(len(leader.Peers), len(settings.SEED_LIST))
# now test adding another
leader.RemoteNodePeerReceived('hello.com', 1234, 6)
# it shouldnt add anything so it doesnt go over max connected peers
self.assertEqual(len(leader.Peers), len(settings.SEED_LIST))
# test adding peer
peer = NeoNode()
peer.endpoint = Endpoint('hellloo.com', 12344)
leader.ADDRS.append('hellloo.com:12344')
leader.AddConnectedPeer(peer)
self.assertEqual(len(leader.Peers), len(settings.SEED_LIST))
# now get a peer
peer = leader.Peers[0]
leader.RemoveConnectedPeer(peer)
self.assertEqual(len(leader.Peers), len(settings.SEED_LIST) - 1)
self.assertEqual(len(leader.ADDRS), len(settings.SEED_LIST) - 1)
# now test adding another
leader.RemoteNodePeerReceived('hello.com', 1234, 6)
self.assertEqual(len(leader.Peers), len(settings.SEED_LIST))
# now on updated max peers test
leader.OnUpdatedMaxPeers(settings.CONNECTED_PEER_MAX, settings.CONNECTED_PEER_MAX - 1)
leader.OnUpdatedMaxPeers(settings.CONNECTED_PEER_MAX - 1, 10)
# now if we remove all peers, it should restart
peers = leader.Peers[:]
for peer in peers:
leader.RemoveConnectedPeer(peer)
# and peers should be equal to the seed list
self.assertEqual(len(leader.Peers), len(settings.SEED_LIST))
# test reset
leader.ResetBlockRequestsAndCache()
self.assertEqual(Blockchain.Default()._block_cache, {})
def mock_connect_tcp(host, port, factory):
node = NeoNode()
node.endpoint = Endpoint(host, port)
leader.AddConnectedPeer(node)
return node
def do_handshake(self, node: NeoNode):
self.node = node
raw_version = b"\xb1\xdd\x00\x00version\x00\x00\x00\x00\x00'\x00\x00\x00a\xbb\x9av\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x0ef\x9e[mO3\xe7q\x08\x0b/NEO:2.7.4/=\x8b\x00\x00\x01"
raw_verack = b'\xb1\xdd\x00\x00verack\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00]\xf6\xe0\xe2'
node.dataReceived(raw_version + raw_verack)
return node
def conn_setup(node: NeoNode):
# at this point we should have a fully connected node, so lets try disconnecting from it
d1 = node.Disconnect()
d1.addCallback(should_not_happen)
d1.addErrback(conn_lost, error.ConnectionDone)
return d1
