facter-statistax 0.0.9 → 0.0.10

data/acceptance/log_performance/performance_times_logging/facter_performance_logs_parser.rb

@@ -0,0 +1,65 @@
+require_relative '../utils'
+
+class FacterPerformanceLogsParser
+  def initialize(statistax_logs_folder, log_files_per_platform)
+    @log_dir_path = statistax_logs_folder
+    @log_files_per_platform = log_files_per_platform
+    @performance_times = {}
+  end
+
+  def extract_performance_times_hash(platform)
+    json_file_paths = FileFolderUtils.get_sub_file_paths_by_type(File.join(@log_dir_path, platform), 'json')
+    if json_file_paths.length != @log_files_per_platform
+      puts "Something went wrong with logs for platform #{platform}. Skipping it!"
+    else
+      results = get_times_for_platform(platform, json_file_paths)
+      @performance_times[platform] = results unless results.empty?
+    end
+    @performance_times
+  end
+
+  private
+
+  def get_times_for_platform(platform, json_log_paths)
+    platform_times = {}
+    json_log_paths.each do |json_path|
+      puts "Parsing log folder #{json_path}"
+      content, facter_type = parse_performance_log(JSONReader.json_file_to_hash(json_path))
+      if content.empty?
+        puts "For platform #{platform}, failed to parse log #{json_path}!"
+        puts "Skipping all logs for platform #{platform}!"
+        return {}
+      end
+      platform_times[facter_type] = content
+    end
+    normalize_hash_structure(platform_times)
+  end
+
+  def parse_performance_log(data)
+    results = {}
+    data_hash = data[0] # the performance data is stored inside a list
+
+    if data_hash['facter_gem?'].nil? || data_hash['facts'].nil?
+      return [{}, '']
+    end
+
+    facter_type = data_hash['facter_gem?'] == 'true' ? 'gem' : 'cpp'
+    data_hash['facts'].each do |fact|
+      results[fact['name']] = fact['average']
+    end
+    [results, facter_type]
+  end
+
+  def normalize_hash_structure(platform_times)
+    # hash is extracted as {cpp/gem => {fact_name => time}}
+    # and is converted to {fact_name => {cpp/gem => time}}
+    normalized_times = {}
+    platform_times.each do |facter_type, fact|
+      fact.each do |fact_name, time|
+        normalized_times[fact_name] ||= {}
+        normalized_times[fact_name][facter_type] = time
+      end
+    end
+    normalized_times
+  end
+end

data/acceptance/log_performance/performance_times_logging/google_sheets.rb

