Merge pull request #66 from PTCInc/feat(api)-cache-ProductInfo

rlabbeptc · web-flow · commit a2a67defa7ab · 2026-03-07T16:09:59.000-05:00
Feat(api) cache product info
diff --git a/Kepware.Api.Test/ApiClient/GetProductInfo.cs b/Kepware.Api.Test/ApiClient/GetProductInfo.cs
@@ -32,6 +32,16 @@ public async Task GetProductInfoAsync_ShouldReturnProductInfo_WhenApiRespondsSuc
             Assert.Equal(240, result.ProductVersionBuild);
             Assert.Equal(0, result.ProductVersionPatch);
 
+            // Also verify that the ProductInfo property on the client is populated correctly
+            Assert.NotNull(_kepwareApiClient.ProductInfo);
+            Assert.Equal("012", _kepwareApiClient.ProductInfo.ProductId);
+            Assert.Equal("KEPServerEX", _kepwareApiClient.ProductInfo.ProductName);
+            Assert.Equal("V6.17.240.0", _kepwareApiClient.ProductInfo.ProductVersion);
+            Assert.Equal(6, _kepwareApiClient.ProductInfo.ProductVersionMajor);
+            Assert.Equal(17, _kepwareApiClient.ProductInfo.ProductVersionMinor);
+            Assert.Equal(240, _kepwareApiClient.ProductInfo.ProductVersionBuild);
+            Assert.Equal(0, _kepwareApiClient.ProductInfo.ProductVersionPatch);
+
         }
 
         #region GetProductInfoAsync - SupportsJsonProjectLoadService
@@ -57,6 +67,10 @@ public async Task GetProductInfoAsync_ShouldReturnCorrect_SupportsJsonProjectLoa
             // Assert
             Assert.NotNull(result);
             Assert.Equal(expectedResult, result.SupportsJsonProjectLoadService);
+
+            // Also verify that the ProductInfo property on the client is populated correctly
+            Assert.NotNull(_kepwareApiClient.ProductInfo);
+            Assert.Equal(expectedResult, _kepwareApiClient.ProductInfo.SupportsJsonProjectLoadService);
         }
 
         #endregion
@@ -99,6 +113,9 @@ public async Task GetProductInfoAsync_ShouldReturnNull_WhenApiReturnsError()
 
             // Assert
             Assert.Null(result);
+
+            // ProductInfo property should also be null on error
+            Assert.Null(_kepwareApiClient.ProductInfo); 
         }
 
         [Fact]
@@ -114,6 +131,9 @@ public async Task GetProductInfoAsync_ShouldReturnNull_WhenApiReturnsInvalidJson
 
             // Assert
             Assert.Null(result);
+
+            // ProductInfo property should also be null on error
+            Assert.Null(_kepwareApiClient.ProductInfo);
         }
 
         [Fact]
@@ -128,6 +148,9 @@ public async Task GetProductInfoAsync_ShouldReturnNull_OnHttpRequestException()
 
             // Assert
             Assert.Null(result);
+
+            // ProductInfo property should also be null on error
+            Assert.Null(_kepwareApiClient.ProductInfo);
         }
         #endregion
     }
diff --git a/Kepware.Api.TestIntg/ApiClient/GetProductInfo.cs b/Kepware.Api.TestIntg/ApiClient/GetProductInfo.cs
@@ -30,6 +30,15 @@ public async Task GetProductInfoAsync_ShouldReturnProductInfo_WhenApiRespondsSuc
             Assert.Equal(_productInfo.ProductVersionBuild, result.ProductVersionBuild);
             Assert.Equal(_productInfo.ProductVersionPatch, result.ProductVersionPatch);
 
+            // Also verify that the ProductInfo property on the client is updated
+            Assert.NotNull(_kepwareApiClient.ProductInfo);
+            Assert.Equal(_productInfo.ProductId, _kepwareApiClient.ProductInfo.ProductId);
+            Assert.Equal(_productInfo.ProductName, _kepwareApiClient.ProductInfo.ProductName);
+            Assert.Equal(_productInfo.ProductVersion, _kepwareApiClient.ProductInfo.ProductVersion);
+            Assert.Equal(_productInfo.ProductVersionMajor, _kepwareApiClient.ProductInfo.ProductVersionMajor);
+            Assert.Equal(_productInfo.ProductVersionMinor, _kepwareApiClient.ProductInfo.ProductVersionMinor);
+            Assert.Equal(_productInfo.ProductVersionBuild, _kepwareApiClient.ProductInfo.ProductVersionBuild);
+            Assert.Equal(_productInfo.ProductVersionPatch, _kepwareApiClient.ProductInfo.ProductVersionPatch);
         }
 
     }
