lemmy/server/src/apub/puller.rs

231 lines
7.4 KiB
Rust
Raw Normal View History

extern crate reqwest;
use crate::api::community::{GetCommunityResponse, ListCommunitiesResponse};
2020-03-14 00:05:42 +00:00
use crate::api::post::GetPostsResponse;
2020-03-18 21:09:00 +00:00
use crate::apub::get_apub_protocol_string;
use crate::db::community_view::CommunityView;
use crate::db::post_view::PostView;
use crate::naive_now;
use crate::routes::nodeinfo::{NodeInfo, NodeInfoWellKnown};
use crate::settings::Settings;
2020-03-19 01:16:17 +00:00
use activitystreams::actor::{properties::ApActorProperties, Group};
use activitystreams::collection::{OrderedCollection, UnorderedCollection};
use activitystreams::ext::Ext;
use activitystreams::object::ObjectBox;
2020-03-19 01:16:17 +00:00
use activitystreams::object::Page;
use failure::Error;
use log::warn;
use serde::Deserialize;
fn fetch_node_info(domain: &str) -> Result<NodeInfo, Error> {
2020-03-18 21:09:00 +00:00
let well_known_uri = format!(
"{}://{}/.well-known/nodeinfo",
get_apub_protocol_string(),
domain
);
let well_known = fetch_remote_object::<NodeInfoWellKnown>(&well_known_uri)?;
Ok(fetch_remote_object::<NodeInfo>(&well_known.links.href)?)
}
2020-03-18 21:09:00 +00:00
fn fetch_communities_from_instance(domain: &str) -> Result<Vec<CommunityView>, Error> {
let node_info = fetch_node_info(domain)?;
if node_info.software.name != "lemmy" {
return Err(format_err!(
"{} is not a Lemmy instance, federation is not supported",
domain
));
}
// TODO: follow pagination (seems like page count is missing?)
// TODO: see if there is any standard for discovering remote actors, so we dont have to rely on lemmy apis
let communities_uri = format!(
"http://{}/api/v1/communities/list?sort=Hot&local_only=true",
domain
);
let communities1 = fetch_remote_object::<ListCommunitiesResponse>(&communities_uri)?;
2020-01-14 15:26:19 +00:00
let mut communities2 = communities1.communities;
for c in &mut communities2 {
c.name = format_community_name(&c.name, domain);
}
Ok(communities2)
}
fn get_remote_community_uri(identifier: &str) -> String {
2020-03-14 00:05:42 +00:00
let x: Vec<&str> = identifier.split('@').collect();
let name = x[0].replace("!", "");
let instance = x[1];
format!("http://{}/federation/c/{}", instance, name)
}
fn fetch_remote_object<Response>(uri: &str) -> Result<Response, Error>
where
Response: for<'de> Deserialize<'de>,
{
2020-03-18 21:09:00 +00:00
if Settings::get().federation.tls_enabled && !uri.starts_with("https") {
return Err(format_err!("Activitypub uri is insecure: {}", uri));
}
// TODO: should cache responses here when we are in production
// TODO: this function should return a future
let x: Response = reqwest::get(uri)?.json()?;
Ok(x)
}
pub fn get_remote_community_posts(identifier: &str) -> Result<GetPostsResponse, Error> {
2020-03-19 01:16:17 +00:00
let community =
fetch_remote_object::<Ext<Group, ApActorProperties>>(&get_remote_community_uri(identifier))?;
let outbox_uri = &community.extension.get_outbox().to_string();
let outbox = fetch_remote_object::<OrderedCollection>(outbox_uri)?;
2020-03-14 00:05:42 +00:00
let items = outbox.collection_props.get_many_items_object_boxs();
let posts: Vec<PostView> = items
.unwrap()
.map(|obox: &ObjectBox| {
let page: Page = obox.clone().to_concrete::<Page>().unwrap();
PostView {
id: -1,
name: page.object_props.get_name_xsd_string().unwrap().to_string(),
2020-03-19 16:27:13 +00:00
url: page
.object_props
.get_url_xsd_any_uri()
.map(|u| u.to_string()),
body: page
.object_props
.get_content_xsd_string()
.map(|c| c.to_string()),
creator_id: -1,
community_id: -1,
removed: false,
locked: false,
2020-03-19 16:27:13 +00:00
published: page
.object_props
.get_published()
.unwrap()
.as_ref()
.naive_local()
.to_owned(),
updated: page
.object_props
.get_updated()
.map(|u| u.as_ref().to_owned().naive_local()),
deleted: false,
nsfw: false,
stickied: false,
embed_title: None,
embed_description: None,
embed_html: None,
thumbnail_url: None,
banned: false,
banned_from_community: false,
creator_name: "".to_string(),
creator_avatar: None,
community_name: "".to_string(),
community_removed: false,
community_deleted: false,
community_nsfw: false,
number_of_comments: -1,
score: -1,
upvotes: -1,
downvotes: -1,
hot_rank: -1,
newest_activity_time: naive_now(),
user_id: None,
my_vote: None,
subscribed: None,
read: None,
saved: None,
}
})
.collect();
Ok(GetPostsResponse { posts })
}
pub fn get_remote_community(identifier: &str) -> Result<GetCommunityResponse, failure::Error> {
2020-03-19 01:16:17 +00:00
let community =
fetch_remote_object::<Ext<Group, ApActorProperties>>(&get_remote_community_uri(identifier))?;
let followers_uri = &community.extension.get_followers().unwrap().to_string();
let outbox_uri = &community.extension.get_outbox().to_string();
let outbox = fetch_remote_object::<OrderedCollection>(outbox_uri)?;
let followers = fetch_remote_object::<UnorderedCollection>(followers_uri)?;
// TODO: this is only for testing until we can call that function from GetPosts
// (once string ids are supported)
//dbg!(get_remote_community_posts(identifier)?);
Ok(GetCommunityResponse {
moderators: vec![],
admins: vec![],
community: CommunityView {
2020-02-29 02:11:39 +00:00
// TODO: we need to merge id and name into a single thing (stuff like @user@instance.com)
2020-03-14 00:05:42 +00:00
id: 1337, //community.object_props.get_id()
name: identifier.to_string(),
title: community
2020-03-19 01:16:17 +00:00
.as_ref()
.get_name_xsd_string()
.unwrap()
.to_string(),
description: community
2020-03-19 01:16:17 +00:00
.as_ref()
.get_summary_xsd_string()
.map(|s| s.to_string()),
category_id: -1,
creator_id: -1, //community.object_props.get_attributed_to_xsd_any_uri()
removed: false,
published: community
2020-03-19 01:16:17 +00:00
.as_ref()
.get_published()
.unwrap()
.as_ref()
.naive_local()
.to_owned(),
updated: community
2020-03-19 01:16:17 +00:00
.as_ref()
.get_updated()
.map(|u| u.as_ref().to_owned().naive_local()),
deleted: false,
nsfw: false,
creator_name: "".to_string(),
2020-01-02 18:22:23 +00:00
creator_avatar: None,
category_name: "".to_string(),
number_of_subscribers: *followers
.collection_props
.get_total_items()
.unwrap()
.as_ref() as i64, // TODO: need to use the same type
2020-03-14 00:05:42 +00:00
number_of_posts: *outbox.collection_props.get_total_items().unwrap().as_ref() as i64,
number_of_comments: -1,
hot_rank: -1,
user_id: None,
2020-03-11 11:29:10 +00:00
subscribed: None,
},
2020-02-05 17:51:03 +00:00
online: 0,
})
}
2020-03-18 21:09:00 +00:00
pub fn get_following_instances() -> Vec<&'static str> {
Settings::get()
.federation
.followed_instances
.split(',')
.collect()
}
pub fn get_all_communities() -> Result<Vec<CommunityView>, Error> {
let mut communities_list: Vec<CommunityView> = vec![];
for instance in &get_following_instances() {
match fetch_communities_from_instance(instance) {
Ok(mut c) => communities_list.append(c.as_mut()),
Err(e) => warn!("Failed to fetch instance list from remote instance: {}", e),
};
}
Ok(communities_list)
}
2020-03-19 16:27:13 +00:00
/// If community is on local instance, don't include the @instance part. This is only for displaying
/// to the user and should never be used otherwise.
pub fn format_community_name(name: &str, instance: &str) -> String {
if instance == Settings::get().hostname {
format!("!{}", name)
} else {
format!("!{}@{}", name, instance)
}
}