run as "bundle exec rails r ocp_refresh_mock_data.rb"

ocp_refresh_mock_data.rb

require 'manageiq_performance'

def persister_class
  # ManageIQ::Providers::Kubernetes::Inventory::Persister::ContainerManager
  ManageIQ::Providers::Openshift::Inventory::Persister::ContainerManagerStream # just having :batch saving
end

def generate_batches_od_data(ems_name:, total_elements:, batch_size: 1000)
  ems       = ExtManagementSystem.find_by(:name => ems_name)
  persister = persister_class.new(
    ems
  )
  count     = 1

  persister, count = process_entity(
    ems,
    :container_image_registries,
    persister,
    count,
    total_elements / 10_000 + 1,
    batch_size)
  persister, count = process_entity(ems, :container_images, persister, count, total_elements, batch_size)

  # Send or update the rest which is batch smaller than the batch size
  # send_or_update(ems, :key_pair, persister, :rest, batch_size)
  send_or_update(ems, :container_images, persister, :rest, batch_size)
end

def process_entity(ems, entity_name, starting_persister, starting_count, total_elements, batch_size)
  persister = starting_persister
  count     = starting_count

  (1..total_elements).each do |index|
    send("parse_#{entity_name.to_s}", index, persister)
    persister, count = send_or_update(ems, entity_name, persister, count, batch_size)
  end

  return persister, count
end

def send_or_update(ems, entity_name, persister, count, batch_size)
  if count == :rest || count >= batch_size
    ############################ Replace by sending to kafka and use the saving code on the other side START #########
    # persister = ManagerRefresh::Inventory::Persister.from_yaml(persister.to_yaml)

    _, timings = Benchmark.realtime_block(:ems_refresh) do
      ManagerRefresh::SaveInventory.save_inventory(
        persister.manager,
        persister.inventory_collections
      )
    end

    $log.info "#{ems.id} BENCH #{timings.inspect}"
    ############################ Replace by sending to kafka and use the saving code on the other side END ###########

    # And and create new persistor so the old one with data can be GCed
    return_persister = persister_class.new(
      ems
    )
    return_count     = 1
  else
    return_persister = persister

    addition = case entity_name
               when :vm
                 2
               else
                 1
               end

    return_count = count + addition
  end

  return return_persister, return_count
end

def parse_container_image_registries(index, persister)
  image_registry = persister.container_image_registries.build(
    :name => "name_#{index}",
    :host => "host_#{index}",
    :port => "443",
  )
end

def parse_container_images(index, persister)
  container_image = persister.container_images.build(
    :container_image_registry => persister.container_image_registries.lazy_find("host_#{index % 10_000}__443"),
    :name                     => "name_#{index}",
    :image_ref                => "container_image_ref_#{index}",
    :command                  => ["/opt/cpm/bin/start.sh"],
    :environment_variables    => {
      :var1 => "val1",
      :var2 => "val2"
    }
  )
  parse_labels(index, persister, container_image)
end

def parse_labels(index, persister, container_image)
  label_persister = persister.collections[[:custom_attributes_for, "ContainerImage", "labels"]]

  (1..20).each do |secondary_index|
    label_persister.build(
      :resource => container_image,
      :section  => "labels",
      :name     => "label_name_#{index}#{secondary_index}",
      :value    => "label_value_#{index}",
      :source   => "source"
    )
  end
end

manager_name   = ARGV[0] || "ocp_manager_small"
batch_size     = ARGV[2].try(:to_i) || 10_000_000_000

# ActiveRecord::Base.logger = Logger.new(STDERR)

sizes = [
  10_000,
  20_000,
  30_000,
  40_000,
  50_000,
  60_000,
  70_000,
  80_000,
  90_000,
  100_000,
]

sizes.each do |total_elements|
  log_size = ((total_elements * 20) / 1000).to_s + "k"

  # ManageIQPerformance.profile do
  _, timings = Benchmark.realtime_block(:ems_total_refresh) do
    generate_batches_od_data(
      :ems_name       => manager_name,
      :total_elements => total_elements,
      :batch_size     => batch_size
    )
  end
  $log.info "ocp_ems TOTAL_BENCH 1st refresh size #{log_size}, #{timings.inspect}"
  puts "ocp_ems TOTAL_BENCH 1st refresh size #{log_size}, #{timings.inspect}"
  # end

  1.times do
    # ManageIQPerformance.profile do
    _, timings = Benchmark.realtime_block(:ems_total_refresh) do
      generate_batches_od_data(
        :ems_name       => manager_name,
        :total_elements => total_elements,
        :batch_size     => batch_size
      )
    end
    $log.info "ocp_ems TOTAL_BENCH 2nd refresh size #{log_size}, #{timings.inspect}"
    puts "ocp_ems TOTAL_BENCH 2nd refresh size #{log_size}, #{timings.inspect}"
    # end
  end
end

puts "finished"