diff --git a/Kepware.Api.TestIntg/appsettings.json b/Kepware.Api.TestIntg/appsettings.json
@@ -3,9 +3,9 @@
     "IntegrationTest": true,
     "TestServer": {
       "Host": "https://localhost",
-      "Port": 57513,
+      "Port": 57512,
       "UserName": "Administrator",
-      "Password": "Kepware400400400"
+      "Password": ""
     }
   }
 }
diff --git a/Kepware.Api/ClientHandler/GenericApiHandler.cs b/Kepware.Api/ClientHandler/GenericApiHandler.cs
@@ -788,7 +788,7 @@ public async Task<bool> DeleteItemsAsync<T, K>(List<K> items, NamedEntity? owner
         }
         #endregion
 
-        #region private methods
+        #region private / internal methods
 
         #region deserialize
         protected Task<K?> DeserializeJsonAsync<K>(HttpResponseMessage httpResponse, CancellationToken cancellationToken = default)
@@ -825,6 +825,20 @@ public async Task<bool> DeleteItemsAsync<T, K>(List<K> items, NamedEntity? owner
         }
         #endregion
 
+        /// <summary>
+        /// Clears any internal caches (supported drivers, supported channels/devices).
+        /// Called when the underlying connection is lost so subsequent calls re-fetch data.
+        /// </summary>
+        internal void InvalidateCaches()
+        {
+            // drop cached drivers so next call re-loads from /doc endpoint
+            m_cachedSupportedDrivers = null;
+
+            // clear cached channel/device property dictionaries
+            m_cachedSupportedChannels.Clear();
+            m_cachedSupportedDevices.Clear();
+        }
+
         #endregion
 
     }
