feat: add license controller + process termination support

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## Release v1.0.0-beta-014 (2025-02-20)
+
+### Features
+
+* Fix bug where invalid config file lead to connector running in a loop displaying connection error
+* Introduce support for license tracking and holding.
+* Introduce support for Process termination.
+
 ## Release v1.0.0-beta-013 (2025-02-17)
 
 ### Features

Cognite.Simulator.Tests/UtilsTests/LicenseControllerTest.cs

@@ -0,0 +1,177 @@
+using Xunit;
+using System;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Cognite.Simulator.Utils;
+
+namespace Cognite.Simulator.Tests.UtilsTests{
+
+    public enum TestLicenseState
+    {
+        Released,
+        Held
+    }
+
+    public class LicenseTrackerTests
+    {
+        private readonly Mock<ILogger> _loggerMock = new Mock<ILogger>();
+
+
+
+        [Fact]
+        public void LicenseTracker_ShouldReleaseLicense_WhenNotInUse()
+        {
+            // Arrange
+            Mock<Func<object>> _releaseLicenseFuncMock = new Mock<Func<object>>();
+            Mock<Func<object>> _acquireLicenseFuncMock = new Mock<Func<object>>();
+            var licenseLockTime = TimeSpan.FromMilliseconds(100);
+            var licenseState = TestLicenseState.Released;
+            var tracker = new LicenseController(
+                licenseLockTime: licenseLockTime,
+                releaseLicenseFunc: () => 
+                { 
+                    _releaseLicenseFuncMock.Object();
+                    licenseState = TestLicenseState.Released;
+                    return null;
+                },
+                acquireLicenseFunc: () => {
+                    _acquireLicenseFuncMock.Object();
+                    licenseState = TestLicenseState.Held;
+                    return null;
+                },
+                _loggerMock.Object
+            );
+
+            // default state of the license should be released
+            Assert.Equal(TestLicenseState.Released, licenseState);
+            tracker.AcquireLicense();
+            _acquireLicenseFuncMock.Verify(f => f(), Times.Once);
+            Assert.Equal(TestLicenseState.Held, licenseState);
+            Assert.True(tracker.LicenseHeld);
+            using (tracker.BeginUsage()) { 
+                // Use and immediately release
+            } 
+
+            // Add buffer time to account for timer inconsistencies
+            Thread.Sleep(250);
+
+            _releaseLicenseFuncMock.Verify(f => f(), Times.Once);
+            Assert.Equal(TestLicenseState.Released, licenseState);
+            Assert.False(tracker.LicenseHeld);
+            tracker.Dispose();
+        }
+
+        [Fact]
+        public void LicenseTracker_ShouldNotRelease_WhileInUse()
+        {
+            // Arrange
+            var licenseLockTime = TimeSpan.FromMilliseconds(100);
+            var licenseState = TestLicenseState.Released;
+            var tracker = new LicenseController(
+                licenseLockTime: licenseLockTime,
+                releaseLicenseFunc: () => 
+                { 
+                    licenseState = TestLicenseState.Released;
+                    return null;
+                },
+                acquireLicenseFunc: () => {
+                    licenseState = TestLicenseState.Held;
+                    return null;
+                },
+                _loggerMock.Object
+            );
+
+            // Act
+            tracker.AcquireLicense();
+            Assert.Equal(TestLicenseState.Held, licenseState);
+            Assert.True(tracker.LicenseHeld);
+            using (var usage = tracker.BeginUsage())
+            {
+                Thread.Sleep(200); // Wait longer than lock time
+                Assert.True(tracker.LicenseHeld); // Should not release while in use
+            }
+
+            tracker.Dispose();
+        }
+
+        [Fact]
+        public void LicenseTracker_ShouldResetTimer_OnNewUsage()
+        {
+            // Arrange
+            var licenseLockTime = TimeSpan.FromMilliseconds(100);
+            var licenseState = TestLicenseState.Released;
+            var tracker = new LicenseController(
+                licenseLockTime: licenseLockTime,
+                releaseLicenseFunc: () => 
+                { 
+                    licenseState = TestLicenseState.Released;
+                    return null;
+                },
+                acquireLicenseFunc: () => {
+                    licenseState = TestLicenseState.Held;
+                    return null;
+                },
+                _loggerMock.Object
+            );
+
+            // Act  
+            tracker.AcquireLicense();
+            Assert.Equal(TestLicenseState.Held, licenseState);
+            using (tracker.BeginUsage()) { } // First usage
+            Thread.Sleep(50);
+
+            using (tracker.BeginUsage()) { } // Second usage should reset timer
+            Thread.Sleep(50);
+
+            // Assert
+            Assert.True(tracker.LicenseHeld); // Should not be released yet due to timer reset
+
+            Thread.Sleep(100); // Wait for full lock time
+            Assert.True(licenseState == TestLicenseState.Released);
+            Assert.False(tracker.LicenseHeld);
+
+            tracker.Dispose();
+        }
+
+        [Fact]
+        public void LicenseTracker_ShouldPreventRelease_DuringContinuousUsage()
+        {
+            // Arrange
+            var licenseLockTime = TimeSpan.FromMilliseconds(100);
+            var licenseState = TestLicenseState.Released;
+            var tracker = new LicenseController(
+                licenseLockTime: licenseLockTime,
+                releaseLicenseFunc: () => 
+                { 
+                    licenseState = TestLicenseState.Released;
+                    return null;
+                },
+                acquireLicenseFunc: () => {
+                    licenseState = TestLicenseState.Held;
+                    return null;
+                },
+                _loggerMock.Object
+            );
+
+            // Act
+            tracker.AcquireLicense();
+            using (var usage1 = tracker.BeginUsage())
+            {
+                Thread.Sleep(50);
+                using (var usage2 = tracker.BeginUsage())
+                {
+                    Thread.Sleep(100);
+                    // Should not release during overlapping usage
+                    Assert.True(tracker.LicenseHeld);
+                }
+            }
+
+            Thread.Sleep(200); // Wait longer than lock time after all usage ends
+
+            // Assert
+            Assert.True(licenseState == TestLicenseState.Released);
+            tracker.Dispose();
+        }
+    }
+}

