(#16) Add command timeout

Author: colinangusmackay

src/Stravaig.Configuration.SqlServer.Tests/FakeDataLoader.cs

@@ -23,8 +23,8 @@ public IDictionary<string, string> RetrieveData(SqlServerConfigurationSource sou
 
 public class FakeSqlServerConfigurationWatcher : ISqlServerConfigurationWatcher
 {
-    ILogger _logger = NullLogger.Instance;
-    private SqlServerConfigurationProvider _provider;
+    ILogger? _logger = NullLogger.Instance;
+    private SqlServerConfigurationProvider? _provider;
 
     public void EnsureStarted()
     {
@@ -35,10 +35,8 @@ public void AttachLogger(ILogger logger)
         _logger = logger;
     }
 
-    public void AttacheProvider(SqlServerConfigurationProvider provider)
+    public void AttachProvider(SqlServerConfigurationProvider provider)
     {
         _provider = provider;
     }
-    
-    
 }

src/Stravaig.Configuration.SqlServer.Tests/SqlServerConfigurationProviderTests.cs

@@ -103,7 +103,7 @@ public void ReplayLogExceptionOnLoadFailure()
         thirdLog.PropertyDictionary["exceptionMessage"].ShouldBe("Dummy Exception.");
         logs[3].OriginalMessage.ShouldBe("End of replay.");
     }
-    
+
     private SqlServerConfigurationProvider SetupProvider()
     {
         _fakeLoader = new FakeDataLoader()

src/Stravaig.Configuration.SqlServer.Tests/SqlServerConfigurationSourceExtensionTests.cs

@@ -0,0 +1,53 @@
+using System;
+using Microsoft.Extensions.Logging.Abstractions;
+using NUnit.Framework;
+using Shouldly;
+using Stravaig.Configuration.SqlServer.Glue;
+using Stravaig.Extensions.Logging.Diagnostics;
+using Stravaig.Extensions.Logging.Diagnostics.Render;
+
+namespace Stravaig.Configuration.SqlServer.Tests;
+
+[TestFixture]
+public class SqlServerConfigurationSourceExtensionTests
+{
+    private const string DummyConnectionString = "Server=localhost;Database=testing;Connection Timeout=5";
+
+    [Test]
+    public void CreateLoggerWhenNotExpectingALoggerIsNullLogger()
+    {
+        var source = new SqlServerConfigurationSource(DummyConnectionString, expectLogger: false);
+
+        source.CreateLogger().ShouldBe(NullLogger<SqlServerConfigurationProvider>.Instance);
+    }
+    
+    [Test]
+    public void CreateLoggerWhenExpectingALoggerIsReplayLogger()
+    {
+        var source = new SqlServerConfigurationSource(DummyConnectionString, expectLogger: true);
+
+        source.CreateLogger().ShouldBeOfType<ReplayLogger<SqlServerConfigurationProvider>>();
+    }
+    
+    [Test]
+    public void CreateLoggerIndicatesHowTheProviderIsSetup()
+    {
+        var source = new SqlServerConfigurationSource(DummyConnectionString, expectLogger: true, refreshInterval: TimeSpan.FromSeconds(120), commandTimeout: TimeSpan.FromSeconds(10));
+        var replayLogger = (ReplayLogger<SqlServerConfigurationProvider>)source.CreateLogger();
+        var captureLogger = new TestCaptureLogger<SqlServerConfigurationProvider>();
+        replayLogger.Replay(captureLogger);
+
+        var logs = captureLogger.GetLogs();
+        logs.RenderLogs(Formatter.SimpleBySequence, Sink.Console);
+        
+        logs[1].OriginalMessage.ShouldBe("SQL Server Configuration Provider will retrieve from [{serverName}].[{databaseName}].[{schemaName}].[{tableName}] {frequency}. Will wait {connectionTimeout} seconds to connect, and {commandTimeout} seconds to retrieve data.");
+        logs[1].PropertyDictionary["serverName"].ShouldBe("localhost");
+        logs[1].PropertyDictionary["databaseName"].ShouldBe("testing");
+        logs[1].PropertyDictionary["schemaName"].ShouldBe("Stravaig");
+        logs[1].PropertyDictionary["tableName"].ShouldBe("AppConfiguration");
+        logs[1].PropertyDictionary["frequency"].ShouldBe("every 120 seconds");
+        logs[1].PropertyDictionary["connectionTimeout"].ShouldBe(5);
+        logs[1].PropertyDictionary["commandTimeout"].ShouldBe(10);
+    }
+
+}

src/Stravaig.Configuration.SqlServer/Glue/DataLoader.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Data.SqlClient;
 
 namespace Stravaig.Configuration.SqlServer.Glue;
@@ -15,6 +16,7 @@ public IDictionary<string, string> RetrieveData(SqlServerConfigurationSource sou
         using SqlConnection connection = new SqlConnection(source.ConnectionString);
         connection.Open();
         var cmd = new SqlCommand(sql, connection);
+        cmd.CommandTimeout = (int)source.CommandTimeout.TotalSeconds;
         using var reader = cmd.ExecuteReader();
         return MaterialiseData(reader);
     }

src/Stravaig.Configuration.SqlServer/Glue/DefaultValues.cs

@@ -3,6 +3,8 @@ namespace Stravaig.Configuration.SqlServer.Glue;
 internal static class DefaultValues
 {
     public const int NoRefresh = 0;
+    public const int CommandTimeout = 15;
+    public const int ConnectionTimeOut = 15;
     public const string SchemaName = "Stravaig";
     public const string TableName = "AppConfiguration";
     public const string ConfigurationSection = "Stravaig:AppConfiguration";

src/Stravaig.Configuration.SqlServer/Glue/Log.cs

@@ -58,4 +58,16 @@ public static partial class Log
         Level = LogLevel.Warning,
         Message = "The replay limit was reached. There are {excessCount} logs that cannot be replayed.")]
     public static partial void ReplayLimitExceeded(this ILogger logger, int excessCount);
+
+    [LoggerMessage(
+        EventId = 10,
+        Level = LogLevel.Information,
+        Message = "SQL Server Configuration Provider will retrieve from [{serverName}].[{databaseName}].[{schemaName}].[{tableName}] {frequency}. Will wait {connectionTimeout} seconds to connect, and {commandTimeout} seconds to retrieve data.")]
+    public static partial void InitialProviderDescription(this ILogger logger, string serverName, string databaseName, string schemaName, string tableName, string frequency, int connectionTimeout, int commandTimeout);
+    
+    [LoggerMessage(
+        EventId = 11,
+        Level = LogLevel.Warning,
+        Message = "The refresh interval, {refreshInterval} seconds, should be greater than combined connection, {connectionTimeout} seconds, and command, {commandTimeout} seconds, timeouts. A new refresh cycle may start before the previous cycle is complete.")]
+    public static partial void WarnOfCycleInterleave(this ILogger logger, int refreshInterval, int connectionTimeout, int commandTimeout);
 }

