Skip to content

Free, open-source Windows optimization tool for performance, privacy, and simplicity.

fix: service parsing now can parse correctly other windows languages

fatDuckb35bb4eda32b
diff --git a/optimizerDuck.Test/Services/OptimizationServices/ServiceProcessServiceTests.cs b/optimizerDuck.Test/Services/OptimizationServices/ServiceProcessServiceTests.cs
new file mode 100644
index 0000000..fea6e37
--- /dev/null
+++ b/optimizerDuck.Test/Services/OptimizationServices/ServiceProcessServiceTests.cs
@@ -0,0 +1,227 @@
+using optimizerDuck.Domain.Optimizations.Models.Services;
+using optimizerDuck.Services.Optimization.Providers;
+
+namespace optimizerDuck.Test.Services.OptimizationServices;
+
+public class ServiceProcessServiceTests
+{
+ // =============================================
+ // Unit tests: ParseScStartType (hardcoded input)
+ // =============================================
+
+ [Fact]
+ public void ParseScStartType_AutoStart_ReturnsAutomatic()
+ {
+ var stdout = """
+ SERVICE_NAME: Audiosrv
+ TYPE : 20 WIN32_SHARE_PROCESS
+ START_TYPE : 2 AUTO_START
+ ERROR_CONTROL : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.Automatic, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_AutoStartDelayed_ReturnsAutomaticDelayedStart()
+ {
+ var stdout = """
+ SERVICE_NAME: CDPSvc
+ TYPE : 20 WIN32_SHARE_PROCESS
+ START_TYPE : 2 AUTO_START (DELAYED)
+ ERROR_CONTROL : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.AutomaticDelayedStart, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_DemandStart_ReturnsManual()
+ {
+ var stdout = """
+ SERVICE_NAME: BITS
+ TYPE : 20 WIN32_SHARE_PROCESS
+ START_TYPE : 3 DEMAND_START
+ ERROR_CONTROL : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.Manual, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_Disabled_ReturnsDisabled()
+ {
+ var stdout = """
+ SERVICE_NAME: AppVClient
+ TYPE : 10 WIN32_OWN_PROCESS
+ START_TYPE : 4 DISABLED
+ ERROR_CONTROL : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.Disabled, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_BootStart_ReturnsNullNotFailed()
+ {
+ var stdout = """
+ SERVICE_NAME: ACPI
+ TYPE : 1 KERNEL_DRIVER
+ START_TYPE : 0 BOOT_START
+ ERROR_CONTROL : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Null(result);
+ }
+
+ [Fact]
+ public void ParseScStartType_SystemStart_ReturnsNullNotFailed()
+ {
+ var stdout = """
+ SERVICE_NAME: AFD
+ TYPE : 1 KERNEL_DRIVER
+ START_TYPE : 1 SYSTEM_START
+ ERROR_CONTROL : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Null(result);
+ }
+
+ [Fact]
+ public void ParseScStartType_NoStartTypeLine_ReturnsParseFailed()
+ {
+ var stdout = """
+ SERVICE_NAME: TestSvc
+ BINARY_PATH_NAME : C:\test.exe
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.True(parseFailed);
+ Assert.Null(result);
+ }
+
+ [Fact]
+ public void ParseScStartType_IgnoresErrorControlLine_ReturnsCorrectType()
+ {
+ var stdout = """
+ SERVICE_NAME: Test
+ TYPE : 20 WIN32_SHARE_PROCESS
+ START_TYPE : 3 DEMAND_START
+ ERROR_CONTROL : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.Manual, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_IgnoresTagZero_ReturnsCorrectType()
+ {
+ var stdout = """
+ SERVICE_NAME: Test
+ TYPE : 20 WIN32_SHARE_PROCESS
+ START_TYPE : 3 DEMAND_START
+ ERROR_CONTROL : 1 NORMAL
+ TAG : 0
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.Manual, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_LocaleIndependentFieldName_ReturnsCorrectType()
+ {
+ var stdout = """
+ SERVICE_NAME: Test
+ FOO_TYPE : 20 WIN32_SHARE_PROCESS
+ STARTTYP : 2 AUTOMATISCHER_START
+ FEHLERKONTROLLE : 1 NORMAL
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.Automatic, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_LocaleIndependentDelayed_ReturnsAutomaticDelayedStart()
+ {
+ var stdout = """
+ SERVICE_NAME: Test
+ STARTTYP : 2 AUTOMATISCHER_START (VERZÖGERT)
+ """;
+
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType(stdout);
+
+ Assert.False(parseFailed);
+ Assert.Equal(ServiceStartupType.AutomaticDelayedStart, result);
+ }
+
+ [Fact]
+ public void ParseScStartType_EmptyOutput_ReturnsParseFailed()
+ {
+ var (result, parseFailed) = ServiceProcessService.ParseScStartType("");
+
+ Assert.True(parseFailed);
+ Assert.Null(result);
+ }
+
+ // =============================================
+ // Integration tests: GetStartupTypeAsync (real sc.exe)
+ // =============================================
+
+ [Fact]
+ public async Task GetStartupTypeAsync_ExistingAutoService_ReturnsAutomatic()
+ {
+ var (result, notFound) = await ServiceProcessService.GetStartupTypeAsync("Audiosrv");
+
+ Assert.False(notFound);
+ Assert.NotNull(result);
+ Assert.Equal(ServiceStartupType.Automatic, result);
+ }
+
+ [Fact]
+ public async Task GetStartupTypeAsync_ExistingDemandService_ReturnsManual()
+ {
+ var (result, notFound) = await ServiceProcessService.GetStartupTypeAsync("BITS");
+
+ Assert.False(notFound);
+ Assert.NotNull(result);
+ Assert.Equal(ServiceStartupType.Manual, result);
+ }
+
+ [Fact]
+ public async Task GetStartupTypeAsync_NonexistentService_ReturnsNotFound()
+ {
+ var (_, notFound) = await ServiceProcessService.GetStartupTypeAsync(
+ "OptimizerDuckTest_Nonexistent_Service_12345"
+ );
+
+ Assert.True(notFound);
+ }
+}
diff --git a/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs b/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs
index 04f9d71..ce11225 100644
--- a/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs
+++ b/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs
@@ -15,19 +15,65 @@ public static class ServiceProcessService
private static readonly AsyncLocal<string?> _lastError = new();
private static readonly AsyncLocal<string?> _lastErrorDetail = new();
- private static readonly Regex _startTypeRegex = new(
- @"START_TYPE\s*:\s*(\d+)",
- RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase
+ /// <summary>
+ /// Matches the START_TYPE line in <c>sc qc</c> output.
+ /// Format: <c>FIELD_NAME : &lt;0-4&gt; DESCRIPTION</c>
+ /// Uses <c>[0-4]</c> to match all possible START_TYPE values
+ /// (0=Boot, 1=System, 2=Auto, 3=Demand, 4=Disabled).
+ /// The first matching line is always START_TYPE because it appears
+ /// before ERROR_CONTROL and TAG in the fixed output order.
+ /// The field name is locale-dependent, so structural matching only.
+ /// Group 1 = numeric start value (0-4), Group 2 = description text
+ /// (used for delayed-auto detection on value 2).
+ /// </summary>
+ private static readonly Regex _startTypeLineRegex = new(
+ @"^\s*\S+\s*:\s*([0-4])\s(.+)$",
+ RegexOptions.Compiled
);
private static readonly Regex _delayedRegex = new(
- @"\(Delayed\)",
- RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase
+ @"\([^)]+\)",
+ RegexOptions.Compiled | RegexOptions.IgnoreCase
);
internal static string? LastError => _lastError.Value;
internal static string? LastErrorDetail => _lastErrorDetail.Value;
+ /// <summary>
+ /// Parses the START_TYPE from raw <c>sc qc</c> stdout.
+ /// Exposed as internal for unit testing.
+ /// </summary>
+ internal static (ServiceStartupType? StartupType, bool ParseFailed) ParseScStartType(
+ string stdout
+ )
+ {
+ var lines = stdout.Split([ '\r', '\n' ], StringSplitOptions.RemoveEmptyEntries);
+
+ foreach (var line in lines)
+ {
+ var match = _startTypeLineRegex.Match(line);
+ if (!match.Success)
+ continue;
+
+ var startValue = int.Parse(match.Groups[1].Value);
+ var valueText = match.Groups[2].Value;
+ var isDelayed = _delayedRegex.IsMatch(valueText);
+
+ var result = startValue switch
+ {
+ 2 => isDelayed
+ ? ServiceStartupType.AutomaticDelayedStart
+ : ServiceStartupType.Automatic,
+ 3 => ServiceStartupType.Manual,
+ 4 => ServiceStartupType.Disabled,
+ _ => (ServiceStartupType?)null,
+ };
+ return (result, false);
+ }
+
+ return (null, true);
+ }
+
/// <summary>Retrieves the current startup type of a Windows service by running <c>sc.exe qc</c>.</summary>
/// <param name="serviceName">The internal service name.</param>
/// <returns>
@@ -55,27 +101,18 @@ public static class ServiceProcessService
return (null, notFound);
}
- var startMatch = _startTypeRegex.Match(stdout);
- if (!startMatch.Success)
+ var (result, parseError) = ParseScStartType(stdout);
+
+ if (parseError)
{
ExecutionScope.LogWarning(
- "[SERVICE][{Name}] Could not parse START_TYPE from sc.exe qc output",
- serviceName
+ "[SERVICE][{Name}] Could not parse START_TYPE from sc.exe qc output:\n{Output}",
+ serviceName,
+ stdout
);
return (null, false);
}
- var startValue = int.Parse(startMatch.Groups[1].Value);
-
- var result = startValue switch
- {
- 2 => _delayedRegex.IsMatch(stdout)
- ? ServiceStartupType.AutomaticDelayedStart
- : ServiceStartupType.Automatic,
- 3 => ServiceStartupType.Manual,
- 4 => ServiceStartupType.Disabled,
- _ => (ServiceStartupType?)null,
- };
return (result, false);
}
catch (Exception ex)