// This is for db migrations that require code
-use activitypub_federation::core::signatures::generate_actor_keypair;
+use activitypub_federation::http_signatures::generate_actor_keypair;
use diesel::{
sql_types::{Nullable, Text},
ExpressionMethods,
TextExpressionMethods,
};
use diesel_async::RunQueryDsl;
-use lemmy_api_common::lemmy_db_views::structs::SiteView;
-use lemmy_apub::{
- generate_followers_url,
- generate_inbox_url,
- generate_local_apub_endpoint,
- generate_shared_inbox_url,
- generate_site_inbox_url,
- EndpointType,
+use lemmy_api_common::{
+ lemmy_db_views::structs::SiteView,
+ utils::{
+ generate_followers_url,
+ generate_inbox_url,
+ generate_local_apub_endpoint,
+ generate_shared_inbox_url,
+ generate_site_inbox_url,
+ EndpointType,
+ },
};
use lemmy_db_schema::{
source::{
use tracing::info;
use url::Url;
-pub async fn run_advanced_migrations(pool: &DbPool, settings: &Settings) -> Result<(), LemmyError> {
+pub async fn run_advanced_migrations(
+ pool: &mut DbPool<'_>,
+ settings: &Settings,
+) -> Result<(), LemmyError> {
let protocol_and_hostname = &settings.get_protocol_and_hostname();
user_updates_2020_04_02(pool, protocol_and_hostname).await?;
community_updates_2020_04_02(pool, protocol_and_hostname).await?;
}
async fn user_updates_2020_04_02(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
protocol_and_hostname: &str,
) -> Result<(), LemmyError> {
- use lemmy_db_schema::schema::person::dsl::*;
+ use lemmy_db_schema::schema::person::dsl::{actor_id, local, person};
let conn = &mut get_conn(pool).await?;
info!("Running user_updates_2020_04_02");
for cperson in &incorrect_persons {
let keypair = generate_actor_keypair()?;
- let form = PersonUpdateForm::builder()
- .actor_id(Some(generate_local_apub_endpoint(
+ let form = PersonUpdateForm {
+ actor_id: Some(generate_local_apub_endpoint(
EndpointType::Person,
&cperson.name,
protocol_and_hostname,
- )?))
- .private_key(Some(Some(keypair.private_key)))
- .public_key(Some(keypair.public_key))
- .last_refreshed_at(Some(naive_now()))
- .build();
+ )?),
+ private_key: Some(Some(keypair.private_key)),
+ public_key: Some(keypair.public_key),
+ last_refreshed_at: Some(naive_now()),
+ ..Default::default()
+ };
Person::update(pool, cperson.id, &form).await?;
}
}
async fn community_updates_2020_04_02(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
protocol_and_hostname: &str,
) -> Result<(), LemmyError> {
- use lemmy_db_schema::schema::community::dsl::*;
+ use lemmy_db_schema::schema::community::dsl::{actor_id, community, local};
let conn = &mut get_conn(pool).await?;
info!("Running community_updates_2020_04_02");
protocol_and_hostname,
)?;
- let form = CommunityUpdateForm::builder()
- .actor_id(Some(community_actor_id.to_owned()))
- .private_key(Some(Some(keypair.private_key)))
- .public_key(Some(keypair.public_key))
- .last_refreshed_at(Some(naive_now()))
- .build();
+ let form = CommunityUpdateForm {
+ actor_id: Some(community_actor_id.clone()),
+ private_key: Some(Some(keypair.private_key)),
+ public_key: Some(keypair.public_key),
+ last_refreshed_at: Some(naive_now()),
+ ..Default::default()
+ };
Community::update(pool, ccommunity.id, &form).await?;
}
}
async fn post_updates_2020_04_03(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
protocol_and_hostname: &str,
) -> Result<(), LemmyError> {
- use lemmy_db_schema::schema::post::dsl::*;
+ use lemmy_db_schema::schema::post::dsl::{ap_id, local, post};
let conn = &mut get_conn(pool).await?;
info!("Running post_updates_2020_04_03");
Post::update(
pool,
cpost.id,
- &PostUpdateForm::builder().ap_id(Some(apub_id)).build(),
+ &PostUpdateForm {
+ ap_id: Some(apub_id),
+ ..Default::default()
+ },
)
.await?;
}
}
async fn comment_updates_2020_04_03(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
protocol_and_hostname: &str,
) -> Result<(), LemmyError> {
- use lemmy_db_schema::schema::comment::dsl::*;
+ use lemmy_db_schema::schema::comment::dsl::{ap_id, comment, local};
let conn = &mut get_conn(pool).await?;
info!("Running comment_updates_2020_04_03");
Comment::update(
pool,
ccomment.id,
- &CommentUpdateForm::builder().ap_id(Some(apub_id)).build(),
+ &CommentUpdateForm {
+ ap_id: Some(apub_id),
+ ..Default::default()
+ },
)
.await?;
}
}
async fn private_message_updates_2020_05_05(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
protocol_and_hostname: &str,
) -> Result<(), LemmyError> {
- use lemmy_db_schema::schema::private_message::dsl::*;
+ use lemmy_db_schema::schema::private_message::dsl::{ap_id, local, private_message};
let conn = &mut get_conn(pool).await?;
info!("Running private_message_updates_2020_05_05");
PrivateMessage::update(
pool,
cpm.id,
- &PrivateMessageUpdateForm::builder()
- .ap_id(Some(apub_id))
- .build(),
+ &PrivateMessageUpdateForm {
+ ap_id: Some(apub_id),
+ ..Default::default()
+ },
)
.await?;
}
}
async fn post_thumbnail_url_updates_2020_07_27(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
protocol_and_hostname: &str,
) -> Result<(), LemmyError> {
- use lemmy_db_schema::schema::post::dsl::*;
+ use lemmy_db_schema::schema::post::dsl::{post, thumbnail_url};
let conn = &mut get_conn(pool).await?;
info!("Running post_thumbnail_url_updates_2020_07_27");
- let domain_prefix = format!("{}/pictrs/image/", protocol_and_hostname,);
+ let domain_prefix = format!("{protocol_and_hostname}/pictrs/image/",);
let incorrect_thumbnails = post.filter(thumbnail_url.not_like("http%"));
/// We are setting inbox and follower URLs for local and remote actors alike, because for now
/// all federated instances are also Lemmy and use the same URL scheme.
-async fn apub_columns_2021_02_02(pool: &DbPool) -> Result<(), LemmyError> {
+async fn apub_columns_2021_02_02(pool: &mut DbPool<'_>) -> Result<(), LemmyError> {
let conn = &mut get_conn(pool).await?;
info!("Running apub_columns_2021_02_02");
{
- use lemmy_db_schema::schema::person::dsl::*;
+ use lemmy_db_schema::schema::person::dsl::{inbox_url, person, shared_inbox_url};
let persons = person
.filter(inbox_url.like("http://changeme%"))
.load::<Person>(conn)
}
{
- use lemmy_db_schema::schema::community::dsl::*;
+ use lemmy_db_schema::schema::community::dsl::{
+ community,
+ followers_url,
+ inbox_url,
+ shared_inbox_url,
+ };
let communities = community
.filter(inbox_url.like("http://changeme%"))
.load::<Community>(conn)
/// Before this point, there is only a single value in the site table which refers to the local
/// Lemmy instance, so thats all we need to update.
async fn instance_actor_2022_01_28(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
protocol_and_hostname: &str,
) -> Result<(), LemmyError> {
info!("Running instance_actor_2021_09_29");
}
let key_pair = generate_actor_keypair()?;
let actor_id = Url::parse(protocol_and_hostname)?;
- let site_form = SiteUpdateForm::builder()
- .actor_id(Some(actor_id.clone().into()))
- .last_refreshed_at(Some(naive_now()))
- .inbox_url(Some(generate_site_inbox_url(&actor_id.into())?))
- .private_key(Some(Some(key_pair.private_key)))
- .public_key(Some(key_pair.public_key))
- .build();
+ let site_form = SiteUpdateForm {
+ actor_id: Some(actor_id.clone().into()),
+ last_refreshed_at: Some(naive_now()),
+ inbox_url: Some(generate_site_inbox_url(&actor_id.into())?),
+ private_key: Some(Some(key_pair.private_key)),
+ public_key: Some(key_pair.public_key),
+ ..Default::default()
+ };
Site::update(pool, site.id, &site_form).await?;
}
Ok(())
/// key field is empty, generate a new keypair. It would be possible to regenerate only the pubkey,
/// but thats more complicated and has no benefit, as federation is already broken for these actors.
/// https://github.com/LemmyNet/lemmy/issues/2347
-async fn regenerate_public_keys_2022_07_05(pool: &DbPool) -> Result<(), LemmyError> {
+async fn regenerate_public_keys_2022_07_05(pool: &mut DbPool<'_>) -> Result<(), LemmyError> {
let conn = &mut get_conn(pool).await?;
info!("Running regenerate_public_keys_2022_07_05");
{
// update communities with empty pubkey
- use lemmy_db_schema::schema::community::dsl::*;
+ use lemmy_db_schema::schema::community::dsl::{community, local, public_key};
let communities: Vec<Community> = community
.filter(local.eq(true))
.filter(public_key.eq(""))
community_.name
);
let key_pair = generate_actor_keypair()?;
- let form = CommunityUpdateForm::builder()
- .public_key(Some(key_pair.public_key))
- .private_key(Some(Some(key_pair.private_key)))
- .build();
- Community::update(pool, community_.id, &form).await?;
+ let form = CommunityUpdateForm {
+ public_key: Some(key_pair.public_key),
+ private_key: Some(Some(key_pair.private_key)),
+ ..Default::default()
+ };
+ Community::update(&mut conn.into(), community_.id, &form).await?;
}
}
{
// update persons with empty pubkey
- use lemmy_db_schema::schema::person::dsl::*;
+ use lemmy_db_schema::schema::person::dsl::{local, person, public_key};
let persons = person
.filter(local.eq(true))
.filter(public_key.eq(""))
person_.name
);
let key_pair = generate_actor_keypair()?;
- let form = PersonUpdateForm::builder()
- .public_key(Some(key_pair.public_key))
- .private_key(Some(Some(key_pair.private_key)))
- .build();
+ let form = PersonUpdateForm {
+ public_key: Some(key_pair.public_key),
+ private_key: Some(Some(key_pair.private_key)),
+ ..Default::default()
+ };
Person::update(pool, person_.id, &form).await?;
}
}
/// If a site already exists, the DB migration should generate a local_site row.
/// This will only be run for brand new sites.
async fn initialize_local_site_2022_10_10(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
settings: &Settings,
) -> Result<(), LemmyError> {
info!("Running initialize_local_site_2022_10_10");
.expect("must have domain");
// Upsert this to the instance table
- let instance = Instance::create(pool, &domain).await?;
+ let instance = Instance::read_or_create(pool, domain).await?;
if let Some(setup) = &settings.setup {
let person_keypair = generate_actor_keypair()?;
// Register the user if there's a site setup
let person_form = PersonInsertForm::builder()
- .name(setup.admin_username.to_owned())
+ .name(setup.admin_username.clone())
.admin(Some(true))
.instance_id(instance.id)
.actor_id(Some(person_actor_id.clone()))
let local_user_form = LocalUserInsertForm::builder()
.person_id(person_inserted.id)
- .password_encrypted(setup.admin_password.to_owned())
- .email(setup.admin_email.to_owned())
+ .password_encrypted(setup.admin_password.clone())
+ .email(setup.admin_email.clone())
.build();
LocalUser::create(pool, &local_user_form).await?;
};
.name(
settings
.setup
- .to_owned()
+ .clone()
.map(|s| s.site_name)
.unwrap_or_else(|| "New Site".to_string()),
)
projects / lemmy.git / blobdiff