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
@@ -3,9 +3,11 @@ use crate::error::Error;
 use crate::generated::mxaccess_gateway::v1::mx_command::Payload;
 use crate::generated::mxaccess_gateway::v1::mx_command_reply;
 use crate::generated::mxaccess_gateway::v1::{
-    AddItem2Command, AddItemCommand, AdviseCommand, CloseSessionRequest, MxCommand, MxCommandKind,
-    MxCommandReply, MxCommandRequest, MxValue as ProtoMxValue, OpenSessionRequest, RegisterCommand,
-    StreamEventsRequest, Write2Command, WriteCommand,
+    AddItem2Command, AddItemBulkCommand, AddItemCommand, AdviseCommand, AdviseItemBulkCommand,
+    CloseSessionRequest, MxCommand, MxCommandKind, MxCommandReply, MxCommandRequest,
+    MxValue as ProtoMxValue, OpenSessionRequest, RegisterCommand, RemoveItemBulkCommand,
+    RemoveItemCommand, StreamEventsRequest, SubscribeBulkCommand, SubscribeResult, UnAdviseCommand,
+    UnAdviseItemBulkCommand, UnsubscribeBulkCommand, Write2Command, WriteCommand,
 };
 use crate::value::MxValue;

@@ -94,6 +96,18 @@ impl Session {
        Ok(add_item2_handle(&reply))
    }

+    pub async fn remove_item(&self, server_handle: i32, item_handle: i32) -> Result<(), Error> {
+        self.invoke(
+            MxCommandKind::RemoveItem,
+            Payload::RemoveItem(RemoveItemCommand {
+                server_handle,
+                item_handle,
+            }),
+        )
+        .await?;
+        Ok(())
+    }
+
    pub async fn advise(&self, server_handle: i32, item_handle: i32) -> Result<(), Error> {
        self.invoke(
            MxCommandKind::Advise,
@@ -106,6 +120,126 @@ impl Session {
        Ok(())
    }

+    pub async fn un_advise(&self, server_handle: i32, item_handle: i32) -> Result<(), Error> {
+        self.invoke(
+            MxCommandKind::UnAdvise,
+            Payload::UnAdvise(UnAdviseCommand {
+                server_handle,
+                item_handle,
+            }),
+        )
+        .await?;
+        Ok(())
+    }
+
+    pub async fn add_item_bulk(
+        &self,
+        server_handle: i32,
+        tag_addresses: Vec<String>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::AddItemBulk,
+                Payload::AddItemBulk(AddItemBulkCommand {
+                    server_handle,
+                    tag_addresses,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::AddItemBulk))
+    }
+
+    pub async fn advise_item_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::AdviseItemBulk,
+                Payload::AdviseItemBulk(AdviseItemBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::AdviseItemBulk))
+    }
+
+    pub async fn remove_item_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::RemoveItemBulk,
+                Payload::RemoveItemBulk(RemoveItemBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::RemoveItemBulk))
+    }
+
+    pub async fn un_advise_item_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::UnAdviseItemBulk,
+                Payload::UnAdviseItemBulk(UnAdviseItemBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::UnAdviseItemBulk))
+    }
+
+    pub async fn subscribe_bulk(
+        &self,
+        server_handle: i32,
+        tag_addresses: Vec<String>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::SubscribeBulk,
+                Payload::SubscribeBulk(SubscribeBulkCommand {
+                    server_handle,
+                    tag_addresses,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::SubscribeBulk))
+    }
+
+    pub async fn unsubscribe_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::UnsubscribeBulk,
+                Payload::UnsubscribeBulk(UnsubscribeBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::UnsubscribeBulk))
+    }
+
    pub async fn write(
        &self,
        server_handle: i32,
@@ -226,6 +360,41 @@ fn add_item2_handle(reply: &MxCommandReply) -> i32 {
    }
 }

