Type CLI import destinations

esnya · esnya · commit 88942d2afeba · 2026-06-03T03:19:19.000+09:00
diff --git a/src/PlateauResoniteLink.Cli/CliApplication.cs b/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)
                             {
diff --git a/src/PlateauResoniteLink.Cli/CliArgumentsParser.cs b/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));
     }
diff --git a/src/PlateauResoniteLink.Cli/CliHostFactory.cs b/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
                 {
diff --git a/src/PlateauResoniteLink.Cli/ImportCommandOptions.cs b/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; }
+    }
+}
diff --git a/tests/PlateauResoniteLink.Tests/Cli/CliArgumentsParserTests.cs b/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]
diff --git a/tests/PlateauResoniteLink.Tests/Cli/CliHostFactoryTests.cs b/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);
diff --git a/tests/PlateauResoniteLink.Tests/Cli/ImportServiceFactoryTests.cs b/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);
     }

Original file line number	Diff line number	Diff line change
`@@ -68,19 +68,19 @@ public async Task<int> RunAsync(string[] args, CancellationToken cancellationTok`
`68`	`68`	`options.WorkRoot,`
`69`	`69`	`cancellationToken);`
`70`	`70`
`71`		`- if (options.CanonicalSceneDumpPath is null)`
	`71`	`+ if (options.Destination is ImportDestination.CanonicalSceneDump canonicalSceneDump)`
`72`	`72`	`{`
`73`		`- await standardOutput.WriteLineAsync("Resonite import completed.");`
	`73`	`+ await standardOutput.WriteLineAsync("Canonical scene dump completed.");`
	`74`	`+ await standardOutput.WriteLineAsync($"Dump: {Path.GetFullPath(canonicalSceneDump.Path)}");`
`74`	`75`	`}`
`75`	`76`	`else`
`76`	`77`	`{`
`77`		`- await standardOutput.WriteLineAsync("Canonical scene dump completed.");`
`78`		`- await standardOutput.WriteLineAsync($"Dump: {Path.GetFullPath(options.CanonicalSceneDumpPath)}");`
	`78`	`+ await standardOutput.WriteLineAsync("Resonite import completed.");`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`await standardOutput.WriteLineAsync($"World: {result.Metadata.SceneName}");`
`82`	`82`
`83`		`- if (options.CanonicalSceneDumpPath is null)`
	`83`	`+ if (options.Destination is ImportDestination.Live)`
`84`	`84`	`{`
`85`	`85`	`foreach (string destination in result.Destinations)`
`86`	`86`	`{`