Cognite.Simulator.Tests/UtilsTests/ProcessUtilsTest.cs

@@ -0,0 +1,128 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using System;
+using System.Diagnostics;
+using System.Management;
+using System.Runtime.InteropServices;
+using System.Security.Principal;
+using Xunit;
+using Cognite.Simulator.Utils;
+
+namespace Cognite.Simulator.Tests.UtilsTests
+{
+    public class ProcessUtilsTests
+    {
+        [Fact]
+        public void GetProcessOwnerWmi_ThrowsOnNonWindows()
+        {
+            // We can't easily mock this static method, so we'll only run this test on non-Windows platforms
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => ProcessUtils.GetProcessOwnerWmi(1));
+            }
+        }
+
+        [Fact]
+        public void GetCurrentUsername_ThrowsOnNonWindows()
+        {
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => ProcessUtils.GetCurrentUsername());
+            }
+        }
+
+        [Fact]
+        public void KillProcess_KillsOwnedProcessesOnly()
+        {
+            // Only run on Windows for simplicity
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return;
+            }
+
+            // Arrange
+            var mockLogger = new Mock<ILogger>();
+            var processName = "notepad";
+
+            // Create test process to ensure at least one exists
+            Process testProcess = null;
+            try
+            {
+                testProcess = Process.Start("notepad.exe");
+
+                // Act
+                ProcessUtils.KillProcess(processName, mockLogger.Object);
+
+                // Assert
+                // Verify log messages were called with correct parameters
+                TestUtilities.VerifyLog(mockLogger, LogLevel.Debug, "Searching for process : {processName}", Times.Once(), isContainsCheck: true);
+
+                // Verify that process.Kill was called if this process belongs to current user
+                string currentUser = ProcessUtils.GetCurrentUsername().ToLower();
+                TestUtilities.VerifyLog(mockLogger, LogLevel.Information, "Killing process with PID", Times.Once(), isContainsCheck: true);
+
+                // Verify that our testProcess was killed (it should belong to current user)
+                Assert.Throws<InvalidOperationException>(() => testProcess.Refresh());
+            }
+            finally
+            {
+                // Cleanup - make sure process is closed
+                testProcess?.Close();
+            }
+        }
+
+        [Fact]
+        public void KillProcess_HandlesExceptions()
+        {
+            // Arrange
+            var mockLogger = new Mock<ILogger>();
+
+            // Act - pass a non-existent process name
+            ProcessUtils.KillProcess("ThisProcessDoesNotExist_12345", mockLogger.Object);
+
+            // Assert - verify error wasn't logged since no exception should occur
+            // when process not found (empty enumeration handled gracefully)
+            TestUtilities.VerifyLog(mockLogger, LogLevel.Information, "Failed to kill process", Times.Once(), isContainsCheck: true);
+        }
+
+        [Fact]
+        public void GetProcessOwnerWmi_ReturnsOwnerString()
+        {
+            // Skip test on non-Windows platforms
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return;
+            }
+
+            // Arrange - get current process ID
+            int processId = Process.GetCurrentProcess().Id;
+
+            // Act
+            string owner = ProcessUtils.GetProcessOwnerWmi(processId);
+
+            // Assert
+            Assert.NotEqual("No Owner Found", owner);
+            Assert.NotEqual("Access Denied or Process Exited", owner);
+            Assert.Contains("\\", owner); // Owner format should be "domain\user"
+        }
+
+        [Fact]
+        public void GetProcessOwnerWmi_ReturnsNoOwnerFound_WhenProcessDoesNotExist()
+        {
+            // Skip test on non-Windows platforms
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return;
+            }
+
+            // Arrange - unlikely that process ID 999999 exists
+            int nonExistentProcessId = 999999;
+
+            // Act
+            string owner = ProcessUtils.GetProcessOwnerWmi(nonExistentProcessId);
+
+            // Assert
+            Assert.Equal("No Owner Found", owner);
+        }
+    }
+}

