Type issue

src/client/client_v5.rs

@@ -24,48 +24,47 @@ where
         }
     }
     // connect -> connack -> publish -> QoS ? -> disconn
-    pub async fn send_message(&'a mut self, topic_name: & str, message: & str, qos: QualityOfService) -> impl Future<Output = Result<(), NetworkError>> {
+    pub async fn send_message(&'a mut self, topic_name: & str, message: & str, qos: QualityOfService) -> Result<(), NetworkError> {
-        async move {
-            let mut len = {
-                let mut connect = ConnectPacket::<3, 0>::clean();
-                connect.encode(self.buffer)
-            };
 
-            self.network_driver.send(self.buffer, len).await?;
+        let mut len = {
+            let mut connect = ConnectPacket::<3, 0>::clean();
+            connect.encode(self.buffer)
+        };
 
-            //connack
+        self.network_driver.send(self.buffer, len).await ?;
-            let connack = {
-                let connack = self.receive().await?;
-                let mut packet = ConnackPacket::new();
-                packet.decode(&mut BuffReader::new(self.buffer));
-                packet
-            };
 
-            if connack.connect_reason_code != 0x00 {
+        //connack
-                todo!();
+        let connack = {
-            }
+            self.receive().await ?;
+            let mut packet = ConnackPacket::new();
+            packet.decode(&mut BuffReader::new(self.buffer));
+            packet
+        };
 
-            // publish
+        if connack.connect_reason_code != 0x00 {
-
+            todo!();
-            len = {
-                let mut packet = PublishPacket::<5>::new(topic_name, message);
-                packet.encode(self.buffer)
-            };
-
-            self.network_driver.send(self.buffer, len).await?;
-
-
-            //QoS1
-            if <QualityOfService as Into<u8>>::into(qos) == <QualityOfService as Into<u8>>::into(QoS1) {
-                todo!();
-            }
-
-            //Disconnect
-            let mut disconnect = DisconnectPacket::<5>::new();
-            len = disconnect.encode(self.buffer);
-            self.network_driver.send(self.buffer, len);
-            Ok(())
         }
+
+        // publish
+
+        len = {
+            let mut packet = PublishPacket::<5>::new(topic_name, message);
+            packet.encode(self.buffer)
+        };
+
+        self.network_driver.send(self.buffer, len).await ?;
+
+
+        //QoS1
+        if <QualityOfService as Into<u8>>::into(qos) == <QualityOfService as Into<u8>>::into(QoS1) {
+            todo!();
+        }
+
+        //Disconnect
+        let mut disconnect = DisconnectPacket::<5>::new();
+        len = disconnect.encode(self.buffer);
+        self.network_driver.send(self.buffer, len);
+        Ok(())
     }
 
     pub async fn receive(&'a mut self) -> Result<(), NetworkError> {

src/main.rs

@@ -6,6 +6,7 @@ use rust_mqtt::packet::publish_packet::PublishPacket;
 use rust_mqtt::packet::subscription_packet::SubscriptionPacket;
 use rust_mqtt::tokio_network::TokioNetwork;
 
+#[tokio::main]
 fn main() {
     env_logger::builder()
         .filter_level(log::LevelFilter::Info)

src/tokio_network.rs

@@ -5,7 +5,6 @@ use core::fmt::Error;
 use core::future::Future;
 use core::ptr::null;
 
-use embassy::io::WriteAll;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};