From 5ab5a1b59dadc7b49dd5c9d8da868af1a3f7c7c2 Mon Sep 17 00:00:00 2001
From: Ko Chanhyuck <lime_bell@naver.com>
Date: Mon, 7 Sep 2020 15:36:34 +0900
Subject: [PATCH 1/2] Fixed a bug where depth not worked  [skip changelog]

---
 Libplanet/Net/Protocols/KademliaProtocol.cs | 22 ++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/Libplanet/Net/Protocols/KademliaProtocol.cs b/Libplanet/Net/Protocols/KademliaProtocol.cs
index ab1ba79d1f..75aa40403d 100644
--- a/Libplanet/Net/Protocols/KademliaProtocol.cs
+++ b/Libplanet/Net/Protocols/KademliaProtocol.cs
@@ -341,17 +341,24 @@ public async Task<BoundPeer> FindSpecificPeerAsync(
             }
 
             var history = new ConcurrentBag<BoundPeer>();
-            var peersToFind = new ConcurrentQueue<BoundPeer>();
+            var peersToFind = new ConcurrentQueue<Tuple<BoundPeer, int>>();
             foreach (BoundPeer peer in _routing.Neighbors(target, _findConcurrency, false))
             {
-                peersToFind.Enqueue(peer);
+                peersToFind.Enqueue(new Tuple<BoundPeer, int>(peer, 0));
             }
 
             while (peersToFind.Any())
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
-                if (!peersToFind.TryDequeue(out BoundPeer viaPeer))
+                if (!peersToFind.TryDequeue(out Tuple<BoundPeer, int> tuple))
+                {
+                    continue;
+                }
+
+                tuple.Deconstruct(out BoundPeer viaPeer, out int curDepth);
+                _logger.Debug("ViaPeer: {Peer}, curDepth: {curDepth}", viaPeer, curDepth);
+                if (depth != -1 && curDepth >= depth)
                 {
                     continue;
                 }
@@ -362,7 +369,7 @@ public async Task<BoundPeer> FindSpecificPeerAsync(
                 IEnumerable<BoundPeer> filteredPeers = foundPeers
                     .Where(peer =>
                         !history.Contains(peer) &&
-                        !peersToFind.Contains(peer) &&
+                        !peersToFind.Any(t => t.Item1.Equals(peer)) &&
                         !peer.Address.Equals(_address))
                     .Take(_findConcurrency);
                 int count = 0;
@@ -376,7 +383,7 @@ public async Task<BoundPeer> FindSpecificPeerAsync(
                             return found;
                         }
 
-                        peersToFind.Enqueue(found);
+                        peersToFind.Enqueue(new Tuple<BoundPeer, int>(found, curDepth + 1));
 
                         if (count++ >= _findConcurrency)
                         {
@@ -445,6 +452,11 @@ internal async Task PingAsync(
             }
         }
 
+        internal void ClearTable()
+        {
+            _routing.Clear();
+        }
+
         /// <summary>
         /// Validate peer by send <see cref="Ping"/> to <paramref name="peer"/>. If target peer
         /// does not responds, remove it from the table.

From 6b2e7dd4da4de5bb7369755dd0593b5c01fd1cc1 Mon Sep 17 00:00:00 2001
From: Ko Chanhyuck <lime_bell@naver.com>
Date: Mon, 7 Sep 2020 15:36:50 +0900
Subject: [PATCH 2/2] Add regression test for depth  [skip changelog]

---
 Libplanet.Tests/Net/SwarmTest.cs | 44 ++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/Libplanet.Tests/Net/SwarmTest.cs b/Libplanet.Tests/Net/SwarmTest.cs
index b4171eb0de..59e98f9296 100644
--- a/Libplanet.Tests/Net/SwarmTest.cs
+++ b/Libplanet.Tests/Net/SwarmTest.cs
@@ -2025,6 +2025,50 @@ public async Task FindSpecificPeerAsyncFail()
             }
         }
 
+        [Fact(Timeout = Timeout)]
+        public async Task FindSpecificPeerAsyncDepthFail()
+        {
+            Swarm<DumbAction> swarmA = _swarms[0];
+            Swarm<DumbAction> swarmB = _swarms[1];
+            Swarm<DumbAction> swarmC = _swarms[2];
+            Swarm<DumbAction> swarmD = _swarms[3];
+            try
+            {
+                await StartAsync(swarmA);
+                await StartAsync(swarmB);
+                await StartAsync(swarmC);
+                await StartAsync(swarmD);
+
+                await swarmA.AddPeersAsync(new Peer[] { swarmB.AsPeer }, null);
+                await swarmB.AddPeersAsync(new Peer[] { swarmC.AsPeer }, null);
+                await swarmC.AddPeersAsync(new Peer[] { swarmD.AsPeer }, null);
+
+                BoundPeer foundPeer = await swarmA.FindSpecificPeerAsync(
+                    swarmC.AsPeer.Address,
+                    1,
+                    TimeSpan.FromMilliseconds(3000));
+
+                Assert.Equal(swarmC.AsPeer.Address, foundPeer.Address);
+                ((KademliaProtocol)swarmA.Protocol).ClearTable();
+                Assert.Empty(swarmA.Peers);
+                await swarmA.AddPeersAsync(new Peer[] { swarmB.AsPeer }, null);
+
+                foundPeer = await swarmA.FindSpecificPeerAsync(
+                    swarmD.AsPeer.Address,
+                    1,
+                    TimeSpan.FromMilliseconds(3000));
+
+                Assert.Null(foundPeer);
+            }
+            finally
+            {
+                await StopAsync(swarmA);
+                await StopAsync(swarmB);
+                await StopAsync(swarmC);
+                await StopAsync(swarmD);
+            }
+        }
+
         [Fact(Timeout = Timeout)]
         public async Task DoNotFillMultipleTimes()
         {