use std::fmt;
use std::io;
use std::pin::Pin;
use std::sync::{Arc, Mutex, PoisonError};
use super::{SessionData, UpdateState};
use crate::session::Salt;
pub type StorageFuture<'a, T> = Pin<Box<dyn Future<Output = io::Result<T>> + Send + 'a>>;
pub type StorageReporter = Arc<dyn Fn(io::Error) + Send + Sync>;
#[derive(Default)]
pub(crate) struct Reports(Mutex<Option<StorageReporter>>);
impl Reports {
pub(crate) fn set(&self, reporter: StorageReporter) {
*self.0.lock().unwrap_or_else(PoisonError::into_inner) = Some(reporter);
}
pub(crate) fn report(&self, error: io::Error) {
let reporter = self.0.lock().unwrap_or_else(PoisonError::into_inner).clone();
if let Some(reporter) = reporter {
reporter(error);
}
}
}
impl fmt::Debug for Reports {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Reports")
}
}
pub trait Storage: Send + Sync + 'static {
fn set_reporter(&self, reporter: StorageReporter) {
let _ = reporter;
}
fn open(&self) -> StorageFuture<'_, ()> {
Box::pin(async { Ok(()) })
}
fn close(&self) -> StorageFuture<'_, ()> {
Box::pin(async { Ok(()) })
}
fn delete(&self) -> StorageFuture<'_, ()>;
fn load_session(&self) -> StorageFuture<'_, Option<SessionData>>;
fn save_session<'a>(&'a self, session: &'a SessionData) -> StorageFuture<'a, ()>;
fn load_state(&self) -> StorageFuture<'_, Option<StoredState>>;
fn save_state<'a>(&'a self, state: &'a StoredState) -> StorageFuture<'a, ()>;
fn update_peers<'a>(&'a self, peers: &'a [PeerRecord]) -> StorageFuture<'a, ()>;
fn get_peer_by_id(&self, id: i64) -> StorageFuture<'_, Option<PeerRecord>>;
fn get_peer_by_username<'a>(&'a self, username: &'a str) -> StorageFuture<'a, Option<PeerRecord>> {
let _ = username;
Box::pin(async { Ok(None) })
}
fn get_peer_by_phone_number<'a>(&'a self, phone_number: &'a str) -> StorageFuture<'a, Option<PeerRecord>> {
let _ = phone_number;
Box::pin(async { Ok(None) })
}
fn export_peers(&self, limit: Option<usize>) -> StorageFuture<'_, Vec<PeerRecord>> {
let _ = limit;
Box::pin(async { Ok(Vec::new()) })
}
fn clear_peers(&self) -> StorageFuture<'_, ()>;
}
impl<T: Storage + ?Sized> Storage for Arc<T> {
fn set_reporter(&self, reporter: StorageReporter) {
(**self).set_reporter(reporter)
}
fn open(&self) -> StorageFuture<'_, ()> {
(**self).open()
}
fn close(&self) -> StorageFuture<'_, ()> {
(**self).close()
}
fn delete(&self) -> StorageFuture<'_, ()> {
(**self).delete()
}
fn load_session(&self) -> StorageFuture<'_, Option<SessionData>> {
(**self).load_session()
}
fn save_session<'a>(&'a self, session: &'a SessionData) -> StorageFuture<'a, ()> {
(**self).save_session(session)
}
fn load_state(&self) -> StorageFuture<'_, Option<StoredState>> {
(**self).load_state()
}
fn save_state<'a>(&'a self, state: &'a StoredState) -> StorageFuture<'a, ()> {
(**self).save_state(state)
}
fn update_peers<'a>(&'a self, peers: &'a [PeerRecord]) -> StorageFuture<'a, ()> {
(**self).update_peers(peers)
}
fn get_peer_by_id(&self, id: i64) -> StorageFuture<'_, Option<PeerRecord>> {
(**self).get_peer_by_id(id)
}
fn get_peer_by_username<'a>(&'a self, username: &'a str) -> StorageFuture<'a, Option<PeerRecord>> {
(**self).get_peer_by_username(username)
}
fn get_peer_by_phone_number<'a>(&'a self, phone_number: &'a str) -> StorageFuture<'a, Option<PeerRecord>> {
(**self).get_peer_by_phone_number(phone_number)
}
fn export_peers(&self, limit: Option<usize>) -> StorageFuture<'_, Vec<PeerRecord>> {
(**self).export_peers(limit)
}
fn clear_peers(&self) -> StorageFuture<'_, ()> {
(**self).clear_peers()
}
}
#[non_exhaustive]
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PeerRecord {
pub id: i64,
pub access_hash: i64,
pub usernames: Vec<String>,
pub phone_number: Option<String>,
pub updated: i64,
}
impl PeerRecord {
pub fn new(id: i64, access_hash: i64) -> PeerRecord {
PeerRecord { id, access_hash, ..PeerRecord::default() }
}
}
#[non_exhaustive]
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StoredState {
pub owner: i64,
pub salt: Salt,
pub update: Option<UpdateState>,
}
impl StoredState {
pub fn new(owner: i64, salt: Salt, update: Option<UpdateState>) -> StoredState {
StoredState { owner, salt, update }
}
}