| | | 1 | | using System.Reflection; |
| | | 2 | | using Kestrun.Runner; |
| | | 3 | | using System.Diagnostics; |
| | | 4 | | using System.ComponentModel; |
| | | 5 | | using System.Security.Principal; |
| | | 6 | | using System.Runtime.Versioning; |
| | | 7 | | using System.Runtime.InteropServices; |
| | | 8 | | using System.IO.Compression; |
| | | 9 | | using System.Formats.Tar; |
| | | 10 | | using System.Net.Http.Headers; |
| | | 11 | | using System.Security.Cryptography; |
| | | 12 | | using System.Text; |
| | | 13 | | using System.Text.RegularExpressions; |
| | | 14 | | using System.Xml.Linq; |
| | | 15 | | |
| | | 16 | | namespace Kestrun.Tool; |
| | | 17 | | |
| | | 18 | | internal static partial class Program |
| | | 19 | | { |
| | | 20 | | private static int Main(string[] args) |
| | | 21 | | { |
| | 2 | 22 | | if (TryHandleInternalServiceRegisterMode(args, out var serviceRegisterExitCode)) |
| | | 23 | | { |
| | 0 | 24 | | return serviceRegisterExitCode; |
| | | 25 | | } |
| | | 26 | | |
| | 2 | 27 | | var globalOptions = ParseGlobalOptions(args); |
| | 2 | 28 | | var commandArgs = globalOptions.CommandArgs; |
| | | 29 | | |
| | 2 | 30 | | if (TryHandleMetaCommands(commandArgs, out var metaExitCode)) |
| | | 31 | | { |
| | 1 | 32 | | return metaExitCode; |
| | | 33 | | } |
| | | 34 | | |
| | 1 | 35 | | if (!TryParseArguments(commandArgs, out var parsedCommand, out var parseError)) |
| | | 36 | | { |
| | 1 | 37 | | Console.Error.WriteLine(parseError); |
| | 1 | 38 | | PrintUsage(); |
| | 1 | 39 | | return 2; |
| | | 40 | | } |
| | | 41 | | |
| | 0 | 42 | | if (TryDispatchParsedCommand(parsedCommand, globalOptions, args, out var commandExitCode)) |
| | | 43 | | { |
| | 0 | 44 | | return commandExitCode; |
| | | 45 | | } |
| | | 46 | | // If the command was not handled by dispatch, it must be a run command. Execute the default run mode path. |
| | 0 | 47 | | return ExecuteRunMode(parsedCommand, globalOptions.SkipGalleryCheck); |
| | | 48 | | } |
| | | 49 | | |
| | | 50 | | /// <summary> |
| | | 51 | | /// Handles internal Windows-only service registration mode prior to normal command parsing. |
| | | 52 | | /// </summary> |
| | | 53 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 54 | | /// <param name="exitCode">Exit code when internal service registration mode is handled.</param> |
| | | 55 | | /// <returns>True when internal service registration mode was handled.</returns> |
| | | 56 | | private static bool TryHandleInternalServiceRegisterMode(string[] args, out int exitCode) |
| | | 57 | | { |
| | 4 | 58 | | exitCode = 0; |
| | | 59 | | |
| | 4 | 60 | | if (TryParseServiceRegisterArguments(args, out var serviceRegisterOptions, out var serviceRegisterError)) |
| | | 61 | | { |
| | 0 | 62 | | if (!OperatingSystem.IsWindows()) |
| | | 63 | | { |
| | 0 | 64 | | Console.Error.WriteLine("Internal service registration mode is only supported on Windows."); |
| | 0 | 65 | | exitCode = 1; |
| | 0 | 66 | | return true; |
| | | 67 | | } |
| | | 68 | | |
| | 0 | 69 | | exitCode = RegisterWindowsService(serviceRegisterOptions!); |
| | 0 | 70 | | return true; |
| | | 71 | | } |
| | | 72 | | |
| | 4 | 73 | | if (string.IsNullOrWhiteSpace(serviceRegisterError)) |
| | | 74 | | { |
| | 3 | 75 | | return false; |
| | | 76 | | } |
| | | 77 | | |
| | 1 | 78 | | Console.Error.WriteLine(serviceRegisterError); |
| | 1 | 79 | | exitCode = 2; |
| | 1 | 80 | | return true; |
| | | 81 | | } |
| | | 82 | | |
| | | 83 | | /// <summary> |
| | | 84 | | /// Dispatches parsed non-run commands and returns an exit code when handled. |
| | | 85 | | /// </summary> |
| | | 86 | | /// <param name="parsedCommand">Parsed command.</param> |
| | | 87 | | /// <param name="globalOptions">Parsed global options.</param> |
| | | 88 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 89 | | /// <param name="exitCode">Exit code when command is handled.</param> |
| | | 90 | | /// <returns>True when the command mode is handled by dispatch.</returns> |
| | | 91 | | private static bool TryDispatchParsedCommand(ParsedCommand parsedCommand, GlobalOptions globalOptions, string[] args |
| | | 92 | | { |
| | 1 | 93 | | switch (parsedCommand.Mode) |
| | | 94 | | { |
| | | 95 | | case CommandMode.ServiceInstall: |
| | 0 | 96 | | exitCode = InstallService(parsedCommand, globalOptions.SkipGalleryCheck); |
| | 0 | 97 | | return true; |
| | | 98 | | case CommandMode.ServiceUpdate: |
| | 0 | 99 | | exitCode = UpdateService(parsedCommand); |
| | 0 | 100 | | return true; |
| | | 101 | | case CommandMode.ModuleInstall: |
| | | 102 | | case CommandMode.ModuleUpdate: |
| | | 103 | | case CommandMode.ModuleRemove: |
| | | 104 | | case CommandMode.ModuleInfo: |
| | 0 | 105 | | exitCode = HandleModuleCommand(parsedCommand, args); |
| | 0 | 106 | | return true; |
| | | 107 | | case CommandMode.ServiceRemove: |
| | 0 | 108 | | exitCode = HandleServiceRemoveCommand(parsedCommand, args); |
| | 0 | 109 | | return true; |
| | | 110 | | case CommandMode.ServiceStart: |
| | 0 | 111 | | exitCode = HandleServiceStartCommand(parsedCommand, args); |
| | 0 | 112 | | return true; |
| | | 113 | | case CommandMode.ServiceStop: |
| | 0 | 114 | | exitCode = HandleServiceStopCommand(parsedCommand, args); |
| | 0 | 115 | | return true; |
| | | 116 | | case CommandMode.ServiceQuery: |
| | 0 | 117 | | exitCode = QueryService(parsedCommand); |
| | 0 | 118 | | return true; |
| | | 119 | | case CommandMode.ServiceInfo: |
| | 0 | 120 | | exitCode = InfoService(parsedCommand); |
| | 0 | 121 | | return true; |
| | | 122 | | default: |
| | 1 | 123 | | exitCode = 0; |
| | 1 | 124 | | return false; |
| | | 125 | | } |
| | | 126 | | } |
| | | 127 | | |
| | | 128 | | /// <summary> |
| | | 129 | | /// Handles module command execution, including Windows elevation for global scope changes. |
| | | 130 | | /// </summary> |
| | | 131 | | /// <param name="parsedCommand">Parsed module command.</param> |
| | | 132 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 133 | | /// <returns>Process exit code.</returns> |
| | | 134 | | private static int HandleModuleCommand(ParsedCommand parsedCommand, string[] args) |
| | | 135 | | { |
| | 0 | 136 | | if (OperatingSystem.IsWindows() && RequiresWindowsElevationForGlobalModuleOperation(parsedCommand)) |
| | | 137 | | { |
| | 0 | 138 | | return RelaunchElevatedOnWindows(args); |
| | | 139 | | } |
| | | 140 | | |
| | | 141 | | // For non-Windows OSes, attempt module management without elevation and rely on error handling for permission i |
| | 0 | 142 | | return ManageModuleCommand(parsedCommand); |
| | | 143 | | } |
| | | 144 | | |
| | | 145 | | /// <summary> |
| | | 146 | | /// Returns true when a module install/update/remove command requires Windows elevation. |
| | | 147 | | /// </summary> |
| | | 148 | | /// <param name="parsedCommand">Parsed command.</param> |
| | | 149 | | /// <returns>True when the command targets global scope on Windows without elevation.</returns> |
| | | 150 | | private static bool RequiresWindowsElevationForGlobalModuleOperation(ParsedCommand parsedCommand) |
| | | 151 | | { |
| | 0 | 152 | | if (!OperatingSystem.IsWindows()) |
| | | 153 | | { |
| | 0 | 154 | | return false; |
| | | 155 | | } |
| | | 156 | | // Global scope module operations require admin rights on Windows. |
| | 0 | 157 | | return parsedCommand.Mode is CommandMode.ModuleInstall or CommandMode.ModuleUpdate or CommandMode.ModuleRemove |
| | 0 | 158 | | && parsedCommand.ModuleScope == ModuleStorageScope.Global |
| | 0 | 159 | | && !IsWindowsAdministrator(); |
| | | 160 | | } |
| | | 161 | | |
| | | 162 | | /// <summary> |
| | | 163 | | /// Handles service remove command execution and Windows elevation preflight. |
| | | 164 | | /// </summary> |
| | | 165 | | /// <param name="parsedCommand">Parsed service command.</param> |
| | | 166 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 167 | | /// <returns>Process exit code.</returns> |
| | | 168 | | private static int HandleServiceRemoveCommand(ParsedCommand parsedCommand, string[] args) |
| | | 169 | | { |
| | 1 | 170 | | if (OperatingSystem.IsWindows() && !IsWindowsAdministrator()) |
| | | 171 | | { |
| | 0 | 172 | | return !TryPreflightWindowsServiceRemove(parsedCommand, out var preflightExitCode) |
| | 0 | 173 | | ? preflightExitCode |
| | 0 | 174 | | : RelaunchElevatedOnWindows(args); |
| | | 175 | | } |
| | | 176 | | |
| | | 177 | | // For non-Windows OSes, attempt removal without elevation and rely on permission/service-state errors. |
| | 1 | 178 | | return RemoveService(parsedCommand); |
| | | 179 | | } |
| | | 180 | | |
| | | 181 | | /// <summary> |
| | | 182 | | /// Handles service start command execution and Windows elevation preflight. |
| | | 183 | | /// </summary> |
| | | 184 | | /// <param name="parsedCommand">Parsed service command.</param> |
| | | 185 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 186 | | /// <returns>Process exit code.</returns> |
| | | 187 | | private static int HandleServiceStartCommand(ParsedCommand parsedCommand, string[] args) |
| | | 188 | | { |
| | 1 | 189 | | if (OperatingSystem.IsWindows() && !IsWindowsAdministrator()) |
| | | 190 | | { |
| | 0 | 191 | | if (!TryPreflightWindowsServiceControl(parsedCommand, out var preflightExitCode, out var preflightMessage)) |
| | | 192 | | { |
| | 0 | 193 | | if (parsedCommand.RawOutput) |
| | | 194 | | { |
| | 0 | 195 | | Console.Error.WriteLine(preflightMessage); |
| | 0 | 196 | | return preflightExitCode; |
| | | 197 | | } |
| | | 198 | | |
| | 0 | 199 | | return WriteServiceControlResult( |
| | 0 | 200 | | parsedCommand, |
| | 0 | 201 | | new ServiceControlResult( |
| | 0 | 202 | | "start", |
| | 0 | 203 | | parsedCommand.ServiceName ?? string.Empty, |
| | 0 | 204 | | "windows", |
| | 0 | 205 | | "unknown", |
| | 0 | 206 | | null, |
| | 0 | 207 | | preflightExitCode, |
| | 0 | 208 | | preflightMessage, |
| | 0 | 209 | | string.Empty, |
| | 0 | 210 | | string.Empty)); |
| | | 211 | | } |
| | | 212 | | |
| | 0 | 213 | | var relaunchExitCode = RelaunchElevatedOnWindows(args, suppressStatusMessages: true); |
| | 0 | 214 | | return relaunchExitCode == 1223 && !parsedCommand.RawOutput |
| | 0 | 215 | | ? WriteServiceControlResult( |
| | 0 | 216 | | parsedCommand, |
| | 0 | 217 | | new ServiceControlResult( |
| | 0 | 218 | | "start", |
| | 0 | 219 | | parsedCommand.ServiceName ?? string.Empty, |
| | 0 | 220 | | "windows", |
| | 0 | 221 | | "unknown", |
| | 0 | 222 | | null, |
| | 0 | 223 | | 1, |
| | 0 | 224 | | "Elevation was canceled by the user. Run this command from an elevated terminal if you want to p |
| | 0 | 225 | | string.Empty, |
| | 0 | 226 | | string.Empty)) |
| | 0 | 227 | | : relaunchExitCode; |
| | | 228 | | } |
| | | 229 | | |
| | | 230 | | // For non-Windows OSes, attempt start without elevation and rely on permission/service-state errors. |
| | 1 | 231 | | return StartService(parsedCommand); |
| | | 232 | | } |
| | | 233 | | |
| | | 234 | | /// <summary> |
| | | 235 | | /// Handles service stop command execution and Windows elevation preflight. |
| | | 236 | | /// </summary> |
| | | 237 | | /// <param name="parsedCommand">Parsed service command.</param> |
| | | 238 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 239 | | /// <returns>Process exit code.</returns> |
| | | 240 | | private static int HandleServiceStopCommand(ParsedCommand parsedCommand, string[] args) |
| | | 241 | | { |
| | 1 | 242 | | if (OperatingSystem.IsWindows() && !IsWindowsAdministrator()) |
| | | 243 | | { |
| | 0 | 244 | | if (!TryPreflightWindowsServiceControl(parsedCommand, out var preflightExitCode, out var preflightMessage)) |
| | | 245 | | { |
| | 0 | 246 | | if (parsedCommand.RawOutput) |
| | | 247 | | { |
| | 0 | 248 | | Console.Error.WriteLine(preflightMessage); |
| | 0 | 249 | | return preflightExitCode; |
| | | 250 | | } |
| | | 251 | | |
| | 0 | 252 | | return WriteServiceControlResult( |
| | 0 | 253 | | parsedCommand, |
| | 0 | 254 | | new ServiceControlResult( |
| | 0 | 255 | | "stop", |
| | 0 | 256 | | parsedCommand.ServiceName ?? string.Empty, |
| | 0 | 257 | | "windows", |
| | 0 | 258 | | "unknown", |
| | 0 | 259 | | null, |
| | 0 | 260 | | preflightExitCode, |
| | 0 | 261 | | preflightMessage, |
| | 0 | 262 | | string.Empty, |
| | 0 | 263 | | string.Empty)); |
| | | 264 | | } |
| | | 265 | | |
| | 0 | 266 | | var relaunchExitCode = RelaunchElevatedOnWindows(args, suppressStatusMessages: true); |
| | 0 | 267 | | return relaunchExitCode == 1223 && !parsedCommand.RawOutput |
| | 0 | 268 | | ? WriteServiceControlResult( |
| | 0 | 269 | | parsedCommand, |
| | 0 | 270 | | new ServiceControlResult( |
| | 0 | 271 | | "stop", |
| | 0 | 272 | | parsedCommand.ServiceName ?? string.Empty, |
| | 0 | 273 | | "windows", |
| | 0 | 274 | | "unknown", |
| | 0 | 275 | | null, |
| | 0 | 276 | | 1, |
| | 0 | 277 | | "Elevation was canceled by the user. Run this command from an elevated terminal if you want to p |
| | 0 | 278 | | string.Empty, |
| | 0 | 279 | | string.Empty)) |
| | 0 | 280 | | : relaunchExitCode; |
| | | 281 | | } |
| | | 282 | | |
| | | 283 | | // For non-Windows OSes, attempt stop without elevation and rely on permission/service-state errors. |
| | 1 | 284 | | return StopService(parsedCommand); |
| | | 285 | | } |
| | | 286 | | |
| | | 287 | | /// <summary> |
| | | 288 | | /// Executes the default run mode path after command parsing succeeds. |
| | | 289 | | /// </summary> |
| | | 290 | | /// <param name="parsedCommand">Parsed run command.</param> |
| | | 291 | | /// <param name="skipGalleryCheck">True to skip gallery version checks.</param> |
| | | 292 | | /// <returns>Process exit code.</returns> |
| | | 293 | | private static int ExecuteRunMode(ParsedCommand parsedCommand, bool skipGalleryCheck) |
| | | 294 | | { |
| | 1 | 295 | | var fullScriptPath = Path.GetFullPath(parsedCommand.ScriptPath); |
| | 1 | 296 | | if (!File.Exists(fullScriptPath)) |
| | | 297 | | { |
| | 1 | 298 | | Console.Error.WriteLine($"Script file not found: {fullScriptPath}"); |
| | 1 | 299 | | return 2; |
| | | 300 | | } |
| | | 301 | | |
| | 0 | 302 | | var moduleManifestPath = ResolveRunModuleManifestPath(parsedCommand.KestrunManifestPath, parsedCommand.KestrunFo |
| | 0 | 303 | | if (moduleManifestPath is null) |
| | | 304 | | { |
| | 0 | 305 | | WriteModuleNotFoundMessage(parsedCommand.KestrunManifestPath, parsedCommand.KestrunFolder, Console.Error.Wri |
| | 0 | 306 | | return 3; |
| | | 307 | | } |
| | | 308 | | |
| | 0 | 309 | | if (!skipGalleryCheck) |
| | | 310 | | { |
| | 0 | 311 | | WarnIfNewerGalleryVersionExists(moduleManifestPath); |
| | | 312 | | } |
| | | 313 | | |
| | | 314 | | try |
| | | 315 | | { |
| | 0 | 316 | | return ExecuteScriptViaServiceHost(fullScriptPath, parsedCommand.ScriptArguments, moduleManifestPath); |
| | | 317 | | } |
| | 0 | 318 | | catch (Exception ex) |
| | | 319 | | { |
| | 0 | 320 | | Console.Error.WriteLine($"Execution failed: {ex.Message}"); |
| | 0 | 321 | | return 1; |
| | | 322 | | } |
| | 0 | 323 | | } |
| | | 324 | | |
| | | 325 | | /// <summary> |
| | | 326 | | /// Checks whether the current Windows process token has administrator privileges. |
| | | 327 | | /// </summary> |
| | | 328 | | /// <returns>True when running elevated as administrator.</returns> |
| | | 329 | | [SupportedOSPlatform("windows")] |
| | | 330 | | private static bool IsWindowsAdministrator() |
| | | 331 | | { |
| | 0 | 332 | | using var identity = WindowsIdentity.GetCurrent(); |
| | 0 | 333 | | var principal = new WindowsPrincipal(identity); |
| | 0 | 334 | | return principal.IsInRole(WindowsBuiltInRole.Administrator); |
| | 0 | 335 | | } |
| | | 336 | | |
| | | 337 | | /// <summary> |
| | | 338 | | /// Performs non-admin checks before elevating a Windows service install request. |
| | | 339 | | /// </summary> |
| | | 340 | | /// <param name="command">Parsed service command.</param> |
| | | 341 | | /// <param name="serviceName">Resolved service name.</param> |
| | | 342 | | /// <param name="exitCode">Exit code when preflight fails.</param> |
| | | 343 | | /// <returns>True when install should proceed with elevation.</returns> |
| | | 344 | | [SupportedOSPlatform("windows")] |
| | | 345 | | private static bool TryPreflightWindowsServiceInstall(ParsedCommand command, string serviceName, out int exitCode) |
| | | 346 | | { |
| | 0 | 347 | | exitCode = 0; |
| | 0 | 348 | | if (string.IsNullOrWhiteSpace(serviceName)) |
| | | 349 | | { |
| | 0 | 350 | | Console.Error.WriteLine("Service name is required. Use --name <value>."); |
| | 0 | 351 | | exitCode = 2; |
| | 0 | 352 | | return false; |
| | | 353 | | } |
| | | 354 | | |
| | 0 | 355 | | var moduleManifestPath = LocateModuleManifest(command.KestrunManifestPath, command.KestrunFolder); |
| | 0 | 356 | | if (moduleManifestPath is null) |
| | | 357 | | { |
| | 0 | 358 | | WriteModuleNotFoundMessage(command.KestrunManifestPath, command.KestrunFolder, Console.Error.WriteLine); |
| | 0 | 359 | | exitCode = 3; |
| | 0 | 360 | | return false; |
| | | 361 | | } |
| | | 362 | | |
| | 0 | 363 | | if (!TryResolveServiceRuntimeExecutableFromModule(moduleManifestPath, out _, out var runtimeError)) |
| | | 364 | | { |
| | 0 | 365 | | Console.Error.WriteLine(runtimeError); |
| | 0 | 366 | | exitCode = 1; |
| | 0 | 367 | | return false; |
| | | 368 | | } |
| | | 369 | | |
| | | 370 | | // Do not hard-fail preflight on bundled modules payload resolution. |
| | | 371 | | // Elevated relaunch can run under a different working-directory/layout context, |
| | | 372 | | // so definitive payload validation is performed during actual bundle preparation. |
| | | 373 | | |
| | 0 | 374 | | if (WindowsServiceExists(serviceName)) |
| | | 375 | | { |
| | 0 | 376 | | Console.Error.WriteLine($"Windows service '{serviceName}' already exists."); |
| | 0 | 377 | | exitCode = 2; |
| | 0 | 378 | | return false; |
| | | 379 | | } |
| | | 380 | | |
| | 0 | 381 | | return true; |
| | | 382 | | } |
| | | 383 | | |
| | | 384 | | /// <summary> |
| | | 385 | | /// Performs non-admin checks before elevating a Windows service removal request. |
| | | 386 | | /// </summary> |
| | | 387 | | /// <param name="command">Parsed service command.</param> |
| | | 388 | | /// <param name="exitCode">Exit code when preflight fails.</param> |
| | | 389 | | /// <returns>True when remove should proceed with elevation.</returns> |
| | | 390 | | [SupportedOSPlatform("windows")] |
| | | 391 | | private static bool TryPreflightWindowsServiceRemove(ParsedCommand command, out int exitCode) |
| | | 392 | | { |
| | 0 | 393 | | exitCode = 0; |
| | 0 | 394 | | if (string.IsNullOrWhiteSpace(command.ServiceName)) |
| | | 395 | | { |
| | 0 | 396 | | Console.Error.WriteLine("Service name is required. Use --name <value>."); |
| | 0 | 397 | | exitCode = 2; |
| | 0 | 398 | | return false; |
| | | 399 | | } |
| | | 400 | | |
| | 0 | 401 | | if (!WindowsServiceExists(command.ServiceName)) |
| | | 402 | | { |
| | 0 | 403 | | Console.Error.WriteLine($"Windows service '{command.ServiceName}' was not found."); |
| | 0 | 404 | | exitCode = 2; |
| | 0 | 405 | | return false; |
| | | 406 | | } |
| | | 407 | | |
| | 0 | 408 | | return true; |
| | | 409 | | } |
| | | 410 | | |
| | | 411 | | /// <summary> |
| | | 412 | | /// Performs non-admin checks before elevating a Windows service start/stop request. |
| | | 413 | | /// </summary> |
| | | 414 | | /// <param name="command">Parsed service command.</param> |
| | | 415 | | /// <param name="exitCode">Exit code when preflight fails.</param> |
| | | 416 | | /// <param name="errorMessage">Preflight failure message when validation fails.</param> |
| | | 417 | | /// <returns>True when control should proceed with elevation.</returns> |
| | | 418 | | [SupportedOSPlatform("windows")] |
| | | 419 | | private static bool TryPreflightWindowsServiceControl(ParsedCommand command, out int exitCode, out string errorMessa |
| | | 420 | | { |
| | 0 | 421 | | exitCode = 0; |
| | 0 | 422 | | errorMessage = string.Empty; |
| | 0 | 423 | | if (string.IsNullOrWhiteSpace(command.ServiceName)) |
| | | 424 | | { |
| | 0 | 425 | | exitCode = 2; |
| | 0 | 426 | | errorMessage = "Service name is required. Use --name <value>."; |
| | 0 | 427 | | return false; |
| | | 428 | | } |
| | | 429 | | |
| | 0 | 430 | | if (!WindowsServiceExists(command.ServiceName)) |
| | | 431 | | { |
| | 0 | 432 | | exitCode = 2; |
| | 0 | 433 | | errorMessage = $"Windows service '{command.ServiceName}' was not found."; |
| | 0 | 434 | | return false; |
| | | 435 | | } |
| | | 436 | | |
| | 0 | 437 | | return true; |
| | | 438 | | } |
| | | 439 | | |
| | | 440 | | /// <summary> |
| | | 441 | | /// Determines whether a Windows service exists. |
| | | 442 | | /// </summary> |
| | | 443 | | /// <param name="serviceName">Service name.</param> |
| | | 444 | | /// <returns>True when the service exists.</returns> |
| | | 445 | | [SupportedOSPlatform("windows")] |
| | | 446 | | private static bool WindowsServiceExists(string serviceName) |
| | | 447 | | { |
| | 0 | 448 | | var result = RunProcess("sc.exe", ["query", serviceName], writeStandardOutput: false); |
| | 0 | 449 | | if (result.ExitCode == 0) |
| | | 450 | | { |
| | 0 | 451 | | return true; |
| | | 452 | | } |
| | | 453 | | |
| | 0 | 454 | | var combined = $"{result.Output}\n{result.Error}"; |
| | 0 | 455 | | if (combined.Contains("1060", StringComparison.OrdinalIgnoreCase) |
| | 0 | 456 | | || combined.Contains("does not exist", StringComparison.OrdinalIgnoreCase)) |
| | | 457 | | { |
| | 0 | 458 | | return false; |
| | | 459 | | } |
| | | 460 | | |
| | | 461 | | // A non-zero exit without a clear not-found signal is likely permission-related. |
| | 0 | 462 | | return true; |
| | | 463 | | } |
| | | 464 | | |
| | | 465 | | /// <summary> |
| | | 466 | | /// Relaunches the current executable with UAC elevation on Windows. |
| | | 467 | | /// </summary> |
| | | 468 | | /// <param name="args">Original command-line arguments.</param> |
| | | 469 | | /// <param name="exePath">Optional executable path to launch. When null, the current process executable will be used |
| | | 470 | | /// <returns>Exit code from the elevated child process or an error code.</returns> |
| | | 471 | | [SupportedOSPlatform("windows")] |
| | | 472 | | private static int RelaunchElevatedOnWindows(IReadOnlyList<string> args, string? exePath = null, bool suppressStatus |
| | | 473 | | { |
| | 0 | 474 | | exePath ??= Environment.ProcessPath; |
| | 0 | 475 | | if (!TryResolveElevationExecutablePath(exePath, out var resolvedExePath)) |
| | | 476 | | { |
| | 0 | 477 | | return 1; |
| | | 478 | | } |
| | | 479 | | |
| | 0 | 480 | | if (!suppressStatusMessages) |
| | | 481 | | { |
| | 0 | 482 | | Console.Error.WriteLine("Administrator rights are required. Requesting elevation..."); |
| | | 483 | | } |
| | | 484 | | |
| | 0 | 485 | | var relaunchArgs = BuildElevatedRelaunchArguments(resolvedExePath, args); |
| | 0 | 486 | | var tempDirectory = Path.Combine(Path.GetTempPath(), ProductName); |
| | 0 | 487 | | _ = Directory.CreateDirectory(tempDirectory); |
| | | 488 | | |
| | 0 | 489 | | var outputPath = Path.Combine(tempDirectory, $"elevated-{Guid.NewGuid():N}.log"); |
| | 0 | 490 | | var wrapperPath = Path.Combine(tempDirectory, $"elevated-{Guid.NewGuid():N}.cmd"); |
| | | 491 | | |
| | 0 | 492 | | WriteElevationWrapperScript(wrapperPath, outputPath, resolvedExePath, relaunchArgs); |
| | | 493 | | |
| | | 494 | | try |
| | | 495 | | { |
| | 0 | 496 | | return StartElevatedProcess(wrapperPath, outputPath, suppressStatusMessages); |
| | | 497 | | } |
| | 0 | 498 | | catch (Win32Exception ex) when (ex.NativeErrorCode == 1223) |
| | | 499 | | { |
| | 0 | 500 | | WriteElevationCanceledMessage(suppressStatusMessages); |
| | 0 | 501 | | return 1223; |
| | | 502 | | } |
| | | 503 | | catch (Exception ex) |
| | | 504 | | { |
| | 0 | 505 | | WriteElevationFailureMessage(ex.Message, suppressStatusMessages); |
| | 0 | 506 | | return 1; |
| | | 507 | | } |
| | | 508 | | finally |
| | | 509 | | { |
| | 0 | 510 | | TryDeleteFileQuietly(wrapperPath); |
| | 0 | 511 | | TryDeleteFileQuietly(outputPath); |
| | 0 | 512 | | } |
| | 0 | 513 | | } |
| | | 514 | | |
| | | 515 | | /// <summary> |
| | | 516 | | /// Resolves and validates the executable path used for elevation relaunch. |
| | | 517 | | /// </summary> |
| | | 518 | | /// <param name="exePath">Input executable path.</param> |
| | | 519 | | /// <param name="resolvedExePath">Resolved executable path when validation succeeds.</param> |
| | | 520 | | /// <returns>True when the executable path is valid.</returns> |
| | | 521 | | private static bool TryResolveElevationExecutablePath(string? exePath, out string resolvedExePath) |
| | | 522 | | { |
| | 0 | 523 | | resolvedExePath = exePath ?? string.Empty; |
| | 0 | 524 | | if (string.IsNullOrWhiteSpace(resolvedExePath) || !File.Exists(resolvedExePath)) |
| | | 525 | | { |
| | 0 | 526 | | Console.Error.WriteLine("Unable to resolve KestrunTool executable path for elevation."); |
| | 0 | 527 | | return false; |
| | | 528 | | } |
| | | 529 | | |
| | 0 | 530 | | return true; |
| | | 531 | | } |
| | | 532 | | |
| | | 533 | | /// <summary> |
| | | 534 | | /// Writes the temporary wrapper script used to capture elevated process output. |
| | | 535 | | /// </summary> |
| | | 536 | | /// <param name="wrapperPath">Wrapper script path.</param> |
| | | 537 | | /// <param name="outputPath">Output capture file path.</param> |
| | | 538 | | /// <param name="exePath">Executable path to launch.</param> |
| | | 539 | | /// <param name="relaunchArgs">Relaunch argument tokens.</param> |
| | | 540 | | private static void WriteElevationWrapperScript(string wrapperPath, string outputPath, string exePath, IReadOnlyList |
| | | 541 | | { |
| | 0 | 542 | | var commandLine = BuildWindowsCommandLine(exePath, relaunchArgs); |
| | 0 | 543 | | var wrapperContents = $"@echo off{Environment.NewLine}{commandLine} > \"{outputPath}\" 2>&1{Environment.NewLine} |
| | 0 | 544 | | File.WriteAllText(wrapperPath, wrapperContents, Encoding.ASCII); |
| | 0 | 545 | | } |
| | | 546 | | |
| | | 547 | | /// <summary> |
| | | 548 | | /// Starts the elevated wrapper process and relays captured output. |
| | | 549 | | /// </summary> |
| | | 550 | | /// <param name="wrapperPath">Wrapper script path.</param> |
| | | 551 | | /// <param name="outputPath">Output capture file path.</param> |
| | | 552 | | /// <param name="suppressStatusMessages">True to suppress non-essential status messages.</param> |
| | | 553 | | /// <returns>Exit code from the elevated child process.</returns> |
| | | 554 | | private static int StartElevatedProcess(string wrapperPath, string outputPath, bool suppressStatusMessages) |
| | | 555 | | { |
| | 0 | 556 | | var startInfo = new ProcessStartInfo |
| | 0 | 557 | | { |
| | 0 | 558 | | FileName = "cmd.exe", |
| | 0 | 559 | | Arguments = $"/c \"{wrapperPath}\"", |
| | 0 | 560 | | UseShellExecute = true, |
| | 0 | 561 | | Verb = "runas", |
| | 0 | 562 | | WorkingDirectory = Environment.CurrentDirectory, |
| | 0 | 563 | | }; |
| | | 564 | | |
| | 0 | 565 | | using var process = Process.Start(startInfo); |
| | 0 | 566 | | if (process is null) |
| | | 567 | | { |
| | 0 | 568 | | Console.Error.WriteLine("Failed to start elevated process."); |
| | 0 | 569 | | return 1; |
| | | 570 | | } |
| | | 571 | | |
| | 0 | 572 | | process.WaitForExit(); |
| | 0 | 573 | | RelayElevatedOutput(outputPath); |
| | | 574 | | |
| | 0 | 575 | | if (process.ExitCode != 0 && !suppressStatusMessages) |
| | | 576 | | { |
| | 0 | 577 | | Console.Error.WriteLine("Elevated operation failed. If no UAC prompt was shown, run this command from an ele |
| | | 578 | | } |
| | | 579 | | |
| | 0 | 580 | | return process.ExitCode; |
| | 0 | 581 | | } |
| | | 582 | | |
| | | 583 | | /// <summary> |
| | | 584 | | /// Writes captured elevated output to standard output when available. |
| | | 585 | | /// </summary> |
| | | 586 | | /// <param name="outputPath">Output capture file path.</param> |
| | | 587 | | private static void RelayElevatedOutput(string outputPath) |
| | | 588 | | { |
| | 0 | 589 | | if (!File.Exists(outputPath)) |
| | | 590 | | { |
| | 0 | 591 | | return; |
| | | 592 | | } |
| | | 593 | | |
| | 0 | 594 | | var elevatedOutput = File.ReadAllText(outputPath); |
| | 0 | 595 | | if (!string.IsNullOrWhiteSpace(elevatedOutput)) |
| | | 596 | | { |
| | 0 | 597 | | Console.Write(elevatedOutput); |
| | | 598 | | } |
| | 0 | 599 | | } |
| | | 600 | | |
| | | 601 | | /// <summary> |
| | | 602 | | /// Writes the standard elevation canceled message when status output is enabled. |
| | | 603 | | /// </summary> |
| | | 604 | | /// <param name="suppressStatusMessages">True to suppress status messages.</param> |
| | | 605 | | private static void WriteElevationCanceledMessage(bool suppressStatusMessages) |
| | | 606 | | { |
| | 0 | 607 | | if (suppressStatusMessages) |
| | | 608 | | { |
| | 0 | 609 | | return; |
| | | 610 | | } |
| | | 611 | | |
| | 0 | 612 | | Console.Error.WriteLine("Elevation was canceled by the user."); |
| | 0 | 613 | | Console.Error.WriteLine("Run this command from an elevated terminal if you want to proceed without UAC interacti |
| | 0 | 614 | | } |
| | | 615 | | |
| | | 616 | | /// <summary> |
| | | 617 | | /// Writes the standard elevation failure message when status output is enabled. |
| | | 618 | | /// </summary> |
| | | 619 | | /// <param name="errorMessage">Error message from the failed elevation attempt.</param> |
| | | 620 | | /// <param name="suppressStatusMessages">True to suppress status messages.</param> |
| | | 621 | | private static void WriteElevationFailureMessage(string errorMessage, bool suppressStatusMessages) |
| | | 622 | | { |
| | 0 | 623 | | if (suppressStatusMessages) |
| | | 624 | | { |
| | 0 | 625 | | return; |
| | | 626 | | } |
| | | 627 | | |
| | 0 | 628 | | Console.Error.WriteLine($"Failed to elevate process: {errorMessage}"); |
| | 0 | 629 | | Console.Error.WriteLine("Run this command from an elevated terminal if automatic elevation is unavailable."); |
| | 0 | 630 | | } |
| | | 631 | | |
| | | 632 | | /// <summary> |
| | | 633 | | /// Best-effort delete for temporary files used by elevated relaunch flow. |
| | | 634 | | /// </summary> |
| | | 635 | | /// <param name="path">File path to remove.</param> |
| | | 636 | | private static void TryDeleteFileQuietly(string path) |
| | | 637 | | { |
| | 15 | 638 | | if (string.IsNullOrWhiteSpace(path)) |
| | | 639 | | { |
| | 0 | 640 | | return; |
| | | 641 | | } |
| | | 642 | | |
| | | 643 | | try |
| | | 644 | | { |
| | 15 | 645 | | if (File.Exists(path)) |
| | | 646 | | { |
| | 15 | 647 | | File.Delete(path); |
| | | 648 | | } |
| | 15 | 649 | | } |
| | 0 | 650 | | catch |
| | | 651 | | { |
| | | 652 | | // Best-effort cleanup only. |
| | 0 | 653 | | } |
| | 15 | 654 | | } |
| | | 655 | | |
| | | 656 | | /// <summary> |
| | | 657 | | /// Builds argument tokens for elevated relaunch scenarios. |
| | | 658 | | /// </summary> |
| | | 659 | | /// <param name="executablePath">Current process executable path.</param> |
| | | 660 | | /// <param name="args">Original command-line arguments.</param> |
| | | 661 | | /// <returns>Argument token list for elevated invocation.</returns> |
| | | 662 | | private static IReadOnlyList<string> BuildElevatedRelaunchArguments(string executablePath, IReadOnlyList<string> arg |
| | | 663 | | { |
| | 2 | 664 | | if (!IsDotnetHostExecutable(executablePath)) |
| | | 665 | | { |
| | 1 | 666 | | return [.. args]; |
| | | 667 | | } |
| | | 668 | | |
| | 1 | 669 | | var assemblyPath = typeof(Program).Assembly.Location; |
| | 1 | 670 | | if (!string.IsNullOrWhiteSpace(assemblyPath) && File.Exists(assemblyPath)) |
| | | 671 | | { |
| | 1 | 672 | | var elevatedArgs = new List<string>(args.Count + 1) |
| | 1 | 673 | | { |
| | 1 | 674 | | Path.GetFullPath(assemblyPath), |
| | 1 | 675 | | }; |
| | | 676 | | |
| | 1 | 677 | | elevatedArgs.AddRange(args); |
| | 1 | 678 | | return elevatedArgs; |
| | | 679 | | } |
| | | 680 | | |
| | | 681 | | // Fallback path when assembly location is unavailable. |
| | 0 | 682 | | var fallbackArgs = new List<string>(args.Count + 1) |
| | 0 | 683 | | { |
| | 0 | 684 | | ProductName, |
| | 0 | 685 | | }; |
| | | 686 | | |
| | 0 | 687 | | fallbackArgs.AddRange(args); |
| | 0 | 688 | | return fallbackArgs; |
| | | 689 | | } |
| | | 690 | | |
| | | 691 | | /// <summary> |
| | | 692 | | /// Determines whether the given executable path is the dotnet host executable. |
| | | 693 | | /// </summary> |
| | | 694 | | /// <param name="executablePath">Executable path to inspect.</param> |
| | | 695 | | /// <returns>True when the executable is dotnet host.</returns> |
| | | 696 | | private static bool IsDotnetHostExecutable(string executablePath) |
| | | 697 | | { |
| | 2 | 698 | | var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(executablePath); |
| | 2 | 699 | | return string.Equals(fileNameWithoutExtension, "dotnet", StringComparison.OrdinalIgnoreCase); |
| | | 700 | | } |
| | | 701 | | |
| | | 702 | | /// <summary> |
| | | 703 | | /// Builds KestrunTool command-line arguments used by installed services/daemons. |
| | | 704 | | /// </summary> |
| | | 705 | | /// <param name="scriptPath">Absolute script path to execute.</param> |
| | | 706 | | /// <param name="scriptArguments">Script arguments for the run command.</param> |
| | | 707 | | /// <param name="kestrunFolder">Optional folder containing Kestrun module manifest.</param> |
| | | 708 | | /// <param name="kestrunManifestPath">Optional explicit Kestrun module manifest path.</param> |
| | | 709 | | /// <returns>Ordered runner argument tokens.</returns> |
| | | 710 | | private static IReadOnlyList<string> BuildRunnerArgumentsForService(string scriptPath, IReadOnlyList<string> scriptA |
| | | 711 | | { |
| | 1 | 712 | | var arguments = new List<string>(8 + scriptArguments.Count); |
| | 1 | 713 | | if (!string.IsNullOrWhiteSpace(kestrunManifestPath)) |
| | | 714 | | { |
| | 1 | 715 | | arguments.Add("--kestrun-manifest"); |
| | 1 | 716 | | arguments.Add(Path.GetFullPath(kestrunManifestPath)); |
| | | 717 | | } |
| | | 718 | | |
| | 1 | 719 | | if (!string.IsNullOrWhiteSpace(kestrunFolder)) |
| | | 720 | | { |
| | 0 | 721 | | arguments.Add("--kestrun-folder"); |
| | 0 | 722 | | arguments.Add(Path.GetFullPath(kestrunFolder)); |
| | | 723 | | } |
| | | 724 | | |
| | 1 | 725 | | arguments.Add("run"); |
| | 1 | 726 | | arguments.Add(scriptPath); |
| | | 727 | | |
| | 1 | 728 | | if (scriptArguments.Count > 0) |
| | | 729 | | { |
| | 1 | 730 | | arguments.Add("--arguments"); |
| | 1 | 731 | | arguments.AddRange(scriptArguments); |
| | | 732 | | } |
| | | 733 | | |
| | 1 | 734 | | return arguments; |
| | | 735 | | } |
| | | 736 | | |
| | | 737 | | /// <summary> |
| | | 738 | | /// Builds command-line arguments for daemon host registration. |
| | | 739 | | /// </summary> |
| | | 740 | | /// <param name="serviceName">Service name.</param> |
| | | 741 | | /// <param name="serviceHostExecutablePath">Service-host executable path.</param> |
| | | 742 | | /// <param name="runnerExecutablePath">Runner executable path.</param> |
| | | 743 | | /// <param name="scriptPath">Absolute script path.</param> |
| | | 744 | | /// <param name="moduleManifestPath">Absolute module manifest path.</param> |
| | | 745 | | /// <param name="scriptArguments">Script arguments for run mode.</param> |
| | | 746 | | /// <param name="serviceLogPath">Optional service log path.</param> |
| | | 747 | | /// <returns>Ordered daemon-host argument tokens.</returns> |
| | | 748 | | private static IReadOnlyList<string> BuildDaemonHostArgumentsForService( |
| | | 749 | | string serviceName, |
| | | 750 | | string serviceHostExecutablePath, |
| | | 751 | | string runnerExecutablePath, |
| | | 752 | | string scriptPath, |
| | | 753 | | string moduleManifestPath, |
| | | 754 | | IReadOnlyList<string> scriptArguments, |
| | | 755 | | string? serviceLogPath) |
| | | 756 | | { |
| | 2 | 757 | | if (UsesDedicatedServiceHostExecutable(serviceHostExecutablePath)) |
| | | 758 | | { |
| | 1 | 759 | | return BuildDedicatedServiceHostArguments(serviceName, runnerExecutablePath, scriptPath, moduleManifestPath, |
| | | 760 | | } |
| | | 761 | | // Fallback to generic runner invocation when the service host is not the dedicated one. |
| | 1 | 762 | | return BuildRunnerArgumentsForService(scriptPath, scriptArguments, null, moduleManifestPath); |
| | | 763 | | } |
| | | 764 | | |
| | | 765 | | /// <summary> |
| | | 766 | | /// Installs a Windows service using sc.exe. |
| | | 767 | | /// </summary> |
| | | 768 | | /// <param name="command">Parsed service command.</param> |
| | | 769 | | /// <param name="serviceName">Resolved service name.</param> |
| | | 770 | | /// <param name="serviceLogPath">Effective service log path.</param> |
| | | 771 | | /// <param name="serviceHostExecutablePath">Service host executable path.</param> |
| | | 772 | | /// <param name="runnerExecutablePath">Runner executable path.</param> |
| | | 773 | | /// <param name="scriptPath">Bundled script path.</param> |
| | | 774 | | /// <param name="moduleManifestPath">Bundled module manifest path.</param> |
| | | 775 | | /// <returns>Process exit code.</returns> |
| | | 776 | | [SupportedOSPlatform("windows")] |
| | | 777 | | private static int InstallWindowsService( |
| | | 778 | | ParsedCommand command, |
| | | 779 | | string serviceName, |
| | | 780 | | string? serviceLogPath, |
| | | 781 | | string serviceHostExecutablePath, |
| | | 782 | | string runnerExecutablePath, |
| | | 783 | | string scriptPath, |
| | | 784 | | string moduleManifestPath) |
| | | 785 | | { |
| | 0 | 786 | | if (!IsWindowsAdministrator()) |
| | | 787 | | { |
| | 0 | 788 | | var relaunchArgs = BuildWindowsServiceRegisterArguments(command, serviceName, serviceLogPath, serviceHostExe |
| | 0 | 789 | | return RelaunchElevatedOnWindows(relaunchArgs); |
| | | 790 | | } |
| | | 791 | | |
| | 0 | 792 | | var createResult = CreateWindowsServiceRegistration( |
| | 0 | 793 | | serviceName, |
| | 0 | 794 | | Path.GetFullPath(serviceHostExecutablePath), |
| | 0 | 795 | | Path.GetFullPath(runnerExecutablePath), |
| | 0 | 796 | | Path.GetFullPath(scriptPath), |
| | 0 | 797 | | Path.GetFullPath(moduleManifestPath), |
| | 0 | 798 | | command.ScriptArguments, |
| | 0 | 799 | | serviceLogPath, |
| | 0 | 800 | | command.ServiceUser, |
| | 0 | 801 | | command.ServicePassword); |
| | | 802 | | |
| | 0 | 803 | | if (createResult.ExitCode != 0) |
| | | 804 | | { |
| | 0 | 805 | | Console.Error.WriteLine(createResult.Error); |
| | 0 | 806 | | return createResult.ExitCode; |
| | | 807 | | } |
| | | 808 | | |
| | 0 | 809 | | WriteServiceOperationLog($"Service '{serviceName}' install operation completed.", serviceLogPath, serviceName); |
| | | 810 | | |
| | 0 | 811 | | Console.WriteLine($"Installed Windows service '{serviceName}' (not started)."); |
| | 0 | 812 | | return 0; |
| | | 813 | | } |
| | | 814 | | |
| | | 815 | | /// <summary> |
| | | 816 | | /// Registers a Windows service using pre-staged runtime/module/script paths. |
| | | 817 | | /// </summary> |
| | | 818 | | /// <param name="options">Parsed service registration options.</param> |
| | | 819 | | /// <returns>Process exit code.</returns> |
| | | 820 | | [SupportedOSPlatform("windows")] |
| | | 821 | | private static int RegisterWindowsService(ServiceRegisterOptions options) |
| | | 822 | | { |
| | 0 | 823 | | var serviceName = options.ServiceName; |
| | 0 | 824 | | var createResult = CreateWindowsServiceRegistration( |
| | 0 | 825 | | serviceName, |
| | 0 | 826 | | Path.GetFullPath(options.ServiceHostExecutablePath), |
| | 0 | 827 | | Path.GetFullPath(options.RunnerExecutablePath), |
| | 0 | 828 | | Path.GetFullPath(options.ScriptPath), |
| | 0 | 829 | | Path.GetFullPath(options.ModuleManifestPath), |
| | 0 | 830 | | options.ScriptArguments, |
| | 0 | 831 | | options.ServiceLogPath, |
| | 0 | 832 | | options.ServiceUser, |
| | 0 | 833 | | options.ServicePassword); |
| | | 834 | | |
| | 0 | 835 | | if (createResult.ExitCode != 0) |
| | | 836 | | { |
| | 0 | 837 | | Console.Error.WriteLine(createResult.Error); |
| | 0 | 838 | | return createResult.ExitCode; |
| | | 839 | | } |
| | | 840 | | |
| | 0 | 841 | | WriteServiceOperationLog($"Service '{serviceName}' install operation completed.", options.ServiceLogPath, servic |
| | | 842 | | |
| | 0 | 843 | | Console.WriteLine($"Installed Windows service '{serviceName}' (not started)."); |
| | 0 | 844 | | return 0; |
| | | 845 | | } |
| | | 846 | | |
| | | 847 | | /// <summary> |
| | | 848 | | /// Creates a Windows service registration using sc.exe. |
| | | 849 | | /// </summary> |
| | | 850 | | /// <param name="serviceName">Service name.</param> |
| | | 851 | | /// <param name="serviceHostExecutablePath">Service-host executable path.</param> |
| | | 852 | | /// <param name="runnerExecutablePath">Runner executable path.</param> |
| | | 853 | | /// <param name="scriptPath">Absolute script path.</param> |
| | | 854 | | /// <param name="moduleManifestPath">Absolute module manifest path.</param> |
| | | 855 | | /// <param name="scriptArguments">Script arguments for service-host mode.</param> |
| | | 856 | | /// <param name="serviceLogPath">Optional service log path.</param> |
| | | 857 | | /// <returns>Process result from sc.exe create.</returns> |
| | | 858 | | private static ProcessResult CreateWindowsServiceRegistration( |
| | | 859 | | string serviceName, |
| | | 860 | | string serviceHostExecutablePath, |
| | | 861 | | string runnerExecutablePath, |
| | | 862 | | string scriptPath, |
| | | 863 | | string moduleManifestPath, |
| | | 864 | | IReadOnlyList<string> scriptArguments, |
| | | 865 | | string? serviceLogPath, |
| | | 866 | | string? serviceUser, |
| | | 867 | | string? servicePassword) |
| | | 868 | | { |
| | 0 | 869 | | if (!UsesDedicatedServiceHostExecutable(serviceHostExecutablePath)) |
| | | 870 | | { |
| | 0 | 871 | | return new ProcessResult( |
| | 0 | 872 | | 1, |
| | 0 | 873 | | string.Empty, |
| | 0 | 874 | | "Service registration now requires the dedicated kestrun-service-host executable. Reinstall or update Ke |
| | | 875 | | } |
| | | 876 | | |
| | 0 | 877 | | var hostArgs = BuildDedicatedServiceHostArguments(serviceName, runnerExecutablePath, scriptPath, moduleManifestP |
| | | 878 | | |
| | 0 | 879 | | var imagePath = BuildWindowsCommandLine(serviceHostExecutablePath, hostArgs); |
| | 0 | 880 | | var scArgs = new List<string> |
| | 0 | 881 | | { |
| | 0 | 882 | | "create", |
| | 0 | 883 | | serviceName, |
| | 0 | 884 | | "start=", |
| | 0 | 885 | | "auto", |
| | 0 | 886 | | "binPath=", |
| | 0 | 887 | | imagePath, |
| | 0 | 888 | | "DisplayName=", |
| | 0 | 889 | | serviceName, |
| | 0 | 890 | | }; |
| | | 891 | | |
| | 0 | 892 | | if (!string.IsNullOrWhiteSpace(serviceUser)) |
| | | 893 | | { |
| | 0 | 894 | | var normalizedServiceUser = NormalizeWindowsServiceAccountName(serviceUser); |
| | 0 | 895 | | scArgs.Add("obj="); |
| | 0 | 896 | | scArgs.Add(normalizedServiceUser); |
| | | 897 | | |
| | | 898 | | // Windows built-in service accounts do not require a password. |
| | 0 | 899 | | if (!IsWindowsBuiltinServiceAccount(normalizedServiceUser) && !string.IsNullOrWhiteSpace(servicePassword)) |
| | | 900 | | { |
| | 0 | 901 | | scArgs.Add("password="); |
| | 0 | 902 | | scArgs.Add(servicePassword); |
| | | 903 | | } |
| | | 904 | | } |
| | | 905 | | |
| | 0 | 906 | | return RunProcess("sc.exe", scArgs); |
| | | 907 | | } |
| | | 908 | | |
| | | 909 | | /// <summary> |
| | | 910 | | /// Normalizes friendly Windows built-in service account aliases to SCM-compatible names. |
| | | 911 | | /// </summary> |
| | | 912 | | /// <param name="serviceUser">Raw service user argument.</param> |
| | | 913 | | /// <returns>Normalized account name for sc.exe registration.</returns> |
| | | 914 | | private static string NormalizeWindowsServiceAccountName(string serviceUser) |
| | | 915 | | { |
| | 5 | 916 | | var trimmed = serviceUser.Trim(); |
| | | 917 | | |
| | 5 | 918 | | return trimmed.ToLowerInvariant() switch |
| | 5 | 919 | | { |
| | 2 | 920 | | "networkservice" or "network service" or @"nt authority\networkservice" => @"NT AUTHORITY\NetworkService", |
| | 1 | 921 | | "localservice" or "local service" or @"nt authority\localservice" => @"NT AUTHORITY\LocalService", |
| | 1 | 922 | | "localsystem" or "local system" or "system" or @"nt authority\system" => "LocalSystem", |
| | 1 | 923 | | _ => trimmed, |
| | 5 | 924 | | }; |
| | | 925 | | } |
| | | 926 | | |
| | | 927 | | /// <summary> |
| | | 928 | | /// Determines whether an account string refers to a Windows built-in service account. |
| | | 929 | | /// </summary> |
| | | 930 | | /// <param name="accountName">Account name to inspect.</param> |
| | | 931 | | /// <returns>True when account is LocalSystem, NetworkService, or LocalService.</returns> |
| | | 932 | | private static bool IsWindowsBuiltinServiceAccount(string accountName) |
| | | 933 | | { |
| | 4 | 934 | | return accountName.Equals("LocalSystem", StringComparison.OrdinalIgnoreCase) |
| | 4 | 935 | | || accountName.Equals(@"NT AUTHORITY\NetworkService", StringComparison.OrdinalIgnoreCase) |
| | 4 | 936 | | || accountName.Equals(@"NT AUTHORITY\LocalService", StringComparison.OrdinalIgnoreCase); |
| | | 937 | | } |
| | | 938 | | |
| | | 939 | | /// <summary> |
| | | 940 | | /// Determines whether a path refers to the dedicated service-host executable. |
| | | 941 | | /// </summary> |
| | | 942 | | /// <param name="executablePath">Executable path.</param> |
| | | 943 | | /// <returns>True when the executable is the dedicated service host.</returns> |
| | | 944 | | private static bool UsesDedicatedServiceHostExecutable(string executablePath) |
| | | 945 | | { |
| | 5 | 946 | | var fileName = Path.GetFileNameWithoutExtension(executablePath); |
| | 5 | 947 | | return string.Equals(fileName, "kestrun-service-host", StringComparison.OrdinalIgnoreCase) |
| | 5 | 948 | | || string.Equals(fileName, "Kestrun.ServiceHost", StringComparison.OrdinalIgnoreCase); |
| | | 949 | | } |
| | | 950 | | |
| | | 951 | | /// <summary> |
| | | 952 | | /// Builds elevated relaunch arguments for internal Windows service registration. |
| | | 953 | | /// </summary> |
| | | 954 | | /// <param name="command">Parsed service command.</param> |
| | | 955 | | /// <param name="serviceName">Resolved service name.</param> |
| | | 956 | | /// <param name="serviceLogPath">Effective service log path.</param> |
| | | 957 | | /// <param name="executablePath">Executable path.</param> |
| | | 958 | | /// <param name="scriptPath">Absolute script path.</param> |
| | | 959 | | /// <param name="moduleManifestPath">Manifest path staged for service runtime.</param> |
| | | 960 | | /// <returns>Ordered argument tokens.</returns> |
| | | 961 | | private static IReadOnlyList<string> BuildWindowsServiceRegisterArguments( |
| | | 962 | | ParsedCommand command, |
| | | 963 | | string serviceName, |
| | | 964 | | string? serviceLogPath, |
| | | 965 | | string serviceHostExecutablePath, |
| | | 966 | | string runnerExecutablePath, |
| | | 967 | | string scriptPath, |
| | | 968 | | string moduleManifestPath) |
| | | 969 | | { |
| | 0 | 970 | | var arguments = new List<string>(16 + command.ScriptArguments.Length) |
| | 0 | 971 | | { |
| | 0 | 972 | | "--service-register", |
| | 0 | 973 | | "--name", |
| | 0 | 974 | | serviceName, |
| | 0 | 975 | | "--service-host-exe", |
| | 0 | 976 | | Path.GetFullPath(serviceHostExecutablePath), |
| | 0 | 977 | | "--runner-exe", |
| | 0 | 978 | | Path.GetFullPath(runnerExecutablePath), |
| | 0 | 979 | | "--script", |
| | 0 | 980 | | Path.GetFullPath(scriptPath), |
| | 0 | 981 | | "--kestrun-manifest", |
| | 0 | 982 | | Path.GetFullPath(moduleManifestPath), |
| | 0 | 983 | | }; |
| | | 984 | | |
| | 0 | 985 | | if (!string.IsNullOrWhiteSpace(serviceLogPath)) |
| | | 986 | | { |
| | 0 | 987 | | arguments.Add("--service-log-path"); |
| | 0 | 988 | | arguments.Add(Path.GetFullPath(serviceLogPath)); |
| | | 989 | | } |
| | | 990 | | |
| | 0 | 991 | | if (!string.IsNullOrWhiteSpace(command.ServiceUser)) |
| | | 992 | | { |
| | 0 | 993 | | arguments.Add("--service-user"); |
| | 0 | 994 | | arguments.Add(command.ServiceUser); |
| | | 995 | | } |
| | | 996 | | |
| | 0 | 997 | | if (!string.IsNullOrWhiteSpace(command.ServicePassword)) |
| | | 998 | | { |
| | 0 | 999 | | arguments.Add("--service-password"); |
| | 0 | 1000 | | arguments.Add(command.ServicePassword); |
| | | 1001 | | } |
| | | 1002 | | |
| | 0 | 1003 | | if (command.ScriptArguments.Length > 0) |
| | | 1004 | | { |
| | 0 | 1005 | | arguments.Add("--arguments"); |
| | 0 | 1006 | | arguments.AddRange(command.ScriptArguments); |
| | | 1007 | | } |
| | | 1008 | | |
| | 0 | 1009 | | return arguments; |
| | | 1010 | | } |
| | | 1011 | | |
| | | 1012 | | /// <summary> |
| | | 1013 | | /// Builds arguments for the dedicated service-host executable. |
| | | 1014 | | /// </summary> |
| | | 1015 | | /// <param name="serviceName">Service name.</param> |
| | | 1016 | | /// <param name="runnerExecutablePath">Runner executable path.</param> |
| | | 1017 | | /// <param name="scriptPath">Absolute script path.</param> |
| | | 1018 | | /// <param name="moduleManifestPath">Manifest path staged for service runtime.</param> |
| | | 1019 | | /// <param name="scriptArguments">Script arguments forwarded to run mode.</param> |
| | | 1020 | | /// <param name="serviceLogPath">Optional service log path.</param> |
| | | 1021 | | /// <returns>Ordered argument tokens.</returns> |
| | | 1022 | | private static IReadOnlyList<string> BuildDedicatedServiceHostArguments( |
| | | 1023 | | string serviceName, |
| | | 1024 | | string runnerExecutablePath, |
| | | 1025 | | string scriptPath, |
| | | 1026 | | string moduleManifestPath, |
| | | 1027 | | IReadOnlyList<string> scriptArguments, |
| | | 1028 | | string? serviceLogPath) |
| | | 1029 | | { |
| | 2 | 1030 | | var arguments = new List<string>(14 + scriptArguments.Count) |
| | 2 | 1031 | | { |
| | 2 | 1032 | | "--name", |
| | 2 | 1033 | | serviceName, |
| | 2 | 1034 | | "--runner-exe", |
| | 2 | 1035 | | Path.GetFullPath(runnerExecutablePath), |
| | 2 | 1036 | | "--script", |
| | 2 | 1037 | | scriptPath, |
| | 2 | 1038 | | "--kestrun-manifest", |
| | 2 | 1039 | | Path.GetFullPath(moduleManifestPath), |
| | 2 | 1040 | | }; |
| | | 1041 | | |
| | 2 | 1042 | | if (!string.IsNullOrWhiteSpace(serviceLogPath)) |
| | | 1043 | | { |
| | 1 | 1044 | | arguments.Add("--service-log-path"); |
| | 1 | 1045 | | arguments.Add(Path.GetFullPath(serviceLogPath)); |
| | | 1046 | | } |
| | | 1047 | | |
| | 2 | 1048 | | if (scriptArguments.Count > 0) |
| | | 1049 | | { |
| | 0 | 1050 | | arguments.Add("--arguments"); |
| | 0 | 1051 | | arguments.AddRange(scriptArguments); |
| | | 1052 | | } |
| | | 1053 | | |
| | 2 | 1054 | | return arguments; |
| | | 1055 | | } |
| | | 1056 | | |
| | | 1057 | | /// <summary> |
| | | 1058 | | /// Removes a Windows service using sc.exe. |
| | | 1059 | | /// </summary> |
| | | 1060 | | /// <param name="command">Parsed service command.</param> |
| | | 1061 | | /// <returns>Process exit code.</returns> |
| | | 1062 | | private static int RemoveWindowsService(ParsedCommand command) |
| | | 1063 | | { |
| | 0 | 1064 | | var operationLogPath = ResolveServiceOperationLogPath(command.ServiceLogPath, command.ServiceName); |
| | | 1065 | | |
| | 0 | 1066 | | var stopResult = RunProcess("sc.exe", ["stop", command.ServiceName!], writeStandardOutput: false); |
| | 0 | 1067 | | if (stopResult.ExitCode != 0 && !IsWindowsServiceAlreadyStopped(stopResult)) |
| | | 1068 | | { |
| | 0 | 1069 | | WriteServiceOperationLog( |
| | 0 | 1070 | | $"Service '{command.ServiceName}' stop-before-delete returned exitCode={stopResult.ExitCode} error='{sto |
| | 0 | 1071 | | operationLogPath, |
| | 0 | 1072 | | command.ServiceName); |
| | | 1073 | | } |
| | 0 | 1074 | | else if (!WaitForWindowsServiceToStopOrDisappear(command.ServiceName!, timeoutMs: 15000)) |
| | | 1075 | | { |
| | 0 | 1076 | | WriteServiceOperationLog( |
| | 0 | 1077 | | $"Service '{command.ServiceName}' did not reach STOPPED/deleted state before delete attempt.", |
| | 0 | 1078 | | operationLogPath, |
| | 0 | 1079 | | command.ServiceName); |
| | | 1080 | | } |
| | | 1081 | | |
| | 0 | 1082 | | var deleteResult = RunProcess("sc.exe", ["delete", command.ServiceName!]); |
| | 0 | 1083 | | if (deleteResult.ExitCode != 0) |
| | | 1084 | | { |
| | 0 | 1085 | | Console.Error.WriteLine(deleteResult.Error); |
| | 0 | 1086 | | return deleteResult.ExitCode; |
| | | 1087 | | } |
| | | 1088 | | |
| | 0 | 1089 | | WriteServiceOperationLog($"Service '{command.ServiceName}' remove operation completed.", operationLogPath, comma |
| | | 1090 | | |
| | 0 | 1091 | | Console.WriteLine($"Removed Windows service '{command.ServiceName}'."); |
| | 0 | 1092 | | return 0; |
| | | 1093 | | } |
| | | 1094 | | |
| | | 1095 | | /// <summary> |
| | | 1096 | | /// Waits until a Windows service reaches STOPPED state or is no longer present in SCM. |
| | | 1097 | | /// </summary> |
| | | 1098 | | /// <param name="serviceName">Service name.</param> |
| | | 1099 | | /// <param name="timeoutMs">Maximum wait time in milliseconds.</param> |
| | | 1100 | | /// <param name="pollIntervalMs">Polling interval in milliseconds.</param> |
| | | 1101 | | /// <returns>True when the service is stopped or deleted before timeout.</returns> |
| | | 1102 | | private static bool WaitForWindowsServiceToStopOrDisappear(string serviceName, int timeoutMs = 15000, int pollInterv |
| | | 1103 | | { |
| | 0 | 1104 | | var timeout = TimeSpan.FromMilliseconds(Math.Max(timeoutMs, pollIntervalMs)); |
| | 0 | 1105 | | var deadline = DateTime.UtcNow + timeout; |
| | | 1106 | | |
| | 0 | 1107 | | while (DateTime.UtcNow <= deadline) |
| | | 1108 | | { |
| | 0 | 1109 | | var queryResult = RunProcess("sc.exe", ["query", serviceName], writeStandardOutput: false); |
| | 0 | 1110 | | var diagnostics = $"{queryResult.Output}\n{queryResult.Error}"; |
| | | 1111 | | |
| | 0 | 1112 | | if (queryResult.ExitCode == 0) |
| | | 1113 | | { |
| | 0 | 1114 | | if (diagnostics.Contains("STOPPED", StringComparison.OrdinalIgnoreCase)) |
| | | 1115 | | { |
| | 0 | 1116 | | return true; |
| | | 1117 | | } |
| | | 1118 | | } |
| | 0 | 1119 | | else if (diagnostics.Contains("1060", StringComparison.OrdinalIgnoreCase) |
| | 0 | 1120 | | || diagnostics.Contains("does not exist", StringComparison.OrdinalIgnoreCase)) |
| | | 1121 | | { |
| | 0 | 1122 | | return true; |
| | | 1123 | | } |
| | | 1124 | | |
| | 0 | 1125 | | Thread.Sleep(pollIntervalMs); |
| | | 1126 | | } |
| | | 1127 | | |
| | 0 | 1128 | | return false; |
| | | 1129 | | } |
| | | 1130 | | |
| | | 1131 | | /// <summary> |
| | | 1132 | | /// Writes an install/remove operation log line for Windows service lifecycle operations. |
| | | 1133 | | /// </summary> |
| | | 1134 | | /// <param name="message">Operation message to append.</param> |
| | | 1135 | | /// <param name="configuredPath">Optional configured log path.</param> |
| | | 1136 | | /// <param name="serviceName">Optional service name used to discover configured log path.</param> |
| | | 1137 | | private static void WriteServiceOperationLog(string message, string? configuredPath, string? serviceName) |
| | | 1138 | | { |
| | 7 | 1139 | | var logPath = ResolveServiceOperationLogPath(configuredPath, serviceName); |
| | | 1140 | | try |
| | | 1141 | | { |
| | 7 | 1142 | | var directory = Path.GetDirectoryName(logPath); |
| | 7 | 1143 | | if (!string.IsNullOrWhiteSpace(directory)) |
| | | 1144 | | { |
| | 7 | 1145 | | _ = Directory.CreateDirectory(directory); |
| | | 1146 | | } |
| | | 1147 | | |
| | 7 | 1148 | | var line = $"{DateTime.UtcNow:O} {message}{Environment.NewLine}"; |
| | 7 | 1149 | | File.AppendAllText(logPath, line, Encoding.UTF8); |
| | 7 | 1150 | | } |
| | 0 | 1151 | | catch |
| | | 1152 | | { |
| | | 1153 | | // Best-effort operation logging only. |
| | 0 | 1154 | | } |
| | 7 | 1155 | | } |
| | | 1156 | | |
| | | 1157 | | /// <summary> |
| | | 1158 | | /// Writes a standardized service operation result entry. |
| | | 1159 | | /// </summary> |
| | | 1160 | | /// <param name="operation">Operation name (install/start/stop/query/remove).</param> |
| | | 1161 | | /// <param name="platform">Platform label.</param> |
| | | 1162 | | /// <param name="serviceName">Service name.</param> |
| | | 1163 | | /// <param name="exitCode">Process exit code.</param> |
| | | 1164 | | /// <param name="configuredPath">Optional configured log path.</param> |
| | | 1165 | | private static void WriteServiceOperationResult(string operation, string platform, string serviceName, int exitCode, |
| | | 1166 | | { |
| | 1 | 1167 | | var result = exitCode == 0 ? "success" : "failed"; |
| | 1 | 1168 | | WriteServiceOperationLog( |
| | 1 | 1169 | | $"operation='{operation}' service='{serviceName}' platform='{platform}' result='{result}' exitCode={exitCode |
| | 1 | 1170 | | configuredPath, |
| | 1 | 1171 | | serviceName); |
| | 1 | 1172 | | } |
| | | 1173 | | |
| | | 1174 | | /// <summary> |
| | | 1175 | | /// Resolves the service operation log path from user input, service config, or defaults. |
| | | 1176 | | /// </summary> |
| | | 1177 | | /// <param name="configuredPath">Optional configured log path.</param> |
| | | 1178 | | /// <param name="serviceName">Optional service name for discovery from service config.</param> |
| | | 1179 | | /// <returns>Absolute log file path.</returns> |
| | | 1180 | | private static string ResolveServiceOperationLogPath(string? configuredPath, string? serviceName) |
| | | 1181 | | { |
| | 7 | 1182 | | var defaultFileName = "kestrun-tool-service.log"; |
| | 7 | 1183 | | var defaultPath = RunnerRuntime.ResolveBootstrapLogPath(null, defaultFileName); |
| | | 1184 | | |
| | 7 | 1185 | | if (!string.IsNullOrWhiteSpace(configuredPath)) |
| | | 1186 | | { |
| | 4 | 1187 | | return NormalizeServiceLogPath(configuredPath, defaultFileName); |
| | | 1188 | | } |
| | | 1189 | | // When no explicit path is configured, attempt to discover a --service-log-path from the service config for bet |
| | 3 | 1190 | | return OperatingSystem.IsWindows() && !string.IsNullOrWhiteSpace(serviceName) |
| | 3 | 1191 | | && TryGetWindowsServiceLogPath(serviceName, out var discoveredPath) |
| | 3 | 1192 | | && !string.IsNullOrWhiteSpace(discoveredPath) |
| | 3 | 1193 | | ? discoveredPath |
| | 3 | 1194 | | : defaultPath; |
| | | 1195 | | } |
| | | 1196 | | |
| | | 1197 | | /// <summary> |
| | | 1198 | | /// Tries to read the configured --service-log-path from a Windows service ImagePath. |
| | | 1199 | | /// </summary> |
| | | 1200 | | /// <param name="serviceName">Service name.</param> |
| | | 1201 | | /// <param name="logPath">Discovered log path.</param> |
| | | 1202 | | /// <returns>True when a log path could be discovered.</returns> |
| | | 1203 | | private static bool TryGetWindowsServiceLogPath(string serviceName, out string? logPath) |
| | | 1204 | | { |
| | 0 | 1205 | | logPath = null; |
| | 0 | 1206 | | var queryResult = RunProcess("sc.exe", ["qc", serviceName], writeStandardOutput: false); |
| | 0 | 1207 | | if (queryResult.ExitCode != 0) |
| | | 1208 | | { |
| | 0 | 1209 | | return false; |
| | | 1210 | | } |
| | | 1211 | | |
| | 0 | 1212 | | var text = string.Concat(queryResult.Output, Environment.NewLine, queryResult.Error); |
| | 0 | 1213 | | var match = ServiceLogPathRegex().Match(text); |
| | | 1214 | | |
| | 0 | 1215 | | if (!match.Success) |
| | | 1216 | | { |
| | 0 | 1217 | | return false; |
| | | 1218 | | } |
| | | 1219 | | |
| | 0 | 1220 | | var rawPath = match.Groups["quoted"].Success |
| | 0 | 1221 | | ? match.Groups["quoted"].Value |
| | 0 | 1222 | | : match.Groups["plain"].Value; |
| | | 1223 | | |
| | 0 | 1224 | | if (string.IsNullOrWhiteSpace(rawPath)) |
| | | 1225 | | { |
| | 0 | 1226 | | return false; |
| | | 1227 | | } |
| | | 1228 | | |
| | 0 | 1229 | | logPath = NormalizeServiceLogPath(rawPath, defaultFileName: "kestrun-tool-service.log"); |
| | 0 | 1230 | | return true; |
| | | 1231 | | } |
| | | 1232 | | |
| | | 1233 | | /// <summary> |
| | | 1234 | | /// Resolves the runtime executable path from a Kestrun module manifest directory. |
| | | 1235 | | /// </summary> |
| | | 1236 | | /// <param name="moduleManifestPath">Path to Kestrun.psd1.</param> |
| | | 1237 | | /// <param name="runtimeExecutablePath">Resolved runtime executable path.</param> |
| | | 1238 | | /// <param name="error">Error details when resolution fails.</param> |
| | | 1239 | | /// <returns>True when a runtime executable is available for the current OS/architecture.</returns> |
| | | 1240 | | private static bool TryResolveServiceRuntimeExecutableFromModule(string moduleManifestPath, out string runtimeExecut |
| | | 1241 | | { |
| | 6 | 1242 | | runtimeExecutablePath = string.Empty; |
| | 6 | 1243 | | error = string.Empty; |
| | | 1244 | | |
| | 6 | 1245 | | var fullManifestPath = Path.GetFullPath(moduleManifestPath); |
| | 6 | 1246 | | var moduleRoot = Path.GetDirectoryName(fullManifestPath); |
| | 6 | 1247 | | if (string.IsNullOrWhiteSpace(moduleRoot) || !Directory.Exists(moduleRoot)) |
| | | 1248 | | { |
| | 0 | 1249 | | error = $"Unable to resolve module root from manifest path: {fullManifestPath}"; |
| | 0 | 1250 | | return false; |
| | | 1251 | | } |
| | | 1252 | | |
| | 6 | 1253 | | if (!TryGetServiceRuntimeRid(out var runtimeRid, out var ridError)) |
| | | 1254 | | { |
| | 0 | 1255 | | error = ridError; |
| | 0 | 1256 | | return false; |
| | | 1257 | | } |
| | | 1258 | | |
| | 6 | 1259 | | var runtimeBinaryName = OperatingSystem.IsWindows() ? WindowsServiceRuntimeBinaryName : UnixServiceRuntimeBinary |
| | 26 | 1260 | | foreach (var candidate in EnumerateServiceRuntimeExecutableCandidates(moduleRoot, runtimeRid, runtimeBinaryName) |
| | | 1261 | | { |
| | 10 | 1262 | | if (!File.Exists(candidate)) |
| | | 1263 | | { |
| | | 1264 | | continue; |
| | | 1265 | | } |
| | | 1266 | | |
| | 6 | 1267 | | runtimeExecutablePath = Path.GetFullPath(candidate); |
| | 6 | 1268 | | return true; |
| | | 1269 | | } |
| | | 1270 | | |
| | | 1271 | | // Module distributions may intentionally omit tool runtime binaries. |
| | | 1272 | | // In that case, reuse the dedicated service-host payload as the runner executable. |
| | 0 | 1273 | | if (TryResolveDedicatedServiceHostExecutableFromToolDistribution(out var serviceHostExecutablePath)) |
| | | 1274 | | { |
| | 0 | 1275 | | runtimeExecutablePath = serviceHostExecutablePath; |
| | 0 | 1276 | | return true; |
| | | 1277 | | } |
| | | 1278 | | |
| | | 1279 | | // Final fallback for non-standard layouts: use the current process executable path when available. |
| | 0 | 1280 | | if (!string.IsNullOrWhiteSpace(Environment.ProcessPath) && File.Exists(Environment.ProcessPath)) |
| | | 1281 | | { |
| | 0 | 1282 | | runtimeExecutablePath = Path.GetFullPath(Environment.ProcessPath); |
| | 0 | 1283 | | return true; |
| | | 1284 | | } |
| | | 1285 | | |
| | 0 | 1286 | | error = $"Unable to locate service runner executable for '{runtimeRid}'. Checked module path '{moduleRoot}', fal |
| | 0 | 1287 | | return false; |
| | 6 | 1288 | | } |
| | | 1289 | | |
| | | 1290 | | /// <summary> |
| | | 1291 | | /// Enumerates candidate runtime executable paths for service bundle staging. |
| | | 1292 | | /// </summary> |
| | | 1293 | | /// <param name="moduleRoot">Resolved module root path.</param> |
| | | 1294 | | /// <param name="runtimeRid">Runtime identifier segment (for example, win-x64).</param> |
| | | 1295 | | /// <param name="runtimeBinaryName">Runtime executable file name.</param> |
| | | 1296 | | /// <returns>Candidate runtime executable paths in resolution priority order.</returns> |
| | | 1297 | | private static IEnumerable<string> EnumerateServiceRuntimeExecutableCandidates(string moduleRoot, string runtimeRid, |
| | | 1298 | | { |
| | 6 | 1299 | | var candidates = new List<string> |
| | 6 | 1300 | | { |
| | 6 | 1301 | | Path.Combine(moduleRoot, "runtimes", runtimeRid, runtimeBinaryName), |
| | 6 | 1302 | | Path.Combine(moduleRoot, "lib", "runtimes", runtimeRid, runtimeBinaryName), |
| | 6 | 1303 | | Path.Combine(GetExecutableDirectory(), "runtimes", runtimeRid, runtimeBinaryName), |
| | 6 | 1304 | | Path.Combine(GetExecutableDirectory(), "lib", "runtimes", runtimeRid, runtimeBinaryName), |
| | 6 | 1305 | | }; |
| | | 1306 | | |
| | 6 | 1307 | | var baseDirectory = Path.GetFullPath(AppContext.BaseDirectory); |
| | 6 | 1308 | | var executableDirectory = GetExecutableDirectory(); |
| | 6 | 1309 | | if (!string.Equals(baseDirectory, executableDirectory, StringComparison.OrdinalIgnoreCase)) |
| | | 1310 | | { |
| | 6 | 1311 | | candidates.Add(Path.Combine(baseDirectory, "runtimes", runtimeRid, runtimeBinaryName)); |
| | 6 | 1312 | | candidates.Add(Path.Combine(baseDirectory, "lib", "runtimes", runtimeRid, runtimeBinaryName)); |
| | | 1313 | | } |
| | | 1314 | | |
| | 84 | 1315 | | foreach (var parent in EnumerateDirectoryAndParents(Environment.CurrentDirectory)) |
| | | 1316 | | { |
| | 36 | 1317 | | candidates.Add(Path.Combine(parent, "src", "PowerShell", "Kestrun", "runtimes", runtimeRid, runtimeBinaryNam |
| | 36 | 1318 | | candidates.Add(Path.Combine(parent, "src", "PowerShell", "Kestrun", "lib", "runtimes", runtimeRid, runtimeBi |
| | | 1319 | | } |
| | | 1320 | | |
| | 26 | 1321 | | foreach (var candidate in candidates.Distinct(StringComparer.OrdinalIgnoreCase)) |
| | | 1322 | | { |
| | 10 | 1323 | | yield return candidate; |
| | | 1324 | | } |
| | 0 | 1325 | | } |
| | | 1326 | | |
| | | 1327 | | /// <summary> |
| | | 1328 | | /// Tries to resolve a dedicated service-host executable path from the Kestrun.Tool distribution. |
| | | 1329 | | /// </summary> |
| | | 1330 | | /// <param name="serviceHostExecutablePath">Resolved service-host executable path when available.</param> |
| | | 1331 | | /// <returns>True when a dedicated service-host executable is available.</returns> |
| | | 1332 | | private static bool TryResolveDedicatedServiceHostExecutableFromToolDistribution(out string serviceHostExecutablePat |
| | | 1333 | | { |
| | 5 | 1334 | | serviceHostExecutablePath = string.Empty; |
| | 5 | 1335 | | if (!TryGetServiceRuntimeRid(out var runtimeRid, out _)) |
| | | 1336 | | { |
| | 0 | 1337 | | return false; |
| | | 1338 | | } |
| | | 1339 | | |
| | 5 | 1340 | | var hostBinaryName = OperatingSystem.IsWindows() ? "kestrun-service-host.exe" : "kestrun-service-host"; |
| | 39 | 1341 | | foreach (var candidate in EnumerateDedicatedServiceHostCandidates(runtimeRid, hostBinaryName)) |
| | | 1342 | | { |
| | 17 | 1343 | | if (!File.Exists(candidate)) |
| | | 1344 | | { |
| | | 1345 | | continue; |
| | | 1346 | | } |
| | | 1347 | | |
| | 5 | 1348 | | serviceHostExecutablePath = Path.GetFullPath(candidate); |
| | 5 | 1349 | | return true; |
| | | 1350 | | } |
| | | 1351 | | |
| | 0 | 1352 | | return false; |
| | 5 | 1353 | | } |
| | | 1354 | | |
| | | 1355 | | /// <summary> |
| | | 1356 | | /// Tries to resolve bundled PowerShell Modules payload from the Kestrun.Tool distribution. |
| | | 1357 | | /// </summary> |
| | | 1358 | | /// <param name="modulesPayloadPath">Resolved modules payload path when available.</param> |
| | | 1359 | | /// <returns>True when the modules payload is available.</returns> |
| | | 1360 | | private static bool TryResolvePowerShellModulesPayloadFromToolDistribution(out string modulesPayloadPath) |
| | | 1361 | | { |
| | 3 | 1362 | | modulesPayloadPath = string.Empty; |
| | 3 | 1363 | | if (!TryGetServiceRuntimeRid(out var runtimeRid, out _)) |
| | | 1364 | | { |
| | 0 | 1365 | | return false; |
| | | 1366 | | } |
| | | 1367 | | |
| | 27 | 1368 | | foreach (var candidate in EnumeratePowerShellModulesPayloadCandidates(runtimeRid)) |
| | | 1369 | | { |
| | 12 | 1370 | | if (!Directory.Exists(candidate)) |
| | | 1371 | | { |
| | | 1372 | | continue; |
| | | 1373 | | } |
| | | 1374 | | |
| | 3 | 1375 | | modulesPayloadPath = Path.GetFullPath(candidate); |
| | 3 | 1376 | | return true; |
| | | 1377 | | } |
| | | 1378 | | |
| | 0 | 1379 | | return false; |
| | 3 | 1380 | | } |
| | | 1381 | | |
| | | 1382 | | /// <summary> |
| | | 1383 | | /// Enumerates candidate service-host paths shipped with Kestrun.Tool for the target RID. |
| | | 1384 | | /// </summary> |
| | | 1385 | | /// <param name="runtimeRid">Runtime identifier segment (for example, win-x64).</param> |
| | | 1386 | | /// <param name="hostBinaryName">Service-host executable file name.</param> |
| | | 1387 | | /// <returns>Candidate service-host paths in resolution priority order.</returns> |
| | | 1388 | | private static IEnumerable<string> EnumerateDedicatedServiceHostCandidates(string runtimeRid, string hostBinaryName) |
| | | 1389 | | { |
| | 5 | 1390 | | var candidates = new List<string>(); |
| | | 1391 | | |
| | | 1392 | | // 1. Development/source path: ./src/CSharp/Kestrun.Tool/kestrun-service/<rid>/ |
| | | 1393 | | // Prefer this during local builds/tests to avoid accidentally selecting a stale globally installed tool payload |
| | 76 | 1394 | | foreach (var parent in EnumerateDirectoryAndParents(Environment.CurrentDirectory)) |
| | | 1395 | | { |
| | 33 | 1396 | | candidates.Add(Path.Combine(parent, "src", "CSharp", "Kestrun.Tool", "kestrun-service", runtimeRid, hostBina |
| | | 1397 | | } |
| | | 1398 | | |
| | | 1399 | | // 2. Dotnet tool store path: ~/.dotnet/tools/.store/kestrun.tool/<version>/ |
| | 5 | 1400 | | var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); |
| | 5 | 1401 | | if (!string.IsNullOrWhiteSpace(homeDirectory)) |
| | | 1402 | | { |
| | 5 | 1403 | | var toolStorePath = Path.Combine(homeDirectory, ".dotnet", "tools", ".store", "kestrun.tool"); |
| | 5 | 1404 | | if (Directory.Exists(toolStorePath)) |
| | | 1405 | | { |
| | 20 | 1406 | | foreach (var versionDir in Directory.GetDirectories(toolStorePath)) |
| | | 1407 | | { |
| | 5 | 1408 | | candidates.Add(Path.Combine(versionDir, "kestrun.tool", Path.GetFileName(versionDir), "tools", "net1 |
| | | 1409 | | } |
| | | 1410 | | } |
| | | 1411 | | } |
| | | 1412 | | |
| | 39 | 1413 | | foreach (var candidate in candidates.Distinct(StringComparer.OrdinalIgnoreCase)) |
| | | 1414 | | { |
| | 17 | 1415 | | yield return candidate; |
| | | 1416 | | } |
| | 0 | 1417 | | } |
| | | 1418 | | |
| | | 1419 | | /// <summary> |
| | | 1420 | | /// Enumerates candidate PowerShell Modules payload paths shipped with Kestrun.Tool for the target RID. |
| | | 1421 | | /// </summary> |
| | | 1422 | | /// <param name="runtimeRid">Runtime identifier segment (for example, win-x64).</param> |
| | | 1423 | | /// <returns>Candidate modules payload paths in resolution priority order.</returns> |
| | | 1424 | | private static IEnumerable<string> EnumeratePowerShellModulesPayloadCandidates(string runtimeRid) |
| | | 1425 | | { |
| | 3 | 1426 | | var executableDirectory = GetExecutableDirectory(); |
| | 3 | 1427 | | var baseDirectory = Path.GetFullPath(AppContext.BaseDirectory); |
| | 3 | 1428 | | var candidates = new List<string> |
| | 3 | 1429 | | { |
| | 3 | 1430 | | Path.Combine(executableDirectory, "kestrun-service", runtimeRid, "Modules"), |
| | 3 | 1431 | | Path.Combine(baseDirectory, "kestrun-service", runtimeRid, "Modules"), |
| | 3 | 1432 | | Path.Combine(executableDirectory, runtimeRid, "Modules"), |
| | 3 | 1433 | | Path.Combine(baseDirectory, runtimeRid, "Modules"), |
| | 3 | 1434 | | Path.Combine(executableDirectory, "runtimes", runtimeRid, "Modules"), |
| | 3 | 1435 | | Path.Combine(baseDirectory, "runtimes", runtimeRid, "Modules"), |
| | 3 | 1436 | | }; |
| | | 1437 | | |
| | 24 | 1438 | | foreach (var parent in EnumerateDirectoryAndParents(Environment.CurrentDirectory)) |
| | | 1439 | | { |
| | 9 | 1440 | | candidates.Add(Path.Combine(parent, "src", "CSharp", "Kestrun.Tool", "kestrun-service", runtimeRid, "Modules |
| | | 1441 | | } |
| | | 1442 | | |
| | 27 | 1443 | | foreach (var candidate in candidates.Distinct(StringComparer.OrdinalIgnoreCase)) |
| | | 1444 | | { |
| | 12 | 1445 | | yield return candidate; |
| | | 1446 | | } |
| | 0 | 1447 | | } |
| | | 1448 | | |
| | | 1449 | | /// <summary> |
| | | 1450 | | /// Enumerates a directory and all parents up to the filesystem root. |
| | | 1451 | | /// </summary> |
| | | 1452 | | /// <param name="startDirectory">Starting directory path.</param> |
| | | 1453 | | /// <returns>Normalized directory path sequence from leaf to root.</returns> |
| | | 1454 | | private static IEnumerable<string> EnumerateDirectoryAndParents(string startDirectory) |
| | | 1455 | | { |
| | 16 | 1456 | | var current = Path.GetFullPath(startDirectory); |
| | 80 | 1457 | | while (!string.IsNullOrWhiteSpace(current)) |
| | | 1458 | | { |
| | 80 | 1459 | | yield return current; |
| | | 1460 | | |
| | 78 | 1461 | | var parent = Directory.GetParent(current); |
| | 78 | 1462 | | if (parent is null) |
| | | 1463 | | { |
| | | 1464 | | break; |
| | | 1465 | | } |
| | | 1466 | | |
| | 64 | 1467 | | current = parent.FullName; |
| | | 1468 | | } |
| | 14 | 1469 | | } |
| | | 1470 | | |
| | | 1471 | | /// <summary> |
| | | 1472 | | /// Resolves service-install script source, including optional content-root semantics. |
| | | 1473 | | /// </summary> |
| | | 1474 | | /// <param name="command">Parsed service command.</param> |
| | | 1475 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 1476 | | /// <param name="error">Error details when validation fails.</param> |
| | | 1477 | | /// <returns>True when script source is valid and exists.</returns> |
| | | 1478 | | private static bool TryResolveServiceScriptSource(ParsedCommand command, out ResolvedServiceScriptSource scriptSourc |
| | | 1479 | | { |
| | 21 | 1480 | | var optionFlags = GetServiceContentRootOptionFlags(command); |
| | 21 | 1481 | | if (!TryClassifyServiceContentRoot(command.ServiceContentRoot, out _, out var contentRootUri, out var fullConten |
| | | 1482 | | { |
| | 1 | 1483 | | var fallbackScriptPath = ResolveRequestedServiceScriptPath(command.ScriptPath, useDefaultWhenMissing: true); |
| | 1 | 1484 | | return TryResolveServiceScriptWithoutContentRoot(fallbackScriptPath, optionFlags, out scriptSource, out erro |
| | | 1485 | | } |
| | | 1486 | | |
| | 20 | 1487 | | if (command.Mode == CommandMode.ServiceInstall && command.ServiceNameProvided) |
| | | 1488 | | { |
| | 0 | 1489 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | 0 | 1490 | | error = "--name is no longer supported for service install. Define Name in Service.psd1 inside the package." |
| | 0 | 1491 | | return false; |
| | | 1492 | | } |
| | | 1493 | | |
| | 20 | 1494 | | if (command.ScriptPathProvided) |
| | | 1495 | | { |
| | 0 | 1496 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | 0 | 1497 | | error = "An explicit script path is not supported when --package is used. Define EntryPoint in Service.psd1 |
| | 0 | 1498 | | return false; |
| | | 1499 | | } |
| | | 1500 | | |
| | 20 | 1501 | | var requestedScriptPath = ResolveRequestedServiceScriptPath(command.ScriptPath, useDefaultWhenMissing: false); |
| | | 1502 | | // When a content-root value is supplied, attempt to resolve the script source from the content root, even if th |
| | | 1503 | | // since some content-root scenarios imply a default script name. |
| | 20 | 1504 | | return TryResolveServiceScriptFromContentRoot( |
| | 20 | 1505 | | command, |
| | 20 | 1506 | | requestedScriptPath, |
| | 20 | 1507 | | contentRootUri, |
| | 20 | 1508 | | fullContentRoot, |
| | 20 | 1509 | | optionFlags, |
| | 20 | 1510 | | out scriptSource, |
| | 20 | 1511 | | out error); |
| | | 1512 | | } |
| | | 1513 | | |
| | | 1514 | | /// <summary> |
| | | 1515 | | /// Classifies service content-root input into normalized local path or HTTP(S) URI forms. |
| | | 1516 | | /// </summary> |
| | | 1517 | | /// <param name="rawContentRoot">Raw content-root token from CLI arguments.</param> |
| | | 1518 | | /// <param name="normalizedContentRoot">Trimmed content-root token.</param> |
| | | 1519 | | /// <param name="contentRootUri">Parsed HTTP(S) URI when the content root is remote; otherwise null.</param> |
| | | 1520 | | /// <param name="fullContentRoot">Normalized absolute local path when the content root is local; otherwise empty.</p |
| | | 1521 | | /// <returns>True when a content-root value exists; false when no content-root was supplied.</returns> |
| | | 1522 | | private static bool TryClassifyServiceContentRoot( |
| | | 1523 | | string? rawContentRoot, |
| | | 1524 | | out string normalizedContentRoot, |
| | | 1525 | | out Uri? contentRootUri, |
| | | 1526 | | out string fullContentRoot) |
| | | 1527 | | { |
| | 23 | 1528 | | normalizedContentRoot = string.Empty; |
| | 23 | 1529 | | contentRootUri = null; |
| | 23 | 1530 | | fullContentRoot = string.Empty; |
| | | 1531 | | |
| | 23 | 1532 | | if (string.IsNullOrWhiteSpace(rawContentRoot)) |
| | | 1533 | | { |
| | 2 | 1534 | | return false; |
| | | 1535 | | } |
| | | 1536 | | |
| | 21 | 1537 | | normalizedContentRoot = rawContentRoot.Trim(); |
| | 21 | 1538 | | if (TryParseServiceContentRootHttpUri(normalizedContentRoot, out var parsedUri)) |
| | | 1539 | | { |
| | 7 | 1540 | | contentRootUri = parsedUri; |
| | 7 | 1541 | | return true; |
| | | 1542 | | } |
| | | 1543 | | |
| | 14 | 1544 | | fullContentRoot = Path.GetFullPath(normalizedContentRoot); |
| | 14 | 1545 | | return true; |
| | | 1546 | | } |
| | | 1547 | | |
| | | 1548 | | /// <summary> |
| | | 1549 | | /// Resolves service script source for a classified content-root input. |
| | | 1550 | | /// </summary> |
| | | 1551 | | /// <param name="command">Parsed service command.</param> |
| | | 1552 | | /// <param name="requestedScriptPath">Requested script path argument.</param> |
| | | 1553 | | /// <param name="contentRootUri">Parsed HTTP(S) content-root URI when applicable.</param> |
| | | 1554 | | /// <param name="fullContentRoot">Absolute local content-root path when applicable.</param> |
| | | 1555 | | /// <param name="optionFlags">Content-root related option usage flags.</param> |
| | | 1556 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 1557 | | /// <param name="error">Error details when resolution fails.</param> |
| | | 1558 | | /// <returns>True when script source resolution succeeds.</returns> |
| | | 1559 | | private static bool TryResolveServiceScriptFromContentRoot( |
| | | 1560 | | ParsedCommand command, |
| | | 1561 | | string requestedScriptPath, |
| | | 1562 | | Uri? contentRootUri, |
| | | 1563 | | string fullContentRoot, |
| | | 1564 | | ServiceContentRootOptionFlags optionFlags, |
| | | 1565 | | out ResolvedServiceScriptSource scriptSource, |
| | | 1566 | | out string error) |
| | | 1567 | | { |
| | 20 | 1568 | | if (contentRootUri is not null) |
| | | 1569 | | { |
| | 6 | 1570 | | return TryResolveServiceScriptFromHttpContentRoot(command, requestedScriptPath, contentRootUri, out scriptSo |
| | | 1571 | | } |
| | | 1572 | | |
| | 14 | 1573 | | if (Directory.Exists(fullContentRoot)) |
| | | 1574 | | { |
| | 6 | 1575 | | return TryResolveServiceScriptFromDirectoryContentRoot(requestedScriptPath, fullContentRoot, optionFlags, ou |
| | | 1576 | | } |
| | | 1577 | | // When content-root is supplied but does not exist as a local directory, attempt to treat it as an archive path |
| | | 1578 | | // to a file without realizing that only directories are supported for local content roots. |
| | 8 | 1579 | | return TryResolveServiceScriptFromArchiveContentRoot(command, requestedScriptPath, fullContentRoot, optionFlags, |
| | | 1580 | | } |
| | | 1581 | | |
| | | 1582 | | /// <summary> |
| | | 1583 | | /// Represents parsed option usage for content-root related arguments. |
| | | 1584 | | /// </summary> |
| | | 1585 | | private readonly record struct ServiceContentRootOptionFlags( |
| | 7 | 1586 | | bool HasArchiveChecksum, |
| | 14 | 1587 | | bool HasBearerToken, |
| | 14 | 1588 | | bool IgnoreCertificate, |
| | 13 | 1589 | | bool HasHeaders); |
| | | 1590 | | |
| | | 1591 | | /// <summary> |
| | | 1592 | | /// Resolves the script path value for service install commands, applying default script fallback. |
| | | 1593 | | /// </summary> |
| | | 1594 | | /// <param name="scriptPath">Requested script path argument.</param> |
| | | 1595 | | /// <param name="useDefaultWhenMissing">True to apply the default script file name when no script path was provided. |
| | | 1596 | | /// <returns>Resolved script path token.</returns> |
| | | 1597 | | private static string ResolveRequestedServiceScriptPath(string scriptPath, bool useDefaultWhenMissing) |
| | 21 | 1598 | | => string.IsNullOrWhiteSpace(scriptPath) |
| | 21 | 1599 | | ? (useDefaultWhenMissing ? ServiceDefaultScriptFileName : string.Empty) |
| | 21 | 1600 | | : scriptPath; |
| | | 1601 | | |
| | | 1602 | | /// <summary> |
| | | 1603 | | /// Captures which content-root related options were supplied on the command line. |
| | | 1604 | | /// </summary> |
| | | 1605 | | /// <param name="command">Parsed service command.</param> |
| | | 1606 | | /// <returns>Normalized option usage flags.</returns> |
| | | 1607 | | private static ServiceContentRootOptionFlags GetServiceContentRootOptionFlags(ParsedCommand command) |
| | 21 | 1608 | | => new( |
| | 21 | 1609 | | !string.IsNullOrWhiteSpace(command.ServiceContentRootChecksum), |
| | 21 | 1610 | | !string.IsNullOrWhiteSpace(command.ServiceContentRootBearerToken), |
| | 21 | 1611 | | command.ServiceContentRootIgnoreCertificate, |
| | 21 | 1612 | | command.ServiceContentRootHeaders.Length > 0); |
| | | 1613 | | |
| | | 1614 | | /// <summary> |
| | | 1615 | | /// Resolves script source when no content-root argument is provided. |
| | | 1616 | | /// </summary> |
| | | 1617 | | /// <param name="requestedScriptPath">Requested script path.</param> |
| | | 1618 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1619 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 1620 | | /// <param name="error">Error details when validation fails.</param> |
| | | 1621 | | /// <returns>True when script resolution succeeds.</returns> |
| | | 1622 | | private static bool TryResolveServiceScriptWithoutContentRoot( |
| | | 1623 | | string requestedScriptPath, |
| | | 1624 | | ServiceContentRootOptionFlags optionFlags, |
| | | 1625 | | out ResolvedServiceScriptSource scriptSource, |
| | | 1626 | | out string error) |
| | | 1627 | | { |
| | 1 | 1628 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | 1 | 1629 | | if (!TryValidateOptionsForMissingContentRoot(optionFlags, out error)) |
| | | 1630 | | { |
| | 0 | 1631 | | return false; |
| | | 1632 | | } |
| | | 1633 | | |
| | 1 | 1634 | | var fullScriptPath = Path.GetFullPath(requestedScriptPath); |
| | 1 | 1635 | | if (!File.Exists(fullScriptPath)) |
| | | 1636 | | { |
| | 0 | 1637 | | error = $"Script file not found: {fullScriptPath}"; |
| | 0 | 1638 | | return false; |
| | | 1639 | | } |
| | | 1640 | | |
| | 1 | 1641 | | scriptSource = new ResolvedServiceScriptSource(fullScriptPath, null, Path.GetFileName(fullScriptPath), null, nul |
| | 1 | 1642 | | error = string.Empty; |
| | 1 | 1643 | | return true; |
| | | 1644 | | } |
| | | 1645 | | |
| | | 1646 | | /// <summary> |
| | | 1647 | | /// Resolves script source when content-root points to an HTTP(S) archive. |
| | | 1648 | | /// </summary> |
| | | 1649 | | /// <param name="command">Parsed service command.</param> |
| | | 1650 | | /// <param name="requestedScriptPath">Requested script path.</param> |
| | | 1651 | | /// <param name="contentRootUri">HTTP(S) archive URI.</param> |
| | | 1652 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1653 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 1654 | | /// <param name="error">Error details when validation fails.</param> |
| | | 1655 | | /// <returns>True when script resolution succeeds.</returns> |
| | | 1656 | | private static bool TryResolveServiceScriptFromHttpContentRoot( |
| | | 1657 | | ParsedCommand command, |
| | | 1658 | | string requestedScriptPath, |
| | | 1659 | | Uri contentRootUri, |
| | | 1660 | | out ResolvedServiceScriptSource scriptSource, |
| | | 1661 | | out string error) |
| | | 1662 | | { |
| | 6 | 1663 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | 6 | 1664 | | if (!TryValidateHttpContentRootScriptPath(requestedScriptPath, out error)) |
| | | 1665 | | { |
| | 0 | 1666 | | return false; |
| | | 1667 | | } |
| | | 1668 | | |
| | 6 | 1669 | | var temporaryRoot = CreateServiceContentRootExtractionDirectory(command.ServiceName); |
| | 6 | 1670 | | var downloadedContentRoot = Path.Combine(temporaryRoot, "content"); |
| | 6 | 1671 | | _ = Directory.CreateDirectory(downloadedContentRoot); |
| | | 1672 | | |
| | | 1673 | | try |
| | | 1674 | | { |
| | 6 | 1675 | | if (!TryDownloadAndExtractHttpContentRoot(command, contentRootUri, temporaryRoot, downloadedContentRoot, out |
| | | 1676 | | { |
| | 3 | 1677 | | TryDeleteDirectoryWithRetry(temporaryRoot, maxAttempts: 5, initialDelayMs: 50); |
| | 3 | 1678 | | return false; |
| | | 1679 | | } |
| | | 1680 | | |
| | 3 | 1681 | | if (!TryResolveServiceInstallDescriptor(downloadedContentRoot, out var descriptor, out error)) |
| | | 1682 | | { |
| | 0 | 1683 | | TryDeleteDirectoryWithRetry(temporaryRoot, maxAttempts: 5, initialDelayMs: 50); |
| | 0 | 1684 | | return false; |
| | | 1685 | | } |
| | | 1686 | | |
| | 3 | 1687 | | if (!TryResolveServiceDescriptorScriptPath(requestedScriptPath, descriptor, out var resolvedScriptPath, out |
| | | 1688 | | { |
| | 0 | 1689 | | TryDeleteDirectoryWithRetry(temporaryRoot, maxAttempts: 5, initialDelayMs: 50); |
| | 0 | 1690 | | return false; |
| | | 1691 | | } |
| | | 1692 | | |
| | 3 | 1693 | | if (!TryResolveScriptFromResolvedContentRoot( |
| | 3 | 1694 | | resolvedScriptPath, |
| | 3 | 1695 | | downloadedContentRoot, |
| | 3 | 1696 | | $"Script path '{resolvedScriptPath}' escapes the extracted archive content root.", |
| | 3 | 1697 | | $"Script file '{resolvedScriptPath}' was not found inside extracted archive downloaded from '{conten |
| | 3 | 1698 | | temporaryRoot, |
| | 3 | 1699 | | out scriptSource, |
| | 3 | 1700 | | out error)) |
| | | 1701 | | { |
| | 0 | 1702 | | TryDeleteDirectoryWithRetry(temporaryRoot, maxAttempts: 5, initialDelayMs: 50); |
| | 0 | 1703 | | return false; |
| | | 1704 | | } |
| | | 1705 | | |
| | 3 | 1706 | | scriptSource = ApplyDescriptorMetadata(scriptSource, descriptor); |
| | | 1707 | | |
| | 3 | 1708 | | return true; |
| | | 1709 | | } |
| | 0 | 1710 | | catch |
| | | 1711 | | { |
| | 0 | 1712 | | TryDeleteDirectoryWithRetry(temporaryRoot, maxAttempts: 5, initialDelayMs: 50); |
| | 0 | 1713 | | throw; |
| | | 1714 | | } |
| | 6 | 1715 | | } |
| | | 1716 | | |
| | | 1717 | | /// <summary> |
| | | 1718 | | /// Resolves script source when content-root points to a local directory. |
| | | 1719 | | /// </summary> |
| | | 1720 | | /// <param name="requestedScriptPath">Requested script path.</param> |
| | | 1721 | | /// <param name="fullContentRoot">Absolute content-root directory path.</param> |
| | | 1722 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1723 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 1724 | | /// <param name="error">Error details when validation fails.</param> |
| | | 1725 | | /// <returns>True when script resolution succeeds.</returns> |
| | | 1726 | | private static bool TryResolveServiceScriptFromDirectoryContentRoot( |
| | | 1727 | | string requestedScriptPath, |
| | | 1728 | | string fullContentRoot, |
| | | 1729 | | ServiceContentRootOptionFlags optionFlags, |
| | | 1730 | | out ResolvedServiceScriptSource scriptSource, |
| | | 1731 | | out string error) |
| | | 1732 | | { |
| | 6 | 1733 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | 6 | 1734 | | if (!TryValidateDirectoryContentRootOptions(optionFlags, out error)) |
| | | 1735 | | { |
| | 0 | 1736 | | return false; |
| | | 1737 | | } |
| | | 1738 | | |
| | 6 | 1739 | | if (!TryResolveServiceInstallDescriptor(fullContentRoot, out var descriptor, out error)) |
| | | 1740 | | { |
| | 2 | 1741 | | return false; |
| | | 1742 | | } |
| | | 1743 | | |
| | 4 | 1744 | | if (!TryResolveServiceDescriptorScriptPath(requestedScriptPath, descriptor, out var resolvedScriptPath, out erro |
| | | 1745 | | { |
| | 1 | 1746 | | return false; |
| | | 1747 | | } |
| | | 1748 | | |
| | 3 | 1749 | | if (!TryResolveScriptFromResolvedContentRoot( |
| | 3 | 1750 | | resolvedScriptPath, |
| | 3 | 1751 | | fullContentRoot, |
| | 3 | 1752 | | $"Script path '{resolvedScriptPath}' escapes the service content root '{fullContentRoot}'.", |
| | 3 | 1753 | | $"Script file '{resolvedScriptPath}' was not found under service content root '{fullContentRoot}'.", |
| | 3 | 1754 | | null, |
| | 3 | 1755 | | out scriptSource, |
| | 3 | 1756 | | out error)) |
| | | 1757 | | { |
| | 0 | 1758 | | return false; |
| | | 1759 | | } |
| | | 1760 | | |
| | 3 | 1761 | | scriptSource = ApplyDescriptorMetadata(scriptSource, descriptor); |
| | 3 | 1762 | | return true; |
| | | 1763 | | } |
| | | 1764 | | |
| | | 1765 | | /// <summary> |
| | | 1766 | | /// Resolves script source when content-root points to a local archive file. |
| | | 1767 | | /// </summary> |
| | | 1768 | | /// <param name="command">Parsed service command.</param> |
| | | 1769 | | /// <param name="requestedScriptPath">Requested script path.</param> |
| | | 1770 | | /// <param name="fullContentRoot">Absolute archive path.</param> |
| | | 1771 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1772 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 1773 | | /// <param name="error">Error details when validation fails.</param> |
| | | 1774 | | /// <returns>True when script resolution succeeds.</returns> |
| | | 1775 | | private static bool TryResolveServiceScriptFromArchiveContentRoot( |
| | | 1776 | | ParsedCommand command, |
| | | 1777 | | string requestedScriptPath, |
| | | 1778 | | string fullContentRoot, |
| | | 1779 | | ServiceContentRootOptionFlags optionFlags, |
| | | 1780 | | out ResolvedServiceScriptSource scriptSource, |
| | | 1781 | | out string error) |
| | | 1782 | | { |
| | 8 | 1783 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | 8 | 1784 | | if (!File.Exists(fullContentRoot)) |
| | | 1785 | | { |
| | 1 | 1786 | | error = $"Service content root path was not found: {fullContentRoot}"; |
| | 1 | 1787 | | return false; |
| | | 1788 | | } |
| | | 1789 | | |
| | 7 | 1790 | | if (!TryValidateLocalArchiveContentRootOptions(optionFlags, out error)) |
| | | 1791 | | { |
| | 2 | 1792 | | return false; |
| | | 1793 | | } |
| | | 1794 | | |
| | 5 | 1795 | | if (!IsSupportedServiceContentRootArchive(fullContentRoot)) |
| | | 1796 | | { |
| | 0 | 1797 | | error = $"Unsupported package format. Supported extensions: {ServicePackageExtension}, .zip, .tar, .tgz, .ta |
| | 0 | 1798 | | return false; |
| | | 1799 | | } |
| | | 1800 | | |
| | 5 | 1801 | | if (!TryValidateServiceContentRootArchiveChecksum(command, fullContentRoot, out error)) |
| | | 1802 | | { |
| | 1 | 1803 | | return false; |
| | | 1804 | | } |
| | | 1805 | | |
| | 4 | 1806 | | var extractedContentRoot = CreateServiceContentRootExtractionDirectory(command.ServiceName); |
| | | 1807 | | try |
| | | 1808 | | { |
| | 4 | 1809 | | if (TryResolveServiceScriptFromExtractedArchiveContentRoot( |
| | 4 | 1810 | | requestedScriptPath, |
| | 4 | 1811 | | fullContentRoot, |
| | 4 | 1812 | | extractedContentRoot, |
| | 4 | 1813 | | out var extractedScriptSource, |
| | 4 | 1814 | | out error)) |
| | | 1815 | | { |
| | 4 | 1816 | | scriptSource = extractedScriptSource; |
| | 4 | 1817 | | return true; |
| | | 1818 | | } |
| | | 1819 | | |
| | 0 | 1820 | | TryDeleteDirectoryWithRetry(extractedContentRoot, maxAttempts: 5, initialDelayMs: 50); |
| | 0 | 1821 | | return false; |
| | | 1822 | | } |
| | 0 | 1823 | | catch |
| | | 1824 | | { |
| | 0 | 1825 | | TryDeleteDirectoryWithRetry(extractedContentRoot, maxAttempts: 5, initialDelayMs: 50); |
| | 0 | 1826 | | throw; |
| | | 1827 | | } |
| | 4 | 1828 | | } |
| | | 1829 | | |
| | | 1830 | | /// <summary> |
| | | 1831 | | /// Resolves service script source from an already-created extraction directory for a local archive content root. |
| | | 1832 | | /// </summary> |
| | | 1833 | | /// <param name="requestedScriptPath">Requested script path.</param> |
| | | 1834 | | /// <param name="fullContentRoot">Absolute archive path.</param> |
| | | 1835 | | /// <param name="extractedContentRoot">Archive extraction directory path.</param> |
| | | 1836 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 1837 | | /// <param name="error">Error details when validation fails.</param> |
| | | 1838 | | /// <returns>True when script source resolution succeeds.</returns> |
| | | 1839 | | private static bool TryResolveServiceScriptFromExtractedArchiveContentRoot( |
| | | 1840 | | string requestedScriptPath, |
| | | 1841 | | string fullContentRoot, |
| | | 1842 | | string extractedContentRoot, |
| | | 1843 | | out ResolvedServiceScriptSource scriptSource, |
| | | 1844 | | out string error) |
| | | 1845 | | { |
| | 4 | 1846 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | | 1847 | | |
| | 4 | 1848 | | if (!TryExtractServiceContentRootArchive(fullContentRoot, extractedContentRoot, out error)) |
| | | 1849 | | { |
| | 0 | 1850 | | return false; |
| | | 1851 | | } |
| | | 1852 | | |
| | 4 | 1853 | | if (!TryResolveServiceInstallDescriptor(extractedContentRoot, out var descriptor, out error)) |
| | | 1854 | | { |
| | 0 | 1855 | | return false; |
| | | 1856 | | } |
| | | 1857 | | |
| | 4 | 1858 | | if (!TryResolveServiceDescriptorScriptPath(requestedScriptPath, descriptor, out var resolvedScriptPath, out erro |
| | | 1859 | | { |
| | 0 | 1860 | | return false; |
| | | 1861 | | } |
| | | 1862 | | |
| | 4 | 1863 | | if (!TryResolveScriptFromResolvedContentRoot( |
| | 4 | 1864 | | resolvedScriptPath, |
| | 4 | 1865 | | extractedContentRoot, |
| | 4 | 1866 | | $"Script path '{resolvedScriptPath}' escapes the extracted archive content root.", |
| | 4 | 1867 | | $"Script file '{resolvedScriptPath}' was not found inside extracted archive '{fullContentRoot}'.", |
| | 4 | 1868 | | extractedContentRoot, |
| | 4 | 1869 | | out scriptSource, |
| | 4 | 1870 | | out error)) |
| | | 1871 | | { |
| | 0 | 1872 | | return false; |
| | | 1873 | | } |
| | | 1874 | | |
| | 4 | 1875 | | scriptSource = ApplyDescriptorMetadata(scriptSource, descriptor); |
| | 4 | 1876 | | return true; |
| | | 1877 | | } |
| | | 1878 | | |
| | | 1879 | | /// <summary> |
| | | 1880 | | /// Validates content-root options when no content-root argument was supplied. |
| | | 1881 | | /// </summary> |
| | | 1882 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1883 | | /// <param name="error">Validation error message when invalid combinations are detected.</param> |
| | | 1884 | | /// <returns>True when the option combination is valid.</returns> |
| | | 1885 | | private static bool TryValidateOptionsForMissingContentRoot(ServiceContentRootOptionFlags optionFlags, out string er |
| | | 1886 | | { |
| | 1 | 1887 | | if (optionFlags.HasArchiveChecksum) |
| | | 1888 | | { |
| | 0 | 1889 | | error = "--content-root-checksum requires --content-root."; |
| | 0 | 1890 | | return false; |
| | | 1891 | | } |
| | | 1892 | | |
| | 1 | 1893 | | if (optionFlags.HasBearerToken) |
| | | 1894 | | { |
| | 0 | 1895 | | error = "--content-root-bearer-token requires --content-root."; |
| | 0 | 1896 | | return false; |
| | | 1897 | | } |
| | | 1898 | | |
| | 1 | 1899 | | if (optionFlags.IgnoreCertificate) |
| | | 1900 | | { |
| | 0 | 1901 | | error = "--content-root-ignore-certificate requires --content-root."; |
| | 0 | 1902 | | return false; |
| | | 1903 | | } |
| | | 1904 | | |
| | 1 | 1905 | | if (optionFlags.HasHeaders) |
| | | 1906 | | { |
| | 0 | 1907 | | error = "--content-root-header requires --content-root."; |
| | 0 | 1908 | | return false; |
| | | 1909 | | } |
| | | 1910 | | |
| | 1 | 1911 | | error = string.Empty; |
| | 1 | 1912 | | return true; |
| | | 1913 | | } |
| | | 1914 | | |
| | | 1915 | | /// <summary> |
| | | 1916 | | /// Validates URL-only options for non-URL content roots. |
| | | 1917 | | /// </summary> |
| | | 1918 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1919 | | /// <param name="error">Validation error message when invalid combinations are detected.</param> |
| | | 1920 | | /// <returns>True when URL-only options were not supplied.</returns> |
| | | 1921 | | private static bool TryValidateUrlOnlyContentRootOptions(ServiceContentRootOptionFlags optionFlags, out string error |
| | | 1922 | | { |
| | 13 | 1923 | | if (optionFlags.HasBearerToken) |
| | | 1924 | | { |
| | 0 | 1925 | | error = "--content-root-bearer-token is only supported when --content-root points to an HTTP(S) archive URL. |
| | 0 | 1926 | | return false; |
| | | 1927 | | } |
| | | 1928 | | |
| | 13 | 1929 | | if (optionFlags.IgnoreCertificate) |
| | | 1930 | | { |
| | 1 | 1931 | | error = "--content-root-ignore-certificate is only supported when --content-root points to an HTTPS archive |
| | 1 | 1932 | | return false; |
| | | 1933 | | } |
| | | 1934 | | |
| | 12 | 1935 | | if (optionFlags.HasHeaders) |
| | | 1936 | | { |
| | 1 | 1937 | | error = "--content-root-header is only supported when --content-root points to an HTTP(S) archive URL."; |
| | 1 | 1938 | | return false; |
| | | 1939 | | } |
| | | 1940 | | |
| | 11 | 1941 | | error = string.Empty; |
| | 11 | 1942 | | return true; |
| | | 1943 | | } |
| | | 1944 | | |
| | | 1945 | | /// <summary> |
| | | 1946 | | /// Validates option combinations for directory-based content roots. |
| | | 1947 | | /// </summary> |
| | | 1948 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1949 | | /// <param name="error">Validation error message when invalid combinations are detected.</param> |
| | | 1950 | | /// <returns>True when the option combination is valid.</returns> |
| | | 1951 | | private static bool TryValidateDirectoryContentRootOptions(ServiceContentRootOptionFlags optionFlags, out string err |
| | | 1952 | | { |
| | 6 | 1953 | | if (optionFlags.HasArchiveChecksum) |
| | | 1954 | | { |
| | 0 | 1955 | | error = "--content-root-checksum is only supported when --content-root points to an archive file."; |
| | 0 | 1956 | | return false; |
| | | 1957 | | } |
| | | 1958 | | |
| | 6 | 1959 | | return TryValidateUrlOnlyContentRootOptions(optionFlags, out error); |
| | | 1960 | | } |
| | | 1961 | | |
| | | 1962 | | /// <summary> |
| | | 1963 | | /// Validates option combinations for local archive content roots. |
| | | 1964 | | /// </summary> |
| | | 1965 | | /// <param name="optionFlags">Content-root related option flags.</param> |
| | | 1966 | | /// <param name="error">Validation error message when invalid combinations are detected.</param> |
| | | 1967 | | /// <returns>True when the option combination is valid.</returns> |
| | | 1968 | | private static bool TryValidateLocalArchiveContentRootOptions(ServiceContentRootOptionFlags optionFlags, out string |
| | 7 | 1969 | | => TryValidateUrlOnlyContentRootOptions(optionFlags, out error); |
| | | 1970 | | |
| | | 1971 | | /// <summary> |
| | | 1972 | | /// Validates script path shape for HTTP archive content roots. |
| | | 1973 | | /// </summary> |
| | | 1974 | | /// <param name="requestedScriptPath">Requested script path.</param> |
| | | 1975 | | /// <param name="error">Validation error text.</param> |
| | | 1976 | | /// <returns>True when the script path is valid for URL archive usage.</returns> |
| | | 1977 | | private static bool TryValidateHttpContentRootScriptPath(string requestedScriptPath, out string error) |
| | | 1978 | | { |
| | 6 | 1979 | | if (!string.IsNullOrWhiteSpace(requestedScriptPath) && Path.IsPathRooted(requestedScriptPath)) |
| | | 1980 | | { |
| | 0 | 1981 | | error = "When --content-root is a URL archive, --script must be a relative path inside the archive."; |
| | 0 | 1982 | | return false; |
| | | 1983 | | } |
| | | 1984 | | |
| | 6 | 1985 | | error = string.Empty; |
| | 6 | 1986 | | return true; |
| | | 1987 | | } |
| | | 1988 | | |
| | | 1989 | | /// <summary> |
| | | 1990 | | /// Reads and validates Service.psd1 from a resolved service content-root folder. |
| | | 1991 | | /// </summary> |
| | | 1992 | | /// <param name="fullContentRoot">Absolute content-root directory path.</param> |
| | | 1993 | | /// <param name="descriptor">Resolved and validated descriptor metadata.</param> |
| | | 1994 | | /// <param name="error">Validation error details.</param> |
| | | 1995 | | /// <returns>True when descriptor exists and mandatory metadata is valid.</returns> |
| | | 1996 | | private static bool TryResolveServiceInstallDescriptor(string fullContentRoot, out ServiceInstallDescriptor descript |
| | | 1997 | | { |
| | 21 | 1998 | | descriptor = new ServiceInstallDescriptor(string.Empty, string.Empty, string.Empty, string.Empty, null, null, [] |
| | 21 | 1999 | | if (!TryReadNormalizedServiceDescriptorText(fullContentRoot, out var descriptorText, out error)) |
| | | 2000 | | { |
| | 0 | 2001 | | return false; |
| | | 2002 | | } |
| | | 2003 | | |
| | 21 | 2004 | | if (!TryResolveServiceDescriptorCoreFields(descriptorText, out var name, out var description, out var formatVers |
| | | 2005 | | { |
| | 1 | 2006 | | return false; |
| | | 2007 | | } |
| | | 2008 | | |
| | 20 | 2009 | | if (!TryResolveServiceDescriptorEntryPointAndVersion( |
| | 20 | 2010 | | descriptorText, |
| | 20 | 2011 | | formatVersion, |
| | 20 | 2012 | | out var normalizedFormatVersion, |
| | 20 | 2013 | | out var entryPoint, |
| | 20 | 2014 | | out var version, |
| | 20 | 2015 | | out error)) |
| | | 2016 | | { |
| | 1 | 2017 | | return false; |
| | | 2018 | | } |
| | | 2019 | | |
| | 19 | 2020 | | _ = TryGetServiceDescriptorStringValue(descriptorText, "ServiceLogPath", required: false, out var serviceLogPath |
| | | 2021 | | |
| | 19 | 2022 | | if (!TryGetServiceDescriptorStringArrayValue(descriptorText, "PreservePaths", out var preservePaths, out error)) |
| | | 2023 | | { |
| | 0 | 2024 | | return false; |
| | | 2025 | | } |
| | | 2026 | | |
| | 19 | 2027 | | if (!TryGetServiceDescriptorStringArrayValue(descriptorText, "ApplicationDataFolders", out var applicationDataFo |
| | | 2028 | | { |
| | 0 | 2029 | | return false; |
| | | 2030 | | } |
| | | 2031 | | |
| | 19 | 2032 | | descriptor = new ServiceInstallDescriptor( |
| | 19 | 2033 | | normalizedFormatVersion, |
| | 19 | 2034 | | name, |
| | 19 | 2035 | | entryPoint, |
| | 19 | 2036 | | description, |
| | 19 | 2037 | | version, |
| | 19 | 2038 | | string.IsNullOrWhiteSpace(serviceLogPath) ? null : serviceLogPath, |
| | 19 | 2039 | | preservePaths, |
| | 19 | 2040 | | applicationDataFolders); |
| | 19 | 2041 | | return true; |
| | | 2042 | | } |
| | | 2043 | | |
| | | 2044 | | /// <summary> |
| | | 2045 | | /// Reads service descriptor text from disk and normalizes escaped newlines for regex parsing. |
| | | 2046 | | /// </summary> |
| | | 2047 | | /// <param name="fullContentRoot">Absolute content-root directory path.</param> |
| | | 2048 | | /// <param name="descriptorText">Normalized service descriptor text.</param> |
| | | 2049 | | /// <param name="error">Error details when file resolution or read fails.</param> |
| | | 2050 | | /// <returns>True when descriptor text is available and normalized.</returns> |
| | | 2051 | | private static bool TryReadNormalizedServiceDescriptorText(string fullContentRoot, out string descriptorText, out st |
| | | 2052 | | { |
| | 21 | 2053 | | descriptorText = string.Empty; |
| | 21 | 2054 | | var descriptorPath = Path.Combine(fullContentRoot, ServiceDescriptorFileName); |
| | 21 | 2055 | | if (!File.Exists(descriptorPath)) |
| | | 2056 | | { |
| | 0 | 2057 | | error = $"Service descriptor file '{ServiceDescriptorFileName}' was not found at content-root '{fullContentR |
| | 0 | 2058 | | return false; |
| | | 2059 | | } |
| | | 2060 | | |
| | | 2061 | | try |
| | | 2062 | | { |
| | 21 | 2063 | | descriptorText = File.ReadAllText(descriptorPath, Encoding.UTF8); |
| | 21 | 2064 | | } |
| | 0 | 2065 | | catch (Exception ex) |
| | | 2066 | | { |
| | 0 | 2067 | | error = $"Failed to read service descriptor '{descriptorPath}': {ex.Message}"; |
| | 0 | 2068 | | return false; |
| | | 2069 | | } |
| | | 2070 | | |
| | 21 | 2071 | | descriptorText = NormalizeServiceDescriptorText(descriptorText); |
| | 21 | 2072 | | error = string.Empty; |
| | 21 | 2073 | | return true; |
| | 0 | 2074 | | } |
| | | 2075 | | |
| | | 2076 | | /// <summary> |
| | | 2077 | | /// Resolves required descriptor core fields and optional format version. |
| | | 2078 | | /// </summary> |
| | | 2079 | | /// <param name="descriptorText">Normalized service descriptor text.</param> |
| | | 2080 | | /// <param name="name">Resolved service name.</param> |
| | | 2081 | | /// <param name="description">Resolved service description.</param> |
| | | 2082 | | /// <param name="formatVersion">Optional format version token.</param> |
| | | 2083 | | /// <param name="error">Validation error details.</param> |
| | | 2084 | | /// <returns>True when required core fields are valid.</returns> |
| | | 2085 | | private static bool TryResolveServiceDescriptorCoreFields( |
| | | 2086 | | string descriptorText, |
| | | 2087 | | out string name, |
| | | 2088 | | out string description, |
| | | 2089 | | out string formatVersion, |
| | | 2090 | | out string error) |
| | | 2091 | | { |
| | 21 | 2092 | | if (!TryGetServiceDescriptorStringValue(descriptorText, "Name", required: true, out name, out error)) |
| | | 2093 | | { |
| | 0 | 2094 | | description = string.Empty; |
| | 0 | 2095 | | formatVersion = string.Empty; |
| | 0 | 2096 | | return false; |
| | | 2097 | | } |
| | | 2098 | | |
| | 21 | 2099 | | if (!TryGetServiceDescriptorStringValue(descriptorText, "Description", required: true, out description, out erro |
| | | 2100 | | { |
| | 1 | 2101 | | formatVersion = string.Empty; |
| | 1 | 2102 | | return false; |
| | | 2103 | | } |
| | | 2104 | | |
| | 20 | 2105 | | _ = TryGetServiceDescriptorStringValue(descriptorText, "FormatVersion", required: false, out formatVersion, out |
| | 20 | 2106 | | error = string.Empty; |
| | 20 | 2107 | | return true; |
| | | 2108 | | } |
| | | 2109 | | |
| | | 2110 | | /// <summary> |
| | | 2111 | | /// Resolves descriptor entrypoint/version fields for legacy and format-1.0 descriptors. |
| | | 2112 | | /// </summary> |
| | | 2113 | | /// <param name="descriptorText">Normalized service descriptor text.</param> |
| | | 2114 | | /// <param name="formatVersion">Optional format version token.</param> |
| | | 2115 | | /// <param name="normalizedFormatVersion">Normalized format marker used by runtime metadata.</param> |
| | | 2116 | | /// <param name="entryPoint">Resolved script entrypoint path.</param> |
| | | 2117 | | /// <param name="version">Optional parsed version string.</param> |
| | | 2118 | | /// <param name="error">Validation error details.</param> |
| | | 2119 | | /// <returns>True when entrypoint/version resolution succeeds.</returns> |
| | | 2120 | | private static bool TryResolveServiceDescriptorEntryPointAndVersion( |
| | | 2121 | | string descriptorText, |
| | | 2122 | | string formatVersion, |
| | | 2123 | | out string normalizedFormatVersion, |
| | | 2124 | | out string entryPoint, |
| | | 2125 | | out string? version, |
| | | 2126 | | out string error) |
| | | 2127 | | { |
| | 20 | 2128 | | version = null; |
| | | 2129 | | |
| | 20 | 2130 | | if (string.IsNullOrWhiteSpace(formatVersion)) |
| | | 2131 | | { |
| | 11 | 2132 | | normalizedFormatVersion = "legacy"; |
| | 11 | 2133 | | if (!TryGetServiceDescriptorStringValue(descriptorText, "Script", required: false, out entryPoint, out error |
| | | 2134 | | { |
| | 0 | 2135 | | return false; |
| | | 2136 | | } |
| | | 2137 | | |
| | 11 | 2138 | | if (string.IsNullOrWhiteSpace(entryPoint)) |
| | | 2139 | | { |
| | 3 | 2140 | | entryPoint = ServiceDefaultScriptFileName; |
| | | 2141 | | } |
| | | 2142 | | |
| | 11 | 2143 | | return TryResolveOptionalServiceDescriptorVersion(descriptorText, out version, out error); |
| | | 2144 | | } |
| | | 2145 | | |
| | 9 | 2146 | | var trimmedFormatVersion = formatVersion.Trim(); |
| | 9 | 2147 | | normalizedFormatVersion = trimmedFormatVersion; |
| | 9 | 2148 | | if (!string.Equals(trimmedFormatVersion, "1.0", StringComparison.Ordinal)) |
| | | 2149 | | { |
| | 0 | 2150 | | entryPoint = string.Empty; |
| | 0 | 2151 | | error = "Service descriptor FormatVersion must be '1.0'."; |
| | 0 | 2152 | | return false; |
| | | 2153 | | } |
| | | 2154 | | |
| | 9 | 2155 | | return TryGetServiceDescriptorStringValue(descriptorText, "EntryPoint", required: true, out entryPoint, out erro |
| | 9 | 2156 | | && TryResolveOptionalServiceDescriptorVersion(descriptorText, out version, out error); |
| | | 2157 | | } |
| | | 2158 | | |
| | | 2159 | | /// <summary> |
| | | 2160 | | /// Resolves and validates optional descriptor version metadata. |
| | | 2161 | | /// </summary> |
| | | 2162 | | /// <param name="descriptorText">Normalized service descriptor text.</param> |
| | | 2163 | | /// <param name="version">Resolved version string when present.</param> |
| | | 2164 | | /// <param name="error">Validation error details.</param> |
| | | 2165 | | /// <returns>True when version is absent or parseable by <see cref="Version"/>.</returns> |
| | | 2166 | | private static bool TryResolveOptionalServiceDescriptorVersion(string descriptorText, out string? version, out strin |
| | | 2167 | | { |
| | 20 | 2168 | | version = null; |
| | 20 | 2169 | | _ = TryGetServiceDescriptorStringValue(descriptorText, "Version", required: false, out var rawVersion, out _); |
| | 20 | 2170 | | if (string.IsNullOrWhiteSpace(rawVersion)) |
| | | 2171 | | { |
| | 0 | 2172 | | error = string.Empty; |
| | 0 | 2173 | | return true; |
| | | 2174 | | } |
| | | 2175 | | |
| | 20 | 2176 | | var trimmedVersion = rawVersion.Trim(); |
| | 20 | 2177 | | if (!Version.TryParse(trimmedVersion, out _)) |
| | | 2178 | | { |
| | 1 | 2179 | | error = $"Service descriptor '{ServiceDescriptorFileName}' key 'Version' must be compatible with System.Vers |
| | 1 | 2180 | | return false; |
| | | 2181 | | } |
| | | 2182 | | |
| | 19 | 2183 | | version = trimmedVersion; |
| | 19 | 2184 | | error = string.Empty; |
| | 19 | 2185 | | return true; |
| | | 2186 | | } |
| | | 2187 | | |
| | | 2188 | | /// <summary> |
| | | 2189 | | /// Normalizes service descriptor text for regex parsing. |
| | | 2190 | | /// </summary> |
| | | 2191 | | /// <param name="descriptorText">Raw descriptor text.</param> |
| | | 2192 | | /// <returns>Descriptor text with PowerShell escaped newline sequences expanded.</returns> |
| | | 2193 | | private static string NormalizeServiceDescriptorText(string descriptorText) |
| | 21 | 2194 | | => descriptorText |
| | 21 | 2195 | | .Replace("`r`n", "\n", StringComparison.Ordinal) |
| | 21 | 2196 | | .Replace("`n", "\n", StringComparison.Ordinal) |
| | 21 | 2197 | | .Replace("`r", "\n", StringComparison.Ordinal); |
| | | 2198 | | |
| | | 2199 | | /// <summary> |
| | | 2200 | | /// Reads a string-valued key from Service.psd1. |
| | | 2201 | | /// </summary> |
| | | 2202 | | /// <param name="descriptorText">Raw descriptor content.</param> |
| | | 2203 | | /// <param name="key">Descriptor key name.</param> |
| | | 2204 | | /// <param name="required">True when a missing key should fail validation.</param> |
| | | 2205 | | /// <param name="value">Resolved string value.</param> |
| | | 2206 | | /// <param name="error">Validation error details when required values are missing.</param> |
| | | 2207 | | /// <returns>True when key resolution succeeded for the required/optional mode.</returns> |
| | | 2208 | | private static bool TryGetServiceDescriptorStringValue(string descriptorText, string key, bool required, out string |
| | | 2209 | | { |
| | 121 | 2210 | | var match = Regex.Match( |
| | 121 | 2211 | | descriptorText, |
| | 121 | 2212 | | $@"(?mi)(?:^|[;{{\r\n])\s*{Regex.Escape(key)}\s*=\s*(?:'(?<single>[^']*)'|""(?<double>[^""]*)"")", |
| | 121 | 2213 | | RegexOptions.CultureInvariant); |
| | | 2214 | | |
| | 121 | 2215 | | if (!match.Success) |
| | | 2216 | | { |
| | 28 | 2217 | | value = string.Empty; |
| | 28 | 2218 | | error = required |
| | 28 | 2219 | | ? $"Service descriptor '{ServiceDescriptorFileName}' is missing required key '{key}'." |
| | 28 | 2220 | | : string.Empty; |
| | 28 | 2221 | | return !required; |
| | | 2222 | | } |
| | | 2223 | | |
| | 93 | 2224 | | value = (match.Groups["single"].Success ? match.Groups["single"].Value : match.Groups["double"].Value).Trim(); |
| | 93 | 2225 | | if (required && string.IsNullOrWhiteSpace(value)) |
| | | 2226 | | { |
| | 0 | 2227 | | error = $"Service descriptor '{ServiceDescriptorFileName}' key '{key}' must not be empty."; |
| | 0 | 2228 | | return false; |
| | | 2229 | | } |
| | | 2230 | | |
| | 93 | 2231 | | error = string.Empty; |
| | 93 | 2232 | | return true; |
| | | 2233 | | } |
| | | 2234 | | |
| | | 2235 | | /// <summary> |
| | | 2236 | | /// Reads a string-array key from Service.psd1 using PowerShell array syntax: Key = @( 'a', 'b' ). |
| | | 2237 | | /// </summary> |
| | | 2238 | | /// <param name="descriptorText">Raw descriptor content.</param> |
| | | 2239 | | /// <param name="key">Descriptor key name.</param> |
| | | 2240 | | /// <param name="values">Resolved array values.</param> |
| | | 2241 | | /// <param name="error">Validation error details.</param> |
| | | 2242 | | /// <returns>True when array resolution succeeds.</returns> |
| | | 2243 | | private static bool TryGetServiceDescriptorStringArrayValue(string descriptorText, string key, out string[] values, |
| | | 2244 | | { |
| | 38 | 2245 | | values = []; |
| | 38 | 2246 | | error = string.Empty; |
| | | 2247 | | |
| | 38 | 2248 | | var arrayMatch = Regex.Match( |
| | 38 | 2249 | | descriptorText, |
| | 38 | 2250 | | $@"(?mis)(?:^|[;{{\r\n])\s*{Regex.Escape(key)}\s*=\s*@\((?<items>.*?)\)", |
| | 38 | 2251 | | RegexOptions.CultureInvariant); |
| | | 2252 | | |
| | 38 | 2253 | | if (!arrayMatch.Success) |
| | | 2254 | | { |
| | 36 | 2255 | | return true; |
| | | 2256 | | } |
| | | 2257 | | |
| | 2 | 2258 | | var itemsText = arrayMatch.Groups["items"].Value; |
| | 2 | 2259 | | var itemMatches = Regex.Matches( |
| | 2 | 2260 | | itemsText, |
| | 2 | 2261 | | "'(?<single>(?:''|[^'])*)'|\"(?<double>(?:\"\"|[^\"])*)\"", |
| | 2 | 2262 | | RegexOptions.CultureInvariant); |
| | | 2263 | | |
| | 2 | 2264 | | if (itemMatches.Count == 0 && !string.IsNullOrWhiteSpace(itemsText)) |
| | | 2265 | | { |
| | 0 | 2266 | | error = $"Service descriptor '{ServiceDescriptorFileName}' key '{key}' must be a string array, for example: |
| | 0 | 2267 | | return false; |
| | | 2268 | | } |
| | | 2269 | | |
| | 2 | 2270 | | values = [.. itemMatches |
| | 2 | 2271 | | .Select(static match => |
| | 2 | 2272 | | { |
| | 5 | 2273 | | var raw = match.Groups["single"].Success |
| | 5 | 2274 | | ? match.Groups["single"].Value.Replace("''", "'", StringComparison.Ordinal) |
| | 5 | 2275 | | : match.Groups["double"].Value.Replace("\"\"", "\"", StringComparison.Ordinal); |
| | 5 | 2276 | | return raw.Trim(); |
| | 2 | 2277 | | }) |
| | 7 | 2278 | | .Where(static path => !string.IsNullOrWhiteSpace(path))]; |
| | 2 | 2279 | | return true; |
| | | 2280 | | } |
| | | 2281 | | |
| | | 2282 | | /// <summary> |
| | | 2283 | | /// Resolves the script path for descriptor-driven service installs. |
| | | 2284 | | /// </summary> |
| | | 2285 | | /// <param name="requestedScriptPath">Script path requested on the command line.</param> |
| | | 2286 | | /// <param name="descriptor">Resolved service descriptor.</param> |
| | | 2287 | | /// <param name="resolvedScriptPath">Final script path relative to content root.</param> |
| | | 2288 | | /// <param name="error">Validation error details.</param> |
| | | 2289 | | /// <returns>True when the resolved script path is valid.</returns> |
| | | 2290 | | private static bool TryResolveServiceDescriptorScriptPath(string requestedScriptPath, ServiceInstallDescriptor descr |
| | | 2291 | | { |
| | 11 | 2292 | | if (!string.IsNullOrWhiteSpace(requestedScriptPath)) |
| | | 2293 | | { |
| | 0 | 2294 | | resolvedScriptPath = string.Empty; |
| | 0 | 2295 | | error = "An explicit script path is not supported when --package is used. Define EntryPoint in Service.psd1 |
| | 0 | 2296 | | return false; |
| | | 2297 | | } |
| | | 2298 | | |
| | 11 | 2299 | | resolvedScriptPath = descriptor.EntryPoint; |
| | | 2300 | | |
| | 11 | 2301 | | if (Path.IsPathRooted(resolvedScriptPath)) |
| | | 2302 | | { |
| | 1 | 2303 | | error = $"Service descriptor '{ServiceDescriptorFileName}' EntryPoint/Script must be a relative path within |
| | 1 | 2304 | | return false; |
| | | 2305 | | } |
| | | 2306 | | |
| | 10 | 2307 | | error = string.Empty; |
| | 10 | 2308 | | return true; |
| | | 2309 | | } |
| | | 2310 | | |
| | | 2311 | | /// <summary> |
| | | 2312 | | /// Applies descriptor metadata to a resolved service script source. |
| | | 2313 | | /// </summary> |
| | | 2314 | | /// <param name="scriptSource">Resolved script source.</param> |
| | | 2315 | | /// <param name="descriptor">Descriptor metadata.</param> |
| | | 2316 | | /// <returns>Script source enriched with descriptor metadata.</returns> |
| | | 2317 | | private static ResolvedServiceScriptSource ApplyDescriptorMetadata(ResolvedServiceScriptSource scriptSource, Service |
| | 10 | 2318 | | => new( |
| | 10 | 2319 | | scriptSource.FullScriptPath, |
| | 10 | 2320 | | scriptSource.FullContentRoot, |
| | 10 | 2321 | | scriptSource.RelativeScriptPath, |
| | 10 | 2322 | | scriptSource.TemporaryContentRootPath, |
| | 10 | 2323 | | descriptor.Name, |
| | 10 | 2324 | | descriptor.Description, |
| | 10 | 2325 | | descriptor.Version, |
| | 10 | 2326 | | descriptor.ServiceLogPath, |
| | 10 | 2327 | | descriptor.PreservePaths, |
| | 10 | 2328 | | descriptor.ApplicationDataFolders); |
| | | 2329 | | |
| | | 2330 | | /// <summary> |
| | | 2331 | | /// Downloads and extracts an HTTP content-root archive into the supplied directory. |
| | | 2332 | | /// </summary> |
| | | 2333 | | /// <param name="command">Parsed service command.</param> |
| | | 2334 | | /// <param name="contentRootUri">HTTP(S) archive URI.</param> |
| | | 2335 | | /// <param name="temporaryRoot">Temporary root folder used for download output.</param> |
| | | 2336 | | /// <param name="downloadedContentRoot">Folder where the archive should be extracted.</param> |
| | | 2337 | | /// <param name="error">Error details when any stage fails.</param> |
| | | 2338 | | /// <returns>True when download, checksum, and extraction all succeed.</returns> |
| | | 2339 | | private static bool TryDownloadAndExtractHttpContentRoot( |
| | | 2340 | | ParsedCommand command, |
| | | 2341 | | Uri contentRootUri, |
| | | 2342 | | string temporaryRoot, |
| | | 2343 | | string downloadedContentRoot, |
| | | 2344 | | out string error) |
| | | 2345 | | { |
| | 6 | 2346 | | if (!TryDownloadServiceContentRootArchive( |
| | 6 | 2347 | | contentRootUri, |
| | 6 | 2348 | | temporaryRoot, |
| | 6 | 2349 | | command.ServiceContentRootBearerToken, |
| | 6 | 2350 | | command.ServiceContentRootHeaders, |
| | 6 | 2351 | | command.ServiceContentRootIgnoreCertificate, |
| | 6 | 2352 | | out var downloadedArchivePath, |
| | 6 | 2353 | | out error)) |
| | | 2354 | | { |
| | 3 | 2355 | | return false; |
| | | 2356 | | } |
| | | 2357 | | |
| | | 2358 | | try |
| | | 2359 | | { |
| | 3 | 2360 | | return |
| | 3 | 2361 | | TryValidateServiceContentRootArchiveChecksum(command, downloadedArchivePath, out error) && |
| | 3 | 2362 | | TryExtractServiceContentRootArchive(downloadedArchivePath, downloadedContentRoot, out error); |
| | | 2363 | | } |
| | | 2364 | | finally |
| | | 2365 | | { |
| | | 2366 | | // Best-effort cleanup to avoid retaining large downloaded archives after extraction attempts. |
| | 3 | 2367 | | TryDeleteFileQuietly(downloadedArchivePath); |
| | 3 | 2368 | | } |
| | 3 | 2369 | | } |
| | | 2370 | | |
| | | 2371 | | /// <summary> |
| | | 2372 | | /// Resolves a relative script path from an already materialized content-root directory. |
| | | 2373 | | /// </summary> |
| | | 2374 | | /// <param name="requestedScriptPath">Requested relative script path.</param> |
| | | 2375 | | /// <param name="fullContentRoot">Absolute content-root path.</param> |
| | | 2376 | | /// <param name="escapedPathError">Error message used when the script path escapes the content root.</param> |
| | | 2377 | | /// <param name="missingScriptError">Error message used when the script file does not exist.</param> |
| | | 2378 | | /// <param name="temporaryContentRootPath">Optional temporary content-root path for cleanup ownership.</param> |
| | | 2379 | | /// <param name="scriptSource">Resolved script source details.</param> |
| | | 2380 | | /// <param name="error">Error details when validation fails.</param> |
| | | 2381 | | /// <returns>True when the script path resolves and exists inside the root.</returns> |
| | | 2382 | | private static bool TryResolveScriptFromResolvedContentRoot( |
| | | 2383 | | string requestedScriptPath, |
| | | 2384 | | string fullContentRoot, |
| | | 2385 | | string escapedPathError, |
| | | 2386 | | string missingScriptError, |
| | | 2387 | | string? temporaryContentRootPath, |
| | | 2388 | | out ResolvedServiceScriptSource scriptSource, |
| | | 2389 | | out string error) |
| | | 2390 | | { |
| | 10 | 2391 | | scriptSource = CreateEmptyResolvedServiceScriptSource(); |
| | 10 | 2392 | | var fullScriptPathFromRoot = Path.GetFullPath(Path.Combine(fullContentRoot, requestedScriptPath)); |
| | 10 | 2393 | | if (!IsPathWithinDirectory(fullScriptPathFromRoot, fullContentRoot)) |
| | | 2394 | | { |
| | 0 | 2395 | | error = escapedPathError; |
| | 0 | 2396 | | return false; |
| | | 2397 | | } |
| | | 2398 | | |
| | 10 | 2399 | | if (!File.Exists(fullScriptPathFromRoot)) |
| | | 2400 | | { |
| | 0 | 2401 | | error = missingScriptError; |
| | 0 | 2402 | | return false; |
| | | 2403 | | } |
| | | 2404 | | |
| | 10 | 2405 | | var relativeScriptPath = Path.GetRelativePath(fullContentRoot, fullScriptPathFromRoot); |
| | 10 | 2406 | | scriptSource = new ResolvedServiceScriptSource(fullScriptPathFromRoot, fullContentRoot, relativeScriptPath, temp |
| | 10 | 2407 | | error = string.Empty; |
| | 10 | 2408 | | return true; |
| | | 2409 | | } |
| | | 2410 | | |
| | | 2411 | | /// <summary> |
| | | 2412 | | /// Creates an empty service-script-source placeholder. |
| | | 2413 | | /// </summary> |
| | | 2414 | | /// <returns>Empty resolved service script source value.</returns> |
| | | 2415 | | private static ResolvedServiceScriptSource CreateEmptyResolvedServiceScriptSource() |
| | 40 | 2416 | | => new(string.Empty, null, string.Empty, null, null, null, null, null, [], []); |
| | | 2417 | | |
| | | 2418 | | /// <summary> |
| | | 2419 | | /// Creates a temporary extraction directory for archive-based service content roots. |
| | | 2420 | | /// </summary> |
| | | 2421 | | /// <param name="serviceName">Optional service name for easier diagnostics.</param> |
| | | 2422 | | /// <returns>Newly created extraction directory path.</returns> |
| | | 2423 | | private static string CreateServiceContentRootExtractionDirectory(string? serviceName) |
| | | 2424 | | { |
| | 10 | 2425 | | var safeServiceName = string.IsNullOrWhiteSpace(serviceName) |
| | 10 | 2426 | | ? "service" |
| | 10 | 2427 | | : string.Concat(serviceName.Where(ch => char.IsLetterOrDigit(ch) || ch is '-' or '_')); |
| | | 2428 | | |
| | 10 | 2429 | | if (string.IsNullOrWhiteSpace(safeServiceName)) |
| | | 2430 | | { |
| | 0 | 2431 | | safeServiceName = "service"; |
| | | 2432 | | } |
| | | 2433 | | |
| | 10 | 2434 | | var extractionRoot = Path.Combine(Path.GetTempPath(), "kestrun-content-root", safeServiceName, Guid.NewGuid().To |
| | 10 | 2435 | | _ = Directory.CreateDirectory(extractionRoot); |
| | 10 | 2436 | | return extractionRoot; |
| | | 2437 | | } |
| | | 2438 | | |
| | | 2439 | | /// <summary> |
| | | 2440 | | /// Parses an HTTP(S) URI for service content-root input. |
| | | 2441 | | /// </summary> |
| | | 2442 | | /// <param name="contentRootInput">Raw content-root input token.</param> |
| | | 2443 | | /// <param name="uri">Parsed HTTP(S) URI.</param> |
| | | 2444 | | /// <returns>True when input is an absolute HTTP(S) URI.</returns> |
| | | 2445 | | private static bool TryParseServiceContentRootHttpUri(string contentRootInput, out Uri uri) |
| | | 2446 | | { |
| | 24 | 2447 | | if (Uri.TryCreate(contentRootInput, UriKind.Absolute, out var parsed) |
| | 24 | 2448 | | && parsed is not null |
| | 24 | 2449 | | && (parsed.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) |
| | 24 | 2450 | | || parsed.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))) |
| | | 2451 | | { |
| | 7 | 2452 | | uri = parsed; |
| | 7 | 2453 | | return true; |
| | | 2454 | | } |
| | | 2455 | | |
| | 17 | 2456 | | uri = null!; |
| | 17 | 2457 | | return false; |
| | | 2458 | | } |
| | | 2459 | | |
| | | 2460 | | /// <summary> |
| | | 2461 | | /// Downloads a service content-root archive from HTTP(S) into a temporary directory. |
| | | 2462 | | /// </summary> |
| | | 2463 | | /// <param name="uri">HTTP(S) source URI.</param> |
| | | 2464 | | /// <param name="temporaryRoot">Temporary root directory for download output.</param> |
| | | 2465 | | /// <param name="archivePath">Downloaded archive path.</param> |
| | | 2466 | | /// <param name="error">Error details when download fails.</param> |
| | | 2467 | | /// <returns>True when archive is downloaded and has a supported extension.</returns> |
| | | 2468 | | private static bool TryDownloadServiceContentRootArchive( |
| | | 2469 | | Uri uri, |
| | | 2470 | | string temporaryRoot, |
| | | 2471 | | string? bearerToken, |
| | | 2472 | | string[] customHeaders, |
| | | 2473 | | bool ignoreCertificate, |
| | | 2474 | | out string archivePath, |
| | | 2475 | | out string error) |
| | | 2476 | | { |
| | 6 | 2477 | | archivePath = string.Empty; |
| | 6 | 2478 | | error = string.Empty; |
| | | 2479 | | |
| | 6 | 2480 | | if (ignoreCertificate && !uri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)) |
| | | 2481 | | { |
| | 0 | 2482 | | error = "--content-root-ignore-certificate is only valid for HTTPS URLs."; |
| | 0 | 2483 | | return false; |
| | | 2484 | | } |
| | | 2485 | | |
| | | 2486 | | try |
| | | 2487 | | { |
| | 6 | 2488 | | using var request = new HttpRequestMessage(HttpMethod.Get, uri); |
| | 6 | 2489 | | if (!string.IsNullOrWhiteSpace(bearerToken)) |
| | | 2490 | | { |
| | 1 | 2491 | | request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", bearerToken); |
| | | 2492 | | } |
| | | 2493 | | |
| | 6 | 2494 | | if (!TryApplyServiceContentRootCustomHeaders(request, customHeaders, out error)) |
| | | 2495 | | { |
| | 3 | 2496 | | return false; |
| | | 2497 | | } |
| | | 2498 | | |
| | 3 | 2499 | | if (!ignoreCertificate) |
| | | 2500 | | { |
| | 3 | 2501 | | using var response = ServiceContentRootHttpClient.Send(request, HttpCompletionOption.ResponseHeadersRead |
| | 3 | 2502 | | if (!response.IsSuccessStatusCode) |
| | | 2503 | | { |
| | 0 | 2504 | | error = $"Failed to download service content root from '{uri}'. HTTP {(int)response.StatusCode} {res |
| | 0 | 2505 | | return false; |
| | | 2506 | | } |
| | | 2507 | | |
| | 3 | 2508 | | return TryWriteDownloadedContentRootArchive(temporaryRoot, uri, response, out archivePath, out error); |
| | | 2509 | | } |
| | | 2510 | | |
| | 0 | 2511 | | using var insecureHandler = new HttpClientHandler |
| | 0 | 2512 | | { |
| | 0 | 2513 | | ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidat |
| | 0 | 2514 | | }; |
| | 0 | 2515 | | using var insecureClient = new HttpClient(insecureHandler) |
| | 0 | 2516 | | { |
| | 0 | 2517 | | Timeout = TimeSpan.FromMinutes(5), |
| | 0 | 2518 | | }; |
| | 0 | 2519 | | insecureClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(ProductName, "1.0")); |
| | 0 | 2520 | | using var insecureResponse = insecureClient.Send(request, HttpCompletionOption.ResponseHeadersRead); |
| | 0 | 2521 | | if (!insecureResponse.IsSuccessStatusCode) |
| | | 2522 | | { |
| | 0 | 2523 | | error = $"Failed to download service content root from '{uri}'. HTTP {(int)insecureResponse.StatusCode} |
| | 0 | 2524 | | return false; |
| | | 2525 | | } |
| | | 2526 | | |
| | 0 | 2527 | | return TryWriteDownloadedContentRootArchive(temporaryRoot, uri, insecureResponse, out archivePath, out error |
| | | 2528 | | } |
| | 0 | 2529 | | catch (Exception ex) |
| | | 2530 | | { |
| | 0 | 2531 | | error = $"Failed to download service content root from '{uri}': {ex.Message}"; |
| | 0 | 2532 | | return false; |
| | | 2533 | | } |
| | 6 | 2534 | | } |
| | | 2535 | | |
| | | 2536 | | /// <summary> |
| | | 2537 | | /// Applies custom request headers used for service content-root URL downloads. |
| | | 2538 | | /// </summary> |
| | | 2539 | | /// <param name="request">HTTP request message to update.</param> |
| | | 2540 | | /// <param name="customHeaders">Custom header tokens in <c>name:value</c> format.</param> |
| | | 2541 | | /// <param name="error">Validation error when a header token cannot be applied.</param> |
| | | 2542 | | /// <returns>True when all headers are valid and applied to the request.</returns> |
| | | 2543 | | private static bool TryApplyServiceContentRootCustomHeaders(HttpRequestMessage request, IReadOnlyList<string> custom |
| | | 2544 | | { |
| | 12 | 2545 | | error = string.Empty; |
| | 29 | 2546 | | foreach (var headerToken in customHeaders) |
| | | 2547 | | { |
| | 4 | 2548 | | if (string.IsNullOrWhiteSpace(headerToken)) |
| | | 2549 | | { |
| | 0 | 2550 | | error = "--content-root-header value cannot be empty. Use <name:value>."; |
| | 0 | 2551 | | return false; |
| | | 2552 | | } |
| | | 2553 | | |
| | 4 | 2554 | | var separatorIndex = headerToken.IndexOf(':'); |
| | 4 | 2555 | | if (separatorIndex <= 0) |
| | | 2556 | | { |
| | 1 | 2557 | | error = $"Invalid --content-root-header value '{headerToken}'. Use <name:value>."; |
| | 1 | 2558 | | return false; |
| | | 2559 | | } |
| | | 2560 | | |
| | 3 | 2561 | | var headerName = headerToken[..separatorIndex].Trim(); |
| | 3 | 2562 | | var headerValue = headerToken[(separatorIndex + 1)..].Trim(); |
| | 3 | 2563 | | if (string.IsNullOrWhiteSpace(headerName)) |
| | | 2564 | | { |
| | 0 | 2565 | | error = $"Invalid --content-root-header value '{headerToken}'. Header name cannot be empty."; |
| | 0 | 2566 | | return false; |
| | | 2567 | | } |
| | | 2568 | | |
| | 3 | 2569 | | if (headerName.Contains('\r') || headerName.Contains('\n')) |
| | | 2570 | | { |
| | 1 | 2571 | | error = $"Invalid --content-root-header value '{headerToken}'. Header name cannot contain CR or LF chara |
| | 1 | 2572 | | return false; |
| | | 2573 | | } |
| | | 2574 | | |
| | 2 | 2575 | | if (headerValue.Contains('\r') || headerValue.Contains('\n')) |
| | | 2576 | | { |
| | 1 | 2577 | | error = $"Invalid --content-root-header value '{headerToken}'. Header value cannot contain CR or LF char |
| | 1 | 2578 | | return false; |
| | | 2579 | | } |
| | | 2580 | | |
| | 1 | 2581 | | if (!request.Headers.TryAddWithoutValidation(headerName, headerValue)) |
| | | 2582 | | { |
| | 0 | 2583 | | error = $"Invalid --content-root-header value '{headerToken}'."; |
| | 0 | 2584 | | return false; |
| | | 2585 | | } |
| | | 2586 | | } |
| | | 2587 | | |
| | 9 | 2588 | | return true; |
| | 3 | 2589 | | } |
| | | 2590 | | |
| | | 2591 | | /// <summary> |
| | | 2592 | | /// Writes a downloaded service content-root archive response to disk. |
| | | 2593 | | /// </summary> |
| | | 2594 | | /// <param name="temporaryRoot">Temporary root directory for archive output.</param> |
| | | 2595 | | /// <param name="uri">Source URI.</param> |
| | | 2596 | | /// <param name="response">HTTP response with archive payload.</param> |
| | | 2597 | | /// <param name="archivePath">Written archive path.</param> |
| | | 2598 | | /// <param name="error">Error details when write or validation fails.</param> |
| | | 2599 | | /// <returns>True when the archive is written and has a supported extension.</returns> |
| | | 2600 | | private static bool TryWriteDownloadedContentRootArchive( |
| | | 2601 | | string temporaryRoot, |
| | | 2602 | | Uri uri, |
| | | 2603 | | HttpResponseMessage response, |
| | | 2604 | | out string archivePath, |
| | | 2605 | | out string error) |
| | | 2606 | | { |
| | 3 | 2607 | | archivePath = string.Empty; |
| | 3 | 2608 | | error = string.Empty; |
| | | 2609 | | |
| | 3 | 2610 | | var resolvedFileName = TryResolveServiceContentRootArchiveFileName(uri, response) |
| | 3 | 2611 | | ?? "content-root"; |
| | 3 | 2612 | | resolvedFileName = GetSafeServiceContentRootArchiveFileName(resolvedFileName, "content-root"); |
| | | 2613 | | |
| | 3 | 2614 | | var provisionalArchivePath = Path.Combine(temporaryRoot, resolvedFileName); |
| | 3 | 2615 | | using (var sourceStream = response.Content.ReadAsStream()) |
| | 3 | 2616 | | using (var destinationStream = File.Create(provisionalArchivePath)) |
| | | 2617 | | { |
| | 3 | 2618 | | sourceStream.CopyTo(destinationStream); |
| | 3 | 2619 | | } |
| | | 2620 | | |
| | 3 | 2621 | | if (!TryResolveDownloadedServiceContentRootArchiveFileName( |
| | 3 | 2622 | | uri, |
| | 3 | 2623 | | resolvedFileName, |
| | 3 | 2624 | | provisionalArchivePath, |
| | 3 | 2625 | | response, |
| | 3 | 2626 | | out var finalizedFileName, |
| | 3 | 2627 | | out error)) |
| | | 2628 | | { |
| | | 2629 | | try |
| | | 2630 | | { |
| | 0 | 2631 | | if (File.Exists(provisionalArchivePath)) |
| | | 2632 | | { |
| | 0 | 2633 | | File.Delete(provisionalArchivePath); |
| | | 2634 | | } |
| | 0 | 2635 | | } |
| | 0 | 2636 | | catch |
| | | 2637 | | { |
| | | 2638 | | // Ignore cleanup errors because the original archive-validation error is more actionable. |
| | 0 | 2639 | | } |
| | 0 | 2640 | | return false; |
| | | 2641 | | } |
| | | 2642 | | |
| | 3 | 2643 | | archivePath = provisionalArchivePath; |
| | 3 | 2644 | | if (!string.Equals(finalizedFileName, resolvedFileName, StringComparison.OrdinalIgnoreCase)) |
| | | 2645 | | { |
| | 1 | 2646 | | var finalizedArchivePath = Path.Combine(temporaryRoot, finalizedFileName); |
| | 1 | 2647 | | File.Move(provisionalArchivePath, finalizedArchivePath, overwrite: true); |
| | 1 | 2648 | | archivePath = finalizedArchivePath; |
| | | 2649 | | } |
| | | 2650 | | |
| | 3 | 2651 | | return true; |
| | | 2652 | | } |
| | | 2653 | | |
| | | 2654 | | /// <summary> |
| | | 2655 | | /// Converts an archive file name candidate to a filesystem-safe file name. |
| | | 2656 | | /// </summary> |
| | | 2657 | | /// <param name="candidate">Raw file name candidate from headers or URI metadata.</param> |
| | | 2658 | | /// <param name="fallbackFileName">Fallback file name when the candidate is empty or invalid.</param> |
| | | 2659 | | /// <returns>Filesystem-safe file name.</returns> |
| | | 2660 | | private static string GetSafeServiceContentRootArchiveFileName(string? candidate, string fallbackFileName) |
| | | 2661 | | { |
| | 3 | 2662 | | var fileName = Path.GetFileName(candidate ?? string.Empty); |
| | 3 | 2663 | | if (string.IsNullOrWhiteSpace(fileName)) |
| | | 2664 | | { |
| | 0 | 2665 | | return fallbackFileName; |
| | | 2666 | | } |
| | | 2667 | | |
| | 3 | 2668 | | var invalidChars = Path.GetInvalidFileNameChars(); |
| | 3 | 2669 | | var builder = new StringBuilder(fileName.Length); |
| | 50 | 2670 | | foreach (var ch in fileName) |
| | | 2671 | | { |
| | 22 | 2672 | | if (char.IsControl(ch) || ch == Path.DirectorySeparatorChar || ch == Path.AltDirectorySeparatorChar || inval |
| | | 2673 | | { |
| | 0 | 2674 | | _ = builder.Append('-'); |
| | 0 | 2675 | | continue; |
| | | 2676 | | } |
| | | 2677 | | |
| | 22 | 2678 | | _ = builder.Append(ch); |
| | | 2679 | | } |
| | | 2680 | | |
| | 3 | 2681 | | var sanitized = builder.ToString().Trim().Trim('.'); |
| | 3 | 2682 | | return string.IsNullOrWhiteSpace(sanitized) ? fallbackFileName : sanitized; |
| | | 2683 | | } |
| | | 2684 | | |
| | | 2685 | | /// <summary> |
| | | 2686 | | /// Resolves a supported archive file name for a downloaded content-root payload. |
| | | 2687 | | /// </summary> |
| | | 2688 | | /// <param name="uri">Source URI.</param> |
| | | 2689 | | /// <param name="resolvedFileName">Initially resolved file name candidate.</param> |
| | | 2690 | | /// <param name="downloadedArchivePath">Downloaded archive payload path.</param> |
| | | 2691 | | /// <param name="response">HTTP response metadata.</param> |
| | | 2692 | | /// <param name="finalizedFileName">Finalized archive file name with supported extension.</param> |
| | | 2693 | | /// <param name="error">Validation error details when archive type cannot be resolved.</param> |
| | | 2694 | | /// <returns>True when a supported archive file name is resolved.</returns> |
| | | 2695 | | private static bool TryResolveDownloadedServiceContentRootArchiveFileName( |
| | | 2696 | | Uri uri, |
| | | 2697 | | string resolvedFileName, |
| | | 2698 | | string downloadedArchivePath, |
| | | 2699 | | HttpResponseMessage response, |
| | | 2700 | | out string finalizedFileName, |
| | | 2701 | | out string error) |
| | | 2702 | | { |
| | 3 | 2703 | | finalizedFileName = resolvedFileName; |
| | 3 | 2704 | | error = string.Empty; |
| | | 2705 | | |
| | 3 | 2706 | | if (IsSupportedServiceContentRootArchive(finalizedFileName)) |
| | | 2707 | | { |
| | 2 | 2708 | | return true; |
| | | 2709 | | } |
| | | 2710 | | |
| | 1 | 2711 | | var mediaType = response.Content.Headers.ContentType?.MediaType; |
| | 1 | 2712 | | if (TryGetServiceContentRootArchiveExtensionFromMediaType(mediaType, out var archiveExtension) |
| | 1 | 2713 | | || TryDetectServiceContentRootArchiveExtensionFromSignature(downloadedArchivePath, out archiveExtension)) |
| | | 2714 | | { |
| | 1 | 2715 | | finalizedFileName = BuildServiceContentRootArchiveFileName(resolvedFileName, archiveExtension); |
| | 1 | 2716 | | return true; |
| | | 2717 | | } |
| | | 2718 | | |
| | 0 | 2719 | | error = $"Downloaded package from '{uri}' is not a supported archive. Supported extensions: {ServicePackageExten |
| | 0 | 2720 | | return false; |
| | | 2721 | | } |
| | | 2722 | | |
| | | 2723 | | /// <summary> |
| | | 2724 | | /// Maps content-type metadata to a preferred service content-root archive extension. |
| | | 2725 | | /// </summary> |
| | | 2726 | | /// <param name="mediaType">HTTP response media type.</param> |
| | | 2727 | | /// <param name="archiveExtension">Resolved archive extension when available.</param> |
| | | 2728 | | /// <returns>True when the media type maps to a supported archive extension.</returns> |
| | | 2729 | | private static bool TryGetServiceContentRootArchiveExtensionFromMediaType(string? mediaType, out string archiveExten |
| | | 2730 | | { |
| | 6 | 2731 | | switch (mediaType?.ToLowerInvariant()) |
| | | 2732 | | { |
| | | 2733 | | case "application/zip": |
| | | 2734 | | case "application/x-zip-compressed": |
| | 1 | 2735 | | archiveExtension = ".zip"; |
| | 1 | 2736 | | return true; |
| | | 2737 | | case "application/x-tar": |
| | 1 | 2738 | | archiveExtension = ".tar"; |
| | 1 | 2739 | | return true; |
| | | 2740 | | case "application/gzip": |
| | | 2741 | | case "application/x-gzip": |
| | 2 | 2742 | | archiveExtension = ".tgz"; |
| | 2 | 2743 | | return true; |
| | | 2744 | | default: |
| | 2 | 2745 | | archiveExtension = string.Empty; |
| | 2 | 2746 | | return false; |
| | | 2747 | | } |
| | | 2748 | | } |
| | | 2749 | | |
| | | 2750 | | /// <summary> |
| | | 2751 | | /// Detects archive extension from file signature when metadata does not provide a usable file name. |
| | | 2752 | | /// </summary> |
| | | 2753 | | /// <param name="archivePath">Downloaded archive payload path.</param> |
| | | 2754 | | /// <param name="archiveExtension">Detected archive extension.</param> |
| | | 2755 | | /// <returns>True when a supported archive signature is recognized.</returns> |
| | | 2756 | | private static bool TryDetectServiceContentRootArchiveExtensionFromSignature(string archivePath, out string archiveE |
| | | 2757 | | { |
| | 5 | 2758 | | archiveExtension = string.Empty; |
| | | 2759 | | try |
| | | 2760 | | { |
| | 5 | 2761 | | Span<byte> signature = stackalloc byte[512]; |
| | 5 | 2762 | | using var stream = File.OpenRead(archivePath); |
| | 5 | 2763 | | var bytesRead = stream.Read(signature); |
| | 5 | 2764 | | if (bytesRead <= 0) |
| | | 2765 | | { |
| | 0 | 2766 | | return false; |
| | | 2767 | | } |
| | | 2768 | | |
| | 5 | 2769 | | if (bytesRead >= 4 |
| | 5 | 2770 | | && signature[0] == 0x50 |
| | 5 | 2771 | | && signature[1] == 0x4B |
| | 5 | 2772 | | && ((signature[2] == 0x03 && signature[3] == 0x04) |
| | 5 | 2773 | | || (signature[2] == 0x05 && signature[3] == 0x06) |
| | 5 | 2774 | | || (signature[2] == 0x07 && signature[3] == 0x08))) |
| | | 2775 | | { |
| | 1 | 2776 | | archiveExtension = ".zip"; |
| | 1 | 2777 | | return true; |
| | | 2778 | | } |
| | | 2779 | | |
| | 4 | 2780 | | if (bytesRead >= 2 && signature[0] == 0x1F && signature[1] == 0x8B) |
| | | 2781 | | { |
| | 2 | 2782 | | archiveExtension = ".tgz"; |
| | 2 | 2783 | | return true; |
| | | 2784 | | } |
| | | 2785 | | |
| | 2 | 2786 | | if (bytesRead >= 262 |
| | 2 | 2787 | | && signature[257] == (byte)'u' |
| | 2 | 2788 | | && signature[258] == (byte)'s' |
| | 2 | 2789 | | && signature[259] == (byte)'t' |
| | 2 | 2790 | | && signature[260] == (byte)'a' |
| | 2 | 2791 | | && signature[261] == (byte)'r') |
| | | 2792 | | { |
| | 1 | 2793 | | archiveExtension = ".tar"; |
| | 1 | 2794 | | return true; |
| | | 2795 | | } |
| | | 2796 | | |
| | 1 | 2797 | | return false; |
| | | 2798 | | } |
| | 0 | 2799 | | catch |
| | | 2800 | | { |
| | 0 | 2801 | | return false; |
| | | 2802 | | } |
| | 5 | 2803 | | } |
| | | 2804 | | |
| | | 2805 | | /// <summary> |
| | | 2806 | | /// Builds a normalized archive file name using the detected archive extension. |
| | | 2807 | | /// </summary> |
| | | 2808 | | /// <param name="resolvedFileName">Initially resolved file name candidate.</param> |
| | | 2809 | | /// <param name="archiveExtension">Detected archive extension.</param> |
| | | 2810 | | /// <returns>Normalized file name with archive extension.</returns> |
| | | 2811 | | private static string BuildServiceContentRootArchiveFileName(string resolvedFileName, string archiveExtension) |
| | | 2812 | | { |
| | 4 | 2813 | | var baseName = Path.GetFileNameWithoutExtension(resolvedFileName); |
| | 4 | 2814 | | if (archiveExtension.Equals(".tar.gz", StringComparison.OrdinalIgnoreCase) |
| | 4 | 2815 | | && resolvedFileName.EndsWith(".tar", StringComparison.OrdinalIgnoreCase)) |
| | | 2816 | | { |
| | 1 | 2817 | | baseName = Path.GetFileNameWithoutExtension(baseName); |
| | | 2818 | | } |
| | | 2819 | | |
| | 4 | 2820 | | if (string.IsNullOrWhiteSpace(baseName)) |
| | | 2821 | | { |
| | 1 | 2822 | | baseName = "content-root"; |
| | | 2823 | | } |
| | | 2824 | | |
| | 4 | 2825 | | return $"{baseName}{archiveExtension}"; |
| | | 2826 | | } |
| | | 2827 | | |
| | | 2828 | | /// <summary> |
| | | 2829 | | /// Resolves a best-effort archive file name from response headers and URI metadata. |
| | | 2830 | | /// </summary> |
| | | 2831 | | /// <param name="uri">Source URI.</param> |
| | | 2832 | | /// <param name="response">HTTP response.</param> |
| | | 2833 | | /// <returns>Resolved file name when available; otherwise null.</returns> |
| | | 2834 | | private static string? TryResolveServiceContentRootArchiveFileName(Uri uri, HttpResponseMessage response) |
| | | 2835 | | { |
| | 6 | 2836 | | var contentDisposition = response.Content.Headers.ContentDisposition; |
| | 6 | 2837 | | var dispositionFileName = contentDisposition?.FileNameStar ?? contentDisposition?.FileName; |
| | 6 | 2838 | | if (!string.IsNullOrWhiteSpace(dispositionFileName)) |
| | | 2839 | | { |
| | 1 | 2840 | | var trimmed = dispositionFileName.Trim().Trim('"'); |
| | 1 | 2841 | | if (!string.IsNullOrWhiteSpace(trimmed)) |
| | | 2842 | | { |
| | 1 | 2843 | | return trimmed; |
| | | 2844 | | } |
| | | 2845 | | } |
| | | 2846 | | |
| | 5 | 2847 | | var uriFileName = Path.GetFileName(uri.AbsolutePath); |
| | 5 | 2848 | | if (!string.IsNullOrWhiteSpace(uriFileName)) |
| | | 2849 | | { |
| | 4 | 2850 | | return uriFileName; |
| | | 2851 | | } |
| | | 2852 | | |
| | | 2853 | | // Fall back to media-type-based extension inference when no usable file name metadata is available, |
| | | 2854 | | // to at least get a correct extension for archive type detection and validation even if the base name is generi |
| | 1 | 2855 | | return TryGetServiceContentRootArchiveExtensionFromMediaType( |
| | 1 | 2856 | | response.Content.Headers.ContentType?.MediaType, |
| | 1 | 2857 | | out var archiveExtension) |
| | 1 | 2858 | | ? BuildServiceContentRootArchiveFileName("content-root", archiveExtension) |
| | 1 | 2859 | | : null; |
| | | 2860 | | } |
| | | 2861 | | |
| | | 2862 | | /// <summary> |
| | | 2863 | | /// Returns true when the package archive path uses the supported extension. |
| | | 2864 | | /// </summary> |
| | | 2865 | | /// <param name="archivePath">Archive file path.</param> |
| | | 2866 | | /// <returns>True when archive extension is supported.</returns> |
| | | 2867 | | private static bool IsSupportedServiceContentRootArchive(string archivePath) |
| | | 2868 | | { |
| | 14 | 2869 | | var lowerPath = archivePath.ToLowerInvariant(); |
| | 14 | 2870 | | return lowerPath.EndsWith(ServicePackageExtension, StringComparison.Ordinal) |
| | 14 | 2871 | | || lowerPath.EndsWith(".zip", StringComparison.Ordinal) |
| | 14 | 2872 | | || lowerPath.EndsWith(".tar", StringComparison.Ordinal) |
| | 14 | 2873 | | || lowerPath.EndsWith(".tar.gz", StringComparison.Ordinal) |
| | 14 | 2874 | | || lowerPath.EndsWith(".tgz", StringComparison.Ordinal); |
| | | 2875 | | } |
| | | 2876 | | |
| | | 2877 | | /// <summary> |
| | | 2878 | | /// Validates a content-root archive checksum when a checksum was provided. |
| | | 2879 | | /// </summary> |
| | | 2880 | | /// <param name="command">Parsed service command.</param> |
| | | 2881 | | /// <param name="archivePath">Archive path to validate.</param> |
| | | 2882 | | /// <param name="error">Error details when checksum validation fails.</param> |
| | | 2883 | | /// <returns>True when checksum is valid or not requested.</returns> |
| | | 2884 | | private static bool TryValidateServiceContentRootArchiveChecksum(ParsedCommand command, string archivePath, out stri |
| | | 2885 | | { |
| | 11 | 2886 | | error = string.Empty; |
| | 11 | 2887 | | if (string.IsNullOrWhiteSpace(command.ServiceContentRootChecksum)) |
| | | 2888 | | { |
| | 7 | 2889 | | return true; |
| | | 2890 | | } |
| | | 2891 | | |
| | 4 | 2892 | | var expectedHash = command.ServiceContentRootChecksum.Trim(); |
| | 4 | 2893 | | if (!Regex.IsMatch(expectedHash, "^[0-9a-fA-F]+$")) |
| | | 2894 | | { |
| | 1 | 2895 | | error = "--content-root-checksum must be a hexadecimal hash string."; |
| | 1 | 2896 | | return false; |
| | | 2897 | | } |
| | | 2898 | | |
| | 3 | 2899 | | var algorithmName = string.IsNullOrWhiteSpace(command.ServiceContentRootChecksumAlgorithm) |
| | 3 | 2900 | | ? "sha256" |
| | 3 | 2901 | | : command.ServiceContentRootChecksumAlgorithm.Trim(); |
| | | 2902 | | |
| | 3 | 2903 | | if (!TryCreateChecksumAlgorithm(algorithmName, out var algorithm, out var normalizedAlgorithmName, out error)) |
| | | 2904 | | { |
| | 0 | 2905 | | return false; |
| | | 2906 | | } |
| | | 2907 | | |
| | 3 | 2908 | | using (algorithm) |
| | 3 | 2909 | | using (var stream = File.OpenRead(archivePath)) |
| | | 2910 | | { |
| | 3 | 2911 | | var actualHash = Convert.ToHexString(algorithm.ComputeHash(stream)); |
| | 3 | 2912 | | if (!string.Equals(actualHash, expectedHash, StringComparison.OrdinalIgnoreCase)) |
| | | 2913 | | { |
| | 2 | 2914 | | error = $"Archive checksum mismatch for '{archivePath}'. Expected {normalizedAlgorithmName}:{expectedHas |
| | 2 | 2915 | | return false; |
| | | 2916 | | } |
| | 1 | 2917 | | } |
| | | 2918 | | |
| | 1 | 2919 | | return true; |
| | 2 | 2920 | | } |
| | | 2921 | | |
| | | 2922 | | /// <summary> |
| | | 2923 | | /// Creates a hash algorithm instance from a user-provided token. |
| | | 2924 | | /// </summary> |
| | | 2925 | | /// <param name="algorithmToken">Algorithm token from CLI.</param> |
| | | 2926 | | /// <param name="algorithm">Created hash algorithm instance.</param> |
| | | 2927 | | /// <param name="normalizedName">Normalized algorithm name.</param> |
| | | 2928 | | /// <param name="error">Validation error text when algorithm creation fails.</param> |
| | | 2929 | | /// <returns>True when the algorithm token is supported and can be created.</returns> |
| | | 2930 | | private static bool TryCreateChecksumAlgorithm(string algorithmToken, out HashAlgorithm algorithm, out string normal |
| | | 2931 | | { |
| | 5 | 2932 | | algorithm = null!; |
| | 5 | 2933 | | normalizedName = string.Empty; |
| | 5 | 2934 | | error = string.Empty; |
| | | 2935 | | |
| | 5 | 2936 | | var compact = algorithmToken.Replace("-", string.Empty, StringComparison.Ordinal).Trim().ToLowerInvariant(); |
| | | 2937 | | |
| | 5 | 2938 | | Func<HashAlgorithm>? algorithmFactory = compact switch |
| | 5 | 2939 | | { |
| | 0 | 2940 | | "md5" => MD5.Create, |
| | 0 | 2941 | | "sha1" or "sha" => SHA1.Create, |
| | 4 | 2942 | | "sha2" or "sha256" => SHA256.Create, |
| | 0 | 2943 | | "sha384" => SHA384.Create, |
| | 0 | 2944 | | "sha512" => SHA512.Create, |
| | 1 | 2945 | | _ => null, |
| | 5 | 2946 | | }; |
| | | 2947 | | |
| | 5 | 2948 | | if (algorithmFactory is null) |
| | | 2949 | | { |
| | 1 | 2950 | | error = "Unsupported --content-root-checksum-algorithm. Supported values: md5, sha1, sha256, sha384, sha512. |
| | 1 | 2951 | | return false; |
| | | 2952 | | } |
| | | 2953 | | |
| | 4 | 2954 | | normalizedName = compact switch |
| | 4 | 2955 | | { |
| | 0 | 2956 | | "sha" => "sha1", |
| | 1 | 2957 | | "sha2" => "sha256", |
| | 3 | 2958 | | _ => compact, |
| | 4 | 2959 | | }; |
| | | 2960 | | |
| | | 2961 | | try |
| | | 2962 | | { |
| | 4 | 2963 | | algorithm = algorithmFactory(); |
| | 4 | 2964 | | return true; |
| | | 2965 | | } |
| | 0 | 2966 | | catch (Exception ex) |
| | | 2967 | | { |
| | 0 | 2968 | | error = $"Unable to create checksum algorithm '{normalizedName}'. The algorithm may be disabled by system po |
| | 0 | 2969 | | algorithm = null!; |
| | 0 | 2970 | | normalizedName = string.Empty; |
| | 0 | 2971 | | return false; |
| | | 2972 | | } |
| | 4 | 2973 | | } |
| | | 2974 | | |
| | | 2975 | | /// <summary> |
| | | 2976 | | /// Extracts a supported archive into the specified target directory. |
| | | 2977 | | /// </summary> |
| | | 2978 | | /// <param name="archivePath">Archive file path.</param> |
| | | 2979 | | /// <param name="destinationDirectory">Extraction destination directory.</param> |
| | | 2980 | | /// <param name="error">Error details when extraction fails.</param> |
| | | 2981 | | /// <returns>True when extraction succeeds.</returns> |
| | | 2982 | | private static bool TryExtractServiceContentRootArchive(string archivePath, string destinationDirectory, out string |
| | | 2983 | | { |
| | 7 | 2984 | | error = string.Empty; |
| | | 2985 | | |
| | | 2986 | | try |
| | | 2987 | | { |
| | 7 | 2988 | | var lowerPath = archivePath.ToLowerInvariant(); |
| | 7 | 2989 | | if (lowerPath.EndsWith(ServicePackageExtension, StringComparison.Ordinal) |
| | 7 | 2990 | | || lowerPath.EndsWith(".zip", StringComparison.Ordinal)) |
| | | 2991 | | { |
| | 5 | 2992 | | return TryExtractZipArchiveSafely(archivePath, destinationDirectory, out error); |
| | | 2993 | | } |
| | | 2994 | | |
| | 2 | 2995 | | if (lowerPath.EndsWith(".tar", StringComparison.Ordinal)) |
| | | 2996 | | { |
| | 0 | 2997 | | return TryExtractTarArchiveSafely(File.OpenRead(archivePath), destinationDirectory, out error); |
| | | 2998 | | } |
| | | 2999 | | |
| | 2 | 3000 | | if (lowerPath.EndsWith(".tar.gz", StringComparison.Ordinal) || lowerPath.EndsWith(".tgz", StringComparison.O |
| | | 3001 | | { |
| | 2 | 3002 | | using var archiveStream = File.OpenRead(archivePath); |
| | 2 | 3003 | | using var gzipStream = new GZipStream(archiveStream, CompressionMode.Decompress); |
| | 2 | 3004 | | return TryExtractTarArchiveSafely(gzipStream, destinationDirectory, out error); |
| | | 3005 | | } |
| | | 3006 | | |
| | 0 | 3007 | | error = $"Unsupported package format. Supported extension: {ServicePackageExtension} (zip payload)."; |
| | 0 | 3008 | | return false; |
| | | 3009 | | } |
| | 0 | 3010 | | catch (Exception ex) |
| | | 3011 | | { |
| | 0 | 3012 | | error = $"Failed to extract service content archive '{archivePath}': {ex.Message}"; |
| | 0 | 3013 | | return false; |
| | | 3014 | | } |
| | 7 | 3015 | | } |
| | | 3016 | | |
| | | 3017 | | /// <summary> |
| | | 3018 | | /// Extracts a zip archive while enforcing destination path boundaries. |
| | | 3019 | | /// </summary> |
| | | 3020 | | /// <param name="archivePath">Archive file path.</param> |
| | | 3021 | | /// <param name="destinationDirectory">Extraction destination directory.</param> |
| | | 3022 | | /// <param name="error">Error details when extraction fails.</param> |
| | | 3023 | | /// <returns>True when extraction succeeds.</returns> |
| | | 3024 | | private static bool TryExtractZipArchiveSafely(string archivePath, string destinationDirectory, out string error) |
| | | 3025 | | { |
| | 17 | 3026 | | error = string.Empty; |
| | 17 | 3027 | | using var archive = ZipFile.OpenRead(archivePath); |
| | 154 | 3028 | | foreach (var entry in archive.Entries) |
| | | 3029 | | { |
| | 60 | 3030 | | var fullDestinationPath = Path.GetFullPath(Path.Combine(destinationDirectory, entry.FullName)); |
| | 60 | 3031 | | if (!IsPathWithinDirectory(fullDestinationPath, destinationDirectory)) |
| | | 3032 | | { |
| | 0 | 3033 | | error = $"Archive entry '{entry.FullName}' escapes extraction root."; |
| | 0 | 3034 | | return false; |
| | | 3035 | | } |
| | | 3036 | | |
| | 60 | 3037 | | var isDirectory = string.IsNullOrEmpty(entry.Name) |
| | 60 | 3038 | | || entry.FullName.EndsWith('/') |
| | 60 | 3039 | | || entry.FullName.EndsWith('\\'); |
| | 60 | 3040 | | if (isDirectory) |
| | | 3041 | | { |
| | 0 | 3042 | | _ = Directory.CreateDirectory(fullDestinationPath); |
| | 0 | 3043 | | continue; |
| | | 3044 | | } |
| | | 3045 | | |
| | 60 | 3046 | | var parentDirectory = Path.GetDirectoryName(fullDestinationPath); |
| | 60 | 3047 | | if (!string.IsNullOrWhiteSpace(parentDirectory)) |
| | | 3048 | | { |
| | 60 | 3049 | | _ = Directory.CreateDirectory(parentDirectory); |
| | | 3050 | | } |
| | | 3051 | | |
| | 60 | 3052 | | entry.ExtractToFile(fullDestinationPath, overwrite: true); |
| | | 3053 | | } |
| | | 3054 | | |
| | 17 | 3055 | | return true; |
| | 17 | 3056 | | } |
| | | 3057 | | |
| | | 3058 | | /// <summary> |
| | | 3059 | | /// Extracts a tar stream while enforcing destination path boundaries. |
| | | 3060 | | /// </summary> |
| | | 3061 | | /// <param name="archiveStream">Tar-formatted stream.</param> |
| | | 3062 | | /// <param name="destinationDirectory">Extraction destination directory.</param> |
| | | 3063 | | /// <param name="error">Error details when extraction fails.</param> |
| | | 3064 | | /// <returns>True when extraction succeeds.</returns> |
| | | 3065 | | private static bool TryExtractTarArchiveSafely(Stream archiveStream, string destinationDirectory, out string error) |
| | | 3066 | | { |
| | 2 | 3067 | | error = string.Empty; |
| | 2 | 3068 | | using var reader = new TarReader(archiveStream, leaveOpen: false); |
| | | 3069 | | TarEntry? entry; |
| | 7 | 3070 | | while ((entry = reader.GetNextEntry()) is not null) |
| | | 3071 | | { |
| | 5 | 3072 | | if (string.IsNullOrWhiteSpace(entry.Name)) |
| | | 3073 | | { |
| | | 3074 | | continue; |
| | | 3075 | | } |
| | | 3076 | | |
| | 5 | 3077 | | var fullDestinationPath = Path.GetFullPath(Path.Combine(destinationDirectory, entry.Name)); |
| | 5 | 3078 | | if (!IsPathWithinDirectory(fullDestinationPath, destinationDirectory)) |
| | | 3079 | | { |
| | 0 | 3080 | | error = $"Archive entry '{entry.Name}' escapes extraction root."; |
| | 0 | 3081 | | return false; |
| | | 3082 | | } |
| | | 3083 | | |
| | 5 | 3084 | | if (entry.EntryType is TarEntryType.Directory) |
| | | 3085 | | { |
| | 0 | 3086 | | _ = Directory.CreateDirectory(fullDestinationPath); |
| | 0 | 3087 | | continue; |
| | | 3088 | | } |
| | | 3089 | | |
| | 5 | 3090 | | if (entry.EntryType is TarEntryType.RegularFile or TarEntryType.V7RegularFile) |
| | | 3091 | | { |
| | 5 | 3092 | | var parentDirectory = Path.GetDirectoryName(fullDestinationPath); |
| | 5 | 3093 | | if (!string.IsNullOrWhiteSpace(parentDirectory)) |
| | | 3094 | | { |
| | 5 | 3095 | | _ = Directory.CreateDirectory(parentDirectory); |
| | | 3096 | | } |
| | | 3097 | | |
| | 5 | 3098 | | if (entry.DataStream is null) |
| | | 3099 | | { |
| | 0 | 3100 | | using var emptyFile = File.Create(fullDestinationPath); |
| | 0 | 3101 | | continue; |
| | | 3102 | | } |
| | | 3103 | | |
| | 5 | 3104 | | using var output = File.Create(fullDestinationPath); |
| | 5 | 3105 | | entry.DataStream.CopyTo(output); |
| | 5 | 3106 | | continue; |
| | | 3107 | | } |
| | | 3108 | | } |
| | | 3109 | | |
| | 2 | 3110 | | return true; |
| | 2 | 3111 | | } |
| | | 3112 | | |
| | | 3113 | | /// <summary> |
| | | 3114 | | /// Checks whether a path is inside (or equal to) a given directory. |
| | | 3115 | | /// </summary> |
| | | 3116 | | /// <param name="candidatePath">Candidate absolute path.</param> |
| | | 3117 | | /// <param name="directoryPath">Directory absolute path.</param> |
| | | 3118 | | /// <returns>True when candidate is within the directory tree.</returns> |
| | | 3119 | | private static bool IsPathWithinDirectory(string candidatePath, string directoryPath) |
| | | 3120 | | { |
| | 81 | 3121 | | var fullCandidate = Path.GetFullPath(candidatePath) |
| | 81 | 3122 | | .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); |
| | 81 | 3123 | | var fullDirectory = Path.GetFullPath(directoryPath) |
| | 81 | 3124 | | .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); |
| | 81 | 3125 | | var comparison = OperatingSystem.IsWindows() || OperatingSystem.IsMacOS() |
| | 81 | 3126 | | ? StringComparison.OrdinalIgnoreCase |
| | 81 | 3127 | | : StringComparison.Ordinal; |
| | | 3128 | | |
| | 81 | 3129 | | return fullCandidate.Equals(fullDirectory, comparison) |
| | 81 | 3130 | | || fullCandidate.StartsWith(fullDirectory + Path.DirectorySeparatorChar, comparison) |
| | 81 | 3131 | | || fullCandidate.StartsWith(fullDirectory + Path.AltDirectorySeparatorChar, comparison); |
| | | 3132 | | } |
| | | 3133 | | |
| | | 3134 | | /// <summary> |
| | | 3135 | | /// Resolves the deployment root path used for service bundles. |
| | | 3136 | | /// </summary> |
| | | 3137 | | /// <param name="deploymentRootOverride">Optional explicit root path.</param> |
| | | 3138 | | /// <param name="deploymentRoot">Resolved writable deployment root.</param> |
| | | 3139 | | /// <param name="error">Error details when no writable root is available.</param> |
| | | 3140 | | /// <returns>True when a writable deployment root is resolved.</returns> |
| | | 3141 | | private static bool TryResolveServiceDeploymentRoot(string? deploymentRootOverride, out string deploymentRoot, out s |
| | | 3142 | | { |
| | 6 | 3143 | | deploymentRoot = string.Empty; |
| | 6 | 3144 | | error = string.Empty; |
| | | 3145 | | |
| | 6 | 3146 | | if (!string.IsNullOrWhiteSpace(deploymentRootOverride)) |
| | | 3147 | | { |
| | 6 | 3148 | | var overrideRoot = Path.GetFullPath(deploymentRootOverride); |
| | 6 | 3149 | | if (!TryEnsureDirectoryWritable(overrideRoot, out var overrideError)) |
| | | 3150 | | { |
| | 1 | 3151 | | error = $"Unable to use deployment root '{deploymentRootOverride}': {overrideError}"; |
| | 1 | 3152 | | return false; |
| | | 3153 | | } |
| | | 3154 | | |
| | 5 | 3155 | | deploymentRoot = overrideRoot; |
| | 5 | 3156 | | return true; |
| | | 3157 | | } |
| | | 3158 | | |
| | 0 | 3159 | | var failures = new List<string>(); |
| | 0 | 3160 | | foreach (var candidate in GetServiceDeploymentRootCandidates()) |
| | | 3161 | | { |
| | 0 | 3162 | | if (string.IsNullOrWhiteSpace(candidate)) |
| | | 3163 | | { |
| | | 3164 | | continue; |
| | | 3165 | | } |
| | | 3166 | | |
| | | 3167 | | try |
| | | 3168 | | { |
| | 0 | 3169 | | var fullCandidate = Path.GetFullPath(candidate); |
| | 0 | 3170 | | if (!TryEnsureDirectoryWritable(fullCandidate, out var candidateError)) |
| | | 3171 | | { |
| | 0 | 3172 | | failures.Add($"{candidate} ({candidateError})"); |
| | 0 | 3173 | | continue; |
| | | 3174 | | } |
| | | 3175 | | |
| | 0 | 3176 | | deploymentRoot = fullCandidate; |
| | 0 | 3177 | | return true; |
| | | 3178 | | } |
| | 0 | 3179 | | catch (Exception ex) |
| | | 3180 | | { |
| | 0 | 3181 | | failures.Add($"{candidate} ({ex.Message})"); |
| | 0 | 3182 | | } |
| | | 3183 | | } |
| | | 3184 | | |
| | 0 | 3185 | | error = failures.Count == 0 |
| | 0 | 3186 | | ? "Unable to resolve a writable service deployment root." |
| | 0 | 3187 | | : $"Unable to resolve a writable service deployment root. Attempted: {string.Join("; ", failures)}"; |
| | 0 | 3188 | | return false; |
| | 0 | 3189 | | } |
| | | 3190 | | |
| | | 3191 | | /// <summary> |
| | | 3192 | | /// Ensures a directory is writable by creating and deleting a short-lived probe file. |
| | | 3193 | | /// </summary> |
| | | 3194 | | /// <param name="directoryPath">Directory path to validate.</param> |
| | | 3195 | | /// <param name="error">Error details when the path is not writable.</param> |
| | | 3196 | | /// <returns>True when the directory can be created and written to.</returns> |
| | | 3197 | | private static bool TryEnsureDirectoryWritable(string directoryPath, out string error) |
| | | 3198 | | { |
| | 6 | 3199 | | error = string.Empty; |
| | | 3200 | | |
| | | 3201 | | try |
| | | 3202 | | { |
| | 6 | 3203 | | _ = Directory.CreateDirectory(directoryPath); |
| | 5 | 3204 | | var probePath = Path.Combine(directoryPath, $".kestrun-write-probe-{Guid.NewGuid():N}"); |
| | 5 | 3205 | | File.WriteAllText(probePath, "ok"); |
| | 5 | 3206 | | File.Delete(probePath); |
| | 5 | 3207 | | return true; |
| | | 3208 | | } |
| | 1 | 3209 | | catch (Exception ex) |
| | | 3210 | | { |
| | 1 | 3211 | | error = ex.Message; |
| | 1 | 3212 | | return false; |
| | | 3213 | | } |
| | 6 | 3214 | | } |
| | | 3215 | | |
| | | 3216 | | /// <summary> |
| | | 3217 | | /// Returns candidate deployment roots for service bundle storage. |
| | | 3218 | | /// </summary> |
| | | 3219 | | /// <returns>Candidate absolute or rooted paths in priority order.</returns> |
| | | 3220 | | private static IEnumerable<string> GetServiceDeploymentRootCandidates() |
| | | 3221 | | { |
| | 10 | 3222 | | if (OperatingSystem.IsWindows()) |
| | | 3223 | | { |
| | 0 | 3224 | | yield return Path.Combine( |
| | 0 | 3225 | | Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), |
| | 0 | 3226 | | ServiceDeploymentProductFolderName, |
| | 0 | 3227 | | ServiceDeploymentServicesFolderName); |
| | 0 | 3228 | | yield break; |
| | | 3229 | | } |
| | | 3230 | | |
| | 10 | 3231 | | if (OperatingSystem.IsLinux()) |
| | | 3232 | | { |
| | 10 | 3233 | | yield return "/var/kestrun/services"; |
| | 10 | 3234 | | yield return "/usr/local/kestrun/services"; |
| | | 3235 | | |
| | 10 | 3236 | | var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); |
| | 10 | 3237 | | if (!string.IsNullOrWhiteSpace(userProfile)) |
| | | 3238 | | { |
| | 10 | 3239 | | yield return Path.Combine(userProfile, ".local", "share", "kestrun", "services"); |
| | | 3240 | | } |
| | | 3241 | | |
| | 10 | 3242 | | yield break; |
| | | 3243 | | } |
| | | 3244 | | |
| | 0 | 3245 | | if (OperatingSystem.IsMacOS()) |
| | | 3246 | | { |
| | 0 | 3247 | | yield return "/usr/local/kestrun/services"; |
| | | 3248 | | |
| | 0 | 3249 | | var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); |
| | 0 | 3250 | | if (!string.IsNullOrWhiteSpace(userProfile)) |
| | | 3251 | | { |
| | 0 | 3252 | | yield return Path.Combine(userProfile, "Library", "Application Support", "Kestrun", "services"); |
| | | 3253 | | } |
| | | 3254 | | |
| | 0 | 3255 | | yield break; |
| | | 3256 | | } |
| | | 3257 | | |
| | 0 | 3258 | | yield return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Kestrun", |
| | 0 | 3259 | | } |
| | | 3260 | | |
| | | 3261 | | /// <summary> |
| | | 3262 | | /// Removes service bundle directories for a given service name from known deployment roots. |
| | | 3263 | | /// </summary> |
| | | 3264 | | /// <param name="serviceName">Service name.</param> |
| | | 3265 | | private static void TryRemoveServiceBundle(string serviceName, string? deploymentRootOverride = null) |
| | | 3266 | | { |
| | 1 | 3267 | | var serviceDirectoryName = GetServiceDeploymentDirectoryName(serviceName); |
| | 1 | 3268 | | var printedPermissionHint = false; |
| | | 3269 | | |
| | 1 | 3270 | | var candidateRoots = new List<string>(); |
| | 1 | 3271 | | if (!string.IsNullOrWhiteSpace(deploymentRootOverride)) |
| | | 3272 | | { |
| | 1 | 3273 | | candidateRoots.Add(deploymentRootOverride); |
| | | 3274 | | } |
| | | 3275 | | |
| | 1 | 3276 | | candidateRoots.AddRange(GetServiceDeploymentRootCandidates()); |
| | | 3277 | | |
| | 10 | 3278 | | foreach (var candidateRoot in candidateRoots.Distinct(StringComparer.OrdinalIgnoreCase)) |
| | | 3279 | | { |
| | 4 | 3280 | | if (string.IsNullOrWhiteSpace(candidateRoot)) |
| | | 3281 | | { |
| | | 3282 | | continue; |
| | | 3283 | | } |
| | | 3284 | | |
| | 4 | 3285 | | var serviceRoot = Path.Combine(candidateRoot, serviceDirectoryName); |
| | | 3286 | | try |
| | | 3287 | | { |
| | 4 | 3288 | | if (OperatingSystem.IsWindows()) |
| | | 3289 | | { |
| | 0 | 3290 | | TryDeleteDirectoryWithRetry(serviceRoot, maxAttempts: 15, initialDelayMs: 250); |
| | | 3291 | | } |
| | | 3292 | | else |
| | | 3293 | | { |
| | 4 | 3294 | | TryDeleteDirectoryWithRetry(serviceRoot); |
| | | 3295 | | } |
| | 4 | 3296 | | } |
| | 0 | 3297 | | catch (Exception ex) |
| | | 3298 | | { |
| | 0 | 3299 | | if (IsExpectedUnixProtectedRootCleanupFailure(candidateRoot, ex, deploymentRootOverride)) |
| | | 3300 | | { |
| | 0 | 3301 | | if (!printedPermissionHint) |
| | | 3302 | | { |
| | 0 | 3303 | | Console.Error.WriteLine("Info: Skipping cleanup of root-owned service bundle locations. Use sudo |
| | 0 | 3304 | | printedPermissionHint = true; |
| | | 3305 | | } |
| | | 3306 | | |
| | 0 | 3307 | | continue; |
| | | 3308 | | } |
| | | 3309 | | |
| | 0 | 3310 | | Console.Error.WriteLine($"Warning: Failed to remove service bundle '{serviceRoot}': {ex.Message}"); |
| | 0 | 3311 | | } |
| | | 3312 | | } |
| | 1 | 3313 | | } |
| | | 3314 | | |
| | | 3315 | | /// <summary> |
| | | 3316 | | /// Returns true when cleanup failures are expected for protected Unix roots owned by another user. |
| | | 3317 | | /// </summary> |
| | | 3318 | | /// <param name="candidateRoot">Deployment root candidate being cleaned.</param> |
| | | 3319 | | /// <param name="exception">Raised exception.</param> |
| | | 3320 | | /// <param name="deploymentRootOverride">Optional explicit deployment root override.</param> |
| | | 3321 | | /// <returns>True when the error can be downgraded to informational output.</returns> |
| | | 3322 | | private static bool IsExpectedUnixProtectedRootCleanupFailure(string candidateRoot, Exception exception, string? dep |
| | | 3323 | | { |
| | 0 | 3324 | | if (!string.IsNullOrWhiteSpace(deploymentRootOverride)) |
| | | 3325 | | { |
| | 0 | 3326 | | return false; |
| | | 3327 | | } |
| | | 3328 | | |
| | 0 | 3329 | | if (exception is not UnauthorizedAccessException) |
| | | 3330 | | { |
| | 0 | 3331 | | return false; |
| | | 3332 | | } |
| | | 3333 | | |
| | 0 | 3334 | | if (!(OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())) |
| | | 3335 | | { |
| | 0 | 3336 | | return false; |
| | | 3337 | | } |
| | | 3338 | | |
| | 0 | 3339 | | if (IsLikelyRunningAsRootOnUnix()) |
| | | 3340 | | { |
| | 0 | 3341 | | return false; |
| | | 3342 | | } |
| | | 3343 | | |
| | | 3344 | | // Cleanup failures for protected system roots are expected when running as a non-root user on Unix, so downgrad |
| | 0 | 3345 | | return IsProtectedUnixServiceRoot(candidateRoot); |
| | | 3346 | | } |
| | | 3347 | | |
| | | 3348 | | /// <summary> |
| | | 3349 | | /// Returns true when the path is a protected system root used for service bundle fallback on Unix. |
| | | 3350 | | /// </summary> |
| | | 3351 | | /// <param name="candidateRoot">Deployment root candidate.</param> |
| | | 3352 | | /// <returns>True when path is a protected system root.</returns> |
| | | 3353 | | private static bool IsProtectedUnixServiceRoot(string candidateRoot) |
| | | 3354 | | { |
| | 0 | 3355 | | if (string.IsNullOrWhiteSpace(candidateRoot)) |
| | | 3356 | | { |
| | 0 | 3357 | | return false; |
| | | 3358 | | } |
| | | 3359 | | |
| | 0 | 3360 | | var fullCandidate = Path.GetFullPath(candidateRoot) |
| | 0 | 3361 | | .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); |
| | | 3362 | | |
| | 0 | 3363 | | return string.Equals(fullCandidate, "/var/kestrun/services", StringComparison.Ordinal) |
| | 0 | 3364 | | || string.Equals(fullCandidate, "/usr/local/kestrun/services", StringComparison.Ordinal); |
| | | 3365 | | } |
| | | 3366 | | |
| | | 3367 | | /// <summary> |
| | | 3368 | | /// Deletes a directory recursively with retry/backoff for transient file-lock scenarios. |
| | | 3369 | | /// </summary> |
| | | 3370 | | /// <param name="directoryPath">Directory path to delete.</param> |
| | | 3371 | | /// <param name="maxAttempts">Maximum number of attempts.</param> |
| | | 3372 | | /// <param name="initialDelayMs">Initial delay between attempts in milliseconds.</param> |
| | | 3373 | | private static void TryDeleteDirectoryWithRetry(string directoryPath, int maxAttempts = 5, int initialDelayMs = 200) |
| | | 3374 | | { |
| | 73 | 3375 | | if (!Directory.Exists(directoryPath)) |
| | | 3376 | | { |
| | 4 | 3377 | | return; |
| | | 3378 | | } |
| | | 3379 | | |
| | 69 | 3380 | | var attempt = 0; |
| | 69 | 3381 | | var delayMs = initialDelayMs; |
| | 69 | 3382 | | Exception? lastError = null; |
| | | 3383 | | |
| | 69 | 3384 | | while (attempt < maxAttempts) |
| | | 3385 | | { |
| | | 3386 | | try |
| | | 3387 | | { |
| | 69 | 3388 | | Directory.Delete(directoryPath, recursive: true); |
| | 69 | 3389 | | return; |
| | | 3390 | | } |
| | 0 | 3391 | | catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) |
| | | 3392 | | { |
| | 0 | 3393 | | lastError = ex; |
| | 0 | 3394 | | attempt += 1; |
| | 0 | 3395 | | if (attempt >= maxAttempts) |
| | | 3396 | | { |
| | 0 | 3397 | | break; |
| | | 3398 | | } |
| | | 3399 | | |
| | 0 | 3400 | | Thread.Sleep(delayMs); |
| | 0 | 3401 | | delayMs = Math.Min(delayMs * 2, 2000); |
| | 0 | 3402 | | } |
| | | 3403 | | } |
| | | 3404 | | |
| | 0 | 3405 | | if (lastError is not null) |
| | | 3406 | | { |
| | 0 | 3407 | | throw lastError; |
| | | 3408 | | } |
| | 69 | 3409 | | } |
| | | 3410 | | |
| | | 3411 | | /// <summary> |
| | | 3412 | | /// Returns a filesystem-safe directory name for service deployment folders. |
| | | 3413 | | /// </summary> |
| | | 3414 | | /// <param name="serviceName">Service name.</param> |
| | | 3415 | | /// <returns>Sanitized directory name.</returns> |
| | | 3416 | | private static string GetServiceDeploymentDirectoryName(string serviceName) |
| | | 3417 | | { |
| | 15 | 3418 | | var invalid = Path.GetInvalidFileNameChars(); |
| | 15 | 3419 | | var builder = new StringBuilder(serviceName.Length); |
| | 426 | 3420 | | foreach (var ch in serviceName) |
| | | 3421 | | { |
| | 198 | 3422 | | if (char.IsControl(ch) || ch == Path.DirectorySeparatorChar || ch == Path.AltDirectorySeparatorChar || inval |
| | | 3423 | | { |
| | 0 | 3424 | | _ = builder.Append('-'); |
| | 0 | 3425 | | continue; |
| | | 3426 | | } |
| | | 3427 | | |
| | 198 | 3428 | | _ = builder.Append(ch); |
| | | 3429 | | } |
| | | 3430 | | |
| | 15 | 3431 | | var sanitized = builder.ToString().Trim().Trim('.'); |
| | 15 | 3432 | | return string.IsNullOrWhiteSpace(sanitized) ? "service" : sanitized; |
| | | 3433 | | } |
| | | 3434 | | |
| | | 3435 | | /// <summary> |
| | | 3436 | | /// Resolves runtime RID segment for service runtime payloads. |
| | | 3437 | | /// </summary> |
| | | 3438 | | /// <param name="runtimeRid">RID segment (for example win-x64).</param> |
| | | 3439 | | /// <param name="error">Error details when runtime architecture is unsupported.</param> |
| | | 3440 | | /// <returns>True when runtime RID can be resolved.</returns> |
| | | 3441 | | private static bool TryGetServiceRuntimeRid(out string runtimeRid, out string error) |
| | | 3442 | | { |
| | 44 | 3443 | | runtimeRid = string.Empty; |
| | 44 | 3444 | | error = string.Empty; |
| | | 3445 | | |
| | 44 | 3446 | | var osPrefix = OperatingSystem.IsWindows() |
| | 44 | 3447 | | ? "win" |
| | 44 | 3448 | | : OperatingSystem.IsLinux() |
| | 44 | 3449 | | ? "linux" |
| | 44 | 3450 | | : OperatingSystem.IsMacOS() |
| | 44 | 3451 | | ? "osx" |
| | 44 | 3452 | | : string.Empty; |
| | | 3453 | | |
| | 44 | 3454 | | if (string.IsNullOrWhiteSpace(osPrefix)) |
| | | 3455 | | { |
| | 0 | 3456 | | error = "Service runtime bundling is not supported on this operating system."; |
| | 0 | 3457 | | return false; |
| | | 3458 | | } |
| | | 3459 | | |
| | 44 | 3460 | | var architecture = RuntimeInformation.ProcessArchitecture switch |
| | 44 | 3461 | | { |
| | 44 | 3462 | | Architecture.X64 => "x64", |
| | 0 | 3463 | | Architecture.Arm64 => "arm64", |
| | 0 | 3464 | | _ => string.Empty, |
| | 44 | 3465 | | }; |
| | | 3466 | | |
| | 44 | 3467 | | if (string.IsNullOrWhiteSpace(architecture)) |
| | | 3468 | | { |
| | 0 | 3469 | | error = $"Service runtime bundling does not support process architecture '{RuntimeInformation.ProcessArchite |
| | 0 | 3470 | | return false; |
| | | 3471 | | } |
| | | 3472 | | |
| | 44 | 3473 | | runtimeRid = $"{osPrefix}-{architecture}"; |
| | 44 | 3474 | | return true; |
| | | 3475 | | } |
| | | 3476 | | |
| | | 3477 | | /// <summary> |
| | | 3478 | | /// Ensures execute permissions are present for service runtime files on Unix platforms. |
| | | 3479 | | /// </summary> |
| | | 3480 | | /// <param name="runtimePath">Runtime executable file path.</param> |
| | | 3481 | | [SupportedOSPlatform("linux")] |
| | | 3482 | | [SupportedOSPlatform("macos")] |
| | | 3483 | | private static void TryEnsureServiceRuntimeExecutablePermissions(string runtimePath) |
| | | 3484 | | { |
| | | 3485 | | try |
| | | 3486 | | { |
| | 8 | 3487 | | var mode = File.GetUnixFileMode(runtimePath); |
| | 8 | 3488 | | mode |= UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute; |
| | 8 | 3489 | | File.SetUnixFileMode(runtimePath, mode); |
| | 8 | 3490 | | } |
| | 0 | 3491 | | catch |
| | | 3492 | | { |
| | | 3493 | | // Ignore permission update failures and let service startup report execution errors if needed. |
| | 0 | 3494 | | } |
| | 8 | 3495 | | } |
| | | 3496 | | |
| | | 3497 | | /// <summary> |
| | | 3498 | | /// Normalizes service log path input; directory input gets the default file name. |
| | | 3499 | | /// </summary> |
| | | 3500 | | /// <param name="inputPath">Configured path input.</param> |
| | | 3501 | | /// <param name="defaultFileName">Default file name for directory-only inputs.</param> |
| | | 3502 | | /// <returns>Absolute log file path.</returns> |
| | | 3503 | | private static string NormalizeServiceLogPath(string inputPath, string defaultFileName) |
| | | 3504 | | { |
| | 6 | 3505 | | var fullPath = Path.GetFullPath(inputPath); |
| | 6 | 3506 | | return Directory.Exists(fullPath) |
| | 6 | 3507 | | || inputPath.EndsWith('\\') |
| | 6 | 3508 | | || inputPath.EndsWith('/') |
| | 6 | 3509 | | ? Path.Combine(fullPath, defaultFileName) |
| | 6 | 3510 | | : fullPath; |
| | | 3511 | | } |
| | | 3512 | | |
| | | 3513 | | /// <summary> |
| | | 3514 | | /// Escapes XML-sensitive characters. |
| | | 3515 | | /// </summary> |
| | | 3516 | | /// <param name="input">Raw input string.</param> |
| | | 3517 | | /// <returns>Escaped XML value.</returns> |
| | | 3518 | | private static string EscapeXml(string input) |
| | | 3519 | | { |
| | 11 | 3520 | | return input |
| | 11 | 3521 | | .Replace("&", "&", StringComparison.Ordinal) |
| | 11 | 3522 | | .Replace("<", "<", StringComparison.Ordinal) |
| | 11 | 3523 | | .Replace(">", ">", StringComparison.Ordinal) |
| | 11 | 3524 | | .Replace("\"", """, StringComparison.Ordinal) |
| | 11 | 3525 | | .Replace("'", "'", StringComparison.Ordinal); |
| | | 3526 | | } |
| | | 3527 | | |
| | | 3528 | | /// <summary> |
| | | 3529 | | /// Escapes one token for systemd ExecStart parsing. |
| | | 3530 | | /// </summary> |
| | | 3531 | | /// <param name="input">Raw token.</param> |
| | | 3532 | | /// <returns>Escaped token.</returns> |
| | | 3533 | | private static string EscapeSystemdToken(string input) |
| | | 3534 | | { |
| | 17 | 3535 | | if (string.IsNullOrEmpty(input)) |
| | | 3536 | | { |
| | 0 | 3537 | | return "\"\""; |
| | | 3538 | | } |
| | | 3539 | | |
| | 17 | 3540 | | var escaped = input |
| | 17 | 3541 | | .Replace("\\", "\\\\", StringComparison.Ordinal) |
| | 17 | 3542 | | .Replace(" ", "\\ ", StringComparison.Ordinal) |
| | 17 | 3543 | | .Replace("\"", "\\\"", StringComparison.Ordinal) |
| | 17 | 3544 | | .Replace("'", "\\'", StringComparison.Ordinal) |
| | 17 | 3545 | | .Replace(";", "\\;", StringComparison.Ordinal) |
| | 17 | 3546 | | .Replace("$", "\\$", StringComparison.Ordinal); |
| | | 3547 | | |
| | 17 | 3548 | | return escaped; |
| | | 3549 | | } |
| | | 3550 | | |
| | | 3551 | | /// <summary> |
| | | 3552 | | /// Builds a Windows command-line string with proper escaping for each token. |
| | | 3553 | | /// </summary> |
| | | 3554 | | /// <param name="exePath">Executable path.</param> |
| | | 3555 | | /// <param name="args">Command-line arguments.</param> |
| | | 3556 | | /// <returns>Full command line string.</returns> |
| | | 3557 | | private static string BuildWindowsCommandLine(string exePath, IReadOnlyList<string> args) |
| | | 3558 | | { |
| | 1 | 3559 | | var all = new List<string>(1 + args.Count) { exePath }; |
| | 1 | 3560 | | all.AddRange(args); |
| | 1 | 3561 | | return string.Join(" ", all.Select(EscapeWindowsCommandLineArgument)); |
| | | 3562 | | } |
| | | 3563 | | |
| | | 3564 | | /// <summary> |
| | | 3565 | | /// Escapes one command-line argument using Windows CreateProcess rules. |
| | | 3566 | | /// </summary> |
| | | 3567 | | /// <param name="arg">Input argument.</param> |
| | | 3568 | | /// <returns>Escaped argument string.</returns> |
| | | 3569 | | private static string EscapeWindowsCommandLineArgument(string arg) |
| | | 3570 | | { |
| | 4 | 3571 | | if (arg.Length == 0) |
| | | 3572 | | { |
| | 0 | 3573 | | return "\"\""; |
| | | 3574 | | } |
| | | 3575 | | |
| | 32 | 3576 | | var requiresQuotes = arg.Any(c => char.IsWhiteSpace(c) || c == '"'); |
| | 4 | 3577 | | if (!requiresQuotes) |
| | | 3578 | | { |
| | 1 | 3579 | | return arg; |
| | | 3580 | | } |
| | | 3581 | | |
| | 3 | 3582 | | var result = new StringBuilder(arg.Length + 2); |
| | 3 | 3583 | | _ = result.Append('"'); |
| | 3 | 3584 | | var backslashes = 0; |
| | 124 | 3585 | | foreach (var c in arg) |
| | | 3586 | | { |
| | 59 | 3587 | | if (c == '\\') |
| | | 3588 | | { |
| | 0 | 3589 | | backslashes += 1; |
| | 0 | 3590 | | continue; |
| | | 3591 | | } |
| | | 3592 | | |
| | 59 | 3593 | | if (c == '"') |
| | | 3594 | | { |
| | 0 | 3595 | | _ = result.Append('\\', (backslashes * 2) + 1); |
| | 0 | 3596 | | _ = result.Append('"'); |
| | 0 | 3597 | | backslashes = 0; |
| | 0 | 3598 | | continue; |
| | | 3599 | | } |
| | | 3600 | | |
| | 59 | 3601 | | if (backslashes > 0) |
| | | 3602 | | { |
| | 0 | 3603 | | _ = result.Append('\\', backslashes); |
| | 0 | 3604 | | backslashes = 0; |
| | | 3605 | | } |
| | | 3606 | | |
| | 59 | 3607 | | _ = result.Append(c); |
| | | 3608 | | } |
| | | 3609 | | |
| | 3 | 3610 | | if (backslashes > 0) |
| | | 3611 | | { |
| | 0 | 3612 | | _ = result.Append('\\', backslashes * 2); |
| | | 3613 | | } |
| | | 3614 | | |
| | 3 | 3615 | | _ = result.Append('"'); |
| | 3 | 3616 | | return result.ToString(); |
| | | 3617 | | } |
| | | 3618 | | |
| | | 3619 | | /// <summary> |
| | | 3620 | | /// Builds a normalized systemd unit name. |
| | | 3621 | | /// </summary> |
| | | 3622 | | /// <param name="serviceName">Input service name.</param> |
| | | 3623 | | /// <returns>Sanitized unit file name.</returns> |
| | | 3624 | | private static string GetLinuxUnitName(string serviceName) |
| | | 3625 | | { |
| | 661 | 3626 | | var safeName = new string([.. serviceName.Select(c => char.IsLetterOrDigit(c) || c is '-' or '_' or '.' ? c : '- |
| | | 3627 | | |
| | 23 | 3628 | | return safeName.EndsWith(".service", StringComparison.OrdinalIgnoreCase) |
| | 23 | 3629 | | ? safeName |
| | 23 | 3630 | | : $"{safeName}.service"; |
| | | 3631 | | } |
| | | 3632 | | |
| | | 3633 | | /// <summary> |
| | | 3634 | | /// Returns true when the current Linux process is likely running as root. |
| | | 3635 | | /// </summary> |
| | | 3636 | | /// <returns>True when username resolves to root on Linux.</returns> |
| | 1 | 3637 | | private static bool IsLikelyRunningAsRootOnLinux() => OperatingSystem.IsLinux() && string.Equals(Environment.UserNam |
| | | 3638 | | |
| | | 3639 | | /// <summary> |
| | | 3640 | | /// Returns true when the current Unix process is likely running as root. |
| | | 3641 | | /// </summary> |
| | | 3642 | | /// <returns>True when username resolves to root on Linux or macOS.</returns> |
| | 0 | 3643 | | private static bool IsLikelyRunningAsRootOnUnix() => (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS()) |
| | 0 | 3644 | | && string.Equals(Environment.UserName, "root", StringComparison.Ordinal); |
| | | 3645 | | |
| | | 3646 | | /// <summary> |
| | | 3647 | | /// Writes actionable guidance for common user-level systemd failures on Linux. |
| | | 3648 | | /// </summary> |
| | | 3649 | | /// <param name="result">Captured process result from a failed systemctl --user call.</param> |
| | | 3650 | | private static void WriteLinuxUserSystemdFailureHint(ProcessResult result) |
| | | 3651 | | { |
| | 1 | 3652 | | if (!OperatingSystem.IsLinux()) |
| | | 3653 | | { |
| | 0 | 3654 | | return; |
| | | 3655 | | } |
| | | 3656 | | |
| | 1 | 3657 | | var diagnostics = string.IsNullOrWhiteSpace(result.Error) ? result.Output : result.Error; |
| | 1 | 3658 | | if (string.IsNullOrWhiteSpace(diagnostics)) |
| | | 3659 | | { |
| | 0 | 3660 | | return; |
| | | 3661 | | } |
| | | 3662 | | |
| | 1 | 3663 | | if (!diagnostics.Contains("Failed to connect to bus", StringComparison.OrdinalIgnoreCase) |
| | 1 | 3664 | | && !diagnostics.Contains("No medium found", StringComparison.OrdinalIgnoreCase) |
| | 1 | 3665 | | && !diagnostics.Contains("Access denied", StringComparison.OrdinalIgnoreCase) |
| | 1 | 3666 | | && !diagnostics.Contains("Permission denied", StringComparison.OrdinalIgnoreCase)) |
| | | 3667 | | { |
| | 0 | 3668 | | return; |
| | | 3669 | | } |
| | | 3670 | | |
| | 1 | 3671 | | Console.Error.WriteLine("Hint: Linux service commands use user-level systemd units (systemctl --user)."); |
| | 1 | 3672 | | Console.Error.WriteLine("Run install/start/stop/query/remove as the same non-root user that installed the unit." |
| | 1 | 3673 | | Console.Error.WriteLine("If running over SSH or a headless session, enable linger: sudo loginctl enable-linger < |
| | 1 | 3674 | | } |
| | | 3675 | | |
| | | 3676 | | /// <summary> |
| | | 3677 | | /// Runs a process and captures output for diagnostics. |
| | | 3678 | | /// </summary> |
| | | 3679 | | /// <param name="fileName">Executable to run.</param> |
| | | 3680 | | /// <param name="arguments">Argument tokens.</param> |
| | | 3681 | | /// <returns>Process result data.</returns> |
| | | 3682 | | private static ProcessResult RunProcess(string fileName, IReadOnlyList<string> arguments, bool writeStandardOutput = |
| | | 3683 | | { |
| | 11 | 3684 | | var startInfo = new ProcessStartInfo |
| | 11 | 3685 | | { |
| | 11 | 3686 | | FileName = fileName, |
| | 11 | 3687 | | UseShellExecute = false, |
| | 11 | 3688 | | RedirectStandardOutput = true, |
| | 11 | 3689 | | RedirectStandardError = true, |
| | 11 | 3690 | | CreateNoWindow = true, |
| | 11 | 3691 | | }; |
| | | 3692 | | |
| | 80 | 3693 | | foreach (var argument in arguments) |
| | | 3694 | | { |
| | 29 | 3695 | | startInfo.ArgumentList.Add(argument); |
| | | 3696 | | } |
| | | 3697 | | |
| | 11 | 3698 | | using var process = Process.Start(startInfo); |
| | 9 | 3699 | | if (process is null) |
| | | 3700 | | { |
| | 0 | 3701 | | return new ProcessResult(1, string.Empty, $"Failed to start process: {fileName}"); |
| | | 3702 | | } |
| | | 3703 | | |
| | 9 | 3704 | | var output = process.StandardOutput.ReadToEnd(); |
| | 9 | 3705 | | var error = process.StandardError.ReadToEnd(); |
| | 9 | 3706 | | process.WaitForExit(); |
| | | 3707 | | |
| | 9 | 3708 | | if (writeStandardOutput && !string.IsNullOrWhiteSpace(output)) |
| | | 3709 | | { |
| | 1 | 3710 | | Console.WriteLine(output.TrimEnd()); |
| | | 3711 | | } |
| | | 3712 | | |
| | 9 | 3713 | | return new ProcessResult(process.ExitCode, output, error); |
| | 9 | 3714 | | } |
| | | 3715 | | |
| | | 3716 | | /// <summary> |
| | | 3717 | | /// Captures child process execution results. |
| | | 3718 | | /// </summary> |
| | | 3719 | | /// <param name="ExitCode">Process exit code.</param> |
| | | 3720 | | /// <param name="Output">Captured standard output.</param> |
| | | 3721 | | /// <param name="Error">Captured standard error.</param> |
| | 53 | 3722 | | private sealed record ProcessResult(int ExitCode, string Output, string Error); |
| | | 3723 | | |
| | | 3724 | | /// <summary> |
| | | 3725 | | /// Resolves a module manifest path for run mode, preferring bundled service payload when no explicit path is provid |
| | | 3726 | | /// </summary> |
| | | 3727 | | /// <param name="kestrunManifestPath">Optional explicit manifest path.</param> |
| | | 3728 | | /// <param name="kestrunFolder">Optional module folder path.</param> |
| | | 3729 | | /// <returns>Absolute path to the resolved module manifest, or null when not found.</returns> |
| | | 3730 | | private static string? ResolveRunModuleManifestPath(string? kestrunManifestPath, string? kestrunFolder) |
| | | 3731 | | { |
| | 0 | 3732 | | if (!string.IsNullOrWhiteSpace(kestrunManifestPath) || !string.IsNullOrWhiteSpace(kestrunFolder)) |
| | | 3733 | | { |
| | 0 | 3734 | | return LocateModuleManifest(kestrunManifestPath, kestrunFolder); |
| | | 3735 | | } |
| | | 3736 | | |
| | 0 | 3737 | | if (TryResolvePowerShellModulesPayloadFromToolDistribution(out var modulesPayloadPath)) |
| | | 3738 | | { |
| | 0 | 3739 | | var bundledManifestPath = Path.Combine(modulesPayloadPath, ModuleName, ModuleManifestFileName); |
| | 0 | 3740 | | if (File.Exists(bundledManifestPath)) |
| | | 3741 | | { |
| | 0 | 3742 | | return Path.GetFullPath(bundledManifestPath); |
| | | 3743 | | } |
| | | 3744 | | } |
| | | 3745 | | |
| | 0 | 3746 | | return LocateModuleManifest(null, null); |
| | | 3747 | | } |
| | | 3748 | | |
| | | 3749 | | /// <summary> |
| | | 3750 | | /// Builds arguments for direct foreground run mode on the dedicated service-host executable. |
| | | 3751 | | /// </summary> |
| | | 3752 | | /// <param name="runnerExecutablePath">Runner executable path.</param> |
| | | 3753 | | /// <param name="scriptPath">Absolute script path.</param> |
| | | 3754 | | /// <param name="moduleManifestPath">Absolute module manifest path.</param> |
| | | 3755 | | /// <param name="scriptArguments">Script arguments.</param> |
| | | 3756 | | /// <param name="discoverPowerShellHome">When true, pass --discover-pshome.</param> |
| | | 3757 | | /// <returns>Ordered argument list.</returns> |
| | | 3758 | | private static IReadOnlyList<string> BuildDedicatedServiceHostRunArguments( |
| | | 3759 | | string runnerExecutablePath, |
| | | 3760 | | string scriptPath, |
| | | 3761 | | string moduleManifestPath, |
| | | 3762 | | IReadOnlyList<string> scriptArguments, |
| | | 3763 | | bool discoverPowerShellHome) |
| | | 3764 | | { |
| | 0 | 3765 | | var arguments = new List<string>(12 + scriptArguments.Count) |
| | 0 | 3766 | | { |
| | 0 | 3767 | | "--runner-exe", |
| | 0 | 3768 | | Path.GetFullPath(runnerExecutablePath), |
| | 0 | 3769 | | "--run", |
| | 0 | 3770 | | Path.GetFullPath(scriptPath), |
| | 0 | 3771 | | "--kestrun-manifest", |
| | 0 | 3772 | | Path.GetFullPath(moduleManifestPath), |
| | 0 | 3773 | | }; |
| | | 3774 | | |
| | 0 | 3775 | | if (discoverPowerShellHome) |
| | | 3776 | | { |
| | 0 | 3777 | | arguments.Add("--discover-pshome"); |
| | | 3778 | | } |
| | | 3779 | | |
| | 0 | 3780 | | if (scriptArguments.Count > 0) |
| | | 3781 | | { |
| | 0 | 3782 | | arguments.Add("--arguments"); |
| | 0 | 3783 | | arguments.AddRange(scriptArguments); |
| | | 3784 | | } |
| | | 3785 | | |
| | 0 | 3786 | | return arguments; |
| | | 3787 | | } |
| | | 3788 | | |
| | | 3789 | | /// <summary> |
| | | 3790 | | /// Resolves whether service-host should auto-discover PSHOME for the selected manifest path. |
| | | 3791 | | /// </summary> |
| | | 3792 | | /// <param name="moduleManifestPath">Absolute path to Kestrun.psd1.</param> |
| | | 3793 | | /// <returns>True when --discover-pshome should be used.</returns> |
| | | 3794 | | private static bool ShouldDiscoverPowerShellHomeForManifest(string moduleManifestPath) |
| | | 3795 | | { |
| | 0 | 3796 | | var fullManifestPath = Path.GetFullPath(moduleManifestPath); |
| | 0 | 3797 | | var moduleDirectory = Path.GetDirectoryName(fullManifestPath); |
| | 0 | 3798 | | if (string.IsNullOrWhiteSpace(moduleDirectory)) |
| | | 3799 | | { |
| | 0 | 3800 | | return true; |
| | | 3801 | | } |
| | | 3802 | | |
| | 0 | 3803 | | var moduleRoot = Directory.GetParent(moduleDirectory); |
| | 0 | 3804 | | var serviceRoot = moduleRoot?.Parent?.FullName; |
| | 0 | 3805 | | if (string.IsNullOrWhiteSpace(serviceRoot)) |
| | | 3806 | | { |
| | 0 | 3807 | | return true; |
| | | 3808 | | } |
| | | 3809 | | |
| | 0 | 3810 | | var modulesDirectory = Path.Combine(serviceRoot, "Modules"); |
| | 0 | 3811 | | return !Directory.Exists(modulesDirectory); |
| | | 3812 | | } |
| | | 3813 | | |
| | | 3814 | | /// <summary> |
| | | 3815 | | /// Resolves the current executable path when available, otherwise falls back to the provided value. |
| | | 3816 | | /// </summary> |
| | | 3817 | | /// <param name="fallbackPath">Fallback path when current process path is unavailable.</param> |
| | | 3818 | | /// <returns>Absolute executable path.</returns> |
| | | 3819 | | private static string ResolveCurrentProcessPathOrFallback(string fallbackPath) |
| | 0 | 3820 | | => !string.IsNullOrWhiteSpace(Environment.ProcessPath) && File.Exists(Environment.ProcessPath) |
| | 0 | 3821 | | ? Path.GetFullPath(Environment.ProcessPath) |
| | 0 | 3822 | | : Path.GetFullPath(fallbackPath); |
| | | 3823 | | |
| | | 3824 | | /// <summary> |
| | | 3825 | | /// Parses runner-specific global options and returns arguments to pass into command parsing. |
| | | 3826 | | /// </summary> |
| | | 3827 | | /// <param name="args">Raw process arguments.</param> |
| | | 3828 | | /// <returns>Normalized argument set and global option flags.</returns> |
| | | 3829 | | private static GlobalOptions ParseGlobalOptions(string[] args) |
| | | 3830 | | { |
| | 4 | 3831 | | var commandArgs = new List<string>(args.Length); |
| | 4 | 3832 | | var skipGalleryCheck = false; |
| | 4 | 3833 | | var passthroughArguments = false; |
| | | 3834 | | |
| | 28 | 3835 | | foreach (var arg in args) |
| | | 3836 | | { |
| | 10 | 3837 | | if (!passthroughArguments && arg is "--arguments" or "--") |
| | | 3838 | | { |
| | 1 | 3839 | | passthroughArguments = true; |
| | 1 | 3840 | | commandArgs.Add(arg); |
| | 1 | 3841 | | continue; |
| | | 3842 | | } |
| | | 3843 | | |
| | 9 | 3844 | | if (!passthroughArguments && IsNoCheckOption(arg)) |
| | | 3845 | | { |
| | 1 | 3846 | | skipGalleryCheck = true; |
| | 1 | 3847 | | continue; |
| | | 3848 | | } |
| | | 3849 | | |
| | 8 | 3850 | | commandArgs.Add(arg); |
| | | 3851 | | } |
| | | 3852 | | |
| | 4 | 3853 | | return new GlobalOptions([.. commandArgs], skipGalleryCheck); |
| | | 3854 | | } |
| | | 3855 | | |
| | | 3856 | | /// <summary> |
| | | 3857 | | /// Determines whether the token disables gallery version checks. |
| | | 3858 | | /// </summary> |
| | | 3859 | | /// <param name="token">Argument token.</param> |
| | | 3860 | | /// <returns>True when the token disables gallery checks.</returns> |
| | | 3861 | | private static bool IsNoCheckOption(string token) |
| | 25 | 3862 | | => string.Equals(token, NoCheckOption, StringComparison.OrdinalIgnoreCase) |
| | 25 | 3863 | | || string.Equals(token, NoCheckAliasOption, StringComparison.OrdinalIgnoreCase); |
| | | 3864 | | |
| | | 3865 | | /// <summary> |
| | | 3866 | | /// Validates install preconditions for module install operations. |
| | | 3867 | | /// </summary> |
| | | 3868 | | /// <param name="moduleRoot">Root folder for module versions.</param> |
| | | 3869 | | /// <param name="scopeToken">Module scope token for messaging.</param> |
| | | 3870 | | /// <param name="errorText">Validation error details when install should not proceed.</param> |
| | | 3871 | | /// <returns>True when install can proceed.</returns> |
| | | 3872 | | private static bool TryValidateInstallAction(string moduleRoot, string scopeToken, out string errorText) |
| | | 3873 | | { |
| | 1 | 3874 | | errorText = string.Empty; |
| | 1 | 3875 | | if (GetInstalledModuleRecords(moduleRoot).Count == 0) |
| | | 3876 | | { |
| | 0 | 3877 | | return true; |
| | | 3878 | | } |
| | | 3879 | | |
| | 1 | 3880 | | errorText = $"{ModuleName} module is already installed in {scopeToken} scope. Use '{ProductName} module update' |
| | 1 | 3881 | | return false; |
| | | 3882 | | } |
| | | 3883 | | |
| | | 3884 | | /// <summary> |
| | | 3885 | | /// Validates update preconditions for module update operations. |
| | | 3886 | | /// </summary> |
| | | 3887 | | /// <param name="moduleRoot">Root folder for module versions.</param> |
| | | 3888 | | /// <param name="packageVersion">Resolved target package version.</param> |
| | | 3889 | | /// <param name="force">When true, overwrite is allowed.</param> |
| | | 3890 | | /// <param name="errorText">Validation error details when update should not proceed.</param> |
| | | 3891 | | /// <returns>True when update can proceed.</returns> |
| | | 3892 | | private static bool TryValidateUpdateAction(string moduleRoot, string packageVersion, bool force, out string errorTe |
| | | 3893 | | { |
| | 2 | 3894 | | errorText = string.Empty; |
| | 2 | 3895 | | if (force) |
| | | 3896 | | { |
| | 1 | 3897 | | return true; |
| | | 3898 | | } |
| | | 3899 | | |
| | 1 | 3900 | | var destinationModuleDirectory = Path.Combine(moduleRoot, packageVersion); |
| | 1 | 3901 | | if (!Directory.Exists(destinationModuleDirectory)) |
| | | 3902 | | { |
| | 0 | 3903 | | return true; |
| | | 3904 | | } |
| | | 3905 | | |
| | 1 | 3906 | | errorText = $"Module version '{packageVersion}' is already installed at '{destinationModuleDirectory}'. Use '{Pr |
| | 1 | 3907 | | return false; |
| | | 3908 | | } |
| | | 3909 | | |
| | | 3910 | | /// <summary> |
| | | 3911 | | /// Reads the package version from a nupkg file payload. |
| | | 3912 | | /// </summary> |
| | | 3913 | | /// <param name="packageBytes">Package bytes.</param> |
| | | 3914 | | /// <param name="packageVersion">Parsed package version.</param> |
| | | 3915 | | /// <returns>True when a version was discovered.</returns> |
| | | 3916 | | private static bool TryReadPackageVersion(byte[] packageBytes, out string packageVersion) |
| | | 3917 | | { |
| | 2 | 3918 | | packageVersion = string.Empty; |
| | | 3919 | | |
| | 2 | 3920 | | using var stream = new MemoryStream(packageBytes, writable: false); |
| | 2 | 3921 | | using var archive = new ZipArchive(stream, ZipArchiveMode.Read, leaveOpen: false); |
| | 4 | 3922 | | var nuspecEntry = archive.Entries.FirstOrDefault(static entry => entry.FullName.EndsWith(".nuspec", StringCompar |
| | 2 | 3923 | | if (nuspecEntry is null) |
| | | 3924 | | { |
| | 1 | 3925 | | return false; |
| | | 3926 | | } |
| | | 3927 | | |
| | 1 | 3928 | | using var reader = new StreamReader(nuspecEntry.Open(), Encoding.UTF8, detectEncodingFromByteOrderMarks: true); |
| | 1 | 3929 | | var nuspecText = reader.ReadToEnd(); |
| | 1 | 3930 | | if (string.IsNullOrWhiteSpace(nuspecText)) |
| | | 3931 | | { |
| | 0 | 3932 | | return false; |
| | | 3933 | | } |
| | | 3934 | | |
| | 1 | 3935 | | var document = XDocument.Parse(nuspecText); |
| | 1 | 3936 | | var versionElement = document.Descendants() |
| | 5 | 3937 | | .FirstOrDefault(static element => string.Equals(element.Name.LocalName, "version", StringComparison.OrdinalI |
| | 1 | 3938 | | if (versionElement is null) |
| | | 3939 | | { |
| | 0 | 3940 | | return false; |
| | | 3941 | | } |
| | | 3942 | | |
| | 1 | 3943 | | packageVersion = versionElement.Value.Trim(); |
| | 1 | 3944 | | return TryNormalizeModuleVersion(packageVersion, out packageVersion); |
| | 2 | 3945 | | } |
| | | 3946 | | |
| | | 3947 | | /// <summary> |
| | | 3948 | | /// Maps package entry paths to relative module payload paths. |
| | | 3949 | | /// </summary> |
| | | 3950 | | /// <param name="entryPath">Original package entry path.</param> |
| | | 3951 | | /// <param name="relativePath">Mapped relative payload path.</param> |
| | | 3952 | | /// <returns>True when the entry belongs to module payload content.</returns> |
| | | 3953 | | private static bool TryGetPackagePayloadPath(string entryPath, out string relativePath) |
| | | 3954 | | { |
| | 5 | 3955 | | relativePath = string.Empty; |
| | 5 | 3956 | | if (string.IsNullOrWhiteSpace(entryPath)) |
| | | 3957 | | { |
| | 0 | 3958 | | return false; |
| | | 3959 | | } |
| | | 3960 | | |
| | 5 | 3961 | | var normalizedPath = entryPath.Replace('\\', '/').TrimStart('/'); |
| | 5 | 3962 | | if (string.IsNullOrWhiteSpace(normalizedPath) || normalizedPath.EndsWith('/')) |
| | | 3963 | | { |
| | 0 | 3964 | | return false; |
| | | 3965 | | } |
| | | 3966 | | |
| | 5 | 3967 | | if (normalizedPath.Equals("[Content_Types].xml", StringComparison.OrdinalIgnoreCase) |
| | 5 | 3968 | | || normalizedPath.StartsWith("_rels/", StringComparison.OrdinalIgnoreCase) |
| | 5 | 3969 | | || normalizedPath.StartsWith("package/", StringComparison.OrdinalIgnoreCase) |
| | 5 | 3970 | | || normalizedPath.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase)) |
| | | 3971 | | { |
| | 1 | 3972 | | return false; |
| | | 3973 | | } |
| | | 3974 | | |
| | 4 | 3975 | | if (normalizedPath.StartsWith("tools/", StringComparison.OrdinalIgnoreCase)) |
| | | 3976 | | { |
| | 4 | 3977 | | normalizedPath = normalizedPath["tools/".Length..]; |
| | | 3978 | | } |
| | 0 | 3979 | | else if (normalizedPath.StartsWith("content/", StringComparison.OrdinalIgnoreCase)) |
| | | 3980 | | { |
| | 0 | 3981 | | normalizedPath = normalizedPath["content/".Length..]; |
| | | 3982 | | } |
| | 0 | 3983 | | else if (normalizedPath.StartsWith("contentFiles/any/any/", StringComparison.OrdinalIgnoreCase)) |
| | | 3984 | | { |
| | 0 | 3985 | | normalizedPath = normalizedPath["contentFiles/any/any/".Length..]; |
| | | 3986 | | } |
| | | 3987 | | |
| | 4 | 3988 | | relativePath = normalizedPath.TrimStart('/'); |
| | 4 | 3989 | | return !string.IsNullOrWhiteSpace(relativePath); |
| | | 3990 | | } |
| | | 3991 | | |
| | | 3992 | | /// <summary> |
| | | 3993 | | /// Copies all files recursively from one directory to another. |
| | | 3994 | | /// </summary> |
| | | 3995 | | /// <param name="sourceDirectory">Source directory.</param> |
| | | 3996 | | /// <param name="destinationDirectory">Destination directory.</param> |
| | | 3997 | | /// <param name="showProgress">When true, writes interactive progress bars.</param> |
| | | 3998 | | private static void CopyDirectoryContents(string sourceDirectory, string destinationDirectory, bool showProgress) |
| | 2 | 3999 | | => CopyDirectoryContents(sourceDirectory, destinationDirectory, showProgress, "Installing files", exclusionPatte |
| | | 4000 | | |
| | | 4001 | | /// <summary> |
| | | 4002 | | /// Copies all files recursively from one directory to another. |
| | | 4003 | | /// </summary> |
| | | 4004 | | /// <param name="sourceDirectory">Source directory.</param> |
| | | 4005 | | /// <param name="destinationDirectory">Destination directory.</param> |
| | | 4006 | | /// <param name="showProgress">When true, writes interactive progress bars.</param> |
| | | 4007 | | /// <param name="progressLabel">Progress bar label for file copy operations.</param> |
| | | 4008 | | /// <param name="exclusionPatterns">Optional wildcard patterns (relative to <paramref name="sourceDirectory"/>) for |
| | | 4009 | | private static void CopyDirectoryContents( |
| | | 4010 | | string sourceDirectory, |
| | | 4011 | | string destinationDirectory, |
| | | 4012 | | bool showProgress, |
| | | 4013 | | string progressLabel, |
| | | 4014 | | IReadOnlyList<string>? exclusionPatterns) |
| | | 4015 | | { |
| | 27 | 4016 | | _ = Directory.CreateDirectory(destinationDirectory); |
| | | 4017 | | |
| | 27 | 4018 | | var exclusionRegexes = BuildCopyExclusionRegexes(exclusionPatterns); |
| | 27 | 4019 | | var sourceFilePaths = Directory.EnumerateFiles(sourceDirectory, "*", SearchOption.AllDirectories) |
| | 42 | 4020 | | .Where(sourceFilePath => !ShouldExcludeCopyFile(sourceDirectory, sourceFilePath, exclusionRegexes)) |
| | 27 | 4021 | | .ToList(); |
| | 27 | 4022 | | using var copyProgress = showProgress |
| | 27 | 4023 | | ? new ConsoleProgressBar(progressLabel, sourceFilePaths.Count, FormatFileProgressDetail) |
| | 27 | 4024 | | : null; |
| | 27 | 4025 | | var copiedFiles = 0; |
| | 27 | 4026 | | copyProgress?.Report(0); |
| | | 4027 | | |
| | 138 | 4028 | | foreach (var sourceFilePath in sourceFilePaths) |
| | | 4029 | | { |
| | 42 | 4030 | | var relativePath = Path.GetRelativePath(sourceDirectory, sourceFilePath); |
| | 42 | 4031 | | var destinationFilePath = Path.Combine(destinationDirectory, relativePath); |
| | 42 | 4032 | | var destinationFileDirectory = Path.GetDirectoryName(destinationFilePath); |
| | 42 | 4033 | | if (!string.IsNullOrWhiteSpace(destinationFileDirectory)) |
| | | 4034 | | { |
| | 42 | 4035 | | _ = Directory.CreateDirectory(destinationFileDirectory); |
| | | 4036 | | } |
| | | 4037 | | |
| | 42 | 4038 | | File.Copy(sourceFilePath, destinationFilePath, overwrite: true); |
| | 42 | 4039 | | copiedFiles++; |
| | 42 | 4040 | | copyProgress?.Report(copiedFiles); |
| | | 4041 | | } |
| | | 4042 | | |
| | 27 | 4043 | | copyProgress?.Complete(copiedFiles); |
| | 27 | 4044 | | } |
| | | 4045 | | |
| | | 4046 | | /// <summary> |
| | | 4047 | | /// Determines whether a source file should be excluded from a directory copy operation. |
| | | 4048 | | /// </summary> |
| | | 4049 | | /// <param name="sourceDirectory">Source directory root.</param> |
| | | 4050 | | /// <param name="sourceFilePath">Absolute source file path.</param> |
| | | 4051 | | /// <param name="exclusionRegexes">Compiled exclusion regexes.</param> |
| | | 4052 | | /// <returns>True when the file should be excluded.</returns> |
| | | 4053 | | private static bool ShouldExcludeCopyFile(string sourceDirectory, string sourceFilePath, IReadOnlyList<Regex> exclus |
| | | 4054 | | { |
| | 42 | 4055 | | if (exclusionRegexes.Count == 0) |
| | | 4056 | | { |
| | 32 | 4057 | | return false; |
| | | 4058 | | } |
| | | 4059 | | |
| | 10 | 4060 | | var relativePath = NormalizeCopyPath(Path.GetRelativePath(sourceDirectory, sourceFilePath)); |
| | 40 | 4061 | | return exclusionRegexes.Any(regex => regex.IsMatch(relativePath)); |
| | | 4062 | | } |
| | | 4063 | | |
| | | 4064 | | /// <summary> |
| | | 4065 | | /// Compiles wildcard exclusion patterns used by directory copy operations. |
| | | 4066 | | /// </summary> |
| | | 4067 | | /// <param name="exclusionPatterns">Wildcard exclusion patterns.</param> |
| | | 4068 | | /// <returns>Compiled regex list for path matching.</returns> |
| | | 4069 | | private static List<Regex> BuildCopyExclusionRegexes(IReadOnlyList<string>? exclusionPatterns) |
| | | 4070 | | { |
| | 27 | 4071 | | if (exclusionPatterns is null || exclusionPatterns.Count == 0) |
| | | 4072 | | { |
| | 21 | 4073 | | return []; |
| | | 4074 | | } |
| | | 4075 | | |
| | 6 | 4076 | | var regexOptions = RegexOptions.Compiled | RegexOptions.CultureInvariant; |
| | 6 | 4077 | | if (OperatingSystem.IsWindows()) |
| | | 4078 | | { |
| | 0 | 4079 | | regexOptions |= RegexOptions.IgnoreCase; |
| | | 4080 | | } |
| | | 4081 | | |
| | 6 | 4082 | | var regexes = new List<Regex>(exclusionPatterns.Count); |
| | 48 | 4083 | | foreach (var exclusionPattern in exclusionPatterns) |
| | | 4084 | | { |
| | 18 | 4085 | | var normalizedPattern = NormalizeCopyPath(exclusionPattern); |
| | 18 | 4086 | | if (string.IsNullOrWhiteSpace(normalizedPattern)) |
| | | 4087 | | { |
| | | 4088 | | continue; |
| | | 4089 | | } |
| | | 4090 | | |
| | 18 | 4091 | | var regexPattern = $"^{Regex.Escape(normalizedPattern).Replace(@"\*", ".*").Replace(@"\?", ".")}$"; |
| | 18 | 4092 | | regexes.Add(new Regex(regexPattern, regexOptions, TimeSpan.FromMilliseconds(250))); |
| | | 4093 | | } |
| | | 4094 | | |
| | 6 | 4095 | | return regexes; |
| | | 4096 | | } |
| | | 4097 | | |
| | | 4098 | | /// <summary> |
| | | 4099 | | /// Normalizes a relative path for wildcard matching. |
| | | 4100 | | /// </summary> |
| | | 4101 | | /// <param name="relativePath">Relative path or wildcard pattern.</param> |
| | | 4102 | | /// <returns>Normalized slash-separated path without leading dot prefixes.</returns> |
| | | 4103 | | private static string NormalizeCopyPath(string relativePath) |
| | | 4104 | | { |
| | 28 | 4105 | | if (string.IsNullOrWhiteSpace(relativePath)) |
| | | 4106 | | { |
| | 0 | 4107 | | return string.Empty; |
| | | 4108 | | } |
| | | 4109 | | |
| | 28 | 4110 | | var normalizedPath = relativePath.Trim().Replace('\\', '/'); |
| | 28 | 4111 | | while (normalizedPath.StartsWith("./", StringComparison.Ordinal)) |
| | | 4112 | | { |
| | 0 | 4113 | | normalizedPath = normalizedPath[2..]; |
| | | 4114 | | } |
| | | 4115 | | |
| | 28 | 4116 | | return normalizedPath.TrimStart('/'); |
| | | 4117 | | } |
| | | 4118 | | |
| | | 4119 | | /// <summary> |
| | | 4120 | | /// Removes all installed module files and folders for the selected scope. |
| | | 4121 | | /// </summary> |
| | | 4122 | | /// <param name="moduleRoot">Module root directory to remove.</param> |
| | | 4123 | | /// <param name="showProgress">When true, writes interactive progress bars.</param> |
| | | 4124 | | /// <param name="errorText">Error details when removal fails.</param> |
| | | 4125 | | /// <returns>True when removal succeeds.</returns> |
| | | 4126 | | private static bool TryRemoveInstalledModule(string moduleRoot, bool showProgress, out string errorText) |
| | | 4127 | | { |
| | 2 | 4128 | | errorText = string.Empty; |
| | | 4129 | | |
| | 2 | 4130 | | if (!Directory.Exists(moduleRoot)) |
| | | 4131 | | { |
| | 1 | 4132 | | return true; |
| | | 4133 | | } |
| | | 4134 | | |
| | | 4135 | | try |
| | | 4136 | | { |
| | 1 | 4137 | | var filePaths = Directory.EnumerateFiles(moduleRoot, "*", SearchOption.AllDirectories).ToList(); |
| | 1 | 4138 | | using var fileProgress = showProgress |
| | 1 | 4139 | | ? new ConsoleProgressBar("Removing files", filePaths.Count, FormatFileProgressDetail) |
| | 1 | 4140 | | : null; |
| | 1 | 4141 | | var removedFiles = 0; |
| | 1 | 4142 | | fileProgress?.Report(0); |
| | | 4143 | | |
| | 6 | 4144 | | foreach (var filePath in filePaths) |
| | | 4145 | | { |
| | | 4146 | | try |
| | | 4147 | | { |
| | 2 | 4148 | | File.SetAttributes(filePath, FileAttributes.Normal); |
| | 2 | 4149 | | } |
| | 0 | 4150 | | catch |
| | | 4151 | | { |
| | | 4152 | | // Best-effort normalization; delete may still succeed without changing attributes. |
| | 0 | 4153 | | } |
| | | 4154 | | |
| | 2 | 4155 | | File.Delete(filePath); |
| | 2 | 4156 | | removedFiles++; |
| | 2 | 4157 | | fileProgress?.Report(removedFiles); |
| | | 4158 | | } |
| | | 4159 | | |
| | 1 | 4160 | | fileProgress?.Complete(removedFiles); |
| | | 4161 | | |
| | 1 | 4162 | | var directoryPaths = Directory.EnumerateDirectories(moduleRoot, "*", SearchOption.AllDirectories) |
| | 2 | 4163 | | .OrderByDescending(path => path.Length) |
| | 1 | 4164 | | .ToList(); |
| | | 4165 | | |
| | 1 | 4166 | | using var directoryProgress = showProgress |
| | 1 | 4167 | | ? new ConsoleProgressBar("Removing folders", directoryPaths.Count + 1, FormatFileProgressDetail) |
| | 1 | 4168 | | : null; |
| | 1 | 4169 | | var removedDirectories = 0; |
| | 1 | 4170 | | directoryProgress?.Report(0); |
| | | 4171 | | |
| | 6 | 4172 | | foreach (var directoryPath in directoryPaths) |
| | | 4173 | | { |
| | 2 | 4174 | | Directory.Delete(directoryPath, recursive: false); |
| | 2 | 4175 | | removedDirectories++; |
| | 2 | 4176 | | directoryProgress?.Report(removedDirectories); |
| | | 4177 | | } |
| | | 4178 | | |
| | 1 | 4179 | | Directory.Delete(moduleRoot, recursive: false); |
| | 1 | 4180 | | removedDirectories++; |
| | 1 | 4181 | | directoryProgress?.Report(removedDirectories); |
| | 1 | 4182 | | directoryProgress?.Complete(removedDirectories); |
| | | 4183 | | |
| | 1 | 4184 | | return true; |
| | | 4185 | | } |
| | 0 | 4186 | | catch (Exception ex) |
| | | 4187 | | { |
| | 0 | 4188 | | errorText = ex.Message; |
| | 0 | 4189 | | return false; |
| | | 4190 | | } |
| | 1 | 4191 | | } |
| | | 4192 | | |
| | | 4193 | | /// <summary> |
| | | 4194 | | /// Copies one stream into another while reporting transfer progress. |
| | | 4195 | | /// </summary> |
| | | 4196 | | /// <param name="source">Source stream.</param> |
| | | 4197 | | /// <param name="destination">Destination stream.</param> |
| | | 4198 | | /// <param name="progress">Optional progress reporter.</param> |
| | | 4199 | | private static void CopyStreamWithProgress(Stream source, Stream destination, ConsoleProgressBar? progress) |
| | | 4200 | | { |
| | 2 | 4201 | | var buffer = new byte[81920]; |
| | 2 | 4202 | | var totalCopied = 0L; |
| | 2 | 4203 | | progress?.Report(0); |
| | | 4204 | | |
| | 0 | 4205 | | while (true) |
| | | 4206 | | { |
| | 3 | 4207 | | var bytesRead = source.Read(buffer, 0, buffer.Length); |
| | 3 | 4208 | | if (bytesRead <= 0) |
| | | 4209 | | { |
| | | 4210 | | break; |
| | | 4211 | | } |
| | | 4212 | | |
| | 1 | 4213 | | destination.Write(buffer, 0, bytesRead); |
| | 1 | 4214 | | totalCopied += bytesRead; |
| | 1 | 4215 | | progress?.Report(totalCopied); |
| | | 4216 | | } |
| | | 4217 | | |
| | 2 | 4218 | | progress?.Complete(totalCopied); |
| | 2 | 4219 | | } |
| | | 4220 | | |
| | | 4221 | | /// <summary> |
| | | 4222 | | /// Formats byte transfer progress details. |
| | | 4223 | | /// </summary> |
| | | 4224 | | /// <param name="current">Current transferred bytes.</param> |
| | | 4225 | | /// <param name="total">Total bytes when known.</param> |
| | | 4226 | | /// <returns>Formatted progress text.</returns> |
| | | 4227 | | private static string FormatByteProgressDetail(long current, long? total) |
| | 1 | 4228 | | => total.HasValue |
| | 1 | 4229 | | ? $"{FormatByteSize(current)} / {FormatByteSize(total.Value)}" |
| | 1 | 4230 | | : FormatByteSize(current); |
| | | 4231 | | |
| | | 4232 | | /// <summary> |
| | | 4233 | | /// Formats file count progress details. |
| | | 4234 | | /// </summary> |
| | | 4235 | | /// <param name="current">Current processed file count.</param> |
| | | 4236 | | /// <param name="total">Total file count when known.</param> |
| | | 4237 | | /// <returns>Formatted progress text.</returns> |
| | | 4238 | | private static string FormatFileProgressDetail(long current, long? total) |
| | 1 | 4239 | | => total.HasValue |
| | 1 | 4240 | | ? $"{current}/{total.Value} files" |
| | 1 | 4241 | | : $"{current} files"; |
| | | 4242 | | |
| | | 4243 | | /// <summary> |
| | | 4244 | | /// Formats progress details for service bundle preparation steps. |
| | | 4245 | | /// </summary> |
| | | 4246 | | /// <param name="current">Current completed step number.</param> |
| | | 4247 | | /// <param name="total">Total step count.</param> |
| | | 4248 | | /// <returns>Formatted step progress detail.</returns> |
| | | 4249 | | private static string FormatServiceBundleStepProgressDetail(long current, long? total) |
| | | 4250 | | { |
| | 1 | 4251 | | var stepLabel = current switch |
| | 1 | 4252 | | { |
| | 0 | 4253 | | <= 0 => "initializing", |
| | 0 | 4254 | | 1 => "creating folders", |
| | 0 | 4255 | | 2 => "copying runtime", |
| | 1 | 4256 | | 3 => "copying module", |
| | 0 | 4257 | | _ => "copying script", |
| | 1 | 4258 | | }; |
| | | 4259 | | |
| | 1 | 4260 | | return total.HasValue |
| | 1 | 4261 | | ? $"step {Math.Min(current, total.Value)}/{total.Value} ({stepLabel})" |
| | 1 | 4262 | | : $"step {current} ({stepLabel})"; |
| | | 4263 | | } |
| | | 4264 | | |
| | | 4265 | | /// <summary> |
| | | 4266 | | /// Formats a byte value to a readable unit string. |
| | | 4267 | | /// </summary> |
| | | 4268 | | /// <param name="bytes">Byte count.</param> |
| | | 4269 | | /// <returns>Human-readable byte text.</returns> |
| | | 4270 | | private static string FormatByteSize(long bytes) |
| | | 4271 | | { |
| | 3 | 4272 | | var unitIndex = 0; |
| | 3 | 4273 | | var value = (double)Math.Max(0, bytes); |
| | 3 | 4274 | | var units = new[] { "B", "KB", "MB", "GB", "TB" }; |
| | | 4275 | | |
| | 6 | 4276 | | while (value >= 1024d && unitIndex < units.Length - 1) |
| | | 4277 | | { |
| | 3 | 4278 | | value /= 1024d; |
| | 3 | 4279 | | unitIndex++; |
| | | 4280 | | } |
| | | 4281 | | |
| | 3 | 4282 | | return unitIndex == 0 |
| | 3 | 4283 | | ? $"{bytes} {units[unitIndex]}" |
| | 3 | 4284 | | : $"{value:0.##} {units[unitIndex]}"; |
| | | 4285 | | } |
| | | 4286 | | |
| | | 4287 | | /// <summary> |
| | | 4288 | | /// Prints an update warning when a newer PowerShell Gallery version exists. |
| | | 4289 | | /// </summary> |
| | | 4290 | | /// <param name="moduleManifestPath">Resolved local module manifest path.</param> |
| | | 4291 | | /// <param name="logPath">Optional log path for warning output; when omitted, warning is written to stderr.</param> |
| | | 4292 | | private static void WarnIfNewerGalleryVersionExists(string moduleManifestPath, string? logPath = null) |
| | | 4293 | | { |
| | 0 | 4294 | | if (!TryGetLatestInstalledModuleVersionText(ModuleStorageScope.Local, out var installedVersion) |
| | 0 | 4295 | | && !TryGetLatestInstalledModuleVersionText(ModuleStorageScope.Global, out installedVersion) |
| | 0 | 4296 | | && !TryGetInstalledModuleVersionText(moduleManifestPath, out installedVersion)) |
| | | 4297 | | { |
| | 0 | 4298 | | return; |
| | | 4299 | | } |
| | | 4300 | | |
| | 0 | 4301 | | if (!TryGetLatestGalleryVersionString(out var galleryVersion, out _)) |
| | | 4302 | | { |
| | 0 | 4303 | | return; |
| | | 4304 | | } |
| | | 4305 | | |
| | 0 | 4306 | | if (CompareModuleVersionValues(galleryVersion, installedVersion) <= 0) |
| | | 4307 | | { |
| | 0 | 4308 | | return; |
| | | 4309 | | } |
| | | 4310 | | |
| | 0 | 4311 | | var warningMessage = |
| | 0 | 4312 | | $"WARNING: A newer {ModuleName} module is available on PowerShell Gallery ({galleryVersion}). " |
| | 0 | 4313 | | + $"Current version: {installedVersion}. Use '{ProductName} module update' or {NoCheckOption} to suppress th |
| | | 4314 | | |
| | 0 | 4315 | | WriteWarningToLogOrConsole(warningMessage, logPath); |
| | 0 | 4316 | | } |
| | | 4317 | | |
| | | 4318 | | /// <summary> |
| | | 4319 | | /// Writes a warning to a configured log file when available; otherwise stderr. |
| | | 4320 | | /// </summary> |
| | | 4321 | | /// <param name="message">Warning message.</param> |
| | | 4322 | | /// <param name="logPath">Optional log path.</param> |
| | | 4323 | | private static void WriteWarningToLogOrConsole(string message, string? logPath) |
| | | 4324 | | { |
| | 1 | 4325 | | switch (string.IsNullOrWhiteSpace(logPath)) |
| | | 4326 | | { |
| | | 4327 | | case true: |
| | 0 | 4328 | | Console.Error.WriteLine(message); |
| | 0 | 4329 | | return; |
| | | 4330 | | |
| | | 4331 | | case false: |
| | | 4332 | | try |
| | | 4333 | | { |
| | 1 | 4334 | | var resolvedPath = NormalizeServiceLogPath(logPath, defaultFileName: "kestrun-tool-service.log"); |
| | 1 | 4335 | | var directory = Path.GetDirectoryName(resolvedPath); |
| | 1 | 4336 | | if (!string.IsNullOrWhiteSpace(directory)) |
| | | 4337 | | { |
| | 1 | 4338 | | _ = Directory.CreateDirectory(directory); |
| | | 4339 | | } |
| | | 4340 | | |
| | 1 | 4341 | | File.AppendAllText(resolvedPath, $"{DateTime.UtcNow:O} {message}{Environment.NewLine}", Encoding.UTF |
| | 1 | 4342 | | return; |
| | | 4343 | | } |
| | 0 | 4344 | | catch |
| | | 4345 | | { |
| | 0 | 4346 | | Console.Error.WriteLine(message); |
| | 0 | 4347 | | return; |
| | | 4348 | | } |
| | | 4349 | | } |
| | 1 | 4350 | | } |
| | | 4351 | | |
| | | 4352 | | /// <summary> |
| | | 4353 | | /// Attempts to read the latest installed module version text from a selected scope. |
| | | 4354 | | /// </summary> |
| | | 4355 | | /// <param name="scope">Module storage scope.</param> |
| | | 4356 | | /// <param name="versionText">Installed semantic version text when available.</param> |
| | | 4357 | | /// <returns>True when an installed version was found in the scope.</returns> |
| | | 4358 | | private static bool TryGetLatestInstalledModuleVersionText(ModuleStorageScope scope, out string versionText) |
| | | 4359 | | { |
| | 0 | 4360 | | var modulePath = GetPowerShellModulePath(scope); |
| | 0 | 4361 | | var moduleRoot = Path.Combine(modulePath, ModuleName); |
| | 0 | 4362 | | return TryGetLatestInstalledModuleVersionTextFromModuleRoot(moduleRoot, out versionText); |
| | | 4363 | | } |
| | | 4364 | | |
| | | 4365 | | /// <summary> |
| | | 4366 | | /// Attempts to read the latest installed module version text from a specific module root path. |
| | | 4367 | | /// </summary> |
| | | 4368 | | /// <param name="moduleRoot">Root directory containing versioned module folders.</param> |
| | | 4369 | | /// <param name="versionText">Installed semantic version text when available.</param> |
| | | 4370 | | /// <returns>True when an installed version was found in the module root.</returns> |
| | | 4371 | | private static bool TryGetLatestInstalledModuleVersionTextFromModuleRoot(string moduleRoot, out string versionText) |
| | | 4372 | | { |
| | 1 | 4373 | | versionText = string.Empty; |
| | 1 | 4374 | | var records = GetInstalledModuleRecords(moduleRoot); |
| | 1 | 4375 | | if (records.Count == 0) |
| | | 4376 | | { |
| | 0 | 4377 | | return false; |
| | | 4378 | | } |
| | | 4379 | | |
| | 1 | 4380 | | versionText = records[0].Version; |
| | 1 | 4381 | | return !string.IsNullOrWhiteSpace(versionText); |
| | | 4382 | | } |
| | | 4383 | | |
| | | 4384 | | /// <summary> |
| | | 4385 | | /// Attempts to read the local Kestrun module semantic version from manifest metadata. |
| | | 4386 | | /// </summary> |
| | | 4387 | | /// <param name="moduleManifestPath">Path to Kestrun.psd1.</param> |
| | | 4388 | | /// <param name="versionText">Installed semantic version text when available.</param> |
| | | 4389 | | /// <returns>True when a version was read.</returns> |
| | | 4390 | | private static bool TryGetInstalledModuleVersionText(string moduleManifestPath, out string versionText) |
| | | 4391 | | { |
| | 1 | 4392 | | versionText = string.Empty; |
| | | 4393 | | |
| | 1 | 4394 | | if (TryReadModuleSemanticVersionFromManifest(moduleManifestPath, out var manifestVersionText)) |
| | | 4395 | | { |
| | 0 | 4396 | | versionText = manifestVersionText; |
| | 0 | 4397 | | return true; |
| | | 4398 | | } |
| | | 4399 | | |
| | 1 | 4400 | | var versionDirectory = Path.GetFileName(Path.GetDirectoryName(moduleManifestPath)); |
| | 1 | 4401 | | if (TryNormalizeModuleVersion(versionDirectory, out var normalizedVersionDirectory)) |
| | | 4402 | | { |
| | 1 | 4403 | | versionText = normalizedVersionDirectory; |
| | 1 | 4404 | | return true; |
| | | 4405 | | } |
| | | 4406 | | |
| | 0 | 4407 | | return false; |
| | | 4408 | | } |
| | | 4409 | | |
| | | 4410 | | /// <summary> |
| | | 4411 | | /// Attempts to read module semantic version (including prerelease) from a PowerShell module manifest file. |
| | | 4412 | | /// </summary> |
| | | 4413 | | /// <param name="manifestPath">Manifest path.</param> |
| | | 4414 | | /// <param name="versionText">Semantic version text when present.</param> |
| | | 4415 | | /// <returns>True when semantic version was discovered.</returns> |
| | | 4416 | | private static bool TryReadModuleSemanticVersionFromManifest(string manifestPath, out string versionText) |
| | | 4417 | | { |
| | 9 | 4418 | | versionText = string.Empty; |
| | 9 | 4419 | | if (!TryReadModuleVersionFromManifest(manifestPath, out var baseVersion)) |
| | | 4420 | | { |
| | 3 | 4421 | | return false; |
| | | 4422 | | } |
| | | 4423 | | |
| | 6 | 4424 | | var semanticVersion = baseVersion; |
| | | 4425 | | try |
| | | 4426 | | { |
| | 6 | 4427 | | var content = File.ReadAllText(manifestPath); |
| | 6 | 4428 | | var prereleaseMatch = ModulePrereleasePatternRegex.Match(content); |
| | 6 | 4429 | | if (prereleaseMatch.Success) |
| | | 4430 | | { |
| | 2 | 4431 | | var prereleaseValue = prereleaseMatch.Groups["value"].Value.Trim(); |
| | 2 | 4432 | | if (!string.IsNullOrWhiteSpace(prereleaseValue) |
| | 2 | 4433 | | && !baseVersion.Contains('-', StringComparison.Ordinal) |
| | 2 | 4434 | | && !baseVersion.Contains('+', StringComparison.Ordinal)) |
| | | 4435 | | { |
| | 2 | 4436 | | semanticVersion = $"{baseVersion}-{prereleaseValue}"; |
| | | 4437 | | } |
| | | 4438 | | } |
| | 6 | 4439 | | } |
| | 0 | 4440 | | catch |
| | | 4441 | | { |
| | | 4442 | | // Fall back to ModuleVersion when Prerelease inspection fails. |
| | 0 | 4443 | | } |
| | | 4444 | | |
| | 6 | 4445 | | versionText = semanticVersion; |
| | 6 | 4446 | | return !string.IsNullOrWhiteSpace(versionText); |
| | | 4447 | | } |
| | | 4448 | | |
| | | 4449 | | /// <summary> |
| | | 4450 | | /// Attempts to query the latest Kestrun module version string from PowerShell Gallery. |
| | | 4451 | | /// </summary> |
| | | 4452 | | /// <param name="version">Latest gallery version string when available.</param> |
| | | 4453 | | /// <param name="errorText">Error details when discovery fails.</param> |
| | | 4454 | | /// <returns>True when latest gallery version was discovered.</returns> |
| | | 4455 | | private static bool TryGetLatestGalleryVersionString(out string version, out string errorText) |
| | 0 | 4456 | | => TryGetLatestGalleryVersionStringFromClient(GalleryHttpClient, out version, out errorText); |
| | | 4457 | | |
| | | 4458 | | /// <summary> |
| | | 4459 | | /// Attempts to query the latest Kestrun module version string from PowerShell Gallery using the specified HTTP clie |
| | | 4460 | | /// </summary> |
| | | 4461 | | /// <param name="httpClient">HTTP client used for the gallery request.</param> |
| | | 4462 | | /// <param name="version">Latest gallery version string when available.</param> |
| | | 4463 | | /// <param name="errorText">Error details when discovery fails.</param> |
| | | 4464 | | /// <returns>True when latest gallery version was discovered.</returns> |
| | | 4465 | | private static bool TryGetLatestGalleryVersionStringFromClient(HttpClient httpClient, out string version, out string |
| | | 4466 | | { |
| | 1 | 4467 | | version = string.Empty; |
| | 1 | 4468 | | if (!TryGetGalleryModuleVersionsFromClient(httpClient, out var versions, out errorText)) |
| | | 4469 | | { |
| | 0 | 4470 | | return false; |
| | | 4471 | | } |
| | | 4472 | | |
| | 1 | 4473 | | var latestVersion = versions[0]; |
| | 6 | 4474 | | for (var index = 1; index < versions.Count; index++) |
| | | 4475 | | { |
| | 2 | 4476 | | if (CompareModuleVersionValues(versions[index], latestVersion) > 0) |
| | | 4477 | | { |
| | 1 | 4478 | | latestVersion = versions[index]; |
| | | 4479 | | } |
| | | 4480 | | } |
| | | 4481 | | |
| | 1 | 4482 | | version = latestVersion; |
| | 1 | 4483 | | return !string.IsNullOrWhiteSpace(version); |
| | | 4484 | | } |
| | | 4485 | | |
| | | 4486 | | /// <summary> |
| | | 4487 | | /// Queries all available Kestrun module versions from PowerShell Gallery. |
| | | 4488 | | /// </summary> |
| | | 4489 | | /// <param name="versions">Discovered gallery versions.</param> |
| | | 4490 | | /// <param name="errorText">Error details when discovery fails.</param> |
| | | 4491 | | /// <returns>True when at least one version was discovered.</returns> |
| | | 4492 | | private static bool TryGetGalleryModuleVersions(out List<string> versions, out string errorText) |
| | 0 | 4493 | | => TryGetGalleryModuleVersionsFromClient(GalleryHttpClient, out versions, out errorText); |
| | | 4494 | | |
| | | 4495 | | /// <summary> |
| | | 4496 | | /// Queries all available Kestrun module versions from PowerShell Gallery using the specified HTTP client. |
| | | 4497 | | /// </summary> |
| | | 4498 | | /// <param name="httpClient">HTTP client used for the gallery request.</param> |
| | | 4499 | | /// <param name="versions">Discovered gallery versions.</param> |
| | | 4500 | | /// <param name="errorText">Error details when discovery fails.</param> |
| | | 4501 | | /// <returns>True when at least one version was discovered.</returns> |
| | | 4502 | | private static bool TryGetGalleryModuleVersionsFromClient(HttpClient httpClient, out List<string> versions, out stri |
| | | 4503 | | { |
| | 3 | 4504 | | versions = []; |
| | 3 | 4505 | | errorText = string.Empty; |
| | | 4506 | | |
| | | 4507 | | try |
| | | 4508 | | { |
| | 3 | 4509 | | var requestUri = $"{PowerShellGalleryApiBaseUri}/FindPackagesById()?id='{Uri.EscapeDataString(ModuleName)}'" |
| | 3 | 4510 | | using var response = httpClient.GetAsync(requestUri).GetAwaiter().GetResult(); |
| | 3 | 4511 | | if (!response.IsSuccessStatusCode) |
| | | 4512 | | { |
| | 1 | 4513 | | var reason = string.IsNullOrWhiteSpace(response.ReasonPhrase) |
| | 1 | 4514 | | ? "Unknown error" |
| | 1 | 4515 | | : response.ReasonPhrase; |
| | 1 | 4516 | | errorText = $"PowerShell Gallery request failed with HTTP {(int)response.StatusCode} ({reason})."; |
| | 1 | 4517 | | return false; |
| | | 4518 | | } |
| | | 4519 | | |
| | 2 | 4520 | | var content = response.Content.ReadAsStringAsync().GetAwaiter().GetResult(); |
| | 2 | 4521 | | if (string.IsNullOrWhiteSpace(content)) |
| | | 4522 | | { |
| | 0 | 4523 | | errorText = "PowerShell Gallery response was empty."; |
| | 0 | 4524 | | return false; |
| | | 4525 | | } |
| | | 4526 | | |
| | 2 | 4527 | | return TryParseGalleryModuleVersions(content, out versions, out errorText); |
| | | 4528 | | } |
| | 0 | 4529 | | catch (Exception ex) |
| | | 4530 | | { |
| | 0 | 4531 | | errorText = ex.Message; |
| | 0 | 4532 | | return false; |
| | | 4533 | | } |
| | 3 | 4534 | | } |
| | | 4535 | | |
| | | 4536 | | /// <summary> |
| | | 4537 | | /// Parses gallery feed XML and extracts module versions. |
| | | 4538 | | /// </summary> |
| | | 4539 | | /// <param name="content">Gallery feed XML payload.</param> |
| | | 4540 | | /// <param name="versions">Discovered gallery versions.</param> |
| | | 4541 | | /// <param name="errorText">Error details when parsing fails.</param> |
| | | 4542 | | /// <returns>True when at least one version was discovered.</returns> |
| | | 4543 | | private static bool TryParseGalleryModuleVersions(string content, out List<string> versions, out string errorText) |
| | | 4544 | | { |
| | 3 | 4545 | | versions = []; |
| | 3 | 4546 | | errorText = string.Empty; |
| | | 4547 | | |
| | | 4548 | | try |
| | | 4549 | | { |
| | 3 | 4550 | | var document = XDocument.Parse(content); |
| | 2 | 4551 | | var discoveredVersions = document.Descendants() |
| | 16 | 4552 | | .Where(static element => string.Equals(element.Name.LocalName, "Version", StringComparison.OrdinalIgnore |
| | 7 | 4553 | | .Select(static element => element.Value.Trim()) |
| | 7 | 4554 | | .Where(static versionText => !string.IsNullOrWhiteSpace(versionText)) |
| | 2 | 4555 | | .Distinct(StringComparer.OrdinalIgnoreCase) |
| | 2 | 4556 | | .ToList(); |
| | | 4557 | | |
| | 2 | 4558 | | if (discoveredVersions.Count == 0) |
| | | 4559 | | { |
| | 0 | 4560 | | errorText = $"Module '{ModuleName}' was not found on PowerShell Gallery."; |
| | 0 | 4561 | | return false; |
| | | 4562 | | } |
| | | 4563 | | |
| | 2 | 4564 | | versions = discoveredVersions; |
| | 2 | 4565 | | return true; |
| | | 4566 | | } |
| | 1 | 4567 | | catch (Exception ex) |
| | | 4568 | | { |
| | 1 | 4569 | | errorText = ex.Message; |
| | 1 | 4570 | | return false; |
| | | 4571 | | } |
| | 3 | 4572 | | } |
| | | 4573 | | |
| | | 4574 | | /// <summary> |
| | | 4575 | | /// Creates the shared HTTP client used for PowerShell Gallery requests. |
| | | 4576 | | /// </summary> |
| | | 4577 | | /// <returns>Configured HTTP client instance.</returns> |
| | | 4578 | | private static HttpClient CreateGalleryHttpClient() |
| | | 4579 | | { |
| | 1 | 4580 | | var client = new HttpClient |
| | 1 | 4581 | | { |
| | 1 | 4582 | | Timeout = TimeSpan.FromSeconds(60), |
| | 1 | 4583 | | }; |
| | | 4584 | | |
| | 1 | 4585 | | client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(ProductName, "1.0")); |
| | 1 | 4586 | | return client; |
| | | 4587 | | } |
| | | 4588 | | |
| | | 4589 | | /// <summary> |
| | | 4590 | | /// Creates the shared HTTP client used for service content-root archive downloads. |
| | | 4591 | | /// </summary> |
| | | 4592 | | /// <returns>Configured HTTP client instance.</returns> |
| | | 4593 | | private static HttpClient CreateServiceContentRootHttpClient() |
| | | 4594 | | { |
| | 1 | 4595 | | var client = new HttpClient |
| | 1 | 4596 | | { |
| | 1 | 4597 | | Timeout = TimeSpan.FromMinutes(5), |
| | 1 | 4598 | | }; |
| | | 4599 | | |
| | 1 | 4600 | | client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(ProductName, "1.0")); |
| | 1 | 4601 | | return client; |
| | | 4602 | | } |
| | | 4603 | | |
| | | 4604 | | /// <summary> |
| | | 4605 | | /// Parses a module version value into a comparable <see cref="Version"/> instance. |
| | | 4606 | | /// </summary> |
| | | 4607 | | /// <param name="rawValue">Raw version string.</param> |
| | | 4608 | | /// <param name="version">Parsed version.</param> |
| | | 4609 | | /// <returns>True when parsing succeeds.</returns> |
| | | 4610 | | private static bool TryParseVersionValue(string? rawValue, out Version version) |
| | | 4611 | | { |
| | 16 | 4612 | | version = new Version(0, 0); |
| | 16 | 4613 | | if (string.IsNullOrWhiteSpace(rawValue)) |
| | | 4614 | | { |
| | 0 | 4615 | | return false; |
| | | 4616 | | } |
| | | 4617 | | |
| | 16 | 4618 | | var normalized = rawValue.Trim(); |
| | 16 | 4619 | | var suffixIndex = normalized.IndexOfAny(['-', '+']); |
| | 16 | 4620 | | if (suffixIndex >= 0) |
| | | 4621 | | { |
| | 6 | 4622 | | normalized = normalized[..suffixIndex]; |
| | | 4623 | | } |
| | | 4624 | | |
| | 16 | 4625 | | if (!Version.TryParse(normalized, out var parsedVersion) || parsedVersion is null) |
| | | 4626 | | { |
| | 1 | 4627 | | return false; |
| | | 4628 | | } |
| | | 4629 | | |
| | 15 | 4630 | | version = parsedVersion; |
| | 15 | 4631 | | return true; |
| | | 4632 | | } |
| | | 4633 | | |
| | | 4634 | | /// <summary> |
| | | 4635 | | /// Normalizes a module version value to the stable numeric folder format used by PowerShell module installs. |
| | | 4636 | | /// </summary> |
| | | 4637 | | /// <param name="rawValue">Raw version token that may include prerelease/build suffixes.</param> |
| | | 4638 | | /// <param name="normalizedVersion">Normalized numeric version text.</param> |
| | | 4639 | | /// <returns>True when normalization succeeds.</returns> |
| | | 4640 | | private static bool TryNormalizeModuleVersion(string? rawValue, out string normalizedVersion) |
| | | 4641 | | { |
| | 5 | 4642 | | normalizedVersion = string.Empty; |
| | 5 | 4643 | | if (!TryParseVersionValue(rawValue, out var parsedVersion)) |
| | | 4644 | | { |
| | 0 | 4645 | | return false; |
| | | 4646 | | } |
| | | 4647 | | |
| | 5 | 4648 | | normalizedVersion = parsedVersion.ToString(); |
| | 5 | 4649 | | return true; |
| | | 4650 | | } |
| | | 4651 | | |
| | | 4652 | | /// <summary> |
| | | 4653 | | /// Tries to parse a module storage scope token. |
| | | 4654 | | /// </summary> |
| | | 4655 | | /// <param name="scopeToken">Scope token.</param> |
| | | 4656 | | /// <param name="scope">Parsed scope value.</param> |
| | | 4657 | | /// <returns>True when parsing succeeds.</returns> |
| | | 4658 | | private static bool TryParseModuleScope(string? scopeToken, out ModuleStorageScope scope) |
| | | 4659 | | { |
| | 3 | 4660 | | scope = ModuleStorageScope.Local; |
| | 3 | 4661 | | if (string.IsNullOrWhiteSpace(scopeToken)) |
| | | 4662 | | { |
| | 0 | 4663 | | return false; |
| | | 4664 | | } |
| | | 4665 | | |
| | 3 | 4666 | | if (string.Equals(scopeToken, ModuleScopeLocalValue, StringComparison.OrdinalIgnoreCase)) |
| | | 4667 | | { |
| | 0 | 4668 | | scope = ModuleStorageScope.Local; |
| | 0 | 4669 | | return true; |
| | | 4670 | | } |
| | | 4671 | | |
| | 3 | 4672 | | if (string.Equals(scopeToken, ModuleScopeGlobalValue, StringComparison.OrdinalIgnoreCase)) |
| | | 4673 | | { |
| | 2 | 4674 | | scope = ModuleStorageScope.Global; |
| | 2 | 4675 | | return true; |
| | | 4676 | | } |
| | | 4677 | | |
| | 1 | 4678 | | return false; |
| | | 4679 | | } |
| | | 4680 | | |
| | | 4681 | | /// <summary> |
| | | 4682 | | /// Gets a stable scope token for messages and help text. |
| | | 4683 | | /// </summary> |
| | | 4684 | | /// <param name="scope">Module storage scope.</param> |
| | | 4685 | | /// <returns>Normalized scope token.</returns> |
| | | 4686 | | private static string GetScopeToken(ModuleStorageScope scope) |
| | 2 | 4687 | | => scope == ModuleStorageScope.Global ? ModuleScopeGlobalValue : ModuleScopeLocalValue; |
| | | 4688 | | |
| | | 4689 | | /// <summary> |
| | | 4690 | | /// Compares two module version strings. |
| | | 4691 | | /// </summary> |
| | | 4692 | | /// <param name="leftVersion">Left version.</param> |
| | | 4693 | | /// <param name="rightVersion">Right version.</param> |
| | | 4694 | | /// <returns>Comparison result compatible with <see cref="IComparer{T}"/>.</returns> |
| | | 4695 | | private static int CompareModuleVersionValues(string? leftVersion, string? rightVersion) |
| | | 4696 | | { |
| | 4 | 4697 | | if (ReferenceEquals(leftVersion, rightVersion)) |
| | | 4698 | | { |
| | 0 | 4699 | | return 0; |
| | | 4700 | | } |
| | | 4701 | | |
| | 4 | 4702 | | if (string.IsNullOrWhiteSpace(leftVersion)) |
| | | 4703 | | { |
| | 0 | 4704 | | return -1; |
| | | 4705 | | } |
| | | 4706 | | |
| | 4 | 4707 | | if (string.IsNullOrWhiteSpace(rightVersion)) |
| | | 4708 | | { |
| | 0 | 4709 | | return 1; |
| | | 4710 | | } |
| | | 4711 | | |
| | 4 | 4712 | | if (TryParseVersionValue(leftVersion, out var leftParsed) |
| | 4 | 4713 | | && TryParseVersionValue(rightVersion, out var rightParsed)) |
| | | 4714 | | { |
| | 4 | 4715 | | var comparison = leftParsed.CompareTo(rightParsed); |
| | 4 | 4716 | | if (comparison != 0) |
| | | 4717 | | { |
| | 3 | 4718 | | return comparison; |
| | | 4719 | | } |
| | | 4720 | | |
| | 1 | 4721 | | var leftHasPrerelease = HasPrereleaseSuffix(leftVersion); |
| | 1 | 4722 | | var rightHasPrerelease = HasPrereleaseSuffix(rightVersion); |
| | 1 | 4723 | | if (leftHasPrerelease != rightHasPrerelease) |
| | | 4724 | | { |
| | 0 | 4725 | | return leftHasPrerelease ? -1 : 1; |
| | | 4726 | | } |
| | | 4727 | | } |
| | | 4728 | | |
| | 1 | 4729 | | return string.Compare(leftVersion.Trim(), rightVersion.Trim(), StringComparison.OrdinalIgnoreCase); |
| | | 4730 | | } |
| | | 4731 | | |
| | | 4732 | | /// <summary> |
| | | 4733 | | /// Determines whether a module version string includes prerelease suffix data. |
| | | 4734 | | /// </summary> |
| | | 4735 | | /// <param name="versionText">Version string to inspect.</param> |
| | | 4736 | | /// <returns>True when prerelease or build suffix exists.</returns> |
| | | 4737 | | private static bool HasPrereleaseSuffix(string versionText) |
| | 2 | 4738 | | => versionText.Contains('-', StringComparison.Ordinal) || versionText.Contains('+', StringComparison.Ordinal); |
| | | 4739 | | |
| | | 4740 | | /// <summary> |
| | | 4741 | | /// Reads ModuleVersion from a PowerShell module manifest file. |
| | | 4742 | | /// </summary> |
| | | 4743 | | /// <param name="manifestPath">Manifest path.</param> |
| | | 4744 | | /// <param name="versionText">ModuleVersion text when present.</param> |
| | | 4745 | | /// <returns>True when ModuleVersion was discovered.</returns> |
| | | 4746 | | private static bool TryReadModuleVersionFromManifest(string manifestPath, out string versionText) |
| | | 4747 | | { |
| | 9 | 4748 | | versionText = string.Empty; |
| | | 4749 | | |
| | | 4750 | | try |
| | | 4751 | | { |
| | 9 | 4752 | | var content = File.ReadAllText(manifestPath); |
| | 9 | 4753 | | var match = ModuleVersionPatternRegex.Match(content); |
| | 9 | 4754 | | if (!match.Success) |
| | | 4755 | | { |
| | 3 | 4756 | | return false; |
| | | 4757 | | } |
| | | 4758 | | |
| | 6 | 4759 | | versionText = match.Groups["value"].Value.Trim(); |
| | 6 | 4760 | | return !string.IsNullOrWhiteSpace(versionText); |
| | | 4761 | | } |
| | 0 | 4762 | | catch |
| | | 4763 | | { |
| | 0 | 4764 | | return false; |
| | | 4765 | | } |
| | 9 | 4766 | | } |
| | | 4767 | | |
| | | 4768 | | /// <summary> |
| | | 4769 | | /// Enumerates installed module manifest records from the user module root. |
| | | 4770 | | /// </summary> |
| | | 4771 | | /// <param name="moduleRoot">Module root path.</param> |
| | | 4772 | | /// <returns>Installed module records sorted by version descending.</returns> |
| | | 4773 | | private static List<InstalledModuleRecord> GetInstalledModuleRecords(string moduleRoot) |
| | | 4774 | | { |
| | 4 | 4775 | | var records = new List<InstalledModuleRecord>(); |
| | 4 | 4776 | | if (!Directory.Exists(moduleRoot)) |
| | | 4777 | | { |
| | 0 | 4778 | | return records; |
| | | 4779 | | } |
| | | 4780 | | |
| | 4 | 4781 | | var seenManifestPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase); |
| | 16 | 4782 | | foreach (var manifestPath in Directory.EnumerateFiles(moduleRoot, ModuleManifestFileName, SearchOption.AllDirect |
| | | 4783 | | { |
| | 4 | 4784 | | if (!seenManifestPaths.Add(manifestPath)) |
| | | 4785 | | { |
| | | 4786 | | continue; |
| | | 4787 | | } |
| | | 4788 | | |
| | 4 | 4789 | | var versionDirectory = Path.GetFileName(Path.GetDirectoryName(manifestPath)); |
| | 4 | 4790 | | string? versionText = null; |
| | | 4791 | | |
| | 4 | 4792 | | if (TryReadModuleSemanticVersionFromManifest(manifestPath, out var manifestSemanticVersion)) |
| | | 4793 | | { |
| | 2 | 4794 | | versionText = manifestSemanticVersion; |
| | | 4795 | | } |
| | | 4796 | | |
| | 4 | 4797 | | if (string.IsNullOrWhiteSpace(versionText) |
| | 4 | 4798 | | && !string.IsNullOrWhiteSpace(versionDirectory) |
| | 4 | 4799 | | && TryNormalizeModuleVersion(versionDirectory, out var normalizedVersionDirectory)) |
| | | 4800 | | { |
| | 2 | 4801 | | versionText = normalizedVersionDirectory; |
| | | 4802 | | } |
| | | 4803 | | |
| | 4 | 4804 | | if (string.IsNullOrWhiteSpace(versionText)) |
| | | 4805 | | { |
| | 0 | 4806 | | versionText = versionDirectory; |
| | | 4807 | | } |
| | | 4808 | | |
| | 4 | 4809 | | if (string.IsNullOrWhiteSpace(versionText)) |
| | | 4810 | | { |
| | | 4811 | | continue; |
| | | 4812 | | } |
| | | 4813 | | |
| | 4 | 4814 | | records.Add(new InstalledModuleRecord(versionText, manifestPath)); |
| | | 4815 | | } |
| | | 4816 | | |
| | 4 | 4817 | | records.Sort(static (left, right) => CompareModuleVersionValues(right.Version, left.Version)); |
| | 4 | 4818 | | return records; |
| | | 4819 | | } |
| | | 4820 | | |
| | | 4821 | | /// <summary> |
| | | 4822 | | /// Gets the module storage path for a selected scope. |
| | | 4823 | | /// </summary> |
| | | 4824 | | /// <param name="scope">Module storage scope.</param> |
| | | 4825 | | /// <returns>Absolute module storage path.</returns> |
| | | 4826 | | private static string GetPowerShellModulePath(ModuleStorageScope scope) |
| | 0 | 4827 | | => scope == ModuleStorageScope.Global |
| | 0 | 4828 | | ? GetGlobalPowerShellModulePath() |
| | 0 | 4829 | | : GetDefaultPowerShellModulePath(); |
| | | 4830 | | |
| | | 4831 | | /// <summary> |
| | | 4832 | | /// Gets the default all-users PowerShell module path for the active OS. |
| | | 4833 | | /// </summary> |
| | | 4834 | | /// <returns>Absolute all-users module path.</returns> |
| | | 4835 | | private static string GetGlobalPowerShellModulePath() |
| | | 4836 | | { |
| | 0 | 4837 | | if (OperatingSystem.IsWindows()) |
| | | 4838 | | { |
| | 0 | 4839 | | var programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); |
| | 0 | 4840 | | var root = string.IsNullOrWhiteSpace(programFiles) ? @"C:\Program Files" : programFiles; |
| | 0 | 4841 | | return Path.Combine(root, "PowerShell", "Modules"); |
| | | 4842 | | } |
| | | 4843 | | |
| | 0 | 4844 | | return "/usr/local/share/powershell/Modules"; |
| | | 4845 | | } |
| | | 4846 | | |
| | | 4847 | | /// <summary> |
| | | 4848 | | /// Gets the default current-user PowerShell module path for the active OS. |
| | | 4849 | | /// </summary> |
| | | 4850 | | /// <returns>Absolute module path.</returns> |
| | | 4851 | | private static string GetDefaultPowerShellModulePath() |
| | | 4852 | | { |
| | 1 | 4853 | | var userHome = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); |
| | 1 | 4854 | | if (OperatingSystem.IsWindows()) |
| | | 4855 | | { |
| | 0 | 4856 | | var documents = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); |
| | 0 | 4857 | | var root = string.IsNullOrWhiteSpace(documents) ? userHome : documents; |
| | 0 | 4858 | | return Path.Combine(root, "PowerShell", "Modules"); |
| | | 4859 | | } |
| | | 4860 | | |
| | 1 | 4861 | | return Path.Combine(userHome, ".local", "share", "powershell", "Modules"); |
| | | 4862 | | } |
| | | 4863 | | |
| | | 4864 | | /// <summary> |
| | | 4865 | | /// Writes a consistent module-not-found message with remediation guidance. |
| | | 4866 | | /// </summary> |
| | | 4867 | | /// <param name="kestrunManifestPath">Optional explicit manifest path argument.</param> |
| | | 4868 | | /// <param name="kestrunFolder">Optional explicit module folder argument.</param> |
| | | 4869 | | /// <param name="writeLine">Output writer callback.</param> |
| | | 4870 | | private static void WriteModuleNotFoundMessage(string? kestrunManifestPath, string? kestrunFolder, Action<string> wr |
| | | 4871 | | { |
| | 9 | 4872 | | if (!string.IsNullOrWhiteSpace(kestrunManifestPath)) |
| | | 4873 | | { |
| | 6 | 4874 | | writeLine($"Unable to locate manifest file: {Path.GetFullPath(kestrunManifestPath)}"); |
| | | 4875 | | } |
| | 3 | 4876 | | else if (!string.IsNullOrWhiteSpace(kestrunFolder)) |
| | | 4877 | | { |
| | 1 | 4878 | | writeLine($"Unable to locate {ModuleManifestFileName} in folder: {Path.GetFullPath(kestrunFolder)}"); |
| | | 4879 | | } |
| | | 4880 | | else |
| | | 4881 | | { |
| | 2 | 4882 | | writeLine($"Unable to locate {ModuleManifestFileName} under the executable folder or PSModulePath."); |
| | | 4883 | | } |
| | | 4884 | | |
| | 9 | 4885 | | writeLine($"No {ModuleName} module was found. Use '{ProductName} module install' to install it from PowerShell G |
| | 9 | 4886 | | } |
| | | 4887 | | |
| | | 4888 | | /// <summary> |
| | | 4889 | | /// Tries to parse command-line arguments into a concrete command payload. |
| | | 4890 | | /// </summary> |
| | | 4891 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 4892 | | /// <param name="parsedCommand">Parsed command payload.</param> |
| | | 4893 | | /// <param name="error">Error message when parsing fails.</param> |
| | | 4894 | | /// <returns>True when parsing succeeds.</returns> |
| | | 4895 | | private static bool TryParseArguments(string[] args, out ParsedCommand parsedCommand, out string error) |
| | | 4896 | | { |
| | 95 | 4897 | | parsedCommand = new ParsedCommand(CommandMode.Run, string.Empty, false, [], null, null, null, false, null, null, |
| | 95 | 4898 | | if (args.Length == 0) |
| | | 4899 | | { |
| | 0 | 4900 | | error = $"No command provided. Use '{ProductName} help' to list commands."; |
| | 0 | 4901 | | return false; |
| | | 4902 | | } |
| | | 4903 | | |
| | 95 | 4904 | | if (!TryParseLeadingKestrunOptions(args, out var commandTokenIndex, out var kestrunFolder, out var kestrunManife |
| | | 4905 | | { |
| | 0 | 4906 | | return false; |
| | | 4907 | | } |
| | | 4908 | | |
| | 95 | 4909 | | if (commandTokenIndex >= args.Length) |
| | | 4910 | | { |
| | 0 | 4911 | | error = $"No command provided. Use '{ProductName} help' to list commands."; |
| | 0 | 4912 | | return false; |
| | | 4913 | | } |
| | | 4914 | | |
| | 95 | 4915 | | return TryParseCommandFromToken(args, commandTokenIndex, kestrunFolder, kestrunManifestPath, out parsedCommand, |
| | | 4916 | | } |
| | | 4917 | | |
| | | 4918 | | /// <summary> |
| | | 4919 | | /// Parses leading global Kestrun options that may appear before the command token. |
| | | 4920 | | /// </summary> |
| | | 4921 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 4922 | | /// <param name="commandTokenIndex">Index of the command token after global options.</param> |
| | | 4923 | | /// <param name="kestrunFolder">Optional module folder path supplied via global option.</param> |
| | | 4924 | | /// <param name="kestrunManifestPath">Optional module manifest path supplied via global option.</param> |
| | | 4925 | | /// <param name="error">Error message when a required option value is missing.</param> |
| | | 4926 | | /// <returns>True when leading options are parsed successfully.</returns> |
| | | 4927 | | private static bool TryParseLeadingKestrunOptions( |
| | | 4928 | | string[] args, |
| | | 4929 | | out int commandTokenIndex, |
| | | 4930 | | out string? kestrunFolder, |
| | | 4931 | | out string? kestrunManifestPath, |
| | | 4932 | | out string error) |
| | | 4933 | | { |
| | 97 | 4934 | | commandTokenIndex = 0; |
| | 97 | 4935 | | kestrunFolder = null; |
| | 97 | 4936 | | kestrunManifestPath = null; |
| | 97 | 4937 | | error = string.Empty; |
| | | 4938 | | |
| | 100 | 4939 | | while (commandTokenIndex < args.Length) |
| | | 4940 | | { |
| | 100 | 4941 | | var current = args[commandTokenIndex]; |
| | 100 | 4942 | | if (current is "--kestrun-folder" or "-k") |
| | | 4943 | | { |
| | 2 | 4944 | | if (!TryConsumeLeadingOptionValue(args, ref commandTokenIndex, "--kestrun-folder", out var folderValue, |
| | | 4945 | | { |
| | 0 | 4946 | | return false; |
| | | 4947 | | } |
| | | 4948 | | |
| | 2 | 4949 | | kestrunFolder = folderValue; |
| | 2 | 4950 | | continue; |
| | | 4951 | | } |
| | | 4952 | | |
| | 98 | 4953 | | if (current is "--kestrun-manifest" or "-m") |
| | | 4954 | | { |
| | 2 | 4955 | | if (!TryConsumeLeadingOptionValue(args, ref commandTokenIndex, "--kestrun-manifest", out var manifestVal |
| | | 4956 | | { |
| | 1 | 4957 | | return false; |
| | | 4958 | | } |
| | | 4959 | | |
| | 1 | 4960 | | kestrunManifestPath = manifestValue; |
| | | 4961 | | continue; |
| | | 4962 | | } |
| | | 4963 | | |
| | | 4964 | | break; |
| | | 4965 | | } |
| | | 4966 | | |
| | 96 | 4967 | | return true; |
| | | 4968 | | } |
| | | 4969 | | |
| | | 4970 | | /// <summary> |
| | | 4971 | | /// Consumes a global option value and advances the parse index. |
| | | 4972 | | /// </summary> |
| | | 4973 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 4974 | | /// <param name="index">Current option index, advanced when consumption succeeds.</param> |
| | | 4975 | | /// <param name="optionName">Canonical option name used in diagnostics.</param> |
| | | 4976 | | /// <param name="value">Consumed option value.</param> |
| | | 4977 | | /// <param name="error">Error text when the value is missing.</param> |
| | | 4978 | | /// <returns>True when the option value is consumed.</returns> |
| | | 4979 | | private static bool TryConsumeLeadingOptionValue(string[] args, ref int index, string optionName, out string value, |
| | | 4980 | | { |
| | 4 | 4981 | | value = string.Empty; |
| | 4 | 4982 | | if (index + 1 >= args.Length) |
| | | 4983 | | { |
| | 1 | 4984 | | error = $"Missing value for {optionName}."; |
| | 1 | 4985 | | return false; |
| | | 4986 | | } |
| | | 4987 | | |
| | 3 | 4988 | | value = args[index + 1]; |
| | 3 | 4989 | | index += 2; |
| | 3 | 4990 | | error = string.Empty; |
| | 3 | 4991 | | return true; |
| | | 4992 | | } |
| | | 4993 | | |
| | | 4994 | | /// <summary> |
| | | 4995 | | /// Dispatches command parsing based on the selected command token. |
| | | 4996 | | /// </summary> |
| | | 4997 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 4998 | | /// <param name="commandTokenIndex">Index of the command token.</param> |
| | | 4999 | | /// <param name="kestrunFolder">Optional module folder path.</param> |
| | | 5000 | | /// <param name="kestrunManifestPath">Optional module manifest path.</param> |
| | | 5001 | | /// <param name="parsedCommand">Parsed command payload.</param> |
| | | 5002 | | /// <param name="error">Error message when dispatch fails.</param> |
| | | 5003 | | /// <returns>True when command parsing succeeds.</returns> |
| | | 5004 | | private static bool TryParseCommandFromToken( |
| | | 5005 | | string[] args, |
| | | 5006 | | int commandTokenIndex, |
| | | 5007 | | string? kestrunFolder, |
| | | 5008 | | string? kestrunManifestPath, |
| | | 5009 | | out ParsedCommand parsedCommand, |
| | | 5010 | | out string error) |
| | | 5011 | | { |
| | 96 | 5012 | | var commandToken = args[commandTokenIndex]; |
| | 96 | 5013 | | if (string.Equals(commandToken, "run", StringComparison.OrdinalIgnoreCase)) |
| | | 5014 | | { |
| | 8 | 5015 | | return TryParseRunArguments(args, commandTokenIndex + 1, kestrunFolder, kestrunManifestPath, out parsedComma |
| | | 5016 | | } |
| | | 5017 | | |
| | 88 | 5018 | | if (string.Equals(commandToken, "service", StringComparison.OrdinalIgnoreCase)) |
| | | 5019 | | { |
| | 76 | 5020 | | return TryParseServiceArguments(args, commandTokenIndex + 1, kestrunFolder, kestrunManifestPath, out parsedC |
| | | 5021 | | } |
| | | 5022 | | |
| | 12 | 5023 | | if (string.Equals(commandToken, "module", StringComparison.OrdinalIgnoreCase)) |
| | | 5024 | | { |
| | 10 | 5025 | | return TryParseModuleArguments(args, commandTokenIndex + 1, out parsedCommand, out error); |
| | | 5026 | | } |
| | | 5027 | | |
| | 2 | 5028 | | parsedCommand = new ParsedCommand(CommandMode.Run, string.Empty, false, [], null, null, null, false, null, null, |
| | 2 | 5029 | | error = $"Unknown command: {commandToken}. Use '{ProductName} help' to list commands."; |
| | 2 | 5030 | | return false; |
| | | 5031 | | } |
| | | 5032 | | |
| | | 5033 | | /// <summary> |
| | | 5034 | | /// Handles help/info/version command routing before command parsing. |
| | | 5035 | | /// </summary> |
| | | 5036 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 5037 | | /// <param name="exitCode">Exit code for the handled command.</param> |
| | | 5038 | | /// <returns>True when a meta command was handled.</returns> |
| | | 5039 | | private static bool TryHandleMetaCommands(string[] args, out int exitCode) |
| | | 5040 | | { |
| | 10 | 5041 | | exitCode = 0; |
| | 10 | 5042 | | var filtered = FilterGlobalOptions(args); |
| | 10 | 5043 | | if (filtered.Count == 0) |
| | | 5044 | | { |
| | 1 | 5045 | | PrintUsage(); |
| | 1 | 5046 | | return true; |
| | | 5047 | | } |
| | | 5048 | | |
| | 9 | 5049 | | if (IsHelpToken(filtered[0]) || string.Equals(filtered[0], "help", StringComparison.OrdinalIgnoreCase)) |
| | | 5050 | | { |
| | 4 | 5051 | | if (filtered.Count == 1) |
| | | 5052 | | { |
| | 2 | 5053 | | PrintUsage(); |
| | 2 | 5054 | | return true; |
| | | 5055 | | } |
| | | 5056 | | |
| | 2 | 5057 | | if (filtered.Count == 2 && TryGetHelpTopic(filtered[1], out var topic)) |
| | | 5058 | | { |
| | 1 | 5059 | | PrintHelpForTopic(topic); |
| | 1 | 5060 | | return true; |
| | | 5061 | | } |
| | | 5062 | | |
| | 1 | 5063 | | Console.Error.WriteLine("Unknown help topic. Use 'kestrun help' to list available topics."); |
| | 1 | 5064 | | exitCode = 2; |
| | 1 | 5065 | | return true; |
| | | 5066 | | } |
| | | 5067 | | |
| | 5 | 5068 | | if (filtered.Count == 2 |
| | 5 | 5069 | | && TryGetHelpTopic(filtered[0], out var commandTopic) |
| | 5 | 5070 | | && (IsHelpToken(filtered[1]) || string.Equals(filtered[1], "help", StringComparison.OrdinalIgnoreCase))) |
| | | 5071 | | { |
| | 1 | 5072 | | PrintHelpForTopic(commandTopic); |
| | 1 | 5073 | | return true; |
| | | 5074 | | } |
| | | 5075 | | |
| | 4 | 5076 | | if (filtered.Count == 1 && string.Equals(filtered[0], "version", StringComparison.OrdinalIgnoreCase)) |
| | | 5077 | | { |
| | 1 | 5078 | | PrintVersion(); |
| | 1 | 5079 | | return true; |
| | | 5080 | | } |
| | | 5081 | | |
| | 3 | 5082 | | if (filtered.Count == 1 && string.Equals(filtered[0], "info", StringComparison.OrdinalIgnoreCase)) |
| | | 5083 | | { |
| | 1 | 5084 | | PrintInfo(); |
| | 1 | 5085 | | return true; |
| | | 5086 | | } |
| | | 5087 | | |
| | 2 | 5088 | | return false; |
| | | 5089 | | } |
| | | 5090 | | |
| | | 5091 | | /// <summary> |
| | | 5092 | | /// Checks whether an argument token requests usage help. |
| | | 5093 | | /// </summary> |
| | | 5094 | | /// <param name="token">Command-line token to inspect.</param> |
| | | 5095 | | /// <returns>True when the token is a help switch.</returns> |
| | 10 | 5096 | | private static bool IsHelpToken(string token) => token is "-h" or "--help" or "/?"; |
| | | 5097 | | |
| | | 5098 | | /// <summary> |
| | | 5099 | | /// Tries to map a help topic token to a known command topic. |
| | | 5100 | | /// </summary> |
| | | 5101 | | /// <param name="token">Input help topic token.</param> |
| | | 5102 | | /// <param name="topic">Normalized topic when recognized.</param> |
| | | 5103 | | /// <returns>True when the topic is recognized.</returns> |
| | | 5104 | | private static bool TryGetHelpTopic(string token, out string topic) |
| | | 5105 | | { |
| | 3 | 5106 | | topic = token.ToLowerInvariant(); |
| | 3 | 5107 | | return topic is "run" or "service" or "module" or "info" or "version"; |
| | | 5108 | | } |
| | | 5109 | | |
| | | 5110 | | /// <summary> |
| | | 5111 | | /// Filters known global options injected by launchers from command-line args. |
| | | 5112 | | /// </summary> |
| | | 5113 | | /// <param name="args">Raw command-line arguments.</param> |
| | | 5114 | | /// <returns>Arguments without known global options and their values.</returns> |
| | | 5115 | | private static List<string> FilterGlobalOptions(string[] args) |
| | | 5116 | | { |
| | 11 | 5117 | | var filtered = new List<string>(args.Length); |
| | 50 | 5118 | | for (var index = 0; index < args.Length; index++) |
| | | 5119 | | { |
| | 14 | 5120 | | if (args[index] is "--kestrun-folder" or "-k" or "--kestrun-manifest" or "-m") |
| | | 5121 | | { |
| | 0 | 5122 | | index += 1; |
| | 0 | 5123 | | continue; |
| | | 5124 | | } |
| | | 5125 | | |
| | 14 | 5126 | | if (IsNoCheckOption(args[index])) |
| | | 5127 | | { |
| | | 5128 | | continue; |
| | | 5129 | | } |
| | | 5130 | | |
| | 13 | 5131 | | filtered.Add(args[index]); |
| | | 5132 | | } |
| | | 5133 | | |
| | 11 | 5134 | | return filtered; |
| | | 5135 | | } |
| | | 5136 | | |
| | | 5137 | | /// <summary> |
| | | 5138 | | /// Prints command usage and discovery hints. |
| | | 5139 | | /// </summary> |
| | | 5140 | | private static void PrintUsage() |
| | | 5141 | | { |
| | 5 | 5142 | | Console.WriteLine("Usage:"); |
| | 5 | 5143 | | Console.WriteLine(" kestrun <command> [options]"); |
| | 5 | 5144 | | Console.WriteLine(); |
| | 5 | 5145 | | Console.WriteLine("Global options:"); |
| | 5 | 5146 | | Console.WriteLine($" {NoCheckOption} Skip PowerShell Gallery update check warnings."); |
| | 5 | 5147 | | Console.WriteLine(); |
| | 5 | 5148 | | Console.WriteLine("Commands:"); |
| | 5 | 5149 | | Console.WriteLine(" run Run a PowerShell script (default script: ./Service.ps1)"); |
| | 5 | 5150 | | Console.WriteLine(" module Manage Kestrun module (install/update/remove/info)"); |
| | 5 | 5151 | | Console.WriteLine(" service Manage service lifecycle (install/update/remove/start/stop/query/info)"); |
| | 5 | 5152 | | Console.WriteLine(" info Show runtime/build diagnostics"); |
| | 5 | 5153 | | Console.WriteLine(" version Show tool version"); |
| | 5 | 5154 | | Console.WriteLine(); |
| | 5 | 5155 | | Console.WriteLine("Help topics:"); |
| | 5 | 5156 | | Console.WriteLine(" kestrun run help"); |
| | 5 | 5157 | | Console.WriteLine(" kestrun module help"); |
| | 5 | 5158 | | Console.WriteLine(" kestrun service help"); |
| | 5 | 5159 | | Console.WriteLine(" kestrun info help"); |
| | 5 | 5160 | | Console.WriteLine(" kestrun version help"); |
| | 5 | 5161 | | } |
| | | 5162 | | |
| | | 5163 | | /// <summary> |
| | | 5164 | | /// Prints detailed help for a specific topic. |
| | | 5165 | | /// </summary> |
| | | 5166 | | /// <param name="topic">Help topic.</param> |
| | | 5167 | | private static void PrintHelpForTopic(string topic) |
| | | 5168 | | { |
| | | 5169 | | switch (topic) |
| | | 5170 | | { |
| | | 5171 | | case "run": |
| | 3 | 5172 | | Console.WriteLine("Usage:"); |
| | 3 | 5173 | | Console.WriteLine(" kestrun [--nocheck] [--kestrun-folder <folder>] [--kestrun-manifest <path-to-Kestru |
| | 3 | 5174 | | Console.WriteLine(); |
| | 3 | 5175 | | Console.WriteLine("Options:"); |
| | 3 | 5176 | | Console.WriteLine(" --script <path> Optional named script path (alternative to positional < |
| | 3 | 5177 | | Console.WriteLine(" --kestrun-manifest <path> Use an explicit Kestrun.psd1 manifest file."); |
| | 3 | 5178 | | Console.WriteLine(" --arguments <args...> Pass remaining values to the script as script arguments |
| | 3 | 5179 | | Console.WriteLine(); |
| | 3 | 5180 | | Console.WriteLine("Notes:"); |
| | 3 | 5181 | | Console.WriteLine(" - If no script is provided, ./Service.ps1 is used."); |
| | 3 | 5182 | | Console.WriteLine(" - Script arguments must be passed after --arguments (or --)."); |
| | 3 | 5183 | | Console.WriteLine(" - Use --kestrun-manifest to pin a specific Kestrun.psd1 file."); |
| | 3 | 5184 | | Console.WriteLine($" - If {ModuleName} is missing, run '{ProductName} module install'."); |
| | 3 | 5185 | | break; |
| | | 5186 | | |
| | | 5187 | | case "module": |
| | 1 | 5188 | | Console.WriteLine("Usage:"); |
| | 1 | 5189 | | Console.WriteLine($" {ProductName} module install [{ModuleVersionOption} <version>] [{ModuleScopeOption |
| | 1 | 5190 | | Console.WriteLine($" {ProductName} module update [{ModuleVersionOption} <version>] [{ModuleScopeOption} |
| | 1 | 5191 | | Console.WriteLine($" {ProductName} module remove [{ModuleScopeOption} <{ModuleScopeLocalValue}|{ModuleS |
| | 1 | 5192 | | Console.WriteLine($" {ProductName} module info [{ModuleScopeOption} <{ModuleScopeLocalValue}|{ModuleSco |
| | 1 | 5193 | | Console.WriteLine(); |
| | 1 | 5194 | | Console.WriteLine("Options:"); |
| | 1 | 5195 | | Console.WriteLine($" {ModuleVersionOption} <version> Optional specific version for install/update. |
| | 1 | 5196 | | Console.WriteLine($" {ModuleScopeOption} <scope> Module storage scope: '{ModuleScopeLocalValue} |
| | 1 | 5197 | | Console.WriteLine($" {ModuleForceOption} Overwrite existing target version folder for u |
| | 1 | 5198 | | Console.WriteLine(); |
| | 1 | 5199 | | Console.WriteLine("Notes:"); |
| | 1 | 5200 | | Console.WriteLine($" - install: fails when Kestrun is already installed; use '{ProductName} module upda |
| | 1 | 5201 | | Console.WriteLine($" - update: updates to latest when no --version is provided and fails if the target |
| | 1 | 5202 | | Console.WriteLine(" - remove: removes all installed versions from the selected scope and shows deletion |
| | 1 | 5203 | | Console.WriteLine(" - info: shows installed module versions and latest Gallery version for the selected |
| | 1 | 5204 | | Console.WriteLine(" - Windows global scope for install/update/remove prompts for elevation (UAC) when n |
| | 1 | 5205 | | break; |
| | | 5206 | | |
| | | 5207 | | case "service": |
| | 1 | 5208 | | Console.WriteLine("Usage:"); |
| | 1 | 5209 | | Console.WriteLine(" kestrun [--nocheck] [--kestrun-manifest <path-to-Kestrun.psd1>] service install [-- |
| | 1 | 5210 | | Console.WriteLine(" kestrun [--nocheck] service update --name <service-name> [--package <path-or-url-to |
| | 1 | 5211 | | Console.WriteLine(" kestrun service remove --name <service-name>"); |
| | 1 | 5212 | | Console.WriteLine(" kestrun service start --name <service-name> [--json | --raw]"); |
| | 1 | 5213 | | Console.WriteLine(" kestrun service stop --name <service-name> [--json | --raw]"); |
| | 1 | 5214 | | Console.WriteLine(" kestrun service query --name <service-name> [--json | --raw]"); |
| | 1 | 5215 | | Console.WriteLine(" kestrun service info [--name <service-name>] [--json]"); |
| | 1 | 5216 | | Console.WriteLine(); |
| | 1 | 5217 | | Console.WriteLine("Options (service install):"); |
| | 1 | 5218 | | Console.WriteLine(" --package <path-or-url> Required .krpack (zip) package containing Service.psd1 |
| | 1 | 5219 | | Console.WriteLine(" --content-root-checksum <h> Verify package checksum before extraction (hex string). |
| | 1 | 5220 | | Console.WriteLine(" --content-root-checksum-algorithm <name> Hash algorithm: md5, sha1, sha256, sha384 |
| | 1 | 5221 | | Console.WriteLine(" --content-root-bearer-token <token> Add Authorization: Bearer <token> for HTTP(S) |
| | 1 | 5222 | | Console.WriteLine(" --content-root-header <name:value> Add custom HTTP request header for HTTP(S) pack |
| | 1 | 5223 | | Console.WriteLine(" --content-root-ignore-certificate Ignore HTTPS certificate validation for package |
| | 1 | 5224 | | Console.WriteLine(" --deployment-root <folder> Override where per-service bundles are created (default |
| | 1 | 5225 | | Console.WriteLine(" --runtime-source <path-or-url> Override runtime acquisition using a local folder, |
| | 1 | 5226 | | Console.WriteLine(" --runtime-package <path> Use an explicit local Kestrun.Service.<rid> .nupkg for |
| | 1 | 5227 | | Console.WriteLine(" --runtime-version <version> Override the runtime package version (defaults to the c |
| | 1 | 5228 | | Console.WriteLine(" --runtime-package-id <id> Override the runtime package id (defaults to Kestrun.Se |
| | 1 | 5229 | | Console.WriteLine(" --runtime-cache <folder> Override the local runtime package cache directory."); |
| | 1 | 5230 | | Console.WriteLine(" --kestrun-manifest <path> Use an explicit Kestrun.psd1 manifest for the service r |
| | 1 | 5231 | | Console.WriteLine(" --service-log-path <path> Set service bootstrap/operation log file path."); |
| | 1 | 5232 | | Console.WriteLine(" --service-user <account> Run installed service/daemon under a specific OS accoun |
| | 1 | 5233 | | Console.WriteLine(" --service-password <secret> Password for --service-user on Windows service accounts |
| | 1 | 5234 | | Console.WriteLine(" --arguments <args...> Pass remaining values to the installed script."); |
| | 1 | 5235 | | Console.WriteLine(" --kestrun For service update: use repository module at src/PowerS |
| | 1 | 5236 | | Console.WriteLine(" --kestrun-module <path> For service update: module manifest path or folder to r |
| | 1 | 5237 | | Console.WriteLine(" --failback For service update: restore application/module from lat |
| | 1 | 5238 | | Console.WriteLine(" --json For service start/stop/query/info: output JSON instead |
| | 1 | 5239 | | Console.WriteLine(" --raw For service start/stop/query: output native OS command |
| | 1 | 5240 | | Console.WriteLine(); |
| | 1 | 5241 | | Console.WriteLine("Notes:"); |
| | 1 | 5242 | | Console.WriteLine(" - install registers the service/daemon but does not auto-start it."); |
| | 1 | 5243 | | Console.WriteLine(" - update fails when the service is running; stop it first."); |
| | 1 | 5244 | | Console.WriteLine(" - update requires at least one of --package or --kestrun-module/--kestrun-manifest |
| | 1 | 5245 | | Console.WriteLine(" - --kestrun updates bundled module only when repository module version is newer; ot |
| | 1 | 5246 | | Console.WriteLine(" - --failback restores from latest backup and fails when no backup is available."); |
| | 1 | 5247 | | Console.WriteLine(" - info without --name lists installed Kestrun services."); |
| | 1 | 5248 | | Console.WriteLine(" - Service name and entry point are read from Service.psd1 in the package."); |
| | 1 | 5249 | | Console.WriteLine(" - Service.psd1 requires FormatVersion='1.0', Name, EntryPoint, and Description."); |
| | 1 | 5250 | | Console.WriteLine(" - Package file must use .krpack extension and contain zip content."); |
| | 1 | 5251 | | Console.WriteLine(" - install resolves a runtime package for the current RID using Kestrun.Service.<rid |
| | 1 | 5252 | | Console.WriteLine(" - install caches canonical runtime packages under packages/<id>/<version>/<id>.<ver |
| | 1 | 5253 | | Console.WriteLine(" - install can be used without --package to prefetch a runtime package into cache on |
| | 1 | 5254 | | Console.WriteLine(" - install does not fall back to the runtime bundled with Kestrun.Tool when package |
| | 1 | 5255 | | Console.WriteLine(" - use --runtime-package for offline installs or --runtime-source to point at a loca |
| | 1 | 5256 | | Console.WriteLine(" - --content-root-checksum is validated against the package file before extraction." |
| | 1 | 5257 | | Console.WriteLine(" - --content-root-bearer-token is used for HTTP(S) package URLs and HTTP(S) runtime- |
| | 1 | 5258 | | Console.WriteLine(" - --content-root-header is used for HTTP(S) package URLs and HTTP(S) runtime-source |
| | 1 | 5259 | | Console.WriteLine(" - --content-root-ignore-certificate applies only to HTTPS package URLs/runtime-sour |
| | 1 | 5260 | | Console.WriteLine(" - --deployment-root overrides the OS default bundle root used during install and re |
| | 1 | 5261 | | Console.WriteLine(" - --service-user enables platform account mapping: Windows service account, Linux s |
| | 1 | 5262 | | Console.WriteLine(" - install snapshots runtime/module/script plus the dedicated service host from the |
| | 1 | 5263 | | Console.WriteLine(" - install shows progress bars during bundle staging in interactive terminals."); |
| | 1 | 5264 | | Console.WriteLine(" - bundle roots: Windows %ProgramData%\\Kestrun\\services; Linux /var/kestrun/servic |
| | 1 | 5265 | | Console.WriteLine(" - remove/start/stop/query require --name and do not accept script paths."); |
| | 1 | 5266 | | Console.WriteLine($" - Use '{ProductName} module install' before service install when {ModuleName} is n |
| | 1 | 5267 | | break; |
| | | 5268 | | |
| | | 5269 | | case "info": |
| | 1 | 5270 | | Console.WriteLine("Usage:"); |
| | 1 | 5271 | | Console.WriteLine(" kestrun info"); |
| | 1 | 5272 | | Console.WriteLine(); |
| | 1 | 5273 | | Console.WriteLine("Shows runtime and build diagnostics (framework, OS, architecture, and binary paths)." |
| | 1 | 5274 | | break; |
| | | 5275 | | |
| | | 5276 | | case "version": |
| | 1 | 5277 | | Console.WriteLine("Usage:"); |
| | 1 | 5278 | | Console.WriteLine(" kestrun version"); |
| | 1 | 5279 | | Console.WriteLine(); |
| | 1 | 5280 | | Console.WriteLine("Shows the kestrun tool version."); |
| | | 5281 | | break; |
| | | 5282 | | } |
| | 1 | 5283 | | } |
| | | 5284 | | |
| | | 5285 | | /// <summary> |
| | | 5286 | | /// Prints the KestrunTool version. |
| | | 5287 | | /// </summary> |
| | | 5288 | | private static void PrintVersion() |
| | | 5289 | | { |
| | 2 | 5290 | | var version = GetProductVersion(); |
| | 2 | 5291 | | Console.WriteLine($"{ProductName} {version}"); |
| | 2 | 5292 | | } |
| | | 5293 | | |
| | | 5294 | | /// <summary> |
| | | 5295 | | /// Prints diagnostic information about the KestrunTool build and runtime. |
| | | 5296 | | /// </summary> |
| | | 5297 | | private static void PrintInfo() |
| | | 5298 | | { |
| | 2 | 5299 | | var version = GetProductVersion(); |
| | 2 | 5300 | | var assembly = typeof(Program).Assembly; |
| | 2 | 5301 | | var informationalVersion = assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVe |
| | | 5302 | | |
| | 2 | 5303 | | Console.WriteLine($"Product: {ProductName}"); |
| | 2 | 5304 | | Console.WriteLine($"Version: {version}"); |
| | 2 | 5305 | | Console.WriteLine($"InformationalVersion: {informationalVersion}"); |
| | 2 | 5306 | | Console.WriteLine($"Framework: {RuntimeInformation.FrameworkDescription}"); |
| | 2 | 5307 | | Console.WriteLine($"OS: {RuntimeInformation.OSDescription}"); |
| | 2 | 5308 | | Console.WriteLine($"OSArchitecture: {RuntimeInformation.OSArchitecture}"); |
| | 2 | 5309 | | Console.WriteLine($"ProcessArchitecture: {RuntimeInformation.ProcessArchitecture}"); |
| | 2 | 5310 | | Console.WriteLine($"ExecutableDirectory: {GetExecutableDirectory()}"); |
| | 2 | 5311 | | Console.WriteLine($"BaseDirectory: {Path.GetFullPath(AppContext.BaseDirectory)}"); |
| | 2 | 5312 | | } |
| | | 5313 | | |
| | | 5314 | | /// <summary> |
| | | 5315 | | /// Gets the product version from assembly metadata. |
| | | 5316 | | /// </summary> |
| | | 5317 | | /// <returns>Product version string.</returns> |
| | | 5318 | | private static string GetProductVersion() |
| | | 5319 | | { |
| | 14 | 5320 | | var assembly = typeof(Program).Assembly; |
| | 14 | 5321 | | var informationalVersion = assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVe |
| | 14 | 5322 | | return !string.IsNullOrWhiteSpace(informationalVersion) ? |
| | 14 | 5323 | | informationalVersion : assembly.GetName().Version?.ToString() ?? "0.0.0"; |
| | | 5324 | | } |
| | | 5325 | | |
| | | 5326 | | /// <summary> |
| | | 5327 | | /// Locates Kestrun.psd1 without launching an external pwsh process. |
| | | 5328 | | /// </summary> |
| | | 5329 | | /// <param name="kestrunManifestPath">Optional explicit path to Kestrun.psd1.</param> |
| | | 5330 | | /// <param name="kestrunFolder">Optional folder containing Kestrun.psd1.</param> |
| | | 5331 | | /// <returns>Absolute manifest path when found; otherwise null.</returns> |
| | | 5332 | | private static string? LocateModuleManifest(string? kestrunManifestPath, string? kestrunFolder) |
| | | 5333 | | { |
| | 10 | 5334 | | if (!string.IsNullOrWhiteSpace(kestrunManifestPath)) |
| | | 5335 | | { |
| | 9 | 5336 | | var explicitPath = Path.GetFullPath(kestrunManifestPath); |
| | 9 | 5337 | | var explicitManifest = Directory.Exists(explicitPath) |
| | 9 | 5338 | | ? Path.Combine(explicitPath, ModuleManifestFileName) |
| | 9 | 5339 | | : explicitPath; |
| | 9 | 5340 | | return File.Exists(explicitManifest) ? explicitManifest : null; |
| | | 5341 | | } |
| | | 5342 | | |
| | 1 | 5343 | | if (!string.IsNullOrWhiteSpace(kestrunFolder)) |
| | | 5344 | | { |
| | 1 | 5345 | | var explicitFolder = Path.GetFullPath(kestrunFolder); |
| | 1 | 5346 | | var explicitCandidate = Path.Combine(explicitFolder, ModuleManifestFileName); |
| | 1 | 5347 | | return File.Exists(explicitCandidate) ? explicitCandidate : null; |
| | | 5348 | | } |
| | | 5349 | | |
| | 0 | 5350 | | foreach (var candidate in EnumerateExecutableManifestCandidates()) |
| | | 5351 | | { |
| | 0 | 5352 | | if (File.Exists(candidate)) |
| | | 5353 | | { |
| | 0 | 5354 | | return Path.GetFullPath(candidate); |
| | | 5355 | | } |
| | | 5356 | | } |
| | | 5357 | | |
| | 0 | 5358 | | foreach (var candidate in EnumerateModulePathManifestCandidates()) |
| | | 5359 | | { |
| | 0 | 5360 | | if (File.Exists(candidate)) |
| | | 5361 | | { |
| | 0 | 5362 | | return Path.GetFullPath(candidate); |
| | | 5363 | | } |
| | | 5364 | | } |
| | | 5365 | | |
| | 0 | 5366 | | return null; |
| | 0 | 5367 | | } |
| | | 5368 | | |
| | | 5369 | | /// <summary> |
| | | 5370 | | /// Enumerates candidate locations for Kestrun.psd1 under the executable folder. |
| | | 5371 | | /// </summary> |
| | | 5372 | | /// <returns>Absolute manifest path when found; otherwise null.</returns> |
| | | 5373 | | private static IEnumerable<string> EnumerateExecutableManifestCandidates() |
| | | 5374 | | { |
| | 0 | 5375 | | var executableDirectory = GetExecutableDirectory(); |
| | | 5376 | | |
| | 0 | 5377 | | yield return Path.Combine(executableDirectory, ModuleManifestFileName); |
| | 0 | 5378 | | yield return Path.Combine(executableDirectory, ModuleName, ModuleManifestFileName); |
| | | 5379 | | |
| | 0 | 5380 | | var baseDirectory = Path.GetFullPath(AppContext.BaseDirectory); |
| | 0 | 5381 | | if (!string.Equals(baseDirectory, executableDirectory, StringComparison.OrdinalIgnoreCase)) |
| | | 5382 | | { |
| | 0 | 5383 | | yield return Path.Combine(baseDirectory, ModuleManifestFileName); |
| | 0 | 5384 | | yield return Path.Combine(baseDirectory, ModuleName, ModuleManifestFileName); |
| | | 5385 | | } |
| | 0 | 5386 | | } |
| | | 5387 | | |
| | | 5388 | | /// <summary> |
| | | 5389 | | /// Gets the directory where the executable file is located. |
| | | 5390 | | /// </summary> |
| | | 5391 | | /// <returns>Absolute executable directory path.</returns> |
| | | 5392 | | private static string GetExecutableDirectory() |
| | | 5393 | | { |
| | 23 | 5394 | | var processPath = Environment.ProcessPath; |
| | 23 | 5395 | | if (!string.IsNullOrWhiteSpace(processPath)) |
| | | 5396 | | { |
| | 23 | 5397 | | var processDirectory = Path.GetDirectoryName(processPath); |
| | 23 | 5398 | | if (!string.IsNullOrWhiteSpace(processDirectory)) |
| | | 5399 | | { |
| | 23 | 5400 | | return Path.GetFullPath(processDirectory); |
| | | 5401 | | } |
| | | 5402 | | } |
| | | 5403 | | |
| | 0 | 5404 | | return Path.GetFullPath(AppContext.BaseDirectory); |
| | | 5405 | | } |
| | | 5406 | | |
| | | 5407 | | /// <summary> |
| | | 5408 | | /// Enumerates candidate manifest paths under PSModulePath entries. |
| | | 5409 | | /// </summary> |
| | | 5410 | | /// <returns>Potential manifest file paths from PSModulePath.</returns> |
| | | 5411 | | private static IEnumerable<string> EnumerateModulePathManifestCandidates() |
| | | 5412 | | { |
| | 0 | 5413 | | var moduleRoots = new HashSet<string>(StringComparer.OrdinalIgnoreCase); |
| | | 5414 | | |
| | 0 | 5415 | | var modulePathRaw = Environment.GetEnvironmentVariable("PSModulePath"); |
| | 0 | 5416 | | if (!string.IsNullOrWhiteSpace(modulePathRaw)) |
| | | 5417 | | { |
| | 0 | 5418 | | foreach (var root in modulePathRaw.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries | StringS |
| | | 5419 | | { |
| | 0 | 5420 | | if (!string.IsNullOrWhiteSpace(root)) |
| | | 5421 | | { |
| | 0 | 5422 | | _ = moduleRoots.Add(root); |
| | | 5423 | | } |
| | | 5424 | | } |
| | | 5425 | | } |
| | | 5426 | | |
| | | 5427 | | // Service and elevated contexts can have an incomplete PSModulePath. |
| | | 5428 | | // Always include the conventional user/global module roots as discovery fallbacks. |
| | 0 | 5429 | | _ = moduleRoots.Add(GetDefaultPowerShellModulePath()); |
| | 0 | 5430 | | _ = moduleRoots.Add(GetGlobalPowerShellModulePath()); |
| | | 5431 | | |
| | 0 | 5432 | | foreach (var root in moduleRoots) |
| | | 5433 | | { |
| | 0 | 5434 | | var moduleDirectory = Path.Combine(root, ModuleName); |
| | 0 | 5435 | | yield return Path.Combine(moduleDirectory, ModuleManifestFileName); |
| | | 5436 | | |
| | 0 | 5437 | | if (!Directory.Exists(moduleDirectory)) |
| | | 5438 | | { |
| | | 5439 | | continue; |
| | | 5440 | | } |
| | | 5441 | | |
| | 0 | 5442 | | var versionDirectories = Directory.EnumerateDirectories(moduleDirectory) |
| | | 5443 | | .OrderByDescending(path => path, StringComparer.OrdinalIgnoreCase); |
| | | 5444 | | |
| | 0 | 5445 | | foreach (var versionDirectory in versionDirectories) |
| | | 5446 | | { |
| | 0 | 5447 | | yield return Path.Combine(versionDirectory, ModuleManifestFileName); |
| | | 5448 | | } |
| | 0 | 5449 | | } |
| | 0 | 5450 | | } |
| | | 5451 | | } |