From 96c427e869cb8aa73905a00e40d46a5eb52900ff Mon Sep 17 00:00:00 2001 From: nathan Date: Thu, 1 Dec 2022 08:35:50 +0800 Subject: [PATCH 1/2] refactor: rename flowy-dispatch structs --- frontend/rust-lib/dart-ffi/src/lib.rs | 8 +- .../dart-ffi/src/model/ffi_request.rs | 6 +- .../flowy-document/src/event_handler.rs | 14 +- .../rust-lib/flowy-document/src/event_map.rs | 10 +- .../rust-lib/flowy-folder/src/event_map.rs | 24 +-- .../src/services/app/event_handler.rs | 22 +-- .../src/services/trash/event_handler.rs | 20 +- .../src/services/view/event_handler.rs | 44 ++--- .../src/services/workspace/event_handler.rs | 20 +- .../rust-lib/flowy-grid/src/event_handler.rs | 122 ++++++------ frontend/rust-lib/flowy-grid/src/event_map.rs | 8 +- frontend/rust-lib/flowy-net/src/event_map.rs | 6 +- .../rust-lib/flowy-net/src/handlers/mod.rs | 6 +- frontend/rust-lib/flowy-sdk/src/lib.rs | 16 +- frontend/rust-lib/flowy-sdk/src/module.rs | 38 +--- .../rust-lib/flowy-test/src/event_builder.rs | 22 ++- frontend/rust-lib/flowy-test/src/helper.rs | 30 +-- frontend/rust-lib/flowy-user/src/event_map.rs | 6 +- .../flowy-user/src/handlers/auth_handler.rs | 8 +- .../flowy-user/src/handlers/user_handler.rs | 18 +- .../rust-lib/lib-dispatch/src/byte_trait.rs | 6 +- frontend/rust-lib/lib-dispatch/src/data.rs | 46 ++--- .../rust-lib/lib-dispatch/src/dispatcher.rs | 69 +++---- .../lib-dispatch/src/errors/errors.rs | 10 +- .../lib-dispatch/src/module/container.rs | 28 ++- .../rust-lib/lib-dispatch/src/module/data.rs | 30 +-- .../lib-dispatch/src/module/module.rs | 178 +++++++----------- .../lib-dispatch/src/request/request.rs | 40 ++-- .../lib-dispatch/src/response/responder.rs | 16 +- .../lib-dispatch/src/response/response.rs | 26 +-- frontend/rust-lib/lib-dispatch/src/runtime.rs | 4 +- .../lib-dispatch/src/service/boxed.rs | 22 +-- .../lib-dispatch/src/service/handler.rs | 80 ++++---- .../lib-dispatch/src/service/service.rs | 18 +- .../rust-lib/lib-dispatch/tests/api/module.rs | 8 +- 35 files changed, 486 insertions(+), 543 deletions(-) diff --git a/frontend/rust-lib/dart-ffi/src/lib.rs b/frontend/rust-lib/dart-ffi/src/lib.rs index 53ac68dfc5..8165cbf6c3 100644 --- a/frontend/rust-lib/dart-ffi/src/lib.rs +++ b/frontend/rust-lib/dart-ffi/src/lib.rs @@ -31,7 +31,7 @@ pub extern "C" fn init_sdk(path: *mut c_char) -> i64 { #[no_mangle] pub extern "C" fn async_event(port: i64, input: *const u8, len: usize) { - let request: ModuleRequest = FFIRequest::from_u8_pointer(input, len).into(); + let request: AFPluginRequest = FFIRequest::from_u8_pointer(input, len).into(); log::trace!( "[FFI]: {} Async Event: {:?} with {} port", &request.id, @@ -46,7 +46,7 @@ pub extern "C" fn async_event(port: i64, input: *const u8, len: usize) { } Some(e) => e.event_dispatcher.clone(), }; - let _ = EventDispatcher::async_send_with_callback(dispatcher, request, move |resp: EventResponse| { + let _ = AFPluginDispatcher::async_send_with_callback(dispatcher, request, move |resp: EventResponse| { log::trace!("[FFI]: Post data to dart through {} port", port); Box::pin(post_to_flutter(resp, port)) }); @@ -54,7 +54,7 @@ pub extern "C" fn async_event(port: i64, input: *const u8, len: usize) { #[no_mangle] pub extern "C" fn sync_event(input: *const u8, len: usize) -> *const u8 { - let request: ModuleRequest = FFIRequest::from_u8_pointer(input, len).into(); + let request: AFPluginRequest = FFIRequest::from_u8_pointer(input, len).into(); log::trace!("[FFI]: {} Sync Event: {:?}", &request.id, &request.event,); let dispatcher = match FLOWY_SDK.get() { @@ -64,7 +64,7 @@ pub extern "C" fn sync_event(input: *const u8, len: usize) -> *const u8 { } Some(e) => e.event_dispatcher.clone(), }; - let _response = EventDispatcher::sync_send(dispatcher, request); + let _response = AFPluginDispatcher::sync_send(dispatcher, request); // FFIResponse { } let response_bytes = vec![]; diff --git a/frontend/rust-lib/dart-ffi/src/model/ffi_request.rs b/frontend/rust-lib/dart-ffi/src/model/ffi_request.rs index d1123d40df..e6c4e30d88 100644 --- a/frontend/rust-lib/dart-ffi/src/model/ffi_request.rs +++ b/frontend/rust-lib/dart-ffi/src/model/ffi_request.rs @@ -1,6 +1,6 @@ use bytes::Bytes; use flowy_derive::ProtoBuf; -use lib_dispatch::prelude::ModuleRequest; +use lib_dispatch::prelude::AFPluginRequest; use std::convert::TryFrom; #[derive(Default, ProtoBuf)] @@ -21,8 +21,8 @@ impl FFIRequest { } } -impl std::convert::From for ModuleRequest { +impl std::convert::From for AFPluginRequest { fn from(ffi_request: FFIRequest) -> Self { - ModuleRequest::new(ffi_request.event).payload(ffi_request.payload) + AFPluginRequest::new(ffi_request.event).payload(ffi_request.payload) } } diff --git a/frontend/rust-lib/flowy-document/src/event_handler.rs b/frontend/rust-lib/flowy-document/src/event_handler.rs index 2d8d99968b..a50aaa0fd3 100644 --- a/frontend/rust-lib/flowy-document/src/event_handler.rs +++ b/frontend/rust-lib/flowy-document/src/event_handler.rs @@ -4,13 +4,13 @@ use crate::entities::{ use crate::DocumentManager; use flowy_error::FlowyError; -use lib_dispatch::prelude::{data_result, AppData, Data, DataResult}; +use lib_dispatch::prelude::{data_result, AFPluginData, AFPluginState, DataResult}; use std::convert::TryInto; use std::sync::Arc; pub(crate) async fn get_document_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let context: OpenDocumentContextPB = data.into_inner(); let editor = manager.open_document_editor(&context.document_id).await?; @@ -22,8 +22,8 @@ pub(crate) async fn get_document_handler( } pub(crate) async fn apply_edit_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: EditParams = data.into_inner().try_into()?; let _ = manager.apply_edit(params).await?; @@ -32,8 +32,8 @@ pub(crate) async fn apply_edit_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn export_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: ExportParams = data.into_inner().try_into()?; let editor = manager.open_document_editor(¶ms.view_id).await?; diff --git a/frontend/rust-lib/flowy-document/src/event_map.rs b/frontend/rust-lib/flowy-document/src/event_map.rs index 50aa9cf7cf..6c8e2f4113 100644 --- a/frontend/rust-lib/flowy-document/src/event_map.rs +++ b/frontend/rust-lib/flowy-document/src/event_map.rs @@ -1,19 +1,19 @@ use crate::event_handler::*; use crate::DocumentManager; use flowy_derive::{Flowy_Event, ProtoBuf_Enum}; -use lib_dispatch::prelude::Module; +use lib_dispatch::prelude::AFPlugin; use std::sync::Arc; use strum_macros::Display; -pub fn create(document_manager: Arc) -> Module { - let mut module = Module::new().name(env!("CARGO_PKG_NAME")).data(document_manager); +pub fn init(document_manager: Arc) -> AFPlugin { + let mut plugin = AFPlugin::new().name(env!("CARGO_PKG_NAME")).state(document_manager); - module = module + plugin = plugin .event(DocumentEvent::GetDocument, get_document_handler) .event(DocumentEvent::ApplyEdit, apply_edit_handler) .event(DocumentEvent::ExportDocument, export_handler); - module + plugin } #[derive(Clone, Copy, PartialEq, Eq, Debug, Display, Hash, ProtoBuf_Enum, Flowy_Event)] diff --git a/frontend/rust-lib/flowy-folder/src/event_map.rs b/frontend/rust-lib/flowy-folder/src/event_map.rs index ba9b3b74e4..2751a69e87 100644 --- a/frontend/rust-lib/flowy-folder/src/event_map.rs +++ b/frontend/rust-lib/flowy-folder/src/event_map.rs @@ -34,17 +34,17 @@ pub trait WorkspaceDatabase: Send + Sync { } } -pub fn create(folder: Arc) -> Module { - let mut module = Module::new() +pub fn init(folder: Arc) -> AFPlugin { + let mut plugin = AFPlugin::new() .name("Flowy-Workspace") - .data(folder.workspace_controller.clone()) - .data(folder.app_controller.clone()) - .data(folder.view_controller.clone()) - .data(folder.trash_controller.clone()) - .data(folder.clone()); + .state(folder.workspace_controller.clone()) + .state(folder.app_controller.clone()) + .state(folder.view_controller.clone()) + .state(folder.trash_controller.clone()) + .state(folder.clone()); // Workspace - module = module + plugin = plugin .event(FolderEvent::CreateWorkspace, create_workspace_handler) .event(FolderEvent::ReadCurrentWorkspace, read_cur_workspace_handler) .event(FolderEvent::ReadWorkspaces, read_workspaces_handler) @@ -52,14 +52,14 @@ pub fn create(folder: Arc) -> Module { .event(FolderEvent::ReadWorkspaceApps, read_workspace_apps_handler); // App - module = module + plugin = plugin .event(FolderEvent::CreateApp, create_app_handler) .event(FolderEvent::ReadApp, read_app_handler) .event(FolderEvent::UpdateApp, update_app_handler) .event(FolderEvent::DeleteApp, delete_app_handler); // View - module = module + plugin = plugin .event(FolderEvent::CreateView, create_view_handler) .event(FolderEvent::ReadView, read_view_handler) .event(FolderEvent::UpdateView, update_view_handler) @@ -71,14 +71,14 @@ pub fn create(folder: Arc) -> Module { .event(FolderEvent::MoveFolderItem, move_item_handler); // Trash - module = module + plugin = plugin .event(FolderEvent::ReadTrash, read_trash_handler) .event(FolderEvent::PutbackTrash, putback_trash_handler) .event(FolderEvent::DeleteTrash, delete_trash_handler) .event(FolderEvent::RestoreAllTrash, restore_all_trash_handler) .event(FolderEvent::DeleteAllTrash, delete_all_trash_handler); - module + plugin } #[derive(Clone, Copy, PartialEq, Eq, Debug, Display, Hash, ProtoBuf_Enum, Flowy_Event)] diff --git a/frontend/rust-lib/flowy-folder/src/services/app/event_handler.rs b/frontend/rust-lib/flowy-folder/src/services/app/event_handler.rs index d3c7dd828a..988f9f2b17 100644 --- a/frontend/rust-lib/flowy-folder/src/services/app/event_handler.rs +++ b/frontend/rust-lib/flowy-folder/src/services/app/event_handler.rs @@ -4,12 +4,12 @@ use crate::{ services::{AppController, TrashController, ViewController}, }; use folder_rev_model::TrashRevision; -use lib_dispatch::prelude::{data_result, AppData, Data, DataResult}; +use lib_dispatch::prelude::{data_result, AFPluginData, AFPluginState, DataResult}; use std::{convert::TryInto, sync::Arc}; pub(crate) async fn create_app_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> DataResult { let params: CreateAppParams = data.into_inner().try_into()?; let detail = controller.create_app_from_params(params).await?; @@ -18,9 +18,9 @@ pub(crate) async fn create_app_handler( } pub(crate) async fn delete_app_handler( - data: Data, - app_controller: AppData>, - trash_controller: AppData>, + data: AFPluginData, + app_controller: AFPluginState>, + trash_controller: AFPluginState>, ) -> Result<(), FlowyError> { let params: AppIdPB = data.into_inner(); let trash = app_controller @@ -36,8 +36,8 @@ pub(crate) async fn delete_app_handler( #[tracing::instrument(level = "trace", skip(data, controller))] pub(crate) async fn update_app_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> Result<(), FlowyError> { let params: UpdateAppParams = data.into_inner().try_into()?; let _ = controller.update_app(params).await?; @@ -46,9 +46,9 @@ pub(crate) async fn update_app_handler( #[tracing::instrument(level = "trace", skip(data, app_controller, view_controller), err)] pub(crate) async fn read_app_handler( - data: Data, - app_controller: AppData>, - view_controller: AppData>, + data: AFPluginData, + app_controller: AFPluginState>, + view_controller: AFPluginState>, ) -> DataResult { let params: AppIdPB = data.into_inner(); let mut app_rev = app_controller.read_app(params.clone()).await?; diff --git a/frontend/rust-lib/flowy-folder/src/services/trash/event_handler.rs b/frontend/rust-lib/flowy-folder/src/services/trash/event_handler.rs index 0034745253..17e83555ba 100644 --- a/frontend/rust-lib/flowy-folder/src/services/trash/event_handler.rs +++ b/frontend/rust-lib/flowy-folder/src/services/trash/event_handler.rs @@ -3,12 +3,12 @@ use crate::{ errors::FlowyError, services::TrashController, }; -use lib_dispatch::prelude::{data_result, AppData, Data, DataResult}; +use lib_dispatch::prelude::{data_result, AFPluginData, AFPluginState, DataResult}; use std::sync::Arc; #[tracing::instrument(level = "debug", skip(controller), err)] pub(crate) async fn read_trash_handler( - controller: AppData>, + controller: AFPluginState>, ) -> DataResult { let repeated_trash = controller.read_trash().await?; data_result(repeated_trash) @@ -16,8 +16,8 @@ pub(crate) async fn read_trash_handler( #[tracing::instrument(level = "debug", skip(identifier, controller), err)] pub(crate) async fn putback_trash_handler( - identifier: Data, - controller: AppData>, + identifier: AFPluginData, + controller: AFPluginState>, ) -> Result<(), FlowyError> { let _ = controller.putback(&identifier.id).await?; Ok(()) @@ -25,21 +25,25 @@ pub(crate) async fn putback_trash_handler( #[tracing::instrument(level = "debug", skip(identifiers, controller), err)] pub(crate) async fn delete_trash_handler( - identifiers: Data, - controller: AppData>, + identifiers: AFPluginData, + controller: AFPluginState>, ) -> Result<(), FlowyError> { let _ = controller.delete(identifiers.into_inner()).await?; Ok(()) } #[tracing::instrument(level = "debug", skip(controller), err)] -pub(crate) async fn restore_all_trash_handler(controller: AppData>) -> Result<(), FlowyError> { +pub(crate) async fn restore_all_trash_handler( + controller: AFPluginState>, +) -> Result<(), FlowyError> { let _ = controller.restore_all_trash().await?; Ok(()) } #[tracing::instrument(level = "debug", skip(controller), err)] -pub(crate) async fn delete_all_trash_handler(controller: AppData>) -> Result<(), FlowyError> { +pub(crate) async fn delete_all_trash_handler( + controller: AFPluginState>, +) -> Result<(), FlowyError> { let _ = controller.delete_all_trash().await?; Ok(()) } diff --git a/frontend/rust-lib/flowy-folder/src/services/view/event_handler.rs b/frontend/rust-lib/flowy-folder/src/services/view/event_handler.rs index 06ee0e797e..ac64d93927 100644 --- a/frontend/rust-lib/flowy-folder/src/services/view/event_handler.rs +++ b/frontend/rust-lib/flowy-folder/src/services/view/event_handler.rs @@ -14,12 +14,12 @@ use crate::{ services::{TrashController, ViewController}, }; use folder_rev_model::TrashRevision; -use lib_dispatch::prelude::{data_result, AppData, Data, DataResult}; +use lib_dispatch::prelude::{data_result, AFPluginData, AFPluginState, DataResult}; use std::{convert::TryInto, sync::Arc}; pub(crate) async fn create_view_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> DataResult { let params: CreateViewParams = data.into_inner().try_into()?; let view_rev = controller.create_view_from_params(params).await?; @@ -27,8 +27,8 @@ pub(crate) async fn create_view_handler( } pub(crate) async fn read_view_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> DataResult { let view_id: ViewIdPB = data.into_inner(); let view_rev = controller.read_view(&view_id.value).await?; @@ -36,8 +36,8 @@ pub(crate) async fn read_view_handler( } pub(crate) async fn read_view_info_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> DataResult { let view_id: ViewIdPB = data.into_inner(); let view_info = controller.read_view_pb(view_id.clone()).await?; @@ -46,8 +46,8 @@ pub(crate) async fn read_view_info_handler( #[tracing::instrument(level = "debug", skip(data, controller), err)] pub(crate) async fn update_view_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> Result<(), FlowyError> { let params: UpdateViewParams = data.into_inner().try_into()?; let _ = controller.update_view(params).await?; @@ -56,9 +56,9 @@ pub(crate) async fn update_view_handler( } pub(crate) async fn delete_view_handler( - data: Data, - view_controller: AppData>, - trash_controller: AppData>, + data: AFPluginData, + view_controller: AFPluginState>, + trash_controller: AFPluginState>, ) -> Result<(), FlowyError> { let params: RepeatedViewIdPB = data.into_inner(); for view_id in ¶ms.items { @@ -80,9 +80,9 @@ pub(crate) async fn delete_view_handler( } pub(crate) async fn set_latest_view_handler( - data: Data, - folder: AppData>, - controller: AppData>, + data: AFPluginData, + folder: AFPluginState>, + controller: AFPluginState>, ) -> Result<(), FlowyError> { let view_id: ViewIdPB = data.into_inner(); let _ = controller.set_latest_view(&view_id.value)?; @@ -91,8 +91,8 @@ pub(crate) async fn set_latest_view_handler( } pub(crate) async fn close_view_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> Result<(), FlowyError> { let view_id: ViewIdPB = data.into_inner(); let _ = controller.close_view(&view_id.value).await?; @@ -101,9 +101,9 @@ pub(crate) async fn close_view_handler( #[tracing::instrument(level = "debug", skip_all, err)] pub(crate) async fn move_item_handler( - data: Data, - view_controller: AppData>, - app_controller: AppData>, + data: AFPluginData, + view_controller: AFPluginState>, + app_controller: AFPluginState>, ) -> Result<(), FlowyError> { let params: MoveFolderItemParams = data.into_inner().try_into()?; match params.ty { @@ -121,8 +121,8 @@ pub(crate) async fn move_item_handler( #[tracing::instrument(level = "debug", skip(data, controller), err)] pub(crate) async fn duplicate_view_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> Result<(), FlowyError> { let view: ViewPB = data.into_inner(); let _ = controller.duplicate_view(view).await?; diff --git a/frontend/rust-lib/flowy-folder/src/services/workspace/event_handler.rs b/frontend/rust-lib/flowy-folder/src/services/workspace/event_handler.rs index bce1f508b5..5ac8ddbd16 100644 --- a/frontend/rust-lib/flowy-folder/src/services/workspace/event_handler.rs +++ b/frontend/rust-lib/flowy-folder/src/services/workspace/event_handler.rs @@ -9,13 +9,13 @@ use crate::{ manager::FolderManager, services::{get_current_workspace, read_local_workspace_apps, WorkspaceController}, }; -use lib_dispatch::prelude::{data_result, AppData, Data, DataResult}; +use lib_dispatch::prelude::{data_result, AFPluginData, AFPluginState, DataResult}; use std::{convert::TryInto, sync::Arc}; #[tracing::instrument(level = "debug", skip(data, controller), err)] pub(crate) async fn create_workspace_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> DataResult { let controller = controller.get_ref().clone(); let params: CreateWorkspaceParams = data.into_inner().try_into()?; @@ -25,7 +25,7 @@ pub(crate) async fn create_workspace_handler( #[tracing::instrument(level = "debug", skip(controller), err)] pub(crate) async fn read_workspace_apps_handler( - controller: AppData>, + controller: AFPluginState>, ) -> DataResult { let items = controller .read_current_workspace_apps() @@ -39,8 +39,8 @@ pub(crate) async fn read_workspace_apps_handler( #[tracing::instrument(level = "debug", skip(data, controller), err)] pub(crate) async fn open_workspace_handler( - data: Data, - controller: AppData>, + data: AFPluginData, + controller: AFPluginState>, ) -> DataResult { let params: WorkspaceIdPB = data.into_inner(); let workspaces = controller.open_workspace(params).await?; @@ -49,8 +49,8 @@ pub(crate) async fn open_workspace_handler( #[tracing::instrument(level = "debug", skip(data, folder), err)] pub(crate) async fn read_workspaces_handler( - data: Data, - folder: AppData>, + data: AFPluginData, + folder: AFPluginState>, ) -> DataResult { let params: WorkspaceIdPB = data.into_inner(); let user_id = folder.user.user_id()?; @@ -78,7 +78,7 @@ pub(crate) async fn read_workspaces_handler( #[tracing::instrument(level = "debug", skip(folder), err)] pub async fn read_cur_workspace_handler( - folder: AppData>, + folder: AFPluginState>, ) -> DataResult { let workspace_id = get_current_workspace()?; let user_id = folder.user.user_id()?; @@ -108,7 +108,7 @@ pub async fn read_cur_workspace_handler( #[tracing::instrument(level = "trace", skip(folder_manager), err)] fn read_workspaces_on_server( - folder_manager: AppData>, + folder_manager: AFPluginState>, user_id: String, params: WorkspaceIdPB, ) -> Result<(), FlowyError> { diff --git a/frontend/rust-lib/flowy-grid/src/event_handler.rs b/frontend/rust-lib/flowy-grid/src/event_handler.rs index c47dbf23ba..191fec38c2 100644 --- a/frontend/rust-lib/flowy-grid/src/event_handler.rs +++ b/frontend/rust-lib/flowy-grid/src/event_handler.rs @@ -10,13 +10,13 @@ use crate::services::field::{ use crate::services::row::{make_block_pbs, make_row_from_row_rev}; use flowy_error::{ErrorCode, FlowyError, FlowyResult}; use grid_rev_model::FieldRevision; -use lib_dispatch::prelude::{data_result, AppData, Data, DataResult}; +use lib_dispatch::prelude::{data_result, AFPluginData, AFPluginState, DataResult}; use std::sync::Arc; #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn get_grid_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let grid_id: GridIdPB = data.into_inner(); let editor = manager.open_grid(grid_id).await?; @@ -26,8 +26,8 @@ pub(crate) async fn get_grid_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn get_grid_setting_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let grid_id: GridIdPB = data.into_inner(); let editor = manager.open_grid(grid_id).await?; @@ -37,8 +37,8 @@ pub(crate) async fn get_grid_setting_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn update_grid_setting_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: GridSettingChangesetParams = data.into_inner().try_into()?; @@ -63,8 +63,8 @@ pub(crate) async fn update_grid_setting_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn get_all_filters_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let grid_id: GridIdPB = data.into_inner(); let editor = manager.open_grid(grid_id).await?; @@ -76,8 +76,8 @@ pub(crate) async fn get_all_filters_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn get_grid_blocks_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: QueryGridBlocksParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -87,8 +87,8 @@ pub(crate) async fn get_grid_blocks_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn get_fields_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: GetFieldParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -99,8 +99,8 @@ pub(crate) async fn get_fields_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn update_field_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let changeset: FieldChangesetParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(&changeset.grid_id).await?; @@ -110,8 +110,8 @@ pub(crate) async fn update_field_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn update_field_type_option_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: TypeOptionChangesetParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -129,8 +129,8 @@ pub(crate) async fn update_field_type_option_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn delete_field_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: FieldIdParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -140,8 +140,8 @@ pub(crate) async fn delete_field_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn switch_to_field_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: EditFieldParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -167,8 +167,8 @@ pub(crate) async fn switch_to_field_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn duplicate_field_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: FieldIdParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -179,8 +179,8 @@ pub(crate) async fn duplicate_field_handler( /// Return the FieldTypeOptionData if the Field exists otherwise return record not found error. #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn get_field_type_option_data_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: TypeOptionPathParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -202,8 +202,8 @@ pub(crate) async fn get_field_type_option_data_handler( /// Create FieldMeta and save it. Return the FieldTypeOptionData. #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn create_field_type_option_data_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: CreateFieldParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -222,8 +222,8 @@ pub(crate) async fn create_field_type_option_data_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn move_field_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: MoveFieldParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -247,8 +247,8 @@ async fn get_type_option_data(field_rev: &FieldRevision, field_type: &FieldType) // #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn get_row_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: RowIdParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -259,8 +259,8 @@ pub(crate) async fn get_row_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn delete_row_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: RowIdParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -270,8 +270,8 @@ pub(crate) async fn delete_row_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn duplicate_row_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: RowIdParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -281,8 +281,8 @@ pub(crate) async fn duplicate_row_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn move_row_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: MoveRowParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.view_id).await?; @@ -292,8 +292,8 @@ pub(crate) async fn move_row_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn create_table_row_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: CreateRowParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(params.grid_id.as_ref()).await?; @@ -303,8 +303,8 @@ pub(crate) async fn create_table_row_handler( #[tracing::instrument(level = "trace", skip_all, err)] pub(crate) async fn get_cell_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: CellPathParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -316,8 +316,8 @@ pub(crate) async fn get_cell_handler( #[tracing::instrument(level = "trace", skip_all, err)] pub(crate) async fn update_cell_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let changeset: CellChangesetPB = data.into_inner(); let editor = manager.get_grid_editor(&changeset.grid_id).await?; @@ -327,8 +327,8 @@ pub(crate) async fn update_cell_handler( #[tracing::instrument(level = "trace", skip_all, err)] pub(crate) async fn new_select_option_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: CreateSelectOptionParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -344,8 +344,8 @@ pub(crate) async fn new_select_option_handler( #[tracing::instrument(level = "trace", skip_all, err)] pub(crate) async fn update_select_option_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let changeset: SelectOptionChangeset = data.into_inner().try_into()?; let editor = manager.get_grid_editor(&changeset.cell_identifier.grid_id).await?; @@ -401,8 +401,8 @@ pub(crate) async fn update_select_option_handler( #[tracing::instrument(level = "trace", skip(data, manager), err)] pub(crate) async fn get_select_option_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: CellPathParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.grid_id).await?; @@ -430,8 +430,8 @@ pub(crate) async fn get_select_option_handler( #[tracing::instrument(level = "trace", skip_all, err)] pub(crate) async fn update_select_option_cell_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let params: SelectOptionCellChangesetParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(¶ms.cell_identifier.grid_id).await?; @@ -441,8 +441,8 @@ pub(crate) async fn update_select_option_cell_handler( #[tracing::instrument(level = "trace", skip_all, err)] pub(crate) async fn update_date_cell_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> Result<(), FlowyError> { let data = data.into_inner(); let cell_path: CellPathParams = data.cell_path.try_into()?; @@ -461,8 +461,8 @@ pub(crate) async fn update_date_cell_handler( #[tracing::instrument(level = "trace", skip_all, err)] pub(crate) async fn get_groups_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: GridIdPB = data.into_inner(); let editor = manager.get_grid_editor(¶ms.value).await?; @@ -472,8 +472,8 @@ pub(crate) async fn get_groups_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn create_board_card_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> DataResult { let params: CreateRowParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(params.grid_id.as_ref()).await?; @@ -483,8 +483,8 @@ pub(crate) async fn create_board_card_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn move_group_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> FlowyResult<()> { let params: MoveGroupParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(params.view_id.as_ref()).await?; @@ -494,8 +494,8 @@ pub(crate) async fn move_group_handler( #[tracing::instrument(level = "debug", skip(data, manager), err)] pub(crate) async fn move_group_row_handler( - data: Data, - manager: AppData>, + data: AFPluginData, + manager: AFPluginState>, ) -> FlowyResult<()> { let params: MoveGroupRowParams = data.into_inner().try_into()?; let editor = manager.get_grid_editor(params.view_id.as_ref()).await?; diff --git a/frontend/rust-lib/flowy-grid/src/event_map.rs b/frontend/rust-lib/flowy-grid/src/event_map.rs index f833cefece..b4fb1c1d55 100644 --- a/frontend/rust-lib/flowy-grid/src/event_map.rs +++ b/frontend/rust-lib/flowy-grid/src/event_map.rs @@ -5,9 +5,9 @@ use lib_dispatch::prelude::*; use std::sync::Arc; use strum_macros::Display; -pub fn create(grid_manager: Arc) -> Module { - let mut module = Module::new().name(env!("CARGO_PKG_NAME")).data(grid_manager); - module = module +pub fn init(grid_manager: Arc) -> AFPlugin { + let mut plugin = AFPlugin::new().name(env!("CARGO_PKG_NAME")).state(grid_manager); + plugin = plugin .event(GridEvent::GetGrid, get_grid_handler) .event(GridEvent::GetGridBlocks, get_grid_blocks_handler) .event(GridEvent::GetGridSetting, get_grid_setting_handler) @@ -45,7 +45,7 @@ pub fn create(grid_manager: Arc) -> Module { .event(GridEvent::MoveGroupRow, move_group_row_handler) .event(GridEvent::GetGroup, get_groups_handler); - module + plugin } /// [GridEvent] defines events that are used to interact with the Grid. You could check [this](https://appflowy.gitbook.io/docs/essential-documentation/contribute-to-appflowy/architecture/backend/protobuf) diff --git a/frontend/rust-lib/flowy-net/src/event_map.rs b/frontend/rust-lib/flowy-net/src/event_map.rs index 4fce155360..aaaab10f7d 100644 --- a/frontend/rust-lib/flowy-net/src/event_map.rs +++ b/frontend/rust-lib/flowy-net/src/event_map.rs @@ -4,10 +4,10 @@ use lib_dispatch::prelude::*; use std::sync::Arc; use strum_macros::Display; -pub fn create(ws_conn: Arc) -> Module { - Module::new() +pub fn init(ws_conn: Arc) -> AFPlugin { + AFPlugin::new() .name("Flowy-Network") - .data(ws_conn) + .state(ws_conn) .event(NetworkEvent::UpdateNetworkType, update_network_ty) } diff --git a/frontend/rust-lib/flowy-net/src/handlers/mod.rs b/frontend/rust-lib/flowy-net/src/handlers/mod.rs index 3f77ba3a04..2fbc71ff0b 100644 --- a/frontend/rust-lib/flowy-net/src/handlers/mod.rs +++ b/frontend/rust-lib/flowy-net/src/handlers/mod.rs @@ -1,12 +1,12 @@ use crate::{entities::NetworkState, ws::connection::FlowyWebSocketConnect}; use flowy_error::FlowyError; -use lib_dispatch::prelude::{AppData, Data}; +use lib_dispatch::prelude::{AFPluginData, AFPluginState}; use std::sync::Arc; #[tracing::instrument(level = "debug", skip(data, ws_manager))] pub async fn update_network_ty( - data: Data, - ws_manager: AppData>, + data: AFPluginData, + ws_manager: AFPluginState>, ) -> Result<(), FlowyError> { let network_state = data.into_inner(); ws_manager.update_network_type(&network_state.ty); diff --git a/frontend/rust-lib/flowy-sdk/src/lib.rs b/frontend/rust-lib/flowy-sdk/src/lib.rs index ec757c9e10..35d898e57a 100644 --- a/frontend/rust-lib/flowy-sdk/src/lib.rs +++ b/frontend/rust-lib/flowy-sdk/src/lib.rs @@ -19,7 +19,7 @@ use flowy_task::{TaskDispatcher, TaskRunner}; use flowy_user::services::{notifier::UserStatus, UserSession, UserSessionConfig}; use lib_dispatch::prelude::*; use lib_dispatch::runtime::tokio_default_runtime; -use module::mk_modules; +use module::make_plugins; pub use module::*; use std::time::Duration; use std::{ @@ -105,7 +105,7 @@ pub struct FlowySDK { pub document_manager: Arc, pub folder_manager: Arc, pub grid_manager: Arc, - pub event_dispatcher: Arc, + pub event_dispatcher: Arc, pub ws_conn: Arc, pub local_server: Option>, pub task_dispatcher: Arc>, @@ -158,8 +158,8 @@ impl FlowySDK { ) }); - let event_dispatcher = Arc::new(EventDispatcher::construct(runtime, || { - mk_modules( + let event_dispatcher = Arc::new(AFPluginDispatcher::construct(runtime, || { + make_plugins( &ws_conn, &folder_manager, &grid_manager, @@ -191,14 +191,14 @@ impl FlowySDK { } } - pub fn dispatcher(&self) -> Arc { + pub fn dispatcher(&self) -> Arc { self.event_dispatcher.clone() } } fn _start_listening( config: &FlowySDKConfig, - event_dispatch: &EventDispatcher, + event_dispatcher: &AFPluginDispatcher, ws_conn: &Arc, user_session: &Arc, document_manager: &Arc, @@ -215,7 +215,7 @@ fn _start_listening( let document_manager = document_manager.clone(); let config = config.clone(); - event_dispatch.spawn(async move { + event_dispatcher.spawn(async move { user_session.init(); listen_on_websocket(ws_conn.clone()); _listen_user_status( @@ -229,7 +229,7 @@ fn _start_listening( .await; }); - event_dispatch.spawn(async move { + event_dispatcher.spawn(async move { _listen_network_status(subscribe_network_type, cloned_folder_manager).await; }); } diff --git a/frontend/rust-lib/flowy-sdk/src/module.rs b/frontend/rust-lib/flowy-sdk/src/module.rs index e6b89da6a6..74bc4cfca6 100644 --- a/frontend/rust-lib/flowy-sdk/src/module.rs +++ b/frontend/rust-lib/flowy-sdk/src/module.rs @@ -3,40 +3,20 @@ use flowy_folder::manager::FolderManager; use flowy_grid::manager::GridManager; use flowy_net::ws::connection::FlowyWebSocketConnect; use flowy_user::services::UserSession; -use lib_dispatch::prelude::Module; +use lib_dispatch::prelude::AFPlugin; use std::sync::Arc; -pub fn mk_modules( +pub fn make_plugins( ws_conn: &Arc, folder_manager: &Arc, grid_manager: &Arc, user_session: &Arc, document_manager: &Arc, -) -> Vec { - let user_module = mk_user_module(user_session.clone()); - let folder_module = mk_folder_module(folder_manager.clone()); - let network_module = mk_network_module(ws_conn.clone()); - let grid_module = mk_grid_module(grid_manager.clone()); - let document_module = mk_text_block_module(document_manager.clone()); - vec![user_module, folder_module, network_module, grid_module, document_module] -} - -fn mk_user_module(user_session: Arc) -> Module { - flowy_user::event_map::create(user_session) -} - -fn mk_folder_module(folder_manager: Arc) -> Module { - flowy_folder::event_map::create(folder_manager) -} - -fn mk_network_module(ws_conn: Arc) -> Module { - flowy_net::event_map::create(ws_conn) -} - -fn mk_grid_module(grid_manager: Arc) -> Module { - flowy_grid::event_map::create(grid_manager) -} - -fn mk_text_block_module(text_block_manager: Arc) -> Module { - flowy_document::event_map::create(text_block_manager) +) -> Vec { + let user_plugin = flowy_user::event_map::init(user_session.clone()); + let folder_plugin = flowy_folder::event_map::init(folder_manager.clone()); + let network_plugin = flowy_net::event_map::init(ws_conn.clone()); + let grid_plugin = flowy_grid::event_map::init(grid_manager.clone()); + let document_plugin = flowy_document::event_map::init(document_manager.clone()); + vec![user_plugin, folder_plugin, network_plugin, grid_plugin, document_plugin] } diff --git a/frontend/rust-lib/flowy-test/src/event_builder.rs b/frontend/rust-lib/flowy-test/src/event_builder.rs index 75cdff5f38..8d34aa7acd 100644 --- a/frontend/rust-lib/flowy-test/src/event_builder.rs +++ b/frontend/rust-lib/flowy-test/src/event_builder.rs @@ -1,6 +1,8 @@ use crate::FlowySDKTest; use flowy_user::{entities::UserProfilePB, errors::FlowyError}; -use lib_dispatch::prelude::{EventDispatcher, EventResponse, FromBytes, ModuleRequest, StatusCode, ToBytes, *}; +use lib_dispatch::prelude::{ + AFPluginDispatcher, AFPluginFromBytes, AFPluginRequest, EventResponse, StatusCode, ToBytes, *, +}; use std::{ convert::TryFrom, fmt::{Debug, Display}, @@ -30,7 +32,7 @@ pub struct EventBuilder { impl EventBuilder where - E: FromBytes + Debug, + E: AFPluginFromBytes + Debug, { fn test(context: TestContext) -> Self { Self { @@ -60,27 +62,27 @@ where where Event: Eq + Hash + Debug + Clone + Display, { - self.context.request = Some(ModuleRequest::new(event)); + self.context.request = Some(AFPluginRequest::new(event)); self } pub fn sync_send(mut self) -> Self { let request = self.get_request(); - let resp = EventDispatcher::sync_send(self.dispatch(), request); + let resp = AFPluginDispatcher::sync_send(self.dispatch(), request); self.context.response = Some(resp); self } pub async fn async_send(mut self) -> Self { let request = self.get_request(); - let resp = EventDispatcher::async_send(self.dispatch(), request).await; + let resp = AFPluginDispatcher::async_send(self.dispatch(), request).await; self.context.response = Some(resp); self } pub fn parse(self) -> R where - R: FromBytes, + R: AFPluginFromBytes, { let response = self.get_response(); match response.clone().parse::() { @@ -105,7 +107,7 @@ where pub fn error(self) -> E { let response = self.get_response(); assert_eq!(response.status_code, StatusCode::Err); - >::try_from(response.payload).unwrap().into_inner() + >::try_from(response.payload).unwrap().into_inner() } pub fn assert_error(self) -> Self { @@ -118,7 +120,7 @@ where self } - fn dispatch(&self) -> Arc { + fn dispatch(&self) -> Arc { self.context.sdk.dispatcher() } @@ -130,7 +132,7 @@ where .clone() } - fn get_request(&mut self) -> ModuleRequest { + fn get_request(&mut self) -> AFPluginRequest { self.context.request.take().expect("must call event first") } } @@ -138,7 +140,7 @@ where #[derive(Clone)] pub struct TestContext { pub sdk: FlowySDKTest, - request: Option, + request: Option, response: Option, } diff --git a/frontend/rust-lib/flowy-test/src/helper.rs b/frontend/rust-lib/flowy-test/src/helper.rs index 3d9a9d06ac..aa1d812509 100644 --- a/frontend/rust-lib/flowy-test/src/helper.rs +++ b/frontend/rust-lib/flowy-test/src/helper.rs @@ -13,7 +13,7 @@ use flowy_user::{ errors::FlowyError, event_map::UserEvent::{InitUser, SignIn, SignOut, SignUp}, }; -use lib_dispatch::prelude::{EventDispatcher, ModuleRequest, ToBytes}; +use lib_dispatch::prelude::{AFPluginDispatcher, AFPluginRequest, ToBytes}; use std::{fs, path::PathBuf, sync::Arc}; pub struct ViewTest { @@ -161,7 +161,7 @@ pub struct SignUpContext { pub password: String, } -pub fn sign_up(dispatch: Arc) -> SignUpContext { +pub fn sign_up(dispatch: Arc) -> SignUpContext { let password = login_password(); let payload = SignUpPayloadPB { email: random_email(), @@ -171,8 +171,8 @@ pub fn sign_up(dispatch: Arc) -> SignUpContext { .into_bytes() .unwrap(); - let request = ModuleRequest::new(SignUp).payload(payload); - let user_profile = EventDispatcher::sync_send(dispatch, request) + let request = AFPluginRequest::new(SignUp).payload(payload); + let user_profile = AFPluginDispatcher::sync_send(dispatch, request) .parse::() .unwrap() .unwrap(); @@ -180,7 +180,7 @@ pub fn sign_up(dispatch: Arc) -> SignUpContext { SignUpContext { user_profile, password } } -pub async fn async_sign_up(dispatch: Arc) -> SignUpContext { +pub async fn async_sign_up(dispatch: Arc) -> SignUpContext { let password = login_password(); let email = random_email(); let payload = SignUpPayloadPB { @@ -191,8 +191,8 @@ pub async fn async_sign_up(dispatch: Arc) -> SignUpContext { .into_bytes() .unwrap(); - let request = ModuleRequest::new(SignUp).payload(payload); - let user_profile = EventDispatcher::async_send(dispatch.clone(), request) + let request = AFPluginRequest::new(SignUp).payload(payload); + let user_profile = AFPluginDispatcher::async_send(dispatch.clone(), request) .await .parse::() .unwrap() @@ -202,13 +202,13 @@ pub async fn async_sign_up(dispatch: Arc) -> SignUpContext { SignUpContext { user_profile, password } } -pub async fn init_user_setting(dispatch: Arc) { - let request = ModuleRequest::new(InitUser); - let _ = EventDispatcher::async_send(dispatch.clone(), request).await; +pub async fn init_user_setting(dispatch: Arc) { + let request = AFPluginRequest::new(InitUser); + let _ = AFPluginDispatcher::async_send(dispatch.clone(), request).await; } #[allow(dead_code)] -fn sign_in(dispatch: Arc) -> UserProfilePB { +fn sign_in(dispatch: Arc) -> UserProfilePB { let payload = SignInPayloadPB { email: login_email(), password: login_password(), @@ -217,14 +217,14 @@ fn sign_in(dispatch: Arc) -> UserProfilePB { .into_bytes() .unwrap(); - let request = ModuleRequest::new(SignIn).payload(payload); - EventDispatcher::sync_send(dispatch, request) + let request = AFPluginRequest::new(SignIn).payload(payload); + AFPluginDispatcher::sync_send(dispatch, request) .parse::() .unwrap() .unwrap() } #[allow(dead_code)] -fn logout(dispatch: Arc) { - let _ = EventDispatcher::sync_send(dispatch, ModuleRequest::new(SignOut)); +fn logout(dispatch: Arc) { + let _ = AFPluginDispatcher::sync_send(dispatch, AFPluginRequest::new(SignOut)); } diff --git a/frontend/rust-lib/flowy-user/src/event_map.rs b/frontend/rust-lib/flowy-user/src/event_map.rs index a6a6d69f5c..c543e895d3 100644 --- a/frontend/rust-lib/flowy-user/src/event_map.rs +++ b/frontend/rust-lib/flowy-user/src/event_map.rs @@ -6,10 +6,10 @@ use lib_dispatch::prelude::*; use lib_infra::future::FutureResult; use std::sync::Arc; -pub fn create(user_session: Arc) -> Module { - Module::new() +pub fn init(user_session: Arc) -> AFPlugin { + AFPlugin::new() .name("Flowy-User") - .data(user_session) + .state(user_session) .event(UserEvent::SignIn, sign_in) .event(UserEvent::SignUp, sign_up) .event(UserEvent::InitUser, init_user_handler) diff --git a/frontend/rust-lib/flowy-user/src/handlers/auth_handler.rs b/frontend/rust-lib/flowy-user/src/handlers/auth_handler.rs index 8ff5bdb7e2..e8a69ee239 100644 --- a/frontend/rust-lib/flowy-user/src/handlers/auth_handler.rs +++ b/frontend/rust-lib/flowy-user/src/handlers/auth_handler.rs @@ -7,8 +7,8 @@ use std::{convert::TryInto, sync::Arc}; // tracing instrument 👉🏻 https://docs.rs/tracing/0.1.26/tracing/attr.instrument.html #[tracing::instrument(level = "debug", name = "sign_in", skip(data, session), fields(email = %data.email), err)] pub async fn sign_in( - data: Data, - session: AppData>, + data: AFPluginData, + session: AFPluginState>, ) -> DataResult { let params: SignInParams = data.into_inner().try_into()?; let user_profile = session.sign_in(params).await?; @@ -26,8 +26,8 @@ pub async fn sign_in( err )] pub async fn sign_up( - data: Data, - session: AppData>, + data: AFPluginData, + session: AFPluginState>, ) -> DataResult { let params: SignUpParams = data.into_inner().try_into()?; let user_profile = session.sign_up(params).await?; diff --git a/frontend/rust-lib/flowy-user/src/handlers/user_handler.rs b/frontend/rust-lib/flowy-user/src/handlers/user_handler.rs index 1abc30e2c6..602e0d9ddd 100644 --- a/frontend/rust-lib/flowy-user/src/handlers/user_handler.rs +++ b/frontend/rust-lib/flowy-user/src/handlers/user_handler.rs @@ -8,33 +8,35 @@ use lib_dispatch::prelude::*; use std::{convert::TryInto, sync::Arc}; #[tracing::instrument(level = "debug", skip(session))] -pub async fn init_user_handler(session: AppData>) -> Result<(), FlowyError> { +pub async fn init_user_handler(session: AFPluginState>) -> Result<(), FlowyError> { let _ = session.init_user().await?; Ok(()) } #[tracing::instrument(level = "debug", skip(session))] -pub async fn check_user_handler(session: AppData>) -> DataResult { +pub async fn check_user_handler(session: AFPluginState>) -> DataResult { let user_profile = session.check_user().await?; data_result(user_profile) } #[tracing::instrument(level = "debug", skip(session))] -pub async fn get_user_profile_handler(session: AppData>) -> DataResult { +pub async fn get_user_profile_handler( + session: AFPluginState>, +) -> DataResult { let user_profile = session.get_user_profile().await?; data_result(user_profile) } #[tracing::instrument(level = "debug", name = "sign_out", skip(session))] -pub async fn sign_out(session: AppData>) -> Result<(), FlowyError> { +pub async fn sign_out(session: AFPluginState>) -> Result<(), FlowyError> { let _ = session.sign_out().await?; Ok(()) } #[tracing::instrument(level = "debug", skip(data, session))] pub async fn update_user_profile_handler( - data: Data, - session: AppData>, + data: AFPluginData, + session: AFPluginState>, ) -> Result<(), FlowyError> { let params: UpdateUserProfileParams = data.into_inner().try_into()?; session.update_user_profile(params).await?; @@ -44,7 +46,7 @@ pub async fn update_user_profile_handler( const APPEARANCE_SETTING_CACHE_KEY: &str = "appearance_settings"; #[tracing::instrument(level = "debug", skip(data), err)] -pub async fn set_appearance_setting(data: Data) -> Result<(), FlowyError> { +pub async fn set_appearance_setting(data: AFPluginData) -> Result<(), FlowyError> { let mut setting = data.into_inner(); if setting.theme.is_empty() { setting.theme = APPEARANCE_DEFAULT_THEME.to_string(); @@ -73,7 +75,7 @@ pub async fn get_appearance_setting() -> DataResult>) -> DataResult { +pub async fn get_user_setting(session: AFPluginState>) -> DataResult { let user_setting = session.user_setting()?; data_result(user_setting) } diff --git a/frontend/rust-lib/lib-dispatch/src/byte_trait.rs b/frontend/rust-lib/lib-dispatch/src/byte_trait.rs index 0e48813afd..d81906082e 100644 --- a/frontend/rust-lib/lib-dispatch/src/byte_trait.rs +++ b/frontend/rust-lib/lib-dispatch/src/byte_trait.rs @@ -39,12 +39,12 @@ where // From bytes -pub trait FromBytes: Sized { +pub trait AFPluginFromBytes: Sized { fn parse_from_bytes(bytes: Bytes) -> Result; } #[cfg(feature = "use_protobuf")] -impl FromBytes for T +impl AFPluginFromBytes for T where // // https://stackoverflow.com/questions/62871045/tryfromu8-trait-bound-in-trait // T: for<'a> std::convert::TryFrom<&'a Bytes, Error = @@ -67,7 +67,7 @@ where } #[cfg(feature = "use_serde")] -impl FromBytes for T +impl AFPluginFromBytes for T where T: serde::de::DeserializeOwned + 'static, { diff --git a/frontend/rust-lib/lib-dispatch/src/data.rs b/frontend/rust-lib/lib-dispatch/src/data.rs index 74d5ab6f17..901529c05c 100644 --- a/frontend/rust-lib/lib-dispatch/src/data.rs +++ b/frontend/rust-lib/lib-dispatch/src/data.rs @@ -1,22 +1,22 @@ use crate::{ byte_trait::*, errors::{DispatchError, InternalError}, - request::{unexpected_none_payload, EventRequest, FromRequest, Payload}, - response::{EventResponse, Responder, ResponseBuilder}, + request::{unexpected_none_payload, AFPluginEventRequest, FromAFPluginRequest, Payload}, + response::{AFPluginResponder, EventResponse, ResponseBuilder}, util::ready::{ready, Ready}, }; use bytes::Bytes; use std::ops; -pub struct Data(pub T); +pub struct AFPluginData(pub T); -impl Data { +impl AFPluginData { pub fn into_inner(self) -> T { self.0 } } -impl ops::Deref for Data { +impl ops::Deref for AFPluginData { type Target = T; fn deref(&self) -> &T { @@ -24,36 +24,36 @@ impl ops::Deref for Data { } } -impl ops::DerefMut for Data { +impl ops::DerefMut for AFPluginData { fn deref_mut(&mut self) -> &mut T { &mut self.0 } } -impl FromRequest for Data +impl FromAFPluginRequest for AFPluginData where - T: FromBytes + 'static, + T: AFPluginFromBytes + 'static, { type Error = DispatchError; type Future = Ready>; #[inline] - fn from_request(req: &EventRequest, payload: &mut Payload) -> Self::Future { + fn from_request(req: &AFPluginEventRequest, payload: &mut Payload) -> Self::Future { match payload { Payload::None => ready(Err(unexpected_none_payload(req))), Payload::Bytes(bytes) => match T::parse_from_bytes(bytes.clone()) { - Ok(data) => ready(Ok(Data(data))), + Ok(data) => ready(Ok(AFPluginData(data))), Err(e) => ready(Err(InternalError::DeserializeFromBytes(format!("{}", e)).into())), }, } } } -impl Responder for Data +impl AFPluginResponder for AFPluginData where T: ToBytes, { - fn respond_to(self, _request: &EventRequest) -> EventResponse { + fn respond_to(self, _request: &AFPluginEventRequest) -> EventResponse { match self.into_inner().into_bytes() { Ok(bytes) => { log::trace!("Serialize Data: {:?} to event response", std::any::type_name::()); @@ -64,29 +64,29 @@ where } } -impl std::convert::TryFrom<&Payload> for Data +impl std::convert::TryFrom<&Payload> for AFPluginData where - T: FromBytes, + T: AFPluginFromBytes, { type Error = DispatchError; - fn try_from(payload: &Payload) -> Result, Self::Error> { + fn try_from(payload: &Payload) -> Result, Self::Error> { parse_payload(payload) } } -impl std::convert::TryFrom for Data +impl std::convert::TryFrom for AFPluginData where - T: FromBytes, + T: AFPluginFromBytes, { type Error = DispatchError; - fn try_from(payload: Payload) -> Result, Self::Error> { + fn try_from(payload: Payload) -> Result, Self::Error> { parse_payload(&payload) } } -fn parse_payload(payload: &Payload) -> Result, DispatchError> +fn parse_payload(payload: &Payload) -> Result, DispatchError> where - T: FromBytes, + T: AFPluginFromBytes, { match payload { Payload::None => Err(InternalError::UnexpectedNone(format!( @@ -96,12 +96,12 @@ where .into()), Payload::Bytes(bytes) => { let data = T::parse_from_bytes(bytes.clone())?; - Ok(Data(data)) + Ok(AFPluginData(data)) } } } -impl std::convert::TryInto for Data +impl std::convert::TryInto for AFPluginData where T: ToBytes, { @@ -114,7 +114,7 @@ where } } -impl ToBytes for Data { +impl ToBytes for AFPluginData { fn into_bytes(self) -> Result { Ok(Bytes::from(self.0)) } diff --git a/frontend/rust-lib/lib-dispatch/src/dispatcher.rs b/frontend/rust-lib/lib-dispatch/src/dispatcher.rs index 961f19986b..a90e10d744 100644 --- a/frontend/rust-lib/lib-dispatch/src/dispatcher.rs +++ b/frontend/rust-lib/lib-dispatch/src/dispatcher.rs @@ -1,9 +1,9 @@ -use crate::runtime::FlowyRuntime; +use crate::runtime::AFPluginRuntime; use crate::{ errors::{DispatchError, Error, InternalError}, - module::{as_module_map, Module, ModuleMap, ModuleRequest}, + module::{as_plugin_map, AFPlugin, AFPluginMap, AFPluginRequest}, response::EventResponse, - service::{Service, ServiceFactory}, + service::{AFPluginServiceFactory, Service}, }; use derivative::*; use futures_core::future::BoxFuture; @@ -12,42 +12,43 @@ use pin_project::pin_project; use std::{future::Future, sync::Arc}; use tokio::macros::support::{Pin, Poll}; -pub struct EventDispatcher { - module_map: ModuleMap, - runtime: FlowyRuntime, +pub struct AFPluginDispatcher { + plugins: AFPluginMap, + runtime: AFPluginRuntime, } -impl EventDispatcher { - pub fn construct(runtime: FlowyRuntime, module_factory: F) -> EventDispatcher +impl AFPluginDispatcher { + pub fn construct(runtime: AFPluginRuntime, module_factory: F) -> AFPluginDispatcher where - F: FnOnce() -> Vec, + F: FnOnce() -> Vec, { - let modules = module_factory(); - tracing::trace!("{}", module_info(&modules)); - let module_map = as_module_map(modules); - - EventDispatcher { module_map, runtime } + let plugins = module_factory(); + tracing::trace!("{}", plugin_info(&plugins)); + AFPluginDispatcher { + plugins: as_plugin_map(plugins), + runtime, + } } - pub fn async_send(dispatch: Arc, request: Req) -> DispatchFuture + pub fn async_send(dispatch: Arc, request: Req) -> DispatchFuture where - Req: std::convert::Into, + Req: std::convert::Into, { - EventDispatcher::async_send_with_callback(dispatch, request, |_| Box::pin(async {})) + AFPluginDispatcher::async_send_with_callback(dispatch, request, |_| Box::pin(async {})) } pub fn async_send_with_callback( - dispatch: Arc, + dispatch: Arc, request: Req, callback: Callback, ) -> DispatchFuture where - Req: std::convert::Into, + Req: std::convert::Into, Callback: FnOnce(EventResponse) -> BoxFuture<'static, ()> + 'static + Send + Sync, { - let request: ModuleRequest = request.into(); - let module_map = dispatch.module_map.clone(); - let service = Box::new(DispatchService { module_map }); + let request: AFPluginRequest = request.into(); + let plugins = dispatch.plugins.clone(); + let service = Box::new(DispatchService { plugins }); tracing::trace!("Async event: {:?}", &request.event); let service_ctx = DispatchContext { request, @@ -72,9 +73,9 @@ impl EventDispatcher { } } - pub fn sync_send(dispatch: Arc, request: ModuleRequest) -> EventResponse { + pub fn sync_send(dispatch: Arc, request: AFPluginRequest) -> EventResponse { futures::executor::block_on(async { - EventDispatcher::async_send_with_callback(dispatch, request, |_| Box::pin(async {})).await + AFPluginDispatcher::async_send_with_callback(dispatch, request, |_| Box::pin(async {})).await }) } @@ -109,20 +110,20 @@ pub type BoxFutureCallback = Box BoxFuture<'static, #[derive(Derivative)] #[derivative(Debug)] pub struct DispatchContext { - pub request: ModuleRequest, + pub request: AFPluginRequest, #[derivative(Debug = "ignore")] pub callback: Option, } impl DispatchContext { - pub(crate) fn into_parts(self) -> (ModuleRequest, Option) { + pub(crate) fn into_parts(self) -> (AFPluginRequest, Option) { let DispatchContext { request, callback } = self; (request, callback) } } pub(crate) struct DispatchService { - pub(crate) module_map: ModuleMap, + pub(crate) plugins: AFPluginMap, } impl Service for DispatchService { @@ -135,7 +136,7 @@ impl Service for DispatchService { tracing::instrument(name = "DispatchService", level = "debug", skip(self, ctx)) )] fn call(&self, ctx: DispatchContext) -> Self::Future { - let module_map = self.module_map.clone(); + let module_map = self.plugins.clone(); let (request, callback) = ctx.into_parts(); Box::pin(async move { @@ -168,17 +169,17 @@ impl Service for DispatchService { } #[allow(dead_code)] -fn module_info(modules: &[Module]) -> String { - let mut info = format!("{} modules loaded\n", modules.len()); - for module in modules { +fn plugin_info(plugins: &[AFPlugin]) -> String { + let mut info = format!("{} plugins loaded\n", plugins.len()); + for module in plugins { info.push_str(&format!("-> {} loaded \n", module.name)); } info } #[allow(dead_code)] -fn print_module_map_info(module_map: &ModuleMap) { - module_map.iter().for_each(|(k, v)| { - tracing::info!("Event: {:?} module: {:?}", k, v.name); +fn print_plugins(plugins: &AFPluginMap) { + plugins.iter().for_each(|(k, v)| { + tracing::info!("Event: {:?} plugin : {:?}", k, v.name); }) } diff --git a/frontend/rust-lib/lib-dispatch/src/errors/errors.rs b/frontend/rust-lib/lib-dispatch/src/errors/errors.rs index e469b186bf..5d43a4b496 100644 --- a/frontend/rust-lib/lib-dispatch/src/errors/errors.rs +++ b/frontend/rust-lib/lib-dispatch/src/errors/errors.rs @@ -1,6 +1,6 @@ use crate::{ - byte_trait::FromBytes, - request::EventRequest, + byte_trait::AFPluginFromBytes, + request::AFPluginEventRequest, response::{EventResponse, ResponseBuilder}, }; use bytes::Bytes; @@ -54,8 +54,8 @@ impl std::error::Error for DispatchError { } } -impl From> for DispatchError { - fn from(err: SendError) -> Self { +impl From> for DispatchError { + fn from(err: SendError) -> Self { InternalError::Other(format!("{}", err)).into() } } @@ -73,7 +73,7 @@ impl From for DispatchError { } } -impl FromBytes for DispatchError { +impl AFPluginFromBytes for DispatchError { fn parse_from_bytes(bytes: Bytes) -> Result { let s = String::from_utf8(bytes.to_vec()).unwrap(); Ok(InternalError::DeserializeFromBytes(s).into()) diff --git a/frontend/rust-lib/lib-dispatch/src/module/container.rs b/frontend/rust-lib/lib-dispatch/src/module/container.rs index 89a71a15b2..fb0a1c84b8 100644 --- a/frontend/rust-lib/lib-dispatch/src/module/container.rs +++ b/frontend/rust-lib/lib-dispatch/src/module/container.rs @@ -4,46 +4,40 @@ use std::{ }; #[derive(Default, Debug)] -pub struct ModuleDataMap { - map: HashMap>, -} +pub struct AFPluginStateMap(HashMap>); -impl ModuleDataMap { +impl AFPluginStateMap { #[inline] - pub fn new() -> ModuleDataMap { - ModuleDataMap { - map: HashMap::default(), - } + pub fn new() -> AFPluginStateMap { + AFPluginStateMap(HashMap::default()) } pub fn insert(&mut self, val: T) -> Option where T: 'static + Send + Sync, { - self.map - .insert(TypeId::of::(), Box::new(val)) - .and_then(downcast_owned) + self.0.insert(TypeId::of::(), Box::new(val)).and_then(downcast_owned) } pub fn remove(&mut self) -> Option where T: 'static + Send + Sync, { - self.map.remove(&TypeId::of::()).and_then(downcast_owned) + self.0.remove(&TypeId::of::()).and_then(downcast_owned) } pub fn get(&self) -> Option<&T> where T: 'static + Send + Sync, { - self.map.get(&TypeId::of::()).and_then(|boxed| boxed.downcast_ref()) + self.0.get(&TypeId::of::()).and_then(|boxed| boxed.downcast_ref()) } pub fn get_mut(&mut self) -> Option<&mut T> where T: 'static + Send + Sync, { - self.map + self.0 .get_mut(&TypeId::of::()) .and_then(|boxed| boxed.downcast_mut()) } @@ -52,11 +46,11 @@ impl ModuleDataMap { where T: 'static + Send + Sync, { - self.map.contains_key(&TypeId::of::()) + self.0.contains_key(&TypeId::of::()) } - pub fn extend(&mut self, other: ModuleDataMap) { - self.map.extend(other.map); + pub fn extend(&mut self, other: AFPluginStateMap) { + self.0.extend(other.0); } } diff --git a/frontend/rust-lib/lib-dispatch/src/module/data.rs b/frontend/rust-lib/lib-dispatch/src/module/data.rs index 59e9b91086..16c80f3acd 100644 --- a/frontend/rust-lib/lib-dispatch/src/module/data.rs +++ b/frontend/rust-lib/lib-dispatch/src/module/data.rs @@ -1,18 +1,18 @@ use crate::{ errors::{DispatchError, InternalError}, - request::{payload::Payload, EventRequest, FromRequest}, + request::{payload::Payload, AFPluginEventRequest, FromAFPluginRequest}, util::ready::{ready, Ready}, }; use std::{any::type_name, ops::Deref, sync::Arc}; -pub struct AppData(Arc); +pub struct AFPluginState(Arc); -impl AppData +impl AFPluginState where T: Send + Sync, { pub fn new(data: T) -> Self { - AppData(Arc::new(data)) + AFPluginState(Arc::new(data)) } pub fn get_ref(&self) -> &T { @@ -20,7 +20,7 @@ where } } -impl Deref for AppData +impl Deref for AFPluginState where T: ?Sized + Send + Sync, { @@ -31,25 +31,25 @@ where } } -impl Clone for AppData +impl Clone for AFPluginState where T: ?Sized + Send + Sync, { - fn clone(&self) -> AppData { - AppData(self.0.clone()) + fn clone(&self) -> AFPluginState { + AFPluginState(self.0.clone()) } } -impl From> for AppData +impl From> for AFPluginState where T: ?Sized + Send + Sync, { fn from(arc: Arc) -> Self { - AppData(arc) + AFPluginState(arc) } } -impl FromRequest for AppData +impl FromAFPluginRequest for AFPluginState where T: ?Sized + Send + Sync + 'static, { @@ -57,11 +57,11 @@ where type Future = Ready>; #[inline] - fn from_request(req: &EventRequest, _: &mut Payload) -> Self::Future { - if let Some(data) = req.module_data::>() { - ready(Ok(data.clone())) + fn from_request(req: &AFPluginEventRequest, _: &mut Payload) -> Self::Future { + if let Some(state) = req.get_state::>() { + ready(Ok(state.clone())) } else { - let msg = format!("Failed to get the module data of type: {}", type_name::()); + let msg = format!("Failed to get the plugin state of type: {}", type_name::()); log::error!("{}", msg,); ready(Err(InternalError::Other(msg).into())) } diff --git a/frontend/rust-lib/lib-dispatch/src/module/module.rs b/frontend/rust-lib/lib-dispatch/src/module/module.rs index d8fe647fdf..f560501397 100644 --- a/frontend/rust-lib/lib-dispatch/src/module/module.rs +++ b/frontend/rust-lib/lib-dispatch/src/module/module.rs @@ -1,3 +1,18 @@ +use crate::{ + errors::{DispatchError, InternalError}, + module::{container::AFPluginStateMap, AFPluginState}, + request::{payload::Payload, AFPluginEventRequest, FromAFPluginRequest}, + response::{AFPluginResponder, EventResponse}, + service::{ + factory, AFPluginHandler, AFPluginHandlerService, AFPluginServiceFactory, BoxService, BoxServiceFactory, + Service, ServiceRequest, ServiceResponse, + }, +}; +use futures_core::future::BoxFuture; +use futures_core::ready; +use nanoid::nanoid; +use pin_project::pin_project; +use std::sync::Arc; use std::{ collections::HashMap, fmt, @@ -8,66 +23,48 @@ use std::{ task::{Context, Poll}, }; -use futures_core::ready; -use pin_project::pin_project; - -use crate::{ - errors::{DispatchError, InternalError}, - module::{container::ModuleDataMap, AppData}, - request::{payload::Payload, EventRequest, FromRequest}, - response::{EventResponse, Responder}, - service::{ - factory, BoxService, BoxServiceFactory, Handler, HandlerService, Service, ServiceFactory, ServiceRequest, - ServiceResponse, - }, -}; -use futures_core::future::BoxFuture; -use nanoid::nanoid; -use std::sync::Arc; - -pub type ModuleMap = Arc>>; -pub(crate) fn as_module_map(modules: Vec) -> ModuleMap { - let mut module_map = HashMap::new(); - modules.into_iter().for_each(|m| { +pub type AFPluginMap = Arc>>; +pub(crate) fn as_plugin_map(plugins: Vec) -> AFPluginMap { + let mut plugin_map = HashMap::new(); + plugins.into_iter().for_each(|m| { let events = m.events(); - let module = Arc::new(m); + let plugins = Arc::new(m); events.into_iter().for_each(|e| { - module_map.insert(e, module.clone()); + plugin_map.insert(e, plugins.clone()); }); }); - Arc::new(module_map) + Arc::new(plugin_map) } #[derive(PartialEq, Eq, Hash, Debug, Clone)] -pub struct Event(String); +pub struct AFPluginEvent(String); -impl std::convert::From for Event { +impl std::convert::From for AFPluginEvent { fn from(t: T) -> Self { - Event(format!("{}", t)) + AFPluginEvent(format!("{}", t)) } } -pub type EventServiceFactory = BoxServiceFactory<(), ServiceRequest, ServiceResponse, DispatchError>; - -pub struct Module { +pub struct AFPlugin { pub name: String, - module_data: Arc, - service_map: Arc>, + states: Arc, + event_service_factory: + Arc>>, } -impl std::default::Default for Module { +impl std::default::Default for AFPlugin { fn default() -> Self { Self { name: "".to_owned(), - module_data: Arc::new(ModuleDataMap::new()), - service_map: Arc::new(HashMap::new()), + states: Arc::new(AFPluginStateMap::new()), + event_service_factory: Arc::new(HashMap::new()), } } } -impl Module { +impl AFPlugin { pub fn new() -> Self { - Module::default() + AFPlugin::default() } pub fn name(mut self, s: &str) -> Self { @@ -75,48 +72,48 @@ impl Module { self } - pub fn data(mut self, data: D) -> Self { - Arc::get_mut(&mut self.module_data).unwrap().insert(AppData::new(data)); + pub fn state(mut self, data: D) -> Self { + Arc::get_mut(&mut self.states).unwrap().insert(AFPluginState::new(data)); self } pub fn event(mut self, event: E, handler: H) -> Self where - H: Handler, - T: FromRequest + 'static + Send + Sync, - ::Future: Sync + Send, + H: AFPluginHandler, + T: FromAFPluginRequest + 'static + Send + Sync, + ::Future: Sync + Send, R: Future + 'static + Send + Sync, - R::Output: Responder + 'static, + R::Output: AFPluginResponder + 'static, E: Eq + Hash + Debug + Clone + Display, { - let event: Event = event.into(); - if self.service_map.contains_key(&event) { + let event: AFPluginEvent = event.into(); + if self.event_service_factory.contains_key(&event) { log::error!("Duplicate Event: {:?}", &event); } - Arc::get_mut(&mut self.service_map) + Arc::get_mut(&mut self.event_service_factory) .unwrap() - .insert(event, factory(HandlerService::new(handler))); + .insert(event, factory(AFPluginHandlerService::new(handler))); self } - pub fn events(&self) -> Vec { - self.service_map.keys().cloned().collect::>() + pub fn events(&self) -> Vec { + self.event_service_factory.keys().cloned().collect::>() } } #[derive(Debug, Clone)] -pub struct ModuleRequest { +pub struct AFPluginRequest { pub id: String, - pub event: Event, + pub event: AFPluginEvent, pub(crate) payload: Payload, } -impl ModuleRequest { +impl AFPluginRequest { pub fn new(event: E) -> Self where - E: Into, + E: Into, { Self { id: nanoid!(6), @@ -134,52 +131,48 @@ impl ModuleRequest { } } -impl std::fmt::Display for ModuleRequest { +impl std::fmt::Display for AFPluginRequest { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}:{:?}", self.id, self.event) } } -impl ServiceFactory for Module { +impl AFPluginServiceFactory for AFPlugin { type Response = EventResponse; type Error = DispatchError; - type Service = BoxService; + type Service = BoxService; type Context = (); type Future = BoxFuture<'static, Result>; fn new_service(&self, _cfg: Self::Context) -> Self::Future { - let service_map = self.service_map.clone(); - let module_data = self.module_data.clone(); + let services = self.event_service_factory.clone(); + let states = self.states.clone(); Box::pin(async move { - let service = ModuleService { - service_map, - module_data, - }; - let module_service = Box::new(service) as Self::Service; - Ok(module_service) + let service = AFPluginService { services, states }; + Ok(Box::new(service) as Self::Service) }) } } -pub struct ModuleService { - service_map: Arc>, - module_data: Arc, +pub struct AFPluginService { + services: Arc>>, + states: Arc, } -impl Service for ModuleService { +impl Service for AFPluginService { type Response = EventResponse; type Error = DispatchError; type Future = BoxFuture<'static, Result>; - fn call(&self, request: ModuleRequest) -> Self::Future { - let ModuleRequest { id, event, payload } = request; - let module_data = self.module_data.clone(); - let request = EventRequest::new(id, event, module_data); + fn call(&self, request: AFPluginRequest) -> Self::Future { + let AFPluginRequest { id, event, payload } = request; + let states = self.states.clone(); + let request = AFPluginEventRequest::new(id, event, states); - match self.service_map.get(&request.event) { + match self.services.get(&request.event) { Some(factory) => { let service_fut = factory.new_service(()); - let fut = ModuleServiceFuture { + let fut = AFPluginServiceFuture { fut: Box::pin(async { let service = service_fut.await?; let service_req = ServiceRequest::new(request, payload); @@ -197,12 +190,12 @@ impl Service for ModuleService { } #[pin_project] -pub struct ModuleServiceFuture { +pub struct AFPluginServiceFuture { #[pin] fut: BoxFuture<'static, Result>, } -impl Future for ModuleServiceFuture { +impl Future for AFPluginServiceFuture { type Output = Result; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { @@ -210,36 +203,3 @@ impl Future for ModuleServiceFuture { Poll::Ready(Ok(response)) } } - -// #[cfg(test)] -// mod tests { -// use super::*; -// use crate::rt::Runtime; -// use futures_util::{future, pin_mut}; -// use tokio::sync::mpsc::unbounded_channel; -// pub async fn hello_service() -> String { "hello".to_string() } -// #[test] -// fn test() { -// let runtime = Runtime::new().unwrap(); -// runtime.block_on(async { -// let (sys_tx, mut sys_rx) = unbounded_channel::(); -// let event = "hello".to_string(); -// let module = Module::new(sys_tx).event(event.clone(), -// hello_service); let req_tx = module.req_tx(); -// let event = async move { -// let request = EventRequest::new(event.clone()); -// req_tx.send(request).unwrap(); -// -// match sys_rx.recv().await { -// Some(cmd) => { -// tracing::info!("{:?}", cmd); -// }, -// None => panic!(""), -// } -// }; -// -// pin_mut!(module, event); -// future::select(module, event).await; -// }); -// } -// } diff --git a/frontend/rust-lib/lib-dispatch/src/request/request.rs b/frontend/rust-lib/lib-dispatch/src/request/request.rs index 3004915366..32ea3c592a 100644 --- a/frontend/rust-lib/lib-dispatch/src/request/request.rs +++ b/frontend/rust-lib/lib-dispatch/src/request/request.rs @@ -2,7 +2,7 @@ use std::future::Future; use crate::{ errors::{DispatchError, InternalError}, - module::{Event, ModuleDataMap}, + module::{AFPluginEvent, AFPluginStateMap}, request::payload::Payload, util::ready::{ready, Ready}, }; @@ -16,31 +16,31 @@ use std::{ }; #[derive(Clone, Debug, Derivative)] -pub struct EventRequest { +pub struct AFPluginEventRequest { #[allow(dead_code)] pub(crate) id: String, - pub(crate) event: Event, + pub(crate) event: AFPluginEvent, #[derivative(Debug = "ignore")] - pub(crate) module_data: Arc, + pub(crate) states: Arc, } -impl EventRequest { - pub fn new(id: String, event: E, module_data: Arc) -> EventRequest +impl AFPluginEventRequest { + pub fn new(id: String, event: E, module_data: Arc) -> AFPluginEventRequest where - E: Into, + E: Into, { Self { id, event: event.into(), - module_data, + states: module_data, } } - pub fn module_data(&self) -> Option<&T> + pub fn get_state(&self) -> Option<&T> where T: Send + Sync, { - if let Some(data) = self.module_data.get::() { + if let Some(data) = self.states.get::() { return Some(data); } @@ -48,29 +48,29 @@ impl EventRequest { } } -pub trait FromRequest: Sized { +pub trait FromAFPluginRequest: Sized { type Error: Into; type Future: Future>; - fn from_request(req: &EventRequest, payload: &mut Payload) -> Self::Future; + fn from_request(req: &AFPluginEventRequest, payload: &mut Payload) -> Self::Future; } #[doc(hidden)] -impl FromRequest for () { +impl FromAFPluginRequest for () { type Error = DispatchError; type Future = Ready>; - fn from_request(_req: &EventRequest, _payload: &mut Payload) -> Self::Future { + fn from_request(_req: &AFPluginEventRequest, _payload: &mut Payload) -> Self::Future { ready(Ok(())) } } #[doc(hidden)] -impl FromRequest for String { +impl FromAFPluginRequest for String { type Error = DispatchError; type Future = Ready>; - fn from_request(req: &EventRequest, payload: &mut Payload) -> Self::Future { + fn from_request(req: &AFPluginEventRequest, payload: &mut Payload) -> Self::Future { match &payload { Payload::None => ready(Err(unexpected_none_payload(req))), Payload::Bytes(buf) => ready(Ok(String::from_utf8_lossy(buf).into_owned())), @@ -78,20 +78,20 @@ impl FromRequest for String { } } -pub fn unexpected_none_payload(request: &EventRequest) -> DispatchError { +pub fn unexpected_none_payload(request: &AFPluginEventRequest) -> DispatchError { log::warn!("{:?} expected payload", &request.event); InternalError::UnexpectedNone("Expected payload".to_string()).into() } #[doc(hidden)] -impl FromRequest for Result +impl FromAFPluginRequest for Result where - T: FromRequest, + T: FromAFPluginRequest, { type Error = DispatchError; type Future = FromRequestFuture; - fn from_request(req: &EventRequest, payload: &mut Payload) -> Self::Future { + fn from_request(req: &AFPluginEventRequest, payload: &mut Payload) -> Self::Future { FromRequestFuture { fut: T::from_request(req, payload), } diff --git a/frontend/rust-lib/lib-dispatch/src/response/responder.rs b/frontend/rust-lib/lib-dispatch/src/response/responder.rs index 35e38d0a8e..efd1c5ede1 100644 --- a/frontend/rust-lib/lib-dispatch/src/response/responder.rs +++ b/frontend/rust-lib/lib-dispatch/src/response/responder.rs @@ -1,19 +1,19 @@ #[allow(unused_imports)] use crate::errors::{DispatchError, InternalError}; use crate::{ - request::EventRequest, + request::AFPluginEventRequest, response::{EventResponse, ResponseBuilder}, }; use bytes::Bytes; -pub trait Responder { - fn respond_to(self, req: &EventRequest) -> EventResponse; +pub trait AFPluginResponder { + fn respond_to(self, req: &AFPluginEventRequest) -> EventResponse; } macro_rules! impl_responder { ($res: ty) => { - impl Responder for $res { - fn respond_to(self, _: &EventRequest) -> EventResponse { + impl AFPluginResponder for $res { + fn respond_to(self, _: &AFPluginEventRequest) -> EventResponse { ResponseBuilder::Ok().data(self).build() } } @@ -27,12 +27,12 @@ impl_responder!(Bytes); impl_responder!(()); impl_responder!(Vec); -impl Responder for Result +impl AFPluginResponder for Result where - T: Responder, + T: AFPluginResponder, E: Into, { - fn respond_to(self, request: &EventRequest) -> EventResponse { + fn respond_to(self, request: &AFPluginEventRequest) -> EventResponse { match self { Ok(val) => val.respond_to(request), Err(e) => e.into().into(), diff --git a/frontend/rust-lib/lib-dispatch/src/response/response.rs b/frontend/rust-lib/lib-dispatch/src/response/response.rs index a745f8ee1a..69abb82f8f 100644 --- a/frontend/rust-lib/lib-dispatch/src/response/response.rs +++ b/frontend/rust-lib/lib-dispatch/src/response/response.rs @@ -1,9 +1,9 @@ use crate::{ - byte_trait::FromBytes, - data::Data, + byte_trait::AFPluginFromBytes, + data::AFPluginData, errors::DispatchError, - request::{EventRequest, Payload}, - response::Responder, + request::{AFPluginEventRequest, Payload}, + response::AFPluginResponder, }; use derivative::*; use std::{convert::TryFrom, fmt, fmt::Formatter}; @@ -35,16 +35,16 @@ impl EventResponse { pub fn parse(self) -> Result, DispatchError> where - T: FromBytes, - E: FromBytes, + T: AFPluginFromBytes, + E: AFPluginFromBytes, { match self.status_code { StatusCode::Ok => { - let data = >::try_from(self.payload)?; + let data = >::try_from(self.payload)?; Ok(Ok(data.into_inner())) } StatusCode::Err | StatusCode::Internal => { - let err = >::try_from(self.payload)?; + let err = >::try_from(self.payload)?; Ok(Err(err.into_inner())) } } @@ -64,18 +64,18 @@ impl std::fmt::Display for EventResponse { } } -impl Responder for EventResponse { +impl AFPluginResponder for EventResponse { #[inline] - fn respond_to(self, _: &EventRequest) -> EventResponse { + fn respond_to(self, _: &AFPluginEventRequest) -> EventResponse { self } } -pub type DataResult = std::result::Result, E>; +pub type DataResult = std::result::Result, E>; -pub fn data_result(data: T) -> Result, E> +pub fn data_result(data: T) -> Result, E> where E: Into, { - Ok(Data(data)) + Ok(AFPluginData(data)) } diff --git a/frontend/rust-lib/lib-dispatch/src/runtime.rs b/frontend/rust-lib/lib-dispatch/src/runtime.rs index de18d29963..b622332d78 100644 --- a/frontend/rust-lib/lib-dispatch/src/runtime.rs +++ b/frontend/rust-lib/lib-dispatch/src/runtime.rs @@ -1,9 +1,9 @@ use std::{io, thread}; use tokio::runtime; -pub type FlowyRuntime = tokio::runtime::Runtime; +pub type AFPluginRuntime = tokio::runtime::Runtime; -pub fn tokio_default_runtime() -> io::Result { +pub fn tokio_default_runtime() -> io::Result { runtime::Builder::new_multi_thread() .thread_name("dispatch-rt") .enable_io() diff --git a/frontend/rust-lib/lib-dispatch/src/service/boxed.rs b/frontend/rust-lib/lib-dispatch/src/service/boxed.rs index 342da26c6c..5d629e9101 100644 --- a/frontend/rust-lib/lib-dispatch/src/service/boxed.rs +++ b/frontend/rust-lib/lib-dispatch/src/service/boxed.rs @@ -1,23 +1,23 @@ -use crate::service::{Service, ServiceFactory}; +use crate::service::{AFPluginServiceFactory, Service}; use futures_core::future::BoxFuture; pub fn factory(factory: SF) -> BoxServiceFactory where - SF: ServiceFactory + 'static + Sync + Send, + SF: AFPluginServiceFactory + 'static + Sync + Send, Req: 'static, SF::Response: 'static, SF::Service: 'static, SF::Future: 'static, SF::Error: 'static + Send + Sync, - >::Service: Sync + Send, - <>::Service as Service>::Future: Send + Sync, - >::Future: Send + Sync, + >::Service: Sync + Send, + <>::Service as Service>::Future: Send + Sync, + >::Future: Send + Sync, { BoxServiceFactory(Box::new(FactoryWrapper(factory))) } type Inner = Box< - dyn ServiceFactory< + dyn AFPluginServiceFactory< Req, Context = Cfg, Response = Res, @@ -29,7 +29,7 @@ type Inner = Box< >; pub struct BoxServiceFactory(Inner); -impl ServiceFactory for BoxServiceFactory +impl AFPluginServiceFactory for BoxServiceFactory where Req: 'static, Res: 'static, @@ -98,16 +98,16 @@ where struct FactoryWrapper(SF); -impl ServiceFactory for FactoryWrapper +impl AFPluginServiceFactory for FactoryWrapper where Req: 'static, Res: 'static, Err: 'static, - SF: ServiceFactory, + SF: AFPluginServiceFactory, SF::Future: 'static, SF::Service: 'static + Send + Sync, - <>::Service as Service>::Future: Send + Sync + 'static, - >::Future: Send + Sync, + <>::Service as Service>::Future: Send + Sync + 'static, + >::Future: Send + Sync, { type Response = Res; type Error = Err; diff --git a/frontend/rust-lib/lib-dispatch/src/service/handler.rs b/frontend/rust-lib/lib-dispatch/src/service/handler.rs index 774b86114c..0f6a0ef9a5 100644 --- a/frontend/rust-lib/lib-dispatch/src/service/handler.rs +++ b/frontend/rust-lib/lib-dispatch/src/service/handler.rs @@ -10,37 +10,37 @@ use pin_project::pin_project; use crate::{ errors::DispatchError, - request::{payload::Payload, EventRequest, FromRequest}, - response::{EventResponse, Responder}, - service::{Service, ServiceFactory, ServiceRequest, ServiceResponse}, + request::{payload::Payload, AFPluginEventRequest, FromAFPluginRequest}, + response::{AFPluginResponder, EventResponse}, + service::{AFPluginServiceFactory, Service, ServiceRequest, ServiceResponse}, util::ready::*, }; -pub trait Handler: Clone + 'static + Sync + Send +pub trait AFPluginHandler: Clone + 'static + Sync + Send where R: Future + Send + Sync, - R::Output: Responder, + R::Output: AFPluginResponder, { fn call(&self, param: T) -> R; } -pub struct HandlerService +pub struct AFPluginHandlerService where - H: Handler, - T: FromRequest, + H: AFPluginHandler, + T: FromAFPluginRequest, R: Future + Sync + Send, - R::Output: Responder, + R::Output: AFPluginResponder, { handler: H, _phantom: PhantomData<(T, R)>, } -impl HandlerService +impl AFPluginHandlerService where - H: Handler, - T: FromRequest, + H: AFPluginHandler, + T: FromAFPluginRequest, R: Future + Sync + Send, - R::Output: Responder, + R::Output: AFPluginResponder, { pub fn new(handler: H) -> Self { Self { @@ -50,12 +50,12 @@ where } } -impl Clone for HandlerService +impl Clone for AFPluginHandlerService where - H: Handler, - T: FromRequest, + H: AFPluginHandler, + T: FromAFPluginRequest, R: Future + Sync + Send, - R::Output: Responder, + R::Output: AFPluginResponder, { fn clone(&self) -> Self { Self { @@ -65,12 +65,12 @@ where } } -impl ServiceFactory for HandlerService +impl AFPluginServiceFactory for AFPluginHandlerService where - F: Handler, - T: FromRequest, + F: AFPluginHandler, + T: FromAFPluginRequest, R: Future + Send + Sync, - R::Output: Responder, + R::Output: AFPluginResponder, { type Response = ServiceResponse; type Error = DispatchError; @@ -83,12 +83,12 @@ where } } -impl Service for HandlerService +impl Service for AFPluginHandlerService where - H: Handler, - T: FromRequest, + H: AFPluginHandler, + T: FromAFPluginRequest, R: Future + Sync + Send, - R::Output: Responder, + R::Output: AFPluginResponder, { type Response = ServiceResponse; type Error = DispatchError; @@ -104,21 +104,21 @@ where #[pin_project(project = HandlerServiceProj)] pub enum HandlerServiceFuture where - H: Handler, - T: FromRequest, + H: AFPluginHandler, + T: FromAFPluginRequest, R: Future + Sync + Send, - R::Output: Responder, + R::Output: AFPluginResponder, { - Extract(#[pin] T::Future, Option, H), - Handle(#[pin] R, Option), + Extract(#[pin] T::Future, Option, H), + Handle(#[pin] R, Option), } impl Future for HandlerServiceFuture where - F: Handler, - T: FromRequest, + F: AFPluginHandler, + T: FromAFPluginRequest, R: Future + Sync + Send, - R::Output: Responder, + R::Output: AFPluginResponder, { type Output = Result; @@ -152,10 +152,10 @@ where } macro_rules! factory_tuple ({ $($param:ident)* } => { - impl Handler<($($param,)*), Res> for Func + impl AFPluginHandler<($($param,)*), Res> for Func where Func: Fn($($param),*) -> Res + Clone + 'static + Sync + Send, Res: Future + Sync + Send, - Res::Output: Responder, + Res::Output: AFPluginResponder, { #[allow(non_snake_case)] fn call(&self, ($($param,)*): ($($param,)*)) -> Res { @@ -170,17 +170,17 @@ macro_rules! tuple_from_req ({$tuple_type:ident, $(($n:tt, $T:ident)),+} => { use super::*; #[pin_project::pin_project] - struct FromRequestFutures<$($T: FromRequest),+>($(#[pin] $T::Future),+); + struct FromRequestFutures<$($T: FromAFPluginRequest),+>($(#[pin] $T::Future),+); /// FromRequest implementation for tuple #[doc(hidden)] #[allow(unused_parens)] - impl<$($T: FromRequest + 'static),+> FromRequest for ($($T,)+) + impl<$($T: FromAFPluginRequest + 'static),+> FromAFPluginRequest for ($($T,)+) { type Error = DispatchError; type Future = $tuple_type<$($T),+>; - fn from_request(req: &EventRequest, payload: &mut Payload) -> Self::Future { + fn from_request(req: &AFPluginEventRequest, payload: &mut Payload) -> Self::Future { $tuple_type { items: <($(Option<$T>,)+)>::default(), futs: FromRequestFutures($($T::from_request(req, payload),)+), @@ -190,13 +190,13 @@ macro_rules! tuple_from_req ({$tuple_type:ident, $(($n:tt, $T:ident)),+} => { #[doc(hidden)] #[pin_project::pin_project] - pub struct $tuple_type<$($T: FromRequest),+> { + pub struct $tuple_type<$($T: FromAFPluginRequest),+> { items: ($(Option<$T>,)+), #[pin] futs: FromRequestFutures<$($T,)+>, } - impl<$($T: FromRequest),+> Future for $tuple_type<$($T),+> + impl<$($T: FromAFPluginRequest),+> Future for $tuple_type<$($T),+> { type Output = Result<($($T,)+), DispatchError>; diff --git a/frontend/rust-lib/lib-dispatch/src/service/service.rs b/frontend/rust-lib/lib-dispatch/src/service/service.rs index 529dd0c8fa..3e0fbb819f 100644 --- a/frontend/rust-lib/lib-dispatch/src/service/service.rs +++ b/frontend/rust-lib/lib-dispatch/src/service/service.rs @@ -1,7 +1,7 @@ use std::future::Future; use crate::{ - request::{payload::Payload, EventRequest}, + request::{payload::Payload, AFPluginEventRequest}, response::EventResponse, }; @@ -13,7 +13,7 @@ pub trait Service { fn call(&self, req: Request) -> Self::Future; } -pub trait ServiceFactory { +pub trait AFPluginServiceFactory { type Response; type Error; type Service: Service; @@ -23,33 +23,33 @@ pub trait ServiceFactory { fn new_service(&self, cfg: Self::Context) -> Self::Future; } -pub struct ServiceRequest { - req: EventRequest, +pub(crate) struct ServiceRequest { + req: AFPluginEventRequest, payload: Payload, } impl ServiceRequest { - pub fn new(req: EventRequest, payload: Payload) -> Self { + pub(crate) fn new(req: AFPluginEventRequest, payload: Payload) -> Self { Self { req, payload } } #[inline] - pub fn into_parts(self) -> (EventRequest, Payload) { + pub(crate) fn into_parts(self) -> (AFPluginEventRequest, Payload) { (self.req, self.payload) } } pub struct ServiceResponse { - request: EventRequest, + request: AFPluginEventRequest, response: EventResponse, } impl ServiceResponse { - pub fn new(request: EventRequest, response: EventResponse) -> Self { + pub fn new(request: AFPluginEventRequest, response: EventResponse) -> Self { ServiceResponse { request, response } } - pub fn into_parts(self) -> (EventRequest, EventResponse) { + pub fn into_parts(self) -> (AFPluginEventRequest, EventResponse) { (self.request, self.response) } } diff --git a/frontend/rust-lib/lib-dispatch/tests/api/module.rs b/frontend/rust-lib/lib-dispatch/tests/api/module.rs index dbdf5b88dc..b14ee02494 100644 --- a/frontend/rust-lib/lib-dispatch/tests/api/module.rs +++ b/frontend/rust-lib/lib-dispatch/tests/api/module.rs @@ -12,11 +12,11 @@ async fn test() { let event = "1"; let runtime = tokio_default_runtime().unwrap(); - let dispatch = Arc::new(EventDispatcher::construct(runtime, || { - vec![Module::new().event(event, hello)] + let dispatch = Arc::new(AFPluginDispatcher::construct(runtime, || { + vec![AFPlugin::new().event(event, hello)] })); - let request = ModuleRequest::new(event); - let _ = EventDispatcher::async_send_with_callback(dispatch.clone(), request, |resp| { + let request = AFPluginRequest::new(event); + let _ = AFPluginDispatcher::async_send_with_callback(dispatch.clone(), request, |resp| { Box::pin(async move { dbg!(&resp); }) From bf36ef7fd9fc0da93610decd166b196ac2d5a2c8 Mon Sep 17 00:00:00 2001 From: nathan Date: Thu, 1 Dec 2022 10:59:22 +0800 Subject: [PATCH 2/2] chore: update documentation --- frontend/rust-lib/dart-ffi/src/lib.rs | 4 +-- .../dart-ffi/src/model/ffi_response.rs | 6 ++-- frontend/rust-lib/flowy-error/src/errors.rs | 4 +-- .../rust-lib/flowy-test/src/event_builder.rs | 6 ++-- frontend/rust-lib/lib-dispatch/src/data.rs | 4 +-- .../rust-lib/lib-dispatch/src/dispatcher.rs | 14 ++++---- .../lib-dispatch/src/errors/errors.rs | 8 ++--- .../lib-dispatch/src/module/module.rs | 34 ++++++++++++++----- .../lib-dispatch/src/response/builder.rs | 6 ++-- .../lib-dispatch/src/response/responder.rs | 8 ++--- .../lib-dispatch/src/response/response.rs | 12 +++---- .../lib-dispatch/src/service/handler.rs | 5 +-- .../lib-dispatch/src/service/service.rs | 18 +++++----- 13 files changed, 74 insertions(+), 55 deletions(-) diff --git a/frontend/rust-lib/dart-ffi/src/lib.rs b/frontend/rust-lib/dart-ffi/src/lib.rs index 8165cbf6c3..78ddb3dfd8 100644 --- a/frontend/rust-lib/dart-ffi/src/lib.rs +++ b/frontend/rust-lib/dart-ffi/src/lib.rs @@ -46,7 +46,7 @@ pub extern "C" fn async_event(port: i64, input: *const u8, len: usize) { } Some(e) => e.event_dispatcher.clone(), }; - let _ = AFPluginDispatcher::async_send_with_callback(dispatcher, request, move |resp: EventResponse| { + let _ = AFPluginDispatcher::async_send_with_callback(dispatcher, request, move |resp: AFPluginEventResponse| { log::trace!("[FFI]: Post data to dart through {} port", port); Box::pin(post_to_flutter(resp, port)) }); @@ -83,7 +83,7 @@ pub extern "C" fn set_stream_port(port: i64) -> i32 { pub extern "C" fn link_me_please() {} #[inline(always)] -async fn post_to_flutter(response: EventResponse, port: i64) { +async fn post_to_flutter(response: AFPluginEventResponse, port: i64) { let isolate = allo_isolate::Isolate::new(port); match isolate .catch_unwind(async { diff --git a/frontend/rust-lib/dart-ffi/src/model/ffi_response.rs b/frontend/rust-lib/dart-ffi/src/model/ffi_response.rs index ea9afa5720..c34252b0d0 100644 --- a/frontend/rust-lib/dart-ffi/src/model/ffi_response.rs +++ b/frontend/rust-lib/dart-ffi/src/model/ffi_response.rs @@ -1,5 +1,5 @@ use flowy_derive::{ProtoBuf, ProtoBuf_Enum}; -use lib_dispatch::prelude::{EventResponse, Payload, StatusCode}; +use lib_dispatch::prelude::{AFPluginEventResponse, Payload, StatusCode}; #[derive(ProtoBuf_Enum, Clone, Copy)] pub enum FFIStatusCode { @@ -23,8 +23,8 @@ pub struct FFIResponse { code: FFIStatusCode, } -impl std::convert::From for FFIResponse { - fn from(resp: EventResponse) -> Self { +impl std::convert::From for FFIResponse { + fn from(resp: AFPluginEventResponse) -> Self { let payload = match resp.payload { Payload::Bytes(bytes) => bytes.to_vec(), Payload::None => vec![], diff --git a/frontend/rust-lib/flowy-error/src/errors.rs b/frontend/rust-lib/flowy-error/src/errors.rs index 8b32005378..36e689ab14 100644 --- a/frontend/rust-lib/flowy-error/src/errors.rs +++ b/frontend/rust-lib/flowy-error/src/errors.rs @@ -1,7 +1,7 @@ use bytes::Bytes; use flowy_derive::ProtoBuf; use flowy_error_code::ErrorCode; -use lib_dispatch::prelude::{EventResponse, ResponseBuilder}; +use lib_dispatch::prelude::{AFPluginEventResponse, ResponseBuilder}; use std::{convert::TryInto, fmt, fmt::Debug}; pub type FlowyResult = std::result::Result; @@ -93,7 +93,7 @@ impl fmt::Display for FlowyError { } impl lib_dispatch::Error for FlowyError { - fn as_response(&self) -> EventResponse { + fn as_response(&self) -> AFPluginEventResponse { let bytes: Bytes = self.clone().try_into().unwrap(); println!("Serialize FlowyError: {:?} to event response", self); diff --git a/frontend/rust-lib/flowy-test/src/event_builder.rs b/frontend/rust-lib/flowy-test/src/event_builder.rs index 8d34aa7acd..f86e733a7e 100644 --- a/frontend/rust-lib/flowy-test/src/event_builder.rs +++ b/frontend/rust-lib/flowy-test/src/event_builder.rs @@ -1,7 +1,7 @@ use crate::FlowySDKTest; use flowy_user::{entities::UserProfilePB, errors::FlowyError}; use lib_dispatch::prelude::{ - AFPluginDispatcher, AFPluginFromBytes, AFPluginRequest, EventResponse, StatusCode, ToBytes, *, + AFPluginDispatcher, AFPluginEventResponse, AFPluginFromBytes, AFPluginRequest, StatusCode, ToBytes, *, }; use std::{ convert::TryFrom, @@ -124,7 +124,7 @@ where self.context.sdk.dispatcher() } - fn get_response(&self) -> EventResponse { + fn get_response(&self) -> AFPluginEventResponse { self.context .response .as_ref() @@ -141,7 +141,7 @@ where pub struct TestContext { pub sdk: FlowySDKTest, request: Option, - response: Option, + response: Option, } impl TestContext { diff --git a/frontend/rust-lib/lib-dispatch/src/data.rs b/frontend/rust-lib/lib-dispatch/src/data.rs index 901529c05c..8f37383934 100644 --- a/frontend/rust-lib/lib-dispatch/src/data.rs +++ b/frontend/rust-lib/lib-dispatch/src/data.rs @@ -2,7 +2,7 @@ use crate::{ byte_trait::*, errors::{DispatchError, InternalError}, request::{unexpected_none_payload, AFPluginEventRequest, FromAFPluginRequest, Payload}, - response::{AFPluginResponder, EventResponse, ResponseBuilder}, + response::{AFPluginEventResponse, AFPluginResponder, ResponseBuilder}, util::ready::{ready, Ready}, }; use bytes::Bytes; @@ -53,7 +53,7 @@ impl AFPluginResponder for AFPluginData where T: ToBytes, { - fn respond_to(self, _request: &AFPluginEventRequest) -> EventResponse { + fn respond_to(self, _request: &AFPluginEventRequest) -> AFPluginEventResponse { match self.into_inner().into_bytes() { Ok(bytes) => { log::trace!("Serialize Data: {:?} to event response", std::any::type_name::()); diff --git a/frontend/rust-lib/lib-dispatch/src/dispatcher.rs b/frontend/rust-lib/lib-dispatch/src/dispatcher.rs index a90e10d744..dc5defd0f8 100644 --- a/frontend/rust-lib/lib-dispatch/src/dispatcher.rs +++ b/frontend/rust-lib/lib-dispatch/src/dispatcher.rs @@ -2,7 +2,7 @@ use crate::runtime::AFPluginRuntime; use crate::{ errors::{DispatchError, Error, InternalError}, module::{as_plugin_map, AFPlugin, AFPluginMap, AFPluginRequest}, - response::EventResponse, + response::AFPluginEventResponse, service::{AFPluginServiceFactory, Service}, }; use derivative::*; @@ -30,7 +30,7 @@ impl AFPluginDispatcher { } } - pub fn async_send(dispatch: Arc, request: Req) -> DispatchFuture + pub fn async_send(dispatch: Arc, request: Req) -> DispatchFuture where Req: std::convert::Into, { @@ -41,10 +41,10 @@ impl AFPluginDispatcher { dispatch: Arc, request: Req, callback: Callback, - ) -> DispatchFuture + ) -> DispatchFuture where Req: std::convert::Into, - Callback: FnOnce(EventResponse) -> BoxFuture<'static, ()> + 'static + Send + Sync, + Callback: FnOnce(AFPluginEventResponse) -> BoxFuture<'static, ()> + 'static + Send + Sync, { let request: AFPluginRequest = request.into(); let plugins = dispatch.plugins.clone(); @@ -73,7 +73,7 @@ impl AFPluginDispatcher { } } - pub fn sync_send(dispatch: Arc, request: AFPluginRequest) -> EventResponse { + pub fn sync_send(dispatch: Arc, request: AFPluginRequest) -> AFPluginEventResponse { futures::executor::block_on(async { AFPluginDispatcher::async_send_with_callback(dispatch, request, |_| Box::pin(async {})).await }) @@ -105,7 +105,7 @@ where } } -pub type BoxFutureCallback = Box BoxFuture<'static, ()> + 'static + Send + Sync>; +pub type BoxFutureCallback = Box BoxFuture<'static, ()> + 'static + Send + Sync>; #[derive(Derivative)] #[derivative(Debug)] @@ -127,7 +127,7 @@ pub(crate) struct DispatchService { } impl Service for DispatchService { - type Response = EventResponse; + type Response = AFPluginEventResponse; type Error = DispatchError; type Future = BoxFuture<'static, Result>; diff --git a/frontend/rust-lib/lib-dispatch/src/errors/errors.rs b/frontend/rust-lib/lib-dispatch/src/errors/errors.rs index 5d43a4b496..4e2787622e 100644 --- a/frontend/rust-lib/lib-dispatch/src/errors/errors.rs +++ b/frontend/rust-lib/lib-dispatch/src/errors/errors.rs @@ -1,7 +1,7 @@ use crate::{ byte_trait::AFPluginFromBytes, request::AFPluginEventRequest, - response::{EventResponse, ResponseBuilder}, + response::{AFPluginEventResponse, ResponseBuilder}, }; use bytes::Bytes; use dyn_clone::DynClone; @@ -10,7 +10,7 @@ use std::fmt; use tokio::{sync::mpsc::error::SendError, task::JoinError}; pub trait Error: fmt::Debug + DynClone + Send + Sync { - fn as_response(&self) -> EventResponse; + fn as_response(&self) -> AFPluginEventResponse; } dyn_clone::clone_trait_object!(Error); @@ -80,7 +80,7 @@ impl AFPluginFromBytes for DispatchError { } } -impl From for EventResponse { +impl From for AFPluginEventResponse { fn from(err: DispatchError) -> Self { err.inner_error().as_response() } @@ -121,7 +121,7 @@ impl fmt::Display for InternalError { } impl Error for InternalError { - fn as_response(&self) -> EventResponse { + fn as_response(&self) -> AFPluginEventResponse { let error = format!("{}", self).into_bytes(); ResponseBuilder::Internal().data(error).build() } diff --git a/frontend/rust-lib/lib-dispatch/src/module/module.rs b/frontend/rust-lib/lib-dispatch/src/module/module.rs index f560501397..e091a6f4e1 100644 --- a/frontend/rust-lib/lib-dispatch/src/module/module.rs +++ b/frontend/rust-lib/lib-dispatch/src/module/module.rs @@ -2,7 +2,7 @@ use crate::{ errors::{DispatchError, InternalError}, module::{container::AFPluginStateMap, AFPluginState}, request::{payload::Payload, AFPluginEventRequest, FromAFPluginRequest}, - response::{AFPluginResponder, EventResponse}, + response::{AFPluginEventResponse, AFPluginResponder}, service::{ factory, AFPluginHandler, AFPluginHandlerService, AFPluginServiceFactory, BoxService, BoxServiceFactory, Service, ServiceRequest, ServiceResponse, @@ -45,9 +45,21 @@ impl std::convert::From for AFPluginE } } +/// A plugin is used to handle the events that the plugin can handle. +/// +/// When an event is a dispatched by the `AFPluginDispatcher`, the dispatcher will +/// find the corresponding plugin to handle the event. The name of the event must be unique, +/// which means only one handler will get called. +/// pub struct AFPlugin { pub name: String, + + /// a list of `AFPluginState` that the plugin registers. The state can be read by the plugin's handler. states: Arc, + + /// Contains a list of factories that are used to generate the services used to handle the passed-in + /// `ServiceRequest`. + /// event_service_factory: Arc>>, } @@ -89,12 +101,12 @@ impl AFPlugin { { let event: AFPluginEvent = event.into(); if self.event_service_factory.contains_key(&event) { - log::error!("Duplicate Event: {:?}", &event); + panic!("Register duplicate Event: {:?}", &event); + } else { + Arc::get_mut(&mut self.event_service_factory) + .unwrap() + .insert(event, factory(AFPluginHandlerService::new(handler))); } - - Arc::get_mut(&mut self.event_service_factory) - .unwrap() - .insert(event, factory(AFPluginHandlerService::new(handler))); self } @@ -103,6 +115,10 @@ impl AFPlugin { } } +/// A request that will be passed to the corresponding plugin. +/// +/// Each request can carry the payload that will be deserialized into the corresponding data struct. +/// #[derive(Debug, Clone)] pub struct AFPluginRequest { pub id: String, @@ -138,7 +154,7 @@ impl std::fmt::Display for AFPluginRequest { } impl AFPluginServiceFactory for AFPlugin { - type Response = EventResponse; + type Response = AFPluginEventResponse; type Error = DispatchError; type Service = BoxService; type Context = (); @@ -160,7 +176,7 @@ pub struct AFPluginService { } impl Service for AFPluginService { - type Response = EventResponse; + type Response = AFPluginEventResponse; type Error = DispatchError; type Future = BoxFuture<'static, Result>; @@ -196,7 +212,7 @@ pub struct AFPluginServiceFuture { } impl Future for AFPluginServiceFuture { - type Output = Result; + type Output = Result; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let (_, response) = ready!(self.as_mut().project().fut.poll(cx))?.into_parts(); diff --git a/frontend/rust-lib/lib-dispatch/src/response/builder.rs b/frontend/rust-lib/lib-dispatch/src/response/builder.rs index a9d4ea6802..e20e648fd8 100644 --- a/frontend/rust-lib/lib-dispatch/src/response/builder.rs +++ b/frontend/rust-lib/lib-dispatch/src/response/builder.rs @@ -1,6 +1,6 @@ use crate::{ request::Payload, - response::{EventResponse, StatusCode}, + response::{AFPluginEventResponse, StatusCode}, }; macro_rules! static_response { @@ -30,8 +30,8 @@ impl ResponseBuilder { self } - pub fn build(self) -> EventResponse { - EventResponse { + pub fn build(self) -> AFPluginEventResponse { + AFPluginEventResponse { payload: self.payload, status_code: self.status, } diff --git a/frontend/rust-lib/lib-dispatch/src/response/responder.rs b/frontend/rust-lib/lib-dispatch/src/response/responder.rs index efd1c5ede1..0b25d1f2b9 100644 --- a/frontend/rust-lib/lib-dispatch/src/response/responder.rs +++ b/frontend/rust-lib/lib-dispatch/src/response/responder.rs @@ -2,18 +2,18 @@ use crate::errors::{DispatchError, InternalError}; use crate::{ request::AFPluginEventRequest, - response::{EventResponse, ResponseBuilder}, + response::{AFPluginEventResponse, ResponseBuilder}, }; use bytes::Bytes; pub trait AFPluginResponder { - fn respond_to(self, req: &AFPluginEventRequest) -> EventResponse; + fn respond_to(self, req: &AFPluginEventRequest) -> AFPluginEventResponse; } macro_rules! impl_responder { ($res: ty) => { impl AFPluginResponder for $res { - fn respond_to(self, _: &AFPluginEventRequest) -> EventResponse { + fn respond_to(self, _: &AFPluginEventRequest) -> AFPluginEventResponse { ResponseBuilder::Ok().data(self).build() } } @@ -32,7 +32,7 @@ where T: AFPluginResponder, E: Into, { - fn respond_to(self, request: &AFPluginEventRequest) -> EventResponse { + fn respond_to(self, request: &AFPluginEventRequest) -> AFPluginEventResponse { match self { Ok(val) => val.respond_to(request), Err(e) => e.into().into(), diff --git a/frontend/rust-lib/lib-dispatch/src/response/response.rs b/frontend/rust-lib/lib-dispatch/src/response/response.rs index 69abb82f8f..515ed95ba4 100644 --- a/frontend/rust-lib/lib-dispatch/src/response/response.rs +++ b/frontend/rust-lib/lib-dispatch/src/response/response.rs @@ -19,15 +19,15 @@ pub enum StatusCode { // serde user guide: https://serde.rs/field-attrs.html #[derive(Debug, Clone, Derivative)] #[cfg_attr(feature = "use_serde", derive(serde::Serialize))] -pub struct EventResponse { +pub struct AFPluginEventResponse { #[derivative(Debug = "ignore")] pub payload: Payload, pub status_code: StatusCode, } -impl EventResponse { +impl AFPluginEventResponse { pub fn new(status_code: StatusCode) -> Self { - EventResponse { + AFPluginEventResponse { payload: Payload::None, status_code, } @@ -51,7 +51,7 @@ impl EventResponse { } } -impl std::fmt::Display for EventResponse { +impl std::fmt::Display for AFPluginEventResponse { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { f.write_fmt(format_args!("Status_Code: {:?}", self.status_code))?; @@ -64,9 +64,9 @@ impl std::fmt::Display for EventResponse { } } -impl AFPluginResponder for EventResponse { +impl AFPluginResponder for AFPluginEventResponse { #[inline] - fn respond_to(self, _: &AFPluginEventRequest) -> EventResponse { + fn respond_to(self, _: &AFPluginEventRequest) -> AFPluginEventResponse { self } } diff --git a/frontend/rust-lib/lib-dispatch/src/service/handler.rs b/frontend/rust-lib/lib-dispatch/src/service/handler.rs index 0f6a0ef9a5..52c9081983 100644 --- a/frontend/rust-lib/lib-dispatch/src/service/handler.rs +++ b/frontend/rust-lib/lib-dispatch/src/service/handler.rs @@ -11,11 +11,12 @@ use pin_project::pin_project; use crate::{ errors::DispatchError, request::{payload::Payload, AFPluginEventRequest, FromAFPluginRequest}, - response::{AFPluginResponder, EventResponse}, + response::{AFPluginEventResponse, AFPluginResponder}, service::{AFPluginServiceFactory, Service, ServiceRequest, ServiceResponse}, util::ready::*, }; +/// A closure that is run every time for the specified plugin event pub trait AFPluginHandler: Clone + 'static + Sync + Send where R: Future + Send + Sync, @@ -135,7 +136,7 @@ where Err(err) => { let req = req.take().unwrap(); let system_err: DispatchError = err.into(); - let res: EventResponse = system_err.into(); + let res: AFPluginEventResponse = system_err.into(); return Poll::Ready(Ok(ServiceResponse::new(req, res))); } }; diff --git a/frontend/rust-lib/lib-dispatch/src/service/service.rs b/frontend/rust-lib/lib-dispatch/src/service/service.rs index 3e0fbb819f..b1fed6e1aa 100644 --- a/frontend/rust-lib/lib-dispatch/src/service/service.rs +++ b/frontend/rust-lib/lib-dispatch/src/service/service.rs @@ -2,7 +2,7 @@ use std::future::Future; use crate::{ request::{payload::Payload, AFPluginEventRequest}, - response::EventResponse, + response::AFPluginEventResponse, }; pub trait Service { @@ -13,6 +13,8 @@ pub trait Service { fn call(&self, req: Request) -> Self::Future; } +/// Returns a future that can handle the request. For the moment, the request will be the +/// `AFPluginRequest` pub trait AFPluginServiceFactory { type Response; type Error; @@ -24,32 +26,32 @@ pub trait AFPluginServiceFactory { } pub(crate) struct ServiceRequest { - req: AFPluginEventRequest, + event_state: AFPluginEventRequest, payload: Payload, } impl ServiceRequest { - pub(crate) fn new(req: AFPluginEventRequest, payload: Payload) -> Self { - Self { req, payload } + pub(crate) fn new(event_state: AFPluginEventRequest, payload: Payload) -> Self { + Self { event_state, payload } } #[inline] pub(crate) fn into_parts(self) -> (AFPluginEventRequest, Payload) { - (self.req, self.payload) + (self.event_state, self.payload) } } pub struct ServiceResponse { request: AFPluginEventRequest, - response: EventResponse, + response: AFPluginEventResponse, } impl ServiceResponse { - pub fn new(request: AFPluginEventRequest, response: EventResponse) -> Self { + pub fn new(request: AFPluginEventRequest, response: AFPluginEventResponse) -> Self { ServiceResponse { request, response } } - pub fn into_parts(self) -> (AFPluginEventRequest, EventResponse) { + pub fn into_parts(self) -> (AFPluginEventRequest, AFPluginEventResponse) { (self.request, self.response) } }