Load trialstartdate from ravenDB (#4446)

* Load trialstartdate from ravenDB

* Check for trial start date in the future

* Add tests

* Add more tests

* Fix the test

* Rename test namespace

---------

Co-authored-by: SzymonPobiega <[email protected]>

Author: WilliamBZA

src/ServiceControl.LicenseManagement/LicenseDetails.cs

@@ -1,6 +1,7 @@
 namespace ServiceControl.LicenseManagement
 {
     using System;
+    using System.Collections.Generic;
     using Particular.Licensing;
 
     public class LicenseDetails
@@ -25,6 +26,28 @@ public class LicenseDetails
         public bool WarnUserUpgradeProtectionHasExpired { get; private init; }
         public string Status { get; private init; }
 
+        public static LicenseDetails TrialFromEndDate(DateOnly endDate)
+        {
+            return FromLicense(new License
+            {
+                LicenseType = "Trial",
+                ExpirationDate = endDate.ToDateTime(TimeOnly.MinValue),
+                IsExtendedTrial = false,
+                ValidApplications = new List<string> { "All" }
+            });
+        }
+
+        public static LicenseDetails TrialExpired()
+        {
+            return FromLicense(new License
+            {
+                LicenseType = "Trial",
+                ExpirationDate = DateTime.UtcNow.Date.AddDays(-2), //HasLicenseDateExpired uses a grace period of 1 day
+                IsExtendedTrial = false,
+                ValidApplications = new List<string> { "All" }
+            });
+        }
+
         internal static LicenseDetails FromLicense(License license)
         {
             LicenseStatus licenseStatus = license.GetLicenseStatus();

src/ServiceControl.Persistence.RavenDB/LicenseLicenseMetadataProvider.cs

@@ -0,0 +1,25 @@
+namespace ServiceControl.Persistence.RavenDB
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    class LicenseLicenseMetadataProvider(IRavenSessionProvider sessionProvider) : ILicenseLicenseMetadataProvider
+    {
+        public async Task<TrialMetadata> GetLicenseMetadata(CancellationToken cancellationToken)
+        {
+            using (var session = await sessionProvider.OpenSession(cancellationToken: cancellationToken))
+            {
+                return await session.LoadAsync<TrialMetadata>(TrialMetadata.TrialMetadataId, cancellationToken);
+            }
+        }
+
+        public async Task InsertLicenseMetadata(TrialMetadata licenseMetadata, CancellationToken cancellationToken)
+        {
+            using (var session = await sessionProvider.OpenSession(cancellationToken: cancellationToken))
+            {
+                await session.StoreAsync(licenseMetadata, TrialMetadata.TrialMetadataId, cancellationToken);
+                await session.SaveChangesAsync(cancellationToken);
+            }
+        }
+    }
+}

src/ServiceControl.Persistence.RavenDB/RavenPersistence.cs

@@ -65,6 +65,8 @@ public void AddPersistence(IServiceCollection services)
         services.AddSingleton<IRetryDocumentDataStore, RetryDocumentDataStore>();
         services.AddSingleton<IRetryHistoryDataStore, RetryHistoryDataStore>();
         services.AddSingleton<IEndpointSettingsStore, EndpointSettingsStore>();
+
+        services.AddSingleton<ILicenseLicenseMetadataProvider, LicenseLicenseMetadataProvider>();
     }
 
     public void AddInstaller(IServiceCollection services)

src/ServiceControl.Persistence.Tests.RavenDB/LicenseMetadata/LicenseMetadataTests.cs

@@ -0,0 +1,36 @@
+namespace ServiceControl.Persistence.Tests.RavenDB.LicenseMetadata
+{
+    using System;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.Extensions.DependencyInjection;
+    using NUnit.Framework;
+    using ServiceControl.Persistence.RavenDB;
+
+    [TestFixture]
+    class LicenseMetadataTests : RavenPersistenceTestBase
+    {
+        public LicenseMetadataTests() =>
+            RegisterServices = services =>
+            {
+                services.AddSingleton<LicenseLicenseMetadataProvider>();
+            };
+
+        [Test]
+        public async Task LicenseMetadata_can_be_saved()
+        {
+            var licenseMetadataService = ServiceProvider.GetRequiredService<LicenseLicenseMetadataProvider>();
+
+            var metaData = new TrialMetadata
+            {
+                TrialStartDate = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(14))
+            };
+
+            await licenseMetadataService.InsertLicenseMetadata(metaData, CancellationToken.None);
+
+            var result = await licenseMetadataService.GetLicenseMetadata(CancellationToken.None);
+
+            Assert.That(result.TrialStartDate, Is.EqualTo(metaData.TrialStartDate));
+        }
+    }
+}

