fixup: cachePath and use client everywhere

nblockchain · Oct 28, 2023 · cdc3da0 · cdc3da0
1 parent 31b2e78
commit cdc3da0
Show file tree

Hide file tree

Showing 7 changed files with 177 additions and 184 deletions.
diff --git a/NOnion.Tests/HiddenServicesTests.cs b/NOnion.Tests/HiddenServicesTests.cs
@@ -16,6 +16,7 @@
 using NOnion.Network;
 using NOnion.Http;
 using NOnion.Cells.Relay;
+using NOnion.Client;
 using NOnion.Directory;
 using NOnion.Tests.Utility;
 using NOnion.Services;
@@ -24,6 +25,23 @@ namespace NOnion.Tests
 {
     public class HiddenServicesTests
     {
+        [SetUp]
+        public void Init()
+        {
+            cachePath =
+                new DirectoryInfo(
+                    Path.Combine(
+                        Path.GetTempPath(),
+                        Path.GetFileNameWithoutExtension(
+                            Path.GetRandomFileName()
+                        )
+                    )
+                );
+            cachePath.Create();
+        }
+
+        private DirectoryInfo cachePath = null;
+
         /* It's possible that the router returned by GetRandomFallbackDirectory or
          * GetRandomRoutersForDirectoryBrowsing be inaccessable so we need to continue
          * retrying if an exceptions happened to make sure the issues are not related
@@ -33,11 +51,8 @@ public class HiddenServicesTests
 
         private async Task CreateIntroductionCircuit()
         {
-            var node = (CircuitNodeDetail.Create)(await CircuitHelper.GetRandomRoutersForDirectoryBrowsingWithRetry()).First();
-            using TorGuard guard = await TorGuard.NewClientAsync(node.EndPoint);
-            var circuit = new TorCircuit(guard);
-
-            await circuit.CreateAsync(CircuitNodeDetail.FastCreate);
+            using TorClient torClient = await TorClient.BootstrapWithGithubAsync(cachePath);
+            var circuit = await torClient.CreateCircuitAsync(1, CircuitPurpose.Unknown, FSharpOption<CircuitNodeDetail>.None);
             await circuit.RegisterAsIntroductionPointAsync(FSharpOption<AsymmetricCipherKeyPair>.None, StubCallback, DisconnectionCallback);
         }
 
@@ -61,12 +76,8 @@ private async Task CreateRendezvousCircuit()
             var array = new byte[Constants.RendezvousCookieLength];
             RandomNumberGenerator.Create().GetNonZeroBytes(array);
 
-            var nodes = await CircuitHelper.GetRandomRoutersForDirectoryBrowsingWithRetry(2);
-            using TorGuard guard = await TorGuard.NewClientAsync(((CircuitNodeDetail.Create)nodes[0]).EndPoint);
-            var circuit = new TorCircuit(guard);
-
-            await circuit.CreateAsync(nodes[0]);
-            await circuit.ExtendAsync(nodes[1]);
+            using TorClient torClient = await TorClient.BootstrapWithGithubAsync(cachePath);
+            var circuit = await torClient.CreateCircuitAsync(2, CircuitPurpose.Unknown, FSharpOption<CircuitNodeDetail>.None);
             await circuit.RegisterAsRendezvousPointAsync(array);
         }
 
@@ -92,10 +103,10 @@ private async Task<int> ReadExact(TorStream stream, byte[] buffer, int off, int
 
         public async Task BrowseFacebookOverHS()
         {
-            TorDirectory directory = await TorDirectory.BootstrapAsync(FallbackDirectorySelector.GetRandomFallbackDirectory(), new DirectoryInfo(Path.GetTempPath()));
+            using TorClient torClient = await TorClient.BootstrapWithGithubAsync(cachePath);
 
-            var client = await TorServiceClient.ConnectAsync(directory, "facebookwkhpilnemxj7asaniu7vnjjbiltxjqhye3mhbshg7kx5tfyd.onion");
-            var httpClient = new TorHttpClient(client.GetStream(), "facebookwkhpilnemxj7asaniu7vnjjbiltxjqhye3mhbshg7kx5tfyd.onion");
+            var serviceClient = await TorServiceClient.ConnectAsync(torClient, "facebookwkhpilnemxj7asaniu7vnjjbiltxjqhye3mhbshg7kx5tfyd.onion");
+            var httpClient = new TorHttpClient(serviceClient.GetStream(), "facebookwkhpilnemxj7asaniu7vnjjbiltxjqhye3mhbshg7kx5tfyd.onion");
 
             try
             {
@@ -109,19 +120,18 @@ public async Task BrowseFacebookOverHS()
         }
 
         [Test]
-        [Retry(TestsRetryCount)]
         public void CanBrowseFacebookOverHS()
         {
             Assert.DoesNotThrowAsync(BrowseFacebookOverHS);
         }
 
         public async Task BrowseFacebookOverHSWithTLS()
         {
-            TorDirectory directory = await TorDirectory.BootstrapAsync(FallbackDirectorySelector.GetRandomFallbackDirectory(), new DirectoryInfo(Path.GetTempPath()));
+            using TorClient torClient = await TorClient.BootstrapWithGithubAsync(cachePath);
+
+            var serviceClient = await TorServiceClient.ConnectAsync(torClient, "facebookwkhpilnemxj7asaniu7vnjjbiltxjqhye3mhbshg7kx5tfyd.onion:443");
 
-            var client = await TorServiceClient.ConnectAsync(directory, "facebookwkhpilnemxj7asaniu7vnjjbiltxjqhye3mhbshg7kx5tfyd.onion:443");
-
-            var sslStream = new SslStream(client.GetStream(), true, (sender, cert, chain, sslPolicyErrors) => true);
+            var sslStream = new SslStream(serviceClient.GetStream(), true, (sender, cert, chain, sslPolicyErrors) => true);
             await sslStream.AuthenticateAsClientAsync(string.Empty, null, SslProtocols.Tls12, false);
 
             var httpClientOverSslStream = new TorHttpClient(sslStream, "www.facebookwkhpilnemxj7asaniu7vnjjbiltxjqhye3mhbshg7kx5tfyd.onion");
@@ -139,26 +149,23 @@ public async Task BrowseFacebookOverHSWithTLS()
         }
 
         [Test]
-        [Retry(TestsRetryCount)]
         public void CanBrowseFacebookOverHSWithTLS()
         {
             Assert.DoesNotThrowAsync(BrowseFacebookOverHSWithTLS);
         }
 
         public async Task EstablishAndCommunicateOverHSConnectionOnionStyle()
         {
-            int descriptorUploadRetryLimit = 2;
-
-            TorDirectory directory = await TorDirectory.BootstrapAsync(FallbackDirectorySelector.GetRandomFallbackDirectory(), new DirectoryInfo(Path.GetTempPath()));
-
+            using TorClient torClient = await TorClient.BootstrapWithGithubAsync(cachePath);
+
             TorLogger.Log("Finished bootstraping");
 
             SecureRandom random = new SecureRandom();
             Ed25519KeyPairGenerator kpGen = new Ed25519KeyPairGenerator();
             kpGen.Init(new Ed25519KeyGenerationParameters(random));
             Ed25519PrivateKeyParameters masterPrivateKey = (Ed25519PrivateKeyParameters)kpGen.GenerateKeyPair().Private;
 
-            TorServiceHost host = new TorServiceHost(directory, descriptorUploadRetryLimit, TestsRetryCount, FSharpOption<Ed25519PrivateKeyParameters>.Some(masterPrivateKey));
+            TorServiceHost host = new TorServiceHost(torClient, FSharpOption<Ed25519PrivateKeyParameters>.Some(masterPrivateKey));
             await host.StartAsync();
 
             TorLogger.Log("Finished starting HS host");
@@ -175,8 +182,8 @@ public async Task EstablishAndCommunicateOverHSConnectionOnionStyle()
 
             var clientSide =
                 Task.Run(async () => {
-                    var client = await TorServiceClient.ConnectAsync(directory, host.ExportUrl());
-                    var stream = client.GetStream();
+                    var serviceClient = await TorServiceClient.ConnectAsync(torClient, host.ExportUrl());
+                    var stream = serviceClient.GetStream();
                     var lengthBytes = new byte[sizeof(int)];
                     await ReadExact(stream, lengthBytes, 0, lengthBytes.Length);
                     var length = BitConverter.ToInt32(lengthBytes);
@@ -192,7 +199,6 @@ public async Task EstablishAndCommunicateOverHSConnectionOnionStyle()
         }
 
         [Test]
-        [Retry(TestsRetryCount)]
         public void CanEstablishAndCommunicateOverHSConnectionOnionStyle()
         {
             Assert.DoesNotThrowAsync(EstablishAndCommunicateOverHSConnectionOnionStyle);

diff --git a/NOnion.Tests/TorClientTests.cs b/NOnion.Tests/TorClientTests.cs
@@ -1,23 +1,40 @@
-using System;
-using System.Collections.Generic;
+using Microsoft.FSharp.Core;
 using System.IO;
-using System.Text;
 using System.Threading.Tasks;
 
 using NUnit.Framework;
 
-using NOnion.Directory;
 using NOnion.Client;
 
-using Microsoft.FSharp.Core;
-
 namespace NOnion.Tests
 {
     public class TorClientTests
     {
+        private async Task BootstrapWithGithub()
+        {
+            await TorClient.BootstrapWithGithubAsync(FSharpOption<DirectoryInfo>.None);
+        }
+
+        [Test]
+        public void CanBootstrapWithGithub()
+        {
+            Assert.DoesNotThrowAsync(BootstrapWithGithub);
+        }
+
+        private async Task BootstrapWithEmbeddedList()
+        {
+            await TorClient.BootstrapWithEmbeddedListAsync(FSharpOption<DirectoryInfo>.None);
+        }
+
+        [Test]
+        public void CanBootstrapWithEmbeddedList()
+        {
+            Assert.DoesNotThrowAsync(BootstrapWithEmbeddedList);
+        }
+
         private async Task CreateCircuit()
         {
-            var client = await TorClient.BootstrapWithEmbeddedListAsync();
+            using TorClient client = await TorClient.BootstrapWithEmbeddedListAsync(FSharpOption<DirectoryInfo>.None);
             await client.CreateCircuitAsync(3, CircuitPurpose.Unknown, FSharpOption<Network.CircuitNodeDetail>.None);
         }
 

diff --git a/NOnion.Tests/TorDirectoryTests.cs b/NOnion.Tests/TorDirectoryTests.cs
@@ -67,4 +67,4 @@ public void CanReturnRandomRouter()
             Assert.DoesNotThrowAsync(ReturnRandomRouter);
         }
     }
-}
+}
diff --git a/NOnion/Client/TorClient.fs b/NOnion/Client/TorClient.fs
@@ -41,17 +41,23 @@ type TorClient internal (directory: TorDirectory) =
         )
         |> Seq.toList
 
-    static let BootstrapDirectory(ipEndPointList: List<IPEndPoint>) =
+    static let BootstrapDirectory
+        (cachePath: Option<DirectoryInfo>)
+        (ipEndPointList: List<IPEndPoint>)
+        =
         async {
             let rec tryBootstrap(ipEndPointList: List<IPEndPoint>) =
                 async {
                     match ipEndPointList with
                     | ipEndPoint :: tail ->
                         try
+                            let cacheDirectory =
+                                match cachePath with
+                                | None -> Path.GetTempPath() |> DirectoryInfo
+                                | Some path -> path
+
                             let! directory =
-                                TorDirectory.Bootstrap
-                                    ipEndPoint
-                                    (Path.GetTempPath() |> DirectoryInfo)
+                                TorDirectory.Bootstrap ipEndPoint cacheDirectory
 
                             return directory
                         with
@@ -62,33 +68,40 @@ type TorClient internal (directory: TorDirectory) =
             return! tryBootstrap ipEndPointList
         }
 
-    static let CreateClientFromFallbackString(fallbackListString: string) =
+    static let CreateClientFromFallbackString
+        (fallbackListString: string)
+        (cachePath: Option<DirectoryInfo>)
+        =
         async {
             let! directory =
                 fallbackListString
                 |> ConvertFallbackIncToList
                 |> SelectRandomEndpoints
-                |> BootstrapDirectory
+                |> BootstrapDirectory cachePath
 
             return new TorClient(directory)
         }
 
     let guardsToDispose = ConcurrentBag<TorGuard>()
 
-    static member AsyncBootstrapWithEmbeddedList() =
+    static member AsyncBootstrapWithEmbeddedList
+        (cachePath: Option<DirectoryInfo>)
+        =
         async {
             let fallbackListString =
                 EmbeddedResourceUtility.ExtractEmbeddedResourceFileContents(
                     "fallback_dirs.inc"
                 )
 
-            return! CreateClientFromFallbackString fallbackListString
+            return! CreateClientFromFallbackString fallbackListString cachePath
         }
 
-    static member BootstrapWithEmbeddedListAsync() =
-        TorClient.AsyncBootstrapWithEmbeddedList() |> Async.StartAsTask
+    static member BootstrapWithEmbeddedListAsync
+        (cachePath: Option<DirectoryInfo>)
+        =
+        TorClient.AsyncBootstrapWithEmbeddedList cachePath |> Async.StartAsTask
 
-    static member AsyncBootstrapWithGithub() =
+    static member AsyncBootstrapWithGithub(cachePath: Option<DirectoryInfo>) =
         async {
             let! fallbackListString =
                 let urlToTorServerList =
@@ -98,15 +111,15 @@ type TorClient internal (directory: TorDirectory) =
 
                 httpClient.GetStringAsync urlToTorServerList |> Async.AwaitTask
 
-            return! CreateClientFromFallbackString fallbackListString
+            return! CreateClientFromFallbackString fallbackListString cachePath
         }
 
-    static member BootstrapWithGithubAsync() =
-        TorClient.AsyncBootstrapWithGithub() |> Async.StartAsTask
+    static member BootstrapWithGithubAsync(cachePath: Option<DirectoryInfo>) =
+        TorClient.AsyncBootstrapWithGithub cachePath |> Async.StartAsTask
 
     member __.Directory = directory
 
-    member __.CreateCircuit
+    member __.AsyncCreateCircuit
         (hopsCount: int)
         (purpose: CircuitPurpose)
         (extendByNodeOpt: Option<CircuitNodeDetail>)
@@ -133,10 +146,7 @@ type TorClient internal (directory: TorDirectory) =
             let rec tryCreateCircuit(tryNumber: int) =
                 async {
                     if tryNumber > maximumExtendByNodeRetry then
-                        return
-                            raise
-                            <| NOnionException
-                                "Destination node can't be reached"
+                        return raise <| DestinationNodeCantBeReachedException()
                     else
                         try
                             let! guard, guardDetail = createNewGuard()
@@ -204,7 +214,8 @@ type TorClient internal (directory: TorDirectory) =
                                 | :? NOnionException ->
                                     return
                                         raise
-                                            DestinationNodeCantBeReachedException
+                                        <| DestinationNodeCantBeReachedException
+                                            ()
                             | None -> ()
 
                             return circuit
@@ -230,7 +241,8 @@ type TorClient internal (directory: TorDirectory) =
             purpose: CircuitPurpose,
             extendByNode: Option<CircuitNodeDetail>
         ) =
-        self.CreateCircuit hopsCount purpose extendByNode |> Async.StartAsTask
+        self.AsyncCreateCircuit hopsCount purpose extendByNode
+        |> Async.StartAsTask
 
 
     interface IDisposable with

diff --git a/NOnion/Exceptions.fs b/NOnion/Exceptions.fs
@@ -54,4 +54,5 @@ type NOnionSocketException
             innerException
         )
 
-exception internal DestinationNodeCantBeReachedException
+type DestinationNodeCantBeReachedException() =
+    inherit NOnionException("Destination node can't be reached")