replace serialize to bincode

Cargo.toml

@@ -29,8 +29,8 @@ base64 = "0.13"
 sha2 = "0.9"
 blake3 = "0.3"
 aes-gcm = "0.8"
+bincode = "1.3"
 serde = { version = "1", features = ["derive"] }
-postcard = { version = "0.5", default-features = false, features = ["alloc"] }
 sysinfo = "0.16"
 tokio = { version = "1", features = ["full"] }
 tdn = { version = "0.5", default-features = false, features = ["full"] }
@@ -40,4 +40,4 @@ group-chat_types = { git = "https://github.com/cympletech/group-chat", branch="m
 #group-chat-types = { path = "../group-chat/types" }
 
 [target.'cfg(target_os="android")'.dependencies]
-jni = { version = "0.19", default-features = false }
+jni = { version = "0.19", default-features = false }

src/apps/chat/layer.rs

@@ -67,7 +67,7 @@ pub(crate) async fn handle(
             // ESSE chat layer connect date structure.
             if handle_connect(&mgid, &fgid, &addr, data, &mut layer, &mut results)? {
                 let proof = layer.group.read().await.prove_addr(&mgid, &addr)?;
-                let data = postcard::to_allocvec(&proof).unwrap_or(vec![]);
+                let data = bincode::serialize(&proof).unwrap_or(vec![]);
                 let msg = SendType::Result(0, addr, true, false, data);
                 results.layers.push((mgid, fgid, msg));
             } else {
@@ -139,7 +139,7 @@ fn handle_connect(
     results: &mut HandleResult,
 ) -> Result<bool> {
     // 0. deserialize connect data.
-    let proof: Proof = postcard::from_bytes(&data)
+    let proof: Proof = bincode::deserialize(&data)
         .map_err(|_e| new_io_error("Deseralize chat layer connect failure"))?;
 
     // 1. check verify.
@@ -178,7 +178,7 @@ impl LayerEvent {
         bytes: Vec<u8>,
     ) -> Result<HandleResult> {
         let event: LayerEvent =
-            postcard::from_bytes(&bytes).map_err(|_| new_io_error("serialize event error."))?;
+            bincode::deserialize(&bytes).map_err(|_| new_io_error("serialize event error."))?;
 
         let mut results = HandleResult::new();
 
@@ -483,7 +483,7 @@ pub(super) fn req_message(layer: &mut Layer, me: User, request: Request) -> Send
     let uid = layer.delivery.len() as u64 + 1;
     layer.delivery.insert(uid, (me.id, request.id));
     let req = LayerEvent::Request(me, request.remark);
-    let data = postcard::to_allocvec(&req).unwrap_or(vec![]);
+    let data = bincode::serialize(&req).unwrap_or(vec![]);
     SendType::Event(uid, request.addr, data)
 }
 
@@ -493,7 +493,7 @@ pub(super) fn reject_message(
     addr: PeerAddr,
     me_id: GroupId,
 ) -> SendType {
-    let data = postcard::to_allocvec(&LayerEvent::Reject).unwrap_or(vec![]);
+    let data = bincode::serialize(&LayerEvent::Reject).unwrap_or(vec![]);
     let uid = layer.delivery.len() as u64 + 1;
     layer.delivery.insert(uid, (me_id, tid));
     SendType::Event(uid, addr, data)
@@ -506,23 +506,23 @@ pub(crate) fn event_message(
     addr: PeerAddr,
     event: &LayerEvent,
 ) -> SendType {
-    let data = postcard::to_allocvec(event).unwrap_or(vec![]);
+    let data = bincode::serialize(event).unwrap_or(vec![]);
     let uid = layer.delivery.len() as u64 + 1;
     layer.delivery.insert(uid, (me_id, tid));
     SendType::Event(uid, addr, data)
 }
 
 pub(crate) fn chat_conn(proof: Proof, addr: PeerAddr) -> SendType {
-    let data = postcard::to_allocvec(&proof).unwrap_or(vec![]);
+    let data = bincode::serialize(&proof).unwrap_or(vec![]);
     SendType::Connect(0, addr, None, None, data)
 }
 
 pub(super) fn agree_message(proof: Proof, me: User, addr: PeerAddr) -> Result<SendType> {
-    let data = postcard::to_allocvec(&LayerEvent::Agree(me, proof)).unwrap_or(vec![]);
+    let data = bincode::serialize(&LayerEvent::Agree(me, proof)).unwrap_or(vec![]);
     Ok(SendType::Event(0, addr, data))
 }
 
 // maybe need if gid or addr in blocklist.
 fn _res_reject() -> Vec<u8> {
-    postcard::to_allocvec(&LayerEvent::Reject).unwrap_or(vec![])
+    bincode::serialize(&LayerEvent::Reject).unwrap_or(vec![])
 }

src/apps/chat/rpc.rs

@@ -169,7 +169,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
                 tokio::spawn(sleep_waiting_close_stable(sender, HashMap::new(), addrs));
             }
 
-            let data = postcard::to_allocvec(&LayerEvent::Close).unwrap_or(vec![]);
+            let data = bincode::serialize(&LayerEvent::Close)?;
             let msg = SendType::Event(0, friend.addr, data);
             results.layers.push((gid, friend.gid, msg));
 
@@ -209,7 +209,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
                 tokio::spawn(sleep_waiting_close_stable(sender, HashMap::new(), addrs));
             }
 
-            let data = postcard::to_allocvec(&LayerEvent::Close).unwrap_or(vec![]);
+            let data = bincode::serialize(&LayerEvent::Close)?;
             let msg = SendType::Event(0, friend.addr, data);
             results.layers.push((gid, friend.gid, msg));
 

src/apps/group_chat/layer.rs

@@ -50,7 +50,7 @@ pub(crate) async fn handle(
         }
         RecvType::Event(addr, bytes) => {
             let event: LayerEvent =
-                postcard::from_bytes(&bytes).map_err(|_| new_io_error("serialize event error."))?;
+                bincode::deserialize(&bytes).map_err(|_| new_io_error("serialize event error."))?;
             handle_event(mgid, addr, event, layer, &mut results).await?;
         }
         RecvType::Stream(_uid, _stream, _bytes) => {
@@ -73,7 +73,7 @@ fn handle_connect(
 ) -> Result<bool> {
     // 0. deserialize result.
     let LayerResult(gcd, height) =
-        postcard::from_bytes(&data).map_err(|_e| new_io_error("Deseralize result failure"))?;
+        bincode::deserialize(&data).map_err(|_e| new_io_error("Deseralize result failure"))?;
 
     // 1. check group.
     if let Some(group) = load_group(layer.base(), &mgid, &gcd)? {
@@ -348,18 +348,18 @@ fn load_group(base: &PathBuf, mgid: &GroupId, gcd: &GroupId) -> Result<Option<Gr
 
 pub(crate) fn group_chat_conn(proof: Proof, addr: PeerAddr, gid: GroupId) -> SendType {
     let data =
-        postcard::to_allocvec(&LayerConnect(gid, ConnectProof::Common(proof))).unwrap_or(vec![]);
+        bincode::serialize(&LayerConnect(gid, ConnectProof::Common(proof))).unwrap_or(vec![]);
     SendType::Connect(0, addr, None, None, data)
 }
 
 fn sync(gcd: GroupId, addr: PeerAddr, height: i64) -> SendType {
     println!("Send sync request...");
-    let data = postcard::to_allocvec(&LayerEvent::SyncReq(gcd, height + 1)).unwrap_or(vec![]);
+    let data = bincode::serialize(&LayerEvent::SyncReq(gcd, height + 1)).unwrap_or(vec![]);
     SendType::Event(0, addr, data)
 }
 
 fn sync_online(gcd: GroupId, addr: PeerAddr) -> SendType {
-    let data = postcard::to_allocvec(&LayerEvent::MemberOnlineSync(gcd)).unwrap_or(vec![]);
+    let data = bincode::serialize(&LayerEvent::MemberOnlineSync(gcd)).unwrap_or(vec![]);
     SendType::Event(0, addr, data)
 }
 

src/apps/group_chat/rpc.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
     message::SendType,
-    primitive::{new_io_error, HandleResult, PeerAddr},
+    primitive::{HandleResult, PeerAddr},
     rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
 };
 use tdn_did::Proof;
@@ -165,7 +165,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let addr = PeerAddr::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
 
             let mut results = HandleResult::new();
-            let data = postcard::to_allocvec(&LayerEvent::Check).unwrap_or(vec![]);
+            let data = bincode::serialize(&LayerEvent::Check)?;
             let s = SendType::Event(0, addr, data);
             add_layer(&mut results, gid, s);
             Ok(results)
@@ -222,8 +222,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
                 // TODO create proof.
                 let proof: Proof = Default::default();
 
-                let data =
-                    postcard::to_allocvec(&LayerEvent::Create(info, proof)).unwrap_or(vec![]);
+                let data = bincode::serialize(&LayerEvent::Create(info, proof))?;
                 let s = SendType::Event(0, addr, data);
                 add_layer(&mut results, gid, s);
             } else {
@@ -257,7 +256,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             // TODO create proof.
             let proof: Proof = Default::default();
 
-            let data = postcard::to_allocvec(&LayerEvent::Create(info, proof)).unwrap_or(vec![]);
+            let data = bincode::serialize(&LayerEvent::Create(info, proof))?;
             let s = SendType::Event(0, addr, data);
             let mut results = HandleResult::new();
             add_layer(&mut results, gid, s);
@@ -311,8 +310,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
                 GroupType::Open => JoinProof::Open(me.name, me.avatar),
             };
 
-            let data =
-                postcard::to_allocvec(&LayerEvent::Request(gcd, join_proof)).unwrap_or(vec![]);
+            let data = bincode::serialize(&LayerEvent::Request(gcd, join_proof))?;
             let s = SendType::Event(0, gaddr, data);
             add_layer(&mut results, gid, s);
             Ok(results)
@@ -411,8 +409,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let gc = GroupChat::get_id(&db, &id)?.ok_or(RpcError::ParseError)?;
 
             let mut results = HandleResult::new();
-            let data =
-                postcard::to_allocvec(&LayerEvent::RequestResult(gcd, rid, ok)).unwrap_or(vec![]);
+            let data = bincode::serialize(&LayerEvent::RequestResult(gcd, rid, ok))?;
             let s = SendType::Event(0, gc.g_addr, data);
             add_layer(&mut results, gid, s);
             Ok(results)
@@ -436,23 +433,23 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
             let gcd = GroupId::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
             let id = params[1].as_i64().ok_or(RpcError::ParseError)?;
-            let m_type = MessageType::from_int(params[2].as_i64().ok_or(RpcError::ParseError)?);
-            let m_content = params[3].as_str().ok_or(RpcError::ParseError)?;
+            let is_remote = params[2].as_bool().ok_or(RpcError::ParseError)?;
+            let m_type = MessageType::from_int(params[3].as_i64().ok_or(RpcError::ParseError)?);
+            let m_content = params[4].as_str().ok_or(RpcError::ParseError)?;
 
-            let db = group_chat_db(state.layer.read().await.base(), &gid)?;
-            let gc = GroupChat::get_id(&db, &id)?.ok_or(RpcError::ParseError)?;
             let base = state.group.read().await.base().clone();
             let (nmsg, datetime) = to_network_message(&base, &gid, m_type, m_content).await?;
             let event = Event::MessageCreate(gid, nmsg, datetime);
 
             let mut results = HandleResult::new();
-            if gc.is_remote {
+            if is_remote {
                 let addr = state.layer.read().await.running(&gid)?.online(&gcd)?;
-                let data =
-                    postcard::to_allocvec(&LayerEvent::Sync(gcd, 0, event)).unwrap_or(vec![]);
+                let data = bincode::serialize(&LayerEvent::Sync(gcd, 0, event))?;
                 let msg = SendType::Event(0, addr, data);
                 add_layer(&mut results, gid, msg);
             } else {
+                let db = group_chat_db(&base, &gid)?;
+
                 // 1. increase the consensus height in running layer.
                 let height = state.layer.write().await.running_mut(&gcd)?.increased();
 
@@ -461,8 +458,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
 
                 // 3. broadcast event bytes.
                 let event = LayerEvent::Sync(gcd, height, event);
-                let new_data = postcard::to_allocvec(&event)
-                    .map_err(|_| new_io_error("serialize event error."))?;
+                let new_data = bincode::serialize(&event)?;
 
                 // 4. handle event.
                 handle_event(db, base, id, gid, event, &mut results).await?;
@@ -500,7 +496,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             GroupChat::close(&db, &id)?;
 
             let event = Event::MemberLeave(gid);
-            let data = postcard::to_allocvec(&LayerEvent::Sync(gcd, 0, event)).unwrap_or(vec![]);
+            let data = bincode::serialize(&LayerEvent::Sync(gcd, 0, event))?;
             let msg = SendType::Event(0, addr, data);
             add_layer(&mut results, gid, msg);
             Ok(results)
@@ -526,11 +522,11 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
                     .remove_online(&gid, &gcd)
                     .ok_or(RpcError::ParseError)?;
                 let event = Event::MemberLeave(gid);
-                let data =
-                    postcard::to_allocvec(&LayerEvent::Sync(gcd, 0, event)).unwrap_or(vec![]);
+                let data = bincode::serialize(&LayerEvent::Sync(gcd, 0, event))?;
                 let msg = SendType::Event(0, addr, data);
                 add_layer(&mut results, gid, msg);
             }
+
             Ok(results)
         },
     );

src/event.rs

@@ -132,7 +132,7 @@ impl InnerEvent {
             .map(|s| s.as_nanos())
             .unwrap_or(0);
         bytes[0..16].copy_from_slice(&datetime.to_le_bytes());
-        let data = postcard::to_allocvec(self).unwrap_or(vec![]);
+        let data = bincode::serialize(self).unwrap_or(vec![]);
         bytes[16..32].copy_from_slice(&blake3::hash(&data).as_bytes()[0..16]);
         EventId(bytes)
     }
@@ -145,7 +145,7 @@ impl InnerEvent {
         event: LayerEvent,
     ) -> Result<()> {
         let addr = layer.read().await.running(&gid)?.online_direct(&fgid)?;
-        let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+        let data = bincode::serialize(&event).unwrap_or(vec![]);
         let msg = SendType::Event(0, addr, data);
         let _ = sender.send(SendMessage::Layer(gid, fgid, msg)).await;
         Ok(())
@@ -165,7 +165,7 @@ impl InnerEvent {
             // TODO request for sync self_height + 1.
             if let Some(gid) = need_sync {
                 let event = GroupEvent::SyncRequest(our_height + 1, event_height);
-                let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+                let data = bincode::serialize(&event).unwrap_or(vec![]);
                 results.groups.push((gid, SendType::Event(0, *addr, data)));
                 return Ok((event_height, our_height, our_event));
             } else {

src/group.rs

@@ -111,7 +111,7 @@ impl Group {
                 self.hanlde_connect(&mut results, &gid, addr, data, true)?;
             }
             RecvType::Event(addr, bytes) => {
-                let event: GroupEvent = postcard::from_bytes(&bytes)
+                let event: GroupEvent = bincode::deserialize(&bytes)
                     .map_err(|_| new_io_error("serialize event error."))?;
                 return GroupEvent::handle(self, event, gid, addr, layer, uid);
             }
@@ -133,7 +133,7 @@ impl Group {
         data: Vec<u8>,
         is_connect: bool,
     ) -> Result<()> {
-        let connect = postcard::from_bytes(&data)
+        let connect = bincode::deserialize(&data)
             .map_err(|_e| new_io_error("Deserialize group connect failure"))?;
 
         let (remote_height, remote_event, others) = match connect {
@@ -502,7 +502,7 @@ impl Group {
             addr,
             None,
             None,
-            postcard::to_allocvec(&GroupConnect::Create(
+            bincode::serialize(&GroupConnect::Create(
                 proof,
                 user,
                 height,
@@ -519,7 +519,7 @@ impl Group {
         let account = self.account(gid)?;
         let height = account.height;
         let event = account.event;
-        let data = postcard::to_allocvec(&GroupConnect::Connect(height, event)).unwrap_or(vec![]);
+        let data = bincode::serialize(&GroupConnect::Connect(height, event)).unwrap_or(vec![]);
         Ok(SendType::Connect(0, addr, None, None, data))
     }
 
@@ -527,7 +527,7 @@ impl Group {
         let account = self.account(gid)?;
         let height = account.height;
         let event = account.event;
-        let data = postcard::to_allocvec(&GroupConnect::Connect(height, event)).unwrap_or(vec![]);
+        let data = bincode::serialize(&GroupConnect::Connect(height, event)).unwrap_or(vec![]);
         Ok(SendType::Result(0, addr, true, false, data))
     }
 
@@ -544,7 +544,7 @@ impl Group {
             addr,
             true,
             false,
-            postcard::to_allocvec(&GroupConnect::Create(
+            bincode::serialize(&GroupConnect::Create(
                 proof,
                 me,
                 height,
@@ -587,12 +587,12 @@ impl Group {
         };
 
         let event = GroupEvent::SyncCheck(ancestors, hashes, is_min);
-        let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+        let data = bincode::serialize(&event).unwrap_or(vec![]);
         Ok(SendType::Event(0, addr, data))
     }
 
     pub fn event_message(&self, addr: PeerAddr, event: &GroupEvent) -> Result<SendType> {
-        let data = postcard::to_allocvec(event).unwrap_or(vec![]);
+        let data = bincode::serialize(event).unwrap_or(vec![]);
         Ok(SendType::Event(0, addr, data))
     }
 
@@ -620,7 +620,7 @@ impl Group {
         drop(account);
 
         let e = GroupEvent::Event(eheight, eid, pre_event, event);
-        let data = postcard::to_allocvec(&e).unwrap_or(vec![]);
+        let data = bincode::serialize(&e).unwrap_or(vec![]);
         let running = self.running(gid)?;
         for (addr, (_id, online)) in &running.distributes {
             if *online {
@@ -638,7 +638,7 @@ impl Group {
         results: &mut HandleResult,
     ) -> Result<()> {
         let running = self.running(gid)?;
-        let data = postcard::to_allocvec(&GroupEvent::Status(event)).unwrap_or(vec![]);
+        let data = bincode::serialize(&GroupEvent::Status(event)).unwrap_or(vec![]);
         for (addr, (_id, online)) in &running.distributes {
             if *online {
                 let msg = SendType::Event(0, *addr, data.clone());
@@ -679,7 +679,7 @@ impl GroupEvent {
                     SendType::Event(
                         0,
                         addr,
-                        postcard::to_allocvec(&GroupEvent::StatusResponse(
+                        bincode::serialize(&GroupEvent::StatusResponse(
                             cpu_n,
                             mem_s,
                             swap_s,
@@ -735,7 +735,7 @@ impl GroupEvent {
 
                     if ours.len() == 0 {
                         let event = GroupEvent::SyncRequest(1, remote_height);
-                        let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+                        let data = bincode::serialize(&event).unwrap_or(vec![]);
                         results.groups.push((gid, SendType::Event(0, addr, data)));
                         return Ok(results);
                     }
@@ -773,7 +773,7 @@ impl GroupEvent {
 
                     if ancestor != 0 {
                         let event = GroupEvent::SyncRequest(ancestor, remote_height);
-                        let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+                        let data = bincode::serialize(&event).unwrap_or(vec![]);
                         results.groups.push((gid, SendType::Event(0, addr, data)));
                     } else {
                         results.groups.push((
@@ -790,7 +790,7 @@ impl GroupEvent {
                 let sync_events =
                     SyncEvent::sync(&group.base, &gid, group.account(&gid)?, from, last_to)?;
                 let event = GroupEvent::SyncResponse(from, last_to, to, sync_events);
-                let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+                let data = bincode::serialize(&event).unwrap_or(vec![]);
                 results.groups.push((gid, SendType::Event(0, addr, data)));
             }
             GroupEvent::SyncResponse(from, last_to, to, events) => {
@@ -800,7 +800,7 @@ impl GroupEvent {
                 );
                 if last_to < to {
                     let event = GroupEvent::SyncRequest(last_to + 1, to);
-                    let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+                    let data = bincode::serialize(&event).unwrap_or(vec![]);
                     results.groups.push((gid, SendType::Event(0, addr, data)));
                 }
                 SyncEvent::handle(gid, from, last_to, events, group, layer, &mut results, addr)?;

src/rpc.rs

@@ -396,7 +396,7 @@ fn new_rpc_handler(
             for gid in keys {
                 for (fgid, addr) in layer_lock.running(&gid)?.onlines() {
                     // send a event that is offline.
-                    let data = postcard::to_allocvec(&LayerEvent::Offline(*fgid)).unwrap_or(vec![]);
+                    let data = bincode::serialize(&LayerEvent::Offline(*fgid))?;
                     let msg = SendType::Event(0, *addr, data);
                     results.layers.push((gid, *fgid, msg));
                 }
@@ -451,7 +451,7 @@ fn new_rpc_handler(
             let layer_lock = state.layer.read().await;
             for (fgid, addr) in layer_lock.running(&gid)?.onlines() {
                 // send a event that is offline.
-                let data = postcard::to_allocvec(&LayerEvent::Offline(*fgid)).unwrap_or(vec![]);
+                let data = bincode::serialize(&LayerEvent::Offline(*fgid))?;
                 let msg = SendType::Event(0, *addr, data);
                 results.layers.push((gid, *fgid, msg));
             }
@@ -534,7 +534,7 @@ fn new_rpc_handler(
             let msg = match s.s_type {
                 SessionType::Chat | SessionType::Group => {
                     let event = LayerEvent::Suspend(s.gid);
-                    let data = postcard::to_allocvec(&event).unwrap_or(vec![]);
+                    let data = bincode::serialize(&event)?;
                     SendType::Event(0, s.addr, data)
                 }
                 _ => {