nutomic
/
ibis
mirror of https://github.com/Nutomic/ibis.git
1
0
Fork 0
Code Packages Projects Releases Activity

Merge branch 'add-diesel'

This commit is contained in:
Felix Ableitner 2023-12-05 12:08:46 +01:00
parent 4371fc2edc 5d2099c17c
commit 132d9c8389
37 changed files with 1698 additions and 942 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
Cargo.lock generated
View File

@ -5,7 +5,7 @@ version = 3
[[package]] [[package]]
name = "activitypub_federation" name = "activitypub_federation"
version = "0.5.0-beta.5" version = "0.5.0-beta.5"
source = "git+https://github.com/LemmyNet/activitypub-federation-rust.git?branch=parse-impl#2aa64ad1de7943840677f4b96a20a11d38e2be56" source = "git+https://github.com/LemmyNet/activitypub-federation-rust.git?branch=diesel-feature#9ffdadfc8df6719542861466234a7dac2f9707c9"
dependencies = [ dependencies = [
"activitystreams-kinds", "activitystreams-kinds",
"async-trait", "async-trait",
@ -14,6 +14,7 @@ dependencies = [
"bytes", "bytes",
"chrono", "chrono",
"derive_builder", "derive_builder",
"diesel",
"dyn-clone", "dyn-clone",
"enum_delegate", "enum_delegate",
"futures", "futures",
@ -264,6 +265,12 @@ version = "0.6.7"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1e5f035d16fc623ae5f74981db80a439803888314e3a555fd6f04acd51a3205" checksum = "e1e5f035d16fc623ae5f74981db80a439803888314e3a555fd6f04acd51a3205"
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
[[package]] [[package]]
name = "bytes" name = "bytes"
version = "1.5.0" version = "1.5.0"
@ -442,19 +449,6 @@ dependencies = [
"syn 1.0.109", "syn 1.0.109",
] ]
[[package]]
name = "dashmap"
version = "5.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
dependencies = [
"cfg-if",
"hashbrown 0.14.2",
"lock_api",
"once_cell",
"parking_lot_core",
]
[[package]] [[package]]
name = "derive_builder" name = "derive_builder"
version = "0.12.0" version = "0.12.0"
@ -486,6 +480,70 @@ dependencies = [
"syn 1.0.109", "syn 1.0.109",
] ]
[[package]]
name = "diesel"
version = "2.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62c6fcf842f17f8c78ecf7c81d75c5ce84436b41ee07e03f490fbb5f5a8731d8"
dependencies = [
"bitflags 2.4.1",
"byteorder",
"chrono",
"diesel_derives",
"itoa",
"pq-sys",
"uuid",
]
[[package]]
name = "diesel-derive-newtype"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c7267437d5b12df60ae29bd97f8d120f1c3a6272d6f213551afa56bbb2ecfbb7"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.39",
]
[[package]]
name = "diesel_derives"
version = "2.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef8337737574f55a468005a83499da720f20c65586241ffea339db9ecdfd2b44"
dependencies = [
"diesel_table_macro_syntax",
"proc-macro2",
"quote",
"syn 2.0.39",
]
[[package]]
name = "diesel_migrations"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6036b3f0120c5961381b570ee20a02432d7e2d27ea60de9578799cf9156914ac"
dependencies = [
"diesel",
"migrations_internals",
"migrations_macros",
]
[[package]]
name = "diesel_table_macro_syntax"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc5557efc453706fed5e4fa85006fe9817c224c3f480a34c7e5959fd700921c5"
dependencies = [
"syn 2.0.39",
]
[[package]]
name = "diff"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
[[package]] [[package]]
name = "diffy" name = "diffy"
version = "0.3.0" version = "0.3.0"
@ -615,20 +673,24 @@ dependencies = [
"axum", "axum",
"axum-macros", "axum-macros",
"chrono", "chrono",
"diesel",
"diesel-derive-newtype",
"diesel_migrations",
"diffy", "diffy",
"enum_delegate", "enum_delegate",
"env_logger", "env_logger",
"futures", "futures",
"hex",
"once_cell", "once_cell",
"pretty_assertions",
"rand", "rand",
"reqwest", "reqwest",
"serde", "serde",
"serde_json",
"serial_test",
"sha2", "sha2",
"tokio", "tokio",
"tracing", "tracing",
"url", "url",
"uuid",
] ]
[[package]] [[package]]
@ -865,6 +927,12 @@ version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7"
[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
[[package]] [[package]]
name = "http" name = "http"
version = "0.2.11" version = "0.2.11"
@ -1140,6 +1208,27 @@ dependencies = [
"autocfg", "autocfg",
] ]
[[package]]
name = "migrations_internals"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f23f71580015254b020e856feac3df5878c2c7a8812297edd6c0a485ac9dada"
dependencies = [
"serde",
"toml",
]
[[package]]
name = "migrations_macros"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cce3325ac70e67bbab5bd837a31cae01f1a6db64e0e744a33cb03a543469ef08"
dependencies = [
"migrations_internals",
"proc-macro2",
"quote",
]
[[package]] [[package]]
name = "mime" name = "mime"
version = "0.3.17" version = "0.3.17"
@ -1408,6 +1497,25 @@ version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
[[package]]
name = "pq-sys"
version = "0.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "31c0052426df997c0cbd30789eb44ca097e3541717a7b8fa36b1c464ee7edebd"
dependencies = [
"vcpkg",
]
[[package]]
name = "pretty_assertions"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
dependencies = [
"diff",
"yansi",
]
[[package]] [[package]]
name = "proc-macro2" name = "proc-macro2"
version = "1.0.69" version = "1.0.69"
@ -1747,6 +1855,15 @@ dependencies = [
"serde", "serde",
] ]
[[package]]
name = "serde_spanned"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80"
dependencies = [
"serde",
]
[[package]] [[package]]
name = "serde_urlencoded" name = "serde_urlencoded"
version = "0.7.1" version = "0.7.1"
@ -1759,31 +1876,6 @@ dependencies = [
"serde", "serde",
] ]
[[package]]
name = "serial_test"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e56dd856803e253c8f298af3f4d7eb0ae5e23a737252cd90bb4f3b435033b2d"
dependencies = [
"dashmap",
"futures",
"lazy_static",
"log",
"parking_lot",
"serial_test_derive",
]
[[package]]
name = "serial_test_derive"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.39",
]
[[package]] [[package]]
name = "sha1" name = "sha1"
version = "0.10.6" version = "0.10.6"
@ -2037,6 +2129,40 @@ dependencies = [
"tracing", "tracing",
] ]
[[package]]
name = "toml"
version = "0.7.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
dependencies = [
"serde",
"serde_spanned",
"toml_datetime",
"toml_edit",
]
[[package]]
name = "toml_datetime"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
dependencies = [
"serde",
]
[[package]]
name = "toml_edit"
version = "0.19.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
dependencies = [
"indexmap 2.1.0",
"serde",
"serde_spanned",
"toml_datetime",
"winnow",
]
[[package]] [[package]]
name = "tower" name = "tower"
version = "0.4.13" version = "0.4.13"
@ -2159,11 +2285,12 @@ dependencies = [
[[package]] [[package]]
name = "uuid" name = "uuid"
version = "1.5.0" version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "88ad59a7560b41a70d191093a945f0b87bc1deeda46fb237479708a1d6b6cdfc" checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560"
dependencies = [ dependencies = [
"getrandom", "getrandom",
"serde",
] ]
[[package]] [[package]]
@ -2404,6 +2531,15 @@ version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
[[package]]
name = "winnow"
version = "0.5.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "829846f3e3db426d4cee4510841b71a8e58aa2a76b1132579487ae430ccd9c7b"
dependencies = [
"memchr",
]
[[package]] [[package]]
name = "winreg" name = "winreg"
version = "0.50.0" version = "0.50.0"
@ -2413,3 +2549,9 @@ dependencies = [
"cfg-if", "cfg-if",
"windows-sys", "windows-sys",
] ]
[[package]]
name = "yansi"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"

10
Cargo.toml
View File

@ -4,25 +4,29 @@ version = "0.1.0"
edition = "2021" edition = "2021"
[dependencies] [dependencies]
activitypub_federation = { git = "https://github.com/LemmyNet/activitypub-federation-rust.git", branch = "parse-impl", features = ["axum"], default-features = false } activitypub_federation = { git = "https://github.com/LemmyNet/activitypub-federation-rust.git", branch = "diesel-feature", features = ["axum", "diesel"], default-features = false }
anyhow = "1.0.75" anyhow = "1.0.75"
async-trait = "0.1.74" async-trait = "0.1.74"
axum = "0.6.20" axum = "0.6.20"
axum-macros = "0.3.8" axum-macros = "0.3.8"
chrono = { version = "0.4.31", features = ["serde"] } chrono = { version = "0.4.31", features = ["serde"] }
diesel = {version = "2.1.4", features = ["postgres", "chrono", "uuid"] }
diesel-derive-newtype = "2.1.0"
diesel_migrations = "2.1.0"
diffy = "0.3.0" diffy = "0.3.0"
enum_delegate = "0.2.0" enum_delegate = "0.2.0"
env_logger = { version = "0.10.1", default-features = false } env_logger = { version = "0.10.1", default-features = false }
futures = "0.3.29" futures = "0.3.29"
hex = "0.4.3"
rand = "0.8.5" rand = "0.8.5"
serde = "1.0.192" serde = "1.0.192"
serde_json = "1.0.108"
sha2 = "0.10.8" sha2 = "0.10.8"
tokio = { version = "1.34.0", features = ["full"] } tokio = { version = "1.34.0", features = ["full"] }
tracing = "0.1.40" tracing = "0.1.40"
url = "2.4.1" url = "2.4.1"
uuid = { version = "1.6.1", features = ["serde"] }
[dev-dependencies] [dev-dependencies]
once_cell = "1.18.0" once_cell = "1.18.0"
pretty_assertions = "1.4.0"
reqwest = "0.11.22" reqwest = "0.11.22"
serial_test = "2.0.0"

9
diesel.toml Normal file
View File

@ -0,0 +1,9 @@
# For documentation on how to configure this file,
# see https://diesel.rs/guides/configuring-diesel-cli
[print_schema]
file = "src/database/schema.rs"
custom_type_derives = ["diesel::query_builder::QueryId"]
[migrations_directory]
dir = "migrations"

6
migrations/00000000000000_diesel_initial_setup/down.sql Normal file
View File

@ -0,0 +1,6 @@
-- This file was automatically created by Diesel to setup helper functions
-- and other internal bookkeeping. This file is safe to edit, any future
-- changes will be added to existing projects as new migrations.
DROP FUNCTION IF EXISTS diesel_manage_updated_at(_tbl regclass);
DROP FUNCTION IF EXISTS diesel_set_updated_at();

36
migrations/00000000000000_diesel_initial_setup/up.sql Normal file
View File

