Merge branch 'main' into 23-feat-doc-1_0_0-release-documentation-updates

Author: rlabbeptc

Kepware.Api.Test/ApiClient/ServerUserGroupTests.cs

@@ -14,7 +14,7 @@ namespace Kepware.Api.Test.ApiClient
 {
     public class ServerUserGroupTests : TestApiClientBase
     {
-        private const string ENDPOINT_USER_GROUP = "/config/v1/admin/server_user_groups";
+        private const string ENDPOINT_USER_GROUP = "/config/v1/admin/server_usergroups";
 
         [Fact]
         public async Task GetServerUserGroupAsync_ShouldReturnServerUserGroup_WhenApiRespondsSuccessfully()

Kepware.Api.Test/ApiClient/_TestApiClientBase.cs

@@ -97,6 +97,9 @@ protected void ConfigureConnectedClient(
             var statusResponse = "[{\"Name\": \"ConfigAPI REST Service\", \"Healthy\": true}]";
             _httpMessageHandlerMock.SetupRequest(HttpMethod.Get, $"{TEST_ENDPOINT}/config/v1/status")
                 .ReturnsResponse(HttpStatusCode.OK, statusResponse, "application/json");
+
+            _httpMessageHandlerMock.SetupRequest(HttpMethod.Get, $"{TEST_ENDPOINT}/config/v1/doc")
+                .ReturnsResponse(HttpStatusCode.OK, statusResponse, "application/json");
         }
 
         protected Channel CreateTestChannel(string name = "TestChannel", string driver = "Advanced Simulator")

Kepware.Api/KepwareApiClient.cs

@@ -31,12 +31,14 @@ public partial class KepwareApiClient : IKepwareDefaultValueProvider
         /// </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";
 
         private readonly ILogger<KepwareApiClient> m_logger;
         private readonly HttpClient m_httpClient;
 
-        private bool? m_blnIsConnected = null;
+        private bool? m_isConnected = null;
+        private bool? m_hasValidCredentials = null;
 
         /// <summary>
         /// Gets the name of the client instance.
@@ -126,7 +128,7 @@ public async Task<bool> TestConnectionAsync(CancellationToken cancellationToken
             bool blnIsConnected = false;
             try
             {
-                if (m_blnIsConnected == null) // first time after connection change
+                if (m_isConnected == null) // first time after connection change
                 {
                     m_logger.LogInformation("Connecting to {ClientName}-client at {BaseAddress}...", ClientName, m_httpClient.BaseAddress);
                 }
@@ -144,7 +146,7 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
                     }
                 }
 
-                if (m_blnIsConnected == null || (m_blnIsConnected != null && m_blnIsConnected != blnIsConnected)) // first time after connection change or when connection is lost
+                if (m_isConnected == null || (m_isConnected != null && m_isConnected != blnIsConnected)) // first time after connection change or when connection is lost
                 {
                     if (!blnIsConnected)
                     {
@@ -154,16 +156,18 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
                     {
                         var prodInfo = await GetProductInfoAsync(cancellationToken).ConfigureAwait(false);
                         m_logger.LogInformation("Successfully connected to {ClientName}-client: {ProductName} {ProductVersion} on {BaseAddress}", ClientName, prodInfo?.ProductName, prodInfo?.ProductVersion, m_httpClient.BaseAddress);
+
+                        m_hasValidCredentials = await TestCredentialsAsync(cancellationToken).ConfigureAwait(false);
                     }
                 }
             }
             catch (HttpRequestException httpEx)
             {
-                if (m_blnIsConnected == null || m_blnIsConnected == true) // first time after connection change or when connection is lost
+                if (m_isConnected == null || m_isConnected == true) // first time after connection change or when connection is lost
                     m_logger.LogWarning(httpEx, "Failed to connect to {ClientName}-client at {BaseAddress}", ClientName, m_httpClient.BaseAddress);
             }
-            m_blnIsConnected = blnIsConnected;
-            return blnIsConnected;
+            m_isConnected = blnIsConnected;
+            return blnIsConnected && m_hasValidCredentials == true;
         }
 
         /// <summary>
@@ -182,7 +186,7 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
                     var content = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
                     var prodInfo = JsonSerializer.Deserialize(content, KepJsonContext.Default.ProductInfo);
 
-                    m_blnIsConnected = true;
+                    m_isConnected = true;
                     return prodInfo;
                 }
                 else