src/Stravaig.Configuration.SqlServer/Glue/SourceBuilder.cs

@@ -21,11 +21,12 @@ public static SqlServerConfigurationSource BuildSource(IConfigurationBuilder bui
             ApplyFromConnectionStringsSection(options, configRoot.Value);
 
         return new SqlServerConfigurationSource(
-            options.ConnectionString ?? throw new SqlServerConfigurationProviderException("Cannot build a SQL Server Configuration Provider without a connection string."),
-            options.IsLoggerExpected,
-            TimeSpan.FromSeconds(options.RefreshSeconds),
-            options.SchemaName ?? throw new SqlServerConfigurationProviderException("The schema name is required to use SQL Server Configuration."),
-            options.TableName ?? throw new SqlServerConfigurationProviderException("The table name is required to use SQL Server Configuration."));
+            connectionString: options.ConnectionString ?? throw new SqlServerConfigurationProviderException("Cannot build a SQL Server Configuration Provider without a connection string."),
+            expectLogger: options.IsLoggerExpected,
+            commandTimeout: TimeSpan.FromSeconds(options.CommandTimeout),
+            refreshInterval: TimeSpan.FromSeconds(options.RefreshSeconds),
+            schemaName: options.SchemaName ?? throw new SqlServerConfigurationProviderException("The schema name is required to use SQL Server Configuration."),
+            tableName: options.TableName ?? throw new SqlServerConfigurationProviderException("The table name is required to use SQL Server Configuration."));
     }
 
     private static void ApplyFromConnectionStringsSection(SqlServerConfigurationOptions options, IConfigurationRoot configRoot)

