pimhwang
/
ESSE
mirror of https://github.com/CympleTech/ESSE.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

rename group to own for distributed

pull/24/head
Sun 3 years ago
parent
559a437971
commit
cf5bc0b5e9
22 changed files with 159 additions and 151 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/apps.rs
  2. 18
      src/apps/chat/layer.rs
  3. 38
      src/apps/chat/rpc.rs
  4. 12
      src/apps/dao/rpc.rs
  5. 10
      src/apps/device/rpc.rs
  6. 2
      src/apps/domain/layer.rs
  7. 12
      src/apps/domain/rpc.rs
  8. 16
      src/apps/file/rpc.rs
  9. 8
      src/apps/group/layer.rs
  10. 14
      src/apps/group/rpc.rs
  11. 6
      src/apps/jarvis/rpc.rs
  12. 24
      src/apps/wallet/rpc.rs
  13. 2
      src/daemon.rs
  14. 8
      src/event.rs
  15. 10
      src/global.rs
  16. 2
      src/layer.rs
  17. 2
      src/lib.rs
  18. 74
      src/own.rs
  19. 0
      src/own/consensus.rs
  20. 0
      src/own/running.rs
  21. 32
      src/rpc.rs
  22. 18
      src/server.rs

2
src/apps.rs
Unescape View File