@@ -192,8 +196,8 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
             }
             catch (HttpRequestException httpEx)
             {
-                m_logger.LogWarning(httpEx, "Failed to connect to {BaseAddress}", m_httpClient.BaseAddress);
-                m_blnIsConnected = null;
+                m_logger.LogWarning(httpEx, "Failed to connect to {ClientName}-client at {BaseAddress}: {Message}", ClientName, m_httpClient.BaseAddress, httpEx.Message);
+                m_isConnected = null;
             }
             catch (JsonException jsonEx)
             {
@@ -202,6 +206,32 @@ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false
 
             return null;
         }
+
+        private async Task<bool> TestCredentialsAsync(CancellationToken cancellationToken = default)
+        {
+            bool hasValidCredentials = false;
+            try
+            {
+                var response = await m_httpClient.GetAsync(ENDPOINT_DOC, cancellationToken).ConfigureAwait(false);
+                hasValidCredentials = response.IsSuccessStatusCode;
+                if (hasValidCredentials)
+                {
+                    // credentials are valid
+                }
+                else
+                {
+                    // log a warning, that we don't have valid credentials
+                    m_logger.LogWarning("Failed to connect to {ClientName}-client at {BaseAddress} with valid credentials, Reason: {ReasonPhrase}",
+                        ClientName, m_httpClient.BaseAddress, response.ReasonPhrase);
+                }
+            }
+            catch (HttpRequestException httpEx)
+            {
+                m_logger.LogWarning(httpEx, "Failed to connect to {ClientName}-client at {BaseAddress}", ClientName, m_httpClient.BaseAddress);
+            }
+
+            return hasValidCredentials;
+        }
         #endregion
 
         #region IKepwareDefaultValueProvider
@@ -238,7 +268,7 @@ async Task<ReadOnlyDictionary<string, JsonElement>> IKepwareDefaultValueProvider
         /// <param name="httpEx"></param>
         internal void OnHttpRequestException(HttpRequestException httpEx)
         {
-            m_blnIsConnected = null;
+            m_isConnected = null;
         }
         #endregion
     }

Kepware.Api/Model/Admin/ServerUserGroup.cs

@@ -11,7 +11,7 @@ namespace Kepware.Api.Model.Admin
     /// <summary>
     /// Represents a user group in Kepware, allowing management of permissions and access control.
     /// </summary>
-    [Endpoint("/config/v1/admin/server_user_groups/{name}")]
+    [Endpoint("/config/v1/admin/server_usergroups/{name}")]
     public class ServerUserGroup : NamedEntity
     {
         /// <summary>
@@ -289,7 +289,7 @@ public bool? BrowseNamespace
         #endregion
     }
 
