mirror of
https://github.com/ankitects/anki.git
synced 2026-01-16 23:39:01 -05:00
3707e54ffa
This PR replaces the existing Python-driven sync server with a new one in Rust. The new server supports both collection and media syncing, and is compatible with both the new protocol mentioned below, and older clients. A setting has been added to the preferences screen to point Anki to a local server, and a similar setting is likely to come to AnkiMobile soon. Documentation is available here: <https://docs.ankiweb.net/sync-server.html> In addition to the new server and refactoring, this PR also makes changes to the sync protocol. The existing sync protocol places payloads and metadata inside a multipart POST body, which causes a few headaches: - Legacy clients build the request in a non-deterministic order, meaning the entire request needs to be scanned to extract the metadata. - Reqwest's multipart API directly writes the multipart body, without exposing the resulting stream to us, making it harder to track the progress of the transfer. We've been relying on a patched version of reqwest for timeouts, which is a pain to keep up to date. To address these issues, the metadata is now sent in a HTTP header, with the data payload sent directly in the body. Instead of the slower gzip, we now use zstd. The old timeout handling code has been replaced with a new implementation that wraps the request and response body streams to track progress, allowing us to drop the git dependencies for reqwest, hyper-timeout and tokio-io-timeout. The main other change to the protocol is that one-way syncs no longer need to downgrade the collection to schema 11 prior to sending.
89 lines
2.3 KiB
Rust
89 lines
2.3 KiB
Rust
// Copyright: Ankitects Pty Ltd and contributors
|
|
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
|
|
use std::path::PathBuf;
|
|
|
|
use snafu::Snafu;
|
|
|
|
/// Wrapper for [std::io::Error] with additional information on the attempted
|
|
/// operation.
|
|
#[derive(Debug, Snafu)]
|
|
#[snafu(visibility(pub), display("{op:?} {path:?}"))]
|
|
pub struct FileIoError {
|
|
pub path: PathBuf,
|
|
pub op: FileOp,
|
|
pub source: std::io::Error,
|
|
}
|
|
|
|
impl PartialEq for FileIoError {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.path == other.path && self.op == other.op
|
|
}
|
|
}
|
|
|
|
impl Eq for FileIoError {}
|
|
|
|
#[derive(Debug, PartialEq, Clone, Eq)]
|
|
pub enum FileOp {
|
|
Read,
|
|
Open,
|
|
Create,
|
|
Write,
|
|
Remove,
|
|
CopyFrom(PathBuf),
|
|
Persist,
|
|
Sync,
|
|
/// For legacy errors without any context.
|
|
Unknown,
|
|
}
|
|
|
|
impl FileOp {
|
|
pub fn copy(from: impl Into<PathBuf>) -> Self {
|
|
Self::CopyFrom(from.into())
|
|
}
|
|
}
|
|
|
|
impl FileIoError {
|
|
pub fn message(&self) -> String {
|
|
format!(
|
|
"Failed to {} '{}':<br>{}",
|
|
match &self.op {
|
|
FileOp::Unknown => return format!("{}", self.source),
|
|
FileOp::Open => "open".into(),
|
|
FileOp::Read => "read".into(),
|
|
FileOp::Create => "create file in".into(),
|
|
FileOp::Write => "write".into(),
|
|
FileOp::Remove => "remove".into(),
|
|
FileOp::CopyFrom(p) => format!("copy from '{}' to", p.to_string_lossy()),
|
|
FileOp::Persist => "persist".into(),
|
|
FileOp::Sync => "sync".into(),
|
|
},
|
|
self.path.to_string_lossy(),
|
|
self.source
|
|
)
|
|
}
|
|
|
|
pub(crate) fn is_not_found(&self) -> bool {
|
|
self.source.kind() == std::io::ErrorKind::NotFound
|
|
}
|
|
}
|
|
|
|
impl From<tempfile::PathPersistError> for FileIoError {
|
|
fn from(err: tempfile::PathPersistError) -> Self {
|
|
FileIoError {
|
|
path: err.path.to_path_buf(),
|
|
op: FileOp::Persist,
|
|
source: err.error,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<tempfile::PersistError> for FileIoError {
|
|
fn from(err: tempfile::PersistError) -> Self {
|
|
FileIoError {
|
|
path: err.file.path().into(),
|
|
op: FileOp::Persist,
|
|
source: err.error,
|
|
}
|
|
}
|
|
}
|