conduit/src/database/globals.rs

141 lines
4.3 KiB
Rust
Raw Normal View History

use crate::{database::Config, utils, Error, Result};
use log::error;
2020-07-26 13:41:28 +00:00
use ruma::ServerName;
use std::collections::HashMap;
use std::sync::Arc;
2020-12-06 10:05:51 +00:00
use std::sync::RwLock;
2020-12-19 15:00:11 +00:00
use std::time::Duration;
use trust_dns_resolver::TokioAsyncResolver;
pub const COUNTER: &str = "c";
2020-09-15 14:13:54 +00:00
#[derive(Clone)]
pub struct Globals {
2021-02-07 16:38:45 +00:00
pub actual_destination_cache: Arc<RwLock<HashMap<Box<ServerName>, (String, Option<String>)>>>, // actual_destination, host
pub(super) globals: sled::Tree,
2020-12-06 10:05:51 +00:00
config: Config,
2020-09-15 14:13:54 +00:00
keypair: Arc<ruma::signatures::Ed25519KeyPair>,
reqwest_client: reqwest::Client,
2020-12-06 10:05:51 +00:00
dns_resolver: TokioAsyncResolver,
2021-02-07 16:38:45 +00:00
jwt_decoding_key: Option<jsonwebtoken::DecodingKey<'static>>,
}
impl Globals {
2020-12-06 10:05:51 +00:00
pub async fn load(globals: sled::Tree, config: Config) -> Result<Self> {
let bytes = &*globals
.update_and_fetch("keypair", utils::generate_keypair)?
.expect("utils::generate_keypair always returns Some");
let mut parts = bytes.splitn(2, |&b| b == 0xff);
let keypair = utils::string_from_bytes(
// 1. version
parts
.next()
.expect("splitn always returns at least one element"),
)
.map_err(|_| Error::bad_database("Invalid version bytes in keypair."))
.and_then(|version| {
// 2. key
parts
.next()
.ok_or_else(|| Error::bad_database("Invalid keypair format in database."))
.map(|key| (version, key))
})
.and_then(|(version, key)| {
ruma::signatures::Ed25519KeyPair::new(&key, version)
.map_err(|_| Error::bad_database("Private or public keys are invalid."))
});
let keypair = match keypair {
Ok(k) => k,
Err(e) => {
error!("Keypair invalid. Deleting...");
globals.remove("keypair")?;
return Err(e);
}
};
2020-12-19 15:00:11 +00:00
let reqwest_client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(30))
.timeout(Duration::from_secs(60 * 3))
.pool_max_idle_per_host(1)
.build()
.unwrap();
2021-02-07 16:38:45 +00:00
let jwt_decoding_key = config
.jwt_secret
.as_ref()
.map(|secret| jsonwebtoken::DecodingKey::from_secret(secret.as_bytes()).into_static());
2020-06-09 13:13:17 +00:00
Ok(Self {
globals,
2020-12-06 10:05:51 +00:00
config,
keypair: Arc::new(keypair),
2020-12-19 15:00:11 +00:00
reqwest_client,
dns_resolver: TokioAsyncResolver::tokio_from_system_conf()
.await
.map_err(|_| {
Error::bad_config("Failed to set up trust dns resolver with system config.")
})?,
2020-12-06 10:05:51 +00:00
actual_destination_cache: Arc::new(RwLock::new(HashMap::new())),
2021-02-07 16:38:45 +00:00
jwt_decoding_key,
2020-06-09 13:13:17 +00:00
})
}
/// Returns this server's keypair.
2020-06-05 16:19:26 +00:00
pub fn keypair(&self) -> &ruma::signatures::Ed25519KeyPair {
&self.keypair
}
/// Returns a reqwest client which can be used to send requests.
pub fn reqwest_client(&self) -> &reqwest::Client {
&self.reqwest_client
}
pub fn next_count(&self) -> Result<u64> {
Ok(utils::u64_from_bytes(
&self
.globals
.update_and_fetch(COUNTER, utils::increment)?
.expect("utils::increment will always put in a value"),
2020-06-09 13:13:17 +00:00
)
.map_err(|_| Error::bad_database("Count has invalid bytes."))?)
}
pub fn current_count(&self) -> Result<u64> {
2020-06-09 13:13:17 +00:00
self.globals.get(COUNTER)?.map_or(Ok(0_u64), |bytes| {
Ok(utils::u64_from_bytes(&bytes)
.map_err(|_| Error::bad_database("Count has invalid bytes."))?)
2020-06-09 13:13:17 +00:00
})
}
pub fn server_name(&self) -> &ServerName {
self.config.server_name.as_ref()
}
pub fn max_request_size(&self) -> u32 {
self.config.max_request_size
}
2021-01-01 12:47:53 +00:00
pub fn allow_registration(&self) -> bool {
self.config.allow_registration
}
2021-01-01 12:47:53 +00:00
pub fn allow_encryption(&self) -> bool {
self.config.allow_encryption
}
2021-01-01 12:47:53 +00:00
pub fn allow_federation(&self) -> bool {
self.config.allow_federation
}
2020-12-06 10:05:51 +00:00
pub fn dns_resolver(&self) -> &TokioAsyncResolver {
&self.dns_resolver
}
2021-02-07 16:38:45 +00:00
pub fn jwt_decoding_key(&self) -> Option<&jsonwebtoken::DecodingKey<'_>> {
self.jwt_decoding_key.as_ref()
}
}