Cognite.Simulator.Utils/Cognite.Simulator.Utils.csproj

@@ -25,6 +25,7 @@
     <PackageReference Include="Cognite.ExtractorUtils" Version="1.29.0" />
     <!-- <ProjectReference Include="..\..\dotnet-extractor-utils\ExtractorUtils\ExtractorUtils.csproj" /> -->
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="System.Management" Version="9.0.2" />
   </ItemGroup>
 
   <ItemGroup>

Cognite.Simulator.Utils/Configuration.cs

@@ -5,6 +5,7 @@
 using Cognite.Extractor.StateStorage;
 using Cognite.Extractor.Utils;
 using Cognite.Simulator.Utils.Automation;
+using Cognite.Extractor.Common;
 
 namespace Cognite.Simulator.Utils
 {
@@ -75,6 +76,7 @@
             }
 
             if (Cognite.CdfRetries == null) {
+                Cognite.CdfRetries = new RetryConfig();
                 Cognite.CdfRetries.MaxRetries = 11;
                 Cognite.CdfRetries.MaxDelay = 60 * 1000; //ms
             }
@@ -266,9 +268,9 @@
         public bool Enabled { get; set; }
     }
 
     public class DefaultConnectorConfig : ConnectorConfig
     {
         public ModelLibraryConfig ModelLibrary { get; set; }
         public RoutineLibraryConfig RoutineLibrary { get; set; }
     }
 

Cognite.Simulator.Utils/DefaultClasses/DefaultConnectorRuntime.cs

@@ -70,6 +70,7 @@ public static async Task RunStandalone()
                 catch (Exception e)
                 {
                     logger.LogError(e, "Unhandled exception: {message}", e.Message);
+                    throw;
                 }
             }
         }