src/ServiceControl.Persistence/ILicenseLicenseMetadataProvider.cs

@@ -0,0 +1,11 @@
+namespace ServiceControl.Persistence
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    public interface ILicenseLicenseMetadataProvider
+    {
+        Task<TrialMetadata> GetLicenseMetadata(CancellationToken cancellationToken);
+        Task InsertLicenseMetadata(TrialMetadata licenseMetadata, CancellationToken cancellationToken);
+    }
+}

src/ServiceControl.Persistence/TrialMetadata.cs

@@ -0,0 +1,11 @@
+namespace ServiceControl.Persistence
+{
+    using System;
+
+    public class TrialMetadata
+    {
+        public DateOnly TrialStartDate { get; set; }
+
+        public static string TrialMetadataId = "metadata/trialinformation";
+    }
+}

src/ServiceControl.UnitTests/Licensing/ActiveLicenseTests.cs

@@ -0,0 +1,119 @@
+namespace ServiceControl.UnitTests.Licensing
+{
+    using System;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using LicenseManagement;
+    using NUnit.Framework;
+    using Particular.ServiceControl.Licensing;
+    using Persistence;
+
+    [TestFixture]
+    public class ActiveLicenseTests
+    {
+        [Test]
+        public async Task Stores_trial_start_date_if_not_found()
+        {
+            var today = DateTime.UtcNow.Date;
+            var trialLicense = LicenseDetails.TrialFromEndDate(DateOnly.FromDateTime(today.AddDays(6)));
+            var metadataProvider = new FakeMetadataProvider();
+
+            var checkedDetails = await ActiveLicense.EnsureTrialLicenseIsValid(trialLicense, metadataProvider, CancellationToken.None);
+
+            Assert.That(metadataProvider.Metadata, Is.Not.Null);
+            Assert.That(metadataProvider.Metadata.TrialStartDate, Is.Not.EqualTo(DateOnly.FromDateTime(today.AddDays(6))));
+
+            Assert.That(checkedDetails.ExpirationDate, Is.EqualTo(today.AddDays(6)));
+            Assert.That(checkedDetails.HasLicenseExpired(), Is.EqualTo(false));
+        }
+
+        [Test]
+        public async Task Overrides_future_disk_trial_start_date_with_db_value_non_expired()
+        {
+            var today = DateTime.UtcNow.Date;
+            var trialLicense = LicenseDetails.TrialFromEndDate(DateOnly.FromDateTime(today.AddDays(66)));
+            var metadataProvider = new FakeMetadataProvider(new TrialMetadata
+            {
+                TrialStartDate = DateOnly.FromDateTime(today.AddDays(-10))
+            });
+
+            var checkedDetails = await ActiveLicense.EnsureTrialLicenseIsValid(trialLicense, metadataProvider, CancellationToken.None);
+
+            Assert.That(checkedDetails.ExpirationDate, Is.EqualTo(today.AddDays(-10).AddDays(14)));
+            Assert.That(checkedDetails.HasLicenseExpired(), Is.False);
+        }
+
+        [Test]
+        public async Task Overrides_past_disk_trial_start_date_with_db_value_non_expired()
+        {
+            var today = DateTime.UtcNow.Date;
+            var trialLicense = LicenseDetails.TrialFromEndDate(DateOnly.FromDateTime(today.AddDays(-66)));
+            var metadataProvider = new FakeMetadataProvider(new TrialMetadata
+            {
+                TrialStartDate = DateOnly.FromDateTime(today.AddDays(-10))
+            });
+
+            var checkedDetails = await ActiveLicense.EnsureTrialLicenseIsValid(trialLicense, metadataProvider, CancellationToken.None);
+
+            Assert.That(checkedDetails.ExpirationDate, Is.EqualTo(today.AddDays(-10).AddDays(14)));
+            Assert.That(checkedDetails.HasLicenseExpired(), Is.False);
+        }
+
+        [Test]
+        public async Task Overrides_disk_trial_start_date_with_db_value_expired()
+        {
+            var today = DateTime.UtcNow.Date;
+            var trialLicense = LicenseDetails.TrialFromEndDate(DateOnly.FromDateTime(today.AddDays(-7)));
+            var metadataProvider = new FakeMetadataProvider(new TrialMetadata
+            {
+                TrialStartDate = DateOnly.FromDateTime(today.AddDays(-20))
+            });
+
+            var checkedDetails = await ActiveLicense.EnsureTrialLicenseIsValid(trialLicense, metadataProvider, CancellationToken.None);
+
+            Assert.That(checkedDetails.ExpirationDate, Is.EqualTo(today.AddDays(-20).AddDays(14)));
+            Assert.That(checkedDetails.HasLicenseExpired(), Is.True);
+        }
+
+        [Test]
+        public async Task Detects_tempered_trial_date_in_db_and_voids_license()
+        {
+            var today = DateTime.UtcNow.Date;
+            var trialLicense = LicenseDetails.TrialFromEndDate(DateOnly.FromDateTime(today.AddDays(14)));
+            var metadataProvider = new FakeMetadataProvider(new TrialMetadata
+            {
+                TrialStartDate = DateOnly.FromDateTime(today.AddDays(20))
+            });
+
+            var checkedDetails = await ActiveLicense.EnsureTrialLicenseIsValid(trialLicense, metadataProvider, CancellationToken.None);
+
+            Assert.That(checkedDetails.ExpirationDate, Is.LessThan(today));
+            Assert.That(checkedDetails.HasLicenseExpired(), Is.True);
+        }
+
+        class FakeMetadataProvider : ILicenseLicenseMetadataProvider
+        {
+            public FakeMetadataProvider()
+            {
+            }
+
+            public FakeMetadataProvider(TrialMetadata metadata)
+            {
+                Metadata = metadata;
+            }
+
+            public TrialMetadata Metadata { get; set; }
+
+            public Task<TrialMetadata> GetLicenseMetadata(CancellationToken cancellationToken)
+            {
+                return Task.FromResult(Metadata);
+            }
+
+            public Task InsertLicenseMetadata(TrialMetadata licenseMetadata, CancellationToken cancellationToken)
+            {
+                Metadata = licenseMetadata;
+                return Task.CompletedTask;
+            }
+        }
+    }
+}

