Add bulk MXAccess subscription commands

2026-04-26 22:29:27 -04:00
parent daff16cfd2
commit 3d11ac3316
31 changed files with 14346 additions and 969 deletions
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using MxGateway.Contracts.Proto;
 using MxGateway.Worker.Conversion;
 using MxGateway.Worker.Sta;
@@ -40,6 +41,12 @@ public sealed class MxAccessCommandExecutor : IStaCommandExecutor
            MxCommandKind.Advise => ExecuteAdvise(command),
            MxCommandKind.UnAdvise => ExecuteUnAdvise(command),
            MxCommandKind.AdviseSupervisory => ExecuteAdviseSupervisory(command),
+            MxCommandKind.AddItemBulk => ExecuteAddItemBulk(command),
+            MxCommandKind.AdviseItemBulk => ExecuteAdviseItemBulk(command),
+            MxCommandKind.RemoveItemBulk => ExecuteRemoveItemBulk(command),
+            MxCommandKind.UnAdviseItemBulk => ExecuteUnAdviseItemBulk(command),
+            MxCommandKind.SubscribeBulk => ExecuteSubscribeBulk(command),
+            MxCommandKind.UnsubscribeBulk => ExecuteUnsubscribeBulk(command),
            _ => CreateInvalidRequestReply(command, $"Unsupported MXAccess command kind {command.Kind}."),
        };
    }
@@ -178,6 +185,84 @@ public sealed class MxAccessCommandExecutor : IStaCommandExecutor
        return CreateOkReply(command);
    }

+    private MxCommandReply ExecuteAddItemBulk(StaCommand command)
+    {
+        if (command.Command.PayloadCase != MxCommand.PayloadOneofCase.AddItemBulk)
+        {
+            return CreateInvalidRequestReply(command, "AddItemBulk command payload is required.");
+        }
+
+        AddItemBulkCommand addItemBulkCommand = command.Command.AddItemBulk;
+        return CreateBulkReply(
+            command,
+            session.AddItemBulk(addItemBulkCommand.ServerHandle, addItemBulkCommand.TagAddresses));
+    }
+
+    private MxCommandReply ExecuteAdviseItemBulk(StaCommand command)
+    {
+        if (command.Command.PayloadCase != MxCommand.PayloadOneofCase.AdviseItemBulk)
+        {
+            return CreateInvalidRequestReply(command, "AdviseItemBulk command payload is required.");
+        }
+
+        AdviseItemBulkCommand adviseItemBulkCommand = command.Command.AdviseItemBulk;
+        return CreateBulkReply(
+            command,
+            session.AdviseItemBulk(adviseItemBulkCommand.ServerHandle, adviseItemBulkCommand.ItemHandles));
+    }
+
+    private MxCommandReply ExecuteRemoveItemBulk(StaCommand command)
+    {
+        if (command.Command.PayloadCase != MxCommand.PayloadOneofCase.RemoveItemBulk)
+        {
+            return CreateInvalidRequestReply(command, "RemoveItemBulk command payload is required.");
+        }
+
+        RemoveItemBulkCommand removeItemBulkCommand = command.Command.RemoveItemBulk;
+        return CreateBulkReply(
+            command,
+            session.RemoveItemBulk(removeItemBulkCommand.ServerHandle, removeItemBulkCommand.ItemHandles));
+    }
+
+    private MxCommandReply ExecuteUnAdviseItemBulk(StaCommand command)
+    {
+        if (command.Command.PayloadCase != MxCommand.PayloadOneofCase.UnAdviseItemBulk)
+        {
+            return CreateInvalidRequestReply(command, "UnAdviseItemBulk command payload is required.");
+        }
+
+        UnAdviseItemBulkCommand unAdviseItemBulkCommand = command.Command.UnAdviseItemBulk;
+        return CreateBulkReply(
+            command,
+            session.UnAdviseItemBulk(unAdviseItemBulkCommand.ServerHandle, unAdviseItemBulkCommand.ItemHandles));
+    }
+
+    private MxCommandReply ExecuteSubscribeBulk(StaCommand command)
+    {
+        if (command.Command.PayloadCase != MxCommand.PayloadOneofCase.SubscribeBulk)
+        {
+            return CreateInvalidRequestReply(command, "SubscribeBulk command payload is required.");
+        }
+
+        SubscribeBulkCommand subscribeBulkCommand = command.Command.SubscribeBulk;
+        return CreateBulkReply(
+            command,
+            session.SubscribeBulk(subscribeBulkCommand.ServerHandle, subscribeBulkCommand.TagAddresses));
+    }
+
+    private MxCommandReply ExecuteUnsubscribeBulk(StaCommand command)
+    {
+        if (command.Command.PayloadCase != MxCommand.PayloadOneofCase.UnsubscribeBulk)
+        {
+            return CreateInvalidRequestReply(command, "UnsubscribeBulk command payload is required.");
+        }
+
+        UnsubscribeBulkCommand unsubscribeBulkCommand = command.Command.UnsubscribeBulk;
+        return CreateBulkReply(
+            command,
+            session.UnsubscribeBulk(unsubscribeBulkCommand.ServerHandle, unsubscribeBulkCommand.ItemHandles));
+    }
+
    private static MxCommandReply CreateOkReply(StaCommand command)
    {
        return new MxCommandReply
@@ -194,6 +279,41 @@ public sealed class MxAccessCommandExecutor : IStaCommandExecutor
        };
    }