@@ -0,0 +1,133 @@
+require 'google/apis/sheets_v4'
+require 'googleauth'
+require_relative '../utils'
+
+class GoogleSheets
+  APPLICATION_NAME = 'Google Sheets API'.freeze
+  #env var with location of the token file needed to authenticate access to spreadsheet
+  AUTHENTICATION_FILE_ENV_VAR = 'GOOGLE_APPLICATION_CREDENTIALS'.freeze
+
+  def initialize(spreadsheet_id)
+    @spreadsheet_id = spreadsheet_id
+    @service = Google::Apis::SheetsV4::SheetsService.new
+    @service.client_options.application_name = APPLICATION_NAME
+    @service.authorization = Google::Auth::ServiceAccountCredentials.make_creds(
+        json_key_io: File.open(ENV[AUTHENTICATION_FILE_ENV_VAR]),
+        scope: Google::Apis::SheetsV4::AUTH_SPREADSHEETS
+    )
+  end
+
+  def name_and_path_of_pages
+    pages = {}
+    spreadsheet = @service.get_spreadsheet(@spreadsheet_id)
+    spreadsheet.sheets.each do |sheet|
+      pages[sheet.properties.title] = sheet.properties.sheet_id
+    end
+    pages
+  end
+
+  def create_page(page_name)
+    add_sheet_request = Google::Apis::SheetsV4::AddSheetRequest.new
+    add_sheet_request.properties = Google::Apis::SheetsV4::SheetProperties.new
+    add_sheet_request.properties.title = page_name
+    batch_update_spreadsheet([add_sheet: add_sheet_request], "Created page: #{page_name}.")
+  end
+
+  def get_rows_from_page(page_name, range_in_table)
+    normalized_range = A1Notation.convert_to_a1_notation(range_in_table)
+    response = @service.get_spreadsheet_values(@spreadsheet_id, get_sheet_range_string(page_name, normalized_range))
+    response.values.nil? ? [[]] : response.values
+  end
+
+  def write_to_page(rows_list, page_name, range)
+    value_range = Google::Apis::SheetsV4::ValueRange.new(values: rows_list)
+    result = @service.append_spreadsheet_value(@spreadsheet_id,
+                                               get_sheet_range_string(page_name, A1Notation.convert_to_a1_notation(range)),
+                                               value_range,
+                                               value_input_option: 'USER_ENTERED')
+    changed_cells = result.updates.updated_cells
+    puts "#{changed_cells.nil? ? 0 : changed_cells} cells appended."
+  end
+
+  def add_row_with_merged_cells(row, page_name, page_id, range)
+    write_to_page([row], page_name, range)
+    merge_columns(page_id, row, range)
+  end
+
+  def format_range_by_condition(color, page_id, rule, range, success_message)
+    conditional_format_request = Google::Apis::SheetsV4::AddConditionalFormatRuleRequest.new
+
+    conditional_format_rule = Google::Apis::SheetsV4::ConditionalFormatRule.new
+    conditional_format_rule.ranges = [create_grid_range(range, page_id)]
+
+    rule[:values] = [Google::Apis::SheetsV4::ConditionValue.new(user_entered_value: rule[:values])]
+    boolean_rule = Google::Apis::SheetsV4::BooleanCondition.new(rule)
+    format = Google::Apis::SheetsV4::CellFormat.new(background_color: Google::Apis::SheetsV4::Color.new(color.code))
+    conditional_format_rule.boolean_rule = Google::Apis::SheetsV4::BooleanRule.new(condition: boolean_rule, format: format)
+
+    conditional_format_request.index = 0
+    conditional_format_request.rule = conditional_format_rule
+
+    batch_update_spreadsheet([add_conditional_format_rule: conditional_format_request], success_message)
+  end
+
+  private
+
+  def batch_update_spreadsheet(requests_hashes_list, success_message)
+    return if requests_hashes_list.empty?
+
+    batch_update_spreadsheet_request = Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest.new
+    batch_update_spreadsheet_request.requests = requests_hashes_list
+
+    begin
+      @service.batch_update_spreadsheet(@spreadsheet_id, batch_update_spreadsheet_request)
+      puts success_message
+    rescue Google::Apis::ClientError => error
+      puts error.body
+    end
+  end
+
+  def get_sheet_range_string(page_name, range)
+    "#{page_name}!"\
+    "#{range.start_column}#{range.start_row}:"\
+    "#{range.end_column}#{range.end_row}"
+  end
+
+  #on a row, merges every empty cell with the next non empty cell
+  def merge_columns(sheet_id, row_data, start_range)
+    merge_requests = []
+    merge_range = start_range.clone
+    merge_range.end_column = merge_range.start_column
+    row_data.each do |value|
+      if value.empty?
+        merge_range.end_column += 1
+      else
+        merge_requests.append(merge_cells: create_merge_request(merge_range, sheet_id))
+        merge_range.start_column = merge_range.end_column += 1
+      end
+    end
+    batch_update_spreadsheet(merge_requests, 'Merged cells.') unless merge_requests.empty?
+  end
+
+  def create_merge_request(merge_range, sheet_id)
+    #for a merge request, you need to extend the right side column and row index. Eg: to merge cells at A1:B1 you need to give a range of A1:C2
+    range = create_grid_range(merge_range, sheet_id)
+    range.end_column_index += 1
+    range.end_row_index += 1
+
+    merge_cells_request = Google::Apis::SheetsV4::MergeCellsRequest.new
+    merge_cells_request.merge_type = 'MERGE_ROWS'
+    merge_cells_request.range = range
+    merge_cells_request
+  end
+
+  def create_grid_range(range_in_table, sheet_id)
+    range = Google::Apis::SheetsV4::GridRange.new
+    range.sheet_id = sheet_id
+    range.start_column_index = range_in_table.start_column
+    range.start_row_index = range_in_table.start_row
+    range.end_column_index = range_in_table.end_column
+    range.end_row_index = range_in_table.end_row
+    range
+  end
+end

data/acceptance/log_performance/performance_times_logging/log_performance_times.rb