src/ServiceControl.UnitTests/ServiceControl.UnitTests.csproj

@@ -12,15 +12,15 @@
 
   <ItemGroup>
     <PackageReference Include="GitHubActionsTestLogger" />
-    <PackageReference Include="Microsoft.Extensions.TimeProvider.Testing"/>
+    <PackageReference Include="Microsoft.Extensions.TimeProvider.Testing" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="NServiceBus.Testing" />
     <PackageReference Include="NUnit" />
     <PackageReference Include="NUnit.Analyzers" />
     <PackageReference Include="NUnit3TestAdapter" />
     <PackageReference Include="Particular.Approvals" />
     <PackageReference Include="PublicApiGenerator" />
-    <PackageReference Include="System.Linq.Async"/>
+    <PackageReference Include="System.Linq.Async" />
   </ItemGroup>
 
 </Project>

src/ServiceControl/Licensing/ActiveLicense.cs

@@ -1,6 +1,10 @@
 namespace Particular.ServiceControl.Licensing
 {
+    using System.Threading.Tasks;
+    using System.Threading;
+    using System;
     using global::ServiceControl.LicenseManagement;
+    using global::ServiceControl.Persistence;
     using NServiceBus.Logging;
 
     public class ActiveLicense
@@ -9,7 +13,7 @@ public class ActiveLicense
 
         public bool IsValid { get; set; }
 
-        internal LicenseDetails Details { get; set; }
+        public LicenseDetails Details { get; set; }
 
         public void Refresh()
         {
@@ -22,6 +26,43 @@ public void Refresh()
             Details = detectedLicense.Details;
         }
 
+        public async Task EnsureTrialLicenseIsValid(ILicenseLicenseMetadataProvider licenseLicenseMetadataProvider, CancellationToken cancellationToken)
+        {
+            Details = await EnsureTrialLicenseIsValid(Details, licenseLicenseMetadataProvider, cancellationToken);
+        }
+
+        internal static async Task<LicenseDetails> EnsureTrialLicenseIsValid(LicenseDetails licenseDetails, ILicenseLicenseMetadataProvider licenseLicenseMetadataProvider, CancellationToken cancellationToken)
+        {
+            if (licenseDetails.LicenseType.Equals("trial", StringComparison.OrdinalIgnoreCase))
+            {
+                var metadata = await licenseLicenseMetadataProvider.GetLicenseMetadata(cancellationToken);
+                if (metadata == null)
+                {
+                    //No start date stored in the database, store one.
+                    metadata = new TrialMetadata
+                    {
+                        //The trial period is 14 days
+                        TrialStartDate = DateOnly.FromDateTime(licenseDetails.ExpirationDate.Value.AddDays(14))
+                    };
+
+                    await licenseLicenseMetadataProvider.InsertLicenseMetadata(metadata, cancellationToken);
+                    return licenseDetails;
+                }
+                if (metadata.TrialStartDate >= DateOnly.FromDateTime(DateTime.Now))
+                {
+                    // Someone has tampered with the date stored in RavenDB, set the license to expired
+                    return LicenseDetails.TrialExpired();
+                }
+                if (DateOnly.FromDateTime(licenseDetails.ExpirationDate ?? DateTime.MinValue) != metadata.TrialStartDate.AddDays(14))
+                {
+                    //The trial end date stored by the license component has been tempered with or reset, use the RavenDB value
+                    return LicenseDetails.TrialFromEndDate(metadata.TrialStartDate.AddDays(14));
+                }
+                //Otherwise use the trial date stored by the licensing component
+            }
+            return licenseDetails;
+        }
+
         static readonly ILog Logger = LogManager.GetLogger(typeof(ActiveLicense));
     }
 }

