316 lines
11 KiB
Rust
Raw Normal View History

use crate::{
errors::{internal_error, DocError, DocResult},
module::DocumentUser,
services::{
2021-12-08 14:17:40 +08:00
doc::{
edit::{EditCommand, EditCommandQueue, OpenDocAction, TransformDeltas},
2021-12-08 21:51:06 +08:00
revision::{RevisionDownStream, RevisionManager},
2021-12-08 14:17:40 +08:00
},
ws::{DocumentWebSocket, WsDocumentHandler},
},
};
use bytes::Bytes;
use flowy_database::ConnectionPool;
2021-11-19 12:18:46 +08:00
use flowy_document_infra::{
core::history::UndoResult,
2021-12-08 21:51:06 +08:00
entities::{doc::DocDelta, ws::WsDocumentData},
2021-11-19 12:18:46 +08:00
errors::DocumentResult,
};
use lib_infra::retry::{ExponentialBackoff, Retry};
2021-12-07 19:59:08 +08:00
use lib_ot::{
core::Interval,
2021-12-08 21:51:06 +08:00
revision::{RevId, RevType, Revision},
2021-12-07 19:59:08 +08:00
rich_text::{RichTextAttribute, RichTextDelta},
};
2021-12-05 14:04:25 +08:00
use lib_ws::WsConnectState;
2021-12-08 21:51:06 +08:00
use std::sync::Arc;
use tokio::sync::{mpsc, mpsc::UnboundedSender, oneshot};
pub type DocId = String;
2021-12-03 22:40:56 +08:00
pub struct ClientDocEditor {
pub doc_id: DocId,
rev_manager: Arc<RevisionManager>,
2021-12-03 22:40:56 +08:00
edit_tx: UnboundedSender<EditCommand>,
2021-12-08 21:51:06 +08:00
ws_sender: Arc<dyn DocumentWebSocket>,
user: Arc<dyn DocumentUser>,
2021-12-08 21:51:06 +08:00
ws_msg_tx: UnboundedSender<WsDocumentData>,
}
#[cfg(feature = "flowy_unit_test")]
impl ClientDocEditor {
pub async fn doc_json(&self) -> DocResult<String> {
let (ret, rx) = oneshot::channel::<DocumentResult<String>>();
let msg = EditCommand::ReadDoc { ret };
let _ = self.edit_tx.send(msg);
let s = rx.await.map_err(internal_error)??;
Ok(s)
}
pub fn rev_manager(&self) -> Arc<RevisionManager> { self.rev_manager.clone() }
}
2021-12-03 22:40:56 +08:00
impl ClientDocEditor {
pub(crate) async fn new(
doc_id: &str,
user: Arc<dyn DocumentUser>,
2021-12-08 21:51:06 +08:00
pool: Arc<ConnectionPool>,
mut rev_manager: RevisionManager,
ws_sender: Arc<dyn DocumentWebSocket>,
) -> DocResult<Arc<Self>> {
2021-10-07 20:46:29 +08:00
let delta = rev_manager.load_document().await?;
2021-12-03 22:40:56 +08:00
let edit_queue_tx = spawn_edit_queue(doc_id, delta, pool.clone());
let doc_id = doc_id.to_string();
2021-10-07 20:46:29 +08:00
let rev_manager = Arc::new(rev_manager);
2021-12-08 21:51:06 +08:00
let (ws_msg_tx, ws_msg_rx) = mpsc::unbounded_channel();
let edit_doc = Arc::new(Self {
doc_id,
rev_manager,
2021-12-03 22:40:56 +08:00
edit_tx: edit_queue_tx,
user,
2021-12-08 21:51:06 +08:00
ws_msg_tx,
ws_sender,
});
edit_doc.notify_open_doc();
2021-12-08 21:51:06 +08:00
start_sync(edit_doc.clone(), ws_msg_rx);
Ok(edit_doc)
}
pub async fn insert<T: ToString>(&self, index: usize, data: T) -> Result<(), DocError> {
2021-12-07 10:39:01 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<RichTextDelta>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::Insert {
index,
data: data.to_string(),
ret,
};
2021-12-03 22:40:56 +08:00
let _ = self.edit_tx.send(msg);
2021-10-06 23:21:57 +08:00
let delta = rx.await.map_err(internal_error)??;
2021-11-12 21:44:26 +08:00
let _ = self.save_local_delta(delta).await?;
Ok(())
}
pub async fn delete(&self, interval: Interval) -> Result<(), DocError> {
2021-12-07 10:39:01 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<RichTextDelta>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::Delete { interval, ret };
let _ = self.edit_tx.send(msg);
2021-10-06 23:21:57 +08:00
let delta = rx.await.map_err(internal_error)??;
let _ = self.save_local_delta(delta).await?;
Ok(())
}
2021-12-07 10:39:01 +08:00
pub async fn format(&self, interval: Interval, attribute: RichTextAttribute) -> Result<(), DocError> {
let (ret, rx) = oneshot::channel::<DocumentResult<RichTextDelta>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::Format {
interval,
attribute,
ret,
};
2021-12-03 22:40:56 +08:00
let _ = self.edit_tx.send(msg);
2021-10-06 23:21:57 +08:00
let delta = rx.await.map_err(internal_error)??;
let _ = self.save_local_delta(delta).await?;
Ok(())
}
pub async fn replace<T: ToString>(&mut self, interval: Interval, data: T) -> Result<(), DocError> {
2021-12-07 10:39:01 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<RichTextDelta>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::Replace {
interval,
data: data.to_string(),
ret,
};
2021-12-03 22:40:56 +08:00
let _ = self.edit_tx.send(msg);
2021-10-06 23:21:57 +08:00
let delta = rx.await.map_err(internal_error)??;
let _ = self.save_local_delta(delta).await?;
Ok(())
}
pub async fn can_undo(&self) -> bool {
let (ret, rx) = oneshot::channel::<bool>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::CanUndo { ret };
let _ = self.edit_tx.send(msg);
rx.await.unwrap_or(false)
}
pub async fn can_redo(&self) -> bool {
let (ret, rx) = oneshot::channel::<bool>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::CanRedo { ret };
let _ = self.edit_tx.send(msg);
rx.await.unwrap_or(false)
}
pub async fn undo(&self) -> Result<UndoResult, DocError> {
2021-11-19 12:18:46 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<UndoResult>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::Undo { ret };
let _ = self.edit_tx.send(msg);
2021-11-19 12:18:46 +08:00
let r = rx.await.map_err(internal_error)??;
Ok(r)
}
pub async fn redo(&self) -> Result<UndoResult, DocError> {
2021-11-19 12:18:46 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<UndoResult>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::Redo { ret };
let _ = self.edit_tx.send(msg);
2021-11-19 12:18:46 +08:00
let r = rx.await.map_err(internal_error)??;
Ok(r)
}
2021-10-06 15:23:38 +08:00
pub async fn delta(&self) -> DocResult<DocDelta> {
2021-11-19 12:18:46 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<String>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::ReadDoc { ret };
let _ = self.edit_tx.send(msg);
let data = rx.await.map_err(internal_error)??;
2021-10-06 15:23:38 +08:00
Ok(DocDelta {
doc_id: self.doc_id.clone(),
data,
})
}
2021-12-07 10:39:01 +08:00
async fn save_local_delta(&self, delta: RichTextDelta) -> Result<RevId, DocError> {
2021-10-06 23:21:57 +08:00
let delta_data = delta.to_bytes();
let (base_rev_id, rev_id) = self.rev_manager.next_rev_id();
let delta_data = delta_data.to_vec();
let revision = Revision::new(base_rev_id, rev_id, delta_data, &self.doc_id, RevType::Local);
let _ = self.rev_manager.add_revision(&revision).await?;
2021-10-02 21:35:06 +08:00
Ok(rev_id.into())
}
#[tracing::instrument(level = "debug", skip(self, data), err)]
pub(crate) async fn composing_local_delta(&self, data: Bytes) -> Result<(), DocError> {
2021-12-07 10:39:01 +08:00
let delta = RichTextDelta::from_bytes(&data)?;
2021-11-19 12:18:46 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<()>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::ComposeDelta {
2021-10-06 23:21:57 +08:00
delta: delta.clone(),
ret,
};
2021-12-03 22:40:56 +08:00
let _ = self.edit_tx.send(msg);
let _ = rx.await.map_err(internal_error)??;
2021-11-12 21:44:26 +08:00
let _ = self.save_local_delta(delta).await?;
Ok(())
}
#[tracing::instrument(level = "debug", skip(self))]
fn notify_open_doc(&self) {
let rev_id: RevId = self.rev_manager.rev_id().into();
if let Ok(user_id) = self.user.user_id() {
2021-12-08 21:51:06 +08:00
let action = OpenDocAction::new(&user_id, &self.doc_id, &rev_id, &self.ws_sender);
let strategy = ExponentialBackoff::from_millis(50).take(3);
let retry = Retry::spawn(strategy, action);
tokio::spawn(async move {
match retry.await {
2021-12-04 17:31:32 +08:00
Ok(_) => log::debug!("Notify open doc success"),
Err(e) => log::error!("Notify open doc failed: {}", e),
}
});
}
}
#[tracing::instrument(level = "debug", skip(self))]
2021-12-08 21:51:06 +08:00
pub(crate) async fn handle_push_rev(&self, bytes: Bytes) -> DocResult<()> {
// Transform the revision
2021-11-19 12:18:46 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<TransformDeltas>>();
2021-12-08 17:33:22 +08:00
let _ = self.edit_tx.send(EditCommand::ProcessRemoteRevision { bytes, ret });
let TransformDeltas {
client_prime,
server_prime,
server_rev_id,
} = rx.await.map_err(internal_error)??;
2021-10-04 17:47:21 +08:00
if self.rev_manager.rev_id() >= server_rev_id.value {
// Ignore this push revision if local_rev_id >= server_rev_id
return Ok(());
}
// compose delta
2021-11-19 12:18:46 +08:00
let (ret, rx) = oneshot::channel::<DocumentResult<()>>();
2021-12-03 22:40:56 +08:00
let msg = EditCommand::ComposeDelta {
delta: client_prime.clone(),
ret,
};
2021-12-03 22:40:56 +08:00
let _ = self.edit_tx.send(msg);
let _ = rx.await.map_err(internal_error)??;
// update rev id
2021-11-11 19:56:30 +08:00
self.rev_manager
.update_rev_id_counter_value(server_rev_id.clone().into());
2021-10-06 23:21:57 +08:00
let (local_base_rev_id, local_rev_id) = self.rev_manager.next_rev_id();
// save the revision
let revision = Revision::new(
2021-10-06 23:21:57 +08:00
local_base_rev_id,
local_rev_id,
client_prime.to_bytes().to_vec(),
&self.doc_id,
RevType::Remote,
);
let _ = self.rev_manager.add_revision(&revision).await?;
// send the server_prime delta
let revision = Revision::new(
2021-10-06 23:21:57 +08:00
local_base_rev_id,
local_rev_id,
server_prime.to_bytes().to_vec(),
&self.doc_id,
RevType::Remote,
);
2021-12-08 21:51:06 +08:00
let _ = self.ws_sender.send(revision.into());
Ok(())
}
async fn handle_ws_message(&self, doc_data: WsDocumentData) -> DocResult<()> {
2021-12-08 21:51:06 +08:00
match self.ws_msg_tx.send(doc_data) {
Ok(_) => {},
Err(e) => log::error!("Propagate ws message data failed. {}", e),
}
Ok(())
}
}
2021-12-03 22:40:56 +08:00
pub struct EditDocWsHandler(pub Arc<ClientDocEditor>);
2021-12-04 17:31:32 +08:00
impl std::ops::Deref for EditDocWsHandler {
type Target = Arc<ClientDocEditor>;
fn deref(&self) -> &Self::Target { &self.0 }
}
impl WsDocumentHandler for EditDocWsHandler {
fn receive(&self, doc_data: WsDocumentData) {
let edit_doc = self.0.clone();
tokio::spawn(async move {
if let Err(e) = edit_doc.handle_ws_message(doc_data).await {
log::error!("{:?}", e);
}
});
}
2021-12-05 14:04:25 +08:00
fn state_changed(&self, state: &WsConnectState) {
match state {
2021-12-05 14:04:25 +08:00
WsConnectState::Init => {},
WsConnectState::Connecting => {},
WsConnectState::Connected => self.notify_open_doc(),
WsConnectState::Disconnected => {},
}
}
}
2021-12-07 10:39:01 +08:00
fn spawn_edit_queue(doc_id: &str, delta: RichTextDelta, _pool: Arc<ConnectionPool>) -> UnboundedSender<EditCommand> {
2021-12-03 22:40:56 +08:00
let (sender, receiver) = mpsc::unbounded_channel::<EditCommand>();
let actor = EditCommandQueue::new(doc_id, delta, receiver);
tokio::spawn(actor.run());
sender
}
2021-12-08 21:51:06 +08:00
fn start_sync(editor: Arc<ClientDocEditor>, ws_msg_rx: mpsc::UnboundedReceiver<WsDocumentData>) {
let rev_manager = editor.rev_manager.clone();
let ws_sender = editor.ws_sender.clone();
let up_stream = editor.rev_manager.make_up_stream();
let down_stream = RevisionDownStream::new(editor, rev_manager, ws_msg_rx, ws_sender);
tokio::spawn(up_stream.run());
tokio::spawn(down_stream.run());
}