@ -63,7 +63,7 @@ pub(crate) async fn app_layer_handle(
let mut delete: HashMap<GroupChatId, Vec<usize>> = HashMap::new(); let mut delete: HashMap<GroupChatId, Vec<usize>> = HashMap::new();
let pid = global.pid().await; let pid = global.pid().await;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = group_db(&global.base, &pid, &db_key)?; let db = group_db(&global.base, &pid, &db_key)?;
for (gid, session) in &layer.groups { for (gid, session) in &layer.groups {

18
src/apps/chat/layer.rs
Unescape View File

@ -87,7 +87,7 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
results.layers.push((ESSE_ID, msg)); results.layers.push((ESSE_ID, msg));
} }
} else { } else {
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
let friend = Friend::get_id(&db, &peer.id)?; let friend = Friend::get_id(&db, &peer.id)?;
results.rpcs.push(rpc::friend_close(friend.id)); results.rpcs.push(rpc::friend_close(friend.id));
@ -101,7 +101,7 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
let mut layer = global.layer.write().await; let mut layer = global.layer.write().await;
let id = layer.delivery.remove(&tid).ok_or(anyhow!("delivery err"))?; let id = layer.delivery.remove(&tid).ok_or(anyhow!("delivery err"))?;
drop(layer); drop(layer);
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
let resp = match t { let resp = match t {
DeliveryType::Event => { DeliveryType::Event => {
@ -137,7 +137,7 @@ async fn handle_connect(
global: &Arc<Global>, global: &Arc<Global>,
results: &mut HandleResult, results: &mut HandleResult,
) -> Result<u64> { ) -> Result<u64> {
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
// 1. check friendship. // 1. check friendship.
@ -194,7 +194,7 @@ impl LayerEvent {
results.rpcs.push(session_connect(&sid, &fpid)); results.rpcs.push(session_connect(&sid, &fpid));
} }
LayerEvent::Request(name, remark) => { LayerEvent::Request(name, remark) => {
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
if Friend::get_id(&db, &fpid).is_err() { if Friend::get_id(&db, &fpid).is_err() {
@ -218,7 +218,7 @@ impl LayerEvent {
} }
} }
LayerEvent::Agree => { LayerEvent::Agree => {
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
// 1. check friendship. // 1. check friendship.
@ -248,7 +248,7 @@ impl LayerEvent {
} }
} }
LayerEvent::Reject => { LayerEvent::Reject => {
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
if let Ok(mut request) = Request::get_id(&db, &fpid) { if let Ok(mut request) = Request::get_id(&db, &fpid) {
@ -260,7 +260,7 @@ impl LayerEvent {
} }
LayerEvent::Message(hash, m) => { LayerEvent::Message(hash, m) => {
let (_sid, fid) = global.layer.read().await.chat_session(&fpid)?; let (_sid, fid) = global.layer.read().await.chat_session(&fpid)?;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
if !Message::exist(&db, &hash)? { if !Message::exist(&db, &hash)? {
@ -303,7 +303,7 @@ impl LayerEvent {
} }
LayerEvent::InfoRes(remote) => { LayerEvent::InfoRes(remote) => {
let (sid, fid) = global.layer.read().await.chat_session(&fpid)?; let (sid, fid) = global.layer.read().await.chat_session(&fpid)?;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
let mut f = Friend::get(&db, &fid)?; let mut f = Friend::get(&db, &fid)?;
@ -329,7 +329,7 @@ impl LayerEvent {
let keep = layer.is_addr_online(&fpid); let keep = layer.is_addr_online(&fpid);
drop(layer); drop(layer);
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = chat_db(&global.base, &pid, &db_key)?; let db = chat_db(&global.base, &pid, &db_key)?;
Friend::id_close(&db, fid)?; Friend::id_close(&db, fid)?;

38
src/apps/chat/rpc.rs
Unescape View File

@ -112,7 +112,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let need_online = params[0].as_bool().ok_or(RpcError::ParseError)?; let need_online = params[0].as_bool().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let friends = Friend::list(&db)?; let friends = Friend::list(&db)?;
@ -143,7 +143,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let mut f = Friend::get(&db, &id)?; let mut f = Friend::get(&db, &id)?;
@ -151,7 +151,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
f.me_update(&db)?; f.me_update(&db)?;
drop(db); drop(db);
// state.group.write().await.broadcast( // state.own.write().await.broadcast(
// &gid, // &gid,
// InnerEvent::SessionFriendUpdate(f.gid, f.remark), // InnerEvent::SessionFriendUpdate(f.gid, f.remark),
// FRIEND_TABLE_PATH, // FRIEND_TABLE_PATH,
@ -170,7 +170,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let friend = Friend::get(&db, &id)?; let friend = Friend::get(&db, &id)?;
@ -189,7 +189,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
.push((ESSE_ID, SendType::Disconnect(friend.pid))); .push((ESSE_ID, SendType::Disconnect(friend.pid)));
} }
// state.group.write().await.broadcast( // state.own.write().await.broadcast(
// &gid, // &gid,
// InnerEvent::SessionFriendClose(friend.gid), // InnerEvent::SessionFriendClose(friend.gid),
// FRIEND_TABLE_PATH, // FRIEND_TABLE_PATH,
@ -208,7 +208,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let friend = Friend::get(&db, &id)?; let friend = Friend::get(&db, &id)?;
@ -229,7 +229,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
.push((ESSE_ID, SendType::Disconnect(friend.pid))); .push((ESSE_ID, SendType::Disconnect(friend.pid)));
} }
// state.group.write().await.broadcast( // state.own.write().await.broadcast(
// &gid, // &gid,
// InnerEvent::SessionFriendDelete(friend.gid), // InnerEvent::SessionFriendDelete(friend.gid),
// FRIEND_TABLE_PATH, // FRIEND_TABLE_PATH,
@ -245,7 +245,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
"chat-request-list", "chat-request-list",
|_params: Vec<RpcParam>, state: Arc<Global>| async move { |_params: Vec<RpcParam>, state: Arc<Global>| async move {
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let requests = Request::list(&db)?; let requests = Request::list(&db)?;
drop(db); drop(db);
@ -261,7 +261,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let remark = params[2].as_str().ok_or(RpcError::ParseError)?.to_string(); let remark = params[2].as_str().ok_or(RpcError::ParseError)?.to_string();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
if Friend::is_friend(&db, &remote_pid)? { if Friend::is_friend(&db, &remote_pid)? {
@ -281,7 +281,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::rpc(json!(request.to_rpc())); let mut results = HandleResult::rpc(json!(request.to_rpc()));
let name = state.group.read().await.account(&pid)?.name.clone(); let name = state.own.read().await.account(&pid)?.name.clone();
let req = LayerEvent::Request(name, request.remark); let req = LayerEvent::Request(name, request.remark);
let data = bincode::serialize(&req).unwrap_or(vec![]); let data = bincode::serialize(&req).unwrap_or(vec![]);
let msg = SendType::Event(0, request.pid, data); let msg = SendType::Event(0, request.pid, data);
@ -298,7 +298,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let mut request = Request::get(&db, &id)?; let mut request = Request::get(&db, &id)?;
@ -344,7 +344,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let mut req = Request::get(&db, &id)?; let mut req = Request::get(&db, &id)?;
@ -357,7 +357,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let msg = SendType::Event(0, req.pid, data); let msg = SendType::Event(0, req.pid, data);
let mut results = HandleResult::layer(ESSE_ID, msg); let mut results = HandleResult::layer(ESSE_ID, msg);
// state.group.write().await.broadcast( // state.own.write().await.broadcast(
// &gid, // &gid,
// InnerEvent::SessionRequestHandle(req.gid, false, vec![]), // InnerEvent::SessionRequestHandle(req.gid, false, vec![]),
// REQUEST_TABLE_PATH, // REQUEST_TABLE_PATH,
@ -374,7 +374,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let req = Request::get(&db, &id)?; let req = Request::get(&db, &id)?;
@ -387,7 +387,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
drop(db); drop(db);
let results = HandleResult::new(); let results = HandleResult::new();
// state.group.write().await.broadcast( // state.own.write().await.broadcast(
// &gid, // &gid,
// InnerEvent::SessionRequestDelete(req.gid), // InnerEvent::SessionRequestDelete(req.gid),
// REQUEST_TABLE_PATH, // REQUEST_TABLE_PATH,
@ -404,7 +404,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let friend = Friend::get(&db, &id)?; let friend = Friend::get(&db, &id)?;
@ -421,7 +421,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let fid = params[0].as_i64().ok_or(RpcError::ParseError)?; let fid = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let messages = Message::get_by_fid(&db, &fid)?; let messages = Message::get_by_fid(&db, &fid)?;
@ -439,7 +439,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let content = params[3].as_str().ok_or(RpcError::ParseError)?; let content = params[3].as_str().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let (nm, raw) = let (nm, raw) =
@ -470,7 +470,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = chat_db(&state.base, &pid, &db_key)?; let db = chat_db(&state.base, &pid, &db_key)?;
let msg = Message::get(&db, &id)?; let msg = Message::get(&db, &id)?;

12
src/apps/dao/rpc.rs
Unescape View File

@ -274,7 +274,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
let _ = write_avatar(&base, &gid, &gcd, &avatar_bytes).await; let _ = write_avatar(&base, &gid, &gcd, &avatar_bytes).await;
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let me = state.group.read().await.clone_user(&gid)?; let me = state.own.read().await.clone_user(&gid)?;
// add to rpcs. // add to rpcs.
results.rpcs.push(json!(gc.to_rpc())); results.rpcs.push(json!(gc.to_rpc()));
@ -343,8 +343,8 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
drop(db); drop(db);
// load avatar // load avatar
let avatar = read_avatar(state.group.read().await.base(), &gid, &gc.g_id).await?; let avatar = read_avatar(state.own.read().await.base(), &gid, &gc.g_id).await?;
let owner_avatar = state.group.read().await.clone_user(&gid)?.avatar; let owner_avatar = state.own.read().await.clone_user(&gid)?.avatar;
let addr = gc.g_addr; let addr = gc.g_addr;
let info = gc.to_group_info(mname, avatar, owner_avatar); let info = gc.to_group_info(mname, avatar, owner_avatar);
@ -389,7 +389,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
} }
drop(db); drop(db);
let me = state.group.read().await.clone_user(&gid)?; let me = state.own.read().await.clone_user(&gid)?;
let join_proof = match gtype { let join_proof = match gtype {
GroupType::Encrypted => { GroupType::Encrypted => {
// remark is inviter did. // remark is inviter did.
@ -424,7 +424,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
.filter_map(|v| v.as_i64()) .filter_map(|v| v.as_i64())
.collect(); .collect();
let group_lock = state.group.read().await; let group_lock = state.own.read().await;
let base = group_lock.base().clone(); let base = group_lock.base().clone();
let chat = chat_db(&base, &gid)?; let chat = chat_db(&base, &gid)?;
@ -533,7 +533,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
let addr = state.layer.read().await.running(&gid)?.online(&gcd)?; let addr = state.layer.read().await.running(&gid)?.online(&gcd)?;
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let base = state.group.read().await.base().clone(); let base = state.own.read().await.base().clone();
let (nmsg, datetime) = to_network_message(&base, &gid, m_type, m_content).await?; let (nmsg, datetime) = to_network_message(&base, &gid, m_type, m_content).await?;
let event = Event::MessageCreate(gid, nmsg, datetime); let event = Event::MessageCreate(gid, nmsg, datetime);
let data = bincode::serialize(&LayerEvent::Sync(gcd, 0, event))?; let data = bincode::serialize(&LayerEvent::Sync(gcd, 0, event))?;

10
src/apps/device/rpc.rs
Unescape View File

@ -5,7 +5,7 @@ use tdn::types::{
}; };
use crate::global::Global; use crate::global::Global;
//use crate::group::GroupEvent; //use crate::own::OwnEvent;
use crate::utils::device_status::device_status as local_device_status; use crate::utils::device_status::device_status as local_device_status;
use super::Device; use super::Device;
@ -66,7 +66,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
handler.add_method( handler.add_method(
"device-list", "device-list",
|_params: Vec<RpcParam>, state: Arc<Global>| async move { |_params: Vec<RpcParam>, state: Arc<Global>| async move {
let devices = &state.group.read().await.distributes; let devices = &state.own.read().await.distributes;
Ok(HandleResult::rpc(device_list(devices))) Ok(HandleResult::rpc(device_list(devices)))
}, },
); );
@ -76,7 +76,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
|params: Vec<RpcParam>, state: Arc<Global>| async move { |params: Vec<RpcParam>, state: Arc<Global>| async move {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let group_lock = state.group.read().await; let group_lock = state.own.read().await;
if id == group_lock.device()?.id { if id == group_lock.device()?.id {
let uptime = group_lock.uptime; let uptime = group_lock.uptime;
let (cpu, memory, swap, disk, cpu_p, memory_p, swap_p, disk_p) = let (cpu, memory, swap, disk, cpu_p, memory_p, swap_p, disk_p) =
@ -87,7 +87,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
} }
drop(group_lock); drop(group_lock);
//let msg = state.group.write().await.event_message(addr, &GroupEvent::StatusRequest)?; //let msg = state.own.write().await.event_message(addr, &OwnEvent::StatusRequest)?;
//Ok(HandleResult::group(msg)) //Ok(HandleResult::group(msg))
Ok(HandleResult::new()) Ok(HandleResult::new())
}, },
@ -96,7 +96,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
handler.add_method( handler.add_method(
"device-search", "device-search",
|_params: Vec<RpcParam>, state: Arc<Global>| async move { |_params: Vec<RpcParam>, state: Arc<Global>| async move {
//let msg = state.group.read().await.create_message(&gid, Peer::peer(addr))?; //let msg = state.own.read().await.create_message(&gid, Peer::peer(addr))?;
//Ok(HandleResult::group(gid, msg)) //Ok(HandleResult::group(gid, msg))
Ok(HandleResult::new()) Ok(HandleResult::new())
}, },

2
src/apps/domain/layer.rs
Unescape View File

@ -27,7 +27,7 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
let event: LayerServerEvent = bincode::deserialize(&bytes)?; let event: LayerServerEvent = bincode::deserialize(&bytes)?;
let pid = global.pid().await; let pid = global.pid().await;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = domain_db(&global.base, &pid, &db_key)?; let db = domain_db(&global.base, &pid, &db_key)?;
match event { match event {

12
src/apps/domain/rpc.rs
Unescape View File

@ -62,7 +62,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
"domain-list", "domain-list",
|_params: Vec<RpcParam>, state: Arc<Global>| async move { |_params: Vec<RpcParam>, state: Arc<Global>| async move {
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = domain_db(&state.base, &pid, &db_key)?; let db = domain_db(&state.base, &pid, &db_key)?;
// list providers. // list providers.
@ -83,7 +83,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = domain_db(&state.base, &pid, &db_key)?; let db = domain_db(&state.base, &pid, &db_key)?;
let mut p = Provider::prepare(provider); let mut p = Provider::prepare(provider);
@ -102,7 +102,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = domain_db(&state.base, &pid, &db_key)?; let db = domain_db(&state.base, &pid, &db_key)?;
let provider = Provider::get(&db, &id)?; let provider = Provider::get(&db, &id)?;
@ -124,7 +124,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = domain_db(&state.base, &pid, &db_key)?; let db = domain_db(&state.base, &pid, &db_key)?;
let names = Name::get_by_provider(&db, &id)?; let names = Name::get_by_provider(&db, &id)?;
@ -147,10 +147,10 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
// save to db. // save to db.
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = domain_db(&state.base, &pid, &db_key)?; let db = domain_db(&state.base, &pid, &db_key)?;
let me = state.group.read().await.clone_user(&pid)?; let me = state.own.read().await.clone_user(&pid)?;
let mut u = Name::prepare(name, bio, provider); let mut u = Name::prepare(name, bio, provider);
u.insert(&db)?; u.insert(&db)?;

16
src/apps/file/rpc.rs
Unescape View File

@ -22,7 +22,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let parent = params[1].as_i64().ok_or(RpcError::ParseError)?; let parent = params[1].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
let files: Vec<RpcParam> = File::list(&db, &root, &parent)? let files: Vec<RpcParam> = File::list(&db, &root, &parent)?
@ -42,7 +42,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let name = params[2].as_str().ok_or(RpcError::ParseError)?.to_owned(); let name = params[2].as_str().ok_or(RpcError::ParseError)?.to_owned();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
// genereate new file. // genereate new file.
@ -71,7 +71,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
.to_owned(); .to_owned();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
let mut file = File::generate(root, parent, name); let mut file = File::generate(root, parent, name);
@ -91,7 +91,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
// create new folder. // create new folder.
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
let mut file = File::generate(root, parent, name); let mut file = File::generate(root, parent, name);
@ -110,7 +110,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let name = params[3].as_str().ok_or(RpcError::ParseError)?.to_owned(); let name = params[3].as_str().ok_or(RpcError::ParseError)?.to_owned();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
let mut file = File::get(&db, &id)?; let mut file = File::get(&db, &id)?;
@ -130,7 +130,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let starred = params[1].as_bool().ok_or(RpcError::ParseError)?; let starred = params[1].as_bool().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
File::star(&db, &id, starred)?; File::star(&db, &id, starred)?;
@ -144,7 +144,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
// TODO trash a directory. // TODO trash a directory.
@ -160,7 +160,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = file_db(&state.base, &pid, &db_key)?; let db = file_db(&state.base, &pid, &db_key)?;
// TODO deleted file & directory. // TODO deleted file & directory.

8
src/apps/group/layer.rs
Unescape View File

@ -51,7 +51,7 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
let gid: GroupChatId = bincode::deserialize(&data)?; let gid: GroupChatId = bincode::deserialize(&data)?;
let pid = global.pid().await; let pid = global.pid().await;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = group_db(&global.base, &pid, &db_key)?; let db = group_db(&global.base, &pid, &db_key)?;
let s_db = session_db(&global.base, &pid, &db_key)?; let s_db = session_db(&global.base, &pid, &db_key)?;
@ -94,7 +94,7 @@ async fn handle_connect(
let (height, _, id, _) = global.layer.read().await.group(&gid)?.info(); let (height, _, id, _) = global.layer.read().await.group(&gid)?.info();
let pid = global.pid().await; let pid = global.pid().await;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = group_db(&global.base, &pid, &db_key)?; let db = group_db(&global.base, &pid, &db_key)?;
// check is member. // check is member.
@ -124,7 +124,7 @@ async fn handle_result(
let LayerResult(gid, name, height) = bincode::deserialize(&data)?; let LayerResult(gid, name, height) = bincode::deserialize(&data)?;
let pid = global.pid().await; let pid = global.pid().await;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = group_db(&global.base, &pid, &db_key)?; let db = group_db(&global.base, &pid, &db_key)?;
let s_db = session_db(&global.base, &pid, &db_key)?; let s_db = session_db(&global.base, &pid, &db_key)?;
@ -184,7 +184,7 @@ async fn handle_event(
let gid = event.gid(); let gid = event.gid();
let (height, sid, id, gaddr) = global.layer.read().await.group(&gid)?.info(); let (height, sid, id, gaddr) = global.layer.read().await.group(&gid)?.info();
let pid = global.pid().await; let pid = global.pid().await;
let db_key = global.group.read().await.db_key(&pid)?; let db_key = global.own.read().await.db_key(&pid)?;
let db = group_db(&global.base, &pid, &db_key)?; let db = group_db(&global.base, &pid, &db_key)?;
let is_server = gaddr == pid; let is_server = gaddr == pid;
if !is_server && gaddr != addr { if !is_server && gaddr != addr {

14
src/apps/group/rpc.rs
Unescape View File

@ -76,7 +76,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
"group-list", "group-list",
|_params: Vec<RpcParam>, state: Arc<Global>| async move { |_params: Vec<RpcParam>, state: Arc<Global>| async move {
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = group_db(&state.base, &pid, &db_key)?; let db = group_db(&state.base, &pid, &db_key)?;
Ok(HandleResult::rpc(group_list(GroupChat::all(&db)?))) Ok(HandleResult::rpc(group_list(GroupChat::all(&db)?)))
@ -89,7 +89,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = group_db(&state.base, &pid, &db_key)?; let db = group_db(&state.base, &pid, &db_key)?;
let group = GroupChat::get(&db, &id)?; let group = GroupChat::get(&db, &id)?;
let members = Member::list(&db, &id)?; let members = Member::list(&db, &id)?;
@ -104,7 +104,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let name = params[0].as_str().ok_or(RpcError::ParseError)?.to_owned(); let name = params[0].as_str().ok_or(RpcError::ParseError)?.to_owned();
let pid = state.pid().await; let pid = state.pid().await;
let group_lock = state.group.read().await; let group_lock = state.own.read().await;
let db_key = group_lock.db_key(&pid)?; let db_key = group_lock.db_key(&pid)?;
let me = group_lock.clone_user(&pid)?; let me = group_lock.clone_user(&pid)?;
drop(group_lock); drop(group_lock);
@ -157,7 +157,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let fid = params[1].as_i64().ok_or(RpcError::ParseError)?; let fid = params[1].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let group_db = group_db(&state.base, &pid, &db_key)?; let group_db = group_db(&state.base, &pid, &db_key)?;
let chat_db = chat_db(&state.base, &pid, &db_key)?; let chat_db = chat_db(&state.base, &pid, &db_key)?;
let s_db = session_db(&state.base, &pid, &db_key)?; let s_db = session_db(&state.base, &pid, &db_key)?;
@ -220,7 +220,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let m_content = params[2].as_str().ok_or(RpcError::ParseError)?; let m_content = params[2].as_str().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = group_db(&state.base, &pid, &db_key)?; let db = group_db(&state.base, &pid, &db_key)?;
let s_db = session_db(&state.base, &pid, &db_key)?; let s_db = session_db(&state.base, &pid, &db_key)?;
@ -267,7 +267,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = group_db(&state.base, &pid, &db_key)?; let db = group_db(&state.base, &pid, &db_key)?;
let s_db = session_db(&state.base, &pid, &db_key)?; let s_db = session_db(&state.base, &pid, &db_key)?;
@ -299,7 +299,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = group_db(&state.base, &pid, &db_key)?; let db = group_db(&state.base, &pid, &db_key)?;
let s_db = session_db(&state.base, &pid, &db_key)?; let s_db = session_db(&state.base, &pid, &db_key)?;

6
src/apps/jarvis/rpc.rs
Unescape View File

@ -51,7 +51,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
"jarvis-list", "jarvis-list",
|_params: Vec<RpcParam>, state: Arc<Global>| async move { |_params: Vec<RpcParam>, state: Arc<Global>| async move {
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = jarvis_db(&state.base, &pid, &db_key)?; let db = jarvis_db(&state.base, &pid, &db_key)?;
let devices = Message::list(&db)?; let devices = Message::list(&db)?;
db.close()?; db.close()?;
@ -71,7 +71,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let content = params[2].as_str().ok_or(RpcError::ParseError)?; let content = params[2].as_str().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = jarvis_db(&state.base, &pid, &db_key)?; let db = jarvis_db(&state.base, &pid, &db_key)?;
let (_, raw) = let (_, raw) =
@ -91,7 +91,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
|params: Vec<RpcParam>, state: Arc<Global>| async move { |params: Vec<RpcParam>, state: Arc<Global>| async move {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = jarvis_db(&state.base, &pid, &db_key)?; let db = jarvis_db(&state.base, &pid, &db_key)?;
Message::delete(&db, id)?; Message::delete(&db, id)?;
db.close()?; db.close()?;

24
src/apps/wallet/rpc.rs
Unescape View File

@ -320,7 +320,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
"wallet-list", "wallet-list",
|_params: Vec<RpcParam>, state: Arc<Global>| async move { |_params: Vec<RpcParam>, state: Arc<Global>| async move {
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = wallet_db(&state.base, &pid, &db_key)?; let db = wallet_db(&state.base, &pid, &db_key)?;
let addresses = Address::list(&db)?; let addresses = Address::list(&db)?;
@ -335,10 +335,10 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let lock = params[1].as_str().ok_or(RpcError::ParseError)?; let lock = params[1].as_str().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = wallet_db(&state.base, &pid, &db_key)?; let db = wallet_db(&state.base, &pid, &db_key)?;
let group_lock = state.group.read().await; let group_lock = state.own.read().await;
let mnemonic = group_lock.mnemonic(&pid, lock, &state.secret)?; let mnemonic = group_lock.mnemonic(&pid, lock, &state.secret)?;
let account = group_lock.account(&pid)?; let account = group_lock.account(&pid)?;
let lang = account.lang(); let lang = account.lang();
@ -371,7 +371,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
results.rpcs.push(address.to_rpc()); results.rpcs.push(address.to_rpc());
if address.main { if address.main {
let a_db = account_db(&state.base, &state.secret)?; let a_db = account_db(&state.base, &state.secret)?;
let mut group_lock = state.group.write().await; let mut group_lock = state.own.write().await;
let account = group_lock.account_mut(&pid)?; let account = group_lock.account_mut(&pid)?;
account.wallet = address.chain.update_main(&address.address, &account.wallet); account.wallet = address.chain.update_main(&address.address, &account.wallet);
account.pub_height = account.pub_height + 1; account.pub_height = account.pub_height + 1;
@ -398,7 +398,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let pid = state.pid().await; let pid = state.pid().await;
let group_lock = state.group.read().await; let group_lock = state.own.read().await;
let ckey = &group_lock.account(&pid)?.encrypt; let ckey = &group_lock.account(&pid)?.encrypt;
let db_key = group_lock.db_key(&pid)?; let db_key = group_lock.db_key(&pid)?;
let cbytes = encrypt(&state.secret, lock, ckey, sk.as_ref())?; let cbytes = encrypt(&state.secret, lock, ckey, sk.as_ref())?;
@ -419,7 +419,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let address = params[1].as_str().ok_or(RpcError::ParseError)?.to_owned(); let address = params[1].as_str().ok_or(RpcError::ParseError)?.to_owned();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = wallet_db(&state.base, &pid, &db_key)?; let db = wallet_db(&state.base, &pid, &db_key)?;
let c_str = if params.len() == 4 { let c_str = if params.len() == 4 {
@ -445,7 +445,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let c = params[3].as_str().ok_or(RpcError::ParseError)?.to_owned(); let c = params[3].as_str().ok_or(RpcError::ParseError)?.to_owned();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = wallet_db(&state.base, &pid, &db_key)?; let db = wallet_db(&state.base, &pid, &db_key)?;
tokio::spawn(token_check(state.rpc_send.clone(), db, chain, net, addr, c)); tokio::spawn(token_check(state.rpc_send.clone(), db, chain, net, addr, c));
@ -480,7 +480,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let lock = params[6].as_str().ok_or(RpcError::ParseError)?; let lock = params[6].as_str().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let group_lock = state.group.read().await; let group_lock = state.own.read().await;
if !group_lock.check_lock(&pid, &lock) { if !group_lock.check_lock(&pid, &lock) {
return Err(RpcError::Custom("Lock is invalid!".to_owned())); return Err(RpcError::Custom("Lock is invalid!".to_owned()));
} }
@ -560,7 +560,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let token = params[1].as_i64().ok_or(RpcError::ParseError)?; let token = params[1].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = wallet_db(&state.base, &pid, &db_key)?; let db = wallet_db(&state.base, &pid, &db_key)?;
let nfts = Balance::list(&db, &address, &token)?; let nfts = Balance::list(&db, &address, &token)?;
@ -580,7 +580,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let hash = params[2].as_str().ok_or(RpcError::ParseError)?.to_owned(); let hash = params[2].as_str().ok_or(RpcError::ParseError)?.to_owned();
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = wallet_db(&state.base, &pid, &db_key)?; let db = wallet_db(&state.base, &pid, &db_key)?;
let t = Token::get(&db, &token)?; let t = Token::get(&db, &token)?;
let a = Address::get(&db, &address)?; let a = Address::get(&db, &address)?;
@ -608,7 +608,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = wallet_db(&state.base, &pid, &db_key)?; let db = wallet_db(&state.base, &pid, &db_key)?;
let a_db = account_db(&state.base, &state.secret)?; let a_db = account_db(&state.base, &state.secret)?;
@ -617,7 +617,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<Global>) {
let mut results = HandleResult::new(); let mut results = HandleResult::new();
let mut group_lock = state.group.write().await; let mut group_lock = state.own.write().await;
let account = group_lock.account_mut(&pid)?; let account = group_lock.account_mut(&pid)?;
account.wallet = address.chain.update_main(&address.address, &account.wallet); account.wallet = address.chain.update_main(&address.address, &account.wallet);
account.pub_height = account.pub_height + 1; account.pub_height = account.pub_height + 1;

2
src/daemon.rs
Unescape View File

@ -11,9 +11,9 @@ mod apps;
//mod consensus; //mod consensus;
//mod event; //mod event;
mod global; mod global;
mod group;
mod layer; mod layer;
mod migrate; mod migrate;
mod own;
mod primitives; mod primitives;
mod rpc; mod rpc;
mod server; mod server;

8
src/event.rs
Unescape View File

@ -15,11 +15,11 @@ use tokio::sync::{mpsc::Sender, RwLock};
use crate::account::{Account, User}; use crate::account::{Account, User};
use crate::apps::chat::LayerEvent; use crate::apps::chat::LayerEvent;
use crate::consensus::Event as OldEvent; use crate::consensus::Event as OldEvent;
use crate::group::{Group, GroupEvent};
use crate::layer::Layer; use crate::layer::Layer;
use crate::migrate::consensus::{ use crate::migrate::consensus::{
ACCOUNT_TABLE_PATH, FILE_TABLE_PATH, FRIEND_TABLE_PATH, MESSAGE_TABLE_PATH, REQUEST_TABLE_PATH, ACCOUNT_TABLE_PATH, FILE_TABLE_PATH, FRIEND_TABLE_PATH, MESSAGE_TABLE_PATH, REQUEST_TABLE_PATH,
}; };
use crate::own::{Own, OwnEvent};
use crate::apps::chat::rpc as chat_rpc; use crate::apps::chat::rpc as chat_rpc;
use crate::apps::chat::{from_model, Friend, Message, Request}; use crate::apps::chat::{from_model, Friend, Message, Request};
@ -33,14 +33,14 @@ pub(crate) enum State {
Account, Account,
Session, Session,
ChatMessage, ChatMessage,
GroupMessage, OwnMessage,
} }
pub(crate) async fn _handle_state( pub(crate) async fn _handle_state(
_gid: GroupId, _gid: GroupId,
_addr: PeerId, _addr: PeerId,
state: State, state: State,
_group: &Arc<RwLock<Group>>, _group: &Arc<RwLock<Own>>,
_layer: &Arc<RwLock<Layer>>, _layer: &Arc<RwLock<Layer>>,
_results: &mut HandleResult, _results: &mut HandleResult,
) -> Result<()> { ) -> Result<()> {
@ -48,7 +48,7 @@ pub(crate) async fn _handle_state(
State::Account => {} State::Account => {}
State::Session => {} State::Session => {}
State::ChatMessage => {} State::ChatMessage => {}
State::GroupMessage => {} State::OwnMessage => {}
} }
Ok(()) Ok(())
} }

10
src/global.rs
Unescape View File

@ -7,8 +7,8 @@ use tdn::{
use tokio::{sync::mpsc::Sender, sync::RwLock}; use tokio::{sync::mpsc::Sender, sync::RwLock};
use crate::account::Account; use crate::account::Account;
use crate::group::Group;
use crate::layer::Layer; use crate::layer::Layer;
use crate::own::Own;
/// global status. /// global status.
pub(crate) struct Global { pub(crate) struct Global {
@ -18,8 +18,8 @@ pub(crate) struct Global {
pub peer_pub_height: RwLock<u64>, pub peer_pub_height: RwLock<u64>,
/// current account own height. /// current account own height.
pub peer_own_height: RwLock<u64>, pub peer_own_height: RwLock<u64>,
/// current group. /// current own.
pub group: RwLock<Group>, pub own: RwLock<Own>,
/// current layer. /// current layer.
pub layer: RwLock<Layer>, pub layer: RwLock<Layer>,
/// message delivery tracking. uuid, me_gid, db_id. /// message delivery tracking. uuid, me_gid, db_id.
@ -61,7 +61,7 @@ impl Global {
peer_id: RwLock::new(PeerId::default()), peer_id: RwLock::new(PeerId::default()),
peer_pub_height: RwLock::new(0), peer_pub_height: RwLock::new(0),
peer_own_height: RwLock::new(0), peer_own_height: RwLock::new(0),
group: RwLock::new(Group::init(accounts)), own: RwLock::new(Own::init(accounts)),
layer: RwLock::new(Layer::init()), layer: RwLock::new(Layer::init()),
p2p_send: RwLock::new(None), p2p_send: RwLock::new(None),
_delivery: RwLock::new(HashMap::new()), _delivery: RwLock::new(HashMap::new()),
@ -104,7 +104,7 @@ impl Global {
} }
let (pheight, oheight) = let (pheight, oheight) =
self.group self.own
.write() .write()
.await .await
.reset(pid, lock, &self.base, &self.secret)?; .reset(pid, lock, &self.base, &self.secret)?;

2
src/layer.rs
Unescape View File

@ -13,7 +13,7 @@ use tokio::sync::RwLock;
use crate::account::User; use crate::account::User;
use crate::apps::chat::LayerEvent as ChatLayerEvent; use crate::apps::chat::LayerEvent as ChatLayerEvent;
//use crate::apps::group::{group_conn, GROUP_ID}; //use crate::apps::group::{group_conn, GROUP_ID};
use crate::group::Group; use crate::own::Own;
use crate::session::{Session, SessionType}; use crate::session::{Session, SessionType};
/// ESSE layers. /// ESSE layers.

2
src/lib.rs
Unescape View File

@ -12,9 +12,9 @@ mod apps;
//mod consensus; //mod consensus;
//mod event; //mod event;
mod global; mod global;
mod group;
mod layer; mod layer;
mod migrate; mod migrate;
mod own;
mod primitives; mod primitives;
mod rpc; mod rpc;
mod server; mod server;

74
src/group.rs → src/own.rs
Unescape View File

@ -24,8 +24,8 @@ use crate::storage::{account_db, account_init, consensus_db, wallet_db, write_av
use crate::utils::crypto::{decrypt, encrypt}; use crate::utils::crypto::{decrypt, encrypt};
use crate::utils::device_status::{device_info, device_status as local_device_status}; use crate::utils::device_status::{device_info, device_status as local_device_status};
/// Esse group. /// ESSE own distributed accounts.
pub(crate) struct Group { pub(crate) struct Own {
/// all accounts. /// all accounts.
pub accounts: HashMap<PeerId, Account>, pub accounts: HashMap<PeerId, Account>,
/// current account secret keypair. /// current account secret keypair.
@ -38,7 +38,7 @@ pub(crate) struct Group {
/// Request for make distributed. /// Request for make distributed.
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
enum GroupConnect { enum OwnConnect {
/// Params: User, consensus height, event_id, remote_name, remote_info, other_devices addr. /// Params: User, consensus height, event_id, remote_name, remote_info, other_devices addr.
Create(User, u64, EventId, String, String, Vec<PeerId>), Create(User, u64, EventId, String, String, Vec<PeerId>),
/// connected. /// connected.
@ -47,7 +47,7 @@ enum GroupConnect {
/// Esse group's Event. /// Esse group's Event.
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
pub(crate) enum GroupEvent { pub(crate) enum OwnEvent {
/// Sync event. /// Sync event.
Event(u64, EventId, EventId), Event(u64, EventId, EventId),
//Event(u64, EventId, EventId, InnerEvent), //Event(u64, EventId, EventId, InnerEvent),
@ -97,8 +97,8 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
//self.hanlde_connect(&mut results, peer, data, true)?; //self.hanlde_connect(&mut results, peer, data, true)?;
} }
RecvType::Event(addr, bytes) => { RecvType::Event(addr, bytes) => {
//let event: GroupEvent = bincode::deserialize(&bytes)?; //let event: OwnEvent = bincode::deserialize(&bytes)?;
//return GroupEvent::handle(self, event, pid, addr, uid).await; //return OwnEvent::handle(self, event, pid, addr, uid).await;
} }
RecvType::Stream(_uid, _stream, _bytes) => { RecvType::Stream(_uid, _stream, _bytes) => {
todo!(); todo!();
@ -121,7 +121,7 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
// let pid = peer.id; // let pid = peer.id;
// let (remote_height, remote_event, others) = match connect { // let (remote_height, remote_event, others) = match connect {
// GroupConnect::Create( // OwnConnect::Create(
// remote, // remote,
// remote_height, // remote_height,
// remote_event, // remote_event,
@ -185,7 +185,7 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
// (remote_height, remote_event, new_addrs) // (remote_height, remote_event, new_addrs)
// } // }
// } // }
// GroupConnect::Connect(remote_height, remote_event) => { // OwnConnect::Connect(remote_height, remote_event) => {
// if self // if self
// .runnings // .runnings
// .get(pid) // .get(pid)
@ -229,9 +229,9 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
// } // }
// } // }
impl Group { impl Own {
pub fn init(accounts: HashMap<PeerId, Account>) -> Group { pub fn init(accounts: HashMap<PeerId, Account>) -> Own {
Group { Own {
accounts, accounts,
keypair: PeerKey::default(), keypair: PeerKey::default(),
distributes: vec![], distributes: vec![],
@ -562,7 +562,7 @@ impl Group {
// Ok(SendType::Connect( // Ok(SendType::Connect(
// 0, // 0,
// addr, // addr,
// bincode::serialize(&GroupConnect::Create( // bincode::serialize(&OwnConnect::Create(
// proof, // proof,
// user, // user,
// height, // height,
@ -579,7 +579,7 @@ impl Group {
// let account = self.account(pid)?; // let account = self.account(pid)?;
// let height = account.own_height; // let height = account.own_height;
// let event = account.event; // let event = account.event;
// let data = bincode::serialize(&GroupConnect::Connect(height, event)).unwrap_or(vec![]); // let data = bincode::serialize(&OwnConnect::Connect(height, event)).unwrap_or(vec![]);
// Ok(SendType::Connect(0, addr, data)) // Ok(SendType::Connect(0, addr, data))
// } // }
@ -587,7 +587,7 @@ impl Group {
// let account = self.account(pid)?; // let account = self.account(pid)?;
// let height = account.own_height; // let height = account.own_height;
// let event = account.event; // let event = account.event;
// let data = bincode::serialize(&GroupConnect::Connect(height, event)).unwrap_or(vec![]); // let data = bincode::serialize(&OwnConnect::Connect(height, event)).unwrap_or(vec![]);
// Ok(SendType::Result(0, addr, true, false, data)) // Ok(SendType::Result(0, addr, true, false, data))
// } // }
@ -604,7 +604,7 @@ impl Group {
// addr, // addr,
// true, // true,
// false, // false,
// bincode::serialize(&GroupConnect::Create( // bincode::serialize(&OwnConnect::Create(
// proof, // proof,
// me, // me,
// height, // height,
@ -640,12 +640,12 @@ impl Group {
// (vec![], vec![], true) // (vec![], vec![], true)
// }; // };
// let event = GroupEvent::SyncCheck(ancestors, hashes, is_min); // let event = OwnEvent::SyncCheck(ancestors, hashes, is_min);
// let data = bincode::serialize(&event).unwrap_or(vec![]); // let data = bincode::serialize(&event).unwrap_or(vec![]);
// Ok(SendType::Event(0, addr, data)) // Ok(SendType::Event(0, addr, data))
// } // }
// pub fn event_message(&self, addr: PeerId, event: &GroupEvent) -> Result<SendType> { // pub fn event_message(&self, addr: PeerId, event: &OwnEvent) -> Result<SendType> {
// let data = bincode::serialize(event).unwrap_or(vec![]); // let data = bincode::serialize(event).unwrap_or(vec![]);
// Ok(SendType::Event(0, addr, data)) // Ok(SendType::Event(0, addr, data))
// } // }
@ -673,7 +673,7 @@ impl Group {
// account_db.close()?; // account_db.close()?;
// drop(account); // drop(account);
// let e = GroupEvent::Event(eheight, eid, pre_event, event); // let e = OwnEvent::Event(eheight, eid, pre_event, event);
// let data = bincode::serialize(&e).unwrap_or(vec![]); // let data = bincode::serialize(&e).unwrap_or(vec![]);
// let running = self.running(pid)?; // let running = self.running(pid)?;
// for (addr, (_peer, _id, online)) in &running.distributes { // for (addr, (_peer, _id, online)) in &running.distributes {
@ -692,7 +692,7 @@ impl Group {
// results: &mut HandleResult, // results: &mut HandleResult,
// ) -> Result<()> { // ) -> Result<()> {
// let running = self.running(pid)?; // let running = self.running(pid)?;
// let data = bincode::serialize(&GroupEvent::Status(event)).unwrap_or(vec![]); // let data = bincode::serialize(&OwnEvent::Status(event)).unwrap_or(vec![]);
// for (addr, (_peer, _id, online)) in &running.distributes { // for (addr, (_peer, _id, online)) in &running.distributes {
// if *online { // if *online {
// let msg = SendType::Event(0, *addr, data.clone()); // let msg = SendType::Event(0, *addr, data.clone());
@ -703,10 +703,10 @@ impl Group {
// } // }
} }
// impl GroupEvent { // impl OwnEvent {
// pub async fn handle( // pub async fn handle(
// group: &mut Group, // group: &mut Own,
// event: GroupEvent, // event: OwnEvent,
// pid: PeerId, // pid: PeerId,
// addr: PeerId, // addr: PeerId,
// //layer: &Arc<RwLock<Layer>>, // //layer: &Arc<RwLock<Layer>>,
@ -714,18 +714,18 @@ impl Group {
// ) -> Result<HandleResult> { // ) -> Result<HandleResult> {
// let mut results = HandleResult::new(); // let mut results = HandleResult::new();
// match event { // match event {
// GroupEvent::DeviceUpdate(_at, _name) => { // OwnEvent::DeviceUpdate(_at, _name) => {
// // TODO // // TODO
// } // }
// GroupEvent::DeviceDelete(_at) => { // OwnEvent::DeviceDelete(_at) => {
// // TODO // // TODO
// } // }
// GroupEvent::DeviceOffline => { // OwnEvent::DeviceOffline => {
// let v = group.running_mut(&pid)?; // let v = group.running_mut(&pid)?;
// let did = v.offline(&addr)?; // let did = v.offline(&addr)?;
// results.rpcs.push(device_rpc::device_offline(pid, did)); // results.rpcs.push(device_rpc::device_offline(pid, did));
// } // }
// GroupEvent::StatusRequest => { // OwnEvent::StatusRequest => {
// let (cpu_n, mem_s, swap_s, disk_s, cpu_p, mem_p, swap_p, disk_p) = // let (cpu_n, mem_s, swap_s, disk_s, cpu_p, mem_p, swap_p, disk_p) =
// local_device_status(); // local_device_status();
// results.groups.push(( // results.groups.push((
@ -733,7 +733,7 @@ impl Group {
// SendType::Event( // SendType::Event(
// 0, // 0,
// addr, // addr,
// bincode::serialize(&GroupEvent::StatusResponse( // bincode::serialize(&OwnEvent::StatusResponse(
// cpu_n, // cpu_n,
// mem_s, // mem_s,
// swap_s, // swap_s,
@ -748,7 +748,7 @@ impl Group {
// ), // ),
// )) // ))
// } // }
// GroupEvent::StatusResponse( // OwnEvent::StatusResponse(
// cpu_n, // cpu_n,
// mem_s, // mem_s,
// swap_s, // swap_s,
@ -761,13 +761,13 @@ impl Group {
// ) => results.rpcs.push(device_rpc::device_status( // ) => results.rpcs.push(device_rpc::device_status(
// pid, cpu_n, mem_s, swap_s, disk_s, cpu_p, mem_p, swap_p, disk_p, uptime, // pid, cpu_n, mem_s, swap_s, disk_s, cpu_p, mem_p, swap_p, disk_p, uptime,
// )), // )),
// GroupEvent::Event(eheight, eid, pre) => { // OwnEvent::Event(eheight, eid, pre) => {
// //inner_event.handle(group, pid, addr, eheight, eid, pre, &mut results, layer)?; // //inner_event.handle(group, pid, addr, eheight, eid, pre, &mut results, layer)?;
// } // }
// GroupEvent::Status => { // OwnEvent::Status => {
// //status_event.handle(group, pid, addr, &mut results, layer, uid)?; // //status_event.handle(group, pid, addr, &mut results, layer, uid)?;
// } // }
// GroupEvent::SyncCheck(ancestors, hashes, is_min) => { // OwnEvent::SyncCheck(ancestors, hashes, is_min) => {
// println!("sync check: {:?}", ancestors); // println!("sync check: {:?}", ancestors);
// let account = group.account(&pid)?; // let account = group.account(&pid)?;
// if ancestors.len() == 0 || hashes.len() == 0 { // if ancestors.len() == 0 || hashes.len() == 0 {
@ -789,7 +789,7 @@ impl Group {
// drop(db); // drop(db);
// if ours.len() == 0 { // if ours.len() == 0 {
// let event = GroupEvent::SyncRequest(1, remote_height); // let event = OwnEvent::SyncRequest(1, remote_height);
// let data = bincode::serialize(&event).unwrap_or(vec![]); // let data = bincode::serialize(&event).unwrap_or(vec![]);
// results.groups.push((pid, SendType::Event(0, addr, data))); // results.groups.push((pid, SendType::Event(0, addr, data)));
// return Ok(results); // return Ok(results);
@ -827,7 +827,7 @@ impl Group {
// } // }
// if ancestor != 0 { // if ancestor != 0 {
// let event = GroupEvent::SyncRequest(ancestor, remote_height); // let event = OwnEvent::SyncRequest(ancestor, remote_height);
// let data = bincode::serialize(&event).unwrap_or(vec![]); // let data = bincode::serialize(&event).unwrap_or(vec![]);
// results.groups.push((pid, SendType::Event(0, addr, data))); // results.groups.push((pid, SendType::Event(0, addr, data)));
// } else { // } else {
@ -838,7 +838,7 @@ impl Group {
// } // }
// } // }
// } // }
// GroupEvent::SyncRequest(from, to) => { // OwnEvent::SyncRequest(from, to) => {
// println!("====== DEBUG Sync Request: from: {} to {}", from, to); // println!("====== DEBUG Sync Request: from: {} to {}", from, to);
// // every time sync MAX is 100. // // every time sync MAX is 100.
// let last_to = if to - from > 100 { to - 100 } else { to }; // let last_to = if to - from > 100 { to - 100 } else { to };
@ -851,17 +851,17 @@ impl Group {
// // last_to, // // last_to,
// // ) // // )
// // .await?; // // .await?;
// let event = GroupEvent::SyncResponse(from, last_to, to); // let event = OwnEvent::SyncResponse(from, last_to, to);
// let data = bincode::serialize(&event).unwrap_or(vec![]); // let data = bincode::serialize(&event).unwrap_or(vec![]);
// results.groups.push((pid, SendType::Event(0, addr, data))); // results.groups.push((pid, SendType::Event(0, addr, data)));
// } // }
// GroupEvent::SyncResponse(from, last_to, to) => { // OwnEvent::SyncResponse(from, last_to, to) => {
// println!( // println!(
// "====== DEBUG Sync Response: from: {} last {}, to {}", // "====== DEBUG Sync Response: from: {} last {}, to {}",
// from, last_to, to // from, last_to, to
// ); // );
// if last_to < to { // if last_to < to {
// let event = GroupEvent::SyncRequest(last_to + 1, to); // let event = OwnEvent::SyncRequest(last_to + 1, to);
// let data = bincode::serialize(&event).unwrap_or(vec![]); // let data = bincode::serialize(&event).unwrap_or(vec![]);
// results.groups.push((pid, SendType::Event(0, addr, data))); // results.groups.push((pid, SendType::Event(0, addr, data)));
// } // }

0
src/group/consensus.rs → src/own/consensus.rs
Unescape View File

0
src/group/running.rs → src/own/running.rs
Unescape View File

32
src/rpc.rs
Unescape View File

@ -174,7 +174,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
handler.add_method("account-list", |_, state: Arc<Global>| async move { handler.add_method("account-list", |_, state: Arc<Global>| async move {
let mut accounts: Vec<Vec<String>> = vec![]; let mut accounts: Vec<Vec<String>> = vec![];
let group_lock = state.group.read().await; let group_lock = state.own.read().await;
for (pid, account) in group_lock.list_accounts().iter() { for (pid, account) in group_lock.list_accounts().iter() {
accounts.push(vec![ accounts.push(vec![
id_to_str(pid), id_to_str(pid),
@ -210,7 +210,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let avatar_bytes = base64::decode(avatar).unwrap_or(vec![]); let avatar_bytes = base64::decode(avatar).unwrap_or(vec![]);
let (_id, pid) = state let (_id, pid) = state
.group .own
.write() .write()
.await .await
.add_account( .add_account(
@ -240,7 +240,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let lock = params[4].as_str().ok_or(RpcError::ParseError)?; let lock = params[4].as_str().ok_or(RpcError::ParseError)?;
let (_id, pid) = state let (_id, pid) = state
.group .own
.write() .write()
.await .await
.add_account( .add_account(
@ -270,7 +270,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let avatar_bytes = base64::decode(avatar).unwrap_or(vec![]); let avatar_bytes = base64::decode(avatar).unwrap_or(vec![]);
let pid = state.pid().await; let pid = state.pid().await;
let mut group_lock = state.group.write().await; let mut group_lock = state.own.write().await;
group_lock.update_account( group_lock.update_account(
pid, pid,
name, name,
@ -298,7 +298,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
|params: Vec<RpcParam>, state: Arc<Global>| async move { |params: Vec<RpcParam>, state: Arc<Global>| async move {
let pid = id_from_str(params[0].as_str().ok_or(RpcError::ParseError)?)?; let pid = id_from_str(params[0].as_str().ok_or(RpcError::ParseError)?)?;
let lock = params[1].as_str().ok_or(RpcError::ParseError)?; let lock = params[1].as_str().ok_or(RpcError::ParseError)?;
let res = state.group.read().await.check_lock(&pid, lock); let res = state.own.read().await.check_lock(&pid, lock);
Ok(HandleResult::rpc(json!([res]))) Ok(HandleResult::rpc(json!([res])))
}, },
); );
@ -311,7 +311,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let pid = state.pid().await; let pid = state.pid().await;
let result = HandleResult::rpc(json!([new])); let result = HandleResult::rpc(json!([new]));
state state
.group .own
.write() .write()
.await .await
.pin(&pid, old, new, &state.base, &state.secret)?; .pin(&pid, old, new, &state.base, &state.secret)?;
@ -324,11 +324,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
|params: Vec<RpcParam>, state: Arc<Global>| async move { |params: Vec<RpcParam>, state: Arc<Global>| async move {
let lock = params[0].as_str().ok_or(RpcError::ParseError)?; let lock = params[0].as_str().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let mnemonic = state let mnemonic = state.own.read().await.mnemonic(&pid, lock, &state.secret)?;
.group
.read()
.await
.mnemonic(&pid, lock, &state.secret)?;
Ok(HandleResult::rpc(json!([mnemonic]))) Ok(HandleResult::rpc(json!([mnemonic])))
}, },
); );
@ -348,7 +344,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
} }
// load all local services created by this account. // load all local services created by this account.
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let group_db = group_db(&state.base, &pid, &db_key)?; let group_db = group_db(&state.base, &pid, &db_key)?;
let s_db = session_db(&state.base, &pid, &db_key)?; let s_db = session_db(&state.base, &pid, &db_key)?;
// 1. group chat. // 1. group chat.
@ -362,7 +358,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
} }
drop(layer); drop(layer);
let key = state.group.read().await.keypair(); let key = state.own.read().await.keypair();
let peer_id = start_main( let peer_id = start_main(
state.gids.clone(), state.gids.clone(),
state.p2p_config.clone(), state.p2p_config.clone(),
@ -394,7 +390,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
"session-list", "session-list",
|_: Vec<RpcParam>, state: Arc<Global>| async move { |_: Vec<RpcParam>, state: Arc<Global>| async move {
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = session_db(&state.base, &pid, &db_key)?; let db = session_db(&state.base, &pid, &db_key)?;
Ok(HandleResult::rpc(session_list(Session::list(&db)?))) Ok(HandleResult::rpc(session_list(Session::list(&db)?)))
}, },
@ -407,7 +403,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let remote = params[1].as_str().ok_or(RpcError::ParseError)?; let remote = params[1].as_str().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = session_db(&state.base, &pid, &db_key)?; let db = session_db(&state.base, &pid, &db_key)?;
Session::readed(&db, &id)?; Session::readed(&db, &id)?;
let s = Session::get(&db, &id)?; let s = Session::get(&db, &id)?;
@ -449,7 +445,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let must = params[2].as_bool().ok_or(RpcError::ParseError)?; // if need must suspend. let must = params[2].as_bool().ok_or(RpcError::ParseError)?; // if need must suspend.
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = session_db(&state.base, &pid, &db_key)?; let db = session_db(&state.base, &pid, &db_key)?;
let s = Session::get(&db, &id)?; let s = Session::get(&db, &id)?;
drop(db); drop(db);
@ -491,7 +487,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let id = params[0].as_i64().ok_or(RpcError::ParseError)?; let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = session_db(&state.base, &pid, &db_key)?; let db = session_db(&state.base, &pid, &db_key)?;
Session::readed(&db, &id)?; Session::readed(&db, &id)?;
Ok(HandleResult::new()) Ok(HandleResult::new())
@ -506,7 +502,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
let is_close = params[2].as_bool().ok_or(RpcError::ParseError)?; let is_close = params[2].as_bool().ok_or(RpcError::ParseError)?;
let pid = state.pid().await; let pid = state.pid().await;
let db_key = state.group.read().await.db_key(&pid)?; let db_key = state.own.read().await.db_key(&pid)?;
let db = session_db(&state.base, &pid, &db_key)?; let db = session_db(&state.base, &pid, &db_key)?;
Session::update(&db, &id, is_top, is_close)?; Session::update(&db, &id, is_top, is_close)?;
Ok(HandleResult::new()) Ok(HandleResult::new())

18
src/server.rs
Unescape View File

@ -20,9 +20,9 @@ use tdn_storage::local::DStorage;
use crate::account::Account; use crate::account::Account;
use crate::apps::app_layer_handle; use crate::apps::app_layer_handle;
use crate::global::Global; use crate::global::Global;
use crate::group::{handle as group_handle, Group};
use crate::layer::Layer; use crate::layer::Layer;
use crate::migrate::{main_migrate, ACCOUNT_DB}; use crate::migrate::{main_migrate, ACCOUNT_DB};
use crate::own::{handle as own_handle, Own};
use crate::primitives::network_seeds; use crate::primitives::network_seeds;
use crate::rpc::{init_rpc, inner_rpc}; use crate::rpc::{init_rpc, inner_rpc};
@ -90,7 +90,7 @@ pub async fn start(db_path: String) -> Result<()> {
while let Some(message) = self_recv.recv().await { while let Some(message) = self_recv.recv().await {
match message { match message {
ReceiveMessage::Own(o_msg) => { ReceiveMessage::Own(o_msg) => {
if let Ok(handle_result) = group_handle(o_msg, &global).await { if let Ok(handle_result) = own_handle(o_msg, &global).await {
handle(handle_result, now_rpc_uid, true, &global).await; handle(handle_result, now_rpc_uid, true, &global).await;
} }
} }
@ -221,7 +221,7 @@ async fn handle(handle_result: HandleResult, uid: u64, is_ws: bool, global: &Arc
mut rpcs, mut rpcs,
mut layers, mut layers,
mut networks, mut networks,
groups: _, // no-group message. mut groups,
} = handle_result; } = handle_result;
loop { loop {
@ -250,6 +250,18 @@ async fn handle(handle_result: HandleResult, uid: u64, is_ws: bool, global: &Arc
} }
} }
loop {
if groups.len() != 0 {
let msg = groups.remove(0);
sender
.send(SendMessage::Group(msg))
.await
.expect("TDN channel closed");
} else {
break;
}
}
loop { loop {
if layers.len() != 0 { if layers.len() != 0 {
let (tgid, msg) = layers.remove(0); let (tgid, msg) = layers.remove(0);

Write Preview
Loading…
Cancel
Save