@@ -0,0 +1,20 @@
+require_relative 'facter_performance_logs_parser'
+require_relative 'write_facter_times_to_logger'
+require_relative 'google_sheets'
+require_relative '../configuration'
+
+class LogPerformanceTimes
+  LOG_FILES_PER_PLATFORM = 2
+  FACT_COLUMNS = ['cpp', 'gem', 'gem increase %']
+
+
+  def initialize(statistax_logs_folder)
+    @log_parser = FacterPerformanceLogsParser.new(statistax_logs_folder, LOG_FILES_PER_PLATFORM)
+    @log_writer = WriteFacterTimesToLogger.new(GoogleSheets.new(Configuration::SPREADSHEET_ID), FACT_COLUMNS)
+  end
+
+  def populate_logs_for(platform_name)
+    performance_times = @log_parser.extract_performance_times_hash(platform_name)
+    @log_writer.write_to_logs(performance_times)
+  end
+end

data/acceptance/log_performance/performance_times_logging/table_logging_utils.rb

@@ -0,0 +1,55 @@
+class RangeInTable
+  attr_accessor :start_column, :start_row, :end_column, :end_row
+
+  def initialize(start_column, start_row, end_column, end_row)
+    @start_column = start_column
+    @start_row = start_row
+    @end_column = end_column
+    @end_row = end_row
+  end
+end
+
+module ConditionRule
+  GREATER_THAN = {type: 'CUSTOM_FORMULA', values: '=GT(%<compared_with>s, %<compared>s)'}.freeze
+
+  def self.greater_than(value, start_position)
+    rule = {type: GREATER_THAN[:type]}
+    rule[:values] = format(GREATER_THAN[:values], compared: value, compared_with: A1Notation.convert_start_position(start_position))
+    rule
+  end
+end
+
+class Color
+  attr_accessor :red, :green, :blue
+
+  def initialize(red = 0, green = 0, blue = 0)
+    @red = red
+    @green = green
+    @blue = blue
+  end
+
+  def code
+    {red: @red, blue: @blue, green: @green}
+  end
+end
+
+module A1Notation
+  #In A1 notation row values start from 1, so we'll add a 1 to row values
+  COLUMN_LETTERS = ('A'..'ZZ').to_a
+
+  def self.convert_start_position(range)
+    "#{COLUMN_LETTERS[range.start_column]}#{range.start_row + 1}"
+  end
+
+  def self.convert_to_a1_notation(range)
+    end_column = if range.end_column.nil? or range.end_column == ''
+                   ''
+                 else
+                   COLUMN_LETTERS[range.end_column]
+                 end
+    RangeInTable.new(COLUMN_LETTERS[range.start_column],
+                     range.start_row + 1,
+                     end_column,
+                     range.end_row + 1)
+  end
+end

data/acceptance/log_performance/performance_times_logging/write_facter_times_to_logger.rb