diff --git a/Kepware.Api/ClientHandler/ProjectApiHandler.cs b/Kepware.Api/ClientHandler/ProjectApiHandler.cs
@@ -230,6 +230,23 @@ public async Task<Project> LoadProject(bool blnLoadFullProject = false, Cancella
         {
             Stopwatch stopwatch = Stopwatch.StartNew();
 
+            var project = await m_kepwareApiClient.GenericConfig.LoadEntityAsync<Project>(cancellationToken: cancellationToken).ConfigureAwait(false);
+
+            if (project == null)
+            {
+                m_logger.LogWarning("Failed to load project");
+                project = new Project();
+            }
+
+            // If not loading full project, return with just project properties.
+            if (!blnLoadFullProject)
+            {
+                m_logger.LogInformation("Loaded project properties in {ElapsedMilliseconds} ms", stopwatch.ElapsedMilliseconds);
+                return project;
+
+            }
+
+
             var productInfo = await m_kepwareApiClient.GetProductInfoAsync(cancellationToken).ConfigureAwait(false);
 
             if (blnLoadFullProject && productInfo?.SupportsJsonProjectLoadService == true)
@@ -280,7 +297,7 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
             }
             else
             {
-                var project = await m_kepwareApiClient.GenericConfig.LoadEntityAsync<Project>(cancellationToken: cancellationToken).ConfigureAwait(false);
+                project = await m_kepwareApiClient.GenericConfig.LoadEntityAsync<Project>(cancellationToken: cancellationToken).ConfigureAwait(false);
 
                 if (project == null)
                 {
diff --git a/Kepware.Api/KepwareApiClient.cs b/Kepware.Api/KepwareApiClient.cs
@@ -30,6 +30,7 @@ public partial class KepwareApiClient : IKepwareDefaultValueProvider
         /// The value for an unknown client or hostname.
         /// </summary>
         public const string UNKNOWN = "Unknown";
+
         private const string ENDPOINT_STATUS = "/config/v1/status";
         private const string ENDPOINT_DOC = "/config/v1/doc";
         private const string ENDPOINT_ABOUT = "/config/v1/about";
@@ -40,6 +41,7 @@ public partial class KepwareApiClient : IKepwareDefaultValueProvider
 
         private bool? m_isConnected = null;
         private bool? m_hasValidCredentials = null;
+        private ProductInfo? m_productInfo = null;
 
         /// <summary>
         /// Gets the name of the client instance.
@@ -51,6 +53,14 @@ public partial class KepwareApiClient : IKepwareDefaultValueProvider
         /// </summary>
         public string ClientHostName => m_httpClient.BaseAddress?.Host ?? UNKNOWN;
 
+        /// <summary>
+        /// Gets the product information of the connected Kepware server, which includes 
+        /// product name and version information. This caches the value during <see cref="KepwareApiClient.TestConnectionAsync(CancellationToken)"/>
+        /// and <see cref="KepwareApiClient.GetProductInfoAsync(CancellationToken)"/> and cached for future use. 
+        /// It will return null if there is no cached value.
+        /// </summary>
+        public ProductInfo? ProductInfo => m_productInfo;
+
         /// <summary>
         /// Gets the client options for the Kepware server connection.
         /// </summary>
@@ -141,7 +151,7 @@ public async Task<bool> TestConnectionAsync(CancellationToken cancellationToken
                 if (!response.IsSuccessStatusCode)
                 {
                     m_logger.LogWarning("Failed to connect to {ClientName}-client at {BaseAddress}, Reason: {ReasonPhrase}", ClientName, m_httpClient.BaseAddress, response.ReasonPhrase);
-                    m_isConnected = null; // set connection state to null if we cannot connect
+                    ClearConnectionState(); // set connection state to null if we cannot connect
                     return false; // connection failed
                 }
 
@@ -155,7 +165,7 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
                 if (status?.FirstOrDefault()?.Healthy == false)
                 {
                     m_logger.LogWarning("Failed to connect to {ClientName}-client at {BaseAddress}, Reason: {String}", ClientName, m_httpClient.BaseAddress, "Server Status Check Failed");
-                    m_isConnected = null; // set connection state to null if we cannot connect
+                    ClearConnectionState(); // set connection state to null if we cannot connect
                     return false; // connection failed
                 }
 
@@ -167,12 +177,12 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
 
                 // Inital connection attempt or a reconnection due to failure,
                 // we need to check the product info and credentials
-                var prodInfo = await GetProductInfoAsync(cancellationToken).ConfigureAwait(false);
+                _ = await GetProductInfoAsync(cancellationToken).ConfigureAwait(false);
 
                 // If we cannot get the product info, we assume the connection is not healthy
-                if (prodInfo == null) 
+                if (m_productInfo == null) 
                 {
-                    m_isConnected = null; // set connection state to null if we cannot get product info
+                    ClearConnectionState(); // set connection state to null if we cannot get product info
                     return false;
                 }
 
@@ -182,12 +192,12 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
                 // If we do not have valid credentials, we assume the connection is not healthy
                 if (m_hasValidCredentials != true)
                 {
-                    m_isConnected = null; // set connection state to null if we cannot connect or credentials are invalid
+                    ClearConnectionState(); // set connection state to null if we cannot connect or credentials are invalid
                     m_logger.LogWarning("Connection to {ClientName}-client at {BaseAddress} failed because credentials are invalid", ClientName, m_httpClient.BaseAddress);
                     return false;
                 }
 
-                m_logger.LogInformation("Successfully connected to {ClientName}-client: {ProductName} {ProductVersion} on {BaseAddress}", ClientName, prodInfo?.ProductName, prodInfo?.ProductVersion, m_httpClient.BaseAddress);
+                m_logger.LogInformation("Successfully connected to {ClientName}-client: {ProductName} {ProductVersion} on {BaseAddress}", ClientName, m_productInfo?.ProductName, m_productInfo?.ProductVersion, m_httpClient.BaseAddress);
 
                 m_isConnected = true; // set connection state to true if we have a valid product info and credentials
                 return m_isConnected.Value; // return true if we have a valid connection
@@ -205,21 +215,29 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
 
         /// <summary>
         /// Gets the product information from the Kepware server which includes product name and version information.
+        /// Will update the client's product info property, which can be used in other calls to avoid calling the API multiple times for the same information.
         /// Uses the /config/v1/about endpoint
         /// </summary>
         /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>A task that represents the asynchronous operation. The task result contains the product information.</returns>
+        /// <returns>A task that represents the asynchronous operation. The task result contains the product information. <see cref="Kepware.Api.Model.ProductInfo"/></returns>
         public async Task<ProductInfo?> GetProductInfoAsync(CancellationToken cancellationToken = default)
         {
+            if (m_productInfo != null)
+            {
+                // return cached product info if we have it
+                return m_productInfo; 
+            }
+
             try
             {
                 var response = await m_httpClient.GetAsync(ENDPOINT_ABOUT, cancellationToken).ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
                     var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    var prodInfo = JsonSerializer.Deserialize(content, KepJsonContext.Default.ProductInfo);
-
-                    return prodInfo;
+                    
+                    // Set Product Info for the client if we have a valid response, so we can use it in other calls without needing to call the API again
+                    m_productInfo = JsonSerializer.Deserialize(content, KepJsonContext.Default.ProductInfo);
+                    return m_productInfo;
                 }
                 else
                 {
@@ -235,6 +253,8 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
                 m_logger.LogWarning(jsonEx, "Failed to parse ProductInfo from {BaseAddress}", m_httpClient.BaseAddress);
             }
 
+            // If we cannot get the product info, we set it to null and return null
+            m_productInfo = null;
             return null;
         }
 
@@ -293,14 +313,41 @@ async Task<ReadOnlyDictionary<string, JsonElement>> IKepwareDefaultValueProvider
         }
         #endregion
 
-        #region internal
+        #region Private / internal helper methods
+        /// <summary>
+        /// Clears all client-level connection state and optionally handler caches.
+        /// Call this whenever the connection should be considered lost or stale.
+        /// </summary>
+        /// <param name="clearCredentials">If true also clears cached credential validation state.</param>
+        private void ClearConnectionState(bool clearCredentials = true)
+        {
+            // Clear derived product info and connection flags
+            m_productInfo = null;
+            m_isConnected = null;
+
+            // Optionally clear credential status so next TestConnection re-evaluates
+            if (clearCredentials)
+                m_hasValidCredentials = null;
+
+            // Invalidate caches on handlers that keep them
+            try
+            {
+                // GenericConfig may implement an InvalidateCaches method (see suggestion below)
+                (GenericConfig as ClientHandler.GenericApiHandler)?.InvalidateCaches();
+            }
+            catch
+            {
+                // swallow - defensive: don't throw from a state-clear helper
+            }
+        }
+
         /// <summary>
         /// Invoked by Handler, when they receice a http request exception
         /// </summary>
         /// <param name="httpEx"></param>
         internal void OnHttpRequestException(HttpRequestException httpEx)
         {
-            m_isConnected = null;
+            ClearConnectionState(false);
         }
         #endregion
     }

Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,15 @@ public async Task GetProductInfoAsync_ShouldReturnProductInfo_WhenApiRespondsSuc`
`30`	`30`	`Assert.Equal(_productInfo.ProductVersionBuild, result.ProductVersionBuild);`
`31`	`31`	`Assert.Equal(_productInfo.ProductVersionPatch, result.ProductVersionPatch);`
`32`	`32`
	`33`	`+ // Also verify that the ProductInfo property on the client is updated`
	`34`	`+ Assert.NotNull(_kepwareApiClient.ProductInfo);`
	`35`	`+ Assert.Equal(_productInfo.ProductId, _kepwareApiClient.ProductInfo.ProductId);`
	`36`	`+ Assert.Equal(_productInfo.ProductName, _kepwareApiClient.ProductInfo.ProductName);`
	`37`	`+ Assert.Equal(_productInfo.ProductVersion, _kepwareApiClient.ProductInfo.ProductVersion);`
	`38`	`+ Assert.Equal(_productInfo.ProductVersionMajor, _kepwareApiClient.ProductInfo.ProductVersionMajor);`
	`39`	`+ Assert.Equal(_productInfo.ProductVersionMinor, _kepwareApiClient.ProductInfo.ProductVersionMinor);`
	`40`	`+ Assert.Equal(_productInfo.ProductVersionBuild, _kepwareApiClient.ProductInfo.ProductVersionBuild);`
	`41`	`+ Assert.Equal(_productInfo.ProductVersionPatch, _kepwareApiClient.ProductInfo.ProductVersionPatch);`
`33`	`42`	`}`
`34`	`43`
`35`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,9 +3,9 @@`
`3`	`3`	`"IntegrationTest": true,`
`4`	`4`	`"TestServer": {`
`5`	`5`	`"Host": "https://localhost",`
`6`		`- "Port": 57513,`
	`6`	`+ "Port": 57512,`
`7`	`7`	`"UserName": "Administrator",`
`8`		`- "Password": "Kepware400400400"`
	`8`	`+ "Password": ""`
`9`	`9`	`}`
`10`	`10`	`}`
`11`	`11`	`}`