-
Notifications
You must be signed in to change notification settings - Fork 849
Expand file tree
/
Copy pathProgram.Command.cs
More file actions
481 lines (417 loc) · 14.1 KB
/
Program.Command.cs
File metadata and controls
481 lines (417 loc) · 14.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging.Abstractions;
using Uno.UI.RemoteControl.Host.Helpers;
namespace Uno.UI.RemoteControl.Host;
partial class Program
{
private static async Task StartCommandAsync(int httpPort, int parentPID, string? solution, string? workingDir, int timeoutMs, string? addins = null, string? ideChannel = null)
{
try
{
if (string.IsNullOrWhiteSpace(workingDir))
{
workingDir = Directory.GetCurrentDirectory();
}
if (string.IsNullOrWhiteSpace(solution))
{
var solutionFiles = Directory.EnumerateFiles(workingDir, "*.sln").Concat(Directory.EnumerateFiles(workingDir, "*.slnx")).ToArray();
solution = solutionFiles.FirstOrDefault();
}
var ambientLogger = NullLogger.Instance;
var ambient = new AmbientRegistry(ambientLogger);
// If a solution is provided (or discovered), check if an active DevServer already serves it.
if (!string.IsNullOrWhiteSpace(solution))
{
var existingBySolution = ambient.GetActiveDevServerForPath(solution);
if (existingBySolution is not null)
{
if (!string.IsNullOrWhiteSpace(ideChannel))
{
await Console.Out.WriteLineAsync($"A DevServer is already running for solution {Path.GetFullPath(solution)} (PID {existingBySolution.ProcessId}, Port {existingBySolution.Port}). Reusing the existing instance and updating the IDE channel.");
var rebound = await TryUpdateExistingIdeChannelAsync(existingBySolution.Port, ideChannel);
if (!rebound)
{
await Console.Error.WriteLineAsync($"Failed to update the IDE channel for the running DevServer on port {existingBySolution.Port}.");
Environment.ExitCode = 1;
return;
}
await CsprojUserGenerator.SetCsprojUserPort(solution, existingBySolution.Port);
await Console.Out.WriteLineAsync($"DevServer is ready on port {existingBySolution.Port}");
Environment.ExitCode = 0;
return;
}
await Console.Out.WriteLineAsync($"A DevServer is already running for solution {Path.GetFullPath(solution)} (PID {existingBySolution.ProcessId}, Port {existingBySolution.Port}). Not starting a new one.");
Environment.ExitCode = 0;
return;
}
}
// If a port was explicitly requested, check for an active DevServer on that port.
if (httpPort > 0)
{
var existingByPort = ambient.GetActiveDevServerForPort(httpPort);
if (existingByPort is not null)
{
if (!string.IsNullOrWhiteSpace(ideChannel))
{
await Console.Out.WriteLineAsync($"A DevServer is already running on port {httpPort} (PID {existingByPort.ProcessId}). Reusing the existing instance and updating the IDE channel.");
var rebound = await TryUpdateExistingIdeChannelAsync(httpPort, ideChannel);
if (!rebound)
{
await Console.Error.WriteLineAsync($"Failed to update the IDE channel for the running DevServer on port {httpPort}.");
Environment.ExitCode = 1;
return;
}
if (!string.IsNullOrWhiteSpace(existingByPort.SolutionPath))
{
await CsprojUserGenerator.SetCsprojUserPort(existingByPort.SolutionPath, httpPort);
}
await Console.Out.WriteLineAsync($"DevServer is ready on port {httpPort}");
Environment.ExitCode = 0;
return;
}
await Console.Out.WriteLineAsync($"A DevServer is already running on port {httpPort} (PID {existingByPort.ProcessId}). Not starting a new one.");
Environment.ExitCode = 0;
return;
}
}
// If no http port was specified, allocate one now.
if (httpPort == 0)
{
httpPort = EnsureTcpPort();
}
var selfPath = Assembly.GetExecutingAssembly().Location;
var psi = new ProcessStartInfo
{
FileName = selfPath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) ? "dotnet" : selfPath,
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
WorkingDirectory = workingDir,
};
if (selfPath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
{
psi.ArgumentList.Add(selfPath);
}
psi.ArgumentList.Add("--httpPort");
psi.ArgumentList.Add(httpPort.ToString(CultureInfo.InvariantCulture));
if (parentPID > 0)
{
psi.ArgumentList.Add("--ppid");
psi.ArgumentList.Add(parentPID.ToString(CultureInfo.InvariantCulture));
}
if (string.IsNullOrWhiteSpace(solution))
{
await Console.Error.WriteLineAsync("A solution file is required");
Environment.ExitCode = 1;
return;
}
psi.ArgumentList.Add("--solution");
psi.ArgumentList.Add(solution);
if (addins is not null)
{
psi.ArgumentList.Add("--addins");
psi.ArgumentList.Add(addins);
}
if (!string.IsNullOrWhiteSpace(ideChannel))
{
psi.ArgumentList.Add("--ideChannel");
psi.ArgumentList.Add(ideChannel);
}
await CsprojUserGenerator.SetCsprojUserPort(solution, httpPort);
await Console.Out.WriteLineAsync($"Starting DevServer: {psi.FileName} {string.Join(' ', psi.ArgumentList)}");
using var process = Process.Start(psi);
if (process is null)
{
await Console.Error.WriteLineAsync("Failed to start DevServer process");
Environment.ExitCode = 1;
return;
}
var (outputTask, errorTask, outputBuffer, errorBuffer) = ObserveProcessOutputs(process);
var ready = await WaitForDevServerReadyAsync(httpPort, timeoutMs);
if (!ready)
{
if (process.HasExited)
{
await Console.Error.WriteLineAsync($"DevServer process died (exit code {process.ExitCode}) before becoming ready");
}
else
{
await Console.Error.WriteLineAsync($"DevServer did not become ready within {timeoutMs}ms");
}
await TerminateProcessAsync(process);
await DrainProcessOutputAsync(outputTask, errorTask);
var output = outputBuffer.ToString();
var error = errorBuffer.ToString();
if (!string.IsNullOrWhiteSpace(output))
{
await Console.Error.WriteLineAsync("DevServer stdout:\n" + output);
}
if (!string.IsNullOrWhiteSpace(error))
{
await Console.Error.WriteLineAsync("DevServer stderr:\n" + error);
}
Environment.ExitCode = 1;
return;
}
else
{
// Display what was generated by the devserver
var output = outputBuffer.ToString();
var error = errorBuffer.ToString();
if (!string.IsNullOrWhiteSpace(output))
{
await Console.Error.WriteLineAsync("DevServer stdout:\n" + output);
}
if (!string.IsNullOrWhiteSpace(error))
{
await Console.Error.WriteLineAsync("DevServer stderr:\n" + error);
}
}
await Console.Out.WriteLineAsync($"DevServer is ready on port {httpPort}");
Environment.ExitCode = 0;
}
catch (Exception ex)
{
await Console.Error.WriteLineAsync($"Controller error: {ex.Message}");
Environment.ExitCode = 1;
}
}
private static (Task stdoutCompleted, Task stderrCompleted, StringBuilder stdoutBuffer, StringBuilder stderrBuffer) ObserveProcessOutputs(Process process)
{
var stdoutBuffer = new StringBuilder();
var stderrBuffer = new StringBuilder();
var stdoutCompletion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var stderrCompletion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
process.OutputDataReceived += (_, args) =>
{
if (args.Data is null)
{
stdoutCompletion.TrySetResult();
return;
}
stdoutBuffer.AppendLine(args.Data);
};
process.ErrorDataReceived += (_, args) =>
{
if (args.Data is null)
{
stderrCompletion.TrySetResult();
return;
}
stderrBuffer.AppendLine(args.Data);
};
process.BeginOutputReadLine();
process.BeginErrorReadLine();
return (stdoutCompletion.Task, stderrCompletion.Task, stdoutBuffer, stderrBuffer);
}
private static async Task<int> StopCommandAsync()
{
var logger = NullLogger.Instance;
var ambient = new AmbientRegistry(logger);
var servers = ambient.GetActiveDevServers().ToList();
if (servers.Count == 0)
{
await Console.Out.WriteLineAsync("No active DevServers found to stop.");
return 0;
}
int stopped = 0, failed = 0;
foreach (var s in servers)
{
await Console.Out.WriteLineAsync($"Stopping DevServer with PID {s.ProcessId} on port {s.Port}...");
try
{
try
{
var p = Process.GetProcessById(s.ProcessId);
if (!p.HasExited)
{
p.Kill();
await p.WaitForExitAsync();
}
stopped++;
}
catch (ArgumentException)
{
// Process not found; treat as already stopped
stopped++;
}
}
catch (Exception ex)
{
failed++;
await Console.Error.WriteLineAsync($"Error stopping DevServer with PID {s.ProcessId}: {ex.Message}");
}
}
ambient.CleanupStaleRegistrations();
await Console.Out.WriteLineAsync($"Successfully stopped {stopped} DevServer(s)");
if (failed > 0)
{
await Console.Error.WriteLineAsync($"Failed to stop {failed} DevServer(s)");
return 1;
}
return 0;
}
private static async Task<int> ListCommandAsync()
{
var logger = NullLogger.Instance;
var ambient = new AmbientRegistry(logger);
var servers = ambient.GetActiveDevServers().ToList();
await Console.Out.WriteLineAsync("Active Uno DevServers:");
if (servers.Count == 0)
{
await Console.Out.WriteLineAsync("No active DevServers found.");
return 0;
}
foreach (var s in servers)
{
var processName = TryGetProcessName(s.ProcessId);
var parentName = TryGetProcessName(s.ParentProcessId);
var processChain = FormatProcessChain(ambient.GetProcessChain(s));
await Console.Out.WriteLineAsync($"Process ID: {s.ProcessId}{(processName is not null ? $" ({processName})" : "")}");
await Console.Out.WriteLineAsync($" Parent PID: {s.ParentProcessId}{(parentName is not null ? $" ({parentName})" : "")}");
await Console.Out.WriteLineAsync($" Port: {s.Port}");
await Console.Out.WriteLineAsync($" Solution: {s.SolutionPath ?? "N/A"}");
await Console.Out.WriteLineAsync($" IDE Channel: {s.IdeChannelId ?? "<none>"}");
await Console.Out.WriteLineAsync($" Process Chain: {processChain}");
await Console.Out.WriteLineAsync($" Machine: {s.MachineName}");
await Console.Out.WriteLineAsync($" User: {s.UserName}");
await Console.Out.WriteLineAsync($" Started: {s.StartTime:yyyy-MM-dd HH:mm:ss} UTC");
}
await Console.Out.WriteLineAsync($"Total active DevServers: {servers.Count}");
return 0;
}
private static async Task<int> CleanupCommandAsync()
{
var logger = NullLogger.Instance;
var ambient = new AmbientRegistry(logger);
await Console.Out.WriteLineAsync("Cleaning up stale DevServer registrations...");
ambient.CleanupStaleRegistrations();
await Console.Out.WriteLineAsync("Cleanup completed.");
return 0;
}
private static async Task TerminateProcessAsync(Process process)
{
try
{
if (!process.HasExited)
{
process.Kill();
await process.WaitForExitAsync();
}
}
catch (InvalidOperationException)
{
// Process already exited.
}
catch (Exception)
{
// Swallow cleanup exceptions to preserve original failure context.
}
}
private static async Task DrainProcessOutputAsync(Task stdoutTask, Task stderrTask)
{
var flushTimeout = TimeSpan.FromSeconds(5);
var combined = Task.WhenAll(stdoutTask, stderrTask);
var completed = await Task.WhenAny(combined, Task.Delay(flushTimeout));
if (completed == combined)
{
await combined;
}
else
{
await Console.Error.WriteLineAsync($"Timed out waiting for DevServer output streams to flush after termination ({flushTimeout.TotalSeconds:F0}s).");
}
}
private static async Task<bool> WaitForDevServerReadyAsync(int port, int timeoutMs)
{
var sw = Stopwatch.StartNew();
var endpoint = new IPEndPoint(IPAddress.Loopback, port);
while (sw.ElapsedMilliseconds < timeoutMs)
{
try
{
using var tcp = new TcpClient();
var connectTask = tcp.ConnectAsync(endpoint.Address, endpoint.Port);
var timeoutTask = Task.Delay(1000);
var winner = await Task.WhenAny(connectTask, timeoutTask);
if (winner == connectTask && !connectTask.IsFaulted)
{
return true;
}
}
catch { }
await Task.Delay(500);
}
return false;
}
private static async Task<bool> TryUpdateExistingIdeChannelAsync(int port, string ideChannel)
{
var url = $"http://127.0.0.1:{port.ToString(CultureInfo.InvariantCulture)}/devserver/idechannel/{Uri.EscapeDataString(ideChannel)}";
await Console.Out.WriteLineAsync($"Rebinding IDE channel on running DevServer: POST {url}");
using var httpClient = new HttpClient
{
Timeout = TimeSpan.FromSeconds(10),
};
try
{
using var response = await httpClient.PostAsync(url, content: null);
var body = await response.Content.ReadAsStringAsync();
await Console.Out.WriteLineAsync($"Rebind response: {(int)response.StatusCode} {response.StatusCode}{(string.IsNullOrWhiteSpace(body) ? "" : $" — {body}")}");
if (response.IsSuccessStatusCode)
{
return true;
}
return false;
}
catch (Exception ex)
{
await Console.Error.WriteLineAsync($"Failed to update the IDE channel on the running DevServer: {ex.Message}");
return false;
}
}
private static string? TryGetProcessName(int pid)
{
try
{
using var process = Process.GetProcessById(pid);
return process.HasExited ? null : process.ProcessName;
}
catch
{
return null;
}
}
private static string FormatProcessChain(IReadOnlyList<AmbientRegistry.ProcessChainNode> chain)
=> string.Join(
" → ",
chain.Reverse().Select(node =>
{
var name = node.ProcessName is not null
&& node.ProcessName.StartsWith("Uno.UI.RemoteControl.Host", StringComparison.OrdinalIgnoreCase)
? "Host"
: node.ProcessName;
return name is { Length: > 0 }
? $"{name} ({node.ProcessId})"
: node.ProcessId.ToString(CultureInfo.InvariantCulture);
}));
private static int EnsureTcpPort()
{
var tcp = new TcpListener(IPAddress.Any, 0) { ExclusiveAddressUse = true };
tcp.Start();
var port = ((IPEndPoint)tcp.LocalEndpoint).Port;
tcp.Stop();
return port;
}
}