Skip to content

Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.

refactor: remove server type

Nathan0906febe957f
diff --git a/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rs b/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rs
index 9c1ee9462c..56bf4e965c 100644
--- a/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rs
+++ b/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rs
@@ -1,4 +1,4 @@
-use crate::server_layer::{ServerProvider, ServerType};
+use crate::server_layer::ServerProvider;
use client_api::collab_sync::{SinkConfig, SyncObject, SyncPlugin};
use client_api::entity::ai_dto::RepeatedRelatedQuestion;
use client_api::entity::workspace_dto::PublishInfoView;
@@ -188,8 +188,8 @@ impl UserCloudServiceProvider for ServerProvider {
/// When user login, the provider type is set by the [AuthType] and save to disk for next use.
///
- /// Each [AuthType] has a corresponding [ServerType]. The [ServerType] is used
- /// to create a new [AppFlowyServer] if it doesn't exist. Once the [ServerType] is set,
+ /// Each [AuthType] has a corresponding [AuthType]. The [AuthType] is used
+ /// to create a new [AppFlowyServer] if it doesn't exist. Once the [AuthType] is set,
/// it will be used when user open the app again.
///
fn set_auth_type(&self, auth_type: &AuthType) {
@@ -211,7 +211,7 @@ impl UserCloudServiceProvider for ServerProvider {
self.encryption.set_secret(secret);
}
- /// Returns the [UserCloudService] base on the current [ServerType].
+ /// Returns the [UserCloudService] base on the current [AuthType].
/// Creates a new [AppFlowyServer] if it doesn't exist.
fn get_user_service(&self) -> Result<Arc<dyn UserCloudService>, FlowyError> {
let user_service = self.get_server()?.user_service();
@@ -219,9 +219,9 @@ impl UserCloudServiceProvider for ServerProvider {
}
fn service_url(&self) -> String {
- match self.get_server_type() {
- ServerType::Local => "".to_string(),
- ServerType::AppFlowyCloud => AFCloudConfiguration::from_env()
+ match self.get_auth_type() {
+ AuthType::Local => "".to_string(),
+ AuthType::AppFlowyCloud => AFCloudConfiguration::from_env()
.map(|config| config.base_url)
.unwrap_or_default(),
}
@@ -578,12 +578,15 @@ impl DocumentCloudService for ServerProvider {
impl CollabCloudPluginProvider for ServerProvider {
fn provider_type(&self) -> CollabPluginProviderType {
- self.get_server_type().into()
+ match self.get_auth_type() {
+ AuthType::Local => CollabPluginProviderType::Local,
+ AuthType::AppFlowyCloud => CollabPluginProviderType::AppFlowyCloud,
+ }
}
fn get_plugins(&self, context: CollabPluginProviderContext) -> Vec<Box<dyn CollabPlugin>> {
// If the user is local, we don't need to create a sync plugin.
- if self.get_server_type().is_local() {
+ if self.get_auth_type().is_local() {
debug!(
"User authenticator is local, skip create sync plugin for: {}",
context
diff --git a/frontend/rust-lib/flowy-core/src/lib.rs b/frontend/rust-lib/flowy-core/src/lib.rs
index bd55c8db1d..d217f52785 100644
--- a/frontend/rust-lib/flowy-core/src/lib.rs
+++ b/frontend/rust-lib/flowy-core/src/lib.rs
@@ -1,6 +1,6 @@
#![allow(unused_doc_comments)]
-use collab_integrate::collab_builder::{AppFlowyCollabBuilder, CollabPluginProviderType};
+use collab_integrate::collab_builder::AppFlowyCollabBuilder;
use flowy_ai::ai_manager::AIManager;
use flowy_database2::DatabaseManager;
use flowy_document::manager::DocumentManager;
@@ -34,7 +34,7 @@ use crate::config::AppFlowyCoreConfig;
use crate::deps_resolve::file_storage_deps::FileStorageResolver;
use crate::deps_resolve::*;
use crate::log_filter::init_log;
-use crate::server_layer::{current_server_type, ServerProvider, ServerType};
+use crate::server_layer::{current_server_type, ServerProvider};
use deps_resolve::reminder_deps::CollabInteractImpl;
use flowy_sqlite::DBConnection;
use lib_infra::async_trait::async_trait;
@@ -131,12 +131,12 @@ impl AppFlowyCore {
store_preference.clone(),
));
- let server_type = current_server_type();
- debug!("🔥runtime:{}, server:{}", runtime, server_type);
+ let auth_type = current_server_type();
+ debug!("🔥runtime:{}, server:{}", runtime, auth_type);
let server_provider = Arc::new(ServerProvider::new(
config.clone(),
- server_type,
+ auth_type,
Arc::downgrade(&store_preference),
ServerUserImpl(Arc::downgrade(&authenticate_user)),
));
@@ -314,15 +314,6 @@ impl AppFlowyCore {
}
}
-impl From<ServerType> for CollabPluginProviderType {
- fn from(server_type: ServerType) -> Self {
- match server_type {
- ServerType::Local => CollabPluginProviderType::Local,
- ServerType::AppFlowyCloud => CollabPluginProviderType::AppFlowyCloud,
- }
- }
-}
-
struct ServerUserImpl(Weak<AuthenticateUser>);
impl ServerUserImpl {
diff --git a/frontend/rust-lib/flowy-core/src/server_layer.rs b/frontend/rust-lib/flowy-core/src/server_layer.rs
index c0bf043d27..ebb86c4417 100644
--- a/frontend/rust-lib/flowy-core/src/server_layer.rs
+++ b/frontend/rust-lib/flowy-core/src/server_layer.rs
@@ -13,52 +13,12 @@ use flowy_server::{AppFlowyEncryption, AppFlowyServer, EncryptionImpl};
use flowy_server_pub::AuthenticatorType;
use flowy_sqlite::kv::KVStorePreferences;
use flowy_user_pub::entities::*;
-use serde_repr::{Deserialize_repr, Serialize_repr};
-use std::fmt::{Display, Formatter, Result as FmtResult};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Weak};
-/// ServerType: local or cloud
-#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize_repr, Deserialize_repr)]
-#[repr(u8)]
-pub enum ServerType {
- Local = 0,
- AppFlowyCloud = 1,
-}
-
-impl ServerType {
- pub fn is_local(&self) -> bool {
- matches!(self, Self::Local)
- }
-}
-
-impl Display for ServerType {
- fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
- write!(f, "{:?}", self)
- }
-}
-
-/// Conversion between AuthType and ServerType
-impl From<&AuthType> for ServerType {
- fn from(a: &AuthType) -> Self {
- match a {
- AuthType::Local => ServerType::Local,
- AuthType::AppFlowyCloud => ServerType::AppFlowyCloud,
- }
- }
-}
-impl From<ServerType> for AuthType {
- fn from(s: ServerType) -> Self {
- match s {
- ServerType::Local => AuthType::Local,
- ServerType::AppFlowyCloud => AuthType::AppFlowyCloud,
- }
- }
-}
-
pub struct ServerProvider {
config: AppFlowyCoreConfig,
- providers: DashMap<ServerType, Arc<dyn AppFlowyServer>>,
+ providers: DashMap<AuthType, Arc<dyn AppFlowyServer>>,
auth_type: ArcSwap<AuthType>,
user: Arc<dyn LoginUserService>,
pub local_ai: Arc<LocalAIController>,
@@ -70,12 +30,11 @@ pub struct ServerProvider {
impl ServerProvider {
pub fn new(
config: AppFlowyCoreConfig,
- initial: ServerType,
+ initial_auth: AuthType,
store_preferences: Weak<KVStorePreferences>,
user_service: impl LoginUserService + 'static,
) -> Self {
let user = Arc::new(user_service);
- let initial_auth = AuthType::from(initial);
let auth_type = ArcSwap::from(Arc::new(initial_auth));
let encryption = Arc::new(EncryptionImpl::new(None)) as Arc<dyn AppFlowyEncryption>;
let ai_user = Arc::new(AIUserServiceImpl(user.clone()));
@@ -98,17 +57,10 @@ impl ServerProvider {
}
}
- /// Reads current type
- pub fn get_server_type(&self) -> ServerType {
- let auth_type = self.auth_type.load_full();
- ServerType::from(auth_type.as_ref())
- }
-
- pub fn set_auth_type(&self, a: AuthType) {
- let old_type = self.get_server_type();
- self.auth_type.store(Arc::new(a));
- let new_type = self.get_server_type();
- if old_type != new_type {
+ pub fn set_auth_type(&self, new_auth_type: AuthType) {
+ let old_type = self.get_auth_type();
+ if old_type != new_auth_type {
+ self.auth_type.store(Arc::new(new_auth_type));
self.providers.remove(&old_type);
}
}
@@ -119,14 +71,14 @@ impl ServerProvider {
/// Lazily create or fetch an AppFlowyServer instance
pub fn get_server(&self) -> FlowyResult<Arc<dyn AppFlowyServer>> {
- let key = self.get_server_type();
- if let Some(entry) = self.providers.get(&key) {
+ let auth_type = self.get_auth_type();
+ if let Some(entry) = self.providers.get(&auth_type) {
return Ok(entry.clone());
}
- let server: Arc<dyn AppFlowyServer> = match key {
- ServerType::Local => Arc::new(LocalServer::new(self.user.clone(), self.local_ai.clone())),
- ServerType::AppFlowyCloud => {
+ let server: Arc<dyn AppFlowyServer> = match auth_type {
+ AuthType::Local => Arc::new(LocalServer::new(self.user.clone(), self.local_ai.clone())),
+ AuthType::AppFlowyCloud => {
let cfg = self
.config
.cloud_config
@@ -142,15 +94,15 @@ impl ServerProvider {
},
};
- self.providers.insert(key.clone(), server.clone());
+ self.providers.insert(auth_type, server.clone());
Ok(server)
}
}
/// Determine current server type from ENV
-pub fn current_server_type() -> ServerType {
+pub fn current_server_type() -> AuthType {
match AuthenticatorType::from_env() {
- AuthenticatorType::Local => ServerType::Local,
- AuthenticatorType::AppFlowyCloud => ServerType::AppFlowyCloud,
+ AuthenticatorType::Local => AuthType::Local,
+ AuthenticatorType::AppFlowyCloud => AuthType::AppFlowyCloud,
}
}
diff --git a/frontend/rust-lib/flowy-core/src/user_state_callback.rs b/frontend/rust-lib/flowy-core/src/user_state_callback.rs
index 89ba14e6d2..ff1c6b6699 100644
--- a/frontend/rust-lib/flowy-core/src/user_state_callback.rs
+++ b/frontend/rust-lib/flowy-core/src/user_state_callback.rs
@@ -18,7 +18,7 @@ use flowy_user_pub::entities::{AuthType, UserProfile, UserWorkspace};
use lib_dispatch::runtime::AFPluginRuntime;
use lib_infra::async_trait::async_trait;
-use crate::server_layer::{ServerProvider, ServerType};
+use crate::server_layer::ServerProvider;
pub(crate) struct UserStatusCallbackImpl {
pub(crate) collab_builder: Arc<AppFlowyCollabBuilder>,
@@ -128,7 +128,6 @@ impl UserStatusCallback for UserStatusCallbackImpl {
auth_type: &AuthType,
) -> FlowyResult<()> {
self.server_provider.set_auth_type(*auth_type);
- let server_type = self.server_provider.get_server_type();
event!(
tracing::Level::TRACE,
@@ -154,17 +153,17 @@ impl UserStatusCallback for UserStatusCallbackImpl {
)
.await
{
- Ok(doc_state) => match server_type {
- ServerType::Local => FolderInitDataSource::LocalDisk {
+ Ok(doc_state) => match auth_type {
+ AuthType::Local => FolderInitDataSource::LocalDisk {
create_if_not_exist: true,
},
- ServerType::AppFlowyCloud => FolderInitDataSource::Cloud(doc_state),
+ AuthType::AppFlowyCloud => FolderInitDataSource::Cloud(doc_state),
},
- Err(err) => match server_type {
- ServerType::Local => FolderInitDataSource::LocalDisk {
+ Err(err) => match auth_type {
+ AuthType::Local => FolderInitDataSource::LocalDisk {
create_if_not_exist: true,
},
- ServerType::AppFlowyCloud => {
+ AuthType::AppFlowyCloud => {
return Err(err);
},
},
diff --git a/frontend/rust-lib/flowy-user-pub/src/entities.rs b/frontend/rust-lib/flowy-user-pub/src/entities.rs
index c09b536ccf..d59f9cab47 100644
--- a/frontend/rust-lib/flowy-user-pub/src/entities.rs
+++ b/frontend/rust-lib/flowy-user-pub/src/entities.rs
@@ -1,3 +1,4 @@
+use std::fmt::{Display, Formatter};
use std::str::FromStr;
use chrono::{DateTime, Utc};
@@ -359,6 +360,15 @@ pub enum AuthType {
AppFlowyCloud = 1,
}
+impl Display for AuthType {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ match self {
+ AuthType::Local => write!(f, "Local"),
+ AuthType::AppFlowyCloud => write!(f, "AppFlowyCloud"),
+ }
+ }
+}
+
impl Default for AuthType {
fn default() -> Self {
Self::Local