src/ServiceControl/Licensing/LicenseCheckHostedService.cs

@@ -4,19 +4,22 @@
     using System.Threading;
     using System.Threading.Tasks;
     using global::ServiceControl.Infrastructure.BackgroundTasks;
+    using global::ServiceControl.Persistence;
     using Microsoft.Extensions.Hosting;
     using NServiceBus.Logging;
 
-    class LicenseCheckHostedService(ActiveLicense activeLicense, IAsyncTimer scheduler) : IHostedService
+    class LicenseCheckHostedService(ActiveLicense activeLicense, ILicenseLicenseMetadataProvider licenseLicenseMetadataProvider, IAsyncTimer scheduler) : IHostedService
     {
         public Task StartAsync(CancellationToken cancellationToken)
         {
             var due = TimeSpan.FromHours(8);
-            timer = scheduler.Schedule(_ =>
+            timer = scheduler.Schedule(async _ =>
             {
                 activeLicense.Refresh();
-                return ScheduleNextExecutionTask;
-            }, due, due, ex => Logger.Error("Unhandled error while refreshing the license.", ex));
+                await activeLicense.EnsureTrialLicenseIsValid(licenseLicenseMetadataProvider, cancellationToken);
+
+                return TimerJobExecutionResult.ScheduleNextExecution;
+            }, TimeSpan.FromTicks(0), due, ex => Logger.Error("Unhandled error while refreshing the license.", ex));
             return Task.CompletedTask;
         }
 
@@ -25,6 +28,5 @@ public Task StartAsync(CancellationToken cancellationToken)
         TimerJob timer;
 
         static readonly ILog Logger = LogManager.GetLogger<LicenseCheckHostedService>();
-        static readonly Task<TimerJobExecutionResult> ScheduleNextExecutionTask = Task.FromResult(TimerJobExecutionResult.ScheduleNextExecution);
     }
 }