fix(net): add outbound buffer limits and write timeouts

src/main/java/org/tron/p2p/connection/Channel.java

@@ -10,6 +10,7 @@
 import io.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;
 import io.netty.handler.timeout.ReadTimeoutException;
 import io.netty.handler.timeout.ReadTimeoutHandler;
+import io.netty.handler.timeout.WriteTimeoutException;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
@@ -83,6 +84,7 @@ public class Channel {
   @Getter
   private long avgLatency;
   private long count;
+  private final WriteBufferHandler writeBufferHandler = new WriteBufferHandler(this);
 
   /** @deprecated Use {@link #isOutbound()} to query connection direction. */
   @Deprecated
@@ -118,6 +120,7 @@ public void init(ChannelPipeline pipeline, String nodeId, boolean nodeDetectMode
     pipeline.addLast(TrafficStats.tcp);
     pipeline.addLast("protoPrepend", new ProtobufVarint32LengthFieldPrepender());
     pipeline.addLast("protoDecode", new P2pProtobufVarint32FrameDecoder(this));
+    pipeline.addLast("writeTimeoutHandler", writeBufferHandler);
     pipeline.addLast("messageHandler", messageHandler);
   }
 
@@ -131,6 +134,7 @@ public void processException(Throwable throwable) {
     }
     SocketAddress address = ctx.channel().remoteAddress();
     if (throwable instanceof ReadTimeoutException
+        || throwable instanceof WriteTimeoutException
         || throwable instanceof IOException
         || throwable instanceof CorruptedFrameException) {
       log.warn("Close peer {}, reason: {}", address, throwable.getMessage());
@@ -217,7 +221,7 @@ public void send(byte[] data) {
       }
 
       ByteBuf byteBuf = Unpooled.wrappedBuffer(data);
-      ctx.writeAndFlush(byteBuf).addListener((ChannelFutureListener) future -> {
+      writeBufferHandler.writeAndFlush(ctx, byteBuf).addListener((ChannelFutureListener) future -> {
         if (!future.isSuccess() && !isDisconnect) {
           log.warn("Send to {} failed, message-type:{}, cause:{}",
               ctx.channel().remoteAddress(), ByteArray.byte2int(type),

src/main/java/org/tron/p2p/connection/WriteBufferHandler.java

@@ -0,0 +1,139 @@
+package org.tron.p2p.connection;
+
+import com.google.protobuf.CodedOutputStream;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.handler.timeout.WriteTimeoutHandler;
+import java.nio.channels.ClosedChannelException;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import lombok.extern.slf4j.Slf4j;
+
+/** Bounds pending TCP writes and closes connections whose writes stall. */
+@Slf4j(topic = "net")
+final class WriteBufferHandler extends WriteTimeoutHandler {
+
+  private static final Budget GLOBAL_BUDGET = new Budget(200L * 1024 * 1024, 500L * 1024 * 1024);
+
+  private final Channel channel;
+  private final Budget budget;
+  // Guarded by budget, including sends originating outside the channel's event loop.
+  private long pendingBytes;
+  private boolean closing;
+
+  WriteBufferHandler(Channel channel) {
+    this(channel, GLOBAL_BUDGET);
+  }
+
+  WriteBufferHandler(Channel channel, Budget budget) {
+    super(10);
+    this.channel = channel;
+    this.budget = budget;
+  }
+
+  ChannelFuture writeAndFlush(ChannelHandlerContext ctx, ByteBuf data) {
+    // Reserve before Netty can enqueue a write task on the event loop. Include the frame prefix
+    // that protoPrepend adds later, after the payload has already been compressed by Channel.send.
+    long size = (long) data.readableBytes()
+        + CodedOutputStream.computeUInt32SizeNoTag(data.readableBytes());
+    ChannelPromise promise = ctx.newPromise();
+    promise.setUncancellable();
+    if (!budget.reserve(this, size)) {
+      data.release();
+      return promise.setFailure(new ClosedChannelException());
+    }
+    promise.addListener(future -> budget.release(this, size));
+    if (channel.isDisconnect()) {
+      data.release();
+      return promise.setFailure(new ClosedChannelException());
+    }
+    return ctx.writeAndFlush(data, promise);
+  }
+
+  private void disconnect() {
+    log.warn("Close peer {}, pending outbound data limit exceeded",
+        channel.getInetSocketAddress());
+    channel.close();
+  }
+
+  /** Shared by TCP connections; the global limit triggers eviction rather than blocking I/O. */
+  static final class Budget {
+
+    private final long peerLimit;
+    private final long globalLimit;
+    private final Set<WriteBufferHandler> peers = new LinkedHashSet<>();
+    private long pendingBytes;
+    private WriteBufferHandler evicting;
+
+    Budget(long peerLimit, long globalLimit) {
+      this.peerLimit = peerLimit;
+      this.globalLimit = globalLimit;
+    }
+
+    private boolean reserve(WriteBufferHandler handler, long size) {
+      WriteBufferHandler victim;
+      synchronized (this) {
+        if (handler.closing || handler.channel.isDisconnect()) {
+          return false;
+        }
+        handler.pendingBytes += size;
+        pendingBytes += size;
+        peers.add(handler);
+        if (handler.pendingBytes > peerLimit) {
+          handler.closing = true;
+          victim = handler;
+          if (evicting == null) {
+            evicting = handler;
+          }
+        } else {
+          victim = selectVictim();
+        }
+      }
+      // Closing may immediately complete writes and re-enter release(). Never close under the lock.
+      if (victim != null) {
+        victim.disconnect();
+      }
+      return true;
+    }
+
+    private void release(WriteBufferHandler handler, long size) {
+      WriteBufferHandler victim;
+      synchronized (this) {
+        handler.pendingBytes -= size;
+        pendingBytes -= size;
+        if (handler.pendingBytes == 0) {
+          peers.remove(handler);
+          if (evicting == handler) {
+            evicting = null;
+          }
+        }
+        victim = selectVictim();
+      }
+      if (victim != null) {
+        victim.disconnect();
+      }
+    }
+
+    // Called with the budget lock held. Wait for the current victim's writes to be released
+    // before selecting another, even if multiple producers observe the global limit concurrently.
+    private WriteBufferHandler selectVictim() {
+      if (evicting != null || pendingBytes < globalLimit) {
+        return null;
+      }
+      WriteBufferHandler largest = null;
+      for (WriteBufferHandler candidate : peers) {
+        if (!candidate.closing && !candidate.channel.isDisconnect()
+            && (largest == null || candidate.pendingBytes > largest.pendingBytes)) {
+          largest = candidate;
+        }
+      }
+      if (largest != null) {
+        largest.closing = true;
+        evicting = largest;
+      }
+      return largest;
+    }
+  }
+}

src/test/java/org/tron/p2p/connection/ChannelWriteTimeoutTest.java

@@ -0,0 +1,51 @@
+package org.tron.p2p.connection;
+
+import io.netty.channel.ChannelOutboundBuffer;
+import io.netty.channel.embedded.EmbeddedChannel;
+import java.lang.reflect.Field;
+import java.net.InetSocketAddress;
+import java.util.concurrent.TimeUnit;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tron.p2p.connection.message.keepalive.PingMessage;
+
+public class ChannelWriteTimeoutTest {
+
+  @Test
+  public void stalledWriteClosesConnectionAfterTenSeconds() throws Exception {
+    EmbeddedChannel netty = new EmbeddedChannel() {
+      @Override
+      protected void doWrite(ChannelOutboundBuffer buffer) {
+        // A socket whose remote peer does not read: leave writes pending in Netty.
+      }
+    };
+    netty.freezeTime();
+    Channel channel = new Channel();
+    channel.init(netty.pipeline(), "", false);
+    InetSocketAddress address = new InetSocketAddress("127.0.0.1", 18888);
+    set(channel, "ctx", netty.pipeline().lastContext());
+    set(channel, "inetSocketAddress", address);
+    set(channel, "inetAddress", address.getAddress());
+    try {
+      channel.send(new PingMessage());
+      netty.advanceTimeBy(9, TimeUnit.SECONDS);
+      netty.runScheduledPendingTasks();
+      Assert.assertTrue(netty.isOpen());
+
+      netty.advanceTimeBy(1, TimeUnit.SECONDS);
+      netty.runScheduledPendingTasks();
+      Assert.assertFalse("a pending write must time out even without a business queue",
+          netty.isOpen());
+      Assert.assertTrue(channel.isDisconnect());
+    } finally {
+      netty.finishAndReleaseAll();
+      ChannelManager.getBannedNodes().invalidate(address.getAddress());
+    }
+  }
+
+  private static void set(Channel channel, String name, Object value) throws Exception {
+    Field field = Channel.class.getDeclaredField(name);
+    field.setAccessible(true);
+    field.set(channel, value);
+  }
+}