+    private static MxCommandReply CreateBulkReply(
+        StaCommand command,
+        IEnumerable<SubscribeResult> results)
+    {
+        MxCommandReply reply = CreateOkReply(command);
+        BulkSubscribeReply bulkReply = new();
+        bulkReply.Results.Add(results);
+
+        switch (command.Kind)
+        {
+            case MxCommandKind.AddItemBulk:
+                reply.AddItemBulk = bulkReply;
+                break;
+            case MxCommandKind.AdviseItemBulk:
+                reply.AdviseItemBulk = bulkReply;
+                break;
+            case MxCommandKind.RemoveItemBulk:
+                reply.RemoveItemBulk = bulkReply;
+                break;
+            case MxCommandKind.UnAdviseItemBulk:
+                reply.UnAdviseItemBulk = bulkReply;
+                break;
+            case MxCommandKind.SubscribeBulk:
+                reply.SubscribeBulk = bulkReply;
+                break;
+            case MxCommandKind.UnsubscribeBulk:
+                reply.UnsubscribeBulk = bulkReply;
+                break;
+            default:
+                throw new InvalidOperationException($"Unsupported bulk command kind {command.Kind}.");
+        }
+
+        return reply;
+    }
+
    private static MxCommandReply CreateInvalidRequestReply(
        StaCommand command,
        string message)
@@ -189,6 +189,202 @@ public sealed class MxAccessSession : IDisposable
            MxAccessAdviceKind.Supervisory);
    }