@@ -0,0 +1,109 @@
+require_relative 'table_logging_utils'
+
+class WriteFacterTimesToLogger
+  RULE_RANGE = RangeInTable.new(1, 2, 100, 1000)
+
+  def initialize(logger, facter_columns)
+    @log_writer = logger
+    @columns_each_fact = facter_columns
+  end
+
+  def write_to_logs(times_to_log)
+    return if times_to_log.empty?
+
+    @performance_times = times_to_log
+    create_platform_page
+    page_names = @log_writer.name_and_path_of_pages # done to get pages that are newly created
+    @performance_times.keys.each do |platform|
+      puts "\nWriting results for platform #{platform}\n"
+      facts_order_in_table, page_is_new = create_title_rows(platform, page_names[platform])
+      write_performance_times(facts_order_in_table, platform)
+      add_conditional_formatting(page_is_new, page_names, platform, RULE_RANGE)
+    end
+  end
+
+  private
+
+  def create_platform_page
+    logged_platforms = @log_writer.name_and_path_of_pages.keys
+    platform_name = @performance_times.keys[0]
+    if logged_platforms.include?(platform_name)
+      puts 'Platform page already created.'
+    else
+      @log_writer.create_page(platform_name)
+    end
+  end
+
+  def create_title_rows(platform, page_location)
+    # fact names are stored on the first table row
+    stored_facts = @log_writer.get_rows_from_page(platform, RangeInTable.new(0, 0, nil, 0))[0]
+
+    new_facts = @performance_times[platform].keys - stored_facts
+    # fact names occupy @columns_per_fact cells, so just the last one has the fact name, the rest are empty
+    new_facts_row_with_spaces = new_facts.flat_map { |fact_name| [''] * (@columns_each_fact.size - 1) << fact_name }
+
+    if new_facts.empty?
+      puts 'No new fact names to add.'
+    else
+      # write new fact names from the second column (the first one is reserved for the date) if the page is empty,
+      # or after the last fact name
+      new_facts_append_range = RangeInTable.new(stored_facts.size + 1, 0, nil, 0)
+
+      puts 'Adding fact names.'
+      @log_writer.add_row_with_merged_cells(new_facts_row_with_spaces, platform, page_location, new_facts_append_range)
+      puts 'Adding facter types and gem time increase.'
+      create_facter_type_row(new_facts_row_with_spaces.size, new_facts_append_range.start_column, platform, stored_facts.empty?)
+    end
+    [get_new_facts_order(new_facts_row_with_spaces, stored_facts), stored_facts.empty?]
+  end
+
+  def get_new_facts_order(new_facts_row_with_spaces, stored_facts)
+    stored_facts_order = stored_facts + new_facts_row_with_spaces
+    stored_facts_order.delete('')
+    stored_facts_order
+  end
+
+  def create_facter_type_row(number_of_facts_to_add, write_from_column, platform, add_date_title)
+    facter_types_row = @columns_each_fact * (number_of_facts_to_add / @columns_each_fact.size)
+    if add_date_title
+      facter_types_row = ['Date'].concat(facter_types_row)
+      facter_types_range = RangeInTable.new(0, 1, nil, 1)
+    else
+      facter_types_range = RangeInTable.new(write_from_column, 1, nil, 1)
+    end
+    @log_writer.write_to_page([facter_types_row], platform, facter_types_range)
+  end
+
+  def write_performance_times(facts_order_list, platform)
+    row = [DateTime.now.strftime("%d/%m/%Y %H:%M")] # adding timestamp
+    facts_order_list.each do |fact|
+      if @performance_times[platform][fact].nil?
+        row.concat([''] * @columns_each_fact.size) # skip values for missing fact
+      else
+        populate_data_row(fact, platform, row)
+      end
+    end
+    puts 'Appending performance times.'
+    # range is for the first cell where data should be added on the sheet. If that cell is not empty, the new values will be
+    # appended under it, where possible.
+    @log_writer.write_to_page([row], platform, RangeInTable.new(0, 2, nil, 2))
+  end
+
+  def populate_data_row(fact, platform, row)
+    cpp_fact = @performance_times[platform][fact][@columns_each_fact[0]]
+    gem_fact = @performance_times[platform][fact][@columns_each_fact[1]]
+    gem_percentage_increase = (gem_fact - cpp_fact) / cpp_fact * 100
+
+    row << cpp_fact
+    row << gem_fact
+    row << format('%<time_difference>.2f', time_difference: gem_percentage_increase)
+  end
+
+  def add_conditional_formatting(page_is_new, page_names, platform, rule_range)
+    return unless page_is_new
+
+    success_message = 'Added rule to highlight gem run time increased over 100%!'
+    rule = ConditionRule.greater_than(100, rule_range)
+    @log_writer.format_range_by_condition(Color.new(1), page_names[platform], rule, rule_range, success_message)
+  end
+end

data/acceptance/log_performance/rspec/file_folder_utils_rspec.rb

@@ -0,0 +1,12 @@
+require 'loggers/google_sheets'
+class FileFolderUtilsRspec
+
+  describe FileFolderUtils
+  context “Testing the file_exists method” do
+    it "should call File.file?(file_path)" do
+      SheetsV4 = double("")
+      google_parser = GoogleSheets.new('spreadsheet_is')
+    end
+  end
+
+end

data/acceptance/log_performance/utils.rb

@@ -0,0 +1,41 @@
+require 'json'
+require 'fileutils'
+
+class JSONReader
+  def self.json_file_to_hash(file_path)
+    JSON.parse(File.read(file_path))
+  end
+end
+
+class FileFolderUtils
+  def self.get_children_names(parent_folder_path)
+    begin
+      #all children who's name doesn't start with '.'
+      Dir.entries(parent_folder_path).reject{|entry| entry =~ /^\.+/}
+    rescue Errno::ENOENT
+      puts "No #{parent_folder_path} folder found!"
+      []
+    end
+  end
+
+  def self.file_exists(file_path)
+    File.file?(file_path)
+  end
+
+  def self.get_sub_file_paths_by_type(parent_folder, file_extension)
+    Dir["#{parent_folder}/**/*.#{file_extension}"].select { |f| File.file? f }
+  end
+
+  def self.create_directories(path)
+    FileUtils.mkdir_p(path) unless File.exist?(path)
+  end
+end
+
+module TimedMethods
+  def self.get_run_time(&block)
+    time = Benchmark.measure do
+      yield block
+    end
+    (time.real / 60).round(2)
+  end
+end

