lib.rs 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  1. mod deps_resolve;
  2. // mod flowy_server;
  3. pub mod module;
  4. use crate::deps_resolve::WorkspaceDepsResolver;
  5. use flowy_dispatch::prelude::*;
  6. use flowy_document::module::FlowyDocument;
  7. use flowy_net::config::ServerConfig;
  8. use flowy_user::services::user::{UserSession, UserSessionBuilder, UserStatus};
  9. use flowy_workspace::{errors::WorkspaceError, prelude::WorkspaceController};
  10. use module::mk_modules;
  11. pub use module::*;
  12. use std::sync::{
  13. atomic::{AtomicBool, Ordering},
  14. Arc,
  15. };
  16. use tokio::sync::broadcast;
  17. static INIT_LOG: AtomicBool = AtomicBool::new(false);
  18. #[derive(Debug, Clone)]
  19. pub struct FlowySDKConfig {
  20. name: String,
  21. root: String,
  22. log_filter: String,
  23. server_config: ServerConfig,
  24. }
  25. impl FlowySDKConfig {
  26. pub fn new(root: &str, server_config: ServerConfig, name: &str) -> Self {
  27. FlowySDKConfig {
  28. name: name.to_owned(),
  29. root: root.to_owned(),
  30. log_filter: crate_log_filter(None),
  31. server_config,
  32. }
  33. }
  34. pub fn log_filter(mut self, filter: &str) -> Self {
  35. self.log_filter = crate_log_filter(Some(filter.to_owned()));
  36. self
  37. }
  38. }
  39. fn crate_log_filter(level: Option<String>) -> String {
  40. let level = level.unwrap_or(std::env::var("RUST_LOG").unwrap_or("info".to_owned()));
  41. let mut filters = vec![];
  42. filters.push(format!("flowy_sdk={}", level));
  43. filters.push(format!("flowy_workspace={}", level));
  44. filters.push(format!("flowy_user={}", level));
  45. filters.push(format!("flowy_document={}", level));
  46. filters.push(format!("flowy_dart_notify={}", level));
  47. filters.push(format!("flowy_ot={}", level));
  48. filters.push(format!("flowy_ws={}", level));
  49. filters.push(format!("flowy_ws={}", level));
  50. filters.push(format!("flowy_infra={}", level));
  51. filters.join(",")
  52. }
  53. #[derive(Clone)]
  54. pub struct FlowySDK {
  55. config: FlowySDKConfig,
  56. pub user_session: Arc<UserSession>,
  57. pub flowy_document: Arc<FlowyDocument>,
  58. pub workspace: Arc<WorkspaceController>,
  59. pub dispatch: Arc<EventDispatch>,
  60. }
  61. impl FlowySDK {
  62. pub fn new(config: FlowySDKConfig) -> Self {
  63. init_log(&config);
  64. init_kv(&config.root);
  65. tracing::debug!("🔥 {:?}", config);
  66. let session_cache_key = format!("{}_session_cache", &config.name);
  67. let user_session = Arc::new(
  68. UserSessionBuilder::new()
  69. .root_dir(&config.root, &config.server_config, &session_cache_key)
  70. .build(),
  71. );
  72. let flowy_document = mk_document_module(user_session.clone(), &config.server_config);
  73. let workspace = mk_workspace(user_session.clone(), flowy_document.clone(), &config.server_config);
  74. let modules = mk_modules(workspace.clone(), user_session.clone());
  75. let dispatch = Arc::new(EventDispatch::construct(|| modules));
  76. _init(&dispatch, user_session.clone(), workspace.clone());
  77. Self {
  78. config,
  79. user_session,
  80. flowy_document,
  81. workspace,
  82. dispatch,
  83. }
  84. }
  85. pub fn dispatch(&self) -> Arc<EventDispatch> { self.dispatch.clone() }
  86. }
  87. fn _init(dispatch: &EventDispatch, user_session: Arc<UserSession>, workspace_controller: Arc<WorkspaceController>) {
  88. let subscribe = user_session.status_subscribe();
  89. dispatch.spawn(async move {
  90. user_session.init();
  91. _listen_user_status(subscribe, workspace_controller).await;
  92. });
  93. }
  94. async fn _listen_user_status(
  95. mut subscribe: broadcast::Receiver<UserStatus>,
  96. workspace_controller: Arc<WorkspaceController>,
  97. ) {
  98. loop {
  99. match subscribe.recv().await {
  100. Ok(status) => {
  101. let result = || async {
  102. match status {
  103. UserStatus::Login { token } => {
  104. let _ = workspace_controller.user_did_sign_in(&token).await?;
  105. },
  106. UserStatus::Logout { .. } => {
  107. workspace_controller.user_did_logout().await;
  108. },
  109. UserStatus::Expired { .. } => {
  110. workspace_controller.user_session_expired().await;
  111. },
  112. UserStatus::SignUp { profile, ret } => {
  113. let _ = workspace_controller.user_did_sign_up(&profile.token).await?;
  114. let _ = ret.send(());
  115. },
  116. }
  117. Ok::<(), WorkspaceError>(())
  118. };
  119. match result().await {
  120. Ok(_) => {},
  121. Err(e) => log::error!("{}", e),
  122. }
  123. },
  124. Err(_) => {},
  125. }
  126. }
  127. }
  128. fn init_kv(root: &str) {
  129. match flowy_infra::kv::KV::init(root) {
  130. Ok(_) => {},
  131. Err(e) => tracing::error!("Init kv store failedL: {}", e),
  132. }
  133. }
  134. fn init_log(config: &FlowySDKConfig) {
  135. if !INIT_LOG.load(Ordering::SeqCst) {
  136. INIT_LOG.store(true, Ordering::SeqCst);
  137. let _ = flowy_log::Builder::new("flowy-client", &config.root)
  138. .env_filter(&config.log_filter)
  139. .build();
  140. }
  141. }
  142. fn mk_workspace(
  143. user_session: Arc<UserSession>,
  144. flowy_document: Arc<FlowyDocument>,
  145. server_config: &ServerConfig,
  146. ) -> Arc<WorkspaceController> {
  147. let workspace_deps = WorkspaceDepsResolver::new(user_session.clone());
  148. let (user, database) = workspace_deps.split_into();
  149. let workspace_controller = flowy_workspace::module::mk_workspace(user, database, flowy_document, server_config);
  150. workspace_controller
  151. }