use crate::json::Value;
use crate::strings;
use std::collections::BTreeMap;
use std::fmt;
use std::rc::Rc;
#[derive(Clone, Default)]
pub enum ZeroStorage {
#[default]
Memory,
#[cfg(feature = "sqlite")]
Sqlite {
directory: Option<std::path::PathBuf>,
},
Custom(Rc<dyn StorageBackend>),
}
impl fmt::Debug for ZeroStorage {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ZeroStorage::Memory => f.write_str("Memory"),
#[cfg(feature = "sqlite")]
ZeroStorage::Sqlite { directory } => f
.debug_struct("Sqlite")
.field("directory", directory)
.finish(),
ZeroStorage::Custom(b) => write!(f, "Custom({})", b.location()),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct StorageFailure {
pub kind: StorageFailureKind,
pub message: String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum StorageFailureKind {
Full,
CannotOpen,
IoError,
}
impl StorageFailureKind {
pub fn as_str(self) -> &'static str {
match self {
StorageFailureKind::Full => "full",
StorageFailureKind::CannotOpen => "cannot-open",
StorageFailureKind::IoError => "io-error",
}
}
}
impl StorageFailure {
pub fn new(kind: StorageFailureKind, message: impl Into<String>) -> Self {
StorageFailure {
kind,
message: message.into(),
}
}
}
impl fmt::Display for StorageFailure {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}: {}", self.kind.as_str(), self.message)
}
}
impl std::error::Error for StorageFailure {}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum LoadError {
Failure(StorageFailure),
Corrupt(String),
}
impl From<StorageFailure> for LoadError {
fn from(f: StorageFailure) -> Self {
LoadError::Failure(f)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DroppedDatabases {
pub deleted: Vec<String>,
pub errors: Vec<StorageFailure>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct ClientGroupRecord {
pub id: String,
pub mutator_names: Vec<String>,
pub disabled: bool,
}
#[derive(Clone, Debug, PartialEq)]
pub struct ClientRecord {
pub id: String,
pub client_group_id: String,
pub heartbeat: f64,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ClientIdPair {
pub client_group_id: String,
pub client_id: String,
}
impl ClientIdPair {
pub fn normalize(mut pairs: Vec<ClientIdPair>) -> Vec<ClientIdPair> {
pairs.sort_by(|a, b| {
strings::utf16(&a.client_group_id, &b.client_group_id)
.then_with(|| strings::utf16(&a.client_id, &b.client_id))
});
pairs.dedup();
pairs
}
}
pub type AggregateWrites = Vec<(String, Option<Value>)>;
#[derive(Clone, Debug, PartialEq)]
pub struct StoredMutation {
pub client_id: String,
pub id: f64,
pub name: String,
pub args: Value,
pub timestamp: f64,
pub aggregate_writes: AggregateWrites,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StoredGroup {
pub entries: BTreeMap<String, Value>,
pub cookie: Value,
pub last_mutation_ids: BTreeMap<String, f64>,
pub mutations: Vec<StoredMutation>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StoredClients {
pub groups: Vec<ClientGroupRecord>,
pub clients: Vec<ClientRecord>,
pub deleted_clients: Vec<ClientIdPair>,
pub profile_id: String,
}
#[derive(Clone, Debug, PartialEq)]
pub enum StorageOp {
PutGroup(ClientGroupRecord),
DeleteGroup(String),
PutClient(ClientRecord),
DeleteClients(Vec<String>),
SetDeletedClients(Vec<ClientIdPair>),
UpdateSnapshot {
group: String,
changes: Vec<(String, Option<Value>)>,
cleared: bool,
cookie: Value,
last_mutation_ids: BTreeMap<String, f64>,
},
AddMutation {
group: String,
mutation: StoredMutation,
},
SetAggregateWrites {
group: String,
client_id: String,
id: f64,
writes: AggregateWrites,
},
DeleteConfirmedMutations {
group: String,
last_mutation_ids: BTreeMap<String, f64>,
},
}
pub trait StorageBackend {
fn location(&self) -> String;
fn open(&self, name: &str) -> Result<Box<dyn StoredDatabase>, LoadError>;
fn drop_databases(&self, matches: &dyn Fn(&str) -> bool) -> DroppedDatabases;
fn collect_databases(&self, except: &str, now: f64, max_age: f64) {
let _ = (except, now, max_age);
}
}
pub trait StoredDatabase {
fn load(&self) -> Result<StoredClients, LoadError>;
fn load_group(&self, id: &str) -> Result<StoredGroup, LoadError>;
fn write(&self, ops: &[StorageOp]) -> Result<(), StorageFailure>;
fn flush(&self) -> Result<(), StorageFailure>;
fn close(&self) -> Result<(), StorageFailure>;
fn drop_database(&self);
}
pub fn drop_all_databases(storage: &ZeroStorage) -> DroppedDatabases {
super::database::ReplicaDatabase::drop_matching(storage, &|_| true)
}