zydronium/internetee-registry
1
0
Fork 0
mirror of https://github.com/internetee/registry.git synced 2025-05-17 17:59:47 +02:00
Code Issues Projects Releases Packages Wiki Activity

Story 108521790 Update how nameservers history is handled

Browse source
This commit is contained in:
Vladimir Krylov 2015-12-16 11:46:52 +02:00
parent 478e07b518
commit faa69eee1c
3 changed files with 98 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

2
app/models/legacy/dnskey_history.rb
View file

@ -43,7 +43,7 @@ module Legacy
def historical_data(old_domain, new_domain, time_attr = :valid_from)
{
whodunnit: old_domain.history_domain.user.try(:id),
whodunnit: old_domain.user.try(:id),
object: nil,
object_changes: new_object_hash(old_domain, new_domain).each_with_object({}){|(k,v), h| h[k] = [nil, v]},
created_at: [try(time_attr), old_domain.try(time_attr)].max

119
app/models/legacy/domain_history.rb
View file

@ -3,6 +3,7 @@ module Legacy
self.table_name = :domain_history
self.primary_key = :id
class_attribute :dnssecs
class_attribute :namesrvs
belongs_to :object_registry, foreign_key: :id
belongs_to :object, foreign_key: :id
@ -65,63 +66,104 @@ module Legacy
# returns imported nameserver ids
def import_nameservers_history(new_domain, time)
# #removing previous nameservers
# NameserverVersion.where("object_changes->>'legacy_domain_id' = '[nil,#{id}]'").where(event: :create).where("created_at <= ?", time).each do |nv|
# if NameserverVersion.where(item_type: nv.item_type, item_id: nv.item_id, event: :destroy).none?
# NameserverVersion.create!(
# item_type: nv.item_type,
# item_id: nv.item_id,
# event: :destroy,
# whodunnit: user.try(:id),
# object: nv.object_changes.each_with_object({}){|(k,v),hash| hash[k] = v.last },
# object_changes: {},
# created_at: time
# )
# end
# end
if (nssets = nsset_histories.at(time).to_a).any?
self.class.namesrvs ||= {}
self.class.namesrvs[id] ||= {}
ids = []
nssets.each do |nsset|
nsset_histories.at(time).to_a.each do |nsset|
nsset.host_histories.at(time).each do |host|
ips = {ipv4: [],ipv6: []}
host.host_ipaddr_map_histories.at(time).each do |ip_map|
next unless ip_map.ipaddr
host.host_ipaddr_map_histories.where.not(ipaddr: nil).at(time).each do |ip_map|
ips[:ipv4] << ip_map.ipaddr.to_s.strip if ip_map.ipaddr.ipv4?
ips[:ipv6] << ip_map.ipaddr.to_s.strip if ip_map.ipaddr.ipv6?
end
server = {
id: Nameserver.next_id,
hostname: host.fqdn.try(:strip),
ipv4: ips[:ipv4],
ipv6: ips[:ipv6],
creator_str: object_registry.try(:registrar).try(:name),
updator_str: object_history.try(:registrar).try(:name) || object_registry.try(:registrar).try(:name),
main_attrs = {
hostname: SimpleIDN.to_unicode(host.fqdn.try(:strip)),
ipv4: ips[:ipv4].sort,
ipv6: ips[:ipv6].sort,
legacy_domain_id: id,
domain_id: new_domain.id,
}
server = main_attrs.merge(
creator_str: object_registry.try(:registrar).try(:name),
updator_str: object_history.try(:registrar).try(:name) || object_registry.try(:registrar).try(:name),
created_at: nsset.object_registry.try(:crdate),
updated_at: nsset.object_registry.try(:object_history).read_attribute(:update) || nsset.object_registry.try(:crdate)
}
)
NameserverVersion.create!(
item_type: Nameserver.to_s,
item_id: server[:id],
event: :create,
if val = self.class.namesrvs[id][main_attrs]
ids << val
else # if not found we should check current dnssec and historical if changes were done
# firstly we need to select the first historical object to take the earliest from create or destroy
if version = ::NameserverVersion.where("object->>'domain_id'='#{main_attrs[:domain_id]}'").where("object->>'legacy_domain_id'='#{main_attrs[:legacy_domain_id]}'").where("object->>'hostname'='#{main_attrs[:hostname]}'").reorder("created_at ASC").first
server[:id] = version.item_id.to_i
version.item.versions.where(event: :create).first_or_create!(
whodunnit: user.try(:id),
object: nil,
object_changes: server.each_with_object({}){|(k,v), h| h[k] = [nil, v]},
created_at: time
)
if !version.ipv4.sort.eql?(main_attrs[:ipv4]) || !version.ipv6.sort.eql?(main_attrs[:ipv6])
object_changes = {}
server.stringify_keys.each{|k, v| object_changes[k] = [v, version.object[k]] if v != version.object[k] }
version.item.versions.where(event: :update).create!(
whodunnit: user.try(:id),
object: server,
object_changes: object_changes,
created_at: time
)
end
# if no historical data - try to load existing
elsif (list = ::Nameserver.where(domain_id: main_attrs[:domain_id], legacy_domain_id: main_attrs[:legacy_domain_id], hostname: main_attrs[:hostname]).to_a).any?
if new_no_version = list.detect{|e|e.versions.where(event: :create).none?} # no create version, so was created via import
server[:id] = new_no_version.id.to_i
new_no_version.versions.where(event: :create).first_or_create!(
whodunnit: user.try(:id),
object: nil,
object_changes: server.each_with_object({}){|(k,v), h| h[k] = [nil, v]},
created_at: time
)
if !new_no_version.ipv4.sort.eql?(main_attrs[:ipv4]) || !new_no_version.ipv6.sort.eql?(main_attrs[:ipv6])
object_changes = {}
server.stringify_keys.each{|k, v| object_changes[k] = [v, new_no_version.attributes[k]] if v != new_no_version.attributes[k] }
new_no_version.versions.where(event: :update).create!(
whodunnit: user.try(:id),
object: server,
object_changes: object_changes,
created_at: time
)
end
else
server[:id] = ::Nameserver.next_id
create_nameserver_history(server,time)
end
else
server[:id] = ::Nameserver.next_id
create_nameserver_history(server,time)
end
self.class.namesrvs[id][main_attrs] = server[:id]
ids << server[:id]
end
end
end
ids
else
[]
end
def create_nameserver_history server, time
::NameserverVersion.where(item_id: server[:id], item_type: ::Nameserver.to_s).where(event: :create).first_or_create!(
whodunnit: user.try(:id), object: nil, created_at: time,
object_changes: server.each_with_object({}){|(k,v), h| h[k] = [nil, v]},
)
::NameserverVersion.where(item_id: server[:id], item_type: ::Nameserver.to_s).where(event: :destroy).create!(
whodunnit: user.try(:id), object: server, created_at: Time.now + 2.days,
object_changes: {},
)
end
# returns imported dnskey ids
@ -134,7 +176,7 @@ module Legacy
if val = self.class.dnssecs[id][dns]
ids << val
else # if not found we should check current dnssec and historical if changes were done
# if current object wan't changed
# if current object wasn't changed
if item=::Dnskey.where(dns.new_object_mains(new_domain)).first
item.versions.where(event: :create).first_or_create!(dns.historical_data(self, new_domain))
self.class.dnssecs[id][dns] = item.id
@ -184,12 +226,7 @@ module Legacy
end
# def last_history_action domain_id
# sql = %Q{SELECT dh.*, h.valid_from, h.valid_to
# from domain_history dh JOIN history h ON dh.historyid=h.id
# where dh.id=#{domain_id} order by dh.historyid desc limit 1;}
# find_by_sql(sql).first
# end
end
end
end

3
lib/tasks/import_history.rake
View file

@ -128,7 +128,6 @@ namespace :import do
if (old_val = last_changes.to_h[k]) != v then changes[k] = [old_val, v] end
end
next if changes.blank? && event != :destroy
responder.import_nameservers_history(domain, time) if responder.respond_to?(:import_nameservers_history)
DomainVersion.create!(
item_type: domain.class,
@ -141,7 +140,7 @@ namespace :import do
children: {
admin_contacts: responder.history_domain.get_admin_contact_new_ids,
tech_contacts: responder.history_domain.get_tech_contact_new_ids,
nameservers: [],
nameservers: responder.history_domain.import_nameservers_history(domain, time),
dnskeys: responder.history_domain.import_dnskeys_history(domain, time),
registrant: [responder.history_domain.new_registrant_id]
}