+    public IReadOnlyList<SubscribeResult> AddItemBulk(
+        int serverHandle,
+        IEnumerable<string> tagAddresses)
+    {
+        ThrowIfDisposed();
+        if (tagAddresses is null)
+        {
+            throw new ArgumentNullException(nameof(tagAddresses));
+        }
+
+        List<SubscribeResult> results = new();
+        foreach (string? tagAddress in tagAddresses)
+        {
+            if (string.IsNullOrWhiteSpace(tagAddress))
+            {
+                results.Add(Failed(serverHandle, tagAddress ?? string.Empty, itemHandle: 0, "Tag address is required."));
+                continue;
+            }
+
+            try
+            {
+                int itemHandle = AddItem(serverHandle, tagAddress);
+                results.Add(Succeeded(serverHandle, tagAddress, itemHandle));
+            }
+            catch (Exception exception)
+            {
+                results.Add(Failed(serverHandle, tagAddress, itemHandle: 0, exception.Message));
+            }
+        }
+
+        return results;
+    }
+
+    public IReadOnlyList<SubscribeResult> AdviseItemBulk(
+        int serverHandle,
+        IEnumerable<int> itemHandles)
+    {
+        ThrowIfDisposed();
+        if (itemHandles is null)
+        {
+            throw new ArgumentNullException(nameof(itemHandles));
+        }
+
+        List<SubscribeResult> results = new();
+        foreach (int itemHandle in itemHandles)
+        {
+            try
+            {
+                Advise(serverHandle, itemHandle);
+                results.Add(Succeeded(serverHandle, string.Empty, itemHandle));
+            }
+            catch (Exception exception)
+            {
+                results.Add(Failed(serverHandle, string.Empty, itemHandle, exception.Message));
+            }
+        }
+
+        return results;
+    }
+
+    public IReadOnlyList<SubscribeResult> RemoveItemBulk(
+        int serverHandle,
+        IEnumerable<int> itemHandles)
+    {
+        ThrowIfDisposed();
+        if (itemHandles is null)
+        {
+            throw new ArgumentNullException(nameof(itemHandles));
+        }
+
+        List<SubscribeResult> results = new();
+        foreach (int itemHandle in itemHandles)
+        {
+            try
+            {
+                RemoveItem(serverHandle, itemHandle);
+                results.Add(Succeeded(serverHandle, string.Empty, itemHandle));
+            }
+            catch (Exception exception)
+            {
+                results.Add(Failed(serverHandle, string.Empty, itemHandle, exception.Message));
+            }
+        }
+
+        return results;
+    }
+
+    public IReadOnlyList<SubscribeResult> UnAdviseItemBulk(
+        int serverHandle,
+        IEnumerable<int> itemHandles)
+    {
+        ThrowIfDisposed();
+        if (itemHandles is null)
+        {
+            throw new ArgumentNullException(nameof(itemHandles));
+        }
+
+        List<SubscribeResult> results = new();
+        foreach (int itemHandle in itemHandles)
+        {
+            try
+            {
+                UnAdvise(serverHandle, itemHandle);
+                results.Add(Succeeded(serverHandle, string.Empty, itemHandle));
+            }
+            catch (Exception exception)
+            {
+                results.Add(Failed(serverHandle, string.Empty, itemHandle, exception.Message));
+            }
+        }
+
+        return results;
+    }
+
+    public IReadOnlyList<SubscribeResult> SubscribeBulk(
+        int serverHandle,
+        IEnumerable<string> tagAddresses)
+    {
+        ThrowIfDisposed();
+        if (tagAddresses is null)
+        {
+            throw new ArgumentNullException(nameof(tagAddresses));
+        }
+
+        List<SubscribeResult> results = new();
+        foreach (string? tagAddress in tagAddresses)
+        {
+            if (string.IsNullOrWhiteSpace(tagAddress))
+            {
+                results.Add(Failed(serverHandle, tagAddress ?? string.Empty, itemHandle: 0, "Tag address is required."));
+                continue;
+            }
+
+            int itemHandle = 0;
+            try
+            {
+                itemHandle = AddItem(serverHandle, tagAddress);
+                Advise(serverHandle, itemHandle);
+                results.Add(Succeeded(serverHandle, tagAddress, itemHandle));
+            }
+            catch (Exception exception)
+            {
+                string errorMessage = exception.Message;
+                if (itemHandle != 0)
+                {
+                    errorMessage = AppendRemoveItemCleanup(serverHandle, itemHandle, errorMessage);
+                }
+
+                results.Add(Failed(serverHandle, tagAddress, itemHandle, errorMessage));
+            }
+        }
+
+        return results;
+    }
+
+    public IReadOnlyList<SubscribeResult> UnsubscribeBulk(
+        int serverHandle,
+        IEnumerable<int> itemHandles)
+    {
+        ThrowIfDisposed();
+        if (itemHandles is null)
+        {
+            throw new ArgumentNullException(nameof(itemHandles));
+        }
+
+        List<SubscribeResult> results = new();
+        foreach (int itemHandle in itemHandles)
+        {
+            List<string> errors = new();
+
+            try
+            {
+                UnAdvise(serverHandle, itemHandle);
+            }
+            catch (Exception exception)
+            {
+                errors.Add($"UnAdvise failed: {exception.Message}");
+            }
+
+            try
+            {
+                RemoveItem(serverHandle, itemHandle);
+            }
+            catch (Exception exception)
+            {
+                errors.Add($"RemoveItem failed: {exception.Message}");
+            }
+
+            results.Add(errors.Count == 0
+                ? Succeeded(serverHandle, string.Empty, itemHandle)
+                : Failed(serverHandle, string.Empty, itemHandle, string.Join("; ", errors)));
+        }
+
+        return results;
+    }
+
    public MxAccessShutdownResult ShutdownGracefully()
    {
        if (disposed)
@@ -290,6 +486,53 @@ public sealed class MxAccessSession : IDisposable
        return ((long)serverHandle << 32) | (uint)itemHandle;
    }

+    private string AppendRemoveItemCleanup(
+        int serverHandle,
+        int itemHandle,
+        string errorMessage)
+    {
+        try
+        {
+            RemoveItem(serverHandle, itemHandle);
+            return $"{errorMessage}; cleanup RemoveItem succeeded.";
+        }
+        catch (Exception cleanupException)
+        {
+            return $"{errorMessage}; cleanup RemoveItem failed: {cleanupException.Message}";
+        }
+    }
+
+    private static SubscribeResult Succeeded(
+        int serverHandle,
+        string tagAddress,
+        int itemHandle)
+    {
+        return new SubscribeResult
+        {
+            ServerHandle = serverHandle,
+            TagAddress = tagAddress,
+            ItemHandle = itemHandle,
+            WasSuccessful = true,
+            ErrorMessage = string.Empty,
+        };
+    }
+
+    private static SubscribeResult Failed(
+        int serverHandle,
+        string tagAddress,
+        int itemHandle,
+        string errorMessage)
+    {
+        return new SubscribeResult
+        {
+            ServerHandle = serverHandle,
+            TagAddress = tagAddress,
+            ItemHandle = itemHandle,
+            WasSuccessful = false,
+            ErrorMessage = errorMessage,
+        };
+    }
+
    private void DisposeCore(ICollection<MxAccessShutdownFailure>? failures)
    {
        try