src/Stravaig.Configuration.SqlServer/Glue/SqlServerConfigurationSourceExtensions.cs

@@ -0,0 +1,32 @@
+using System;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Stravaig.Configuration.SqlServer.Glue;
+
+internal static class SqlServerConfigurationSourceExtensions
+{
+    public static ILogger<SqlServerConfigurationProvider> CreateLogger(this SqlServerConfigurationSource source)
+    {
+        if (!source.ExpectLogger) 
+            return NullLogger<SqlServerConfigurationProvider>.Instance;
+
+        var logger = new ReplayLogger<SqlServerConfigurationProvider>();
+        logger.InitialProviderDescription(
+            source.ServerName,
+            source.DatabaseName,
+            source.SchemaName,
+            source.TableName,
+            frequency: source.RefreshInterval == TimeSpan.Zero ? "once only" : $"every {source.RefreshInterval.TotalSeconds} seconds",
+            (int)source.ConnectionTimeout.TotalSeconds,
+            (int)source.CommandTimeout.TotalSeconds);
+        
+        if (source.ConnectionTimeout + source.CommandTimeout > source.RefreshInterval)
+            logger.WarnOfCycleInterleave(
+                (int)source.RefreshInterval.TotalSeconds,
+                (int)source.ConnectionTimeout.TotalSeconds,
+                (int)source.CommandTimeout.TotalSeconds);
+        return logger;
+
+    }
+}

src/Stravaig.Configuration.SqlServer/SqlServerConfigurationOptions.cs

@@ -15,6 +15,8 @@ public class SqlServerConfigurationOptions
     public string TableName { get; set; } = DefaultValues.TableName;
 
     public int RefreshSeconds { get; set; } = DefaultValues.NoRefresh;
+
+    public int CommandTimeout { get; set; } = DefaultValues.CommandTimeout;
 
     public SqlServerConfigurationOptions FromExistingConfiguration(string configurationSection = DefaultValues.ConfigurationSection)
     {

src/Stravaig.Configuration.SqlServer/SqlServerConfigurationProvider.cs

@@ -16,7 +16,7 @@ public class SqlServerConfigurationProvider : ConfigurationProvider
     private readonly ISqlServerConfigurationWatcher _watcher;
 
     public SqlServerConfigurationProvider(SqlServerConfigurationSource source)
-        : this (source, new DataLoader(), NullSqlServerConfigurationWatcher.Instance, CreateLogger(source))
+        : this (source, new DataLoader(), NullSqlServerConfigurationWatcher.Instance, source.CreateLogger())
     {
         _watcher = CreateWatcher(source, this);
     }
@@ -34,14 +34,7 @@ internal SqlServerConfigurationProvider(
         _watcher = watcher;
         _watcher.AttachLogger(_logger);
     }
-
-    private static ILogger<SqlServerConfigurationProvider> CreateLogger(SqlServerConfigurationSource source)
-    {
-        return source.ExpectLogger
-            ? new ReplayLogger<SqlServerConfigurationProvider>()
-            : NullLogger<SqlServerConfigurationProvider>.Instance;
-    }
-
+    
     private static ISqlServerConfigurationWatcher CreateWatcher(SqlServerConfigurationSource source, SqlServerConfigurationProvider provider)
     {
         return source.RefreshInterval == TimeSpan.Zero