use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use rightkit_http::{
form_encode, parse_retry_after, Client, ErrorClass, HttpError, Method, Request, Response,
RetryPolicy,
};
use serde_json::{json, Value};
use crate::engine::SyncConfig;
use crate::error::{SyncError, SyncResult};
use crate::record::RawRecord;
use crate::traits::{AuthProvider, Backend, ChangePage, RecordOutcome, SavePolicy};
use crate::wire::WireRecord;
pub const DEFAULT_API_BASE: &str = "https://www.googleapis.com";
pub const SCOPE: &str = "https://www.googleapis.com/auth/drive.appdata";
const FOLDER_MIME: &str = "application/vnd.google-apps.folder";
const RECORD_MIME: &str = "application/json";
const NETWORK_RETRY_SECS: f64 = 15.0;
const SERVER_RETRY_SECS: f64 = 30.0;
pub fn sync_config() -> SyncConfig {
SyncConfig {
require_consent_on_scope_change: true,
..SyncConfig::default()
}
}
pub fn account_scope(app: &str, zone: &str, account_id: &str) -> String {
rightkit_fs::digest::sha256_bytes(
format!("rightkit-drive|{app}|{zone}|{account_id}").as_bytes(),
)
}
pub trait DriveTokenSource: Send + Sync {
fn access_token(&self) -> SyncResult<Option<String>>;
fn rejected(&self, _token: &str) {}
fn account_scope(&self) -> Option<String> {
None
}
fn generation(&self) -> u64 {
0
}
}
pub struct FnToken<F>(pub F);
impl<F> DriveTokenSource for FnToken<F>
where
F: Fn() -> SyncResult<Option<String>> + Send + Sync,
{
fn access_token(&self) -> SyncResult<Option<String>> {
(self.0)()
}
}
pub struct DriveAuth {
source: Arc<dyn DriveTokenSource>,
enabled: AtomicBool,
epoch: AtomicU64,
}
impl DriveAuth {
pub fn new(source: Arc<dyn DriveTokenSource>) -> Self {
Self {
source,
enabled: AtomicBool::new(true),
epoch: AtomicU64::new(0),
}
}
pub fn set_enabled(&self, enabled: bool) {
self.enabled.store(enabled, Ordering::SeqCst);
if !enabled {
self.epoch.fetch_add(1, Ordering::SeqCst);
}
}
}
impl AuthProvider for DriveAuth {
fn enabled(&self) -> bool {
self.enabled.load(Ordering::SeqCst)
}
fn availability(&self) -> SyncResult<()> {
match self.source.access_token()? {
Some(t) if !t.is_empty() => Ok(()),
_ => Err(SyncError::Unavailable(
"not signed in to Google Drive".into(),
)),
}
}
fn generation(&self) -> u64 {
self.source
.generation()
.wrapping_add(self.epoch.load(Ordering::SeqCst))
}
fn account_scope(&self) -> Option<String> {
self.source.account_scope()
}
fn bearer(&self) -> SyncResult<Option<String>> {
self.source.access_token()
}
}
#[derive(Debug, Clone)]
pub struct DriveConfig {
pub api_base: String,
pub zone: String,
pub max_batch: usize,
pub page_size: usize,
pub max_record_bytes: usize,
pub request_timeout: Option<Duration>,
}
impl DriveConfig {
pub fn new(zone: impl Into<String>) -> Self {
Self {
api_base: DEFAULT_API_BASE.to_string(),
zone: zone.into(),
max_batch: 25,
page_size: 50,
max_record_bytes: 1024 * 1024,
request_timeout: None,
}
}
}
struct Fail {
status: u16,
err: SyncError,
}
impl Fail {
fn not_found(&self) -> bool {
self.status == 404
}
fn local(err: SyncError) -> Self {
Self { status: 0, err }
}
}
impl From<SyncError> for Fail {
fn from(err: SyncError) -> Self {
Fail::local(err)
}
}
impl From<Fail> for SyncError {
fn from(f: Fail) -> Self {
f.err
}
}
type DResult<T> = Result<T, Fail>;
fn zone_missing() -> Fail {
Fail {
status: 404,
err: SyncError::ZoneMissing,
}
}
fn malformed(what: &str) -> Fail {
Fail::local(SyncError::Transient(format!(
"malformed Google Drive response: {what}"
)))
}
fn segment(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for b in s.bytes() {
match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
out.push(b as char)
}
_ => out.push_str(&format!("%{b:02X}")),
}
}
out
}
fn q_quote(s: &str) -> String {
s.replace('\\', "\\\\").replace('\'', "\\'")
}
fn file_name(record_name: &str) -> String {
format!("{record_name}.json")
}
fn make_tag(id: &str, version: &str) -> String {
format!("{id}:{version}")
}
fn parse_tag(tag: Option<&str>) -> Option<(String, String)> {
let (id, version) = tag?.split_once(':')?;
if id.is_empty() {
return None;
}
Some((id.to_string(), version.to_string()))
}
fn version_str(v: &Value) -> Option<String> {
match v {
Value::String(s) => Some(s.clone()),
Value::Number(n) => Some(n.to_string()),
_ => None,
}
}
#[derive(Debug, Clone)]
struct FileMeta {
id: String,
version: String,
}
fn meta_of(v: &Value) -> Option<FileMeta> {
Some(FileMeta {
id: v.get("id")?.as_str()?.to_string(),
version: v.get("version").and_then(version_str).unwrap_or_default(),
})
}
fn map_http_error(e: &HttpError) -> SyncError {
match e.class() {
ErrorClass::Timeout | ErrorClass::Transport => SyncError::RetryAfter {
secs: NETWORK_RETRY_SECS,
detail: e.to_string(),
},
ErrorClass::AddressDenied | ErrorClass::Invalid => SyncError::Unavailable(e.to_string()),
_ => SyncError::Transient(e.to_string()),
}
}
fn retry_after(resp: &Response) -> Option<f64> {
resp.header("retry-after")
.and_then(parse_retry_after)
.map(|d| d.as_secs_f64())
.filter(|s| s.is_finite() && *s > 0.0)
}
fn google_error(resp: &Response) -> (Option<String>, String) {
let parsed: Option<Value> = serde_json::from_slice(&resp.body).ok();
let err = parsed.as_ref().and_then(|v| v.get("error"));
let reason = err
.and_then(|e| e.get("errors"))
.and_then(Value::as_array)
.and_then(|a| {
a.iter()
.find_map(|e| e.get("reason").and_then(Value::as_str))
})
.map(str::to_string);
let message = err
.and_then(|e| e.get("message"))
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
(reason, message)
}
fn fail_from_response(resp: &Response) -> Fail {
let (reason, message) = google_error(resp);
let mut detail = format!("Google Drive HTTP {}", resp.status);
if let Some(r) = &reason {
detail.push(' ');
detail.push_str(r);
}
if !message.is_empty() {
detail.push_str(": ");
detail.push_str(&message);
}
let hint = retry_after(resp);
let err = match resp.status {
401 => SyncError::Unavailable(detail),
403 => match reason.as_deref() {
Some("rateLimitExceeded" | "userRateLimitExceeded" | "sharingRateLimitExceeded") => {
SyncError::RetryAfter {
secs: hint.unwrap_or(SERVER_RETRY_SECS),
detail,
}
}
_ => SyncError::Unavailable(detail),
},
404 => SyncError::Transient(detail),
408 | 429 | 500..=599 => SyncError::RetryAfter {
secs: hint.unwrap_or(SERVER_RETRY_SECS),
detail,
},
_ => SyncError::Unavailable(detail),
};
Fail {
status: resp.status,
err,
}
}
fn json_of(resp: &Response) -> DResult<Value> {
resp.json::<Value>()
.map_err(|_| malformed("body is not JSON"))
}
fn multipart_body(meta: &Value, content: &[u8]) -> (String, Vec<u8>) {
let meta_bytes = serde_json::to_vec(meta).unwrap_or_default();
let clashes = |b: &str| {
let needle = b.as_bytes();
meta_bytes.windows(needle.len()).any(|w| w == needle)
|| content.windows(needle.len()).any(|w| w == needle)
};
let mut n = 0u32;
let boundary = loop {
let b = format!("rightkit_sync_{n:04}_boundary");
if !clashes(&b) {
break b;
}
n += 1;
};
let mut body = Vec::with_capacity(meta_bytes.len() + content.len() + 256);
body.extend_from_slice(
format!("--{boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n").as_bytes(),
);
body.extend_from_slice(&meta_bytes);
body.extend_from_slice(
format!("\r\n--{boundary}\r\nContent-Type: {RECORD_MIME}\r\n\r\n").as_bytes(),
);
body.extend_from_slice(content);
body.extend_from_slice(format!("\r\n--{boundary}--\r\n").as_bytes());
(boundary, body)
}
enum Downloaded {
Record(RawRecord),
Gone,
Malformed,
}
enum Saved {
Ok,
Conflict(Option<RawRecord>),
}
enum Cursor {
List {
token: Option<String>,
start: Option<String>,
folder: Option<String>,
},
Changes {
token: String,
folder: Option<String>,
},
}
impl Cursor {
fn folder(&self) -> Option<&str> {
match self {
Cursor::List { folder, .. } | Cursor::Changes { folder, .. } => folder.as_deref(),
}
}
fn encode(&self) -> Vec<u8> {
let v = match self {
Cursor::List {
token,
start,
folder,
} => json!({ "v": 1, "p": "list", "t": token, "s": start, "f": folder }),
Cursor::Changes { token, folder } => {
json!({ "v": 1, "p": "chg", "t": token, "f": folder })
}
};
v.to_string().into_bytes()
}
fn decode(bytes: &[u8]) -> Option<Cursor> {
let v: Value = serde_json::from_slice(bytes).ok()?;
if v.get("v").and_then(Value::as_i64) != Some(1) {
return None;
}
let text = |k: &str| v.get(k).and_then(Value::as_str).map(str::to_string);
match v.get("p").and_then(Value::as_str)? {
"list" => Some(Cursor::List {
token: text("t"),
start: text("s"),
folder: text("f"),
}),
"chg" => Some(Cursor::Changes {
token: text("t")?,
folder: text("f"),
}),
_ => None,
}
}
}
pub struct DriveBackend {
client: Client,
tokens: Arc<dyn DriveTokenSource>,
cfg: DriveConfig,
origin: String,
folder: Mutex<Option<String>>,
ids: Mutex<HashMap<String, String>>,
malformed: AtomicU64,
}
impl DriveBackend {
pub fn new(client: Client, tokens: Arc<dyn DriveTokenSource>, mut cfg: DriveConfig) -> Self {
cfg.page_size = cfg.page_size.clamp(1, 1000);
let origin = cfg.api_base.trim_end_matches('/').to_string();
Self {
client,
tokens,
cfg,
origin,
folder: Mutex::new(None),
ids: Mutex::new(HashMap::new()),
malformed: AtomicU64::new(0),
}
}
pub fn malformed_skipped(&self) -> u64 {
self.malformed.load(Ordering::SeqCst)
}
fn token(&self) -> SyncResult<String> {
match self.tokens.access_token()? {
Some(t) if !t.is_empty() => Ok(t),
_ => Err(SyncError::Unavailable(
"not signed in to Google Drive".into(),
)),
}
}
fn url(&self, path: &str, params: &[(&str, &str)]) -> String {
if params.is_empty() {
format!("{}{path}", self.origin)
} else {
format!("{}{path}?{}", self.origin, form_encode(params))
}
}
fn call(&self, req: Request) -> DResult<Response> {
let mut refreshed = false;
loop {
let token = self.token()?;
let mut attempt = req
.clone()
.header("Accept", "application/json")
.retry(RetryPolicy::none())
.bearer(&token);
if let Some(t) = self.cfg.request_timeout {
attempt = attempt.timeout(t);
}
let resp = self
.client
.send_any(&attempt)
.map_err(|e| Fail::local(map_http_error(&e)))?;
if (200..300).contains(&resp.status) {
return Ok(resp);
}
if resp.status == 401 && !refreshed {
refreshed = true;
self.tokens.rejected(&token);
continue;
}
return Err(fail_from_response(&resp));
}
}
fn cached_folder(&self) -> Option<String> {
self.folder.lock().unwrap().clone()
}
fn set_folder(&self, id: &str) {
let mut f = self.folder.lock().unwrap();
if f.as_deref() != Some(id) {
*f = Some(id.to_string());
self.ids.lock().unwrap().clear();
}
}
fn forget_folder(&self) {
*self.folder.lock().unwrap() = None;
self.ids.lock().unwrap().clear();
}
fn remember(&self, name: &str, id: &str) {
self.ids
.lock()
.unwrap()
.insert(name.to_string(), id.to_string());
}
fn forget(&self, name: &str) {
self.ids.lock().unwrap().remove(name);
}
fn cached_id(&self, name: &str) -> Option<String> {
self.ids.lock().unwrap().get(name).cloned()
}
fn find_folder(&self) -> DResult<Option<String>> {
let q = format!(
"name = '{}' and mimeType = '{FOLDER_MIME}' and 'appDataFolder' in parents and trashed = false",
q_quote(&self.cfg.zone)
);
let url = self.url(
"/drive/v3/files",
&[
("spaces", "appDataFolder"),
("q", q.as_str()),
("fields", "files(id)"),
("pageSize", "100"),
],
);
let v = json_of(&self.call(Request::get(url))?)?;
let mut ids: Vec<String> = v
.get("files")
.and_then(Value::as_array)
.map(|a| {
a.iter()
.filter_map(|f| f.get("id").and_then(Value::as_str).map(str::to_string))
.collect()
})
.unwrap_or_default();
ids.sort();
Ok(ids.into_iter().next())
}
fn ensure_folder(&self) -> DResult<String> {
if let Some(id) = self.find_folder()? {
self.set_folder(&id);
return Ok(id);
}
let url = self.url("/drive/v3/files", &[("fields", "id")]);
let req = Request::post(url)
.json(&json!({
"name": self.cfg.zone,
"mimeType": FOLDER_MIME,
"parents": ["appDataFolder"],
}))
.map_err(|e| Fail::local(SyncError::Persistence(e.to_string())))?;
let v = json_of(&self.call(req)?)?;
let mine = v
.get("id")
.and_then(Value::as_str)
.ok_or_else(|| malformed("folder id"))?
.to_string();
match self.find_folder()? {
Some(first) if first != mine => {
let _ = self.delete(&mine);
self.set_folder(&first);
Ok(first)
}
_ => {
self.set_folder(&mine);
Ok(mine)
}
}
}
fn folder_id(&self) -> DResult<String> {
if let Some(id) = self.cached_folder() {
return Ok(id);
}
match self.find_folder()? {
Some(id) => {
self.set_folder(&id);
Ok(id)
}
None => Err(zone_missing()),
}
}
fn find_files(&self, record_name: &str) -> DResult<Vec<FileMeta>> {
let folder = self.folder_id()?;
let q = format!(
"name = '{}' and '{}' in parents and trashed = false",
q_quote(&file_name(record_name)),
q_quote(&folder)
);
let url = self.url(
"/drive/v3/files",
&[
("spaces", "appDataFolder"),
("q", q.as_str()),
("fields", "files(id,version)"),
("pageSize", "100"),
],
);
let v = match self.call(Request::get(url)) {
Ok(r) => json_of(&r)?,
Err(f) if f.not_found() => {
self.forget_folder();
return Err(zone_missing());
}
Err(f) => return Err(f),
};
let mut files: Vec<FileMeta> = v
.get("files")
.and_then(Value::as_array)
.map(|a| a.iter().filter_map(meta_of).collect())
.unwrap_or_default();
files.sort_by(|a, b| a.id.cmp(&b.id));
Ok(files)
}
fn get_meta(&self, id: &str) -> DResult<FileMeta> {
let url = self.url(
&format!("/drive/v3/files/{}", segment(id)),
&[("fields", "id,version,trashed")],
);
let v = json_of(&self.call(Request::get(url))?)?;
if v.get("trashed").and_then(Value::as_bool) == Some(true) {
return Err(Fail {
status: 404,
err: SyncError::Transient("file is trashed".into()),
});
}
meta_of(&v).ok_or_else(|| malformed("file metadata"))
}
fn download(&self, id: &str, version: &str) -> DResult<Downloaded> {
let url = self.url(
&format!("/drive/v3/files/{}", segment(id)),
&[("alt", "media")],
);
let resp = match self.call(Request::get(url)) {
Ok(r) => r,
Err(f) if f.not_found() => return Ok(Downloaded::Gone),
Err(f) => return Err(f),
};
let parsed = serde_json::from_slice::<WireRecord>(&resp.body)
.map_err(|e| e.to_string())
.and_then(WireRecord::into_raw);
match parsed {
Ok(mut rec) => {
rec.change_tag = Some(make_tag(id, version));
self.remember(&rec.record_name, id);
Ok(Downloaded::Record(rec))
}
Err(_) => {
self.malformed.fetch_add(1, Ordering::SeqCst);
Ok(Downloaded::Malformed)
}
}
}
fn server_record(&self, meta: &FileMeta) -> DResult<Option<RawRecord>> {
Ok(match self.download(&meta.id, &meta.version)? {
Downloaded::Record(r) => Some(r),
Downloaded::Gone | Downloaded::Malformed => None,
})
}
fn create(&self, folder: &str, name: &str, body: &[u8]) -> DResult<FileMeta> {
let meta = json!({
"name": name,
"mimeType": RECORD_MIME,
"parents": [folder],
});
let (boundary, payload) = multipart_body(&meta, body);
let url = self.url(
"/upload/drive/v3/files",
&[("uploadType", "multipart"), ("fields", "id,version")],
);
let req = Request::post(url)
.header(
"Content-Type",
format!("multipart/related; boundary={boundary}"),
)
.body(payload);
let v = json_of(&self.call(req)?)?;
meta_of(&v).ok_or_else(|| malformed("created file"))
}
fn update(&self, id: &str, name: &str, body: &[u8]) -> DResult<FileMeta> {
let meta = json!({ "name": name, "mimeType": RECORD_MIME });
let (boundary, payload) = multipart_body(&meta, body);
let url = self.url(
&format!("/upload/drive/v3/files/{}", segment(id)),
&[("uploadType", "multipart"), ("fields", "id,version")],
);
let req = Request::new(Method::Patch, url)
.header(
"Content-Type",
format!("multipart/related; boundary={boundary}"),
)
.body(payload);
let v = json_of(&self.call(req)?)?;
meta_of(&v).ok_or_else(|| malformed("updated file"))
}
fn delete(&self, id: &str) -> DResult<()> {
let url = self.url(&format!("/drive/v3/files/{}", segment(id)), &[]);
self.call(Request::delete(url)).map(|_| ())
}
fn start_page_token(&self) -> DResult<String> {
let url = self.url(
"/drive/v3/changes/startPageToken",
&[("fields", "startPageToken")],
);
let v = json_of(&self.call(Request::get(url))?)?;
v.get("startPageToken")
.and_then(version_str)
.ok_or_else(|| malformed("startPageToken"))
}
fn encode_record(&self, rec: &RawRecord) -> DResult<Vec<u8>> {
if rec.record_name.is_empty() {
return Err(Fail::local(SyncError::Persistence(
"record has no name".into(),
)));
}
let mut w = WireRecord::from(rec);
w.change_tag = None;
w.modified_ms = None;
let bytes = serde_json::to_vec(&w)
.map_err(|e| Fail::local(SyncError::Persistence(e.to_string())))?;
if bytes.len() > self.cfg.max_record_bytes {
return Err(Fail::local(SyncError::Persistence(format!(
"record `{}` is {} bytes, over the {} byte cap",
rec.record_name,
bytes.len(),
self.cfg.max_record_bytes
))));
}
Ok(bytes)
}
fn save_one(&self, rec: &RawRecord, policy: SavePolicy) -> DResult<Saved> {
let body = self.encode_record(rec)?;
match policy {
SavePolicy::Overwrite => self.write_overwrite(rec, &body),
SavePolicy::IfServerUnchanged => self.write_conditional(rec, &body),
}
}
fn create_checked(&self, rec: &RawRecord, body: &[u8], policy: SavePolicy) -> DResult<Saved> {
let name = rec.record_name.as_str();
let fname = file_name(name);
let folder = self.folder_id()?;
let created = match self.create(&folder, &fname, body) {
Ok(m) => m,
Err(f) if f.not_found() => {
self.forget_folder();
return Err(zone_missing());
}
Err(f) => return Err(f),
};
let all = self.find_files(name)?;
match all.first() {
Some(first) if first.id != created.id => {
let _ = self.delete(&created.id);
match policy {
SavePolicy::IfServerUnchanged => {
let server = self.server_record(first)?;
Ok(Saved::Conflict(server))
}
SavePolicy::Overwrite => {
self.update(&first.id, &fname, body)?;
self.remember(name, &first.id);
Ok(Saved::Ok)
}
}
}
_ => {
self.remember(name, &created.id);
Ok(Saved::Ok)
}
}
}
fn write_overwrite(&self, rec: &RawRecord, body: &[u8]) -> DResult<Saved> {
let name = rec.record_name.as_str();
let fname = file_name(name);
let mut candidate = parse_tag(rec.change_tag.as_deref())
.map(|(id, _)| id)
.or_else(|| self.cached_id(name));
for _ in 0..2 {
let id = match candidate.take() {
Some(id) => Some(id),
None => self.find_files(name)?.into_iter().next().map(|m| m.id),
};
match id {
Some(id) => match self.update(&id, &fname, body) {
Ok(_) => {
self.remember(name, &id);
return Ok(Saved::Ok);
}
Err(f) if f.not_found() => {
self.forget(name);
}
Err(f) => return Err(f),
},
None => return self.create_checked(rec, body, SavePolicy::Overwrite),
}
}
self.create_checked(rec, body, SavePolicy::Overwrite)
}
fn write_conditional(&self, rec: &RawRecord, body: &[u8]) -> DResult<Saved> {
let name = rec.record_name.as_str();
let fname = file_name(name);
match (&rec.change_tag, parse_tag(rec.change_tag.as_deref())) {
(Some(_), None) => Err(Fail::local(SyncError::Transient(format!(
"record `{name}` carries a change tag that is not a Drive tag"
)))),
(Some(_), Some((id, version))) => match self.get_meta(&id) {
Ok(meta) if meta.version == version => match self.update(&id, &fname, body) {
Ok(_) => {
self.remember(name, &id);
Ok(Saved::Ok)
}
Err(f) if f.not_found() => {
self.forget(name);
Ok(Saved::Conflict(None))
}
Err(f) => Err(f),
},
Ok(meta) => {
let server = self.server_record(&meta)?;
Ok(Saved::Conflict(server))
}
Err(f) if f.not_found() => {
self.forget(name);
let server = match self.find_files(name)?.first() {
Some(m) => self.server_record(m)?,
None => None,
};
Ok(Saved::Conflict(server))
}
Err(f) => Err(f),
},
(None, _) => {
if let Some(first) = self.find_files(name)?.first() {
return match self.download(&first.id, &first.version)? {
Downloaded::Record(r) => Ok(Saved::Conflict(Some(r))),
Downloaded::Malformed => Err(Fail::local(SyncError::Persistence(format!(
"the Drive file for record `{name}` is not a readable record; not overwritten"
)))),
Downloaded::Gone => self.create_checked(rec, body, SavePolicy::IfServerUnchanged),
};
}
self.create_checked(rec, body, SavePolicy::IfServerUnchanged)
}
}
}
fn push_download(&self, out: &mut Vec<RawRecord>, meta: &FileMeta) -> DResult<()> {
if let Downloaded::Record(r) = self.download(&meta.id, &meta.version)? {
out.push(r);
}
Ok(())
}
fn list_page(
&self,
folder: &str,
token: Option<String>,
start: Option<String>,
) -> SyncResult<ChangePage> {
let start = match start {
Some(s) => s,
None => self.start_page_token()?,
};
let q = format!("'{}' in parents and trashed = false", q_quote(folder));
let size = self.cfg.page_size.to_string();
let mut params: Vec<(&str, &str)> = vec![
("spaces", "appDataFolder"),
("q", q.as_str()),
("pageSize", size.as_str()),
("fields", "nextPageToken,files(id,version,mimeType)"),
];
if let Some(t) = &token {
params.push(("pageToken", t.as_str()));
}
let resp = match self.call(Request::get(self.url("/drive/v3/files", ¶ms))) {
Ok(r) => r,
Err(f) if f.not_found() => {
self.forget_folder();
return Err(SyncError::ZoneMissing);
}
Err(f) if token.is_some() && (f.status == 400 || f.status == 410) => {
return Err(SyncError::TokenExpired)
}
Err(f) => return Err(f.err),
};
let v = json_of(&resp)?;
let files = v
.get("files")
.and_then(Value::as_array)
.ok_or_else(|| malformed("files"))?;
let mut records = Vec::new();
for f in files {
if f.get("mimeType").and_then(Value::as_str) == Some(FOLDER_MIME) {
continue;
}
if let Some(meta) = meta_of(f) {
self.push_download(&mut records, &meta)?;
}
}
let next = v
.get("nextPageToken")
.and_then(Value::as_str)
.map(str::to_string);
let folder = Some(folder.to_string());
let (cursor, more) = match next {
Some(t) => (
Cursor::List {
token: Some(t),
start: Some(start),
folder,
},
true,
),
None => (
Cursor::Changes {
token: start,
folder,
},
false,
),
};
Ok(ChangePage {
records,
deleted_record_names: Vec::new(),
new_token: Some(cursor.encode()),
more_coming: more,
})
}
fn change_page(&self, folder: &str, token: &str) -> SyncResult<ChangePage> {
let size = self.cfg.page_size.to_string();
let url = self.url(
"/drive/v3/changes",
&[
("pageToken", token),
("spaces", "appDataFolder"),
("includeRemoved", "true"),
("pageSize", size.as_str()),
(
"fields",
"nextPageToken,newStartPageToken,changes(fileId,removed,file(id,version,mimeType,parents,trashed))",
),
],
);
let resp = match self.call(Request::get(url)) {
Ok(r) => r,
Err(f) if f.status == 400 || f.status == 410 => return Err(SyncError::TokenExpired),
Err(f) => return Err(f.err),
};
let v = json_of(&resp)?;
let changes = v
.get("changes")
.and_then(Value::as_array)
.ok_or_else(|| malformed("changes"))?;
let mut order: Vec<String> = Vec::new();
let mut latest: HashMap<String, FileMeta> = HashMap::new();
for c in changes {
let Some(file_id) = c.get("fileId").and_then(Value::as_str) else {
continue;
};
if c.get("removed").and_then(Value::as_bool) == Some(true) {
if file_id == folder {
self.forget_folder();
return Err(SyncError::ZoneMissing);
}
latest.remove(file_id);
continue;
}
let Some(file) = c.get("file") else { continue };
let in_zone = file
.get("parents")
.and_then(Value::as_array)
.is_some_and(|p| p.iter().any(|x| x.as_str() == Some(folder)));
let trashed = file.get("trashed").and_then(Value::as_bool) == Some(true);
let is_folder = file.get("mimeType").and_then(Value::as_str) == Some(FOLDER_MIME);
if !in_zone || trashed || is_folder {
continue;
}
if let Some(meta) = meta_of(file) {
if !latest.contains_key(file_id) {
order.push(file_id.to_string());
}
latest.insert(file_id.to_string(), meta);
}
}
let mut records = Vec::new();
for id in &order {
if let Some(meta) = latest.get(id) {
self.push_download(&mut records, meta)?;
}
}
let (token, more) = match v.get("nextPageToken").and_then(version_str) {
Some(t) => (t, true),
None => (
v.get("newStartPageToken")
.and_then(version_str)
.ok_or_else(|| malformed("newStartPageToken"))?,
false,
),
};
Ok(ChangePage {
records,
deleted_record_names: Vec::new(),
new_token: Some(
Cursor::Changes {
token,
folder: Some(folder.to_string()),
}
.encode(),
),
more_coming: more,
})
}
}
impl Backend for DriveBackend {
fn prepare(&self) -> SyncResult<()> {
self.ensure_folder().map(|_| ()).map_err(SyncError::from)
}
fn fetch_changes(&self, since: Option<&[u8]>) -> SyncResult<ChangePage> {
let cursor = match since {
None => Cursor::List {
token: None,
start: None,
folder: None,
},
Some(bytes) => Cursor::decode(bytes).ok_or(SyncError::TokenExpired)?,
};
let folder = self.folder_id()?;
if cursor.folder().is_some_and(|f| f != folder) {
return Err(SyncError::ZoneMissing);
}
match cursor {
Cursor::List { token, start, .. } => self.list_page(&folder, token, start),
Cursor::Changes { token, .. } => self.change_page(&folder, &token),
}
}
fn fetch_record(&self, record_name: &str) -> SyncResult<Option<RawRecord>> {
let files = self.find_files(record_name)?;
let Some(first) = files.first() else {
return Ok(None);
};
Ok(self.server_record(first)?)
}
fn save_records(
&self,
records: &[RawRecord],
policy: SavePolicy,
) -> SyncResult<Vec<RecordOutcome>> {
let mut out: Vec<RecordOutcome> = Vec::with_capacity(records.len());
let mut abort: Option<SyncError> = None;
for (i, r) in records.iter().enumerate() {
let name = r.record_name.clone();
if let Some(e) = &abort {
out.push(RecordOutcome {
record_name: name,
result: Err(e.clone()),
server_record: None,
});
continue;
}
match self.save_one(r, policy) {
Ok(Saved::Ok) => out.push(RecordOutcome {
record_name: name,
result: Ok(()),
server_record: None,
}),
Ok(Saved::Conflict(server)) => out.push(RecordOutcome {
record_name: name,
result: Err(SyncError::Conflict),
server_record: server,
}),
Err(f) => {
let call_level = matches!(
f.err,
SyncError::RetryAfter { .. }
| SyncError::Unavailable(_)
| SyncError::ZoneMissing
| SyncError::Cancelled
);
if call_level {
if i == 0 {
return Err(f.err);
}
abort = Some(f.err.clone());
}
out.push(RecordOutcome {
record_name: name,
result: Err(f.err),
server_record: None,
});
}
}
}
Ok(out)
}
fn max_batch(&self) -> usize {
self.cfg.max_batch.max(1)
}
}