Skip to content

Commit 2e9fa7f

Browse files
sean-liu55sean-liu55
committed
Merge remote-tracking branch 'origin/feature/debug_net_limit' into feature/debug_net_limit
2 parents 660d44a + c9a1e16 commit 2e9fa7f

39 files changed

+747
-703
lines changed

‎src/main/java/org/tron/common/overlay/discover/DiscoverListener.java‎

Lines changed: 16 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -24,19 +24,23 @@
2424
*/
2525
public interface DiscoverListener {
2626

27-
/**
28-
* Invoked whenever a new node appeared which meets criteria specified
29-
* in the {@link NodeManager#addDiscoverListener} method
30-
*/
31-
void nodeAppeared(NodeHandler handler);
27+
/**
28+
* Invoked whenever a new node appeared which meets criteria specified in the {@link
29+
* NodeManager#addDiscoverListener} method
30+
*/
31+
void nodeAppeared(NodeHandler handler);
3232

33-
/**
34-
* Invoked whenever a node stops meeting criteria.
35-
*/
36-
void nodeDisappeared(NodeHandler handler);
33+
/**
34+
* Invoked whenever a node stops meeting criteria.
35+
*/
36+
void nodeDisappeared(NodeHandler handler);
3737

38-
class Adapter implements DiscoverListener {
39-
public void nodeAppeared(NodeHandler handler) {}
40-
public void nodeDisappeared(NodeHandler handler) {}
38+
class Adapter implements DiscoverListener {
39+
40+
public void nodeAppeared(NodeHandler handler) {
41+
}
42+
43+
public void nodeDisappeared(NodeHandler handler) {
4144
}
45+
}
4246
}

‎src/main/java/org/tron/common/overlay/discover/DiscoverTask.java‎

Lines changed: 61 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -17,78 +17,84 @@
1717
*/
1818
package org.tron.common.overlay.discover;
1919

20+
import java.util.ArrayList;
21+
import java.util.List;
2022
import org.slf4j.Logger;
2123
import org.slf4j.LoggerFactory;
2224
import org.tron.common.overlay.discover.table.KademliaOptions;
2325
import org.tron.common.overlay.discover.table.NodeEntry;
2426

25-
import java.util.ArrayList;
26-
import java.util.List;
27-
2827
public class DiscoverTask implements Runnable {
29-
private static final Logger logger = LoggerFactory.getLogger("DiscoverTask");
3028

31-
NodeManager nodeManager;
29+
private static final Logger logger = LoggerFactory.getLogger("DiscoverTask");
3230

33-
byte[] nodeId;
31+
NodeManager nodeManager;
3432

35-
public DiscoverTask(NodeManager nodeManager) {
36-
this.nodeManager = nodeManager;
37-
nodeId = nodeManager.homeNode.getId();
38-
}
33+
byte[] nodeId;
3934

40-
@Override
41-
public void run() {
42-
discover(nodeId, 0, new ArrayList<Node>());
43-
}
35+
public DiscoverTask(NodeManager nodeManager) {
36+
this.nodeManager = nodeManager;
37+
nodeId = nodeManager.homeNode.getId();
38+
}
39+
40+
@Override
41+
public void run() {
42+
discover(nodeId, 0, new ArrayList<Node>());
43+
}
4444

45-
public synchronized void discover(byte[] nodeId, int round, List<Node> prevTried) {
45+
public synchronized void discover(byte[] nodeId, int round, List<Node> prevTried) {
4646

47-
try {
48-
if (round == KademliaOptions.MAX_STEPS) {
49-
logger.debug("Node table contains [{}] peers", nodeManager.getTable().getNodesCount());
50-
logger.debug("{}", String.format("(KademliaOptions.MAX_STEPS) Terminating discover after %d rounds.", round));
51-
logger.trace("{}\n{}", String.format("Nodes discovered %d ", nodeManager.getTable().getNodesCount()), dumpNodes());
52-
return;
53-
}
47+
try {
48+
if (round == KademliaOptions.MAX_STEPS) {
49+
logger.debug("Node table contains [{}] peers", nodeManager.getTable().getNodesCount());
50+
logger.debug("{}", String
51+
.format("(KademliaOptions.MAX_STEPS) Terminating discover after %d rounds.", round));
52+
logger.trace("{}\n{}",
53+
String.format("Nodes discovered %d ", nodeManager.getTable().getNodesCount()),
54+
dumpNodes());
55+
return;
56+
}
5457

55-
List<Node> closest = nodeManager.getTable().getClosestNodes(nodeId);
56-
List<Node> tried = new ArrayList<>();
57-
for (Node n : closest) {
58-
if (!tried.contains(n) && !prevTried.contains(n)) {
59-
try {
60-
nodeManager.getNodeHandler(n).sendFindNode(nodeId);
61-
tried.add(n);
62-
Thread.sleep(50);
63-
}catch (InterruptedException e) {
64-
} catch (Exception ex) {
65-
logger.error("Unexpected Exception " + ex, ex);
66-
}
67-
}
68-
if (tried.size() == KademliaOptions.ALPHA) {
69-
break;
70-
}
71-
}
58+
List<Node> closest = nodeManager.getTable().getClosestNodes(nodeId);
59+
List<Node> tried = new ArrayList<>();
60+
for (Node n : closest) {
61+
if (!tried.contains(n) && !prevTried.contains(n)) {
62+
try {
63+
nodeManager.getNodeHandler(n).sendFindNode(nodeId);
64+
tried.add(n);
65+
Thread.sleep(50);
66+
} catch (InterruptedException e) {
67+
} catch (Exception ex) {
68+
logger.error("Unexpected Exception " + ex, ex);
69+
}
70+
}
71+
if (tried.size() == KademliaOptions.ALPHA) {
72+
break;
73+
}
74+
}
7275

73-
if (tried.isEmpty()) {
74-
logger.debug("{}", String.format("(tried.isEmpty()) Terminating discover after %d rounds.", round));
75-
logger.trace("{}\n{}", String.format("Nodes discovered %d ", nodeManager.getTable().getNodesCount()), dumpNodes());
76-
return;
77-
}
76+
if (tried.isEmpty()) {
77+
logger.debug("{}",
78+
String.format("(tried.isEmpty()) Terminating discover after %d rounds.", round));
79+
logger.trace("{}\n{}",
80+
String.format("Nodes discovered %d ", nodeManager.getTable().getNodesCount()),
81+
dumpNodes());
82+
return;
83+
}
7884

79-
tried.addAll(prevTried);
85+
tried.addAll(prevTried);
8086

81-
discover(nodeId, round + 1, tried);
82-
} catch (Exception ex) {
83-
logger.error("{}", ex);
84-
}
87+
discover(nodeId, round + 1, tried);
88+
} catch (Exception ex) {
89+
logger.error("{}", ex);
8590
}
91+
}
8692

87-
private String dumpNodes() {
88-
String ret = "";
89-
for (NodeEntry entry : nodeManager.getTable().getAllNodes()) {
90-
ret += " " + entry.getNode() + "\n";
91-
}
92-
return ret;
93+
private String dumpNodes() {
94+
String ret = "";
95+
for (NodeEntry entry : nodeManager.getTable().getAllNodes()) {
96+
ret += " " + entry.getNode() + "\n";
9397
}
98+
return ret;
99+
}
94100
}

‎src/main/java/org/tron/common/overlay/discover/DiscoveryEvent.java‎

Lines changed: 19 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -17,33 +17,32 @@
1717
*/
1818
package org.tron.common.overlay.discover;
1919

20-
import org.tron.common.overlay.discover.message.Message;
21-
2220
import java.net.InetSocketAddress;
21+
import org.tron.common.overlay.discover.message.Message;
2322

2423
public class DiscoveryEvent {
2524

26-
private Message message;
27-
private InetSocketAddress address;
25+
private Message message;
26+
private InetSocketAddress address;
2827

29-
public DiscoveryEvent(Message m, InetSocketAddress a) {
30-
message = m;
31-
address = a;
32-
}
28+
public DiscoveryEvent(Message m, InetSocketAddress a) {
29+
message = m;
30+
address = a;
31+
}
3332

34-
public Message getMessage() {
35-
return message;
36-
}
33+
public Message getMessage() {
34+
return message;
35+
}
3736

38-
public void setMessage(Message message) {
39-
this.message = message;
40-
}
37+
public void setMessage(Message message) {
38+
this.message = message;
39+
}
4140

42-
public InetSocketAddress getAddress() {
43-
return address;
44-
}
41+
public InetSocketAddress getAddress() {
42+
return address;
43+
}
4544

46-
public void setAddress(InetSocketAddress address) {
47-
this.address = address;
48-
}
45+
public void setAddress(InetSocketAddress address) {
46+
this.address = address;
47+
}
4948
}

‎src/main/java/org/tron/common/overlay/discover/DiscoveryExecutor.java‎

Lines changed: 19 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -17,35 +17,34 @@
1717
*/
1818
package org.tron.common.overlay.discover;
1919

20-
import org.tron.common.overlay.discover.table.KademliaOptions;
21-
2220
import java.util.concurrent.Executors;
2321
import java.util.concurrent.ScheduledExecutorService;
2422
import java.util.concurrent.TimeUnit;
23+
import org.tron.common.overlay.discover.table.KademliaOptions;
2524

2625
public class DiscoveryExecutor {
2726

28-
ScheduledExecutorService discoverer = Executors.newSingleThreadScheduledExecutor();
29-
ScheduledExecutorService refresher = Executors.newSingleThreadScheduledExecutor();
27+
ScheduledExecutorService discoverer = Executors.newSingleThreadScheduledExecutor();
28+
ScheduledExecutorService refresher = Executors.newSingleThreadScheduledExecutor();
3029

31-
NodeManager nodeManager;
30+
NodeManager nodeManager;
3231

33-
public DiscoveryExecutor(NodeManager nodeManager) {
34-
this.nodeManager = nodeManager;
35-
}
32+
public DiscoveryExecutor(NodeManager nodeManager) {
33+
this.nodeManager = nodeManager;
34+
}
3635

37-
public void start() {
38-
discoverer.scheduleWithFixedDelay(
39-
new DiscoverTask(nodeManager),
40-
1, KademliaOptions.DISCOVER_CYCLE, TimeUnit.SECONDS);
36+
public void start() {
37+
discoverer.scheduleWithFixedDelay(
38+
new DiscoverTask(nodeManager),
39+
1, KademliaOptions.DISCOVER_CYCLE, TimeUnit.SECONDS);
4140

42-
refresher.scheduleWithFixedDelay(
43-
new RefreshTask(nodeManager),
44-
1, KademliaOptions.BUCKET_REFRESH, TimeUnit.MILLISECONDS);
45-
}
41+
refresher.scheduleWithFixedDelay(
42+
new RefreshTask(nodeManager),
43+
1, KademliaOptions.BUCKET_REFRESH, TimeUnit.MILLISECONDS);
44+
}
4645

47-
public void close() {
48-
discoverer.shutdownNow();
49-
refresher.shutdownNow();
50-
}
46+
public void close() {
47+
discoverer.shutdownNow();
48+
refresher.shutdownNow();
49+
}
5150
}

‎src/main/java/org/tron/common/overlay/discover/MessageHandler.java‎

Lines changed: 46 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -23,63 +23,64 @@
2323
import io.netty.channel.SimpleChannelInboundHandler;
2424
import io.netty.channel.socket.DatagramPacket;
2525
import io.netty.channel.socket.nio.NioDatagramChannel;
26-
import org.slf4j.LoggerFactory;
27-
2826
import java.net.InetSocketAddress;
2927
import java.util.function.Consumer;
28+
import org.slf4j.LoggerFactory;
3029

3130

3231
public class MessageHandler extends SimpleChannelInboundHandler<DiscoveryEvent>
33-
implements Consumer<DiscoveryEvent> {
34-
static final org.slf4j.Logger logger = LoggerFactory.getLogger("MessageHandler");
32+
implements Consumer<DiscoveryEvent> {
33+
34+
static final org.slf4j.Logger logger = LoggerFactory.getLogger("MessageHandler");
3535

36-
public Channel channel;
36+
public Channel channel;
3737

38-
NodeManager nodeManager;
38+
NodeManager nodeManager;
3939

40-
public MessageHandler(NioDatagramChannel ch, NodeManager nodeManager) {
41-
channel = ch;
42-
this.nodeManager = nodeManager;
43-
}
40+
public MessageHandler(NioDatagramChannel ch, NodeManager nodeManager) {
41+
channel = ch;
42+
this.nodeManager = nodeManager;
43+
}
4444

45-
@Override
46-
public void channelActive(ChannelHandlerContext ctx) throws Exception {
47-
nodeManager.channelActivated();
48-
}
45+
@Override
46+
public void channelActive(ChannelHandlerContext ctx) throws Exception {
47+
nodeManager.channelActivated();
48+
}
4949

50-
@Override
51-
public void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent discoveryEvent) throws Exception {
52-
logger.debug("rcv udp msg type {}, len {} from {} ",
53-
discoveryEvent.getMessage().getType(),
54-
discoveryEvent.getMessage().getSendData().length,
55-
discoveryEvent.getAddress());
56-
nodeManager.handleInbound(discoveryEvent);
57-
}
50+
@Override
51+
public void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent discoveryEvent)
52+
throws Exception {
53+
logger.debug("rcv udp msg type {}, len {} from {} ",
54+
discoveryEvent.getMessage().getType(),
55+
discoveryEvent.getMessage().getSendData().length,
56+
discoveryEvent.getAddress());
57+
nodeManager.handleInbound(discoveryEvent);
58+
}
5859

59-
@Override
60-
public void accept(DiscoveryEvent discoveryEvent) {
61-
logger.debug("send udp msg type {}, len {} to {} ",
62-
discoveryEvent.getMessage().getType(),
63-
discoveryEvent.getMessage().getSendData().length,
64-
discoveryEvent.getAddress());
65-
InetSocketAddress address = discoveryEvent.getAddress();
66-
sendPacket(discoveryEvent.getMessage().getSendData(), address);
67-
}
60+
@Override
61+
public void accept(DiscoveryEvent discoveryEvent) {
62+
logger.debug("send udp msg type {}, len {} to {} ",
63+
discoveryEvent.getMessage().getType(),
64+
discoveryEvent.getMessage().getSendData().length,
65+
discoveryEvent.getAddress());
66+
InetSocketAddress address = discoveryEvent.getAddress();
67+
sendPacket(discoveryEvent.getMessage().getSendData(), address);
68+
}
6869

69-
void sendPacket(byte[] wire, InetSocketAddress address) {
70-
DatagramPacket packet = new DatagramPacket(Unpooled.copiedBuffer(wire), address);
71-
channel.write(packet);
72-
channel.flush();
73-
}
70+
void sendPacket(byte[] wire, InetSocketAddress address) {
71+
DatagramPacket packet = new DatagramPacket(Unpooled.copiedBuffer(wire), address);
72+
channel.write(packet);
73+
channel.flush();
74+
}
7475

75-
@Override
76-
public void channelReadComplete(ChannelHandlerContext ctx) {
77-
ctx.flush();
78-
}
76+
@Override
77+
public void channelReadComplete(ChannelHandlerContext ctx) {
78+
ctx.flush();
79+
}
7980

80-
@Override
81-
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
82-
logger.info("exception caught, {} {}", ctx.channel().remoteAddress(), cause.getMessage());
83-
ctx.close();
84-
}
81+
@Override
82+
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
83+
logger.info("exception caught, {} {}", ctx.channel().remoteAddress(), cause.getMessage());
84+
ctx.close();
85+
}
8586
}

0 commit comments

Comments
 (0)