Plume/plume-models/src/blogs.rs

831 lines
26 KiB
Rust
Raw Normal View History

use activitypub::{actor::Group, collection::OrderedCollection, Actor, CustomObject, Object};
2018-09-27 23:06:40 +02:00
use chrono::NaiveDateTime;
use diesel::{self, ExpressionMethods, QueryDsl, RunQueryDsl};
2018-05-19 09:39:59 +02:00
use openssl::{
hash::MessageDigest,
pkey::{PKey, Private},
rsa::Rsa,
sign::{Signer, Verifier},
2018-05-19 09:39:59 +02:00
};
use reqwest::{
header::{HeaderValue, ACCEPT},
Client,
};
use serde_json;
use url::Url;
2018-06-18 23:50:40 +02:00
use webfinger::*;
2018-04-24 11:21:39 +02:00
use instance::*;
use plume_common::activity_pub::{
ap_accept_header,
2018-10-20 15:03:59 +02:00
inbox::{Deletable, WithInbox},
sign, ActivityStream, ApSignature, Id, IntoId, PublicKey,
2018-05-19 09:39:59 +02:00
};
2018-10-20 15:03:59 +02:00
use posts::Post;
use safe_string::SafeString;
2018-04-24 11:21:39 +02:00
use schema::blogs;
2018-10-20 15:03:59 +02:00
use users::User;
use {Connection, BASE_URL, USE_HTTPS};
2018-04-24 11:21:39 +02:00
pub type CustomGroup = CustomObject<ApSignature, Group>;
2018-04-23 12:29:27 +02:00
2018-05-18 10:04:40 +02:00
#[derive(Queryable, Identifiable, Serialize, Deserialize, Clone)]
2018-04-23 12:29:27 +02:00
pub struct Blog {
pub id: i32,
pub actor_id: String,
pub title: String,
pub summary: String,
pub outbox_url: String,
pub inbox_url: String,
2018-04-30 19:46:27 +02:00
pub instance_id: i32,
2018-09-27 23:06:40 +02:00
pub creation_date: NaiveDateTime,
pub ap_url: String,
pub private_key: Option<String>,
pub public_key: String,
2018-04-23 12:29:27 +02:00
}
#[derive(Insertable)]
#[table_name = "blogs"]
pub struct NewBlog {
pub actor_id: String,
pub title: String,
pub summary: String,
pub outbox_url: String,
pub inbox_url: String,
2018-05-01 20:02:29 +02:00
pub instance_id: i32,
pub ap_url: String,
pub private_key: Option<String>,
pub public_key: String,
2018-04-23 12:29:27 +02:00
}
const BLOG_PREFIX: &str = "~";
2018-04-23 12:29:27 +02:00
impl Blog {
insert!(blogs, NewBlog);
get!(blogs);
find_by!(blogs, find_by_ap_url, ap_url as &str);
find_by!(blogs, find_by_name, actor_id as &str, instance_id as i32);
2018-04-23 12:29:27 +02:00
pub fn get_instance(&self, conn: &Connection) -> Instance {
Instance::get(conn, self.instance_id).expect("Blog::get_instance: instance not found error")
}
pub fn list_authors(&self, conn: &Connection) -> Vec<User> {
use schema::blog_authors;
use schema::users;
let authors_ids = blog_authors::table
.filter(blog_authors::blog_id.eq(self.id))
.select(blog_authors::author_id);
users::table
.filter(users::id.eq_any(authors_ids))
.load::<User>(conn)
.expect("Blog::list_authors: author loading error")
}
pub fn find_for_author(conn: &Connection, author: &User) -> Vec<Blog> {
2018-06-10 19:55:08 +02:00
use schema::blog_authors;
let author_ids = blog_authors::table
.filter(blog_authors::author_id.eq(author.id))
.select(blog_authors::blog_id);
blogs::table
.filter(blogs::id.eq_any(author_ids))
2018-06-10 19:55:08 +02:00
.load::<Blog>(conn)
.expect("Blog::find_for_author: blog loading error")
2018-06-10 19:55:08 +02:00
}
pub fn find_local(conn: &Connection, name: &str) -> Option<Blog> {
Blog::find_by_name(conn, name, Instance::local_id(conn))
}
pub fn find_by_fqn(conn: &Connection, fqn: &str) -> Option<Blog> {
if fqn.contains('@') {
// remote blog
match Instance::find_by_domain(
conn,
fqn.split('@')
.last()
.expect("Blog::find_by_fqn: unreachable"),
) {
Some(instance) => match Blog::find_by_name(
conn,
fqn.split('@')
.nth(0)
.expect("Blog::find_by_fqn: unreachable"),
instance.id,
) {
Some(u) => Some(u),
None => Blog::fetch_from_webfinger(conn, fqn),
},
None => Blog::fetch_from_webfinger(conn, fqn),
}
} else {
// local blog
Blog::find_local(conn, fqn)
}
}
fn fetch_from_webfinger(conn: &Connection, acct: &str) -> Option<Blog> {
match resolve(acct.to_owned(), *USE_HTTPS) {
Ok(wf) => wf
.links
.into_iter()
.find(|l| l.mime_type == Some(String::from("application/activity+json")))
.and_then(|l| {
Blog::fetch_from_url(
conn,
&l.href
.expect("Blog::fetch_from_webfinger: href not found error"),
)
}),
Err(details) => {
2018-06-18 23:50:40 +02:00
println!("{:?}", details);
None
}
}
}
fn fetch_from_url(conn: &Connection, url: &str) -> Option<Blog> {
let req = Client::new()
.get(url)
.header(
ACCEPT,
HeaderValue::from_str(
&ap_accept_header()
.into_iter()
.collect::<Vec<_>>()
.join(", "),
).expect("Blog::fetch_from_url: accept_header generation error"),
)
.send();
match req {
Ok(mut res) => {
let text = &res
.text()
.expect("Blog::fetch_from_url: body reading error");
let ap_sign: ApSignature =
serde_json::from_str(text).expect("Blog::fetch_from_url: body parsing error");
let mut json: CustomGroup =
serde_json::from_str(text).expect("Blog::fetch_from_url: body parsing error");
json.custom_props = ap_sign; // without this workaround, publicKey is not correctly deserialized
Some(Blog::from_activity(
conn,
&json,
Url::parse(url)
.expect("Blog::fetch_from_url: url parsing error")
.host_str()
.expect("Blog::fetch_from_url: host extraction error"),
))
}
Err(_) => None,
}
}
fn from_activity(conn: &Connection, acct: &CustomGroup, inst: &str) -> Blog {
let instance = match Instance::find_by_domain(conn, inst) {
Some(instance) => instance,
None => {
Instance::insert(
conn,
NewInstance {
public_domain: inst.to_owned(),
name: inst.to_owned(),
local: false,
// We don't really care about all the following for remote instances
long_description: SafeString::new(""),
short_description: SafeString::new(""),
default_license: String::new(),
open_registrations: true,
short_description_html: String::new(),
long_description_html: String::new(),
},
)
}
};
Blog::insert(
conn,
NewBlog {
actor_id: acct
.object
.ap_actor_props
.preferred_username_string()
.expect("Blog::from_activity: preferredUsername error"),
title: acct
.object
.object_props
.name_string()
.expect("Blog::from_activity: name error"),
outbox_url: acct
.object
.ap_actor_props
.outbox_string()
.expect("Blog::from_activity: outbox error"),
inbox_url: acct
.object
.ap_actor_props
.inbox_string()
.expect("Blog::from_activity: inbox error"),
summary: acct
.object
.object_props
.summary_string()
.expect("Blog::from_activity: summary error"),
instance_id: instance.id,
ap_url: acct
.object
.object_props
.id_string()
.expect("Blog::from_activity: id error"),
public_key: acct
.custom_props
.public_key_publickey()
.expect("Blog::from_activity: publicKey error")
.public_key_pem_string()
.expect("Blog::from_activity: publicKey.publicKeyPem error"),
private_key: None,
},
)
}
pub fn to_activity(&self, _conn: &Connection) -> CustomGroup {
2018-06-21 23:07:04 +02:00
let mut blog = Group::default();
blog.ap_actor_props
.set_preferred_username_string(self.actor_id.clone())
.expect("Blog::to_activity: preferredUsername error");
blog.object_props
.set_name_string(self.title.clone())
.expect("Blog::to_activity: name error");
blog.ap_actor_props
.set_outbox_string(self.outbox_url.clone())
.expect("Blog::to_activity: outbox error");
blog.ap_actor_props
.set_inbox_string(self.inbox_url.clone())
.expect("Blog::to_activity: inbox error");
blog.object_props
.set_summary_string(self.summary.clone())
.expect("Blog::to_activity: summary error");
blog.object_props
.set_id_string(self.ap_url.clone())
.expect("Blog::to_activity: id error");
2018-06-21 23:07:04 +02:00
let mut public_key = PublicKey::default();
public_key
.set_id_string(format!("{}#main-key", self.ap_url))
.expect("Blog::to_activity: publicKey.id error");
public_key
.set_owner_string(self.ap_url.clone())
.expect("Blog::to_activity: publicKey.owner error");
public_key
.set_public_key_pem_string(self.public_key.clone())
.expect("Blog::to_activity: publicKey.publicKeyPem error");
2018-06-21 23:07:04 +02:00
let mut ap_signature = ApSignature::default();
ap_signature
.set_public_key_publickey(public_key)
.expect("Blog::to_activity: publicKey error");
2018-06-21 23:07:04 +02:00
CustomGroup::new(blog, ap_signature)
}
pub fn update_boxes(&self, conn: &Connection) {
let instance = self.get_instance(conn);
if self.outbox_url.is_empty() {
diesel::update(self)
.set(blogs::outbox_url.eq(instance.compute_box(
BLOG_PREFIX,
&self.actor_id,
"outbox",
)))
.execute(conn)
.expect("Blog::update_boxes: outbox update error");
}
if self.inbox_url.is_empty() {
diesel::update(self)
.set(blogs::inbox_url.eq(instance.compute_box(
BLOG_PREFIX,
&self.actor_id,
"inbox",
)))
.execute(conn)
.expect("Blog::update_boxes: inbox update error");
}
2018-05-01 20:02:29 +02:00
if self.ap_url.is_empty() {
2018-05-01 20:02:29 +02:00
diesel::update(self)
.set(blogs::ap_url.eq(instance.compute_box(BLOG_PREFIX, &self.actor_id, "")))
.execute(conn)
.expect("Blog::update_boxes: ap_url update error");
2018-05-01 20:02:29 +02:00
}
}
2018-04-29 19:49:56 +02:00
pub fn outbox(&self, conn: &Connection) -> ActivityStream<OrderedCollection> {
2018-05-16 20:20:44 +02:00
let mut coll = OrderedCollection::default();
coll.collection_props.items = serde_json::to_value(self.get_activities(conn))
.expect("Blog::outbox: activity serialization error");
coll.collection_props
.set_total_items_u64(self.get_activities(conn).len() as u64)
.expect("Blog::outbox: count serialization error");
2018-05-16 20:20:44 +02:00
ActivityStream::new(coll)
2018-04-29 19:49:56 +02:00
}
fn get_activities(&self, _conn: &Connection) -> Vec<serde_json::Value> {
2018-04-29 19:49:56 +02:00
vec![]
}
pub fn get_keypair(&self) -> PKey<Private> {
PKey::from_rsa(
Rsa::private_key_from_pem(
self.private_key
.clone()
.expect("Blog::get_keypair: private key not found error")
.as_ref(),
).expect("Blog::get_keypair: pem parsing error"),
).expect("Blog::get_keypair: private key deserialization error")
}
2018-06-18 23:50:40 +02:00
pub fn webfinger(&self, conn: &Connection) -> Webfinger {
2018-06-18 23:50:40 +02:00
Webfinger {
subject: format!(
"acct:{}@{}",
self.actor_id,
self.get_instance(conn).public_domain
),
aliases: vec![self.ap_url.clone()],
2018-06-18 23:50:40 +02:00
links: vec![
Link {
rel: String::from("http://webfinger.net/rel/profile-page"),
mime_type: None,
href: Some(self.ap_url.clone()),
template: None,
2018-06-18 23:50:40 +02:00
},
Link {
rel: String::from("http://schemas.google.com/g/2010#updates-from"),
mime_type: Some(String::from("application/atom+xml")),
href: Some(self.get_instance(conn).compute_box(
BLOG_PREFIX,
&self.actor_id,
"feed.atom",
)),
template: None,
2018-06-18 23:50:40 +02:00
},
Link {
rel: String::from("self"),
mime_type: Some(String::from("application/activity+json")),
href: Some(self.ap_url.clone()),
template: None,
},
],
2018-06-18 23:50:40 +02:00
}
}
pub fn from_url(conn: &Connection, url: &str) -> Option<Blog> {
Blog::find_by_ap_url(conn, url).or_else(|| {
// The requested blog was not in the DB
2018-06-21 23:07:04 +02:00
// We try to fetch it if it is remote
if Url::parse(url)
.expect("Blog::from_url: ap_url parsing error")
.host_str()
.expect("Blog::from_url: host extraction error") != BASE_URL.as_str()
{
Blog::fetch_from_url(conn, url)
2018-06-21 23:07:04 +02:00
} else {
None
}
})
}
pub fn get_fqn(&self, conn: &Connection) -> String {
if self.instance_id == Instance::local_id(conn) {
self.actor_id.clone()
} else {
format!(
"{}@{}",
self.actor_id,
self.get_instance(conn).public_domain
)
}
}
pub fn to_json(&self, conn: &Connection) -> serde_json::Value {
let mut json = serde_json::to_value(self).expect("Blog::to_json: serialization error");
json["fqn"] = json!(self.get_fqn(conn));
json
}
2018-10-20 15:03:59 +02:00
pub fn delete(&self, conn: &Connection) {
for post in Post::get_for_blog(conn, &self) {
post.delete(conn);
2018-10-20 15:03:59 +02:00
}
diesel::delete(self)
.execute(conn)
.expect("Blog::delete: blog deletion error");
2018-10-20 15:03:59 +02:00
}
2018-04-23 12:29:27 +02:00
}
2018-05-19 00:04:30 +02:00
impl IntoId for Blog {
fn into_id(self) -> Id {
2018-05-18 10:04:40 +02:00
Id::new(self.ap_url)
}
}
impl Object for Blog {}
impl Actor for Blog {}
impl WithInbox for Blog {
fn get_inbox_url(&self) -> String {
self.inbox_url.clone()
}
fn get_shared_inbox_url(&self) -> Option<String> {
None
}
fn is_local(&self) -> bool {
self.instance_id == 0
}
2018-05-18 10:04:40 +02:00
}
impl sign::Signer for Blog {
fn get_key_id(&self) -> String {
format!("{}#main-key", self.ap_url)
}
fn sign(&self, to_sign: &str) -> Vec<u8> {
let key = self.get_keypair();
let mut signer =
Signer::new(MessageDigest::sha256(), &key).expect("Blog::sign: initialization error");
signer
.update(to_sign.as_bytes())
.expect("Blog::sign: content insertion error");
signer
.sign_to_vec()
.expect("Blog::sign: finalization error")
}
fn verify(&self, data: &str, signature: &[u8]) -> bool {
let key = PKey::from_rsa(
Rsa::public_key_from_pem(self.public_key.as_ref())
.expect("Blog::verify: pem parsing error"),
).expect("Blog::verify: deserialization error");
let mut verifier = Verifier::new(MessageDigest::sha256(), &key)
.expect("Blog::verify: initialization error");
verifier
.update(data.as_bytes())
.expect("Blog::verify: content insertion error");
verifier
.verify(&signature)
.expect("Blog::verify: finalization error")
}
}
impl NewBlog {
pub fn new_local(
actor_id: String,
title: String,
summary: String,
instance_id: i32,
) -> NewBlog {
let (pub_key, priv_key) = sign::gen_keypair();
NewBlog {
actor_id,
title,
summary,
outbox_url: String::from(""),
inbox_url: String::from(""),
instance_id,
ap_url: String::from(""),
public_key: String::from_utf8(pub_key).expect("NewBlog::new_local: public key error"),
private_key: Some(
String::from_utf8(priv_key).expect("NewBlog::new_local: private key error"),
),
}
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
use blog_authors::*;
use diesel::Connection;
use instance::tests as instance_tests;
use tests::db;
use users::tests as usersTests;
use Connection as Conn;
pub(crate) fn fill_database(conn: &Conn) -> Vec<Blog> {
instance_tests::fill_database(conn);
let users = usersTests::fill_database(conn);
let blogs = vec![
NewBlog::new_local(
"BlogName".to_owned(),
"Blog name".to_owned(),
"This is a small blog".to_owned(),
Instance::local_id(conn),
),
NewBlog::new_local(
"MyBlog".to_owned(),
"My blog".to_owned(),
"Welcome to my blog".to_owned(),
Instance::local_id(conn),
),
NewBlog::new_local(
"WhyILikePlume".to_owned(),
"Why I like Plume".to_owned(),
"In this blog I will explay you why I like Plume so much".to_owned(),
Instance::local_id(conn),
),
].into_iter()
.map(|nb| Blog::insert(conn, nb))
.collect::<Vec<_>>();
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blogs[0].id,
author_id: users[0].id,
is_owner: true,
},
);
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blogs[0].id,
author_id: users[1].id,
is_owner: false,
},
);
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blogs[1].id,
author_id: users[1].id,
is_owner: true,
},
);
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blogs[2].id,
author_id: users[2].id,
is_owner: true,
},
);
blogs
}
#[test]
fn get_instance() {
let conn = &db();
conn.test_transaction::<_, (), _>(|| {
fill_database(conn);
let blog = Blog::insert(
conn,
NewBlog::new_local(
"SomeName".to_owned(),
"Some name".to_owned(),
"This is some blog".to_owned(),
Instance::local_id(conn),
),
);
assert_eq!(blog.get_instance(conn).id, Instance::local_id(conn));
// TODO add tests for remote instance
Ok(())
});
}
#[test]
fn authors() {
let conn = &db();
conn.test_transaction::<_, (), _>(|| {
let user = usersTests::fill_database(conn);
fill_database(conn);
let blog = vec![
Blog::insert(
conn,
NewBlog::new_local(
"SomeName".to_owned(),
"Some name".to_owned(),
"This is some blog".to_owned(),
Instance::local_id(conn),
),
),
Blog::insert(
conn,
NewBlog::new_local(
"Blog".to_owned(),
"Blog".to_owned(),
"I've named my blog Blog".to_owned(),
Instance::local_id(conn),
),
),
];
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blog[0].id,
author_id: user[0].id,
is_owner: true,
},
);
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blog[0].id,
author_id: user[1].id,
is_owner: false,
},
);
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blog[1].id,
author_id: user[0].id,
is_owner: true,
},
);
assert!(
blog[0]
.list_authors(conn)
.iter()
.any(|a| a.id == user[0].id)
);
assert!(
blog[0]
.list_authors(conn)
.iter()
.any(|a| a.id == user[1].id)
);
assert!(
blog[1]
.list_authors(conn)
.iter()
.any(|a| a.id == user[0].id)
);
assert!(
!blog[1]
.list_authors(conn)
.iter()
.any(|a| a.id == user[1].id)
);
assert!(
Blog::find_for_author(conn, &user[0])
.iter()
.any(|b| b.id == blog[0].id)
);
assert!(
Blog::find_for_author(conn, &user[1])
.iter()
.any(|b| b.id == blog[0].id)
);
assert!(
Blog::find_for_author(conn, &user[0])
.iter()
.any(|b| b.id == blog[1].id)
);
assert!(
!Blog::find_for_author(conn, &user[1])
.iter()
.any(|b| b.id == blog[1].id)
);
Ok(())
});
}
#[test]
fn find_local() {
let conn = &db();
conn.test_transaction::<_, (), _>(|| {
fill_database(conn);
let blog = Blog::insert(
conn,
NewBlog::new_local(
"SomeName".to_owned(),
"Some name".to_owned(),
"This is some blog".to_owned(),
Instance::local_id(conn),
),
);
assert_eq!(
Blog::find_local(conn, "SomeName").unwrap().id,
blog.id
);
Ok(())
});
}
#[test]
fn get_fqn() {
let conn = &db();
conn.test_transaction::<_, (), _>(|| {
fill_database(conn);
let blog = Blog::insert(
conn,
NewBlog::new_local(
"SomeName".to_owned(),
"Some name".to_owned(),
"This is some blog".to_owned(),
Instance::local_id(conn),
),
);
assert_eq!(blog.get_fqn(conn), "SomeName");
Ok(())
});
}
#[test]
fn delete() {
let conn = &db();
conn.test_transaction::<_, (), _>(|| {
let blogs = fill_database(conn);
blogs[0].delete(conn);
assert!(Blog::get(conn, blogs[0].id).is_none());
Ok(())
});
}
#[test]
fn delete_via_user() {
let conn = &db();
conn.test_transaction::<_, (), _>(|| {
let user = usersTests::fill_database(conn);
fill_database(conn);
let blog = vec![
Blog::insert(
conn,
NewBlog::new_local(
"SomeName".to_owned(),
"Some name".to_owned(),
"This is some blog".to_owned(),
Instance::local_id(conn),
),
),
Blog::insert(
conn,
NewBlog::new_local(
"Blog".to_owned(),
"Blog".to_owned(),
"I've named my blog Blog".to_owned(),
Instance::local_id(conn),
),
),
];
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blog[0].id,
author_id: user[0].id,
is_owner: true,
},
);
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blog[0].id,
author_id: user[1].id,
is_owner: false,
},
);
BlogAuthor::insert(
conn,
NewBlogAuthor {
blog_id: blog[1].id,
author_id: user[0].id,
is_owner: true,
},
);
user[0].delete(conn);
assert!(Blog::get(conn, blog[0].id).is_some());
assert!(Blog::get(conn, blog[1].id).is_none());
user[1].delete(conn);
assert!(Blog::get(conn, blog[0].id).is_none());
Ok(())
});
}
}