Type CLI import destinations

Author: esnya

src/PlateauResoniteLink.Cli/CliApplication.cs

@@ -68,19 +68,19 @@ public async Task<int> RunAsync(string[] args, CancellationToken cancellationTok
                             options.WorkRoot,
                             cancellationToken);
 
-                        if (options.CanonicalSceneDumpPath is null)
+                        if (options.Destination is ImportDestination.CanonicalSceneDump canonicalSceneDump)
                         {
-                            await standardOutput.WriteLineAsync("Resonite import completed.");
+                            await standardOutput.WriteLineAsync("Canonical scene dump completed.");
+                            await standardOutput.WriteLineAsync($"Dump: {Path.GetFullPath(canonicalSceneDump.Path)}");
                         }
                         else
                         {
-                            await standardOutput.WriteLineAsync("Canonical scene dump completed.");
-                            await standardOutput.WriteLineAsync($"Dump: {Path.GetFullPath(options.CanonicalSceneDumpPath)}");
+                            await standardOutput.WriteLineAsync("Resonite import completed.");
                         }
 
                         await standardOutput.WriteLineAsync($"World: {result.Metadata.SceneName}");
 
-                        if (options.CanonicalSceneDumpPath is null)
+                        if (options.Destination is ImportDestination.Live)
                         {
                             foreach (string destination in result.Destinations)
                             {

src/PlateauResoniteLink.Cli/CliArgumentsParser.cs

@@ -400,17 +400,19 @@ private static CliParseResult ParseImport(string[] args)
                 "Specify either --resonitelink-port or --resonitelink-url.");
         }
 
+        ImportDestination destination = canonicalSceneDumpPath is null
+            ? new ImportDestination.Live(resoniteLinkUri!, resoniteLinkConnectionCount)
+            : new ImportDestination.CanonicalSceneDump(canonicalSceneDumpPath);
+
         return CliParseResult.Success(
             new ImportCommandOptions(
                 request,
                 workRoot,
-                resoniteLinkUri,
-                resoniteLinkConnectionCount,
+                destination,
                 memoryProfile,
                 enableMeshBake,
                 terrainTileCacheRoot,
                 disableTerrainTileCache,
-                canonicalSceneDumpPath,
                 enableSendMetrics,
                 verboseLogging));
     }

src/PlateauResoniteLink.Cli/CliHostFactory.cs

@@ -131,20 +131,25 @@ public ISceneSink Create(ImportCommandOptions options, Action<string>? progressR
         AsyncServiceScope scope = serviceScopeFactory.CreateAsyncScope();
         try
         {
-            if (!string.IsNullOrWhiteSpace(options.CanonicalSceneDumpPath))
+            if (options.Destination is ImportDestination.CanonicalSceneDump canonicalSceneDump)
             {
                 IResoniteCanonicalSceneDumpSinkFactory dumpSinkFactory =
                     scope.ServiceProvider.GetRequiredService<IResoniteCanonicalSceneDumpSinkFactory>();
                 return new ScopedSceneSink(
                     scope,
                     dumpSinkFactory.Create(
                         CreateCanonicalDumpTargetOptions(options, progressReporter),
-                        options.CanonicalSceneDumpPath));
+                        canonicalSceneDump.Path));
             }
 
+            ImportDestination.Live liveDestination = options.Destination switch
+            {
+                ImportDestination.Live live => live,
+                _ => throw new InvalidOperationException($"Unsupported import destination '{options.Destination.GetType().Name}'."),
+            };
             ResoniteLiveSceneImportTargetOptions targetOptions = new(
-                options.ResoniteLinkUri!,
-                options.ResoniteLinkConnectionCount,
+                liveDestination.ResoniteLinkUri,
+                liveDestination.ConnectionCount,
                 options.EnableSendMetrics,
                 options.MemoryProfile switch
                 {

src/PlateauResoniteLink.Cli/ImportCommandOptions.cs

@@ -7,23 +7,19 @@ namespace PlateauResoniteLink.Cli;
 public sealed class ImportCommandOptions(
     PlateauImportRequest Request,
     string WorkRoot,
-    Uri? ResoniteLinkUri,
-    int ResoniteLinkConnectionCount,
+    ImportDestination Destination,
     PlateauImportMemoryProfile MemoryProfile,
     bool EnableMeshBake,
     string? TerrainTileCacheRoot,
     bool DisableTerrainTileCache,
-    string? CanonicalSceneDumpPath,
     bool EnableSendMetrics,
     bool VerboseLogging) : CliCommandOptions
 {
     public PlateauImportRequest Request { get; } = Request ?? throw new ArgumentNullException(nameof(Request));
 
     public string WorkRoot { get; } = WorkRoot ?? throw new ArgumentNullException(nameof(WorkRoot));
 
-    public Uri? ResoniteLinkUri { get; } = ResoniteLinkUri;
-
-    public int ResoniteLinkConnectionCount { get; } = ResoniteLinkConnectionCount;
+    public ImportDestination Destination { get; } = Destination ?? throw new ArgumentNullException(nameof(Destination));
 
     public PlateauImportMemoryProfile MemoryProfile { get; } = MemoryProfile;
 
@@ -33,9 +29,50 @@ public sealed class ImportCommandOptions(
 
     public bool DisableTerrainTileCache { get; } = DisableTerrainTileCache;
 
-    public string? CanonicalSceneDumpPath { get; } = CanonicalSceneDumpPath;
-
     public bool EnableSendMetrics { get; } = EnableSendMetrics;
 
     public bool VerboseLogging { get; } = VerboseLogging;
 }
+
+public abstract record ImportDestination
+{
+    private ImportDestination()
+    {
+    }
+
+    public sealed record Live : ImportDestination
+    {
+        public Live(Uri resoniteLinkUri, int connectionCount)
+        {
+            ArgumentNullException.ThrowIfNull(resoniteLinkUri);
+            if (!resoniteLinkUri.IsAbsoluteUri)
+            {
+                throw new ArgumentException("The ResoniteLink URI must be absolute.", nameof(resoniteLinkUri));
+            }
+
+            if (connectionCount < 1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(connectionCount), connectionCount, "Connection count must be positive.");
+            }
+
+            ResoniteLinkUri = resoniteLinkUri;
+            ConnectionCount = connectionCount;
+        }
+
+        public Uri ResoniteLinkUri { get; }
+
+        public int ConnectionCount { get; }
+    }
+
+    public sealed record CanonicalSceneDump : ImportDestination
+    {
+        public CanonicalSceneDump(string path)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(path);
+
+            Path = path;
+        }
+
+        public string Path { get; }
+    }
+}

tests/PlateauResoniteLink.Tests/Cli/CliArgumentsParserTests.cs

@@ -26,7 +26,9 @@ public void ParseParsesLocalImportCommand()
         Assert.Equal("/data/plateau", options.Request.CityGmlLocalSourcePath);
         Assert.Null(options.Request.DemTextureSource);
         Assert.Equal(CliTestData.DocumentedDefaultPackageNames, options.Request.PackageNames);
-        Assert.Equal(new Uri("ws://localhost:12345/"), options.ResoniteLinkUri);
+        ImportDestination.Live destination = Assert.IsType<ImportDestination.Live>(options.Destination);
+        Assert.Equal(new Uri("ws://localhost:12345/"), destination.ResoniteLinkUri);
+        Assert.Equal(CliDefaultOptions.ResoniteLinkConnectionCount, destination.ConnectionCount);
     }
 
     [Fact]
