684 lines
22 KiB
Ruby
684 lines
22 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require_dependency "db_helper"
|
|
|
|
module BackupRestore
|
|
|
|
class RestoreDisabledError < RuntimeError; end
|
|
class FilenameMissingError < RuntimeError; end
|
|
|
|
class Restorer
|
|
attr_reader :success
|
|
|
|
def self.pg_produces_portable_dump?(version)
|
|
# anything pg 11 or above will produce a non-portable dump
|
|
return false if version.to_i >= 11
|
|
|
|
# below 11, the behaviour was changed in multiple different minor
|
|
# versions depending on major release line - we list those versions below
|
|
gem_version = Gem::Version.new(version)
|
|
|
|
%w{
|
|
10.3
|
|
9.6.8
|
|
9.5.12
|
|
9.4.17
|
|
9.3.22
|
|
}.each do |unportable_version|
|
|
return false if Gem::Dependency.new("", "~> #{unportable_version}").match?("", gem_version)
|
|
end
|
|
|
|
true
|
|
end
|
|
|
|
def initialize(user_id, opts = {})
|
|
@user_id = user_id
|
|
@client_id = opts[:client_id]
|
|
@filename = opts[:filename]
|
|
@publish_to_message_bus = opts[:publish_to_message_bus] || false
|
|
@disable_emails = opts.fetch(:disable_emails, true)
|
|
|
|
ensure_restore_is_enabled
|
|
ensure_no_operation_is_running
|
|
ensure_we_have_a_user
|
|
ensure_we_have_a_filename
|
|
|
|
initialize_state
|
|
end
|
|
|
|
def run
|
|
log "[STARTED]"
|
|
log "'#{@user_info[:username]}' has started the restore!"
|
|
|
|
mark_restore_as_running
|
|
|
|
listen_for_shutdown_signal
|
|
|
|
ensure_directory_exists(@tmp_directory)
|
|
|
|
copy_archive_to_tmp_directory
|
|
decompress_archive
|
|
|
|
extract_metadata
|
|
validate_metadata
|
|
|
|
extract_dump
|
|
create_missing_discourse_functions
|
|
|
|
if !can_restore_into_different_schema?
|
|
log "Cannot restore into different schema, restoring in-place"
|
|
enable_readonly_mode
|
|
pause_sidekiq
|
|
wait_for_sidekiq
|
|
BackupRestore.move_tables_between_schemas("public", "backup")
|
|
@db_was_changed = true
|
|
restore_dump
|
|
else
|
|
log "Restoring into 'backup' schema"
|
|
restore_dump
|
|
enable_readonly_mode
|
|
pause_sidekiq
|
|
wait_for_sidekiq
|
|
switch_schema!
|
|
end
|
|
|
|
migrate_database
|
|
reconnect_database
|
|
reload_site_settings
|
|
clear_emoji_cache
|
|
disable_readonly_mode
|
|
clear_theme_cache
|
|
|
|
extract_uploads
|
|
|
|
after_restore_hook
|
|
rescue Compression::Strategy::ExtractFailed
|
|
log "The uncompressed file is too big. Consider increasing the decompressed_theme_max_file_size_mb hidden setting."
|
|
rollback
|
|
rescue SystemExit
|
|
log "Restore process was cancelled!"
|
|
rollback
|
|
rescue => ex
|
|
log "EXCEPTION: " + ex.message
|
|
log ex.backtrace.join("\n")
|
|
rollback
|
|
else
|
|
@success = true
|
|
ensure
|
|
clean_up
|
|
notify_user
|
|
log "Finished!"
|
|
|
|
@success ? log("[SUCCESS]") : log("[FAILED]")
|
|
end
|
|
|
|
### The methods listed below are public just for testing purposes.
|
|
### This is not a good practice, but we need to be sure that our new compression API will work.
|
|
|
|
attr_reader :tmp_directory
|
|
|
|
def ensure_directory_exists(directory)
|
|
log "Making sure #{directory} exists..."
|
|
FileUtils.mkdir_p(directory)
|
|
end
|
|
|
|
def copy_archive_to_tmp_directory
|
|
if @store.remote?
|
|
log "Downloading archive to tmp directory..."
|
|
failure_message = "Failed to download archive to tmp directory."
|
|
else
|
|
log "Copying archive to tmp directory..."
|
|
failure_message = "Failed to copy archive to tmp directory."
|
|
end
|
|
|
|
@store.download_file(@filename, @archive_filename, failure_message)
|
|
end
|
|
|
|
def decompress_archive
|
|
return unless @is_archive
|
|
|
|
log "Unzipping archive, this may take a while..."
|
|
|
|
pipeline = Compression::Pipeline.new([Compression::Tar.new, Compression::Gzip.new])
|
|
|
|
unzipped_path = pipeline.decompress(@tmp_directory, @archive_filename, available_size)
|
|
pipeline.strip_directory(unzipped_path, @tmp_directory)
|
|
end
|
|
|
|
def extract_metadata
|
|
metadata_path = File.join(@tmp_directory, BackupRestore::METADATA_FILE)
|
|
@metadata = if File.exists?(metadata_path)
|
|
data = Oj.load_file(@meta_filename)
|
|
raise "Failed to load metadata file." if !data
|
|
data
|
|
else
|
|
log "No metadata file to extract."
|
|
if @filename =~ /-#{BackupRestore::VERSION_PREFIX}(\d{14})/
|
|
{ "version" => Regexp.last_match[1].to_i }
|
|
else
|
|
raise "Migration version is missing from the filename."
|
|
end
|
|
end
|
|
end
|
|
|
|
def extract_dump
|
|
@dump_filename =
|
|
if @is_archive
|
|
# For backwards compatibility
|
|
old_dump_path = File.join(@tmp_directory, BackupRestore::OLD_DUMP_FILE)
|
|
File.exists?(old_dump_path) ? old_dump_path : File.join(@tmp_directory, BackupRestore::DUMP_FILE)
|
|
else
|
|
File.join(@tmp_directory, @filename)
|
|
end
|
|
|
|
log "Extracting dump file..."
|
|
|
|
Compression::Gzip.new.decompress(@tmp_directory, @dump_filename, available_size)
|
|
end
|
|
|
|
protected
|
|
|
|
def available_size
|
|
SiteSetting.decompressed_backup_max_file_size_mb
|
|
end
|
|
|
|
def ensure_restore_is_enabled
|
|
raise BackupRestore::RestoreDisabledError unless Rails.env.development? || SiteSetting.allow_restore?
|
|
end
|
|
|
|
def ensure_no_operation_is_running
|
|
raise BackupRestore::OperationRunningError if BackupRestore.is_operation_running?
|
|
end
|
|
|
|
def ensure_we_have_a_user
|
|
user = User.find_by(id: @user_id)
|
|
raise Discourse::InvalidParameters.new(:user_id) unless user
|
|
# keep some user data around to check them against the newly restored database
|
|
@user_info = { id: user.id, username: user.username, email: user.email }
|
|
end
|
|
|
|
def ensure_we_have_a_filename
|
|
raise BackupRestore::FilenameMissingError if @filename.nil?
|
|
end
|
|
|
|
def initialize_state
|
|
@success = false
|
|
@store = BackupRestore::BackupStore.create
|
|
@db_was_changed = false
|
|
@current_db = RailsMultisite::ConnectionManagement.current_db
|
|
@current_version = BackupRestore.current_version
|
|
@timestamp = Time.now.strftime("%Y-%m-%d-%H%M%S")
|
|
@tmp_directory = File.join(Rails.root, "tmp", "restores", @current_db, @timestamp)
|
|
@archive_filename = File.join(@tmp_directory, @filename)
|
|
@tar_filename = @archive_filename[0...-3]
|
|
@is_archive = !(@filename =~ /.sql.gz$/)
|
|
|
|
@logs = []
|
|
@readonly_mode_was_enabled = Discourse.readonly_mode?
|
|
@created_functions_for_table_columns = []
|
|
end
|
|
|
|
def listen_for_shutdown_signal
|
|
Thread.new do
|
|
while BackupRestore.is_operation_running?
|
|
exit if BackupRestore.should_shutdown?
|
|
sleep 0.1
|
|
end
|
|
end
|
|
end
|
|
|
|
def mark_restore_as_running
|
|
log "Marking restore as running..."
|
|
BackupRestore.mark_as_running!
|
|
end
|
|
|
|
def enable_readonly_mode
|
|
return if @readonly_mode_was_enabled
|
|
log "Enabling readonly mode..."
|
|
Discourse.enable_readonly_mode
|
|
end
|
|
|
|
def pause_sidekiq
|
|
log "Pausing sidekiq..."
|
|
Sidekiq.pause!
|
|
end
|
|
|
|
def wait_for_sidekiq
|
|
log "Waiting for sidekiq to finish running jobs..."
|
|
iterations = 1
|
|
while sidekiq_has_running_jobs?
|
|
log "Waiting for sidekiq to finish running jobs... ##{iterations}"
|
|
sleep 5
|
|
iterations += 1
|
|
raise "Sidekiq did not finish running all the jobs in the allowed time!" if iterations > 6
|
|
end
|
|
end
|
|
|
|
def sidekiq_has_running_jobs?
|
|
Sidekiq::Workers.new.each do |_, _, worker|
|
|
payload = worker.try(:payload)
|
|
return true if payload.try(:all_sites)
|
|
return true if payload.try(:current_site_id) == @current_db
|
|
end
|
|
|
|
false
|
|
end
|
|
|
|
def validate_metadata
|
|
log "Validating metadata..."
|
|
log " Current version: #{@current_version}"
|
|
|
|
raise "Metadata has not been extracted correctly." if !@metadata
|
|
|
|
log " Restored version: #{@metadata["version"]}"
|
|
|
|
error = "You're trying to restore a more recent version of the schema. You should migrate first!"
|
|
raise error if @metadata["version"] > @current_version
|
|
end
|
|
|
|
def get_dumped_by_version
|
|
output = Discourse::Utils.execute_command(
|
|
File.extname(@dump_filename) == '.gz' ? 'zgrep' : 'grep',
|
|
'-m1', @dump_filename, '-e', "-- Dumped by pg_dump version",
|
|
failure_message: "Failed to check version of pg_dump used to generate the dump file"
|
|
)
|
|
|
|
output.match(/version (\d+(\.\d+)+)/)[1]
|
|
end
|
|
|
|
def can_restore_into_different_schema?
|
|
self.class.pg_produces_portable_dump?(get_dumped_by_version)
|
|
end
|
|
|
|
def restore_dump_command
|
|
if File.extname(@dump_filename) == '.gz'
|
|
"#{sed_command} #{@dump_filename.gsub('.gz', '')} | #{psql_command} 2>&1"
|
|
else
|
|
"#{psql_command} 2>&1 < #{@dump_filename}"
|
|
end
|
|
end
|
|
|
|
def restore_dump
|
|
log "Restoring dump file... (can be quite long)"
|
|
|
|
logs = Queue.new
|
|
psql_running = true
|
|
has_error = false
|
|
|
|
Thread.new do
|
|
RailsMultisite::ConnectionManagement::establish_connection(db: @current_db)
|
|
while psql_running
|
|
message = logs.pop.strip
|
|
has_error ||= (message =~ /ERROR:/)
|
|
log(message) unless message.blank?
|
|
end
|
|
end
|
|
|
|
IO.popen(restore_dump_command) do |pipe|
|
|
begin
|
|
while line = pipe.readline
|
|
logs << line
|
|
end
|
|
rescue EOFError
|
|
# finished reading...
|
|
ensure
|
|
psql_running = false
|
|
logs << ""
|
|
end
|
|
end
|
|
|
|
# psql does not return a valid exit code when an error happens
|
|
raise "psql failed" if has_error
|
|
end
|
|
|
|
def psql_command
|
|
db_conf = BackupRestore.database_configuration
|
|
|
|
password_argument = "PGPASSWORD='#{db_conf.password}'" if db_conf.password.present?
|
|
host_argument = "--host=#{db_conf.host}" if db_conf.host.present?
|
|
port_argument = "--port=#{db_conf.port}" if db_conf.port.present?
|
|
username_argument = "--username=#{db_conf.username}" if db_conf.username.present?
|
|
|
|
[ password_argument, # pass the password to psql (if any)
|
|
"psql", # the psql command
|
|
"--dbname='#{db_conf.database}'", # connect to database *dbname*
|
|
"--single-transaction", # all or nothing (also runs COPY commands faster)
|
|
host_argument, # the hostname to connect to (if any)
|
|
port_argument, # the port to connect to (if any)
|
|
username_argument # the username to connect as (if any)
|
|
].join(" ")
|
|
end
|
|
|
|
def sed_command
|
|
# in order to limit the downtime when restoring as much as possible
|
|
# we force the restoration to happen in the "restore" schema
|
|
|
|
# during the restoration, this make sure we
|
|
# - drop the "restore" schema if it exists
|
|
# - create the "restore" schema
|
|
# - prepend the "restore" schema into the search_path
|
|
|
|
regexp = "SET search_path = public, pg_catalog;"
|
|
|
|
replacement = [ "DROP SCHEMA IF EXISTS restore CASCADE;",
|
|
"CREATE SCHEMA restore;",
|
|
"SET search_path = restore, public, pg_catalog;",
|
|
].join(" ")
|
|
|
|
# we only want to replace the VERY first occurence of the search_path command
|
|
expression = "1,/^#{regexp}$/s/#{regexp}/#{replacement}/"
|
|
|
|
"sed -e '#{expression}'"
|
|
end
|
|
|
|
def switch_schema!
|
|
log "Switching schemas... try reloading the site in 5 minutes, if successful, then reboot and restore is complete."
|
|
|
|
sql = [
|
|
"BEGIN;",
|
|
BackupRestore.move_tables_between_schemas_sql("public", "backup"),
|
|
BackupRestore.move_tables_between_schemas_sql("restore", "public"),
|
|
"COMMIT;"
|
|
].join("\n")
|
|
|
|
@db_was_changed = true
|
|
|
|
DB.exec(sql)
|
|
end
|
|
|
|
def migrate_database
|
|
log "Migrating the database..."
|
|
|
|
if Discourse.skip_post_deployment_migrations?
|
|
ENV["SKIP_POST_DEPLOYMENT_MIGRATIONS"] = "0"
|
|
Rails.application.config.paths['db/migrate'] << Rails.root.join(
|
|
Discourse::DB_POST_MIGRATE_PATH
|
|
).to_s
|
|
end
|
|
|
|
Discourse::Application.load_tasks
|
|
ENV["VERSION"] = @current_version.to_s
|
|
DB.exec("SET search_path = public, pg_catalog;")
|
|
Rake::Task["db:migrate"].invoke
|
|
end
|
|
|
|
def reconnect_database
|
|
log "Reconnecting to the database..."
|
|
RailsMultisite::ConnectionManagement::reload if RailsMultisite::ConnectionManagement::instance
|
|
RailsMultisite::ConnectionManagement::establish_connection(db: @current_db)
|
|
end
|
|
|
|
def reload_site_settings
|
|
log "Reloading site settings..."
|
|
SiteSetting.refresh!
|
|
|
|
DiscourseEvent.trigger(:site_settings_restored)
|
|
|
|
if @disable_emails && SiteSetting.disable_emails == 'no'
|
|
log "Disabling outgoing emails for non-staff users..."
|
|
user = User.find_by_email(@user_info[:email]) || Discourse.system_user
|
|
SiteSetting.set_and_log(:disable_emails, 'non-staff', user)
|
|
end
|
|
end
|
|
|
|
def clear_emoji_cache
|
|
log "Clearing emoji cache..."
|
|
Emoji.clear_cache
|
|
end
|
|
|
|
def extract_uploads
|
|
return unless File.exists?(File.join(@tmp_directory, 'uploads'))
|
|
log "Extracting uploads..."
|
|
|
|
public_uploads_path = File.join(Rails.root, "public")
|
|
|
|
FileUtils.cd(public_uploads_path) do
|
|
FileUtils.mkdir_p("uploads")
|
|
|
|
tmp_uploads_path = Dir.glob(File.join(@tmp_directory, "uploads", "*")).first
|
|
return if tmp_uploads_path.blank?
|
|
previous_db_name = BackupMetadata.value_for("db_name") || File.basename(tmp_uploads_path)
|
|
current_db_name = RailsMultisite::ConnectionManagement.current_db
|
|
optimized_images_exist = File.exist?(File.join(tmp_uploads_path, 'optimized'))
|
|
|
|
Discourse::Utils.execute_command(
|
|
'rsync', '-avp', '--safe-links', "#{tmp_uploads_path}/", "uploads/#{current_db_name}/",
|
|
failure_message: "Failed to restore uploads."
|
|
)
|
|
|
|
remap_uploads(previous_db_name, current_db_name)
|
|
|
|
if SiteSetting.Upload.enable_s3_uploads
|
|
migrate_to_s3
|
|
remove_local_uploads(File.join(public_uploads_path, "uploads/#{current_db_name}"))
|
|
end
|
|
|
|
generate_optimized_images unless optimized_images_exist
|
|
end
|
|
end
|
|
|
|
def remap_uploads(previous_db_name, current_db_name)
|
|
log "Remapping uploads..."
|
|
|
|
was_multisite = BackupMetadata.value_for("multisite") == "t"
|
|
uploads_folder = was_multisite ? "/" : "/uploads/#{current_db_name}/"
|
|
|
|
if (old_base_url = BackupMetadata.value_for("base_url")) && old_base_url != Discourse.base_url
|
|
remap(old_base_url, Discourse.base_url)
|
|
end
|
|
|
|
current_s3_base_url = SiteSetting.Upload.enable_s3_uploads ? SiteSetting.Upload.s3_base_url : nil
|
|
if (old_s3_base_url = BackupMetadata.value_for("s3_base_url")) && old_base_url != current_s3_base_url
|
|
remap("#{old_s3_base_url}/", uploads_folder)
|
|
end
|
|
|
|
current_s3_cdn_url = SiteSetting.Upload.enable_s3_uploads ? SiteSetting.Upload.s3_cdn_url : nil
|
|
if (old_s3_cdn_url = BackupMetadata.value_for("s3_cdn_url")) && old_s3_cdn_url != current_s3_cdn_url
|
|
base_url = SiteSetting.Upload.enable_s3_uploads ? SiteSetting.Upload.s3_cdn_url : Discourse.base_url
|
|
remap("#{old_s3_cdn_url}/", UrlHelper.schemaless("#{base_url}#{uploads_folder}"))
|
|
|
|
old_host = URI.parse(old_s3_cdn_url).host
|
|
new_host = URI.parse(base_url).host
|
|
remap(old_host, new_host)
|
|
end
|
|
|
|
if (old_cdn_url = BackupMetadata.value_for("cdn_url")) && old_cdn_url != Discourse.asset_host
|
|
base_url = Discourse.asset_host || Discourse.base_url
|
|
remap("#{old_cdn_url}/", UrlHelper.schemaless("#{base_url}/"))
|
|
|
|
old_host = URI.parse(old_cdn_url).host
|
|
new_host = URI.parse(base_url).host
|
|
remap(old_host, new_host)
|
|
end
|
|
|
|
if previous_db_name != current_db_name
|
|
remap("uploads/#{previous_db_name}", "uploads/#{current_db_name}")
|
|
end
|
|
|
|
rescue => ex
|
|
log "Something went wrong while remapping uploads.", ex
|
|
end
|
|
|
|
def remap(from, to)
|
|
puts "Remapping '#{from}' to '#{to}'"
|
|
DbHelper.remap(from, to, verbose: true, excluded_tables: ["backup_metadata"])
|
|
end
|
|
|
|
def migrate_to_s3
|
|
log "Migrating uploads to S3..."
|
|
ENV["SKIP_FAILED"] = "1"
|
|
ENV["MIGRATE_TO_MULTISITE"] = "1" if Rails.configuration.multisite
|
|
Rake::Task["uploads:migrate_to_s3"].invoke
|
|
Jobs.run_later!
|
|
end
|
|
|
|
def remove_local_uploads(directory)
|
|
log "Removing local uploads directory..."
|
|
FileUtils.rm_rf(directory) if Dir[directory].present?
|
|
rescue => ex
|
|
log "Something went wrong while removing the following uploads directory: #{directory}", ex
|
|
end
|
|
|
|
def generate_optimized_images
|
|
log 'Optimizing site icons...'
|
|
DB.exec("TRUNCATE TABLE optimized_images")
|
|
SiteIconManager.ensure_optimized!
|
|
|
|
log 'Posts will be rebaked by a background job in sidekiq. You will see missing images until that has completed.'
|
|
log 'You can expedite the process by manually running "rake posts:rebake_uncooked_posts"'
|
|
|
|
DB.exec(<<~SQL)
|
|
UPDATE posts
|
|
SET baked_version = NULL
|
|
WHERE id IN (SELECT post_id FROM post_uploads)
|
|
SQL
|
|
|
|
User.where("uploaded_avatar_id IS NOT NULL").find_each do |user|
|
|
Jobs.enqueue(:create_avatar_thumbnails, upload_id: user.uploaded_avatar_id)
|
|
end
|
|
end
|
|
|
|
def rollback
|
|
log "Trying to rollback..."
|
|
if @db_was_changed && BackupRestore.can_rollback?
|
|
log "Rolling back..."
|
|
BackupRestore.move_tables_between_schemas("backup", "public")
|
|
else
|
|
log "There was no need to rollback"
|
|
end
|
|
end
|
|
|
|
def notify_user
|
|
if user = User.find_by_email(@user_info[:email])
|
|
log "Notifying '#{user.username}' of the end of the restore..."
|
|
status = @success ? :restore_succeeded : :restore_failed
|
|
|
|
SystemMessage.create_from_system_user(user, status,
|
|
logs: Discourse::Utils.pretty_logs(@logs)
|
|
)
|
|
else
|
|
log "Could not send notification to '#{@user_info[:username]}' (#{@user_info[:email]}), because the user does not exists..."
|
|
end
|
|
rescue => ex
|
|
log "Something went wrong while notifying user.", ex
|
|
end
|
|
|
|
def create_missing_discourse_functions
|
|
log "Creating missing functions in the discourse_functions schema"
|
|
|
|
all_readonly_table_columns = []
|
|
|
|
Dir[Rails.root.join(Discourse::DB_POST_MIGRATE_PATH, "*.rb")].each do |path|
|
|
require path
|
|
class_name = File.basename(path, ".rb").sub(/^\d+_/, "").camelize
|
|
migration_class = class_name.constantize
|
|
|
|
if migration_class.const_defined?(:DROPPED_TABLES)
|
|
migration_class::DROPPED_TABLES.each do |table_name|
|
|
all_readonly_table_columns << [table_name]
|
|
end
|
|
end
|
|
|
|
if migration_class.const_defined?(:DROPPED_COLUMNS)
|
|
migration_class::DROPPED_COLUMNS.each do |table_name, column_names|
|
|
column_names.each do |column_name|
|
|
all_readonly_table_columns << [table_name, column_name]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
existing_function_names = Migration::BaseDropper.existing_discourse_function_names.map { |name| "#{name}()" }
|
|
|
|
all_readonly_table_columns.each do |table_name, column_name|
|
|
function_name = Migration::BaseDropper.readonly_function_name(table_name, column_name, with_schema: false)
|
|
|
|
if !existing_function_names.include?(function_name)
|
|
Migration::BaseDropper.create_readonly_function(table_name, column_name)
|
|
@created_functions_for_table_columns << [table_name, column_name]
|
|
end
|
|
end
|
|
end
|
|
|
|
def clean_up
|
|
log "Cleaning stuff up..."
|
|
drop_created_discourse_functions
|
|
remove_tmp_directory
|
|
unpause_sidekiq
|
|
disable_readonly_mode if Discourse.readonly_mode?
|
|
mark_restore_as_not_running
|
|
end
|
|
|
|
def remove_tmp_directory
|
|
log "Removing tmp '#{@tmp_directory}' directory..."
|
|
FileUtils.rm_rf(@tmp_directory) if Dir[@tmp_directory].present?
|
|
rescue => ex
|
|
log "Something went wrong while removing the following tmp directory: #{@tmp_directory}", ex
|
|
end
|
|
|
|
def unpause_sidekiq
|
|
log "Unpausing sidekiq..."
|
|
Sidekiq.unpause!
|
|
rescue => ex
|
|
log "Something went wrong while unpausing Sidekiq.", ex
|
|
end
|
|
|
|
def clear_theme_cache
|
|
log "Clear theme cache"
|
|
ThemeField.force_recompilation!
|
|
Theme.expire_site_cache!
|
|
Stylesheet::Manager.cache.clear
|
|
end
|
|
|
|
def drop_created_discourse_functions
|
|
log "Dropping function from the discourse_functions schema"
|
|
@created_functions_for_table_columns.each do |table_name, column_name|
|
|
Migration::BaseDropper.drop_readonly_function(table_name, column_name)
|
|
end
|
|
rescue => ex
|
|
log "Something went wrong while dropping functions from the discourse_functions schema", ex
|
|
end
|
|
|
|
def disable_readonly_mode
|
|
return if @readonly_mode_was_enabled
|
|
log "Disabling readonly mode..."
|
|
Discourse.disable_readonly_mode
|
|
rescue => ex
|
|
log "Something went wrong while disabling readonly mode.", ex
|
|
end
|
|
|
|
def mark_restore_as_not_running
|
|
log "Marking restore as finished..."
|
|
BackupRestore.mark_as_not_running!
|
|
rescue => ex
|
|
log "Something went wrong while marking restore as finished.", ex
|
|
end
|
|
|
|
def after_restore_hook
|
|
log "Executing the after_restore_hook..."
|
|
DiscourseEvent.trigger(:restore_complete)
|
|
end
|
|
|
|
def log(message, ex = nil)
|
|
return if Rails.env.test?
|
|
|
|
timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
|
|
puts(message)
|
|
publish_log(message, timestamp)
|
|
save_log(message, timestamp)
|
|
Rails.logger.error("#{ex}\n" + ex.backtrace.join("\n")) if ex
|
|
end
|
|
|
|
def publish_log(message, timestamp)
|
|
return unless @publish_to_message_bus
|
|
data = { timestamp: timestamp, operation: "restore", message: message }
|
|
MessageBus.publish(BackupRestore::LOGS_CHANNEL, data, user_ids: [@user_id], client_ids: [@client_id])
|
|
end
|
|
|
|
def save_log(message, timestamp)
|
|
@logs << "[#{timestamp}] #{message}"
|
|
end
|
|
|
|
end
|
|
end
|