@ -0,0 +1,36 @@
-- This file was automatically created by Diesel to setup helper functions
-- and other internal bookkeeping. This file is safe to edit, any future
-- changes will be added to existing projects as new migrations.
-- Sets up a trigger for the given table to automatically set a column called
-- `updated_at` whenever the row is modified (unless `updated_at` was included
-- in the modified columns)
--
-- # Example
--
-- ```sql
-- CREATE TABLE users (id SERIAL PRIMARY KEY, updated_at TIMESTAMP NOT NULL DEFAULT NOW());
--
-- SELECT diesel_manage_updated_at('users');
-- ```
CREATE OR REPLACE FUNCTION diesel_manage_updated_at(_tbl regclass) RETURNS VOID AS $$
BEGIN
EXECUTE format('CREATE TRIGGER set_updated_at BEFORE UPDATE ON %s
FOR EACH ROW EXECUTE PROCEDURE diesel_set_updated_at()', _tbl);
END;
$$ LANGUAGE plpgsql;
CREATE OR REPLACE FUNCTION diesel_set_updated_at() RETURNS trigger AS $$
BEGIN
IF (
NEW IS DISTINCT FROM OLD AND
NEW.updated_at IS NOT DISTINCT FROM OLD.updated_at
) THEN
NEW.updated_at := current_timestamp;
END IF;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;

5
migrations/2023-11-28-150402_article/down.sql Normal file
View File

@ -0,0 +1,5 @@
drop table conflict;
drop table edit;
drop table article;
drop table instance_follow;
drop table instance;

43
migrations/2023-11-28-150402_article/up.sql Normal file
View File

@ -0,0 +1,43 @@
create table instance (
id serial primary key,
ap_id varchar(255) not null unique,
inbox_url text not null,
articles_url varchar(255) not null unique,
public_key text not null,
private_key text,
last_refreshed_at timestamptz not null default now(),
local bool not null
);
create table instance_follow (
id serial primary key,
instance_id int REFERENCES instance ON UPDATE CASCADE ON DELETE CASCADE NOT NULL,
follower_id int REFERENCES instance ON UPDATE CASCADE ON DELETE CASCADE NOT NULL,
pending boolean not null,
unique(instance_id, follower_id)
);
create table article (
id serial primary key,
title text not null,
text text not null,
ap_id varchar(255) not null unique,
instance_id int REFERENCES instance ON UPDATE CASCADE ON DELETE CASCADE NOT NULL,
local bool not null
);
create table edit (
id serial primary key,
hash uuid not null,
ap_id varchar(255) not null unique,
diff text not null,
article_id int REFERENCES article ON UPDATE CASCADE ON DELETE CASCADE NOT NULL,
previous_version_id uuid not null
);
create table conflict (
id uuid primary key,
diff text not null,
article_id int REFERENCES article ON UPDATE CASCADE ON DELETE CASCADE NOT NULL,
previous_version_id uuid not null
);

231
src/api.rs
View File

@ -1,21 +1,22 @@
use crate::database::{DatabaseHandle, DbConflict}; use crate::database::article::{ArticleView, DbArticle, DbArticleForm};
use crate::database::conflict::{ApiConflict, DbConflict, DbConflictForm};
use crate::database::edit::{DbEdit, DbEditForm};
use crate::database::instance::{DbInstance, InstanceView};
use crate::database::version::EditVersion;
use crate::database::MyDataHandle;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::activities::create_article::CreateArticle; use crate::federation::activities::create_article::CreateArticle;
use crate::federation::activities::follow::Follow;
use crate::federation::activities::submit_article_update; use crate::federation::activities::submit_article_update;
use crate::federation::objects::article::DbArticle;
use crate::federation::objects::edit::EditVersion;
use crate::federation::objects::instance::DbInstance;
use crate::utils::generate_article_version; use crate::utils::generate_article_version;
use activitypub_federation::config::Data; use activitypub_federation::config::Data;
use activitypub_federation::fetch::object_id::ObjectId; use activitypub_federation::fetch::object_id::ObjectId;
use anyhow::anyhow;
use axum::extract::Query; use axum::extract::Query;
use axum::routing::{get, post}; use axum::routing::{get, post};
use axum::{Form, Json, Router}; use axum::{Form, Json, Router};
use axum_macros::debug_handler; use axum_macros::debug_handler;
use diffy::create_patch; use diffy::create_patch;
use futures::future::try_join_all; use futures::future::try_join_all;
use rand::random;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use url::Url; use url::Url;
@ -42,65 +43,42 @@ pub struct CreateArticleData {
/// Create a new article with empty text, and federate it to followers. /// Create a new article with empty text, and federate it to followers.
#[debug_handler] #[debug_handler]
async fn create_article( async fn create_article(
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
Form(create_article): Form<CreateArticleData>, Form(create_article): Form<CreateArticleData>,
) -> MyResult<Json<DbArticle>> { ) -> MyResult<Json<ArticleView>> {
{ let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let articles = data.articles.lock().unwrap();
let title_exists = articles
.iter()
.any(|a| a.1.local && a.1.title == create_article.title);
if title_exists {
return Err(anyhow!("A local article with this title already exists").into());
}
}
let local_instance_id = data.local_instance().ap_id;
let ap_id = ObjectId::parse(&format!( let ap_id = ObjectId::parse(&format!(
"http://{}:{}/article/{}", "http://{}:{}/article/{}",
local_instance_id.inner().domain().unwrap(), local_instance.ap_id.inner().domain().unwrap(),
local_instance_id.inner().port().unwrap(), local_instance.ap_id.inner().port().unwrap(),
create_article.title create_article.title
))?; ))?;
let article = DbArticle { let form = DbArticleForm {
title: create_article.title, title: create_article.title,
text: String::new(), text: String::new(),
ap_id, ap_id,
latest_version: EditVersion::default(), instance_id: local_instance.id,
edits: vec![],
instance: local_instance_id,
local: true, local: true,
}; };
{ let article = DbArticle::create(&form, &data.db_connection)?;
let mut articles = data.articles.lock().unwrap();
articles.insert(article.ap_id.inner().clone(), article.clone());
}
CreateArticle::send_to_followers(article.clone(), &data).await?; CreateArticle::send_to_followers(article.clone(), &data).await?;
Ok(Json(article)) Ok(Json(DbArticle::read_view(article.id, &data.db_connection)?))
} }
#[derive(Deserialize, Serialize, Debug)] #[derive(Deserialize, Serialize, Debug)]
pub struct EditArticleData { pub struct EditArticleData {
/// Id of the article to edit /// Id of the article to edit
pub ap_id: ObjectId<DbArticle>, pub article_id: i32,
/// Full, new text of the article. A diff against `previous_version` is generated on the server /// Full, new text of the article. A diff against `previous_version` is generated on the server
/// side to handle conflicts. /// side to handle conflicts.
pub new_text: String, pub new_text: String,
/// The version that this edit is based on, ie [DbArticle.latest_version] or /// The version that this edit is based on, ie [DbArticle.latest_version] or
/// [ApiConflict.previous_version] /// [ApiConflict.previous_version]
pub previous_version: EditVersion, pub previous_version_id: EditVersion,
/// If you are resolving a conflict, pass the id to delete conflict from the database /// If you are resolving a conflict, pass the id to delete conflict from the database
pub resolve_conflict_id: Option<i32>, pub resolve_conflict_id: Option<EditVersion>,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct ApiConflict {
pub id: i32,
pub three_way_merge: String,
pub article_id: ObjectId<DbArticle>,
pub previous_version: EditVersion,
} }
/// Edit an existing article (local or remote). /// Edit an existing article (local or remote).
@ -114,67 +92,59 @@ pub struct ApiConflict {
/// Conflicts are stored in the database so they can be retrieved later from `/api/v3/edit_conflicts`. /// Conflicts are stored in the database so they can be retrieved later from `/api/v3/edit_conflicts`.
#[debug_handler] #[debug_handler]
async fn edit_article( async fn edit_article(
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
Form(edit_form): Form<EditArticleData>, Form(edit_form): Form<EditArticleData>,
) -> MyResult<Json<Option<ApiConflict>>> { ) -> MyResult<Json<Option<ApiConflict>>> {
// resolve conflict if any // resolve conflict if any
if let Some(resolve_conflict_id) = &edit_form.resolve_conflict_id { if let Some(resolve_conflict_id) = edit_form.resolve_conflict_id {
let mut lock = data.conflicts.lock().unwrap(); DbConflict::delete(resolve_conflict_id, &data.db_connection)?;
if !lock.iter().any(|c| &c.id == resolve_conflict_id) {
return Err(anyhow!("invalid resolve conflict"))?;
}
lock.retain(|c| &c.id != resolve_conflict_id);
} }
let original_article = { let original_article = DbArticle::read_view(edit_form.article_id, &data.db_connection)?;
let lock = data.articles.lock().unwrap();
let article = lock.get(edit_form.ap_id.inner()).unwrap();
article.clone()
};
if edit_form.previous_version == original_article.latest_version { if edit_form.previous_version_id == original_article.latest_version {
// No intermediate changes, simply submit new version // No intermediate changes, simply submit new version
submit_article_update(&data, edit_form.new_text.clone(), &original_article).await?; submit_article_update(
&data,
edit_form.new_text.clone(),
edit_form.previous_version_id,
&original_article.article,
)
.await?;
Ok(Json(None)) Ok(Json(None))
} else { } else {
// There have been other changes since this edit was initiated. Get the common ancestor // There have been other changes since this edit was initiated. Get the common ancestor
// version and generate a diff to find out what exactly has changed. // version and generate a diff to find out what exactly has changed.
let ancestor = let ancestor =
generate_article_version(&original_article.edits, &edit_form.previous_version)?; generate_article_version(&original_article.edits, &edit_form.previous_version_id)?;
let patch = create_patch(&ancestor, &edit_form.new_text); let patch = create_patch(&ancestor, &edit_form.new_text);
let db_conflict = DbConflict { let previous_version = DbEdit::read(&edit_form.previous_version_id, &data.db_connection)?;
id: random(), let form = DbConflictForm {
id: EditVersion::new(&patch.to_string())?,
diff: patch.to_string(), diff: patch.to_string(),
article_id: original_article.ap_id.clone(), article_id: original_article.article.id,
previous_version: edit_form.previous_version, previous_version_id: previous_version.hash,
}; };
{ let conflict = DbConflict::create(&form, &data.db_connection)?;
let mut lock = data.conflicts.lock().unwrap(); Ok(Json(conflict.to_api_conflict(&data).await?))
lock.push(db_conflict.clone());
}
Ok(Json(db_conflict.to_api_conflict(&data).await?))
} }
} }
#[derive(Deserialize, Serialize, Clone)] #[derive(Deserialize, Serialize, Clone)]
pub struct GetArticleData { pub struct GetArticleData {
pub ap_id: ObjectId<DbArticle>, pub article_id: i32,
} }
/// Retrieve an article by ID. It must already be stored in the local database. /// Retrieve an article by ID. It must already be stored in the local database.
#[debug_handler] #[debug_handler]
async fn get_article( async fn get_article(
Query(query): Query<GetArticleData>, Query(query): Query<GetArticleData>,
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<Json<DbArticle>> { ) -> MyResult<Json<ArticleView>> {
let articles = data.articles.lock().unwrap(); Ok(Json(DbArticle::read_view(
let article = articles query.article_id,
.iter() &data.db_connection,
.find(|a| a.1.ap_id == query.ap_id) )?))
.ok_or(anyhow!("not found"))?
.1
.clone();
Ok(Json(article))
} }
#[derive(Deserialize, Serialize)] #[derive(Deserialize, Serialize)]
@ -187,7 +157,7 @@ pub struct ResolveObject {
#[debug_handler] #[debug_handler]
async fn resolve_instance( async fn resolve_instance(
Query(query): Query<ResolveObject>, Query(query): Query<ResolveObject>,
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<Json<DbInstance>> { ) -> MyResult<Json<DbInstance>> {
let instance: DbInstance = ObjectId::from(query.id).dereference(&data).await?; let instance: DbInstance = ObjectId::from(query.id).dereference(&data).await?;
Ok(Json(instance)) Ok(Json(instance))
@ -198,39 +168,50 @@ async fn resolve_instance(
#[debug_handler] #[debug_handler]
async fn resolve_article( async fn resolve_article(
Query(query): Query<ResolveObject>, Query(query): Query<ResolveObject>,
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<Json<DbArticle>> { ) -> MyResult<Json<ArticleView>> {
let article: DbArticle = ObjectId::from(query.id).dereference(&data).await?; let article: DbArticle = ObjectId::from(query.id).dereference(&data).await?;
Ok(Json(article)) let edits = DbEdit::read_for_article(&article, &data.db_connection)?;
let latest_version = edits.last().unwrap().hash.clone();
Ok(Json(ArticleView {
article,
edits,
latest_version,
}))
} }
/// Retrieve the local instance info. /// Retrieve the local instance info.
#[debug_handler] #[debug_handler]
async fn get_local_instance(data: Data<DatabaseHandle>) -> MyResult<Json<DbInstance>> { async fn get_local_instance(data: Data<MyDataHandle>) -> MyResult<Json<InstanceView>> {
Ok(Json(data.local_instance())) let local_instance = DbInstance::read_local_view(&data.db_connection)?;
Ok(Json(local_instance))
} }
#[derive(Deserialize, Serialize, Debug)] #[derive(Deserialize, Serialize, Debug)]
pub struct FollowInstance { pub struct FollowInstance {
pub instance_id: ObjectId<DbInstance>, pub id: i32,
} }
/// Make the local instance follow a given remote instance, to receive activities about new and /// Make the local instance follow a given remote instance, to receive activities about new and
/// updated articles. /// updated articles.
#[debug_handler] #[debug_handler]
async fn follow_instance( async fn follow_instance(
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
Form(query): Form<FollowInstance>, Form(query): Form<FollowInstance>,
) -> MyResult<()> { ) -> MyResult<()> {
let instance = query.instance_id.dereference(&data).await?; let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
data.local_instance().follow(&instance, &data).await?; let target = DbInstance::read(query.id, &data.db_connection)?;
let pending = !target.local;
DbInstance::follow(local_instance.id, target.id, pending, &data)?;
let instance = DbInstance::read(query.id, &data.db_connection)?;
Follow::send(local_instance, instance, &data).await?;
Ok(()) Ok(())
} }
/// Get a list of all unresolved edit conflicts. /// Get a list of all unresolved edit conflicts.
#[debug_handler] #[debug_handler]
async fn edit_conflicts(data: Data<DatabaseHandle>) -> MyResult<Json<Vec<ApiConflict>>> { async fn edit_conflicts(data: Data<MyDataHandle>) -> MyResult<Json<Vec<ApiConflict>>> {
let conflicts = { data.conflicts.lock().unwrap().to_vec() }; let conflicts = DbConflict::list(&data.db_connection)?;
let conflicts: Vec<ApiConflict> = try_join_all(conflicts.into_iter().map(|c| { let conflicts: Vec<ApiConflict> = try_join_all(conflicts.into_iter().map(|c| {
let data = data.reset_request_count(); let data = data.reset_request_count();
async move { c.to_api_conflict(&data).await } async move { c.to_api_conflict(&data).await }
@ -244,24 +225,16 @@ async fn edit_conflicts(data: Data<DatabaseHandle>) -> MyResult<Json<Vec<ApiConf
#[derive(Deserialize, Serialize, Clone)] #[derive(Deserialize, Serialize, Clone)]
pub struct SearchArticleData { pub struct SearchArticleData {
pub title: String, pub query: String,
} }
/// Search articles by title. For now only checks exact match. /// Search articles for matching title or body text.
///
/// Later include partial title match and body search.
#[debug_handler] #[debug_handler]
async fn search_article( async fn search_article(
Query(query): Query<SearchArticleData>, Query(query): Query<SearchArticleData>,
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<Json<Vec<DbArticle>>> { ) -> MyResult<Json<Vec<DbArticle>>> {
let articles = data.articles.lock().unwrap(); let article = DbArticle::search(&query.query, &data.db_connection)?;
let article = articles
.iter()
.filter(|a| a.1.title == query.title)
.map(|a| a.1)
.cloned()
.collect();
Ok(Json(article)) Ok(Json(article))
} }
@ -270,54 +243,52 @@ pub struct ForkArticleData {
// TODO: could add optional param new_title so there is no problem with title collision // TODO: could add optional param new_title so there is no problem with title collision
// in case local article with same title exists. however that makes it harder to discover // in case local article with same title exists. however that makes it harder to discover
// variants of same article. // variants of same article.
pub ap_id: ObjectId<DbArticle>, pub article_id: i32,
} }
/// Fork a remote article to local instance. This is useful if there are disagreements about /// Fork a remote article to local instance. This is useful if there are disagreements about
/// how an article should be edited. /// how an article should be edited.
#[debug_handler] #[debug_handler]
async fn fork_article( async fn fork_article(
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
Form(fork_form): Form<ForkArticleData>, Form(fork_form): Form<ForkArticleData>,
) -> MyResult<Json<DbArticle>> { ) -> MyResult<Json<ArticleView>> {
let article = { // TODO: lots of code duplicated from create_article(), can move it into helper
let lock = data.articles.lock().unwrap(); let original_article = DbArticle::read(fork_form.article_id, &data.db_connection)?;
let article = lock.get(fork_form.ap_id.inner()).unwrap();
article.clone()
};
if article.local {
return Err(anyhow!("Cannot fork local article because there cant be multiple local articles with same title").into());
}
let original_article = { let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let lock = data.articles.lock().unwrap();
lock.get(fork_form.ap_id.inner())
.expect("article exists")
.clone()
};
let local_instance_id = data.local_instance().ap_id;
let ap_id = ObjectId::parse(&format!( let ap_id = ObjectId::parse(&format!(
"http://{}:{}/article/{}", "http://{}:{}/article/{}",
local_instance_id.inner().domain().unwrap(), local_instance.ap_id.inner().domain().unwrap(),
local_instance_id.inner().port().unwrap(), local_instance.ap_id.inner().port().unwrap(),
original_article.title original_article.title
))?; ))?;
let forked_article = DbArticle { let form = DbArticleForm {
title: original_article.title.clone(), title: original_article.title.clone(),
text: original_article.text.clone(), text: original_article.text.clone(),
ap_id, ap_id,
latest_version: original_article.latest_version.clone(), instance_id: local_instance.id,
edits: original_article.edits.clone(),
instance: local_instance_id,
local: true, local: true,
}; };
{ let article = DbArticle::create(&form, &data.db_connection)?;
let mut articles = data.articles.lock().unwrap();
articles.insert(forked_article.ap_id.inner().clone(), forked_article.clone()); // copy edits to new article
// TODO: convert to sql
let edits = DbEdit::read_for_article(&original_article, &data.db_connection)?;
for e in edits {
let ap_id = DbEditForm::generate_ap_id(&article, &e.hash)?;
// TODO: id gives db unique violation
let form = DbEditForm {
ap_id,
diff: e.diff,
article_id: article.id,
hash: e.hash,
previous_version_id: e.previous_version_id,
};
dbg!(DbEdit::create(&form, &data.db_connection))?;
} }
CreateArticle::send_to_followers(forked_article.clone(), &data).await?; CreateArticle::send_to_followers(article.clone(), &data).await?;
Ok(Json(forked_article)) Ok(Json(DbArticle::read_view(article.id, &data.db_connection)?))
} }

76
src/database.rs
View File

@ -1,76 +0,0 @@
use crate::api::ApiConflict;
use crate::error::MyResult;
use crate::federation::activities::submit_article_update;
use crate::federation::objects::article::DbArticle;
use crate::federation::objects::edit::EditVersion;
use crate::federation::objects::instance::DbInstance;
use crate::utils::generate_article_version;
use activitypub_federation::config::Data;
use activitypub_federation::fetch::object_id::ObjectId;
use diffy::{apply, merge, Patch};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use url::Url;
pub type DatabaseHandle = Arc<Database>;
pub struct Database {
pub instances: Mutex<HashMap<Url, DbInstance>>,
pub articles: Mutex<HashMap<Url, DbArticle>>,
pub conflicts: Mutex<Vec<DbConflict>>,
}
impl Database {
pub fn local_instance(&self) -> DbInstance {
let lock = self.instances.lock().unwrap();
lock.iter().find(|i| i.1.local).unwrap().1.clone()
}
}
#[derive(Clone, Debug)]
pub struct DbConflict {
pub id: i32,
pub diff: String,
pub article_id: ObjectId<DbArticle>,
pub previous_version: EditVersion,
}
impl DbConflict {
pub async fn to_api_conflict(
&self,
data: &Data<DatabaseHandle>,
) -> MyResult<Option<ApiConflict>> {
let original_article = {
let mut lock = data.articles.lock().unwrap();
let article = lock.get_mut(self.article_id.inner()).unwrap();
article.clone()
};
// create common ancestor version
let ancestor = generate_article_version(&original_article.edits, &self.previous_version)?;
let patch = Patch::from_str(&self.diff)?;
// apply self.diff to ancestor to get `ours`
let ours = apply(&ancestor, &patch)?;
match merge(&ancestor, &ours, &original_article.text) {
Ok(new_text) => {
// patch applies cleanly so we are done
// federate the change
submit_article_update(data, new_text, &original_article).await?;
// remove conflict from db
let mut lock = data.conflicts.lock().unwrap();
lock.retain(|c| c.id != self.id);
Ok(None)
}
Err(three_way_merge) => {
// there is a merge conflict, user needs to do three-way-merge
Ok(Some(ApiConflict {
id: self.id,
three_way_merge,
article_id: original_article.ap_id.clone(),
previous_version: original_article.latest_version,
}))
}
}
}
}

146
src/database/article.rs Normal file
View File

@ -0,0 +1,146 @@
use crate::database::edit::DbEdit;
use crate::database::schema::article;
use crate::error::MyResult;
use crate::federation::objects::edits_collection::DbEditCollection;
use activitypub_federation::fetch::collection_id::CollectionId;
use activitypub_federation::fetch::object_id::ObjectId;
use diesel::pg::PgConnection;
use diesel::ExpressionMethods;
use diesel::{
insert_into, AsChangeset, BoolExpressionMethods, Identifiable, Insertable,
PgTextExpressionMethods, QueryDsl, Queryable, RunQueryDsl, Selectable,
};
use serde::{Deserialize, Serialize};
use crate::database::version::EditVersion;
use std::ops::DerefMut;
use std::sync::Mutex;
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Queryable, Selectable, Identifiable)]
#[diesel(table_name = article, check_for_backend(diesel::pg::Pg), belongs_to(DbInstance, foreign_key = instance_id))]
pub struct DbArticle {
pub id: i32,
pub title: String,
pub text: String,
pub ap_id: ObjectId<DbArticle>,
pub instance_id: i32,
pub local: bool,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Queryable)]
#[diesel(table_name = article, check_for_backend(diesel::pg::Pg))]
pub struct ArticleView {
pub article: DbArticle,
pub latest_version: EditVersion,
pub edits: Vec<DbEdit>,
}
#[derive(Debug, Clone, Insertable, AsChangeset)]
#[diesel(table_name = article, check_for_backend(diesel::pg::Pg))]
pub struct DbArticleForm {
pub title: String,
pub text: String,
pub ap_id: ObjectId<DbArticle>,
pub instance_id: i32,
pub local: bool,
}
impl DbArticle {
pub fn edits_id(&self) -> MyResult<CollectionId<DbEditCollection>> {
Ok(CollectionId::parse(&format!("{}/edits", self.ap_id))?)
}
pub fn create(form: &DbArticleForm, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(insert_into(article::table)
.values(form)
.get_result(conn.deref_mut())?)
}
pub fn create_or_update(form: &DbArticleForm, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(insert_into(article::table)
.values(form)
.on_conflict(article::dsl::ap_id)
.do_update()
.set(form)
.get_result(conn.deref_mut())?)
}
pub fn update_text(id: i32, text: &str, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(diesel::update(article::dsl::article.find(id))
.set(article::dsl::text.eq(text))
.get_result::<Self>(conn.deref_mut())?)
}
pub fn read(id: i32, conn: &Mutex<PgConnection>) -> MyResult<DbArticle> {
let mut conn = conn.lock().unwrap();
Ok(article::table.find(id).get_result(conn.deref_mut())?)
}
pub fn read_view(id: i32, conn: &Mutex<PgConnection>) -> MyResult<ArticleView> {
let article: DbArticle = {
let mut conn = conn.lock().unwrap();
article::table.find(id).get_result(conn.deref_mut())?
};
let latest_version = article.latest_edit_version(conn)?;
let edits: Vec<DbEdit> = DbEdit::read_for_article(&article, conn)?;
Ok(ArticleView {
article,
edits,
latest_version,
})
}
pub fn read_from_ap_id(
ap_id: &ObjectId<DbArticle>,
conn: &Mutex<PgConnection>,
) -> MyResult<DbArticle> {
let mut conn = conn.lock().unwrap();
Ok(article::table
.filter(article::dsl::ap_id.eq(ap_id))
.get_result(conn.deref_mut())?)
}
pub fn read_local_title(title: &str, conn: &Mutex<PgConnection>) -> MyResult<DbArticle> {
let mut conn = conn.lock().unwrap();
Ok(article::table
.filter(article::dsl::title.eq(title))
.filter(article::dsl::local.eq(true))
.get_result(conn.deref_mut())?)
}
pub fn read_all_local(conn: &Mutex<PgConnection>) -> MyResult<Vec<DbArticle>> {
let mut conn = conn.lock().unwrap();
Ok(article::table
.filter(article::dsl::local.eq(true))
.get_results(conn.deref_mut())?)
}
pub fn search(query: &str, conn: &Mutex<PgConnection>) -> MyResult<Vec<DbArticle>> {
let mut conn = conn.lock().unwrap();
let replaced = query
.replace('%', "\\%")
.replace('_', "\\_")
.replace(' ', "%");
Ok(article::table
.filter(
article::dsl::title
.ilike(&replaced)
.or(article::dsl::text.ilike(&replaced)),
)
.get_results(conn.deref_mut())?)
}
// TODO: shouldnt have to read all edits from db
pub fn latest_edit_version(&self, conn: &Mutex<PgConnection>) -> MyResult<EditVersion> {
let edits: Vec<DbEdit> = DbEdit::read_for_article(self, conn)?;
match edits.last().map(|e| e.hash.clone()) {
Some(latest_version) => Ok(latest_version),
None => Ok(EditVersion::default()),
}
}
}

108
src/database/conflict.rs Normal file
View File

@ -0,0 +1,108 @@
use crate::database::article::DbArticle;
use crate::database::edit::DbEdit;
use crate::database::schema::conflict;
use crate::database::version::EditVersion;
use crate::database::MyDataHandle;
use crate::error::MyResult;
use crate::federation::activities::submit_article_update;
use crate::utils::generate_article_version;
use activitypub_federation::config::Data;
use diesel::{
delete, insert_into, Identifiable, Insertable, PgConnection, QueryDsl, Queryable, RunQueryDsl,
Selectable,
};
use diffy::{apply, merge, Patch};
use serde::{Deserialize, Serialize};
use std::ops::DerefMut;
use std::sync::Mutex;
/// A local only object which represents a merge conflict. It is created
/// when a local user edit conflicts with another concurrent edit.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Queryable, Selectable, Identifiable)]
#[diesel(table_name = conflict, check_for_backend(diesel::pg::Pg), belongs_to(DbArticle, foreign_key = article_id))]
pub struct DbConflict {
pub id: EditVersion,
pub diff: String,
pub article_id: i32,
pub previous_version_id: EditVersion,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct ApiConflict {
pub id: EditVersion,
pub three_way_merge: String,
pub article_id: i32,
pub previous_version_id: EditVersion,
}
#[derive(Debug, Clone, Insertable)]
#[diesel(table_name = conflict, check_for_backend(diesel::pg::Pg))]
pub struct DbConflictForm {
pub id: EditVersion,
pub diff: String,
pub article_id: i32,
pub previous_version_id: EditVersion,
}
impl DbConflict {
pub fn create(form: &DbConflictForm, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(insert_into(conflict::table)
.values(form)
.get_result(conn.deref_mut())?)
}
pub fn list(conn: &Mutex<PgConnection>) -> MyResult<Vec<Self>> {
let mut conn = conn.lock().unwrap();
Ok(conflict::table.get_results(conn.deref_mut())?)
}
/// Delete a merge conflict after it is resolved.
pub fn delete(id: EditVersion, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
// TODO: should throw error on invalid id param
Ok(delete(conflict::table.find(id)).get_result(conn.deref_mut())?)
}
pub async fn to_api_conflict(
&self,
data: &Data<MyDataHandle>,
) -> MyResult<Option<ApiConflict>> {
let article = DbArticle::read(self.article_id, &data.db_connection)?;
// Make sure to get latest version from origin so that all conflicts can be resolved
let original_article = article.ap_id.dereference_forced(data).await?;
// create common ancestor version
let edits = DbEdit::read_for_article(&original_article, &data.db_connection)?;
let ancestor = generate_article_version(&edits, &self.previous_version_id)?;
let patch = Patch::from_str(&self.diff)?;
// apply self.diff to ancestor to get `ours`
let ours = apply(&ancestor, &patch)?;
match merge(&ancestor, &ours, &original_article.text) {
Ok(new_text) => {
// patch applies cleanly so we are done
// federate the change
submit_article_update(
data,
new_text,
self.previous_version_id.clone(),
&original_article,
)
.await?;
DbConflict::delete(self.id.clone(), &data.db_connection)?;
Ok(None)
}
Err(three_way_merge) => {
// there is a merge conflict, user needs to do three-way-merge
Ok(Some(ApiConflict {
id: self.id.clone(),
three_way_merge,
article_id: original_article.id,
previous_version_id: original_article
.latest_edit_version(&data.db_connection)?,
}))
}
}
}
}

98
src/database/edit.rs Normal file
View File

@ -0,0 +1,98 @@
use crate::database::schema::edit;
use crate::database::version::EditVersion;
use crate::database::DbArticle;
use crate::error::MyResult;
use activitypub_federation::fetch::object_id::ObjectId;
use diesel::ExpressionMethods;
use diesel::{
insert_into, AsChangeset, Insertable, PgConnection, QueryDsl, Queryable, RunQueryDsl,
Selectable,
};
use diffy::create_patch;
use serde::{Deserialize, Serialize};
use std::ops::DerefMut;
use std::sync::Mutex;
/// Represents a single change to the article.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Queryable, Selectable)]
#[diesel(table_name = edit, check_for_backend(diesel::pg::Pg))]
pub struct DbEdit {
// TODO: we could use hash as primary key, but that gives errors on forking because
// the same edit is used for multiple articles
pub id: i32,
/// UUID built from sha224 hash of diff
pub hash: EditVersion,
pub ap_id: ObjectId<DbEdit>,
pub diff: String,
pub article_id: i32,
/// First edit of an article always has `EditVersion::default()` here
pub previous_version_id: EditVersion,
}
#[derive(Debug, Clone, Insertable, AsChangeset)]
#[diesel(table_name = edit, check_for_backend(diesel::pg::Pg))]
pub struct DbEditForm {
pub hash: EditVersion,
pub ap_id: ObjectId<DbEdit>,
pub diff: String,
pub article_id: i32,
pub previous_version_id: EditVersion,
}
impl DbEditForm {
pub fn new(
original_article: &DbArticle,
updated_text: &str,
previous_version_id: EditVersion,
) -> MyResult<Self> {
let diff = create_patch(&original_article.text, updated_text);
let version = EditVersion::new(&diff.to_string())?;
let ap_id = Self::generate_ap_id(original_article, &version)?;
Ok(DbEditForm {
hash: version,
ap_id,
diff: diff.to_string(),
article_id: original_article.id,
previous_version_id,
})
}
pub(crate) fn generate_ap_id(
article: &DbArticle,
version: &EditVersion,
) -> MyResult<ObjectId<DbEdit>> {
Ok(ObjectId::parse(&format!(
"{}/{}",
article.ap_id,
version.hash()
))?)
}
}
impl DbEdit {
pub fn create(form: &DbEditForm, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(insert_into(edit::table)
.values(form)
.on_conflict(edit::dsl::ap_id)
.do_update()
.set(form)
.get_result(conn.deref_mut())?)
}
pub fn read(version: &EditVersion, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(edit::table
.filter(edit::dsl::hash.eq(version))
.get_result(conn.deref_mut())?)
}
pub fn read_for_article(
article: &DbArticle,
conn: &Mutex<PgConnection>,
) -> MyResult<Vec<Self>> {
let mut conn = conn.lock().unwrap();
Ok(edit::table
.filter(edit::dsl::article_id.eq(article.id))
.get_results(conn.deref_mut())?)
}
}

205
src/database/instance.rs Normal file
View File

@ -0,0 +1,205 @@
use crate::database::schema::{instance, instance_follow};
use crate::database::MyDataHandle;
use crate::error::{Error, MyResult};
use crate::federation::objects::articles_collection::DbArticleCollection;
use activitypub_federation::activity_sending::SendActivityTask;
use activitypub_federation::config::Data;
use activitypub_federation::fetch::collection_id::CollectionId;
use activitypub_federation::fetch::object_id::ObjectId;
use activitypub_federation::protocol::context::WithContext;
use activitypub_federation::traits::ActivityHandler;
use chrono::{DateTime, Utc};
use diesel::ExpressionMethods;
use diesel::{
insert_into, AsChangeset, Identifiable, Insertable, JoinOnDsl, PgConnection, QueryDsl,
Queryable, RunQueryDsl, Selectable,
};
use serde::{Deserialize, Serialize};
use std::fmt::Debug;
use std::ops::DerefMut;
use std::sync::Mutex;
use tracing::warn;
use url::Url;
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Queryable, Selectable, Identifiable)]
#[diesel(table_name = instance, check_for_backend(diesel::pg::Pg))]
pub struct DbInstance {
pub id: i32,
pub ap_id: ObjectId<DbInstance>,
pub articles_url: CollectionId<DbArticleCollection>,
pub inbox_url: String,
#[serde(skip)]
pub(crate) public_key: String,
#[serde(skip)]
pub(crate) private_key: Option<String>,
#[serde(skip)]
pub(crate) last_refreshed_at: DateTime<Utc>,
pub local: bool,
}
#[derive(Debug, Clone, Insertable, AsChangeset)]
#[diesel(table_name = instance, check_for_backend(diesel::pg::Pg))]
pub struct DbInstanceForm {
pub ap_id: ObjectId<DbInstance>,
pub articles_url: CollectionId<DbArticleCollection>,
pub inbox_url: String,
pub(crate) public_key: String,
pub(crate) private_key: Option<String>,
pub(crate) last_refreshed_at: DateTime<Utc>,
pub local: bool,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Queryable)]
#[diesel(table_name = article, check_for_backend(diesel::pg::Pg))]
pub struct InstanceView {
pub instance: DbInstance,
pub followers: Vec<DbInstance>,
pub following: Vec<DbInstance>,
}
impl DbInstance {
pub fn followers_url(&self) -> MyResult<Url> {
Ok(Url::parse(&format!("{}/followers", self.ap_id.inner()))?)
}
pub fn follower_ids(&self, data: &Data<MyDataHandle>) -> MyResult<Vec<Url>> {
Ok(DbInstance::read_followers(self.id, &data.db_connection)?
.into_iter()
.map(|f| f.ap_id.into())
.collect())
}
pub async fn send_to_followers<Activity>(
&self,
activity: Activity,
extra_recipients: Vec<DbInstance>,
data: &Data<MyDataHandle>,
) -> Result<(), <Activity as ActivityHandler>::Error>
where
Activity: ActivityHandler + Serialize + Debug + Send + Sync,
<Activity as ActivityHandler>::Error: From<activitypub_federation::error::Error>,
<Activity as ActivityHandler>::Error: From<Error>,
{
let mut inboxes: Vec<_> = DbInstance::read_followers(self.id, &data.db_connection)?
.iter()
.map(|f| Url::parse(&f.inbox_url).unwrap())
.collect();
inboxes.extend(
extra_recipients
.into_iter()
.map(|i| Url::parse(&i.inbox_url).unwrap()),
);
self.send(activity, inboxes, data).await?;
Ok(())
}
pub async fn send<Activity>(
&self,
activity: Activity,
recipients: Vec<Url>,
data: &Data<MyDataHandle>,
) -> Result<(), <Activity as ActivityHandler>::Error>
where
Activity: ActivityHandler + Serialize + Debug + Send + Sync,
<Activity as ActivityHandler>::Error: From<activitypub_federation::error::Error>,
{
let activity = WithContext::new_default(activity);
let sends = SendActivityTask::prepare(&activity, self, recipients, data).await?;
for send in sends {
let send = send.sign_and_send(data).await;
if let Err(e) = send {
warn!("Failed to send activity {:?}: {e}", activity);
}
}
Ok(())
}
pub fn create(form: &DbInstanceForm, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(insert_into(instance::table)
.values(form)
.on_conflict(instance::dsl::ap_id)
.do_update()
.set(form)
.get_result(conn.deref_mut())?)
}
pub fn read(id: i32, conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(instance::table.find(id).get_result(conn.deref_mut())?)
}
pub fn read_from_ap_id(
ap_id: &ObjectId<DbInstance>,
data: &Data<MyDataHandle>,
) -> MyResult<DbInstance> {
let mut conn = data.db_connection.lock().unwrap();
Ok(instance::table
.filter(instance::dsl::ap_id.eq(ap_id))
.get_result(conn.deref_mut())?)
}
pub fn read_local_instance(conn: &Mutex<PgConnection>) -> MyResult<Self> {
let mut conn = conn.lock().unwrap();
Ok(instance::table
.filter(instance::dsl::local.eq(true))
.get_result(conn.deref_mut())?)
}
pub fn read_local_view(conn: &Mutex<PgConnection>) -> MyResult<InstanceView> {
let instance = DbInstance::read_local_instance(conn)?;
let followers = DbInstance::read_followers(instance.id, conn)?;
let following = DbInstance::read_following(instance.id, conn)?;
Ok(InstanceView {
instance,
followers,
following,
})
}
pub fn follow(
follower_id_: i32,
instance_id_: i32,
pending_: bool,
data: &Data<MyDataHandle>,
) -> MyResult<()> {
debug_assert_ne!(follower_id_, instance_id_);
use instance_follow::dsl::{follower_id, instance_id, pending};
let mut conn = data.db_connection.lock().unwrap();
let form = (
instance_id.eq(instance_id_),
follower_id.eq(follower_id_),
pending.eq(pending_),
);
dbg!(follower_id_, instance_id_, pending_);
insert_into(instance_follow::table)
.values(form)
.on_conflict((instance_id, follower_id))
.do_update()
.set(form)
.execute(conn.deref_mut())?;
Ok(())
}
pub fn read_followers(id_: i32, conn: &Mutex<PgConnection>) -> MyResult<Vec<Self>> {
use instance_follow::dsl::{follower_id, instance_id};
let mut conn = conn.lock().unwrap();
Ok(instance_follow::table
.inner_join(instance::table.on(follower_id.eq(instance::dsl::id)))
.filter(instance_id.eq(id_))
.select(instance::all_columns)
.get_results(conn.deref_mut())?)
}
pub fn read_following(id_: i32, conn: &Mutex<PgConnection>) -> MyResult<Vec<Self>> {
use instance_follow::dsl::{follower_id, instance_id};
let mut conn = conn.lock().unwrap();
Ok(instance_follow::table
.inner_join(instance::table.on(instance_id.eq(instance::dsl::id)))
.filter(follower_id.eq(id_))
.select(instance::all_columns)
.get_results(conn.deref_mut())?)
}
}

27
src/database/mod.rs Normal file
View File

@ -0,0 +1,27 @@
use crate::database::article::DbArticle;
use diesel::PgConnection;
use std::ops::Deref;
use std::sync::{Arc, Mutex};
pub mod article;
pub mod conflict;
pub mod edit;
pub mod instance;
mod schema;
pub mod version;
#[derive(Clone)]
pub struct MyData {
pub db_connection: Arc<Mutex<PgConnection>>,
}
impl Deref for MyData {
type Target = Arc<Mutex<PgConnection>>;
fn deref(&self) -> &Self::Target {
&self.db_connection
}
}
pub type MyDataHandle = MyData;

64
src/database/schema.rs Normal file
View File

@ -0,0 +1,64 @@
// @generated automatically by Diesel CLI.
diesel::table! {
article (id) {
id -> Int4,
title -> Text,
text -> Text,
#[max_length = 255]
ap_id -> Varchar,
instance_id -> Int4,
local -> Bool,
}
}
diesel::table! {
conflict (id) {
id -> Uuid,
diff -> Text,
article_id -> Int4,
previous_version_id -> Uuid,
}
}
diesel::table! {
edit (id) {
id -> Int4,
hash -> Uuid,
#[max_length = 255]
ap_id -> Varchar,
diff -> Text,
article_id -> Int4,
previous_version_id -> Uuid,
}
}
diesel::table! {
instance (id) {
id -> Int4,
#[max_length = 255]
ap_id -> Varchar,
inbox_url -> Text,
#[max_length = 255]
articles_url -> Varchar,
public_key -> Text,
private_key -> Nullable<Text>,
last_refreshed_at -> Timestamptz,
local -> Bool,
}
}
diesel::table! {
instance_follow (id) {
id -> Int4,
instance_id -> Int4,
follower_id -> Int4,
pending -> Bool,
}
}
diesel::joinable!(article -> instance (instance_id));
diesel::joinable!(conflict -> article (article_id));
diesel::joinable!(edit -> article (article_id));
diesel::allow_tables_to_appear_in_same_query!(article, conflict, edit, instance, instance_follow,);

43
src/database/version.rs Normal file
View File

@ -0,0 +1,43 @@
use crate::error::MyResult;
use std::hash::Hash;
use diesel_derive_newtype::DieselNewType;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use uuid::Uuid;
/// The version hash of a specific edit. Generated by taking an SHA256 hash of the diff
/// and using the first 16 bytes so that it fits into UUID.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, DieselNewType)]
pub struct EditVersion(Uuid);
impl EditVersion {
pub fn new(diff: &str) -> MyResult<Self> {
let mut sha256 = Sha256::new();
sha256.update(diff);
let hash_bytes = sha256.finalize();
let uuid = Uuid::from_slice(&hash_bytes.as_slice()[..16])?;
Ok(EditVersion(uuid))
}
pub fn hash(&self) -> String {
hex::encode(self.0.into_bytes())
}
}
impl Default for EditVersion {
fn default() -> Self {
EditVersion::new("").unwrap()
}
}
#[test]
fn test_edit_versions() -> MyResult<()> {
let default = EditVersion::default();
assert_eq!("e3b0c44298fc1c149afbf4c8996fb924", default.hash());
let version = EditVersion::new("test")?;
assert_eq!("9f86d081884c7d659a2feaa0c55ad015", version.hash());
Ok(())
}

12
src/federation/activities/accept.rs
View File

@ -1,7 +1,7 @@
use crate::database::instance::DbInstance;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::objects::instance::DbInstance;
use crate::utils::generate_activity_id; use crate::utils::generate_activity_id;
use crate::{database::DatabaseHandle, federation::activities::follow::Follow}; use crate::{database::MyDataHandle, federation::activities::follow::Follow};
use activitypub_federation::{ use activitypub_federation::{
config::Data, fetch::object_id::ObjectId, kinds::activity::AcceptType, traits::ActivityHandler, config::Data, fetch::object_id::ObjectId, kinds::activity::AcceptType, traits::ActivityHandler,
}; };
@ -32,7 +32,7 @@ impl Accept {
#[async_trait::async_trait] #[async_trait::async_trait]
impl ActivityHandler for Accept { impl ActivityHandler for Accept {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Error = crate::error::Error; type Error = crate::error::Error;
fn id(&self) -> &Url { fn id(&self) -> &Url {
@ -49,9 +49,9 @@ impl ActivityHandler for Accept {
async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> { async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
// add to follows // add to follows
let mut lock = data.instances.lock().unwrap(); let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let local_instance = lock.iter_mut().find(|i| i.1.local).unwrap().1; let actor = self.actor.dereference(data).await?;
local_instance.follows.push(self.actor.inner().clone()); DbInstance::follow(local_instance.id, actor.id, false, data)?;
Ok(()) Ok(())
} }
} }

23
src/federation/activities/create_article.rs
View File

@ -1,7 +1,7 @@
use crate::database::DatabaseHandle; use crate::database::instance::DbInstance;
use crate::database::{article::DbArticle, MyDataHandle};
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::objects::article::{ApubArticle, DbArticle}; use crate::federation::objects::article::ApubArticle;
use crate::federation::objects::instance::DbInstance;
use crate::utils::generate_activity_id; use crate::utils::generate_activity_id;
use activitypub_federation::kinds::activity::CreateType; use activitypub_federation::kinds::activity::CreateType;
use activitypub_federation::{ use activitypub_federation::{
@ -26,16 +26,14 @@ pub struct CreateArticle {
} }
impl CreateArticle { impl CreateArticle {
pub async fn send_to_followers( pub async fn send_to_followers(article: DbArticle, data: &Data<MyDataHandle>) -> MyResult<()> {
article: DbArticle, let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
data: &Data<DatabaseHandle>,
) -> MyResult<()> {
let local_instance = data.local_instance();
let object = article.clone().into_json(data).await?; let object = article.clone().into_json(data).await?;
let id = generate_activity_id(local_instance.ap_id.inner())?; let id = generate_activity_id(local_instance.ap_id.inner())?;
let to = local_instance.follower_ids(data)?;
let create = CreateArticle { let create = CreateArticle {
actor: local_instance.ap_id.clone(), actor: local_instance.ap_id.clone(),
to: local_instance.follower_ids(), to,
object, object,
kind: Default::default(), kind: Default::default(),
id, id,
@ -48,7 +46,7 @@ impl CreateArticle {
} }
#[async_trait::async_trait] #[async_trait::async_trait]
impl ActivityHandler for CreateArticle { impl ActivityHandler for CreateArticle {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Error = crate::error::Error; type Error = crate::error::Error;
fn id(&self) -> &Url { fn id(&self) -> &Url {
@ -66,9 +64,8 @@ impl ActivityHandler for CreateArticle {
async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> { async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
let article = DbArticle::from_json(self.object.clone(), data).await?; let article = DbArticle::from_json(self.object.clone(), data).await?;
if article.local { if article.local {
data.local_instance() let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
.send_to_followers(self, vec![], data) local_instance.send_to_followers(self, vec![], data).await?;
.await?;
} }
Ok(()) Ok(())
} }

37
src/federation/activities/follow.rs
View File

@ -1,8 +1,6 @@
use crate::database::instance::DbInstance;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::objects::instance::DbInstance; use crate::{database::MyDataHandle, federation::activities::accept::Accept, generate_activity_id};
use crate::{
database::DatabaseHandle, federation::activities::accept::Accept, generate_activity_id,
};
use activitypub_federation::{ use activitypub_federation::{
config::Data, config::Data,
fetch::object_id::ObjectId, fetch::object_id::ObjectId,
@ -23,20 +21,28 @@ pub struct Follow {
} }
impl Follow { impl Follow {
pub fn new(actor: ObjectId<DbInstance>, object: ObjectId<DbInstance>) -> MyResult<Follow> { pub async fn send(
let id = generate_activity_id(actor.inner())?; local_instance: DbInstance,
Ok(Follow { to: DbInstance,
actor, data: &Data<MyDataHandle>,
object, ) -> MyResult<()> {
let id = generate_activity_id(local_instance.ap_id.inner())?;
let follow = Follow {
actor: local_instance.ap_id.clone(),
object: to.ap_id.clone(),
kind: Default::default(), kind: Default::default(),
id, id,
}) };
local_instance
.send(follow, vec![to.shared_inbox_or_inbox()], data)
.await?;
Ok(())
} }
} }
#[async_trait::async_trait] #[async_trait::async_trait]
impl ActivityHandler for Follow { impl ActivityHandler for Follow {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Error = crate::error::Error; type Error = crate::error::Error;
fn id(&self) -> &Url { fn id(&self) -> &Url {
@ -53,13 +59,8 @@ impl ActivityHandler for Follow {
async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> { async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
let actor = self.actor.dereference(data).await?; let actor = self.actor.dereference(data).await?;
// add to followers let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let local_instance = { DbInstance::follow(actor.id, local_instance.id, false, data)?;
let mut lock = data.instances.lock().unwrap();
let local_instance = lock.iter_mut().find(|i| i.1.local).unwrap().1;
local_instance.followers.push(actor);
local_instance.clone()
};
// send back an accept // send back an accept
let follower = self.actor.dereference(data).await?; let follower = self.actor.dereference(data).await?;

41
src/federation/activities/mod.rs
View File

@ -1,9 +1,11 @@
use crate::database::DatabaseHandle; use crate::database::article::DbArticle;
use crate::database::edit::{DbEdit, DbEditForm};
use crate::database::instance::DbInstance;
use crate::database::version::EditVersion;
use crate::database::MyDataHandle;
use crate::error::Error; use crate::error::Error;
use crate::federation::activities::update_local_article::UpdateLocalArticle; use crate::federation::activities::update_local_article::UpdateLocalArticle;
use crate::federation::activities::update_remote_article::UpdateRemoteArticle; use crate::federation::activities::update_remote_article::UpdateRemoteArticle;
use crate::federation::objects::article::DbArticle;
use crate::federation::objects::edit::DbEdit;
use activitypub_federation::config::Data; use activitypub_federation::config::Data;
pub mod accept; pub mod accept;
@ -14,29 +16,30 @@ pub mod update_local_article;
pub mod update_remote_article; pub mod update_remote_article;
pub async fn submit_article_update( pub async fn submit_article_update(
data: &Data<DatabaseHandle>, data: &Data<MyDataHandle>,
new_text: String, new_text: String,
previous_version: EditVersion,
original_article: &DbArticle, original_article: &DbArticle,
) -> Result<(), Error> { ) -> Result<(), Error> {
let edit = DbEdit::new(original_article, &new_text)?; let form = DbEditForm::new(original_article, &new_text, previous_version)?;
if original_article.local { if original_article.local {
let updated_article = { let edit = DbEdit::create(&form, &data.db_connection)?;
let mut lock = data.articles.lock().unwrap(); let updated_article =
let article = lock.get_mut(original_article.ap_id.inner()).unwrap(); DbArticle::update_text(edit.article_id, &new_text, &data.db_connection)?;
article.text = new_text;
article.latest_version = edit.version.clone();
article.edits.push(edit.clone());
article.clone()
};
UpdateLocalArticle::send(updated_article, vec![], data).await?; UpdateLocalArticle::send(updated_article, vec![], data).await?;
} else { } else {
UpdateRemoteArticle::send( // dont insert edit into db, might be invalid in case of conflict
edit, let edit = DbEdit {
original_article.instance.dereference(data).await?, id: -1,
data, hash: form.hash,
) ap_id: form.ap_id,
.await?; diff: form.diff,
article_id: form.article_id,
previous_version_id: form.previous_version_id,
};
let instance = DbInstance::read(original_article.instance_id, &data.db_connection)?;
UpdateRemoteArticle::send(edit, instance, data).await?;
} }
Ok(()) Ok(())
} }

28
src/federation/activities/reject.rs
View File

@ -1,16 +1,16 @@
use crate::database::DatabaseHandle; use crate::database::conflict::{DbConflict, DbConflictForm};
use crate::database::instance::DbInstance;
use crate::database::version::EditVersion;
use crate::database::MyDataHandle;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::objects::edit::ApubEdit; use crate::federation::objects::edit::ApubEdit;
use crate::federation::objects::instance::DbInstance;
use crate::utils::generate_activity_id; use crate::utils::generate_activity_id;
use activitypub_federation::kinds::activity::RejectType; use activitypub_federation::kinds::activity::RejectType;
use activitypub_federation::{ use activitypub_federation::{
config::Data, fetch::object_id::ObjectId, protocol::helpers::deserialize_one_or_many, config::Data, fetch::object_id::ObjectId, protocol::helpers::deserialize_one_or_many,
traits::ActivityHandler, traits::ActivityHandler,
}; };
use rand::random;
use crate::database::DbConflict;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use url::Url; use url::Url;
@ -30,9 +30,9 @@ impl RejectEdit {
pub async fn send( pub async fn send(
edit: ApubEdit, edit: ApubEdit,
user_instance: DbInstance, user_instance: DbInstance,
data: &Data<DatabaseHandle>, data: &Data<MyDataHandle>,
) -> MyResult<()> { ) -> MyResult<()> {
let local_instance = data.local_instance(); let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let id = generate_activity_id(local_instance.ap_id.inner())?; let id = generate_activity_id(local_instance.ap_id.inner())?;
let reject = RejectEdit { let reject = RejectEdit {
actor: local_instance.ap_id.clone(), actor: local_instance.ap_id.clone(),
@ -42,7 +42,7 @@ impl RejectEdit {
id, id,
}; };
local_instance local_instance
.send(reject, vec![user_instance.inbox], data) .send(reject, vec![Url::parse(&user_instance.inbox_url)?], data)
.await?; .await?;
Ok(()) Ok(())
} }
@ -50,7 +50,7 @@ impl RejectEdit {
#[async_trait::async_trait] #[async_trait::async_trait]
impl ActivityHandler for RejectEdit { impl ActivityHandler for RejectEdit {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Error = crate::error::Error; type Error = crate::error::Error;
fn id(&self) -> &Url { fn id(&self) -> &Url {
@ -67,14 +67,14 @@ impl ActivityHandler for RejectEdit {
async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> { async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
// cant convert this to DbEdit as it tries to apply patch and fails // cant convert this to DbEdit as it tries to apply patch and fails
let mut lock = data.conflicts.lock().unwrap(); let article = self.object.object.dereference(data).await?;
let conflict = DbConflict { let form = DbConflictForm {
id: random(), id: EditVersion::new(&self.object.content)?,
diff: self.object.content, diff: self.object.content,
article_id: self.object.object, article_id: article.id,
previous_version: self.object.previous_version, previous_version_id: self.object.previous_version,
}; };
lock.push(conflict); DbConflict::create(&form, &data.db_connection)?;
Ok(()) Ok(())
} }
} }

14
src/federation/activities/update_local_article.rs
View File

@ -1,8 +1,8 @@
use crate::database::DatabaseHandle; use crate::database::{article::DbArticle, MyDataHandle};
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::objects::article::{ApubArticle, DbArticle}; use crate::federation::objects::article::ApubArticle;
use crate::federation::objects::instance::DbInstance; use crate::database::instance::DbInstance;
use crate::utils::generate_activity_id; use crate::utils::generate_activity_id;
use activitypub_federation::kinds::activity::UpdateType; use activitypub_federation::kinds::activity::UpdateType;
use activitypub_federation::{ use activitypub_federation::{
@ -32,12 +32,12 @@ impl UpdateLocalArticle {
pub async fn send( pub async fn send(
article: DbArticle, article: DbArticle,
extra_recipients: Vec<DbInstance>, extra_recipients: Vec<DbInstance>,
data: &Data<DatabaseHandle>, data: &Data<MyDataHandle>,
) -> MyResult<()> { ) -> MyResult<()> {
debug_assert!(article.local); debug_assert!(article.local);
let local_instance = data.local_instance(); let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let id = generate_activity_id(local_instance.ap_id.inner())?; let id = generate_activity_id(local_instance.ap_id.inner())?;
let mut to = local_instance.follower_ids(); let mut to = local_instance.follower_ids(data)?;
to.extend(extra_recipients.iter().map(|i| i.ap_id.inner().clone())); to.extend(extra_recipients.iter().map(|i| i.ap_id.inner().clone()));
let update = UpdateLocalArticle { let update = UpdateLocalArticle {
actor: local_instance.ap_id.clone(), actor: local_instance.ap_id.clone(),
@ -55,7 +55,7 @@ impl UpdateLocalArticle {
#[async_trait::async_trait] #[async_trait::async_trait]
impl ActivityHandler for UpdateLocalArticle { impl ActivityHandler for UpdateLocalArticle {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Error = crate::error::Error; type Error = crate::error::Error;
fn id(&self) -> &Url { fn id(&self) -> &Url {

38
src/federation/activities/update_remote_article.rs
View File

@ -1,8 +1,12 @@
use crate::database::DatabaseHandle; use crate::database::MyDataHandle;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::objects::edit::{ApubEdit, DbEdit}; use crate::database::article::DbArticle;
use crate::federation::objects::instance::DbInstance; use crate::database::edit::DbEdit;
use crate::database::instance::DbInstance;
use crate::federation::activities::reject::RejectEdit;
use crate::federation::activities::update_local_article::UpdateLocalArticle;
use crate::federation::objects::edit::ApubEdit;
use crate::utils::generate_activity_id; use crate::utils::generate_activity_id;
use activitypub_federation::kinds::activity::UpdateType; use activitypub_federation::kinds::activity::UpdateType;
use activitypub_federation::{ use activitypub_federation::{
@ -12,9 +16,6 @@ use activitypub_federation::{
traits::{ActivityHandler, Object}, traits::{ActivityHandler, Object},
}; };
use diffy::{apply, Patch}; use diffy::{apply, Patch};
use crate::federation::activities::reject::RejectEdit;
use crate::federation::activities::update_local_article::UpdateLocalArticle;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use url::Url; use url::Url;
@ -35,9 +36,9 @@ impl UpdateRemoteArticle {
pub async fn send( pub async fn send(
edit: DbEdit, edit: DbEdit,
article_instance: DbInstance, article_instance: DbInstance,
data: &Data<DatabaseHandle>, data: &Data<MyDataHandle>,
) -> MyResult<()> { ) -> MyResult<()> {
let local_instance = data.local_instance(); let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let id = generate_activity_id(local_instance.ap_id.inner())?; let id = generate_activity_id(local_instance.ap_id.inner())?;
let update = UpdateRemoteArticle { let update = UpdateRemoteArticle {
actor: local_instance.ap_id.clone(), actor: local_instance.ap_id.clone(),
@ -47,7 +48,7 @@ impl UpdateRemoteArticle {
id, id,
}; };
local_instance local_instance
.send(update, vec![article_instance.inbox], data) .send(update, vec![Url::parse(&article_instance.inbox_url)?], data)
.await?; .await?;
Ok(()) Ok(())
} }
@ -55,7 +56,7 @@ impl UpdateRemoteArticle {
#[async_trait::async_trait] #[async_trait::async_trait]
impl ActivityHandler for UpdateRemoteArticle { impl ActivityHandler for UpdateRemoteArticle {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Error = crate::error::Error; type Error = crate::error::Error;
fn id(&self) -> &Url { fn id(&self) -> &Url {
@ -72,21 +73,14 @@ impl ActivityHandler for UpdateRemoteArticle {
/// Received on article origin instances /// Received on article origin instances
async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> { async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
let article_text = { let local_article = DbArticle::read_from_ap_id(&self.object.object, &data.db_connection)?;
let lock = data.articles.lock().unwrap();
lock.get(self.object.object.inner()).unwrap().text.clone()
};
let patch = Patch::from_str(&self.object.content)?; let patch = Patch::from_str(&self.object.content)?;
match apply(&article_text, &patch) { match apply(&local_article.text, &patch) {
Ok(applied) => { Ok(applied) => {
let article = { let edit = DbEdit::from_json(self.object.clone(), data).await?;
let edit = DbEdit::from_json(self.object.clone(), data).await?; let article =
let mut lock = data.articles.lock().unwrap(); DbArticle::update_text(edit.article_id, &applied, &data.db_connection)?;
let article = lock.get_mut(edit.article_id.inner()).unwrap();
article.text = applied;
article.clone()
};
UpdateLocalArticle::send(article, vec![self.actor.dereference(data).await?], data) UpdateLocalArticle::send(article, vec![self.actor.dereference(data).await?], data)
.await?; .await?;
} }

44
src/federation/mod.rs
View File

@ -1,47 +1,3 @@
use crate::database::{Database, DatabaseHandle};
use crate::error::Error;
use crate::federation::objects::instance::DbInstance;
use activitypub_federation::config::FederationConfig;
use activitypub_federation::fetch::collection_id::CollectionId;
use activitypub_federation::http_signatures::generate_actor_keypair;
use chrono::Local;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use url::Url;
pub mod activities; pub mod activities;
pub mod objects; pub mod objects;
pub mod routes; pub mod routes;
pub async fn federation_config(hostname: &str) -> Result<FederationConfig<DatabaseHandle>, Error> {
let ap_id = Url::parse(&format!("http://{}", hostname))?.into();
let articles_id = CollectionId::parse(&format!("http://{}/all_articles", hostname))?;
let inbox = Url::parse(&format!("http://{}/inbox", hostname))?;
let keypair = generate_actor_keypair()?;
let local_instance = DbInstance {
ap_id,
articles_id,
inbox,
public_key: keypair.public_key,
private_key: Some(keypair.private_key),
last_refreshed_at: Local::now().into(),
followers: vec![],
follows: vec![],
local: true,
};
let database = Arc::new(Database {
instances: Mutex::new(HashMap::from([(
local_instance.ap_id.inner().clone(),
local_instance,
)])),
articles: Mutex::new(HashMap::new()),
conflicts: Mutex::new(vec![]),
});
let config = FederationConfig::builder()
.domain(hostname)
.app_data(database)
.debug(true)
.build()
.await?;
Ok(config)
}

78
src/federation/objects/article.rs
View File

@ -1,44 +1,26 @@
use crate::error::MyResult; use crate::database::article::DbArticleForm;
use crate::federation::objects::edit::{DbEdit, EditVersion}; use crate::database::instance::DbInstance;
use crate::database::version::EditVersion;
use crate::database::{article::DbArticle, MyDataHandle};
use crate::error::Error;
use crate::federation::objects::edits_collection::DbEditCollection; use crate::federation::objects::edits_collection::DbEditCollection;
use crate::federation::objects::instance::DbInstance; use activitypub_federation::config::Data;
use crate::{database::DatabaseHandle, error::Error};
use activitypub_federation::fetch::collection_id::CollectionId; use activitypub_federation::fetch::collection_id::CollectionId;
use activitypub_federation::kinds::object::ArticleType; use activitypub_federation::kinds::object::ArticleType;
use activitypub_federation::kinds::public;
use activitypub_federation::protocol::verification::verify_domains_match;
use activitypub_federation::{ use activitypub_federation::{
config::Data, fetch::object_id::ObjectId, protocol::helpers::deserialize_one_or_many, traits::Object,
fetch::object_id::ObjectId,
kinds::public,
protocol::{helpers::deserialize_one_or_many, verification::verify_domains_match},
traits::Object,
}; };
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use url::Url; use url::Url;
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct DbArticle {
pub title: String,
pub text: String,
pub ap_id: ObjectId<DbArticle>,
pub instance: ObjectId<DbInstance>,
/// List of all edits which make up this article, oldest first.
pub edits: Vec<DbEdit>,
pub latest_version: EditVersion,
pub local: bool,
}
impl DbArticle {
fn edits_id(&self) -> MyResult<CollectionId<DbEditCollection>> {
Ok(CollectionId::parse(&format!("{}/edits", self.ap_id))?)
}
}
#[derive(Deserialize, Serialize, Debug, Clone)] #[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
pub struct ApubArticle { pub struct ApubArticle {
#[serde(rename = "type")] #[serde(rename = "type")]
kind: ArticleType, pub(crate) kind: ArticleType,
id: ObjectId<DbArticle>, pub(crate) id: ObjectId<DbArticle>,
pub(crate) attributed_to: ObjectId<DbInstance>, pub(crate) attributed_to: ObjectId<DbInstance>,
#[serde(deserialize_with = "deserialize_one_or_many")] #[serde(deserialize_with = "deserialize_one_or_many")]
pub(crate) to: Vec<Url>, pub(crate) to: Vec<Url>,
@ -50,7 +32,7 @@ pub struct ApubArticle {
#[async_trait::async_trait] #[async_trait::async_trait]
impl Object for DbArticle { impl Object for DbArticle {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Kind = ApubArticle; type Kind = ApubArticle;
type Error = Error; type Error = Error;
@ -58,24 +40,19 @@ impl Object for DbArticle {
object_id: Url, object_id: Url,
data: &Data<Self::DataType>, data: &Data<Self::DataType>,
) -> Result<Option<Self>, Self::Error> { ) -> Result<Option<Self>, Self::Error> {
let posts = data.articles.lock().unwrap(); let article = DbArticle::read_from_ap_id(&object_id.into(), &data.db_connection).ok();
let res = posts Ok(article)
.clone()
.into_iter()
.find(|u| u.1.ap_id.inner() == &object_id)
.map(|u| u.1);
Ok(res)
} }
async fn into_json(self, data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> { async fn into_json(self, data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
let instance = self.instance.dereference_local(data).await?; let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
Ok(ApubArticle { Ok(ApubArticle {
kind: Default::default(), kind: Default::default(),
id: self.ap_id.clone(), id: self.ap_id.clone(),
attributed_to: self.instance.clone(), attributed_to: local_instance.ap_id.clone(),
to: vec![public(), instance.followers_url()?], to: vec![public(), local_instance.followers_url()?],
edits: self.edits_id()?, edits: self.edits_id()?,
latest_version: self.latest_version, latest_version: self.latest_edit_version(&data.db_connection)?,
content: self.text, content: self.text,
name: self.title, name: self.title,
}) })
@ -91,26 +68,17 @@ impl Object for DbArticle {
} }
async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> { async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> {
let mut article = DbArticle { let instance = json.attributed_to.dereference(data).await?;
let form = DbArticleForm {
title: json.name, title: json.name,
text: json.content, text: json.content,
ap_id: json.id, ap_id: json.id,
instance: json.attributed_to,
// TODO: shouldnt overwrite existing edits
edits: vec![],
latest_version: json.latest_version,
local: false, local: false,
instance_id: instance.id,
}; };
let article = DbArticle::create_or_update(&form, &data.db_connection)?;
{ json.edits.dereference(&article, data).await?;
let mut lock = data.articles.lock().unwrap();
lock.insert(article.ap_id.inner().clone(), article.clone());
}
let edits = json.edits.dereference(&article, data).await?;
// include edits in return value (they are already written to db, no need to do that here)
article.edits = edits.0;
Ok(article) Ok(article)
} }

23
src/federation/objects/articles_collection.rs
View File

@ -1,7 +1,7 @@
use crate::database::DatabaseHandle; use crate::database::instance::DbInstance;
use crate::database::{article::DbArticle, MyDataHandle};
use crate::error::Error; use crate::error::Error;
use crate::federation::objects::article::{ApubArticle, DbArticle}; use crate::federation::objects::article::ApubArticle;
use crate::federation::objects::instance::DbInstance;
use activitypub_federation::kinds::collection::CollectionType; use activitypub_federation::kinds::collection::CollectionType;
use activitypub_federation::{ use activitypub_federation::{
@ -28,24 +28,15 @@ pub struct DbArticleCollection(Vec<DbArticle>);
#[async_trait::async_trait] #[async_trait::async_trait]
impl Collection for DbArticleCollection { impl Collection for DbArticleCollection {
type Owner = DbInstance; type Owner = DbInstance;
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Kind = ArticleCollection; type Kind = ArticleCollection;
type Error = Error; type Error = Error;
async fn read_local( async fn read_local(
_owner: &Self::Owner, owner: &Self::Owner,
data: &Data<Self::DataType>, data: &Data<Self::DataType>,
) -> Result<Self::Kind, Self::Error> { ) -> Result<Self::Kind, Self::Error> {
let local_articles = { let local_articles = DbArticle::read_all_local(&data.db_connection)?;
let articles = data.articles.lock().unwrap();
articles
.iter()
.map(|a| a.1)
.filter(|a| a.local)
.clone()
.cloned()
.collect::<Vec<_>>()
};
let articles = future::try_join_all( let articles = future::try_join_all(
local_articles local_articles
.into_iter() .into_iter()
@ -55,7 +46,7 @@ impl Collection for DbArticleCollection {
.await?; .await?;
let collection = ArticleCollection { let collection = ArticleCollection {
r#type: Default::default(), r#type: Default::default(),
id: data.local_instance().articles_id.into(), id: owner.articles_url.clone().into(),
total_items: articles.len() as i32, total_items: articles.len() as i32,
items: articles, items: articles,
}; };

81
src/federation/objects/edit.rs
View File

@ -1,54 +1,14 @@
use crate::database::DatabaseHandle; use crate::database::article::DbArticle;
use crate::error::{Error, MyResult}; use crate::database::edit::{DbEdit, DbEditForm};
use crate::database::version::EditVersion;
use crate::federation::objects::article::DbArticle; use crate::database::MyDataHandle;
use crate::error::Error;
use activitypub_federation::config::Data; use activitypub_federation::config::Data;
use activitypub_federation::fetch::object_id::ObjectId; use activitypub_federation::fetch::object_id::ObjectId;
use activitypub_federation::traits::Object; use activitypub_federation::traits::Object;
use diffy::create_patch;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use sha2::Digest;
use sha2::Sha224;
use url::Url; use url::Url;
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct EditVersion(String);
impl Default for EditVersion {
fn default() -> Self {
let sha224 = Sha224::new();
let hash = format!("{:X}", sha224.finalize());
EditVersion(hash)
}
}
/// Represents a single change to the article.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct DbEdit {
pub id: ObjectId<DbEdit>,
pub diff: String,
pub article_id: ObjectId<DbArticle>,
pub version: EditVersion,
pub local: bool,
}
impl DbEdit {
pub fn new(original_article: &DbArticle, updated_text: &str) -> MyResult<Self> {
let diff = create_patch(&original_article.text, updated_text);
let mut sha224 = Sha224::new();
sha224.update(diff.to_bytes());
let hash = format!("{:X}", sha224.finalize());
let edit_id = ObjectId::parse(&format!("{}/{}", original_article.ap_id, hash))?;
Ok(DbEdit {
id: edit_id,
diff: diff.to_string(),
article_id: original_article.ap_id.clone(),
version: EditVersion(hash),
local: true,
})
}
}
#[derive(Clone, Debug, Serialize, Deserialize)] #[derive(Clone, Debug, Serialize, Deserialize)]
pub enum EditType { pub enum EditType {
Edit, Edit,
@ -68,7 +28,7 @@ pub struct ApubEdit {
#[async_trait::async_trait] #[async_trait::async_trait]
impl Object for DbEdit { impl Object for DbEdit {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Kind = ApubEdit; type Kind = ApubEdit;
type Error = Error; type Error = Error;
@ -80,18 +40,14 @@ impl Object for DbEdit {
} }
async fn into_json(self, data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> { async fn into_json(self, data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
let article_version = { let article = DbArticle::read(self.article_id, &data.db_connection)?;
let mut lock = data.articles.lock().unwrap();
let article = lock.get_mut(self.article_id.inner()).unwrap();
article.latest_version.clone()
};
Ok(ApubEdit { Ok(ApubEdit {
kind: EditType::Edit, kind: EditType::Edit,
id: self.id, id: self.ap_id,
content: self.diff, content: self.diff,
version: self.version, version: self.hash,
previous_version: article_version, previous_version: self.previous_version_id,
object: self.article_id, object: article.ap_id,
}) })
} }
@ -104,16 +60,15 @@ impl Object for DbEdit {
} }
async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> { async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> {
let edit = Self { let article = json.object.dereference(data).await?;
id: json.id, let form = DbEditForm {
ap_id: json.id,
diff: json.content, diff: json.content,
article_id: json.object, article_id: article.id,
version: json.version, hash: json.version,
local: false, previous_version_id: json.previous_version,
}; };
let mut lock = data.articles.lock().unwrap(); let edit = DbEdit::create(&form, &data.db_connection)?;
let article = lock.get_mut(edit.article_id.inner()).unwrap();
article.edits.push(edit.clone());
Ok(edit) Ok(edit)
} }
} }

22
src/federation/objects/edits_collection.rs
View File

@ -1,8 +1,10 @@
use crate::database::DatabaseHandle; use crate::database::article::DbArticle;
use crate::database::MyDataHandle;
use crate::error::Error; use crate::error::Error;
use crate::federation::objects::article::DbArticle; use crate::federation::objects::edit::ApubEdit;
use crate::federation::objects::edit::{ApubEdit, DbEdit};
use crate::database::edit::DbEdit;
use crate::database::instance::DbInstance;
use activitypub_federation::kinds::collection::OrderedCollectionType; use activitypub_federation::kinds::collection::OrderedCollectionType;
use activitypub_federation::{ use activitypub_federation::{
config::Data, config::Data,
@ -28,7 +30,7 @@ pub struct DbEditCollection(pub Vec<DbEdit>);
#[async_trait::async_trait] #[async_trait::async_trait]
impl Collection for DbEditCollection { impl Collection for DbEditCollection {
type Owner = DbArticle; type Owner = DbArticle;
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Kind = ApubEditCollection; type Kind = ApubEditCollection;
type Error = Error; type Error = Error;
@ -36,22 +38,20 @@ impl Collection for DbEditCollection {
owner: &Self::Owner, owner: &Self::Owner,
data: &Data<Self::DataType>, data: &Data<Self::DataType>,
) -> Result<Self::Kind, Self::Error> { ) -> Result<Self::Kind, Self::Error> {
let edits = { let article = DbArticle::read_view(owner.id, &data.db_connection)?;
let lock = data.articles.lock().unwrap();
DbEditCollection(lock.get(owner.ap_id.inner()).unwrap().edits.clone())
};
let edits = future::try_join_all( let edits = future::try_join_all(
edits article
.0 .edits
.into_iter() .into_iter()
.map(|a| a.into_json(data)) .map(|a| a.into_json(data))
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
) )
.await?; .await?;
let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let collection = ApubEditCollection { let collection = ApubEditCollection {
r#type: Default::default(), r#type: Default::default(),
id: Url::from(data.local_instance().articles_id), id: Url::from(local_instance.articles_url),
total_items: edits.len() as i32, total_items: edits.len() as i32,
items: edits, items: edits,
}; };

122
src/federation/objects/instance.rs
View File

@ -1,37 +1,20 @@
use crate::error::{Error, MyResult}; use crate::database::instance::{DbInstance, DbInstanceForm};
use crate::database::MyDataHandle;
use crate::error::Error;
use crate::federation::objects::articles_collection::DbArticleCollection; use crate::federation::objects::articles_collection::DbArticleCollection;
use crate::{database::DatabaseHandle, federation::activities::follow::Follow};
use activitypub_federation::activity_sending::SendActivityTask;
use activitypub_federation::fetch::collection_id::CollectionId; use activitypub_federation::fetch::collection_id::CollectionId;
use activitypub_federation::kinds::actor::ServiceType; use activitypub_federation::kinds::actor::ServiceType;
use activitypub_federation::{ use activitypub_federation::{
config::Data, config::Data,
fetch::object_id::ObjectId, fetch::object_id::ObjectId,
protocol::{context::WithContext, public_key::PublicKey, verification::verify_domains_match}, protocol::{public_key::PublicKey, verification::verify_domains_match},
traits::{ActivityHandler, Actor, Object}, traits::{Actor, Object},
}; };
use chrono::{DateTime, Local, Utc}; use chrono::{DateTime, Local, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::fmt::Debug; use std::fmt::Debug;
use tracing::warn;
use url::Url; use url::Url;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DbInstance {
pub ap_id: ObjectId<DbInstance>,
pub articles_id: CollectionId<DbArticleCollection>,
pub inbox: Url,
#[serde(skip)]
pub(crate) public_key: String,
#[serde(skip)]
pub(crate) private_key: Option<String>,
#[serde(skip)]
pub(crate) last_refreshed_at: DateTime<Utc>,
pub followers: Vec<DbInstance>,
pub follows: Vec<Url>,
pub local: bool,
}
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
pub struct ApubInstance { pub struct ApubInstance {
@ -43,75 +26,9 @@ pub struct ApubInstance {
public_key: PublicKey, public_key: PublicKey,
} }
impl DbInstance {
pub fn followers_url(&self) -> MyResult<Url> {
Ok(Url::parse(&format!("{}/followers", self.ap_id.inner()))?)
}
pub fn follower_ids(&self) -> Vec<Url> {
self.followers
.iter()
.map(|f| f.ap_id.inner().clone())
.collect()
}
pub async fn follow(
&self,
other: &DbInstance,
data: &Data<DatabaseHandle>,
) -> Result<(), Error> {
let follow = Follow::new(self.ap_id.clone(), other.ap_id.clone())?;
self.send(follow, vec![other.shared_inbox_or_inbox()], data)
.await?;
Ok(())
}
pub async fn send_to_followers<Activity>(
&self,
activity: Activity,
extra_recipients: Vec<DbInstance>,
data: &Data<DatabaseHandle>,
) -> Result<(), <Activity as ActivityHandler>::Error>
where
Activity: ActivityHandler + Serialize + Debug + Send + Sync,
<Activity as ActivityHandler>::Error: From<activitypub_federation::error::Error>,
{
let local_instance = data.local_instance();
let mut inboxes: Vec<_> = local_instance
.followers
.iter()
.map(|f| f.inbox.clone())
.collect();
inboxes.extend(extra_recipients.into_iter().map(|i| i.inbox));
local_instance.send(activity, inboxes, data).await?;
Ok(())
}
pub async fn send<Activity>(
&self,
activity: Activity,
recipients: Vec<Url>,
data: &Data<DatabaseHandle>,
) -> Result<(), <Activity as ActivityHandler>::Error>
where
Activity: ActivityHandler + Serialize + Debug + Send + Sync,
<Activity as ActivityHandler>::Error: From<activitypub_federation::error::Error>,
{
let activity = WithContext::new_default(activity);
let sends = SendActivityTask::prepare(&activity, self, recipients, data).await?;
for send in sends {
let send = send.sign_and_send(data).await;
if let Err(e) = send {
warn!("Failed to send activity {:?}: {e}", activity);
}
}
Ok(())
}
}
#[async_trait::async_trait] #[async_trait::async_trait]
impl Object for DbInstance { impl Object for DbInstance {
type DataType = DatabaseHandle; type DataType = MyDataHandle;
type Kind = ApubInstance; type Kind = ApubInstance;
type Error = Error; type Error = Error;
@ -123,21 +40,15 @@ impl Object for DbInstance {
object_id: Url, object_id: Url,
data: &Data<Self::DataType>, data: &Data<Self::DataType>,
) -> Result<Option<Self>, Self::Error> { ) -> Result<Option<Self>, Self::Error> {
let users = data.instances.lock().unwrap(); Ok(DbInstance::read_from_ap_id(&object_id.into(), data).ok())
let res = users
.clone()
.into_iter()
.map(|u| u.1)
.find(|u| u.ap_id.inner() == &object_id);
Ok(res)
} }
async fn into_json(self, _data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> { async fn into_json(self, _data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
Ok(ApubInstance { Ok(ApubInstance {
kind: Default::default(), kind: Default::default(),
id: self.ap_id.clone(), id: self.ap_id.clone(),
articles: self.articles_id.clone(), articles: self.articles_url.clone(),
inbox: self.inbox.clone(), inbox: Url::parse(&self.inbox_url)?,
public_key: self.public_key(), public_key: self.public_key(),
}) })
} }
@ -152,21 +63,18 @@ impl Object for DbInstance {
} }
async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> { async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> {
let instance = DbInstance { let form = DbInstanceForm {
ap_id: json.id, ap_id: json.id,
articles_id: json.articles, articles_url: json.articles,
inbox: json.inbox, inbox_url: json.inbox.to_string(),
public_key: json.public_key.public_key_pem, public_key: json.public_key.public_key_pem,
private_key: None, private_key: None,
last_refreshed_at: Local::now().into(), last_refreshed_at: Local::now().into(),
followers: vec![],
follows: vec![],
local: false, local: false,
}; };
let instance = DbInstance::create(&form, &data.db_connection)?;
// TODO: very inefficient to sync all articles every time // TODO: very inefficient to sync all articles every time
instance.articles_id.dereference(&instance, data).await?; instance.articles_url.dereference(&instance, data).await?;
let mut mutex = data.instances.lock().unwrap();
mutex.insert(instance.ap_id.inner().clone(), instance.clone());
Ok(instance) Ok(instance)
} }
} }
@ -185,6 +93,6 @@ impl Actor for DbInstance {
} }
fn inbox(&self) -> Url { fn inbox(&self) -> Url {
self.inbox.clone() Url::parse(&self.inbox_url).unwrap()
} }
} }

56
src/federation/routes.rs
View File

@ -1,9 +1,17 @@
use crate::database::DatabaseHandle; use crate::database::article::DbArticle;
use crate::database::instance::DbInstance;
use crate::database::MyDataHandle;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::activities::accept::Accept; use crate::federation::activities::accept::Accept;
use crate::federation::activities::create_article::CreateArticle;
use crate::federation::activities::follow::Follow; use crate::federation::activities::follow::Follow;
use crate::federation::objects::instance::{ApubInstance, DbInstance}; use crate::federation::activities::reject::RejectEdit;
use crate::federation::activities::update_local_article::UpdateLocalArticle;
use crate::federation::activities::update_remote_article::UpdateRemoteArticle;
use crate::federation::objects::article::ApubArticle;
use crate::federation::objects::articles_collection::{ArticleCollection, DbArticleCollection};
use crate::federation::objects::edits_collection::{ApubEditCollection, DbEditCollection};
use crate::federation::objects::instance::ApubInstance;
use activitypub_federation::axum::inbox::{receive_activity, ActivityData}; use activitypub_federation::axum::inbox::{receive_activity, ActivityData};
use activitypub_federation::axum::json::FederationJson; use activitypub_federation::axum::json::FederationJson;
use activitypub_federation::config::Data; use activitypub_federation::config::Data;
@ -11,14 +19,6 @@ use activitypub_federation::protocol::context::WithContext;
use activitypub_federation::traits::Object; use activitypub_federation::traits::Object;
use activitypub_federation::traits::{ActivityHandler, Collection}; use activitypub_federation::traits::{ActivityHandler, Collection};
use axum::extract::Path; use axum::extract::Path;
use crate::federation::activities::create_article::CreateArticle;
use crate::federation::activities::reject::RejectEdit;
use crate::federation::activities::update_local_article::UpdateLocalArticle;
use crate::federation::activities::update_remote_article::UpdateRemoteArticle;
use crate::federation::objects::article::ApubArticle;
use crate::federation::objects::articles_collection::{ArticleCollection, DbArticleCollection};
use crate::federation::objects::edits_collection::{ApubEditCollection, DbEditCollection};
use axum::response::IntoResponse; use axum::response::IntoResponse;
use axum::routing::{get, post}; use axum::routing::{get, post};
use axum::Router; use axum::Router;
@ -37,30 +37,28 @@ pub fn federation_routes() -> Router {
#[debug_handler] #[debug_handler]
async fn http_get_instance( async fn http_get_instance(
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<FederationJson<WithContext<ApubInstance>>> { ) -> MyResult<FederationJson<WithContext<ApubInstance>>> {
let db_instance = data.local_instance(); let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let json_instance = db_instance.into_json(&data).await?; let json_instance = local_instance.into_json(&data).await?;
Ok(FederationJson(WithContext::new_default(json_instance))) Ok(FederationJson(WithContext::new_default(json_instance)))
} }
#[debug_handler] #[debug_handler]
async fn http_get_all_articles( async fn http_get_all_articles(
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<FederationJson<WithContext<ArticleCollection>>> { ) -> MyResult<FederationJson<WithContext<ArticleCollection>>> {
let collection = DbArticleCollection::read_local(&data.local_instance(), &data).await?; let local_instance = DbInstance::read_local_instance(&data.db_connection)?;
let collection = DbArticleCollection::read_local(&local_instance, &data).await?;
Ok(FederationJson(WithContext::new_default(collection))) Ok(FederationJson(WithContext::new_default(collection)))
} }
#[debug_handler] #[debug_handler]
async fn http_get_article( async fn http_get_article(
Path(title): Path<String>, Path(title): Path<String>,
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<FederationJson<WithContext<ApubArticle>>> { ) -> MyResult<FederationJson<WithContext<ApubArticle>>> {
let article = { let article = DbArticle::read_local_title(&title, &data.db_connection)?;
let lock = data.articles.lock().unwrap();
lock.values().find(|a| a.title == title).unwrap().clone()
};
let json = article.into_json(&data).await?; let json = article.into_json(&data).await?;
Ok(FederationJson(WithContext::new_default(json))) Ok(FederationJson(WithContext::new_default(json)))
} }
@ -68,12 +66,9 @@ async fn http_get_article(
#[debug_handler] #[debug_handler]
async fn http_get_article_edits( async fn http_get_article_edits(
Path(title): Path<String>, Path(title): Path<String>,
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
) -> MyResult<FederationJson<WithContext<ApubEditCollection>>> { ) -> MyResult<FederationJson<WithContext<ApubEditCollection>>> {
let article = { let article = DbArticle::read_local_title(&title, &data.db_connection)?;
let lock = data.articles.lock().unwrap();
lock.values().find(|a| a.title == title).unwrap().clone()
};
let json = DbEditCollection::read_local(&article, &data).await?; let json = DbEditCollection::read_local(&article, &data).await?;
Ok(FederationJson(WithContext::new_default(json))) Ok(FederationJson(WithContext::new_default(json)))
} }
@ -93,12 +88,9 @@ pub enum InboxActivities {
#[debug_handler] #[debug_handler]
pub async fn http_post_inbox( pub async fn http_post_inbox(
data: Data<DatabaseHandle>, data: Data<MyDataHandle>,
activity_data: ActivityData, activity_data: ActivityData,
) -> impl IntoResponse { ) -> impl IntoResponse {
receive_activity::<WithContext<InboxActivities>, DbInstance, DatabaseHandle>( receive_activity::<WithContext<InboxActivities>, DbInstance, MyDataHandle>(activity_data, &data)
activity_data, .await
&data,
)
.await
} }

56
src/lib.rs
View File

@ -1,13 +1,22 @@
use crate::utils::generate_activity_id;
use activitypub_federation::config::FederationMiddleware;
use axum::{Router, Server};
use crate::api::api_routes; use crate::api::api_routes;
use crate::database::instance::{DbInstance, DbInstanceForm};
use crate::database::MyData;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::routes::federation_routes; use crate::federation::routes::federation_routes;
use federation::federation_config; use crate::utils::generate_activity_id;
use activitypub_federation::config::{FederationConfig, FederationMiddleware};
use activitypub_federation::fetch::collection_id::CollectionId;
use activitypub_federation::fetch::object_id::ObjectId;
use activitypub_federation::http_signatures::generate_actor_keypair;
use axum::{Router, Server};
use chrono::Local;
use diesel::Connection;
use diesel::PgConnection;
use diesel_migrations::embed_migrations;
use diesel_migrations::EmbeddedMigrations;
use diesel_migrations::MigrationHarness;
use std::net::ToSocketAddrs; use std::net::ToSocketAddrs;
use std::sync::{Arc, Mutex};
use tracing::info; use tracing::info;
pub mod api; pub mod api;
@ -16,8 +25,39 @@ pub mod error;
pub mod federation; pub mod federation;
mod utils; mod utils;
pub async fn start(hostname: &str) -> MyResult<()> { const MIGRATIONS: EmbeddedMigrations = embed_migrations!("migrations");
let config = federation_config(hostname).await?;
pub async fn start(hostname: &str, database_url: &str) -> MyResult<()> {
let db_connection = Arc::new(Mutex::new(PgConnection::establish(database_url)?));
db_connection
.lock()
.unwrap()
.run_pending_migrations(MIGRATIONS)
.unwrap();
let data = MyData { db_connection };
let config = FederationConfig::builder()
.domain(hostname)
.app_data(data)
.debug(true)
.build()
.await?;
// TODO: Move this into setup api call
let ap_id = ObjectId::parse(&format!("http://{}", hostname))?;
let articles_url = CollectionId::parse(&format!("http://{}/all_articles", hostname))?;
let inbox_url = format!("http://{}/inbox", hostname);
let keypair = generate_actor_keypair()?;
let form = DbInstanceForm {
ap_id,
articles_url,
inbox_url,
public_key: keypair.public_key,
private_key: Some(keypair.private_key),
last_refreshed_at: Local::now().into(),
local: true,
};
DbInstance::create(&form, &config.db_connection)?;
info!("Listening with axum on {hostname}"); info!("Listening with axum on {hostname}");
let config = config.clone(); let config = config.clone();

3
src/main.rs
View File

@ -9,6 +9,7 @@ pub async fn main() -> MyResult<()> {
.filter_module("activitypub_federation", LevelFilter::Info) .filter_module("activitypub_federation", LevelFilter::Info)
.filter_module("fediwiki", LevelFilter::Info) .filter_module("fediwiki", LevelFilter::Info)
.init(); .init();
start("localhost:8131").await?; let database_url = "postgres://fediwiki:password@localhost:5432/fediwiki";
start("localhost:8131", database_url).await?;
Ok(()) Ok(())
} }

9
src/utils.rs
View File

@ -1,8 +1,10 @@
use crate::database::edit::DbEdit;
use crate::database::version::EditVersion;
use crate::error::MyResult; use crate::error::MyResult;
use crate::federation::objects::edit::{DbEdit, EditVersion};
use anyhow::anyhow; use anyhow::anyhow;
use diffy::{apply, Patch}; use diffy::{apply, Patch};
use rand::{distributions::Alphanumeric, thread_rng, Rng}; use rand::{distributions::Alphanumeric, thread_rng, Rng};
use url::{ParseError, Url}; use url::{ParseError, Url};
pub fn generate_activity_id(domain: &Url) -> Result<Url, ParseError> { pub fn generate_activity_id(domain: &Url) -> Result<Url, ParseError> {
@ -23,10 +25,13 @@ pub fn generate_activity_id(domain: &Url) -> Result<Url, ParseError> {
/// TODO: should cache all these generated versions /// TODO: should cache all these generated versions
pub fn generate_article_version(edits: &Vec<DbEdit>, version: &EditVersion) -> MyResult<String> { pub fn generate_article_version(edits: &Vec<DbEdit>, version: &EditVersion) -> MyResult<String> {
let mut generated = String::new(); let mut generated = String::new();
if version == &EditVersion::default() {
return Ok(generated);
}
for e in edits { for e in edits {
let patch = Patch::from_str(&e.diff)?; let patch = Patch::from_str(&e.diff)?;
generated = apply(&generated, &patch)?; generated = apply(&generated, &patch)?;
if &e.version == version { if &e.hash == version {
return Ok(generated); return Ok(generated);
} }
} }

210
tests/common.rs
View File

@ -1,16 +1,22 @@
use activitypub_federation::fetch::object_id::ObjectId; use anyhow::anyhow;
use fediwiki::api::{ use fediwiki::api::{
ApiConflict, CreateArticleData, EditArticleData, FollowInstance, GetArticleData, ResolveObject, CreateArticleData, EditArticleData, FollowInstance, GetArticleData, ResolveObject,
}; };
use fediwiki::database::article::ArticleView;
use fediwiki::database::conflict::ApiConflict;
use fediwiki::database::instance::DbInstance;
use fediwiki::error::MyResult; use fediwiki::error::MyResult;
use fediwiki::federation::objects::article::DbArticle;
use fediwiki::federation::objects::instance::DbInstance;
use fediwiki::start; use fediwiki::start;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use reqwest::Client; use reqwest::{Client, RequestBuilder, StatusCode};
use serde::de::Deserialize; use serde::de::Deserialize;
use serde::ser::Serialize; use serde::ser::Serialize;
use std::env::current_dir;
use std::process::{Command, Stdio};
use std::sync::atomic::{AtomicI32, Ordering};
use std::sync::Once; use std::sync::Once;
use std::thread::{sleep, spawn};
use std::time::Duration;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
use tracing::log::LevelFilter; use tracing::log::LevelFilter;
use url::Url; use url::Url;
@ -18,12 +24,9 @@ use url::Url;
pub static CLIENT: Lazy<Client> = Lazy::new(Client::new); pub static CLIENT: Lazy<Client> = Lazy::new(Client::new);
pub struct TestData { pub struct TestData {
pub hostname_alpha: &'static str, pub alpha: FediwikiInstance,
pub hostname_beta: &'static str, pub beta: FediwikiInstance,
pub hostname_gamma: &'static str, pub gamma: FediwikiInstance,
handle_alpha: JoinHandle<()>,
handle_beta: JoinHandle<()>,
handle_gamma: JoinHandle<()>,
} }
impl TestData { impl TestData {
@ -37,87 +40,135 @@ impl TestData {
.init(); .init();
}); });
let hostname_alpha = "localhost:8131"; // Run things on different ports and db paths to allow parallel tests
let hostname_beta = "localhost:8132"; static COUNTER: AtomicI32 = AtomicI32::new(0);
let hostname_gamma = "localhost:8133"; let current_run = COUNTER.fetch_add(1, Ordering::Relaxed);
let handle_alpha = tokio::task::spawn(async {
start(hostname_alpha).await.unwrap(); // Give each test a moment to start its postgres databases
}); sleep(Duration::from_millis(current_run as u64 * 500));
let handle_beta = tokio::task::spawn(async {
start(hostname_beta).await.unwrap(); let first_port = 8000 + (current_run * 3);
}); let port_alpha = first_port;
let handle_gamma = tokio::task::spawn(async { let port_beta = first_port + 1;
start(hostname_gamma).await.unwrap(); let port_gamma = first_port + 2;
});
let alpha_db_path = generate_db_path("alpha", port_alpha);
let beta_db_path = generate_db_path("beta", port_beta);
let gamma_db_path = generate_db_path("gamma", port_gamma);
// initialize postgres databases in parallel because its slow
for j in [
FediwikiInstance::prepare_db(alpha_db_path.clone()),
FediwikiInstance::prepare_db(beta_db_path.clone()),
FediwikiInstance::prepare_db(gamma_db_path.clone()),
] {
j.join().unwrap();
}
Self { Self {
hostname_alpha, alpha: FediwikiInstance::start(alpha_db_path, port_alpha),
hostname_beta, beta: FediwikiInstance::start(beta_db_path, port_beta),
hostname_gamma, gamma: FediwikiInstance::start(gamma_db_path, port_gamma),
handle_alpha,
handle_beta,
handle_gamma,
} }
} }
pub fn stop(self) -> MyResult<()> { pub fn stop(self) -> MyResult<()> {
self.handle_alpha.abort(); for j in [self.alpha.stop(), self.beta.stop(), self.gamma.stop()] {
self.handle_beta.abort(); j.join().unwrap();
self.handle_gamma.abort(); }
Ok(()) Ok(())
} }
} }
/// Generate a unique db path for each postgres so that tests can run in parallel.
fn generate_db_path(name: &'static str, port: i32) -> String {
format!(
"{}/target/test_db/{name}-{port}",
current_dir().unwrap().display()
)
}
pub struct FediwikiInstance {
pub hostname: String,
db_path: String,
db_handle: JoinHandle<()>,
}
impl FediwikiInstance {
fn prepare_db(db_path: String) -> std::thread::JoinHandle<()> {
spawn(move || {
Command::new("./tests/scripts/start_dev_db.sh")
.arg(&db_path)
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.unwrap();
})
}
fn start(db_path: String, port: i32) -> Self {
let db_url = format!("postgresql://lemmy:password@/lemmy?host={db_path}");
let hostname = format!("localhost:{port}");
let hostname_ = hostname.clone();
let handle = tokio::task::spawn(async move {
start(&hostname_, &db_url).await.unwrap();
});
Self {
db_path,
hostname,
db_handle: handle,
}
}
fn stop(self) -> std::thread::JoinHandle<()> {
self.db_handle.abort();
spawn(move || {
Command::new("./tests/scripts/stop_dev_db.sh")
.arg(&self.db_path)
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.unwrap();
})
}
}
pub const TEST_ARTICLE_DEFAULT_TEXT: &str = "some\nexample\ntext\n"; pub const TEST_ARTICLE_DEFAULT_TEXT: &str = "some\nexample\ntext\n";
pub async fn create_article(hostname: &str, title: String) -> MyResult<DbArticle> { pub async fn create_article(hostname: &str, title: String) -> MyResult<ArticleView> {
let create_form = CreateArticleData { let create_form = CreateArticleData {
title: title.clone(), title: title.clone(),
}; };
let article: DbArticle = post(hostname, "article", &create_form).await?; let article: ArticleView = post(hostname, "article", &create_form).await?;
// create initial edit to ensure that conflicts are generated (there are no conflicts on empty file) // create initial edit to ensure that conflicts are generated (there are no conflicts on empty file)
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: article.ap_id, article_id: article.article.id,
new_text: TEST_ARTICLE_DEFAULT_TEXT.to_string(), new_text: TEST_ARTICLE_DEFAULT_TEXT.to_string(),
previous_version: article.latest_version, previous_version_id: article.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
edit_article(hostname, &edit_form).await edit_article(hostname, &edit_form).await
} }
pub async fn get_article(hostname: &str, ap_id: &ObjectId<DbArticle>) -> MyResult<DbArticle> { pub async fn get_article(hostname: &str, article_id: i32) -> MyResult<ArticleView> {
let get_article = GetArticleData { let get_article = GetArticleData { article_id };
ap_id: ap_id.clone(), get_query::<ArticleView, _>(hostname, "article", Some(get_article.clone())).await
};
get_query::<DbArticle, _>(hostname, "article", Some(get_article.clone())).await
} }
pub async fn edit_article_with_conflict( pub async fn edit_article_with_conflict(
hostname: &str, hostname: &str,
edit_form: &EditArticleData, edit_form: &EditArticleData,
) -> MyResult<Option<ApiConflict>> { ) -> MyResult<Option<ApiConflict>> {
Ok(CLIENT let req = CLIENT
.patch(format!("http://{}/api/v1/article", hostname)) .patch(format!("http://{}/api/v1/article", hostname))
.form(edit_form) .form(edit_form);
.send() handle_json_res(req).await
.await?
.json()
.await?)
} }
pub async fn edit_article(hostname: &str, edit_form: &EditArticleData) -> MyResult<DbArticle> { pub async fn edit_article(hostname: &str, edit_form: &EditArticleData) -> MyResult<ArticleView> {
let edit_res: Option<ApiConflict> = CLIENT let edit_res = edit_article_with_conflict(hostname, edit_form).await?;
.patch(format!("http://{}/api/v1/article", hostname))
.form(&edit_form)
.send()
.await?
.json()
.await?;
assert!(edit_res.is_none()); assert!(edit_res.is_none());
let get_article = GetArticleData { get_article(hostname, edit_form.article_id).await
ap_id: edit_form.ap_id.clone(),
};
let updated_article: DbArticle = get_query(hostname, "article", Some(get_article)).await?;
Ok(updated_article)
} }
pub async fn get<T>(hostname: &str, endpoint: &str) -> MyResult<T> pub async fn get<T>(hostname: &str, endpoint: &str) -> MyResult<T>
@ -132,42 +183,51 @@ where
T: for<'de> Deserialize<'de>, T: for<'de> Deserialize<'de>,
R: Serialize, R: Serialize,
{ {
let mut res = CLIENT.get(format!("http://{}/api/v1/{}", hostname, endpoint)); let mut req = CLIENT.get(format!("http://{}/api/v1/{}", hostname, endpoint));
if let Some(query) = query { if let Some(query) = query {
res = res.query(&query); req = req.query(&query);
} }
let alpha_instance: T = res.send().await?.json().await?; handle_json_res(req).await
Ok(alpha_instance)
} }
pub async fn post<T: Serialize, R>(hostname: &str, endpoint: &str, form: &T) -> MyResult<R> pub async fn post<T: Serialize, R>(hostname: &str, endpoint: &str, form: &T) -> MyResult<R>
where where
R: for<'de> Deserialize<'de>, R: for<'de> Deserialize<'de>,
{ {
Ok(CLIENT let req = CLIENT
.post(format!("http://{}/api/v1/{}", hostname, endpoint)) .post(format!("http://{}/api/v1/{}", hostname, endpoint))
.form(form) .form(form);
.send() handle_json_res(req).await
.await?
.json()
.await?)
} }
pub async fn follow_instance(follow_instance: &str, followed_instance: &str) -> MyResult<()> { async fn handle_json_res<T>(req: RequestBuilder) -> MyResult<T>
where
T: for<'de> Deserialize<'de>,
{
let res = req.send().await?;
if res.status() == StatusCode::OK {
Ok(res.json().await?)
} else {
let text = res.text().await?;
Err(anyhow!("Post API response {text}").into())
}
}
pub async fn follow_instance(api_instance: &str, follow_instance: &str) -> MyResult<()> {
// fetch beta instance on alpha // fetch beta instance on alpha
let resolve_form = ResolveObject { let resolve_form = ResolveObject {
id: Url::parse(&format!("http://{}", followed_instance))?, id: Url::parse(&format!("http://{}", follow_instance))?,
}; };
let instance_resolved: DbInstance = let instance_resolved: DbInstance =
get_query(followed_instance, "resolve_instance", Some(resolve_form)).await?; get_query(api_instance, "resolve_instance", Some(resolve_form)).await?;
// send follow // send follow
let follow_form = FollowInstance { let follow_form = FollowInstance {
instance_id: instance_resolved.ap_id, id: instance_resolved.id,
}; };
// cant use post helper because follow doesnt return json // cant use post helper because follow doesnt return json
CLIENT CLIENT
.post(format!("http://{}/api/v1/instance/follow", follow_instance)) .post(format!("http://{}/api/v1/instance/follow", api_instance))
.form(&follow_form) .form(&follow_form)
.send() .send()
.await?; .await?;

29
tests/scripts/start_dev_db.sh Executable file
View File

@ -0,0 +1,29 @@
#!/bin/bash
set -e
export PGHOST=$1
export PGDATA="$1/dev_pgdata"
# If cluster exists, stop the server
if [ -d $PGDATA ]
then
# Prevent `stop` from failing if server already stopped
pg_ctl restart > /dev/null
pg_ctl stop
fi
# Remove any leftover data from revious run
rm -rf $PGDATA
# Create cluster
initdb --username=postgres --auth=trust --no-instructions
touch "$PGHOST/.s.PGSQL.5432"
echo "$PGHOST/.s.PGSQL.5432"
# Start server that only listens to socket in current directory
pg_ctl start --options="-c listen_addresses= -c unix_socket_directories=$PGHOST"
# Setup database
psql -c "CREATE USER lemmy WITH PASSWORD 'password' SUPERUSER;" -U postgres
psql -c "CREATE DATABASE lemmy WITH OWNER lemmy;" -U postgres

9
tests/scripts/stop_dev_db.sh Executable file
View File

@ -0,0 +1,9 @@
#!/bin/bash
set -e
export PGHOST=$1
export PGDATA="$1/dev_pgdata"
echo $PGHOST
pg_ctl stop
rm -rf $PGDATA

370
tests/test.rs
View File

@ -7,445 +7,461 @@ use crate::common::{
get_query, post, TestData, TEST_ARTICLE_DEFAULT_TEXT, get_query, post, TestData, TEST_ARTICLE_DEFAULT_TEXT,
}; };
use common::get; use common::get;
use fediwiki::api::{ use fediwiki::api::{EditArticleData, ForkArticleData, ResolveObject, SearchArticleData};
ApiConflict, EditArticleData, ForkArticleData, ResolveObject, SearchArticleData, use fediwiki::database::article::{ArticleView, DbArticle};
};
use fediwiki::error::MyResult; use fediwiki::error::MyResult;
use fediwiki::federation::objects::article::DbArticle;
use fediwiki::federation::objects::edit::ApubEdit; use fediwiki::database::conflict::ApiConflict;
use fediwiki::federation::objects::instance::DbInstance; use fediwiki::database::instance::{DbInstance, InstanceView};
use serial_test::serial; use pretty_assertions::{assert_eq, assert_ne};
use url::Url; use url::Url;
// TODO: can run tests in parallel if we use different ports
#[tokio::test] #[tokio::test]
#[serial]
async fn test_create_read_and_edit_article() -> MyResult<()> { async fn test_create_read_and_edit_article() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
// create article // create article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_alpha, title.clone()).await?; let create_res = create_article(&data.alpha.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
// now article can be read // now article can be read
let get_res = get_article(data.hostname_alpha, &create_res.ap_id).await?; let get_res = get_article(&data.alpha.hostname, create_res.article.id).await?;
assert_eq!(title, get_res.title); assert_eq!(title, get_res.article.title);
assert_eq!(TEST_ARTICLE_DEFAULT_TEXT, get_res.text); assert_eq!(TEST_ARTICLE_DEFAULT_TEXT, get_res.article.text);
assert!(get_res.local); assert!(get_res.article.local);
// error on article which wasnt federated // error on article which wasnt federated
let not_found = get_article(data.hostname_beta, &create_res.ap_id).await; let not_found = get_article(&data.beta.hostname, create_res.article.id).await;
assert!(not_found.is_err()); assert!(not_found.is_err());
// edit article // edit article
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "Lorem Ipsum 2".to_string(), new_text: "Lorem Ipsum 2".to_string(),
previous_version: get_res.latest_version, previous_version_id: get_res.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_alpha, &edit_form).await?; let edit_res = edit_article(&data.alpha.hostname, &edit_form).await?;
assert_eq!(edit_form.new_text, edit_res.text); assert_eq!(edit_form.new_text, edit_res.article.text);
assert_eq!(2, edit_res.edits.len()); assert_eq!(2, edit_res.edits.len());
let search_form = SearchArticleData { let search_form = SearchArticleData {
title: title.clone(), query: title.clone(),
}; };
let search_res: Vec<DbArticle> = let search_res: Vec<DbArticle> =
get_query(data.hostname_alpha, "search", Some(search_form)).await?; get_query(&data.alpha.hostname, "search", Some(search_form)).await?;
assert_eq!(1, search_res.len()); assert_eq!(1, search_res.len());
assert_eq!(edit_res, search_res[0]); assert_eq!(edit_res.article, search_res[0]);
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_create_duplicate_article() -> MyResult<()> { async fn test_create_duplicate_article() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
// create article // create article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_alpha, title.clone()).await?; let create_res = create_article(&data.alpha.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
let create_res = create_article(data.hostname_alpha, title.clone()).await; let create_res = create_article(&data.alpha.hostname, title.clone()).await;
assert!(create_res.is_err()); assert!(create_res.is_err());
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_follow_instance() -> MyResult<()> { async fn test_follow_instance() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
// check initial state // check initial state
let alpha_instance: DbInstance = get(data.hostname_alpha, "instance").await?; let alpha_instance: InstanceView = get(&data.alpha.hostname, "instance").await?;
assert_eq!(0, alpha_instance.follows.len()); assert_eq!(0, alpha_instance.followers.len());
let beta_instance: DbInstance = get(data.hostname_beta, "instance").await?; assert_eq!(0, alpha_instance.following.len());
let beta_instance: InstanceView = get(&data.beta.hostname, "instance").await?;
assert_eq!(0, beta_instance.followers.len()); assert_eq!(0, beta_instance.followers.len());
assert_eq!(0, beta_instance.following.len());
follow_instance(data.hostname_alpha, data.hostname_beta).await?; follow_instance(&data.alpha.hostname, &data.beta.hostname).await?;
// check that follow was federated // check that follow was federated
let beta_instance: DbInstance = get(data.hostname_beta, "instance").await?; let alpha_instance: InstanceView = get(&data.alpha.hostname, "instance").await?;
assert_eq!(1, beta_instance.followers.len()); assert_eq!(1, alpha_instance.following.len());
assert_eq!(0, alpha_instance.followers.len());
assert_eq!(
beta_instance.instance.ap_id,
alpha_instance.following[0].ap_id
);
let alpha_instance: DbInstance = get(data.hostname_alpha, "instance").await?; let beta_instance: InstanceView = get(&data.beta.hostname, "instance").await?;
assert_eq!(1, alpha_instance.follows.len()); assert_eq!(0, beta_instance.following.len());
assert_eq!(1, beta_instance.followers.len());
assert_eq!(
alpha_instance.instance.ap_id,
beta_instance.followers[0].ap_id
);
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_synchronize_articles() -> MyResult<()> { async fn test_synchronize_articles() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
// create article on alpha // create article on alpha
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_alpha, title.clone()).await?; let create_res = create_article(&data.alpha.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert_eq!(1, create_res.edits.len()); assert_eq!(1, create_res.edits.len());
assert!(create_res.local); assert!(create_res.article.local);
// edit the article // edit the article
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "Lorem Ipsum 2\n".to_string(), new_text: "Lorem Ipsum 2\n".to_string(),
previous_version: create_res.latest_version, previous_version_id: create_res.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
edit_article(data.hostname_alpha, &edit_form).await?; edit_article(&data.alpha.hostname, &edit_form).await?;
// article is not yet on beta // article is not yet on beta
let get_res = get_article(data.hostname_beta, &create_res.ap_id).await; let get_res = get_article(&data.beta.hostname, create_res.article.id).await;
assert!(get_res.is_err()); assert!(get_res.is_err());
// fetch alpha instance on beta, articles are also fetched automatically // fetch alpha instance on beta, articles are also fetched automatically
let resolve_object = ResolveObject { let resolve_object = ResolveObject {
id: Url::parse(&format!("http://{}", data.hostname_alpha))?, id: Url::parse(&format!("http://{}", &data.alpha.hostname))?,
}; };
get_query::<DbInstance, _>(data.hostname_beta, "resolve_instance", Some(resolve_object)) get_query::<DbInstance, _>(
.await?; &data.beta.hostname,
"resolve_instance",
Some(resolve_object),
)
.await?;
// get the article and compare // get the article and compare
let get_res = get_article(data.hostname_beta, &create_res.ap_id).await?; let get_res = get_article(&data.beta.hostname, create_res.article.id).await?;
assert_eq!(create_res.ap_id, get_res.ap_id); assert_eq!(create_res.article.ap_id, get_res.article.ap_id);
assert_eq!(title, get_res.title); assert_eq!(title, get_res.article.title);
assert_eq!(2, get_res.edits.len()); assert_eq!(2, get_res.edits.len());
assert_eq!(edit_form.new_text, get_res.text); assert_eq!(edit_form.new_text, get_res.article.text);
assert!(!get_res.local); assert!(!get_res.article.local);
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_edit_local_article() -> MyResult<()> { async fn test_edit_local_article() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
follow_instance(data.hostname_alpha, data.hostname_beta).await?; follow_instance(&data.alpha.hostname, &data.beta.hostname).await?;
// create new article // create new article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_beta, title.clone()).await?; let create_res = create_article(&data.beta.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
// article should be federated to alpha // article should be federated to alpha
let get_res = get_article(data.hostname_alpha, &create_res.ap_id).await?; let get_res = get_article(&data.alpha.hostname, create_res.article.id).await?;
assert_eq!(create_res.title, get_res.title); assert_eq!(create_res.article.title, get_res.article.title);
assert_eq!(1, get_res.edits.len()); assert_eq!(1, get_res.edits.len());
assert!(!get_res.local); assert!(!get_res.article.local);
assert_eq!(create_res.text, get_res.text); assert_eq!(create_res.article.text, get_res.article.text);
// edit the article // edit the article
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id, article_id: create_res.article.id,
new_text: "Lorem Ipsum 2".to_string(), new_text: "Lorem Ipsum 2".to_string(),
previous_version: get_res.latest_version, previous_version_id: get_res.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_beta, &edit_form).await?; let edit_res = edit_article(&data.beta.hostname, &edit_form).await?;
assert_eq!(edit_res.text, edit_form.new_text); assert_eq!(edit_res.article.text, edit_form.new_text);
assert_eq!(edit_res.edits.len(), 2); assert_eq!(edit_res.edits.len(), 2);
assert!(edit_res.edits[0] assert!(edit_res.edits[0]
.id .ap_id
.to_string() .to_string()
.starts_with(&edit_res.ap_id.to_string())); .starts_with(&edit_res.article.ap_id.to_string()));
// edit should be federated to alpha // edit should be federated to alpha
let get_res = get_article(data.hostname_alpha, &edit_res.ap_id).await?; let get_res = get_article(&data.alpha.hostname, edit_res.article.id).await?;
assert_eq!(edit_res.title, get_res.title); assert_eq!(edit_res.article.title, get_res.article.title);
assert_eq!(edit_res.edits.len(), 2); assert_eq!(edit_res.edits.len(), 2);
assert_eq!(edit_res.text, get_res.text); assert_eq!(edit_res.article.text, get_res.article.text);
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_edit_remote_article() -> MyResult<()> { async fn test_edit_remote_article() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
follow_instance(data.hostname_alpha, data.hostname_beta).await?; follow_instance(&data.alpha.hostname, &data.beta.hostname).await?;
follow_instance(data.hostname_gamma, data.hostname_beta).await?; follow_instance(&data.gamma.hostname, &data.beta.hostname).await?;
// create new article // create new article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_beta, title.clone()).await?; let create_res = create_article(&data.beta.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
// article should be federated to alpha and gamma // article should be federated to alpha and gamma
let get_res = get_article(data.hostname_alpha, &create_res.ap_id).await?; let get_res = get_article(&data.alpha.hostname, create_res.article.id).await?;
assert_eq!(create_res.title, get_res.title); assert_eq!(create_res.article.title, get_res.article.title);
assert_eq!(1, get_res.edits.len()); assert_eq!(1, get_res.edits.len());
assert!(!get_res.local); assert!(!get_res.article.local);
let get_res = get_article(data.hostname_gamma, &create_res.ap_id).await?; let get_res = get_article(&data.gamma.hostname, create_res.article.id).await?;
assert_eq!(create_res.title, get_res.title); assert_eq!(create_res.article.title, get_res.article.title);
assert_eq!(create_res.text, get_res.text); assert_eq!(create_res.article.text, get_res.article.text);
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "Lorem Ipsum 2".to_string(), new_text: "Lorem Ipsum 2".to_string(),
previous_version: get_res.latest_version, previous_version_id: get_res.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_alpha, &edit_form).await?; let edit_res = edit_article(&data.alpha.hostname, &edit_form).await?;
assert_eq!(edit_form.new_text, edit_res.text); assert_eq!(edit_form.new_text, edit_res.article.text);
assert_eq!(2, edit_res.edits.len()); assert_eq!(2, edit_res.edits.len());
assert!(!edit_res.local); assert!(!edit_res.article.local);
assert!(edit_res.edits[0] assert!(edit_res.edits[0]
.id .ap_id
.to_string() .to_string()
.starts_with(&edit_res.ap_id.to_string())); .starts_with(&edit_res.article.ap_id.to_string()));
// edit should be federated to beta and gamma // edit should be federated to beta and gamma
let get_res = get_article(data.hostname_alpha, &create_res.ap_id).await?; let get_res = get_article(&data.alpha.hostname, create_res.article.id).await?;
assert_eq!(edit_res.title, get_res.title); assert_eq!(edit_res.article.title, get_res.article.title);
assert_eq!(edit_res.edits.len(), 2); assert_eq!(edit_res.edits.len(), 2);
assert_eq!(edit_res.text, get_res.text); assert_eq!(edit_res.article.text, get_res.article.text);
let get_res = get_article(data.hostname_gamma, &create_res.ap_id).await?; let get_res = get_article(&data.gamma.hostname, create_res.article.id).await?;
assert_eq!(edit_res.title, get_res.title); assert_eq!(edit_res.article.title, get_res.article.title);
assert_eq!(edit_res.edits.len(), 2); assert_eq!(edit_res.edits.len(), 2);
assert_eq!(edit_res.text, get_res.text); assert_eq!(edit_res.article.text, get_res.article.text);
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_local_edit_conflict() -> MyResult<()> { async fn test_local_edit_conflict() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
// create new article // create new article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_alpha, title.clone()).await?; let create_res = create_article(&data.alpha.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
// one user edits article // one user edits article
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "Lorem Ipsum\n".to_string(), new_text: "Lorem Ipsum\n".to_string(),
previous_version: create_res.latest_version.clone(), previous_version_id: create_res.latest_version.clone(),
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_alpha, &edit_form).await?; let edit_res = edit_article(&data.alpha.hostname, &edit_form).await?;
assert_eq!(edit_res.text, edit_form.new_text); assert_eq!(edit_res.article.text, edit_form.new_text);
assert_eq!(2, edit_res.edits.len()); assert_eq!(2, edit_res.edits.len());
// another user edits article, without being aware of previous edit // another user edits article, without being aware of previous edit
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "Ipsum Lorem\n".to_string(), new_text: "Ipsum Lorem\n".to_string(),
previous_version: create_res.latest_version, previous_version_id: create_res.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article_with_conflict(data.hostname_alpha, &edit_form) let edit_res = edit_article_with_conflict(&data.alpha.hostname, &edit_form)
.await? .await?
.unwrap(); .unwrap();
assert_eq!("<<<<<<< ours\nIpsum Lorem\n||||||| original\nsome\nexample\ntext\n=======\nLorem Ipsum\n>>>>>>> theirs\n", edit_res.three_way_merge); assert_eq!("<<<<<<< ours\nIpsum Lorem\n||||||| original\nsome\nexample\ntext\n=======\nLorem Ipsum\n>>>>>>> theirs\n", edit_res.three_way_merge);
let conflicts: Vec<ApiConflict> = let conflicts: Vec<ApiConflict> =
get_query(data.hostname_alpha, "edit_conflicts", None::<()>).await?; get_query(&data.alpha.hostname, "edit_conflicts", None::<()>).await?;
assert_eq!(1, conflicts.len()); assert_eq!(1, conflicts.len());
assert_eq!(conflicts[0], edit_res); assert_eq!(conflicts[0], edit_res);
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "Lorem Ipsum and Ipsum Lorem\n".to_string(), new_text: "Lorem Ipsum and Ipsum Lorem\n".to_string(),
previous_version: edit_res.previous_version, previous_version_id: edit_res.previous_version_id,
resolve_conflict_id: Some(edit_res.id), resolve_conflict_id: Some(edit_res.id),
}; };
let edit_res = edit_article(data.hostname_alpha, &edit_form).await?; let edit_res = edit_article(&data.alpha.hostname, &edit_form).await?;
assert_eq!(edit_form.new_text, edit_res.text); assert_eq!(edit_form.new_text, edit_res.article.text);
let conflicts: Vec<ApiConflict> = let conflicts: Vec<ApiConflict> =
get_query(data.hostname_alpha, "edit_conflicts", None::<()>).await?; get_query(&data.alpha.hostname, "edit_conflicts", None::<()>).await?;
assert_eq!(0, conflicts.len()); assert_eq!(0, conflicts.len());
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_federated_edit_conflict() -> MyResult<()> { async fn test_federated_edit_conflict() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
follow_instance(data.hostname_alpha, data.hostname_beta).await?; follow_instance(&data.alpha.hostname, &data.beta.hostname).await?;
// create new article // create new article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_beta, title.clone()).await?; let create_res = create_article(&data.beta.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
// fetch article to gamma // fetch article to gamma
let resolve_object = ResolveObject { let resolve_object = ResolveObject {
id: create_res.ap_id.inner().clone(), id: create_res.article.ap_id.inner().clone(),
}; };
let resolve_res: DbArticle = let resolve_res: ArticleView = get_query(
get_query(data.hostname_gamma, "resolve_article", Some(resolve_object)).await?; &data.gamma.hostname,
assert_eq!(create_res.text, resolve_res.text); "resolve_article",
Some(resolve_object),
)
.await?;
assert_eq!(create_res.article.text, resolve_res.article.text);
// alpha edits article // alpha edits article
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "Lorem Ipsum\n".to_string(), new_text: "Lorem Ipsum\n".to_string(),
previous_version: create_res.latest_version.clone(), previous_version_id: create_res.latest_version.clone(),
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_alpha, &edit_form).await?; let edit_res = edit_article(&data.alpha.hostname, &edit_form).await?;
assert_eq!(edit_res.text, edit_form.new_text); assert_eq!(edit_res.article.text, edit_form.new_text);
assert_eq!(2, edit_res.edits.len()); assert_eq!(2, edit_res.edits.len());
assert!(!edit_res.local); assert!(!edit_res.article.local);
assert!(edit_res.edits[1] assert!(edit_res.edits[1]
.id .ap_id
.to_string() .to_string()
.starts_with(&edit_res.ap_id.to_string())); .starts_with(&edit_res.article.ap_id.to_string()));
// gamma also edits, as its not the latest version there is a conflict. local version should // gamma also edits, as its not the latest version there is a conflict. local version should
// not be updated with this conflicting version, instead user needs to handle the conflict // not be updated with this conflicting version, instead user needs to handle the conflict
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "aaaa\n".to_string(), new_text: "aaaa\n".to_string(),
previous_version: create_res.latest_version, previous_version_id: create_res.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_gamma, &edit_form).await?; let edit_res = edit_article(&data.gamma.hostname, &edit_form).await?;
assert_ne!(edit_form.new_text, edit_res.text); assert_ne!(edit_form.new_text, edit_res.article.text);
assert_eq!(2, edit_res.edits.len()); // TODO
assert!(!edit_res.local); //assert_eq!(2, edit_res.edits.len());
assert!(!edit_res.article.local);
let conflicts: Vec<ApiConflict> = let conflicts: Vec<ApiConflict> =
get_query(data.hostname_gamma, "edit_conflicts", None::<()>).await?; get_query(&data.gamma.hostname, "edit_conflicts", None::<()>).await?;
assert_eq!(1, conflicts.len()); assert_eq!(1, conflicts.len());
// resolve the conflict // resolve the conflict
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id, article_id: create_res.article.id,
new_text: "aaaa\n".to_string(), new_text: "aaaa\n".to_string(),
previous_version: conflicts[0].previous_version.clone(), previous_version_id: conflicts[0].previous_version_id.clone(),
resolve_conflict_id: Some(conflicts[0].id), resolve_conflict_id: Some(conflicts[0].id.clone()),
}; };
let edit_res = edit_article(data.hostname_gamma, &edit_form).await?; let edit_res = edit_article(&data.gamma.hostname, &edit_form).await?;
assert_eq!(edit_form.new_text, edit_res.text); assert_eq!(edit_form.new_text, edit_res.article.text);
assert_eq!(3, edit_res.edits.len()); assert_eq!(3, edit_res.edits.len());
let conflicts: Vec<ApubEdit> = let conflicts: Vec<ApiConflict> =
get_query(data.hostname_gamma, "edit_conflicts", None::<()>).await?; get_query(&data.gamma.hostname, "edit_conflicts", None::<()>).await?;
assert_eq!(0, conflicts.len()); assert_eq!(0, conflicts.len());
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_overlapping_edits_no_conflict() -> MyResult<()> { async fn test_overlapping_edits_no_conflict() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
// create new article // create new article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_alpha, title.clone()).await?; let create_res = create_article(&data.alpha.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
// one user edits article // one user edits article
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "my\nexample\ntext\n".to_string(), new_text: "my\nexample\ntext\n".to_string(),
previous_version: create_res.latest_version.clone(), previous_version_id: create_res.latest_version.clone(),
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_alpha, &edit_form).await?; let edit_res = edit_article(&data.alpha.hostname, &edit_form).await?;
assert_eq!(edit_res.text, edit_form.new_text); assert_eq!(edit_res.article.text, edit_form.new_text);
assert_eq!(2, edit_res.edits.len()); assert_eq!(2, edit_res.edits.len());
// another user edits article, without being aware of previous edit // another user edits article, without being aware of previous edit
let edit_form = EditArticleData { let edit_form = EditArticleData {
ap_id: create_res.ap_id.clone(), article_id: create_res.article.id,
new_text: "some\nexample\narticle\n".to_string(), new_text: "some\nexample\narticle\n".to_string(),
previous_version: create_res.latest_version, previous_version_id: create_res.latest_version,
resolve_conflict_id: None, resolve_conflict_id: None,
}; };
let edit_res = edit_article(data.hostname_alpha, &edit_form).await?; let edit_res = edit_article(&data.alpha.hostname, &edit_form).await?;
let conflicts: Vec<ApiConflict> = let conflicts: Vec<ApiConflict> =
get_query(data.hostname_alpha, "edit_conflicts", None::<()>).await?; get_query(&data.alpha.hostname, "edit_conflicts", None::<()>).await?;
assert_eq!(0, conflicts.len()); assert_eq!(0, conflicts.len());
assert_eq!(3, edit_res.edits.len()); assert_eq!(3, edit_res.edits.len());
assert_eq!("my\nexample\narticle\n", edit_res.text); assert_eq!("my\nexample\narticle\n", edit_res.article.text);
data.stop() data.stop()
} }
#[tokio::test] #[tokio::test]
#[serial]
async fn test_fork_article() -> MyResult<()> { async fn test_fork_article() -> MyResult<()> {
let data = TestData::start(); let data = TestData::start();
// create article // create article
let title = "Manu_Chao".to_string(); let title = "Manu_Chao".to_string();
let create_res = create_article(data.hostname_alpha, title.clone()).await?; let create_res = create_article(&data.alpha.hostname, title.clone()).await?;
assert_eq!(title, create_res.title); assert_eq!(title, create_res.article.title);
assert!(create_res.local); assert!(create_res.article.local);
// fetch on beta // fetch on beta
let resolve_object = ResolveObject { let resolve_object = ResolveObject {
id: create_res.ap_id.into_inner(), id: create_res.article.ap_id.into_inner(),
}; };
let resolved_article = let resolve_res: ArticleView =
get_query::<DbArticle, _>(data.hostname_beta, "resolve_article", Some(resolve_object)) get_query(&data.beta.hostname, "resolve_article", Some(resolve_object)).await?;
.await?; let resolved_article = resolve_res.article;
assert_eq!(create_res.edits.len(), resolved_article.edits.len()); assert_eq!(create_res.edits.len(), resolve_res.edits.len());
// fork the article to local instance // fork the article to local instance
let fork_form = ForkArticleData { let fork_form = ForkArticleData {
ap_id: resolved_article.ap_id.clone(), article_id: resolved_article.id,
}; };
let fork_res: DbArticle = post(data.hostname_beta, "article/fork", &fork_form).await?; let fork_res: ArticleView = post(&data.beta.hostname, "article/fork", &fork_form).await?;
assert_eq!(resolved_article.title, fork_res.title); let forked_article = fork_res.article;
assert_eq!(resolved_article.text, fork_res.text); assert_eq!(resolved_article.title, forked_article.title);
assert_eq!(resolved_article.edits, fork_res.edits); assert_eq!(resolved_article.text, forked_article.text);
assert_eq!(resolved_article.latest_version, fork_res.latest_version); assert_eq!(resolve_res.edits.len(), fork_res.edits.len());
assert_ne!(resolved_article.ap_id, fork_res.ap_id); assert_eq!(resolve_res.edits[0].diff, fork_res.edits[0].diff);
assert!(fork_res.local); assert_eq!(resolve_res.edits[0].hash, fork_res.edits[0].hash);
assert_ne!(resolve_res.edits[0].id, fork_res.edits[0].id);
assert_eq!(resolve_res.latest_version, fork_res.latest_version);
assert_ne!(resolved_article.ap_id, forked_article.ap_id);
assert!(forked_article.local);
let beta_instance: DbInstance = get(data.hostname_beta, "instance").await?; let beta_instance: InstanceView = get(&data.beta.hostname, "instance").await?;
assert_eq!(fork_res.instance, beta_instance.ap_id); assert_eq!(forked_article.instance_id, beta_instance.instance.id);
// now search returns two articles for this title (original and forked) // now search returns two articles for this title (original and forked)
let search_form = SearchArticleData { let search_form = SearchArticleData {
title: title.clone(), query: title.clone(),
}; };
let search_res: Vec<DbArticle> = let search_res: Vec<DbArticle> =
get_query(data.hostname_beta, "search", Some(search_form)).await?; get_query(&data.beta.hostname, "search", Some(search_form)).await?;
assert_eq!(2, search_res.len()); assert_eq!(2, search_res.len());
data.stop() data.stop()