@@ -64,6 +66,25 @@ public void ParseParsesRemoteImportCommandAndOptionalGeoTiffSource()
         Assert.Equal(new Uri("https://example.invalid/53394525.tif"), options.Request.DemTextureServerUri);
     }
 
+    [Fact]
+    public void ParseParsesLiveImportDestinationConnectionCount()
+    {
+        CliParseResult result = CliArgumentsParser.Parse(
+            [
+                "import",
+                "--dataset", "tokyo23ku",
+                "--mesh-code", "53394525",
+                "--citygml-source", "/data/plateau",
+                "--resonitelink-url", "wss://example.invalid/link",
+                "--resonitelink-connections", "3",
+            ]);
+
+        ImportCommandOptions options = AssertImportSuccess(result);
+        ImportDestination.Live destination = Assert.IsType<ImportDestination.Live>(options.Destination);
+        Assert.Equal(new Uri("wss://example.invalid/link"), destination.ResoniteLinkUri);
+        Assert.Equal(3, destination.ConnectionCount);
+    }
+
     [Fact]
     public void ParseRequiresCityGmlSource()
     {
@@ -91,8 +112,8 @@ public void ParseParsesCanonicalSceneDumpImportWithoutResoniteLinkEndpoint()
             ]);
 
         ImportCommandOptions options = AssertImportSuccess(result);
-        Assert.Null(options.ResoniteLinkUri);
-        Assert.Equal("out/scene.json", options.CanonicalSceneDumpPath);
+        ImportDestination.CanonicalSceneDump destination = Assert.IsType<ImportDestination.CanonicalSceneDump>(options.Destination);
+        Assert.Equal("out/scene.json", destination.Path);
     }
 
     [Fact]

tests/PlateauResoniteLink.Tests/Cli/CliHostFactoryTests.cs

@@ -58,13 +58,11 @@ public async Task CreateSceneSinkFactoryBuildsCanonicalDumpSinkThroughRegistered
                     MeshCode: "53394525",
                     CityGmlSource: DatasetLocation.Local(Path.GetTempPath())),
                 WorkRoot: Path.GetTempPath(),
-                ResoniteLinkUri: null,
-                ResoniteLinkConnectionCount: 4,
+                Destination: new ImportDestination.CanonicalSceneDump(Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.json")),
                 MemoryProfile: PlateauImportMemoryProfile.Large,
                 EnableMeshBake: true,
                 TerrainTileCacheRoot: null,
                 DisableTerrainTileCache: false,
-                CanonicalSceneDumpPath: Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.json"),
                 EnableSendMetrics: true,
                 VerboseLogging: false),
             progressReporter: null);

tests/PlateauResoniteLink.Tests/Cli/ImportServiceFactoryTests.cs

@@ -56,13 +56,11 @@ private static ImportCommandOptions CreateOptions(string meshCode, bool enableMe
         return new ImportCommandOptions(
             request,
             "local",
-            new Uri("ws://localhost:12345/"),
-            4,
+            new ImportDestination.Live(new Uri("ws://localhost:12345/"), 4),
             PlateauImportMemoryProfile.Large,
             enableMeshBake,
             TerrainTileCacheRoot: null,
             DisableTerrainTileCache: false,
-            CanonicalSceneDumpPath: null,
             EnableSendMetrics: false,
             VerboseLogging: false);
     }