108 lines
2.8 KiB
Rust
108 lines
2.8 KiB
Rust
use crate::{
|
|
config::{Config, UrlKind},
|
|
data::NodeCache,
|
|
db::Db,
|
|
error::MyError,
|
|
requests::{Breakers, Requests},
|
|
};
|
|
use activitystreams::url::Url;
|
|
use actix_web::web;
|
|
use async_rwlock::RwLock;
|
|
use log::info;
|
|
use lru::LruCache;
|
|
use rand::thread_rng;
|
|
use rsa::{RSAPrivateKey, RSAPublicKey};
|
|
use std::sync::Arc;
|
|
|
|
#[derive(Clone)]
|
|
pub struct State {
|
|
pub(crate) public_key: RSAPublicKey,
|
|
private_key: RSAPrivateKey,
|
|
config: Config,
|
|
object_cache: Arc<RwLock<LruCache<Url, Url>>>,
|
|
node_cache: NodeCache,
|
|
breakers: Breakers,
|
|
pub(crate) db: Db,
|
|
}
|
|
|
|
impl State {
|
|
pub(crate) fn node_cache(&self) -> NodeCache {
|
|
self.node_cache.clone()
|
|
}
|
|
|
|
pub(crate) fn requests(&self) -> Requests {
|
|
Requests::new(
|
|
self.config.generate_url(UrlKind::MainKey).to_string(),
|
|
self.private_key.clone(),
|
|
format!(
|
|
"Actix Web 3.0.0-alpha.1 ({}/{}; +{})",
|
|
self.config.software_name(),
|
|
self.config.software_version(),
|
|
self.config.generate_url(UrlKind::Index),
|
|
),
|
|
self.breakers.clone(),
|
|
)
|
|
}
|
|
|
|
pub(crate) async fn inboxes_without(
|
|
&self,
|
|
existing_inbox: &Url,
|
|
domain: &str,
|
|
) -> Result<Vec<Url>, MyError> {
|
|
Ok(self
|
|
.db
|
|
.inboxes()
|
|
.await?
|
|
.iter()
|
|
.filter_map(|inbox| {
|
|
if let Some(dom) = inbox.domain() {
|
|
if inbox != existing_inbox && dom != domain {
|
|
return Some(inbox.clone());
|
|
}
|
|
}
|
|
|
|
None
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
pub(crate) async fn is_cached(&self, object_id: &Url) -> bool {
|
|
self.object_cache.read().await.contains(object_id)
|
|
}
|
|
|
|
pub(crate) async fn cache(&self, object_id: Url, actor_id: Url) {
|
|
self.object_cache.write().await.put(object_id, actor_id);
|
|
}
|
|
|
|
pub(crate) async fn build(config: Config, db: Db) -> Result<Self, MyError> {
|
|
let private_key = if let Ok(Some(key)) = db.private_key().await {
|
|
key
|
|
} else {
|
|
info!("Generating new keys");
|
|
let key = web::block(move || {
|
|
let mut rng = thread_rng();
|
|
RSAPrivateKey::new(&mut rng, 4096)
|
|
})
|
|
.await?;
|
|
|
|
db.update_private_key(&key).await?;
|
|
|
|
key
|
|
};
|
|
|
|
let public_key = private_key.to_public_key();
|
|
|
|
let state = State {
|
|
public_key,
|
|
private_key,
|
|
config,
|
|
object_cache: Arc::new(RwLock::new(LruCache::new(1024 * 8))),
|
|
node_cache: NodeCache::new(db.clone()),
|
|
breakers: Breakers::default(),
|
|
db,
|
|
};
|
|
|
|
Ok(state)
|
|
}
|
|
}
|