slim-bindings 0.6.1__tar.gz → 0.6.2__tar.gz

{slim_bindings-0.6.1 → slim_bindings-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slim-bindings
-Version: 0.6.1
+Version: 0.6.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries

{slim_bindings-0.6.1 → slim_bindings-0.6.2}/core/datapath/src/message_processing.rs

@@ -262,30 +262,36 @@ impl MessageProcessor {
             .await
     }
 
-    pub fn disconnect(&self, conn: u64) -> Result<(), DataPathError> {
-        match self.forwarder().get_connection(conn) {
+    pub fn disconnect(&self, conn: u64) -> Result<ClientConfig, DataPathError> {
+        let connection = match self.forwarder().get_connection(conn) {
+            Some(c) => c,
             None => {
                 error!("error handling disconnect: connection unknown");
                 return Err(DataPathError::DisconnectionError(
                     "connection not found".to_string(),
                 ));
             }
-            Some(c) => {
-                match c.cancellation_token() {
-                    None => {
-                        error!("error handling disconnect: missing cancellation token");
-                    }
-                    Some(t) => {
-                        // here token cancel will stop the receiving loop on
-                        // conn and this will cause the delition of the state
-                        // for this connection
-                        t.cancel();
-                    }
-                }
+        };
+
+        let token = match connection.cancellation_token() {
+            Some(t) => t,
+            None => {
+                error!("error handling disconnect: missing cancellation token");
+                return Err(DataPathError::DisconnectionError(
+                    "missing cancellation token".to_string(),
+                ));
             }
-        }
+        };
+
+        // Cancel receiving loop; this triggers deletion of connection state.
+        token.cancel();
 
-        Ok(())
+        connection
+            .config_data()
+            .cloned()
+            .ok_or(DataPathError::DisconnectionError(
+                "missing client config data".to_string(),
+            ))
     }
 
     pub fn register_local_connection(

{slim_bindings-0.6.1 → slim_bindings-0.6.2}/core/datapath/tests/data_path_test.rs

@@ -147,6 +147,71 @@ mod tests {
         assert!(logs_contain(expected_msg));
     }
 
+    #[tokio::test]
+    #[traced_test]
+    async fn test_disconnection() {
+        // setup server from configuration
+        let mut server_conf = ServerConfig::with_endpoint("127.0.0.1:50052");
+        server_conf.tls_setting.insecure = true;
+
+        let (processor, _signal) = MessageProcessor::new();
+        let svc = Arc::new(processor);
+        let msg_processor = svc.clone();
+
+        let ep_server = server_conf
+            .to_server_future(&[DataPlaneServiceServer::from_arc(svc)])
+            .unwrap();
+
+        tokio::spawn(async move {
+            if let Err(e) = ep_server.await {
+                panic!("Server error: {:?}", e);
+            }
+        });
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        // create a client config we will attach to the connection
+        let mut client_config = ClientConfig::with_endpoint("http://127.0.0.1:50052");
+        client_config.tls_setting.insecure = true;
+        let channel = client_config.to_channel().unwrap();
+
+        // connect with client_config Some(...)
+        let (_, conn_index) = msg_processor
+            .connect(
+                channel,
+                Some(client_config.clone()),
+                None,
+                Some(SocketAddr::from(([127, 0, 0, 1], 50052))),
+            )
+            .await
+            .expect("error creating channel");
+
+        // ensure connection exists before disconnect
+        assert!(
+            msg_processor
+                .connection_table()
+                .get(conn_index as usize)
+                .is_some()
+        );
+
+        // disconnect (should cancel stream and eventually remove connection)
+        let _returned_cfg = msg_processor
+            .disconnect(conn_index)
+            .expect("disconnect should return client config");
+
+        // wait for cancellation to propagate and stream task to drop connection
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+
+        // after disconnect the connection should be removed
+        assert!(
+            msg_processor
+                .connection_table()
+                .get(conn_index as usize)
+                .is_none(),
+            "connection should be removed after disconnect"
+        );
+    }
+
     fn make_message(org: &str, ns: &str, name: &str) -> Message {
         let source = Name::from_strings([org, ns, name]).with_id(0);
         let name = Name::from_strings([org, ns, name]).with_id(1);

{slim_bindings-0.6.1 → slim_bindings-0.6.2}/core/service/src/service.rs

@@ -344,9 +344,27 @@ impl Service {
     pub fn disconnect(&self, conn: u64) -> Result<(), ServiceError> {
         info!("disconnect from conn {}", conn);
 
-        self.message_processor
-            .disconnect(conn)
-            .map_err(|e| ServiceError::DisconnectError(e.to_string()))
+        match self.message_processor.disconnect(conn) {
+            Ok(cfg) => {
+                let endpoint = cfg.endpoint.clone();
+                let mut clients = self.clients.write();
+                if let Some(stored_conn) = clients.get(&endpoint) {
+                    if *stored_conn == conn {
+                        clients.remove(&endpoint);
+                        info!("removed client mapping for endpoint {}", endpoint);
+                    } else {
+                        debug!(
+                            "client mapping endpoint {} has different conn_id {} != {}",
+                            endpoint, stored_conn, conn
+                        );
+                    }
+                } else {
+                    debug!("no client mapping found for endpoint {}", endpoint);
+                }
+                Ok(())
+            }
+            Err(e) => Err(ServiceError::DisconnectError(e.to_string())),
+        }
     }
 
     pub fn get_connection_id(&self, endpoint: &str) -> Option<u64> {
@@ -469,6 +487,62 @@ mod tests {
         assert!(logs_contain("shutting down server"));
     }
 
+    #[tokio::test]
+    #[traced_test]
+    async fn test_service_disconnection() {
+        // create the service (server + one client we will disconnect)
+        let tls_config = TlsServerConfig::new().with_insecure(true);
+        let server_config =
+            ServerConfig::with_endpoint("0.0.0.0:12346").with_tls_settings(tls_config);
+        let config = ServiceConfiguration::new().with_server([server_config].to_vec());
+        let mut service = config
+            .build_server(ID::new_with_name(Kind::new(KIND).unwrap(), "test-disconnect").unwrap())
+            .unwrap();
+
+        service.run().await.expect("failed to run service");
+
+        // wait a bit for server loop to start
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        // build client configuration and connect
+        let mut client_conf =
+            slim_config::grpc::client::ClientConfig::with_endpoint("http://0.0.0.0:12346");
+        client_conf.tls_setting.insecure = true;
+        let conn_id = service
+            .connect(&client_conf)
+            .await
+            .expect("failed to connect client");
+
+        assert!(service.get_connection_id(&client_conf.endpoint).is_some());
+
+        // disconnect
+        service
+            .disconnect(conn_id)
+            .expect("disconnect should succeed");
+
+        // allow cancellation token to propagate and stream to terminate
+        tokio::time::sleep(Duration::from_millis(200)).await;
+
+        // verify connection is removed from internal client mapping
+        assert!(
+            service.get_connection_id(&client_conf.endpoint).is_none(),
+            "client mapping should be removed after disconnect"
+        );
+
+        // verify connection is removed from connection table
+        assert!(
+            service
+                .message_processor
+                .connection_table()
+                .get(conn_id as usize)
+                .is_none(),
+            "connection should be removed after disconnect"
+        );
+
+        // verify disconnect log
+        assert!(logs_contain("disconnect from conn"));
+    }
+
     #[tokio::test]
     #[traced_test]
     async fn test_service_publish_subscribe() {

{slim_bindings-0.6.1 → slim_bindings-0.6.2}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "maturin"
 
 [project]
 name = "slim-bindings"
-version = "0.6.1"
+version = "0.6.2"
 description = "SLIM Rust bindings for Python"
 requires-python = ">=3.9, <4.0"
 readme = "README.md"

{slim_bindings-0.6.1 → slim_bindings-0.6.2}/python/bindings/uv.lock

@@ -340,7 +340,7 @@ wheels = [
 
 [[package]]
 name = "slim-bindings"
-version = "0.6.0"
+version = "0.6.1"
 source = { editable = "." }
 
 [package.dev-dependencies]