+enum BulkReplyKind {
+    AddItemBulk,
+    AdviseItemBulk,
+    RemoveItemBulk,
+    UnAdviseItemBulk,
+    SubscribeBulk,
+    UnsubscribeBulk,
+}
+
+fn bulk_results(reply: MxCommandReply, kind: BulkReplyKind) -> Vec<SubscribeResult> {
+    match (reply.payload, kind) {
+        (Some(mx_command_reply::Payload::AddItemBulk(reply)), BulkReplyKind::AddItemBulk) => {
+            reply.results
+        }
+        (Some(mx_command_reply::Payload::AdviseItemBulk(reply)), BulkReplyKind::AdviseItemBulk) => {
+            reply.results
+        }
+        (Some(mx_command_reply::Payload::RemoveItemBulk(reply)), BulkReplyKind::RemoveItemBulk) => {
+            reply.results
+        }
+        (
+            Some(mx_command_reply::Payload::UnAdviseItemBulk(reply)),
+            BulkReplyKind::UnAdviseItemBulk,
+        ) => reply.results,
+        (Some(mx_command_reply::Payload::SubscribeBulk(reply)), BulkReplyKind::SubscribeBulk) => {
+            reply.results
+        }
+        (
+            Some(mx_command_reply::Payload::UnsubscribeBulk(reply)),
+            BulkReplyKind::UnsubscribeBulk,
+        ) => reply.results,
+        _ => Vec::new(),
+    }
+}
+
 fn int32_reply_value(value: &ProtoMxValue) -> Option<i32> {
    match value.kind.as_ref()? {
        crate::generated::mxaccess_gateway::v1::mx_value::Kind::Int32Value(value) => Some(*value),
@@ -14,10 +14,10 @@ use mxgateway_client::generated::mxaccess_gateway::v1::mx_access_gateway_server:
 use mxgateway_client::generated::mxaccess_gateway::v1::mx_command_reply;
 use mxgateway_client::generated::mxaccess_gateway::v1::mx_value::Kind;
 use mxgateway_client::generated::mxaccess_gateway::v1::{
-    AddItemReply, CloseSessionReply, CloseSessionRequest, MxCommandKind, MxCommandReply,
-    MxDataType, MxEvent, MxEventFamily, MxStatusCategory, MxStatusProxy, MxStatusSource, MxValue,
-    OpenSessionReply, OpenSessionRequest, ProtocolStatus, ProtocolStatusCode, SessionState,
-    StreamEventsRequest,
+    AddItemReply, BulkSubscribeReply, CloseSessionReply, CloseSessionRequest, MxCommandKind,
+    MxCommandReply, MxDataType, MxEvent, MxEventFamily, MxStatusCategory, MxStatusProxy,
+    MxStatusSource, MxValue, OpenSessionReply, OpenSessionRequest, ProtocolStatus,
+    ProtocolStatusCode, SessionState, StreamEventsRequest, SubscribeResult,
 };
 use mxgateway_client::{
    ApiKey, ClientOptions, CommandError, Error, GatewayClient, MxStatus, MxValue as ClientMxValue,
@@ -87,6 +87,25 @@ async fn session_helpers_build_commands_and_preserve_command_errors() {
    assert_eq!(error.reply().statuses.len(), 2);
 }

+#[tokio::test]
+async fn subscribe_bulk_builds_one_bulk_command_and_returns_results() {
+    let state = Arc::new(FakeState::default());
+    let endpoint = spawn_fake_gateway(state.clone()).await;
+    let client = GatewayClient::connect(ClientOptions::new(endpoint))
+        .await
+        .unwrap();
+    let session = client.session("session-fixture");
+
+    let results = session
+        .subscribe_bulk(12, vec!["Area001.Pump001.Speed".to_owned()])
+        .await
+        .unwrap();
+
+    assert_eq!(results[0].item_handle, 34);
+    let last_command = state.last_command_kind.lock().await;
+    assert_eq!(*last_command, Some(MxCommandKind::SubscribeBulk as i32));
+}
+
 #[tokio::test]
 async fn event_stream_preserves_order_and_drop_cancels_server_stream() {
    let state = Arc::new(FakeState::default());
@@ -268,6 +287,27 @@ impl MxAccessGateway for FakeGateway {
            return Ok(Response::new(mxaccess_failure_reply()));
        }

+        if kind == MxCommandKind::SubscribeBulk as i32 {
+            return Ok(Response::new(MxCommandReply {
+                session_id: request.session_id,
+                correlation_id: "fake-correlation".to_owned(),
+                kind,
+                protocol_status: Some(ok_status("command ok")),
+                payload: Some(mx_command_reply::Payload::SubscribeBulk(
+                    BulkSubscribeReply {
+                        results: vec![SubscribeResult {
+                            server_handle: 12,
+                            tag_address: "Area001.Pump001.Speed".to_owned(),
+                            item_handle: 34,
+                            was_successful: true,
+                            error_message: String::new(),
+                        }],
+                    },
+                )),
+                ..MxCommandReply::default()
+            }));
+        }
+
        Ok(Response::new(MxCommandReply {
            session_id: request.session_id,
            correlation_id: "fake-correlation".to_owned(),