2024-04-13 21:22:19 +02:00
|
|
|
use std::collections::BTreeMap;
|
|
|
|
|
2024-04-13 00:44:53 +02:00
|
|
|
use base64::Engine;
|
2024-04-13 04:21:33 +02:00
|
|
|
use reqwest::{header::{ACCEPT, CONTENT_TYPE, USER_AGENT}, Method, Response};
|
2024-03-25 21:19:02 +01:00
|
|
|
use sea_orm::{DatabaseConnection, EntityTrait, IntoActiveModel};
|
|
|
|
|
2024-04-13 03:03:54 +02:00
|
|
|
use crate::{model, VERSION};
|
2024-03-25 21:19:02 +01:00
|
|
|
|
2024-04-13 21:22:19 +02:00
|
|
|
use super::{auth::HttpSignature, Context};
|
2024-04-13 00:44:53 +02:00
|
|
|
|
2024-03-25 21:19:02 +01:00
|
|
|
|
|
|
|
pub struct Fetcher {
|
|
|
|
db: DatabaseConnection,
|
2024-04-13 21:22:19 +02:00
|
|
|
key: String, // TODO store pre-parsed
|
2024-03-25 21:19:02 +01:00
|
|
|
domain: String, // TODO merge directly with Context so we don't need to copy this
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Fetcher {
|
|
|
|
pub fn new(db: DatabaseConnection, domain: String, key: String) -> Self {
|
2024-04-13 21:22:19 +02:00
|
|
|
Fetcher { db, domain, key }
|
2024-03-25 21:19:02 +01:00
|
|
|
}
|
|
|
|
|
2024-04-13 03:21:25 +02:00
|
|
|
pub async fn request(
|
2024-04-13 00:44:53 +02:00
|
|
|
method: reqwest::Method,
|
|
|
|
url: &str,
|
|
|
|
payload: Option<&str>,
|
|
|
|
from: &str,
|
2024-04-13 21:22:19 +02:00
|
|
|
key: &str,
|
2024-04-13 00:44:53 +02:00
|
|
|
domain: &str,
|
2024-04-13 21:22:19 +02:00
|
|
|
) -> crate::Result<Response> {
|
2024-04-13 00:44:53 +02:00
|
|
|
let host = Context::server(url);
|
|
|
|
let date = chrono::Utc::now().format("%a, %d %b %Y %H:%M:%S GMT").to_string(); // lmao @ "GMT"
|
|
|
|
let path = url.replace("https://", "").replace("http://", "").replace(&host, "");
|
2024-04-13 21:22:19 +02:00
|
|
|
|
|
|
|
let mut headers = vec!["(request-target)", "host", "date"];
|
|
|
|
let mut headers_map : BTreeMap<String, String> = [
|
|
|
|
("host".to_string(), host.clone()),
|
|
|
|
("date".to_string(), date.clone()),
|
|
|
|
].into();
|
2024-04-13 00:44:53 +02:00
|
|
|
|
2024-04-13 02:35:18 +02:00
|
|
|
let mut client = reqwest::Client::new()
|
2024-04-13 04:31:50 +02:00
|
|
|
.request(method.clone(), url)
|
2024-04-13 04:21:33 +02:00
|
|
|
.header(ACCEPT, "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"")
|
2024-04-13 02:35:18 +02:00
|
|
|
.header(CONTENT_TYPE, "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"")
|
|
|
|
.header(USER_AGENT, format!("upub+{VERSION} ({domain})"))
|
2024-04-13 02:55:10 +02:00
|
|
|
.header("Host", host.clone())
|
|
|
|
.header("Date", date.clone());
|
2024-04-13 00:44:53 +02:00
|
|
|
|
2024-04-13 04:31:50 +02:00
|
|
|
|
2024-04-13 00:44:53 +02:00
|
|
|
if let Some(payload) = payload {
|
|
|
|
let digest = format!("sha-256={}", base64::prelude::BASE64_STANDARD.encode(openssl::sha::sha256(payload.as_bytes())));
|
2024-04-13 21:22:19 +02:00
|
|
|
headers_map.insert("digest".to_string(), digest.clone());
|
|
|
|
headers.push("digest");
|
2024-04-13 00:44:53 +02:00
|
|
|
client = client
|
|
|
|
.header("Digest", digest)
|
|
|
|
.body(payload.to_string());
|
2024-03-25 21:19:02 +01:00
|
|
|
}
|
|
|
|
|
2024-04-13 21:22:19 +02:00
|
|
|
let mut signer = HttpSignature::new(
|
|
|
|
format!("{from}#main-key"), // TODO don't hardcode #main-key
|
|
|
|
"rsa-sha256".to_string(),
|
|
|
|
&headers,
|
|
|
|
);
|
|
|
|
|
|
|
|
signer
|
|
|
|
.build_manually(&method.to_string().to_lowercase(), &path, headers_map)
|
|
|
|
.sign(key)?;
|
|
|
|
|
|
|
|
let res = client
|
|
|
|
.header("Signature", signer.header())
|
|
|
|
.send()
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
Ok(res.error_for_status()?)
|
2024-04-13 00:44:53 +02:00
|
|
|
}
|
|
|
|
|
2024-04-13 01:49:04 +02:00
|
|
|
pub async fn user(&self, id: &str) -> crate::Result<model::user::Model> {
|
2024-04-13 00:44:53 +02:00
|
|
|
if let Some(x) = model::user::Entity::find_by_id(id).one(&self.db).await? {
|
|
|
|
return Ok(x); // already in db, easy
|
|
|
|
}
|
2024-03-25 21:19:02 +01:00
|
|
|
|
2024-04-13 03:21:25 +02:00
|
|
|
let user = Self::request(
|
2024-04-13 00:44:53 +02:00
|
|
|
Method::GET, id, None, &format!("https://{}", self.domain), &self.key, &self.domain,
|
2024-04-13 03:21:25 +02:00
|
|
|
).await?.json::<serde_json::Value>().await?;
|
2024-03-25 21:19:02 +01:00
|
|
|
let user_model = model::user::Model::new(&user)?;
|
|
|
|
|
|
|
|
model::user::Entity::insert(user_model.clone().into_active_model())
|
|
|
|
.exec(&self.db).await?;
|
|
|
|
|
|
|
|
Ok(user_model)
|
|
|
|
}
|
2024-04-13 00:44:53 +02:00
|
|
|
|
2024-04-13 01:49:04 +02:00
|
|
|
pub async fn activity(&self, id: &str) -> crate::Result<model::activity::Model> {
|
2024-04-13 00:44:53 +02:00
|
|
|
if let Some(x) = model::activity::Entity::find_by_id(id).one(&self.db).await? {
|
|
|
|
return Ok(x); // already in db, easy
|
|
|
|
}
|
|
|
|
|
2024-04-13 03:21:25 +02:00
|
|
|
let activity = Self::request(
|
2024-04-13 00:44:53 +02:00
|
|
|
Method::GET, id, None, &format!("https://{}", self.domain), &self.key, &self.domain,
|
2024-04-13 03:21:25 +02:00
|
|
|
).await?.json::<serde_json::Value>().await?;
|
2024-04-13 00:44:53 +02:00
|
|
|
let activity_model = model::activity::Model::new(&activity)?;
|
|
|
|
|
|
|
|
model::activity::Entity::insert(activity_model.clone().into_active_model())
|
|
|
|
.exec(&self.db).await?;
|
|
|
|
|
|
|
|
Ok(activity_model)
|
|
|
|
}
|
|
|
|
|
2024-04-13 01:49:04 +02:00
|
|
|
pub async fn object(&self, id: &str) -> crate::Result<model::object::Model> {
|
2024-04-13 00:44:53 +02:00
|
|
|
if let Some(x) = model::object::Entity::find_by_id(id).one(&self.db).await? {
|
|
|
|
return Ok(x); // already in db, easy
|
|
|
|
}
|
|
|
|
|
2024-04-13 03:21:25 +02:00
|
|
|
let object = Self::request(
|
2024-04-13 00:44:53 +02:00
|
|
|
Method::GET, id, None, &format!("https://{}", self.domain), &self.key, &self.domain,
|
2024-04-13 03:21:25 +02:00
|
|
|
).await?.json::<serde_json::Value>().await?;
|
2024-04-13 00:44:53 +02:00
|
|
|
let object_model = model::object::Model::new(&object)?;
|
|
|
|
|
|
|
|
model::object::Entity::insert(object_model.clone().into_active_model())
|
|
|
|
.exec(&self.db).await?;
|
|
|
|
|
|
|
|
Ok(object_model)
|
|
|
|
}
|
2024-03-25 21:19:02 +01:00
|
|
|
}
|
2024-04-13 22:13:36 +02:00
|
|
|
|
|
|
|
#[axum::async_trait]
|
|
|
|
pub trait Fetchable : Sync + Send {
|
|
|
|
async fn fetch(&mut self, ctx: &crate::server::Context) -> crate::Result<&mut Self>;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[axum::async_trait]
|
|
|
|
impl Fetchable for apb::Node<serde_json::Value> {
|
|
|
|
async fn fetch(&mut self, ctx: &crate::server::Context) -> crate::Result<&mut Self> {
|
|
|
|
if let apb::Node::Link(uri) = self {
|
|
|
|
let from = format!("{}{}", ctx.protocol(), ctx.base()); // TODO helper to avoid this?
|
|
|
|
let pkey = &ctx.app().private_key;
|
|
|
|
*self = Fetcher::request(Method::GET, uri.href(), None, &from, pkey, ctx.base())
|
|
|
|
.await?
|
|
|
|
.json::<serde_json::Value>()
|
|
|
|
.await?
|
|
|
|
.into();
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(self)
|
|
|
|
}
|
|
|
|
}
|