-    [Endpoint("/config/v1/admin/server_user_groups")]
+    [Endpoint("/config/v1/admin/server_usergroups")]
     public class ServerUserGroupCollection : EntityCollection<ServerUserGroup>
     {
 

KepwareSync.Service/SyncService.cs

@@ -52,7 +52,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             m_logger.LogInformation("Starting SyncService...");
 
-            await InititalizeAsync();
+            await InititalizeAsync().ConfigureAwait(false);
 
             if (m_syncOptions.SyncDirection == SyncDirection.DiskToKepware)
             {
@@ -67,28 +67,37 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
             {
                 try
                 {
-                    if (await m_kepServerClient.TestConnectionAsync(stoppingToken))
+                    if (await m_kepServerClient.TestConnectionAsync(stoppingToken).ConfigureAwait(false))
                     {
-                        if (m_syncOptions.SyncMode == SyncMode.TwoWay ||
-                            m_syncOptions.SyncDirection == SyncDirection.KepwareToDisk)
+                        if (m_changeQueue.TryDequeue(out var changeEvent))
                         {
-                            if (m_changeQueue.TryDequeue(out var changeEvent))
+                            // check if there are more events for the same source
+                            while (m_changeQueue.TryPeek(out var nextPending) && nextPending.Source == changeEvent!.Source)
                             {
-                                while (m_changeQueue.TryPeek(out var nextPending) && nextPending.Source == changeEvent!.Source)
-                                {
-                                    m_changeQueue.TryDequeue(out changeEvent);
-                                }
-                                await ProcessChangeAsync(changeEvent!, stoppingToken);
+                                m_changeQueue.TryDequeue(out changeEvent);
+                            }
+                            // Process the change event
+                            await ProcessChangeAsync(changeEvent!, stoppingToken).ConfigureAwait(false);
+                        }
+                        // We don't need to read the project Id in "DiskToKepware"-only mode, due to the fact that we are not syncing from Kepware to disk
+                        else if (m_syncOptions.SyncMode == SyncMode.TwoWay || m_syncOptions.SyncDirection != SyncDirection.DiskToKepware)
+                        {
+                            // If we are in two-way sync or Kepware to disk mode, we need to check the current project ID
+                            var currentProjectId = await FetchCurrentProjectIdAsync(m_kepServerClient, stoppingToken).ConfigureAwait(false);
+                            if (m_lastProjectId != currentProjectId)
+                            {
+                                // If the project ID has changed, we need to sync from Kepware to disk
+                                await ProcessChangeAsync(new ChangeEvent { Source = ChangeSource.PrimaryKepServer, Reason = "Project changed" }, stoppingToken).ConfigureAwait(false);
                             }
                             else
                             {
-                                var currentProjectId = await FetchCurrentProjectIdAsync(m_kepServerClient, stoppingToken);
-                                if (m_lastProjectId != currentProjectId)
-                                {
-                                    await ProcessChangeAsync(new ChangeEvent { Source = ChangeSource.PrimaryKepServer, Reason = "Project changed" }, stoppingToken);
-                                }
+                                // No changes to process, but we still want to check the connection
                             }
                         }
+                        else
+                        {
+                            // No changes to process, but we still want to check the connection
+                        }
 
                         blnFirstDisconnect = true;
                     }
@@ -270,22 +279,30 @@ private async Task SyncProjectToKepServerAsync(string projectSource, Project pro
                     targetOptions.OverwriteConfigFile, projectSource, clientName, kepServerClient.ClientHostName);
 
                 project = await project.CloneAsync(cancellationToken).ConfigureAwait(false);
-                var overwrite= await RuntimeOverwriteConfig.LoadFromYamlFileAsync(targetOptions.OverwriteConfigFile, cancellationToken).ConfigureAwait(false);
+                var overwrite = await RuntimeOverwriteConfig.LoadFromYamlFileAsync(targetOptions.OverwriteConfigFile, cancellationToken).ConfigureAwait(false);
                 overwrite.Apply(project);
             }
 
-            var (inserts, updates, deletes) = await kepServerClient.Project.CompareAndApply(project, cancellationToken).ConfigureAwait(false);
-
-            if (updates > 0 || deletes > 0 || inserts > 0)
+            if (await kepServerClient.TestConnectionAsync(cancellationToken).ConfigureAwait(false))
             {
-                m_logger.LogInformation("Completed synchronisation from {ProjectSource} to {ClientName}-kepserver ({ClientHostName}): {NumUpdates} updates, {NumInserts} inserts, {NumDeletes} deletes",
-                 projectSource, clientName, kepServerClient.ClientHostName, updates, inserts, deletes);
-                onSyncedWithChanges?.Invoke();
+                var (inserts, updates, deletes) = await kepServerClient.Project.CompareAndApply(project, cancellationToken).ConfigureAwait(false);
+
+                if (updates > 0 || deletes > 0 || inserts > 0)
+                {
+                    m_logger.LogInformation("Completed synchronisation from {ProjectSource} to {ClientName}-kepserver ({ClientHostName}): {NumUpdates} updates, {NumInserts} inserts, {NumDeletes} deletes",
+                     projectSource, clientName, kepServerClient.ClientHostName, updates, inserts, deletes);
+                    onSyncedWithChanges?.Invoke();
+                }
+                else
+                {
+                    m_logger.LogInformation("Completed synchronisation from {ProjectSource} to {ClientName}-kepserver ({ClientHostName}):: no changes made",
+                        projectSource, clientName, kepServerClient.ClientHostName);
+                }
             }
             else
             {
-                m_logger.LogInformation("Completed synchronisation from {ProjectSource} to {ClientName}-kepserver ({ClientHostName}):: no changes made",
-                    projectSource, clientName, kepServerClient.ClientHostName);
+                // No connection to the kepware server, log a warning that the sync could not be performed (conection error is alread logged)
+                m_logger.LogWarning("No connection to {ClientName}-kepserver ({ClientHostName}). Sync from {ProjectSource} skipped.", clientName, kepServerClient.ClientHostName, projectSource);
             }
         }