Select Git revision
migrations.rake 12.44 KiB
# frozen_string_literal: true
# rubocop:disable all
namespace :migrations do
DEFAULT_ROLES_MAP = { "admin" => "Administrator", "user" => "User" }.freeze
COMMON = {
headers: { "Content-Type" => "application/json", "Accept" => "application/json" },
batch_size: 500,
filtered_roles: %w[admin user super_admin pending denied],
filtered_user_roles: %w[super_admin pending denied]
}.freeze
desc "Migrates v2 resources to v3"
task :roles, [:provider] => :environment do |_task, args|
has_encountred_issue = 0
roles = Role.unscoped
roles = roles.where(provider: args[:provider]) if args[:provider].present?
roles = roles.select(:id, :name, :provider)
.includes(:role_permissions)
.where.not(name: COMMON[:filtered_roles])
roles.find_each(batch_size: COMMON[:batch_size]) do |r|
# RolePermissions
role_permissions_hash = r.role_permissions.pluck(:name, :value).to_h
role_permissions = {
CreateRoom: role_permissions_hash['can_create_rooms'] == "true" ? "true" : "false",
CanRecord: role_permissions_hash['can_launch_recording'] == "true" ? "true" : "false",
ManageUsers: role_permissions_hash['can_manage_users'] == "true" ? "true" : "false",
ManageRoles: role_permissions_hash['can_edit_roles'] == "true" ? "true" : "false",
# In V3, can_manage_room_recordings is split into two distinct permissions: ManageRooms and ManageRecordings
ManageRooms: role_permissions_hash['can_manage_rooms_recordings'] == "true" ? "true" : "false",
ManageRecordings: role_permissions_hash['can_manage_rooms_recordings'] == "true" ? "true" : "false",
ManageSiteSettings: role_permissions_hash['can_edit_site_settings'] == "true" ? "true" : "false"
}
params = { role: { name: r.name.capitalize,
provider: r.provider,
role_permissions: role_permissions } }
response = Net::HTTP.post(uri('roles'), payload(params), COMMON[:headers])
case response
when Net::HTTPCreated
puts green "Successfully migrated Role:"
puts cyan "ID: #{r.id}"
puts cyan "Name: #{params[:role][:name]}"
puts cyan "Provider: #{params[:role][:provider]}"
else
puts red "Unable to migrate Role:"
puts yellow "ID: #{r.id}"
puts yellow "Name: #{params[:role][:name]}"
puts yellow "Provider: #{params[:role][:provider]}"
puts red "Errors: #{JSON.parse(response.body.to_s)['errors']}"
has_encountred_issue = 1 # At least one of the migrations failed.
end
end
puts
puts green "Roles migration complete."
puts yellow "In case of an error please retry the process to resolve." unless has_encountred_issue.zero?
exit has_encountred_issue
end
task :users, [:provider, :start, :stop] => :environment do |_task, args|
start, stop = range(args)
has_encountred_issue = 0
user = User.unscoped user = user.where(provider: args[:provider]) if args[:provider].present?
user = user.select(:id, :uid, :name, :email, :social_uid, :language, :role_id, :created_at)
.includes(:role)
.where.not(roles: { name: COMMON[:filtered_user_roles] }, deleted: true)
user.find_each(start: start, finish: stop, batch_size: COMMON[:batch_size]) do |u|
role_name = infer_role_name(u.role.name)
params = { user:
{ name: u.name,
email: u.email,
external_id: u.social_uid,
provider: u.provider,
language: u.language,
role: role_name,
created_at: u.created_at } }
response = Net::HTTP.post(uri('users'), payload(params), COMMON[:headers])
case response
when Net::HTTPCreated
puts green "Successfully migrated User:"
puts cyan " UID: #{u.uid}"
puts cyan " Name: #{params[:user][:name]}"
puts cyan " Provider: #{params[:user][:provider]}"
else
puts red "Unable to migrate User:"
puts yellow "UID: #{u.uid}"
puts yellow "Name: #{params[:user][:name]}"
puts yellow "Provider: #{params[:user][:provider]}"
puts red "Errors: #{JSON.parse(response.body.to_s)['errors']}"
has_encountred_issue = 1 # At least one of the migrations failed.
end
end
puts
puts green "Users migration completed."
unless has_encountred_issue.zero?
puts yellow "In case of an error please retry the process to resolve."
puts yellow "If you have not migrated your roles, kindly run 'rake migrations:roles' first and then retry."
end
exit has_encountred_issue
end
task :rooms, [:provider, :start, :stop] => :environment do |_task, args|
start, stop = range(args)
has_encountred_issue = 0
filtered_roles_ids = Role.unscoped
filtered_roles_ids = filtered_roles_ids.where(provider: args[:provider]) if args[:provider].present?
filtered_roles_ids = filtered_roles_ids.select(:id, :name)
.where(name: COMMON[:filtered_user_roles])
.pluck(:id)
rooms = Room.unscoped
.select(:id, :uid, :name, :bbb_id, :last_session, :user_id, :room_settings)
.includes(:owner)
rooms = rooms.where('users.provider': args[:provider]) if args[:provider].present?
rooms = rooms.where.not(users: { role_id: filtered_roles_ids, deleted: true }, deleted: true)
rooms.find_each(start: start, finish: stop, batch_size: COMMON[:batch_size]) do |r|
# RoomSettings
parsed_room_settings = JSON.parse(r.room_settings)
# Returns nil if the RoomSetting value is the same as the corresponding default value in V3
room_settings = if parsed_room_settings.empty? # Bypass Home Rome room_settings which is an empty hash by default
{}
else
{
record: parsed_room_settings["recording"] == true ? "true" : "false", muteOnStart: parsed_room_settings["muteOnStart"] == true ? "true" : "false",
glAnyoneCanStart: parsed_room_settings["anyoneCanStart"] == true ? "true" : "false",
glAnyoneJoinAsModerator: parsed_room_settings["joinModerator"] == true ? "true" : "false",
guestPolicy: parsed_room_settings["requireModeratorApproval"] == true ? "ASK_MODERATOR" : "ALWAYS_ACCEPT"
}
end
shared_users_emails = r.shared_access.joins(:user).pluck(:'users.email')
params = { room: { friendly_id: r.uid,
name: r.name,
meeting_id: r.bbb_id,
last_session: r.last_session&.to_datetime,
owner_email: r.owner.email,
provider: r.owner.provider,
room_settings: room_settings,
shared_users_emails: shared_users_emails } }
response = Net::HTTP.post(uri('rooms'), payload(params), COMMON[:headers])
case response
when Net::HTTPCreated
puts green "Successfully migrated Room:"
puts cyan "UID: #{r.uid}"
puts cyan "Name: #{params[:room][:name]}"
puts cyan "Provider: #{params[:room][:provider]}"
else
puts red "Unable to migrate Room:"
puts yellow "UID: #{r.uid}"
puts yellow "Name: #{params[:room][:name]}"
puts yellow "Provider: #{params[:room][:provider]}"
puts red "Errors: #{JSON.parse(response.body.to_s)['errors']}"
has_encountred_issue = 1 # At least one of the migrations failed.
end
end
puts
puts green "Rooms migration completed."
unless has_encountred_issue.zero?
puts yellow "In case of an error please retry the process to resolve."
puts yellow "If you have not migrated your users, kindly run 'rake migrations:users' first and then retry."
end
exit has_encountred_issue
end
task :settings, [:provider] => :environment do |_task, args|
args.with_defaults(provider: "greenlight")
has_encountred_issue = 0
setting = Setting.includes(:features).find_by(provider: args[:provider])
# SiteSettings
site_settings = {
PrimaryColor: setting.get_value('Primary Color'),
PrimaryColorLight: setting.get_value('Primary Color Lighten'),
Terms: setting.get_value('Legal URL'),
PrivacyPolicy: setting.get_value('Privacy Policy URL'),
RegistrationMethod: infer_registration_method(setting.get_value('Registration Method')),
ShareRooms: setting.get_value('Shared Access'),
PreuploadPresentation: setting.get_value('Preupload Presentation'),
}.compact
# Sets Record to default_enabled in V3 if set to optional in V2
rooms_config_record_value = infer_room_config_value(setting.get_value('Room Configuration Recording'))
# RoomConfigurations
rooms_configurations = { record: rooms_config_record_value == "optional" ? "default_enabled" : rooms_config_record_value,
muteOnStart: infer_room_config_value(setting.get_value('Room Configuration Mute On Join')),
guestPolicy: infer_room_config_value(setting.get_value('Room Configuration Require Moderator')),
glAnyoneCanStart: infer_room_config_value(setting.get_value('Room Configuration Allow Any Start')),
glAnyoneJoinAsModerator: infer_room_config_value(setting.get_value('Room Configuration All Join Moderator')),
glRequireAuthentication: infer_room_config_value(setting.get_value('Room Authentication'))
}.compact
params = { settings: { provider: args[:provider], site_settings: site_settings, rooms_configurations: rooms_configurations } }
response = Net::HTTP.post(uri('settings'), payload(params), COMMON[:headers])
case response
when Net::HTTPCreated
puts green "Successfully migrated Site Settings"
puts cyan "Provider: #{args[:provider]}"
site_settings.each do |setting|
puts cyan "#{setting[0]}: #{setting[1]}"
end
puts green "Successfully migrated Rooms Configurations"
rooms_configurations.each do |rooms_config|
puts cyan "#{rooms_config[0]}: #{rooms_config[1]}"
end
else
puts red "Unable to migrate Settings"
puts red "Provider: #{args[:provider]}"
puts red "Errors: #{JSON.parse(response.body.to_s)['errors']}"
has_encountred_issue = 1 # At least one of the migrations failed.
end
puts
puts green "Settings migration completed."
puts yellow "In case of an error please retry the process to resolve." unless has_encountred_issue.zero?
exit has_encountred_issue
end
private
def encrypt_params(params)
unless ENV["V3_SECRET_KEY_BASE"].present?
raise red 'Unable to migrate: No "V3_SECRET_KEY_BASE" provided, please check your .env file.'
end
unless ENV["V3_SECRET_KEY_BASE"].size >= 32
raise red 'Unable to migrate: Provided "V3_SECRET_KEY_BASE" must be at least 32 characters in length.'
end
key = ENV["V3_SECRET_KEY_BASE"][0..31]
crypt = ActiveSupport::MessageEncryptor.new(key, cipher: 'aes-256-gcm', serializer: Marshal)
crypt.encrypt_and_sign(params, expires_in: 10.seconds)
end
def uri(path)
raise red 'Unable to migrate: No "V3_ENDPOINT" provided, please check your .env file.' unless ENV["V3_ENDPOINT"].present?
base_uri = URI(ENV["V3_ENDPOINT"])
res = URI::join(base_uri, "api/v1/migrations/#{path}.json")
res
end
def payload(params)
res = { "v2" => { "encrypted_params" => encrypt_params(params) } }
res.to_json
end
def range(args)
start = args[:start].to_i
start = 1 unless start.positive?
stop = args[:stop].to_i
stop = nil unless stop.positive?
raise red "Unable to migrate: Invalid provided range [start: #{start}, finish: #{stop}]" if stop && start > stop
[start, stop]
end
def infer_role_name(name)
DEFAULT_ROLES_MAP[name] || name.capitalize
end
# Registration Method returns "0", "1" or "2" but V3 expects "open", "invite" or "approval"
def infer_registration_method(registration_method)
case registration_method
when "1"
"invite"
when "2"
"approval"
else
"open"
end
end
def infer_room_config_value(config_val)
return nil unless config_val.present?
case config_val
when "enabled"
"true"
when "disabled"
"false"
when "true"
"true"
else
"optional"
end
end
end