lemmy/server/src/routes/nodeinfo.rs

use crate::{
  apub::get_apub_protocol_string,
  blocking,
  db::site_view::SiteView,
  routes::DbPoolParam,
  version,
  LemmyError,
  Settings,
};
use actix_web::{body::Body, error::ErrorBadRequest, *};
use serde::{Deserialize, Serialize};
use url::Url;

pub fn config(cfg: &mut web::ServiceConfig) {
  cfg
    .route("/nodeinfo/2.0.json", web::get().to(node_info))
    .route("/.well-known/nodeinfo", web::get().to(node_info_well_known));
}

async fn node_info_well_known() -> Result<HttpResponse<Body>, LemmyError> {
  let node_info = NodeInfoWellKnown {
    links: NodeInfoWellKnownLinks {
      rel: Url::parse("http://nodeinfo.diaspora.software/ns/schema/2.0")?,
      href: Url::parse(&format!(
        "{}://{}/nodeinfo/2.0.json",
        get_apub_protocol_string(),
        Settings::get().hostname
      ))?,
    },
  };
  Ok(HttpResponse::Ok().json(node_info))
}

async fn node_info(db: DbPoolParam) -> Result<HttpResponse, Error> {
  let site_view = blocking(&db, SiteView::read)
    .await?
    .map_err(|_| ErrorBadRequest(LemmyError::from(format_err!("not_found"))))?;

  let protocols = if Settings::get().federation.enabled {
    vec!["activitypub".to_string()]
  } else {
    vec![]
  };

  let json = NodeInfo {
    version: "2.0".to_string(),
    software: NodeInfoSoftware {
      name: "lemmy".to_string(),
      version: version::VERSION.to_string(),
    },
    protocols,
    usage: NodeInfoUsage {
      users: NodeInfoUsers {
        total: site_view.number_of_users,
      },
      local_posts: site_view.number_of_posts,
      local_comments: site_view.number_of_comments,
      open_registrations: site_view.open_registration,
    },
  };

  Ok(HttpResponse::Ok().json(json))
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NodeInfoWellKnown {
  pub links: NodeInfoWellKnownLinks,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NodeInfoWellKnownLinks {
  pub rel: Url,
  pub href: Url,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NodeInfo {
  pub version: String,
  pub software: NodeInfoSoftware,
  pub protocols: Vec<String>,
  pub usage: NodeInfoUsage,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NodeInfoSoftware {
  pub name: String,
  pub version: String,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct NodeInfoUsage {
  pub users: NodeInfoUsers,
  pub local_posts: i64,
  pub local_comments: i64,
  pub open_registrations: bool,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NodeInfoUsers {
  pub total: i64,
}
Rework imports 2020-05-16 14:04:08 +00:00			`use crate::{`
			`apub::get_apub_protocol_string,`
Federation async (#848) * Asyncify more * I guess these changed * Clean PR a bit * Convert more away from failure error * config changes for testing federation * It was DNS So actix-web's client relies on TRust DNS Resolver to figure out where to send data, but TRust DNS Resolver seems to not play nice with docker, which expressed itself as not resolving the name to an IP address _the first time_ when making a request. The fix was literally to make the request again (which I limited to 3 times total, and not exceeding the request timeout in total) * Only retry for connecterror Since TRust DNS Resolver was causing ConnectError::Timeout, this change limits the retry to only this error, returning immediately for any other error * Use http sig norm 0.4.0-alpha for actix-web 3.0 support * Blocking function, retry http requests * cargo +nightly fmt * Only create one pictrs dir * Don't yarn build * cargo +nightly fmt 2020-07-01 12:54:29 +00:00			`blocking,`
Rework imports 2020-05-16 14:04:08 +00:00			`db::site_view::SiteView,`
			`routes::DbPoolParam,`
			`version,`
Federation async (#848) * Asyncify more * I guess these changed * Clean PR a bit * Convert more away from failure error * config changes for testing federation * It was DNS So actix-web's client relies on TRust DNS Resolver to figure out where to send data, but TRust DNS Resolver seems to not play nice with docker, which expressed itself as not resolving the name to an IP address _the first time_ when making a request. The fix was literally to make the request again (which I limited to 3 times total, and not exceeding the request timeout in total) * Only retry for connecterror Since TRust DNS Resolver was causing ConnectError::Timeout, this change limits the retry to only this error, returning immediately for any other error * Use http sig norm 0.4.0-alpha for actix-web 3.0 support * Blocking function, retry http requests * cargo +nightly fmt * Only create one pictrs dir * Don't yarn build * cargo +nightly fmt 2020-07-01 12:54:29 +00:00			`LemmyError,`
Rework imports 2020-05-16 14:04:08 +00:00			`Settings,`
			`};`
			`use actix_web::{body::Body, error::ErrorBadRequest, *};`
			`use serde::{Deserialize, Serialize};`
			`use url::Url;`
got it working 2019-11-15 02:08:25 +00:00
Use actix config to handle routes in seperate folders (#378) 2019-12-31 12:55:33 +00:00			`pub fn config(cfg: &mut web::ServiceConfig) {`
			`cfg`
			`.route("/nodeinfo/2.0.json", web::get().to(node_info))`
			`.route("/.well-known/nodeinfo", web::get().to(node_info_well_known));`
			`}`

Federation async (#848) * Asyncify more * I guess these changed * Clean PR a bit * Convert more away from failure error * config changes for testing federation * It was DNS So actix-web's client relies on TRust DNS Resolver to figure out where to send data, but TRust DNS Resolver seems to not play nice with docker, which expressed itself as not resolving the name to an IP address _the first time_ when making a request. The fix was literally to make the request again (which I limited to 3 times total, and not exceeding the request timeout in total) * Only retry for connecterror Since TRust DNS Resolver was causing ConnectError::Timeout, this change limits the retry to only this error, returning immediately for any other error * Use http sig norm 0.4.0-alpha for actix-web 3.0 support * Blocking function, retry http requests * cargo +nightly fmt * Only create one pictrs dir * Don't yarn build * cargo +nightly fmt 2020-07-01 12:54:29 +00:00			`async fn node_info_well_known() -> Result<HttpResponse<Body>, LemmyError> {`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`let node_info = NodeInfoWellKnown {`
			`links: NodeInfoWellKnownLinks {`
Use Url instead of String 2020-04-08 12:37:05 +00:00			`rel: Url::parse("http://nodeinfo.diaspora.software/ns/schema/2.0")?,`
			`href: Url::parse(&format!(`
Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`"{}://{}/nodeinfo/2.0.json",`
			`get_apub_protocol_string(),`
			`Settings::get().hostname`
Use Url instead of String 2020-04-08 12:37:05 +00:00			`))?,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`},`
			`};`
Use Url instead of String 2020-04-08 12:37:05 +00:00			`Ok(HttpResponse::Ok().json(node_info))`
got it working 2019-11-15 02:08:25 +00:00			`}`

Adding activity table inserts. 2020-04-27 22:17:02 +00:00			`async fn node_info(db: DbPoolParam) -> Result<HttpResponse, Error> {`
Federation async (#848) * Asyncify more * I guess these changed * Clean PR a bit * Convert more away from failure error * config changes for testing federation * It was DNS So actix-web's client relies on TRust DNS Resolver to figure out where to send data, but TRust DNS Resolver seems to not play nice with docker, which expressed itself as not resolving the name to an IP address _the first time_ when making a request. The fix was literally to make the request again (which I limited to 3 times total, and not exceeding the request timeout in total) * Only retry for connecterror Since TRust DNS Resolver was causing ConnectError::Timeout, this change limits the retry to only this error, returning immediately for any other error * Use http sig norm 0.4.0-alpha for actix-web 3.0 support * Blocking function, retry http requests * cargo +nightly fmt * Only create one pictrs dir * Don't yarn build * cargo +nightly fmt 2020-07-01 12:54:29 +00:00			`let site_view = blocking(&db, SiteView::read)`
			`.await?`
			`.map_err(\|_\| ErrorBadRequest(LemmyError::from(format_err!("not_found"))))?;`

			`let protocols = if Settings::get().federation.enabled {`
			`vec!["activitypub".to_string()]`
			`} else {`
			`vec![]`
			`};`

			`let json = NodeInfo {`
			`version: "2.0".to_string(),`
			`software: NodeInfoSoftware {`
			`name: "lemmy".to_string(),`
			`version: version::VERSION.to_string(),`
			`},`
			`protocols,`
			`usage: NodeInfoUsage {`
			`users: NodeInfoUsers {`
			`total: site_view.number_of_users,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`},`
Federation async (#848) * Asyncify more * I guess these changed * Clean PR a bit * Convert more away from failure error * config changes for testing federation * It was DNS So actix-web's client relies on TRust DNS Resolver to figure out where to send data, but TRust DNS Resolver seems to not play nice with docker, which expressed itself as not resolving the name to an IP address _the first time_ when making a request. The fix was literally to make the request again (which I limited to 3 times total, and not exceeding the request timeout in total) * Only retry for connecterror Since TRust DNS Resolver was causing ConnectError::Timeout, this change limits the retry to only this error, returning immediately for any other error * Use http sig norm 0.4.0-alpha for actix-web 3.0 support * Blocking function, retry http requests * cargo +nightly fmt * Only create one pictrs dir * Don't yarn build * cargo +nightly fmt 2020-07-01 12:54:29 +00:00			`local_posts: site_view.number_of_posts,`
			`local_comments: site_view.number_of_comments,`
			`open_registrations: site_view.open_registration,`
			`},`
			`};`

			`Ok(HttpResponse::Ok().json(json))`
got it working 2019-11-15 02:08:25 +00:00			`}`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00
Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`#[derive(Serialize, Deserialize, Debug)]`
			`pub struct NodeInfoWellKnown {`
			`pub links: NodeInfoWellKnownLinks,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`}`

Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`#[derive(Serialize, Deserialize, Debug)]`
			`pub struct NodeInfoWellKnownLinks {`
Use Url instead of String 2020-04-08 12:37:05 +00:00			`pub rel: Url,`
			`pub href: Url,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`}`

Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`#[derive(Serialize, Deserialize, Debug)]`
			`pub struct NodeInfo {`
			`pub version: String,`
			`pub software: NodeInfoSoftware,`
			`pub protocols: Vec<String>,`
			`pub usage: NodeInfoUsage,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`}`

Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`#[derive(Serialize, Deserialize, Debug)]`
			`pub struct NodeInfoSoftware {`
			`pub name: String,`
			`pub version: String,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`}`

Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`#[derive(Serialize, Deserialize, Debug)]`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`#[serde(rename_all = "camelCase")]`
Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`pub struct NodeInfoUsage {`
			`pub users: NodeInfoUsers,`
			`pub local_posts: i64,`
			`pub local_comments: i64,`
			`pub open_registrations: bool,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`}`

Read remote nodeinfo before doing anything 2020-03-18 15:08:08 +00:00			`#[derive(Serialize, Deserialize, Debug)]`
			`pub struct NodeInfoUsers {`
			`pub total: i64,`
Use actual structs for nodeinfo 2020-01-19 11:32:02 +00:00			`}`