data/acceptance/run/run_statistax.rb

@@ -1,49 +1,65 @@
 # frozen_string_literal: true
 
 require 'pathname'
+require_relative '../log_performance/performance_times_logging/log_performance_times'
+
+def correct_platform_name(agent)
+  if agent['platform'].include?('aix')
+    agent.to_s.split('-')[0].sub(/aix(\d)(\d)/, 'aix-\1.\2') + '-power'
+  elsif agent.has_key?('template') && agent['template'].include?('fips')
+    agent['template']
+  else
+    agent['platform']
+  end
+end
+
+def run_statistax(agent, home_dir, is_gem)
+  content = ::File.read(File.join(Pathname.new(File.expand_path('..', __dir__)), 'config.json'))
+  create_remote_file(agent, "#{home_dir}/config.json", content)
+  if agent['platform'] =~ /windows/
+    puppetbin_path = '"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/puppet/bin":"/cygdrive/c/Program Files/Puppet Labs/Puppet/puppet/bin"'
+    on agent, %( echo 'export PATH=$PATH:#{puppetbin_path}' > /etc/bash.bashrc )
+    on agent, "statistax.bat config.json #{is_gem}"
+  else
+    on agent, "statistax #{home_dir}/config.json #{is_gem}"
+  end
+end
+
+def save_output(agent, home_dir, host_dir, is_gem)
+  out_dir = File.join(host_dir, is_gem ? 'gem' : 'cpp')
+
+  FileUtils.mkdir_p(out_dir)
+  scp_from agent, "#{home_dir}/log/output.json", out_dir
+end
+
 test_name 'Run facter statistax' do
+  log_dir = File.join(File.expand_path('..', __dir__), "log_dir")
+
   agents.each do |agent|
-    is_gem = 'false'
-    home_dir = on(agent, 'pwd').stdout.chop
-    host_dir = File.join(Pathname.new(File.expand_path('..', __dir__)), "log_dir/#{agent['platform']}")
+    is_gem        = false
+    home_dir      = on(agent, 'pwd').stdout.chop
+    platform_name = correct_platform_name(agent)
+    host_dir      = File.join(log_dir, "#{platform_name}")
 
     step 'Run facter statistax for Cfacter' do
-      content = ::File.read(File.join(Pathname.new(File.expand_path('..', __dir__)), 'config.json'))
-      create_remote_file(agent, "#{home_dir}/config.json", content)
-      if agent['platform'] =~ /windows/
-        puppetbin_path = '"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/puppet/bin":"/cygdrive/c/Program Files/Puppet Labs/Puppet/puppet/bin"'
-        on agent, %( echo 'export PATH=$PATH:#{puppetbin_path}' > /etc/bash.bashrc )
-        on agent, "statistax.bat config.json #{is_gem}"
-      else
-        on agent, "statistax #{home_dir}/config.json #{is_gem}"
-      end
+      run_statistax(agent, home_dir, is_gem)
     end
 
     step 'Save output' do
-      out_dir = File.join(host_dir, 'cpp')
-
-      FileUtils.mkdir_p(out_dir)
-      scp_from agent, "#{home_dir}/log/output.json", out_dir
+      save_output(agent, home_dir, host_dir, is_gem)
     end
 
     step 'Run facter statistax for facter-ng' do
       is_gem = 'true'
-      content = ::File.read(File.join(Pathname.new(File.expand_path('..', __dir__)), 'config.json'))
-      create_remote_file(agent, "#{home_dir}/config.json", content)
-      if agent['platform'] =~ /windows/
-        puppetbin_path = '"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/puppet/bin":"/cygdrive/c/Program Files/Puppet Labs/Puppet/puppet/bin"'
-        on agent, %( echo 'export PATH=$PATH:#{puppetbin_path}' > /etc/bash.bashrc )
-        on agent, "statistax.bat config.json #{is_gem}"
-      else
-        on agent, "statistax #{home_dir}/config.json #{is_gem}"
-      end
+      run_statistax(agent, home_dir, is_gem)
     end
 
-    step 'Save output' do
-      out_dir = File.join(host_dir, 'cpp')
+    step 'Save output to files' do
+      save_output(agent, home_dir, host_dir, is_gem)
+    end
 
-      FileUtils.mkdir_p(out_dir)
-      scp_from agent, "#{home_dir}/log/output.json", out_dir
+    step 'Copy results to Google spreadsheet' do
+      LogPerformanceTimes.new(log_dir).populate_logs_for(platform_name)
     end
   end
 end