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 e5a8caba39aa934a87e9189a934da54d517a265b..f92d261b544c9910a63cf5839aad9c6bf3bbaaa7 100644 (file)
--- a/crates/db_schema/src/impls/instance.rs
+++ b/crates/db_schema/src/impls/instance.rs
@@ -1,18 +1,26 @@
 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 diesel::{
+  dsl::{insert_into, now},
+  result::Error,
+  sql_types::{Nullable, Timestamp},
+  ExpressionMethods,
+  QueryDsl,
+};
+use diesel_async::RunQueryDsl;
 
 impl Instance {
-  pub(crate) async fn read_or_create_with_conn(
-    conn: &mut AsyncPgConnection,
-    domain_: String,
-  ) -> 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?;
+
     // First try to read the instance row and return directly if found
     let instance = instance::table
       .filter(domain.eq(&domain_))
@@ -39,25 +47,36 @@ impl Instance {
       e => e,
     }
   }
+  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
+  }
 
-  /// 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: &DbPool, domain: String) -> Result<Self, Error> {
+  pub async fn read_all(pool: &mut DbPool<'_>) -> Result<Vec<Instance>, Error> {
     let conn = &mut get_conn(pool).await?;
-    Self::read_or_create_with_conn(conn, domain).await
+    instance::table
+      .select(instance::all_columns)
+      .get_results(conn)
+      .await
   }
-  pub async fn delete(pool: &DbPool, instance_id: InstanceId) -> Result<usize, Error> {
+
+  pub async fn dead_instances(pool: &mut DbPool<'_>) -> Result<Vec<String>, Error> {
     let conn = &mut get_conn(pool).await?;
-    diesel::delete(instance::table.find(instance_id))
-      .execute(conn)
+    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: &DbPool) -> Result<usize, Error> {
+  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)
@@ -66,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)
@@ -75,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)
@@ -85,3 +108,5 @@ impl Instance {
       .await
   }
 }
+
+sql_function! { fn coalesce(x: Nullable<Timestamp>, y: Timestamp) -> Timestamp; }