mirror of
https://github.com/mastodon/mastodon.git
synced 2024-12-23 19:13:13 +01:00
54b273bf99
HTTP connections must be explicitly closed in many cases, and letting perform method close connections makes its callers less redundant and prevent them from forgetting to close connections.
824 lines
33 KiB
Ruby
824 lines
33 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'optparse'
|
|
require 'colorize'
|
|
|
|
namespace :mastodon do
|
|
desc 'Configure the instance for production use'
|
|
task :setup do
|
|
prompt = TTY::Prompt.new
|
|
env = {}
|
|
|
|
begin
|
|
prompt.say('Your instance is identified by its domain name. Changing it afterward will break things.')
|
|
env['LOCAL_DOMAIN'] = prompt.ask('Domain name:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
q.validate(/\A[a-z0-9\.\-]+\z/i)
|
|
q.messages[:valid?] = 'Invalid domain. If you intend to use unicode characters, enter punycode here'
|
|
end
|
|
|
|
prompt.say "\n"
|
|
|
|
prompt.say('Single user mode disables registrations and redirects the landing page to your public profile.')
|
|
env['SINGLE_USER_MODE'] = prompt.yes?('Do you want to enable single user mode?', default: false)
|
|
|
|
%w(SECRET_KEY_BASE OTP_SECRET).each do |key|
|
|
env[key] = SecureRandom.hex(64)
|
|
end
|
|
|
|
vapid_key = Webpush.generate_key
|
|
|
|
env['VAPID_PRIVATE_KEY'] = vapid_key.private_key
|
|
env['VAPID_PUBLIC_KEY'] = vapid_key.public_key
|
|
|
|
prompt.say "\n"
|
|
|
|
using_docker = prompt.yes?('Are you using Docker to run Mastodon?')
|
|
db_connection_works = false
|
|
|
|
prompt.say "\n"
|
|
|
|
loop do
|
|
env['DB_HOST'] = prompt.ask('PostgreSQL host:') do |q|
|
|
q.required true
|
|
q.default using_docker ? 'db' : '/var/run/postgresql'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['DB_PORT'] = prompt.ask('PostgreSQL port:') do |q|
|
|
q.required true
|
|
q.default 5432
|
|
q.convert :int
|
|
end
|
|
|
|
env['DB_NAME'] = prompt.ask('Name of PostgreSQL database:') do |q|
|
|
q.required true
|
|
q.default using_docker ? 'postgres' : 'mastodon_production'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['DB_USER'] = prompt.ask('Name of PostgreSQL user:') do |q|
|
|
q.required true
|
|
q.default using_docker ? 'postgres' : 'mastodon'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['DB_PASS'] = prompt.ask('Password of PostgreSQL user:') do |q|
|
|
q.echo false
|
|
end
|
|
|
|
# The chosen database may not exist yet. Connect to default database
|
|
# to avoid "database does not exist" error.
|
|
db_options = {
|
|
adapter: :postgresql,
|
|
database: 'postgres',
|
|
host: env['DB_HOST'],
|
|
port: env['DB_PORT'],
|
|
user: env['DB_USER'],
|
|
password: env['DB_PASS'],
|
|
}
|
|
|
|
begin
|
|
ActiveRecord::Base.establish_connection(db_options)
|
|
ActiveRecord::Base.connection
|
|
prompt.ok 'Database configuration works! 🎆'
|
|
db_connection_works = true
|
|
break
|
|
rescue StandardError => e
|
|
prompt.error 'Database connection could not be established with this configuration, try again.'
|
|
prompt.error e.message
|
|
break unless prompt.yes?('Try again?')
|
|
end
|
|
end
|
|
|
|
prompt.say "\n"
|
|
|
|
loop do
|
|
env['REDIS_HOST'] = prompt.ask('Redis host:') do |q|
|
|
q.required true
|
|
q.default using_docker ? 'redis' : 'localhost'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['REDIS_PORT'] = prompt.ask('Redis port:') do |q|
|
|
q.required true
|
|
q.default 6379
|
|
q.convert :int
|
|
end
|
|
|
|
redis_options = {
|
|
host: env['REDIS_HOST'],
|
|
port: env['REDIS_PORT'],
|
|
driver: :hiredis,
|
|
}
|
|
|
|
begin
|
|
redis = Redis.new(redis_options)
|
|
redis.ping
|
|
prompt.ok 'Redis configuration works! 🎆'
|
|
break
|
|
rescue StandardError => e
|
|
prompt.error 'Redis connection could not be established with this configuration, try again.'
|
|
prompt.error e.message
|
|
break unless prompt.yes?('Try again?')
|
|
end
|
|
end
|
|
|
|
prompt.say "\n"
|
|
|
|
if prompt.yes?('Do you want to store uploaded files on the cloud?', default: false)
|
|
case prompt.select('Provider', ['Amazon S3', 'Wasabi', 'Minio'])
|
|
when 'Amazon S3'
|
|
env['S3_ENABLED'] = 'true'
|
|
env['S3_PROTOCOL'] = 'https'
|
|
|
|
env['S3_BUCKET'] = prompt.ask('S3 bucket name:') do |q|
|
|
q.required true
|
|
q.default "files.#{env['LOCAL_DOMAIN']}"
|
|
q.modify :strip
|
|
end
|
|
|
|
env['S3_REGION'] = prompt.ask('S3 region:') do |q|
|
|
q.required true
|
|
q.default 'us-east-1'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['S3_HOSTNAME'] = prompt.ask('S3 hostname:') do |q|
|
|
q.required true
|
|
q.default 's3-us-east-1.amazonaws.com'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['AWS_ACCESS_KEY_ID'] = prompt.ask('S3 access key:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
|
|
env['AWS_SECRET_ACCESS_KEY'] = prompt.ask('S3 secret key:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
when 'Wasabi'
|
|
env['S3_ENABLED'] = 'true'
|
|
env['S3_PROTOCOL'] = 'https'
|
|
env['S3_REGION'] = 'us-east-1'
|
|
env['S3_HOSTNAME'] = 's3.wasabisys.com'
|
|
env['S3_ENDPOINT'] = 'https://s3.wasabisys.com/'
|
|
|
|
env['S3_BUCKET'] = prompt.ask('Wasabi bucket name:') do |q|
|
|
q.required true
|
|
q.default "files.#{env['LOCAL_DOMAIN']}"
|
|
q.modify :strip
|
|
end
|
|
|
|
env['AWS_ACCESS_KEY_ID'] = prompt.ask('Wasabi access key:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
|
|
env['AWS_SECRET_ACCESS_KEY'] = prompt.ask('Wasabi secret key:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
when 'Minio'
|
|
env['S3_ENABLED'] = 'true'
|
|
env['S3_PROTOCOL'] = 'https'
|
|
env['S3_REGION'] = 'us-east-1'
|
|
|
|
env['S3_ENDPOINT'] = prompt.ask('Minio endpoint URL:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
|
|
env['S3_PROTOCOL'] = env['S3_ENDPOINT'].start_with?('https') ? 'https' : 'http'
|
|
env['S3_HOSTNAME'] = env['S3_ENDPOINT'].gsub(/\Ahttps?:\/\//, '')
|
|
|
|
env['S3_BUCKET'] = prompt.ask('Minio bucket name:') do |q|
|
|
q.required true
|
|
q.default "files.#{env['LOCAL_DOMAIN']}"
|
|
q.modify :strip
|
|
end
|
|
|
|
env['AWS_ACCESS_KEY_ID'] = prompt.ask('Minio access key:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
|
|
env['AWS_SECRET_ACCESS_KEY'] = prompt.ask('Minio secret key:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
end
|
|
|
|
if prompt.yes?('Do you want to access the uploaded files from your own domain?')
|
|
env['S3_CLOUDFRONT_HOST'] = prompt.ask('Domain for uploaded files:') do |q|
|
|
q.required true
|
|
q.default "files.#{env['LOCAL_DOMAIN']}"
|
|
q.modify :strip
|
|
end
|
|
end
|
|
end
|
|
|
|
prompt.say "\n"
|
|
|
|
loop do
|
|
if prompt.yes?('Do you want to send e-mails from localhost?', default: false)
|
|
env['SMTP_SERVER'] = 'localhost'
|
|
env['SMTP_PORT'] = 25
|
|
env['SMTP_AUTH_METHOD'] = 'none'
|
|
env['SMTP_OPENSSL_VERIFY_MODE'] = 'none'
|
|
else
|
|
env['SMTP_SERVER'] = prompt.ask('SMTP server:') do |q|
|
|
q.required true
|
|
q.default 'smtp.mailgun.org'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['SMTP_PORT'] = prompt.ask('SMTP port:') do |q|
|
|
q.required true
|
|
q.default 587
|
|
q.convert :int
|
|
end
|
|
|
|
env['SMTP_LOGIN'] = prompt.ask('SMTP username:') do |q|
|
|
q.modify :strip
|
|
end
|
|
|
|
env['SMTP_PASSWORD'] = prompt.ask('SMTP password:') do |q|
|
|
q.echo false
|
|
end
|
|
|
|
env['SMTP_AUTH_METHOD'] = prompt.ask('SMTP authentication:') do |q|
|
|
q.required
|
|
q.default 'plain'
|
|
q.modify :strip
|
|
end
|
|
|
|
env['SMTP_OPENSSL_VERIFY_MODE'] = prompt.ask('SMTP OpenSSL verify mode:') do |q|
|
|
q.required
|
|
q.default 'peer'
|
|
q.modify :strip
|
|
end
|
|
end
|
|
|
|
env['SMTP_FROM_ADDRESS'] = prompt.ask('E-mail address to send e-mails "from":') do |q|
|
|
q.required true
|
|
q.default "Mastodon <notifications@#{env['LOCAL_DOMAIN']}>"
|
|
q.modify :strip
|
|
end
|
|
|
|
break unless prompt.yes?('Send a test e-mail with this configuration right now?')
|
|
|
|
send_to = prompt.ask('Send test e-mail to:', required: true)
|
|
|
|
begin
|
|
ActionMailer::Base.smtp_settings = {
|
|
:port => env['SMTP_PORT'],
|
|
:address => env['SMTP_SERVER'],
|
|
:user_name => env['SMTP_LOGIN'].presence,
|
|
:password => env['SMTP_PASSWORD'].presence,
|
|
:domain => env['LOCAL_DOMAIN'],
|
|
:authentication => env['SMTP_AUTH_METHOD'] == 'none' ? nil : env['SMTP_AUTH_METHOD'] || :plain,
|
|
:openssl_verify_mode => env['SMTP_OPENSSL_VERIFY_MODE'],
|
|
:enable_starttls_auto => true,
|
|
}
|
|
|
|
ActionMailer::Base.default_options = {
|
|
from: env['SMTP_FROM_ADDRESS'],
|
|
}
|
|
|
|
mail = ActionMailer::Base.new.mail to: send_to, subject: 'Test', body: 'Mastodon SMTP configuration works!'
|
|
mail.deliver
|
|
break
|
|
rescue StandardError => e
|
|
prompt.error 'E-mail could not be sent with this configuration, try again.'
|
|
prompt.error e.message
|
|
break unless prompt.yes?('Try again?')
|
|
end
|
|
end
|
|
|
|
prompt.say "\n"
|
|
prompt.say 'This configuration will be written to .env.production'
|
|
|
|
if prompt.yes?('Save configuration?')
|
|
cmd = TTY::Command.new(printer: :quiet)
|
|
|
|
File.write(Rails.root.join('.env.production'), "# Generated with mastodon:setup on #{Time.now.utc}\n\n" + env.each_pair.map { |key, value| "#{key}=#{value}" }.join("\n") + "\n")
|
|
|
|
if using_docker
|
|
prompt.ok 'Below is your configuration, save it to an .env.production file outside Docker:'
|
|
prompt.say "\n"
|
|
prompt.say File.read(Rails.root.join('.env.production'))
|
|
prompt.say "\n"
|
|
prompt.ok 'It is also saved within this container so you can proceed with this wizard.'
|
|
end
|
|
|
|
prompt.say "\n"
|
|
prompt.say 'Now that configuration is saved, the database schema must be loaded.'
|
|
prompt.warn 'If the database already exists, this will erase its contents.'
|
|
|
|
if prompt.yes?('Prepare the database now?')
|
|
prompt.say 'Running `RAILS_ENV=production rails db:setup` ...'
|
|
prompt.say "\n"
|
|
|
|
if cmd.run!({ RAILS_ENV: 'production', SAFETY_ASSURED: 1 }, :rails, 'db:setup').failure?
|
|
prompt.say "\n"
|
|
prompt.error 'That failed! Perhaps your configuration is not right'
|
|
else
|
|
prompt.say "\n"
|
|
prompt.ok 'Done!'
|
|
end
|
|
end
|
|
|
|
prompt.say "\n"
|
|
prompt.say 'The final step is compiling CSS/JS assets.'
|
|
prompt.say 'This may take a while and consume a lot of RAM.'
|
|
|
|
if prompt.yes?('Compile the assets now?')
|
|
prompt.say 'Running `RAILS_ENV=production rails assets:precompile` ...'
|
|
prompt.say "\n"
|
|
|
|
if cmd.run!({ RAILS_ENV: 'production' }, :rails, 'assets:precompile').failure?
|
|
prompt.say "\n"
|
|
prompt.error 'That failed! Maybe you need swap space?'
|
|
else
|
|
prompt.say "\n"
|
|
prompt.say 'Done!'
|
|
end
|
|
end
|
|
|
|
prompt.say "\n"
|
|
prompt.ok 'All done! You can now power on the Mastodon server 🐘'
|
|
prompt.say "\n"
|
|
|
|
if db_connection_works && prompt.yes?('Do you want to create an admin user straight away?')
|
|
env.each_pair do |key, value|
|
|
ENV[key] = value.to_s
|
|
end
|
|
|
|
require_relative '../../config/environment'
|
|
disable_log_stdout!
|
|
|
|
username = prompt.ask('Username:') do |q|
|
|
q.required true
|
|
q.default 'admin'
|
|
q.validate(/\A[a-z0-9_]+\z/i)
|
|
q.modify :strip
|
|
end
|
|
|
|
email = prompt.ask('E-mail:') do |q|
|
|
q.required true
|
|
q.modify :strip
|
|
end
|
|
|
|
password = SecureRandom.hex(16)
|
|
|
|
user = User.new(admin: true, email: email, password: password, confirmed_at: Time.now.utc, account_attributes: { username: username })
|
|
user.save(validate: false)
|
|
|
|
prompt.ok "You can login with the password: #{password}"
|
|
prompt.warn 'You can change your password once you login.'
|
|
end
|
|
else
|
|
prompt.warn 'Nothing saved. Bye!'
|
|
end
|
|
rescue TTY::Reader::InputInterrupt
|
|
prompt.ok 'Aborting. Bye!'
|
|
end
|
|
end
|
|
|
|
desc 'Execute daily tasks (deprecated)'
|
|
task :daily do
|
|
# No-op
|
|
# All of these tasks are now executed via sidekiq-scheduler
|
|
end
|
|
|
|
desc 'Turn a user into an admin, identified by the USERNAME environment variable'
|
|
task make_admin: :environment do
|
|
include RoutingHelper
|
|
|
|
account_username = ENV.fetch('USERNAME')
|
|
user = User.joins(:account).where(accounts: { username: account_username })
|
|
|
|
if user.present?
|
|
user.update(admin: true)
|
|
puts "Congrats! #{account_username} is now an admin. \\o/\nNavigate to #{edit_admin_settings_url} to get started"
|
|
else
|
|
puts "User could not be found; please make sure an account with the `#{account_username}` username exists."
|
|
end
|
|
end
|
|
|
|
desc 'Turn a user into a moderator, identified by the USERNAME environment variable'
|
|
task make_mod: :environment do
|
|
account_username = ENV.fetch('USERNAME')
|
|
user = User.joins(:account).where(accounts: { username: account_username })
|
|
|
|
if user.present?
|
|
user.update(moderator: true)
|
|
puts "Congrats! #{account_username} is now a moderator \\o/"
|
|
else
|
|
puts "User could not be found; please make sure an account with the `#{account_username}` username exists."
|
|
end
|
|
end
|
|
|
|
desc 'Remove admin and moderator privileges from user identified by the USERNAME environment variable'
|
|
task revoke_staff: :environment do
|
|
account_username = ENV.fetch('USERNAME')
|
|
user = User.joins(:account).where(accounts: { username: account_username })
|
|
|
|
if user.present?
|
|
user.update(moderator: false, admin: false)
|
|
puts "#{account_username} is no longer admin or moderator."
|
|
else
|
|
puts "User could not be found; please make sure an account with the `#{account_username}` username exists."
|
|
end
|
|
end
|
|
|
|
desc 'Manually confirms a user with associated user email address stored in USER_EMAIL environment variable.'
|
|
task confirm_email: :environment do
|
|
email = ENV.fetch('USER_EMAIL')
|
|
user = User.find_by(email: email)
|
|
|
|
if user
|
|
user.update(confirmed_at: Time.now.utc)
|
|
puts "#{email} confirmed"
|
|
else
|
|
abort "#{email} not found"
|
|
end
|
|
end
|
|
|
|
desc 'Add a user by providing their email, username and initial password.' \
|
|
'The user will receive a confirmation email, then they must reset their password before logging in.'
|
|
task add_user: :environment do
|
|
disable_log_stdout!
|
|
|
|
prompt = TTY::Prompt.new
|
|
|
|
begin
|
|
email = prompt.ask('E-mail:', required: true) do |q|
|
|
q.modify :strip
|
|
end
|
|
|
|
username = prompt.ask('Username:', required: true) do |q|
|
|
q.modify :strip
|
|
end
|
|
|
|
role = prompt.select('Role:', %w(user moderator admin))
|
|
|
|
if prompt.yes?('Proceed to create the user?')
|
|
user = User.new(email: email, password: SecureRandom.hex, admin: role == 'admin', moderator: role == 'moderator', account_attributes: { username: username })
|
|
|
|
if user.save
|
|
prompt.ok 'User created and confirmation mail sent to the user\'s email address.'
|
|
prompt.ok "Here is the random password generated for the user: #{user.password}"
|
|
else
|
|
prompt.warn 'User was not created because of the following errors:'
|
|
|
|
user.errors.each do |key, val|
|
|
prompt.error "#{key}: #{val}"
|
|
end
|
|
end
|
|
else
|
|
prompt.ok 'Aborting. Bye!'
|
|
end
|
|
rescue TTY::Reader::InputInterrupt
|
|
prompt.ok 'Aborting. Bye!'
|
|
end
|
|
end
|
|
|
|
namespace :media do
|
|
desc 'Removes media attachments that have not been assigned to any status for longer than a day (deprecated)'
|
|
task clear: :environment do
|
|
# No-op
|
|
# This task is now executed via sidekiq-scheduler
|
|
end
|
|
|
|
desc 'Remove media attachments attributed to silenced accounts'
|
|
task remove_silenced: :environment do
|
|
MediaAttachment.where(account: Account.silenced).find_each(&:destroy)
|
|
end
|
|
|
|
desc 'Remove cached remote media attachments that are older than NUM_DAYS. By default 7 (week)'
|
|
task remove_remote: :environment do
|
|
time_ago = ENV.fetch('NUM_DAYS') { 7 }.to_i.days.ago
|
|
|
|
MediaAttachment.where.not(remote_url: '').where.not(file_file_name: nil).where('created_at < ?', time_ago).find_each do |media|
|
|
next unless media.file.exists?
|
|
|
|
media.file.destroy
|
|
media.save
|
|
end
|
|
end
|
|
|
|
desc 'Set unknown attachment type for remote-only attachments'
|
|
task set_unknown: :environment do
|
|
puts 'Setting unknown attachment type for remote-only attachments...'
|
|
MediaAttachment.where(file_file_name: nil).where.not(type: :unknown).in_batches.update_all(type: :unknown)
|
|
puts 'Done!'
|
|
end
|
|
|
|
desc 'Redownload avatars/headers of remote users. Optionally limit to a particular domain with DOMAIN'
|
|
task redownload_avatars: :environment do
|
|
accounts = Account.remote
|
|
accounts = accounts.where(domain: ENV['DOMAIN']) if ENV['DOMAIN'].present?
|
|
|
|
accounts.find_each do |account|
|
|
begin
|
|
account.reset_avatar!
|
|
account.reset_header!
|
|
account.save
|
|
rescue Paperclip::Error
|
|
puts "Error resetting avatar and header for account #{username}@#{domain}"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
namespace :push do
|
|
desc 'Unsubscribes from PuSH updates of feeds nobody follows locally'
|
|
task clear: :environment do
|
|
Pubsubhubbub::UnsubscribeWorker.push_bulk(Account.remote.without_followers.where.not(subscription_expires_at: nil).pluck(:id))
|
|
end
|
|
|
|
desc 'Re-subscribes to soon expiring PuSH subscriptions (deprecated)'
|
|
task refresh: :environment do
|
|
# No-op
|
|
# This task is now executed via sidekiq-scheduler
|
|
end
|
|
end
|
|
|
|
namespace :feeds do
|
|
desc 'Clear timelines of inactive users (deprecated)'
|
|
task clear: :environment do
|
|
# No-op
|
|
# This task is now executed via sidekiq-scheduler
|
|
end
|
|
|
|
desc 'Clear all timelines without regenerating them'
|
|
task clear_all: :environment do
|
|
Redis.current.keys('feed:*').each { |key| Redis.current.del(key) }
|
|
end
|
|
|
|
desc 'Generates home timelines for users who logged in in the past two weeks'
|
|
task build: :environment do
|
|
User.active.includes(:account).find_each do |u|
|
|
PrecomputeFeedService.new.call(u.account)
|
|
end
|
|
end
|
|
end
|
|
|
|
namespace :emails do
|
|
desc 'Send out digest e-mails (deprecated)'
|
|
task digest: :environment do
|
|
# No-op
|
|
# This task is now executed via sidekiq-scheduler
|
|
end
|
|
end
|
|
|
|
namespace :users do
|
|
desc 'Clear out unconfirmed users (deprecated)'
|
|
task clear: :environment do
|
|
# No-op
|
|
# This task is now executed via sidekiq-scheduler
|
|
end
|
|
|
|
desc 'List e-mails of all admin users'
|
|
task admins: :environment do
|
|
puts 'Admin user emails:'
|
|
puts User.admins.map(&:email).join("\n")
|
|
end
|
|
end
|
|
|
|
namespace :settings do
|
|
desc 'Open registrations on this instance'
|
|
task open_registrations: :environment do
|
|
Setting.open_registrations = true
|
|
end
|
|
|
|
desc 'Close registrations on this instance'
|
|
task close_registrations: :environment do
|
|
Setting.open_registrations = false
|
|
end
|
|
end
|
|
|
|
namespace :webpush do
|
|
desc 'Generate VAPID key'
|
|
task generate_vapid_key: :environment do
|
|
vapid_key = Webpush.generate_key
|
|
puts "VAPID_PRIVATE_KEY=#{vapid_key.private_key}"
|
|
puts "VAPID_PUBLIC_KEY=#{vapid_key.public_key}"
|
|
end
|
|
end
|
|
|
|
namespace :maintenance do
|
|
desc 'Update counter caches'
|
|
task update_counter_caches: :environment do
|
|
puts 'Updating counter caches for accounts...'
|
|
|
|
Account.unscoped.where.not(protocol: :activitypub).select('id').find_in_batches do |batch|
|
|
Account.where(id: batch.map(&:id)).update_all('statuses_count = (select count(*) from statuses where account_id = accounts.id), followers_count = (select count(*) from follows where target_account_id = accounts.id), following_count = (select count(*) from follows where account_id = accounts.id)')
|
|
end
|
|
|
|
puts 'Updating counter caches for statuses...'
|
|
|
|
Status.unscoped.select('id').find_in_batches do |batch|
|
|
Status.where(id: batch.map(&:id)).update_all('favourites_count = (select count(*) from favourites where favourites.status_id = statuses.id), reblogs_count = (select count(*) from statuses as reblogs where reblogs.reblog_of_id = statuses.id)')
|
|
end
|
|
|
|
puts 'Done!'
|
|
end
|
|
|
|
desc 'Generate static versions of GIF avatars/headers'
|
|
task add_static_avatars: :environment do
|
|
puts 'Generating static avatars/headers for GIF ones...'
|
|
|
|
Account.unscoped.where(avatar_content_type: 'image/gif').or(Account.unscoped.where(header_content_type: 'image/gif')).find_each do |account|
|
|
begin
|
|
account.avatar.reprocess! if account.avatar_content_type == 'image/gif' && !account.avatar.exists?(:static)
|
|
account.header.reprocess! if account.header_content_type == 'image/gif' && !account.header.exists?(:static)
|
|
rescue StandardError => e
|
|
Rails.logger.error "Error while generating static avatars/headers for account #{account.id}: #{e}"
|
|
next
|
|
end
|
|
end
|
|
|
|
puts 'Done!'
|
|
end
|
|
|
|
desc 'Ensure referencial integrity'
|
|
task prepare_for_foreign_keys: :environment do
|
|
# All the deletes:
|
|
ActiveRecord::Base.connection.execute('DELETE FROM statuses USING statuses s LEFT JOIN accounts a ON a.id = s.account_id WHERE statuses.id = s.id AND a.id IS NULL')
|
|
|
|
if ActiveRecord::Base.connection.table_exists? :account_domain_blocks
|
|
ActiveRecord::Base.connection.execute('DELETE FROM account_domain_blocks USING account_domain_blocks adb LEFT JOIN accounts a ON a.id = adb.account_id WHERE account_domain_blocks.id = adb.id AND a.id IS NULL')
|
|
end
|
|
|
|
if ActiveRecord::Base.connection.table_exists? :conversation_mutes
|
|
ActiveRecord::Base.connection.execute('DELETE FROM conversation_mutes USING conversation_mutes cm LEFT JOIN accounts a ON a.id = cm.account_id WHERE conversation_mutes.id = cm.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM conversation_mutes USING conversation_mutes cm LEFT JOIN conversations c ON c.id = cm.conversation_id WHERE conversation_mutes.id = cm.id AND c.id IS NULL')
|
|
end
|
|
|
|
ActiveRecord::Base.connection.execute('DELETE FROM favourites USING favourites f LEFT JOIN accounts a ON a.id = f.account_id WHERE favourites.id = f.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM favourites USING favourites f LEFT JOIN statuses s ON s.id = f.status_id WHERE favourites.id = f.id AND s.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM blocks USING blocks b LEFT JOIN accounts a ON a.id = b.account_id WHERE blocks.id = b.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM blocks USING blocks b LEFT JOIN accounts a ON a.id = b.target_account_id WHERE blocks.id = b.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM follow_requests USING follow_requests fr LEFT JOIN accounts a ON a.id = fr.account_id WHERE follow_requests.id = fr.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM follow_requests USING follow_requests fr LEFT JOIN accounts a ON a.id = fr.target_account_id WHERE follow_requests.id = fr.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM follows USING follows f LEFT JOIN accounts a ON a.id = f.account_id WHERE follows.id = f.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM follows USING follows f LEFT JOIN accounts a ON a.id = f.target_account_id WHERE follows.id = f.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM mutes USING mutes m LEFT JOIN accounts a ON a.id = m.account_id WHERE mutes.id = m.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM mutes USING mutes m LEFT JOIN accounts a ON a.id = m.target_account_id WHERE mutes.id = m.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM imports USING imports i LEFT JOIN accounts a ON a.id = i.account_id WHERE imports.id = i.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM mentions USING mentions m LEFT JOIN accounts a ON a.id = m.account_id WHERE mentions.id = m.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM mentions USING mentions m LEFT JOIN statuses s ON s.id = m.status_id WHERE mentions.id = m.id AND s.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM notifications USING notifications n LEFT JOIN accounts a ON a.id = n.account_id WHERE notifications.id = n.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM notifications USING notifications n LEFT JOIN accounts a ON a.id = n.from_account_id WHERE notifications.id = n.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM preview_cards USING preview_cards pc LEFT JOIN statuses s ON s.id = pc.status_id WHERE preview_cards.id = pc.id AND s.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM reports USING reports r LEFT JOIN accounts a ON a.id = r.account_id WHERE reports.id = r.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM reports USING reports r LEFT JOIN accounts a ON a.id = r.target_account_id WHERE reports.id = r.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM statuses_tags USING statuses_tags st LEFT JOIN statuses s ON s.id = st.status_id WHERE statuses_tags.tag_id = st.tag_id AND statuses_tags.status_id = st.status_id AND s.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM statuses_tags USING statuses_tags st LEFT JOIN tags t ON t.id = st.tag_id WHERE statuses_tags.tag_id = st.tag_id AND statuses_tags.status_id = st.status_id AND t.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM stream_entries USING stream_entries se LEFT JOIN accounts a ON a.id = se.account_id WHERE stream_entries.id = se.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM subscriptions USING subscriptions s LEFT JOIN accounts a ON a.id = s.account_id WHERE subscriptions.id = s.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM users USING users u LEFT JOIN accounts a ON a.id = u.account_id WHERE users.id = u.id AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM web_settings USING web_settings ws LEFT JOIN users u ON u.id = ws.user_id WHERE web_settings.id = ws.id AND u.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM oauth_access_grants USING oauth_access_grants oag LEFT JOIN users u ON u.id = oag.resource_owner_id WHERE oauth_access_grants.id = oag.id AND oag.resource_owner_id IS NOT NULL AND u.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM oauth_access_grants USING oauth_access_grants oag LEFT JOIN oauth_applications a ON a.id = oag.application_id WHERE oauth_access_grants.id = oag.id AND oag.application_id IS NOT NULL AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM oauth_access_tokens USING oauth_access_tokens oat LEFT JOIN users u ON u.id = oat.resource_owner_id WHERE oauth_access_tokens.id = oat.id AND oat.resource_owner_id IS NOT NULL AND u.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('DELETE FROM oauth_access_tokens USING oauth_access_tokens oat LEFT JOIN oauth_applications a ON a.id = oat.application_id WHERE oauth_access_tokens.id = oat.id AND oat.application_id IS NOT NULL AND a.id IS NULL')
|
|
|
|
# All the nullifies:
|
|
ActiveRecord::Base.connection.execute('UPDATE statuses SET in_reply_to_id = NULL FROM statuses s LEFT JOIN statuses rs ON rs.id = s.in_reply_to_id WHERE statuses.id = s.id AND s.in_reply_to_id IS NOT NULL AND rs.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('UPDATE statuses SET in_reply_to_account_id = NULL FROM statuses s LEFT JOIN accounts a ON a.id = s.in_reply_to_account_id WHERE statuses.id = s.id AND s.in_reply_to_account_id IS NOT NULL AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('UPDATE media_attachments SET status_id = NULL FROM media_attachments ma LEFT JOIN statuses s ON s.id = ma.status_id WHERE media_attachments.id = ma.id AND ma.status_id IS NOT NULL AND s.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('UPDATE media_attachments SET account_id = NULL FROM media_attachments ma LEFT JOIN accounts a ON a.id = ma.account_id WHERE media_attachments.id = ma.id AND ma.account_id IS NOT NULL AND a.id IS NULL')
|
|
ActiveRecord::Base.connection.execute('UPDATE reports SET action_taken_by_account_id = NULL FROM reports r LEFT JOIN accounts a ON a.id = r.action_taken_by_account_id WHERE reports.id = r.id AND r.action_taken_by_account_id IS NOT NULL AND a.id IS NULL')
|
|
end
|
|
|
|
desc 'Remove deprecated preview cards'
|
|
task remove_deprecated_preview_cards: :environment do
|
|
next unless ActiveRecord::Base.connection.table_exists? 'deprecated_preview_cards'
|
|
|
|
class DeprecatedPreviewCard < ActiveRecord::Base
|
|
self.inheritance_column = false
|
|
|
|
path = '/preview_cards/:attachment/:id_partition/:style/:filename'
|
|
if ENV['S3_ENABLED'] != 'true'
|
|
path = (ENV['PAPERCLIP_ROOT_PATH'] || ':rails_root/public/system') + path
|
|
end
|
|
|
|
has_attached_file :image, styles: { original: '280x120>' }, convert_options: { all: '-quality 80 -strip' }, path: path
|
|
end
|
|
|
|
puts 'Delete records and associated files from deprecated preview cards? [y/N]: '
|
|
confirm = STDIN.gets.chomp
|
|
|
|
if confirm.casecmp('y').zero?
|
|
DeprecatedPreviewCard.in_batches.destroy_all
|
|
|
|
puts 'Drop deprecated preview cards table? [y/N]: '
|
|
confirm = STDIN.gets.chomp
|
|
|
|
if confirm.casecmp('y').zero?
|
|
ActiveRecord::Migration.drop_table :deprecated_preview_cards
|
|
end
|
|
end
|
|
end
|
|
|
|
desc 'Migrate photo preview cards made before 2.1'
|
|
task migrate_photo_preview_cards: :environment do
|
|
status_ids = Status.joins(:preview_cards)
|
|
.where(preview_cards: { embed_url: '', type: :photo })
|
|
.reorder(nil)
|
|
.group(:id)
|
|
.pluck(:id)
|
|
|
|
PreviewCard.where(embed_url: '', type: :photo).delete_all
|
|
LinkCrawlWorker.push_bulk status_ids
|
|
end
|
|
|
|
desc 'Remove all home feed regeneration markers'
|
|
task remove_regeneration_markers: :environment do
|
|
keys = Redis.current.keys('account:*:regeneration')
|
|
|
|
Redis.current.pipelined do
|
|
keys.each { |key| Redis.current.del(key) }
|
|
end
|
|
end
|
|
|
|
desc 'Check every known remote account and delete those that no longer exist in origin'
|
|
task purge_removed_accounts: :environment do
|
|
prepare_for_options!
|
|
|
|
options = {}
|
|
|
|
OptionParser.new do |opts|
|
|
opts.banner = 'Usage: rails mastodon:maintenance:purge_removed_accounts [options]'
|
|
|
|
opts.on('-f', '--force', 'Remove all encountered accounts without asking for confirmation') do
|
|
options[:force] = true
|
|
end
|
|
|
|
opts.on('-h', '--help', 'Display this message') do
|
|
puts opts
|
|
exit
|
|
end
|
|
end.parse!
|
|
|
|
disable_log_stdout!
|
|
|
|
total = Account.remote.where(protocol: :activitypub).count
|
|
progress_bar = ProgressBar.create(total: total, format: '%c/%C |%w>%i| %e')
|
|
|
|
Account.remote.where(protocol: :activitypub).partitioned.find_each do |account|
|
|
progress_bar.increment
|
|
|
|
begin
|
|
code = Request.new(:head, account.uri).perform(&:code)
|
|
rescue StandardError
|
|
# This could happen due to network timeout, DNS timeout, wrong SSL cert, etc,
|
|
# which should probably not lead to perceiving the account as deleted, so
|
|
# just skip till next time
|
|
next
|
|
end
|
|
|
|
if [404, 410].include?(code)
|
|
if options[:force]
|
|
SuspendAccountService.new.call(account)
|
|
account.destroy
|
|
else
|
|
progress_bar.pause
|
|
progress_bar.clear
|
|
print "\nIt seems like #{account.acct} no longer exists. Purge the account from the database? [Y/n]: ".colorize(:yellow)
|
|
confirm = STDIN.gets.chomp
|
|
puts ''
|
|
progress_bar.resume
|
|
|
|
if confirm.casecmp('n').zero?
|
|
next
|
|
else
|
|
SuspendAccountService.new.call(account)
|
|
account.destroy
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def disable_log_stdout!
|
|
dev_null = Logger.new('/dev/null')
|
|
|
|
Rails.logger = dev_null
|
|
ActiveRecord::Base.logger = dev_null
|
|
HttpLog.configuration.logger = dev_null
|
|
Paperclip.options[:log] = false
|
|
end
|
|
|
|
def prepare_for_options!
|
|
2.times { ARGV.shift }
|
|
end
|