Omit local instance from federated instances list (#3712)

[lemmy.git] / crates / db_schema / src / impls / instance.rs

diff --git a/crates/db_schema/src/impls/instance.rs b/crates/db_schema/src/impls/instance.rs
index 473ca007e6015d334f6de3e3644c7270ae407b7d..f92d261b544c9910a63cf5839aad9c6bf3bbaaa7 100644 (file)
--- a/crates/db_schema/src/impls/instance.rs
+++ b/crates/db_schema/src/impls/instance.rs
@@ -1,53 +1,82 @@
 use crate::{
+  diesel::dsl::IntervalDsl,
   newtypes::InstanceId,
-  schema::{federation_allowlist, federation_blocklist, instance},
+  schema::{federation_allowlist, federation_blocklist, instance, local_site, site},
   source::instance::{Instance, InstanceForm},
   utils::{get_conn, naive_now, DbPool},
 };
-use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
-use diesel_async::{AsyncPgConnection, RunQueryDsl};
-use url::Url;
+use diesel::{
+  dsl::{insert_into, now},
+  result::Error,
+  sql_types::{Nullable, Timestamp},
+  ExpressionMethods,
+  QueryDsl,
+};
+use diesel_async::RunQueryDsl;
 
 impl Instance {
-  async fn create_from_form_conn(
-    conn: &mut AsyncPgConnection,
-    form: &InstanceForm,
-  ) -> Result<Self, Error> {
-    // Do upsert on domain name conflict
-    insert_into(instance::table)
-      .values(form)
-      .on_conflict(instance::domain)
-      .do_update()
-      .set(form)
-      .get_result::<Self>(conn)
-      .await
-  }
-  pub async fn create(pool: &DbPool, domain: &str) -> Result<Self, Error> {
+  /// Attempt to read Instance column for the given domain. If it doesnt exist, insert a new one.
+  /// There is no need for update as the domain of an existing instance cant change.
+  pub async fn read_or_create(pool: &mut DbPool<'_>, domain_: String) -> Result<Self, Error> {
+    use crate::schema::instance::domain;
     let conn = &mut get_conn(pool).await?;
-    Self::create_conn(conn, domain).await
-  }
-  pub async fn create_from_actor_id(pool: &DbPool, actor_id: &Url) -> Result<Self, Error> {
-    let domain = actor_id.host_str().expect("actor id missing a domain");
-    Self::create(pool, domain).await
-  }
-  pub async fn create_conn(conn: &mut AsyncPgConnection, domain: &str) -> Result<Self, Error> {
-    let form = InstanceForm::builder()
-      .domain(domain.to_string())
-      .updated(Some(naive_now()))
-      .build();
-    Self::create_from_form_conn(conn, &form).await
+
+    // First try to read the instance row and return directly if found
+    let instance = instance::table
+      .filter(domain.eq(&domain_))
+      .first::<Self>(conn)
+      .await;
+    match instance {
+      Ok(i) => Ok(i),
+      Err(diesel::NotFound) => {
+        // Instance not in database yet, insert it
+        let form = InstanceForm::builder()
+          .domain(domain_)
+          .updated(Some(naive_now()))
+          .build();
+        insert_into(instance::table)
+          .values(&form)
+          // Necessary because this method may be called concurrently for the same domain. This
+          // could be handled with a transaction, but nested transactions arent allowed
+          .on_conflict(instance::domain)
+          .do_update()
+          .set(&form)
+          .get_result::<Self>(conn)
+          .await
+      }
+      e => e,
+    }
   }
-  pub async fn delete(pool: &DbPool, instance_id: InstanceId) -> Result<usize, Error> {
+  pub async fn delete(pool: &mut DbPool<'_>, instance_id: InstanceId) -> Result<usize, Error> {
     let conn = &mut get_conn(pool).await?;
     diesel::delete(instance::table.find(instance_id))
       .execute(conn)
       .await
   }
-  pub async fn delete_all(pool: &DbPool) -> Result<usize, Error> {
+
+  pub async fn read_all(pool: &mut DbPool<'_>) -> Result<Vec<Instance>, Error> {
+    let conn = &mut get_conn(pool).await?;
+    instance::table
+      .select(instance::all_columns)
+      .get_results(conn)
+      .await
+  }
+
+  pub async fn dead_instances(pool: &mut DbPool<'_>) -> Result<Vec<String>, Error> {
+    let conn = &mut get_conn(pool).await?;
+    instance::table
+      .select(instance::domain)
+      .filter(coalesce(instance::updated, instance::published).lt(now - 3.days()))
+      .get_results(conn)
+      .await
+  }
+
+  #[cfg(test)]
+  pub async fn delete_all(pool: &mut DbPool<'_>) -> Result<usize, Error> {
     let conn = &mut get_conn(pool).await?;
     diesel::delete(instance::table).execute(conn).await
   }
-  pub async fn allowlist(pool: &DbPool) -> Result<Vec<Self>, Error> {
+  pub async fn allowlist(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
     let conn = &mut get_conn(pool).await?;
     instance::table
       .inner_join(federation_allowlist::table)
@@ -56,7 +85,7 @@ impl Instance {
       .await
   }
 
-  pub async fn blocklist(pool: &DbPool) -> Result<Vec<Self>, Error> {
+  pub async fn blocklist(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
     let conn = &mut get_conn(pool).await?;
     instance::table
       .inner_join(federation_blocklist::table)
@@ -65,9 +94,13 @@ impl Instance {
       .await
   }
 
-  pub async fn linked(pool: &DbPool) -> Result<Vec<Self>, Error> {
+  pub async fn linked(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
     let conn = &mut get_conn(pool).await?;
     instance::table
+      // omit instance representing the local site
+      .left_join(site::table.inner_join(local_site::table))
+      .filter(local_site::id.is_null())
+      // omit instances in the blocklist
       .left_join(federation_blocklist::table)
       .filter(federation_blocklist::id.is_null())
       .select(instance::all_columns)
@@ -75,3 +108,5 @@ impl Instance {
       .await
   }
 }
+
+sql_function! { fn coalesce(x: Nullable<Timestamp>, y: Timestamp) -> Timestamp; }