632 lines
23 KiB
Ruby
632 lines
23 KiB
Ruby
#!/usr/bin/env ruby
|
|
# export-user.rb
|
|
# This class can be used to generate an as-is backup of the metadata of an user.
|
|
# It can be ran against a single user or a single user ID or a list of any of both.
|
|
# See lib/tasks/user_mover.rake for usage examples.
|
|
|
|
require 'pg'
|
|
require 'redis'
|
|
require 'yaml'
|
|
require 'optparse'
|
|
require 'json'
|
|
require 'tsort'
|
|
require 'securerandom'
|
|
require 'carto/configuration'
|
|
|
|
require_relative 'config'
|
|
require_relative 'utils'
|
|
|
|
module CartoDB
|
|
module DataMover
|
|
class DumpJob
|
|
attr_reader :logger
|
|
include CartoDB::DataMover::Utils
|
|
|
|
def dump_db
|
|
# find database host for user
|
|
run_command("#{pg_dump_bin_path} #{conn_string(
|
|
CartoDB::DataMover::Config[:dbuser],
|
|
@database_host,
|
|
CartoDB::DataMover::Config[:user_dbport],
|
|
@database_name
|
|
)} #{skip_orphan_overview_tables} -Z0 -Fc -f #{@filename} --serializable-deferrable -v --quote-all-identifiers")
|
|
end
|
|
|
|
def initialize(conn, database_host, database_name, path, filename, database_schema = nil, logger = default_logger)
|
|
@conn = conn
|
|
@database_host = database_host
|
|
@database_name = database_name
|
|
@filename = filename
|
|
@database_schema = database_schema
|
|
@path = path
|
|
@logger = logger
|
|
|
|
if database_schema == nil
|
|
dump_db
|
|
else
|
|
dump_schema
|
|
end
|
|
end
|
|
|
|
def dump_schema
|
|
run_command("#{pg_dump_bin_path} #{conn_string(
|
|
CartoDB::DataMover::Config[:dbuser],
|
|
@database_host,
|
|
CartoDB::DataMover::Config[:user_dbport],
|
|
@database_name
|
|
)} #{skip_orphan_overview_tables} -f #{@path}/#{@database_schema}.schema.sql -n #{@database_schema} --verbose --no-tablespaces --quote-all-identifiers -Z 0")
|
|
end
|
|
|
|
private
|
|
|
|
def user_pg_conn
|
|
@user_pg_conn ||= PGconn.connect(host: @database_host,
|
|
user: CartoDB::DataMover::Config[:dbuser],
|
|
dbname: @database_name,
|
|
port: CartoDB::DataMover::Config[:user_dbport],
|
|
password: CartoDB::DataMover::Config[:dbpass])
|
|
end
|
|
|
|
def skip_orphan_overview_tables
|
|
orphan_overview_tables.reduce('') { |m, t| m + " -T #{t}" }
|
|
end
|
|
|
|
def orphan_overview_tables
|
|
return @orphan_overviews if @orphan_overviews
|
|
# PG12_DEPRECATED checks if the table raster_columns exsits
|
|
raster_available = user_pg_conn.exec(%{
|
|
SELECT 1
|
|
FROM pg_views
|
|
WHERE viewname = 'raster_overviews';
|
|
}).count > 0
|
|
|
|
return @orphan_overviews ||= [] unless raster_available
|
|
raster_tables = user_pg_conn.exec("SELECT DISTINCT r_table_schema, r_table_name FROM raster_columns").map {
|
|
|r| "#{r['r_table_schema']}.#{r['r_table_name']}"
|
|
}
|
|
overview_re = Regexp.new('([^\.]+)\.o_\d+_(.+)$')
|
|
@orphan_overviews = raster_tables.select do |table|
|
|
match = overview_re.match(table)
|
|
match && !raster_tables.include?("#{match.captures.first}.#{match.captures.last}")
|
|
end
|
|
@orphan_overviews ||= []
|
|
end
|
|
|
|
def pg_dump_bin_path
|
|
get_pg_dump_bin_path(@conn)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
module CartoDB
|
|
module DataMover
|
|
class TsortableHash < Hash
|
|
include TSort
|
|
alias tsort_each_node each_key
|
|
def tsort_each_child(node, &block)
|
|
fetch(node).each(&block)
|
|
end
|
|
end
|
|
class ExportJob
|
|
include Carto::Configuration
|
|
|
|
attr_reader :logger, :json_file
|
|
|
|
REDIS_KEYS = {
|
|
mapviews: {
|
|
template: "user:USERNAME:mapviews:*",
|
|
var_position: 1,
|
|
type: 'zset',
|
|
db: 5,
|
|
separator: ":"
|
|
},
|
|
map_style: {
|
|
template: "map_style|USERDB|*",
|
|
var_position: 1,
|
|
separator: '|',
|
|
db: 0,
|
|
type: 'string'
|
|
},
|
|
map_template: {
|
|
template: "map_tpl|USERNAME",
|
|
no_clone: true,
|
|
var_position: 1,
|
|
separator: '|',
|
|
db: 0,
|
|
type: 'hash'
|
|
},
|
|
table: {
|
|
template: "rails:USERDB:*",
|
|
var_position: 1,
|
|
separator: ':',
|
|
db: 0,
|
|
type: 'hash',
|
|
attributes: {
|
|
user_id: 'USERID'
|
|
}
|
|
},
|
|
limits_tiler: {
|
|
template: "limits:tiler:USERNAME",
|
|
no_clone: true,
|
|
var_position: 2,
|
|
separator: ':',
|
|
db: 5,
|
|
type: 'hash'
|
|
},
|
|
user: {
|
|
template: "rails:users:USERNAME",
|
|
no_clone: true,
|
|
var_position: 2,
|
|
separator: ':',
|
|
db: 5,
|
|
type: 'hash',
|
|
attributes: {
|
|
database_name: 'USERDB',
|
|
id: 'USERID'
|
|
}
|
|
}
|
|
}.freeze
|
|
# the next fields won't be discarded if set to NULL
|
|
TABLE_NULL_EXCEPTIONS = ['table_quota', 'public_map_quota', 'private_map_quota', 'regular_api_key_quota',
|
|
'builder_enabled', 'public_dataset_quota'].freeze
|
|
include CartoDB::DataMover::Utils
|
|
|
|
def get_user_metadata(user_id)
|
|
q = pg_conn.exec("SELECT * FROM users WHERE username = '#{user_id}'")
|
|
if q.count > 0
|
|
user_data = q[0]
|
|
else
|
|
raise "Can't find user #{@user_id}"
|
|
end
|
|
user_data
|
|
end
|
|
|
|
def get_org_metadata(organization_id)
|
|
q = pg_conn.exec("SELECT * FROM organizations WHERE name = '#{organization_id}'")
|
|
if q.count > 0
|
|
org_data = q[0]
|
|
else
|
|
raise "Can't find organization #{@organization_id}"
|
|
end
|
|
|
|
org_data
|
|
end
|
|
|
|
def get_org_users(organization_id)
|
|
# owners have to be in the last position to prevent errors
|
|
q = pg_conn.exec(%{
|
|
SELECT u.* FROM users u INNER JOIN organizations o
|
|
ON u.organization_id = o.id
|
|
WHERE o.id = '#{organization_id}'
|
|
ORDER BY (CASE WHEN u.id = o.owner_id THEN 1 ELSE 0 END) ASC;
|
|
})
|
|
if q.count > 0
|
|
return q
|
|
else
|
|
raise "Can't find organization #{@organization_id}"
|
|
end
|
|
end
|
|
|
|
def get_org_groups(organization_id)
|
|
pg_conn.exec("SELECT * FROM groups WHERE organization_id = '#{organization_id}'")
|
|
end
|
|
|
|
def get_user_models_metadata
|
|
data = dump_related_data(Carto::User, @user_id)
|
|
data[Carto::User] = [@user_data]
|
|
data.reject! { |key, _value| [Carto::Organization, Carto::Group, Carto::FeatureFlag].include?(key) }
|
|
data
|
|
end
|
|
|
|
def dump_user_metadata
|
|
dump_sql_data(get_user_models_metadata, "user_#{@user_id}")
|
|
dump_redis_keys
|
|
end
|
|
|
|
def dump_role_grants(role)
|
|
roles = user_pg_conn.exec("SELECT oid, rolname FROM pg_roles WHERE pg_has_role( '#{role}', oid, 'member') AND rolname not similar to '(carto_role|carto_oauth_app)_%';")
|
|
roles.map { |q| q['rolname'] }.reject { |r| r == role }
|
|
end
|
|
|
|
def dump_org_metadata
|
|
data = dump_related_data(Carto::Organization, @org_id)
|
|
data[Carto::Organization] = [@org_metadata]
|
|
data.select! { |key, _value| [::Carto::Organization, ::Carto::Group].include?(key) }
|
|
dump_sql_data(data, "org_#{@org_id}")
|
|
end
|
|
|
|
def dump_sql_data(data, prefix)
|
|
# We sort the order of the tables to be exported so rows are imported before their dependencies, and deleted after.
|
|
# For this, we generate a dependency tree and then use the built-in "tsort" topological sort library
|
|
models = data.keys
|
|
model_dependencies = models.map do |m|
|
|
[m,
|
|
m.reflections.values.select(&:belongs_to?)
|
|
.reject { |r| !r.inverse_of.nil? && r.inverse_of.belongs_to? } # Remove mutual foreign_keys
|
|
.map(&:klass).select { |s| models.include?(s) }]
|
|
end
|
|
models_ordered = TsortableHash[model_dependencies].tsort
|
|
File.open(@options[:path] + "/#{prefix}_metadata.sql", "w") do |f|
|
|
models_ordered.each do |model|
|
|
data[model].each do |rows|
|
|
keys = rows.keys.select { |k| TABLE_NULL_EXCEPTIONS.include?(k.to_s) || !rows[k].nil? }
|
|
f.write generate_pg_insert_query(model.table_name, keys, rows)
|
|
end
|
|
end
|
|
end
|
|
File.open(@options[:path] + "/#{prefix}_metadata_undo.sql", "w") do |f|
|
|
models_ordered.reverse_each do |model|
|
|
data[model].each do |rows|
|
|
keys = rows.keys.select { |k| !rows[k].nil? }
|
|
f.write generate_pg_delete_query(model, rows)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def generate_pg_delete_query(model, rows)
|
|
"DELETE FROM #{model.table_name} WHERE #{model.primary_key} = '#{rows[model.primary_key]}';\n"
|
|
end
|
|
|
|
# This could be more solid by avoiding to generate SQL queries manually. There are
|
|
# two things here besides the generation itself. The need for setting the NULL word
|
|
# and escaping stuff, quoting marks, etc..
|
|
# A safer way would be selecting the affected rows in a new table and dump the table.
|
|
# That would require creating and removing extra tables
|
|
# Another approach would be using COPY with SQL query into a CSV and restore it later
|
|
def generate_pg_insert_query(table_name, keys, rows)
|
|
"INSERT INTO #{table_name}(#{keys.map { |i| "\"#{i}\"" }.join(',')}) VALUES(#{keys.map { |i| rows[i] == nil ? 'NULL' : "'" + pg_conn.escape_string(rows[i]) + "'" }.join(',')});\n"
|
|
end
|
|
|
|
def dump_related_data(model, id, exclude = [])
|
|
data = {}
|
|
id = [id] if id.is_a?(Integer) || id.is_a?(String)
|
|
|
|
# first dump this model
|
|
query = "SELECT * FROM #{model.table_name} WHERE #{model.primary_key} IN (#{id.map { |i| "'#{i}'" }.join(', ')});"
|
|
result = pg_conn.exec(query)
|
|
data[model] = (0..result.cmd_tuples - 1).map do |tuple_number|
|
|
result[tuple_number]
|
|
end
|
|
|
|
model.reflections.each do |_name, reflection|
|
|
unless exclude.include?(reflection.klass) || !reflection.through_reflection.nil?
|
|
if reflection.belongs_to?
|
|
ids = data[model].map { |t| t[reflection.association_foreign_key.to_s] }.reject { |t| t == nil }
|
|
next if ids.empty?
|
|
query = "SELECT * FROM #{reflection.table_name} WHERE #{reflection.association_primary_key} IN (#{ids.map { |i| "'#{i}'" }.join(', ')})"
|
|
else
|
|
query = "SELECT * FROM #{reflection.table_name} WHERE #{reflection.foreign_key} IN (#{id.map { |i| "'#{i}'" }.join(', ')})"
|
|
end
|
|
result = pg_conn.exec(query)
|
|
|
|
data[reflection.klass] = (0..result.cmd_tuples - 1).map do |tuple_number|
|
|
result[tuple_number]
|
|
end
|
|
|
|
ids = data[reflection.klass].map do |data_for_related_key|
|
|
data_for_related_key[reflection.klass.primary_key]
|
|
end
|
|
data.merge!(dump_related_data(reflection.klass, ids, exclude + [model])) { |_, x, y| merge_without_duplicated_ids(x, y, reflection.klass.primary_key) } if !ids.empty?
|
|
end
|
|
end
|
|
|
|
data
|
|
end
|
|
|
|
def merge_without_duplicated_ids(x, y, primary_key)
|
|
# this gets called when we try to merge >1 table.
|
|
# it will remove duplicates by ida
|
|
(x + y).uniq { |s| s[primary_key] }
|
|
end
|
|
|
|
# This is not very solid since we are definining the protocol
|
|
# It would be nice using dump/restore
|
|
def gen_redis_proto(*cmd)
|
|
proto = ""
|
|
proto << "*" + cmd.length.to_s + "\r\n"
|
|
cmd.each do |arg|
|
|
proto << "$" + arg.to_s.bytesize.to_s + "\r\n"
|
|
proto << arg.to_s + "\r\n"
|
|
end
|
|
proto
|
|
end
|
|
|
|
def format_redis_dump(str)
|
|
str.gsub("'", "\\\'")
|
|
end
|
|
|
|
def dump_redis_keys
|
|
File.open(@options[:path] + "/user_#{@user_id}_metadata.redis", "wb") do |dump|
|
|
File.open(@options[:path] + "/user_#{@user_id}_metadata_undo.redis", "wb") do |undo|
|
|
REDIS_KEYS.each do |k, v|
|
|
dump.write gen_redis_proto("SELECT", v[:db])
|
|
undo.write gen_redis_proto("SELECT", v[:db])
|
|
redis_conn.select(v[:db])
|
|
these_redis_keys = redis_conn.keys(redis_template_user_gsub(v[:template], @user_id, @username))
|
|
these_redis_keys.each do |trd|
|
|
type = redis_conn.type(trd)
|
|
if type == 'string'
|
|
dump.write gen_redis_proto("SET", trd, redis_conn.get(trd))
|
|
end
|
|
|
|
if type == 'hash'
|
|
redis_conn.hgetall(trd).each do |key, value|
|
|
dump.write gen_redis_proto("HSET", trd, key, value)
|
|
end
|
|
end
|
|
|
|
if type == 'zset'
|
|
r = redis_conn.zrangebyscore(trd, '-inf', '+inf')
|
|
r.each do |r_key|
|
|
k = redis_conn.zscore(trd, r_key)
|
|
dump.write gen_redis_proto("ZINCRBY", trd, k, r_key)
|
|
end
|
|
end
|
|
undo.write gen_redis_proto("DEL", trd)
|
|
end
|
|
end
|
|
dump.write redis_oauth_keys
|
|
end
|
|
end
|
|
end
|
|
|
|
def redis_oauth_keys
|
|
dump = ""
|
|
pg_conn.exec("SELECT token,user_id FROM oauth_tokens WHERE type='AccessToken' AND user_id = '#{@user_id}'") do |result|
|
|
dump += gen_redis_proto("SELECT", 3)
|
|
redis_conn.select(3)
|
|
result.each do |row|
|
|
redis_conn.hgetall("rails:oauth_access_tokens:#{row['token']}").each do |key, value|
|
|
dump += gen_redis_proto("HSET", "rails:oauth_access_tokens:#{row['token']}", key, value)
|
|
end
|
|
end
|
|
end
|
|
dump
|
|
end
|
|
|
|
def redis_replace_from_template(template, id)
|
|
if template.include?('USERDB')
|
|
user_database(id)
|
|
elsif template.include?('DBUSER')
|
|
database_username(id)
|
|
elsif template.include?('USERNAME')
|
|
@username
|
|
elsif template.include?('USERID')
|
|
id
|
|
else
|
|
''
|
|
end
|
|
end
|
|
|
|
def redis_template_user_gsub(template, id, _username)
|
|
replacement = redis_replace_from_template(template, id)
|
|
if template.include?('USERDB')
|
|
template.gsub('USERDB', replacement)
|
|
elsif template.include?('DBUSER')
|
|
template.gsub('DBUSER', replacement)
|
|
elsif template.include?('USERNAME')
|
|
template.gsub('USERNAME', replacement)
|
|
else
|
|
''
|
|
end
|
|
end
|
|
|
|
def alter_redis_hash(redis_key, _redis_attribute, redis_value, options = {})
|
|
redis_db = options['db'].nil? ? 0 : options['db']
|
|
redis_conn.select(redis_db)
|
|
redis_conn.hset(redis_key, @user_id, redis_value)
|
|
end
|
|
|
|
def redis_conn
|
|
@redis ||= Redis.new(host: CartoDB::DataMover::Config[:redis_host], port: CartoDB::DataMover::Config[:redis_port])
|
|
end
|
|
|
|
def pg_conn
|
|
@conn ||= PGconn.connect(host: CartoDB::DataMover::Config[:dbhost],
|
|
user: CartoDB::DataMover::Config[:dbuser],
|
|
dbname: CartoDB::DataMover::Config[:dbname],
|
|
port: CartoDB::DataMover::Config[:dbport],
|
|
password: CartoDB::DataMover::Config[:dbpass])
|
|
end
|
|
|
|
def user_pg_conn
|
|
@user_conn ||= PGconn.connect(host: @database_host,
|
|
user: CartoDB::DataMover::Config[:dbuser],
|
|
dbname: @database_name,
|
|
port: CartoDB::DataMover::Config[:user_dbport],
|
|
password: CartoDB::DataMover::Config[:dbpass])
|
|
end
|
|
|
|
def run_command(cmd)
|
|
p cmd
|
|
IO.popen(cmd) do |io|
|
|
Process.wait(io.pid)
|
|
end
|
|
puts "Output code: #{$?}"
|
|
end
|
|
|
|
def user_roles
|
|
roles = if @user_data['database_schema'] == 'public'
|
|
['publicuser', database_username(@user_id)]
|
|
else
|
|
["cartodb_publicuser_#{@user_id}", database_username(@user_id)]
|
|
end
|
|
|
|
Hash[roles.map { |role| [role, dump_role_grants(role)] }]
|
|
end
|
|
|
|
def user_info
|
|
{ user: @user_data, roles: user_roles }
|
|
end
|
|
|
|
def reflections_for_model(model, skip = [], parents = [])
|
|
result = {}
|
|
parents << model.table_name.to_sym
|
|
reflections = model.reflections
|
|
related = reflections.keys.select { |r| reflections[r].through_reflection == nil && !parents.include?(reflections[r].table_name.to_sym) }
|
|
relations = {}
|
|
related.each do |reflection_name|
|
|
reflection = reflections[reflection_name]
|
|
relations[reflection.klass.table_name] = reflection.foreign_key
|
|
end
|
|
result[model.table_name] = { related: related.map { |t| reflections[t].klass.table_name }, relation_for: relations }
|
|
related.each do |rel|
|
|
unless skip.include?(reflections[rel].klass.table_name) || result.keys.include?(reflections[rel].klass.table_name)
|
|
result.merge!(reflections_for_model(reflections[rel.to_sym].klass, (skip + result.keys).uniq, parents))
|
|
end
|
|
end
|
|
result
|
|
end
|
|
|
|
def exportjob_logger
|
|
@@exportjob_logger ||= CartoDB.unformatted_logger(log_file_path("datamover.log"))
|
|
end
|
|
|
|
def get_db_size(database)
|
|
q = user_pg_conn.exec("SELECT pg_database_size('#{database}')")
|
|
if q.count > 0
|
|
size = q[0]['pg_database_size']
|
|
else
|
|
raise "Can't find db #{database}"
|
|
end
|
|
size
|
|
end
|
|
|
|
def disable_ghost_tables_event_trigger
|
|
user_pg_conn.exec("SELECT CDB_DisableGhostTablesTrigger()")
|
|
end
|
|
|
|
def enable_ghost_tables_event_trigger
|
|
user_pg_conn.exec("SELECT CDB_EnableGhostTablesTrigger()")
|
|
end
|
|
|
|
def initialize(options)
|
|
default_options = { metadata: true, data: true, split_user_schemas: true, path: '', set_banner: true }
|
|
@options = default_options.merge(options)
|
|
|
|
@start = Time.now
|
|
@logger = options[:logger] || default_logger
|
|
@@exportjob_logger = options[:export_job_logger]
|
|
|
|
job_uuid = @options[:job_uuid] || Carto::UUIDHelper.random_uuid
|
|
export_log = { job_uuid: job_uuid,
|
|
id: @options[:id] || @options[:organization_name] || nil,
|
|
type: 'export',
|
|
path: @options[:path],
|
|
start: @start,
|
|
end: nil,
|
|
elapsed_time: nil,
|
|
server: `hostname`.strip,
|
|
pid: Process.pid,
|
|
db_source: nil,
|
|
db_size: nil,
|
|
status: nil,
|
|
trace: nil
|
|
}
|
|
begin
|
|
|
|
if @options[:id]
|
|
@user_data = get_user_metadata(options[:id])
|
|
@username = @user_data["username"]
|
|
@user_id = @user_data["id"]
|
|
@database_host = @user_data['database_host']
|
|
@database_name = @user_data['database_name']
|
|
disable_ghost_tables_event_trigger
|
|
export_log[:db_source] = @database_host
|
|
export_log[:db_size] = get_db_size(@database_name)
|
|
dump_user_metadata if @options[:metadata]
|
|
redis_conn.quit
|
|
|
|
if @options[:data]
|
|
DumpJob.new(
|
|
user_pg_conn,
|
|
@user_data['database_host'] || '127.0.0.1',
|
|
@user_data['database_name'],
|
|
@options[:path],
|
|
"#{@options[:path]}/user_#{@user_id}.dump",
|
|
@options[:schema_mode] ? @user_data['database_schema'] : nil,
|
|
@logger
|
|
)
|
|
end
|
|
|
|
@json_file = "user_#{@user_id}.json"
|
|
File.open("#{@options[:path]}/#{json_file}", "w") do |f|
|
|
f.write(user_info.to_json)
|
|
end
|
|
set_user_mover_banner(@user_id) if options[:set_banner]
|
|
elsif @options[:organization_name]
|
|
@org_metadata = get_org_metadata(@options[:organization_name])
|
|
@org_id = @org_metadata['id']
|
|
@org_users = get_org_users(@org_metadata['id'])
|
|
@org_groups = get_org_groups(@org_metadata['id'])
|
|
|
|
# Ensure all users belong to the same database
|
|
database_names = @org_users.map { |u| u['database_name'] }.uniq
|
|
raise "Organization users inconsistent - there are users belonging to multiple databases" if database_names.length > 1
|
|
@database_name = database_names[0]
|
|
|
|
# Ensure all users belong to the same database host
|
|
database_hosts = @org_users.map { |u| u['database_host'] }.uniq
|
|
raise "Organization users inconsistent - there are users belonging to multiple database hosts" if database_hosts.length > 1
|
|
@database_host = database_hosts[0]
|
|
|
|
dump_org_metadata if @options[:metadata]
|
|
data = { organization: @org_metadata, users: @org_users.to_a, groups: @org_groups, split_user_schemas: @options[:split_user_schemas] }
|
|
@json_file = "org_#{@org_metadata['id']}.json"
|
|
File.open("#{@options[:path]}/#{json_file}", "w") do |f|
|
|
f.write(data.to_json)
|
|
end
|
|
|
|
export_log[:db_source] ||= @database_host
|
|
export_log[:db_size] ||= get_db_size(@database_name)
|
|
|
|
if @options[:data] && !@options[:split_user_schemas]
|
|
disable_ghost_tables_event_trigger
|
|
DumpJob.new(
|
|
user_pg_conn,
|
|
@database_host,
|
|
@database_name,
|
|
@options[:path],
|
|
"#{@options[:path]}/org_#{@org_id}.dump",
|
|
nil,
|
|
@logger
|
|
)
|
|
end
|
|
@org_users.each do |org_user|
|
|
CartoDB::DataMover::ExportJob.new(id: org_user['username'],
|
|
data: @options[:data] && @options[:split_user_schemas],
|
|
metadata: @options[:metadata],
|
|
path: @options[:path],
|
|
job_uuid: job_uuid,
|
|
from_org: true,
|
|
schema_mode: true,
|
|
logger: @logger,
|
|
export_job_logger: exportjob_logger)
|
|
end
|
|
end
|
|
rescue StandardError => e
|
|
export_log[:end] = Time.now
|
|
export_log[:elapsed_time] = (export_log[:end] - export_log[:start]).ceil
|
|
export_log[:status] = 'failure'
|
|
export_log[:trace] = e.to_s
|
|
if options[:organization_name]
|
|
@org_users.each do |org_user|
|
|
remove_user_mover_banner(org_user['id']) if options[:set_banner]
|
|
end
|
|
end
|
|
raise
|
|
else
|
|
export_log[:end] = Time.now
|
|
export_log[:elapsed_time] = (export_log[:end] - export_log[:start]).ceil
|
|
export_log[:status] = 'success'
|
|
ensure
|
|
exportjob_logger.info(export_log.to_json) unless options[:from_org]
|
|
enable_ghost_tables_event_trigger
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|