standard_automation_library 0.2.1.pre.temp

data/lib/standard_automation_library/services/slack_service.rb

@@ -0,0 +1,383 @@
+require 'yaml'
+
+require_relative '../api_clients/slack'
+require_relative '../util/path_container'
+require_relative '../util/shared_constants'
+require_relative '../util/slack_constants'
+
+# This class handles all slack related functionality
+class SlackService
+  include SlackConstants
+
+  attr_reader :slack_client
+
+  def initialize(
+    api_key,
+    username_mapping_file_path = nil,
+    valid_email_suffixes = VALID_EMAIL_SUFFIXES,
+    is_dry_run: false
+  )
+    @slack_client = SlackClient.new(
+      api_key,
+      username_mapping_file_path ? PathContainer.new([username_mapping_file_path]) : nil,
+      valid_email_suffixes,
+      is_dry_run: is_dry_run
+    )
+  end
+
+  def post_new_rc_build_announcement(version_details:, rc_releases_link:, commit_title:, channels:)
+    version = version_details['version']
+    build_number = version_details['build_number']
+    formatted_version_details = "*#{version}* (#{build_number})"
+    pr_number = commit_title.scan(/\(#(\d+)\)/).flatten.first
+
+    message = "New *RC* build version #{formatted_version_details} is available on " \
+              "<#{rc_releases_link}|App Center>.\n"
+
+    message += if pr_number
+                 "(PR <https://github.com/plangrid/build-mobile/pull/#{pr_number}/|##{pr_number}>) #{commit_title}"
+               else
+                 "*Commit*: #{commit_title}"
+               end
+
+    send_message(
+      channel_strings: channels,
+      message: message
+    )
+  end
+
+  def post_headsup_announcement(channel_names, version, platform_name)
+    post_announcement(channel_names, version, platform_name, HEADSUP)
+  end
+
+  def post_release_announcement(channel_names, version, platform_name, pretext_addition: nil)
+    post_announcement(
+      channel_names,
+      version,
+      platform_name,
+      RELEASE,
+      pretext_addition: pretext_addition
+    )
+  end
+
+  # Post an announcement with the release notes.
+  def post_announcement(channel_names, version, platform_name, type, pretext_addition: nil)
+    pretext = format_pretext(version, platform_name, type, pretext_addition)
+    attachments = [{
+      pretext: pretext,
+      color: type == HEADSUP ? ATTACHMENT_COLOR_YELLOW : ATTACHMENT_COLOR_GOOD,
+      mrkdwn_in: %w[text pretext]
+    }]
+    channel_ids = @slack_client.unique_channel_ids(channel_names)
+    with_multiple_channels(channel_ids) do |channel_id|
+      @slack_client.update_or_send_message(
+        channel_id,
+        pretext,
+        attachments: attachments
+      )
+    end
+  end
+
+  def format_pretext(version, platform_name, type, pretext_addition)
+    case type
+    when HEADSUP
+      action = 'is coming soon'
+    when RELEASE
+      url_prefix = "https://jira.autodesk.com/issues/?jql=platform+%3D+#{platform_name}+AND+fixVersion+%3D+#{version}"
+      bugs_suffix = "%20AND%20(issuetype%20%3D%20Bug%20OR%20issuetype%20%3D%20'Escalated%20User%20Issue')"
+      features_suffix = "%20AND%20(issuetype%20!%3D%20Bug%20AND%20issuetype%20!%3D%20'Escalated%20User%20Issue')"
+
+      released_tickets_url = "\nRefer to the following links for the list of tickets for the version:" \
+                             "\n• <#{url_prefix}#{features_suffix}|Features>" \
+                             "\n• <#{url_prefix}#{bugs_suffix}|Bugs>"
+      action = 'has been released'
+    else
+      raise "Invalid announcement type: #{type}"
+    end
+
+    pretext = "#{platform_name} version #{version} #{action}! #{pretext_addition}".strip
+    emoji = case platform_name
+            when IOS
+              IOS_SLACK_EMOJI
+            when ANDROID
+              ANDROID_SLACK_EMOJI
+            when WINDOWS
+              WINDOWS_SLACK_EMOJI
+            else
+              ''
+            end
+    formated_text = "#{emoji} #{pretext} #{emoji}".strip
+    formated_text += released_tickets_url if released_tickets_url
+    formated_text
+  end
+
+  def user_hash(user_identifiers, error_if_not_found: false)
+    user_hash = {}
+    user_hash[@slack_client.team_domain] = fetch_user_ids(user_identifiers, error_if_not_found)
+    user_hash
+  end
+
+  def user_slack_tags(user_identifiers, error_if_not_found: false)
+    fetch_user_ids(user_identifiers, error_if_not_found)
+      .map { |user_id| "<@#{user_id}>" }
+      .join(' ')
+  end
+
+  # Send a build related slack message. The repo name is the full repo name. For instance: plangrid/plangrid
+  # message payload is a hash of key value pairs that will be transformed into slack attachment fields.
+  # It is intended that the message_payload be constructed with create_git_message_payload so that it
+  # contains the necessary fields.
+  def send_build_slack(
+    message,
+    channel_strings,
+    message_payload,
+    send_to_channels,
+    team,
+    build_initiator: nil,
+    success: true,
+    mention_on_failure: false
+  )
+    attachment = create_attachment(message, message_payload, success)
+    missed_user_ids = 0
+    message_recipient = build_initiator || message_payload['Git Author']
+
+    attachment_clone = attachment.clone
+    if send_to_channels
+      mention = ''
+      if mention_on_failure && !success
+        slack_user_ids = team.slack_ids(@slack_client.team_domain)
+        slack_user_ids += @slack_client.user_ids([message_recipient]).compact
+        mention = slack_user_ids.uniq.map { |slack_id| "<@#{slack_id}>" }.join(' ').strip
+        mention = '<!here>' if mention.empty?
+      end
+      attachment_clone['text'] = "#{mention} #{attachment_clone['text']}".strip
+      channel_ids = @slack_client.unique_channel_ids(channel_strings)
+      with_multiple_channels(channel_ids) do |channel_id|
+        @slack_client.send_message(
+          channel_name: channel_id,
+          attachments: [attachment_clone]
+        )
+      end
+    else
+      user_ids = @slack_client.user_ids([message_recipient]).compact
+      if user_ids.empty?
+        missed_user_ids += 1
+      else
+        @slack_client.send_message(
+          user_id: user_ids[0],
+          attachments: [attachment_clone]
+        )
+      end
+    end
+
+    return unless missed_user_ids != 0
+
+    mention_users = team.render_slack_ids(@slack_client.team_domain).join(' ').strip
+    mention_users = '<!here>' if mention_users.empty?
+    message = "#{mention_users} Could not send message to #{message_recipient}. " \
+              'Ensure their commit author name or jenkins email address can be looked up in slack, ' \
+              'their first and last name can be composed into an autodesk ' \
+              'email address like first.last@autodesk.com, or that they have an entry in the ' \
+              '<https://github.com/plangrid/build-mobile/blob/dev/common/fastlane/slack_username_mapping.yml|' \
+              "slack_username_mapping.yml>.\n\n" \
+              "Please ping the slack user to run the following commands: \n" \
+              "`git config --global user.name \"Your Slack Name\"` \n" \
+              '`git config --global user.email "first.last@autodesk.com"`'
+    channel_ids = @slack_client.unique_channel_ids(channel_strings)
+    with_multiple_channels(channel_ids) do |channel_id|
+      slack_ids = team.slack_ids(@slack_client.team_domain).compact
+      @slack_client.invite_to_channel_if_needed(channel_id, slack_ids)
+      @slack_client.send_message(
+        channel_name: channel_id,
+        message: message,
+        attachments: [attachment]
+      )
+    end
+  end
+
+  def create_attachment(message, message_payload, success)
+    attachment = { 'text' => message }
+    attachment['fallback'] = message
+    attachment['fields'] = message_payload.map do |key, value|
+      {
+        'title' => key,
+        'value' => value,
+        'short' => false
+      }
+    end
+    attachment['color'] = if success == WARNING
+                            ATTACHMENT_COLOR_YELLOW
+                          else
+                            success ? ATTACHMENT_COLOR_GOOD : ATTACHMENT_COLOR_DANGER
+                          end
+    attachment['mrkdwn_in'] = %w[text fields]
+    attachment
+  end
+
+  # Count test flakes and post a message to the desired channel.
+  def send_flake_message(send_channel_names, flake_channel_names, oldest_flake_time)
+    attachments = []
+    # Search for all channel names at once for efficiency. This primes the channel ID cache.
+    @slack_client.unique_channel_ids(flake_channel_names + send_channel_names)
+    flake_channel_ids = @slack_client.unique_channel_ids(flake_channel_names)
+    return if flake_channel_ids.empty?
+
+    raise 'Found more than one flake channel in a single slack workspace' if flake_channel_ids.size != 1
+
+    flake_channel_id = flake_channel_ids[0]
+    response_json = @slack_client.client.conversations_history(
+      channel: flake_channel_id,
+      oldest: oldest_flake_time,
+      limit: 500
+    )
+    error_message = 'Error getting slack channel history for channel id ' \
+                    "#{flake_channel_id}: #{response_json['error']}"
+    raise exception.class, error_message unless response_json['ok']
+
+    all_flaking_tests = response_json['messages'].flat_map do |message_json|
+      next [] unless message_json['type'] == 'message'
+
+      next [] if message_json.fetch('attachments', []).empty?
+
+      attachment_text = message_json['attachments'][0].fetch('text', '')
+      next [] unless attachment_text.include?('Flaking tests:')
+
+      attachment_text.gsub('Flaking tests:', '').split("\n")[0].strip.split(',').map(&:strip)
+    end.compact
+
+    test_count_map = all_flaking_tests.uniq.to_h do |test_name|
+      [test_name.strip, all_flaking_tests.count(test_name)]
+    end
+    flake_message = test_count_map.keys.sort { |x, y| test_count_map[x] <=> test_count_map[y] }.reverse.map do |key|
+      "#{key}: #{test_count_map[key]}"
+    end.join("\n")
+    flake_message = "Total flakes: #{all_flaking_tests.size}\n#{flake_message}"
+    attachment = {
+      'text' => "Happy Fix-it-Friday! Here are the test flake counts from the past week.\n\n#{flake_message}",
+      'color' => ATTACHMENT_COLOR_YELLOW
+    }
+    attachments << attachment
+
+    send_channel_ids = @slack_client.unique_channel_ids(send_channel_names)
+    with_multiple_channels(send_channel_ids) do |channel_id|
+      attachments.each do |attachment_item|
+        @slack_client.send_message(channel_name: channel_id, attachments: [attachment_item])
+      end
+    end
+  end
+
+  # Iterate over all given channel strings (names or IDs) and call the given block. Only raise
+  # an exception if an exception is encountered running the given block over every channel string.
+  def with_multiple_channels(channel_strings, &_blk)
+    channel_exceptions = []
+    channel_strings.each do |channel_string|
+      yield channel_string
+    rescue StandardError => e
+      channel_exceptions << e
+    end
+    return unless channel_exceptions.size == channel_strings.size && channel_strings.size.positive?
+
+    error_message = channel_exceptions.map do |exception|
+      puts exception.message
+      puts exception.backtrace
+      exception.message
+    end.join("\n\n")
+    raise error_message
+  end
+
+  # Set the channel topic for all channel_strings (names or IDs) across all slack clients
+  def update_channel_topic(channel_strings, &_blk)
+    channel_ids = @slack_client.unique_channel_ids(channel_strings)
+    with_multiple_channels(channel_ids) do |channel_id|
+      yield @slack_client, channel_id
+    end
+  end
+
+  # Send a message to all channel_strings (names or ID's) or user_ids across all slack clients.
+  # Only raise an exception if every message sending attempt raises an exception.
+  def send_message(channel_strings: [], user_strings: [], message: nil, attachments: nil, icon_url: nil)
+    send_message_exceptions = []
+
+    channel_ids = @slack_client.unique_channel_ids(channel_strings)
+    begin
+      # send a message to all channel_strings
+      with_multiple_channels(channel_ids) do |channel_id|
+        @slack_client.send_message(
+          channel_name: channel_id,
+          message: message,
+          attachments: attachments,
+          icon_url: icon_url
+        )
+      end
+    rescue StandardError => e
+      send_message_exceptions << e
+    end
+
+    user_ids = @slack_client.user_ids(user_strings).compact
+    begin
+      with_multiple_channels(user_ids) do |user_id|
+        @slack_client.send_message(
+          user_id: user_id,
+          message: message,
+          attachments: attachments,
+          icon_url: icon_url
+        )
+      end
+    rescue StandardError => e
+      send_message_exceptions << e
+    end
+
+    return unless !send_message_exceptions.empty? &&
+                  send_message_exceptions.size == (channel_ids.size + user_ids.size)
+
+    error_message = send_message_exceptions.map do |exception|
+      puts exception.backtrace
+      exception.message
+    end.join("\n\n")
+    raise exception.class, error_message
+  end
+
+  # Sends an initial message and makes it a thread for the additional messages formatted as Slack API blocks
+  def send_message_in_thread(channel_strings, initial_message, formatted_reply_blocks, slack_ids)
+    send_message_exceptions = []
+
+    channel_ids = @slack_client.unique_channel_ids(channel_strings)
+    begin
+      # send a message to all channel_strings
+      with_multiple_channels(channel_ids) do |channel_id|
+        begin
+          @slack_client.invite_to_channel_if_needed(channel_id, slack_ids.uniq)
+        rescue StandardError => e
+          puts "Error inviting tagged users, #{e.message}"
+        end
+        @slack_client.send_messages_in_thread(channel_id, initial_message, formatted_reply_blocks)
+      end
+    rescue StandardError => e
+      send_message_exceptions << e
+    end
+    return unless !send_message_exceptions.empty? && send_message_exceptions.size == (channel_ids.size)
+
+    error_message = send_message_exceptions.map do |exception|
+      puts exception.backtrace
+      exception.message
+    end.join("\n\n")
+    raise exception.class, error_message
+  end
+
+  def update_or_send_message(channel_names, message, historical_lookup_count: 100)
+    with_multiple_channels(channel_names) do |channel_id|
+      @slack_client.update_or_send_message(
+        channel_id,
+        message,
+        new_message: message,
+        historical_lookup_count: historical_lookup_count
+      )
+    end
+  end
+
+  private
+
+  def fetch_user_ids(user_identifiers, error_if_not_found)
+    @slack_client.user_ids(user_identifiers, error_if_not_found: error_if_not_found)
+  end
+end

data/lib/standard_automation_library/util/automerge_configuration.rb

@@ -0,0 +1,134 @@
+require_relative '../services/merge_driver_service'
+require_relative 'shared_constants'
+
+# Encapsulates the branch configurations that drive automerging.
+class AutomergeConfiguration
+  include SharedConstants
+
+  def initialize(
+    automerge_map,
+    merge_driver_map,
+    git_merge_error_message_cleaner = nil,
+    cycle_check_initiation_type_allow_list = [INITIATION_TYPE_MANUAL]
+  )
+    @automerge_map = automerge_map
+    @merge_driver_service = MergeDriverService.new(merge_driver_map)
+    @git_merge_error_message_cleaner = git_merge_error_message_cleaner
+    validate_automerge_map(cycle_check_initiation_type_allow_list)
+  end
+
+  attr_reader :merge_driver_service
+
+  def validate_automerge_map(cycle_check_initiation_type_allow_list)
+    @automerge_map.each do |key, value|
+      target_branches = value.map { |target_branch_element| target_branch_element[:branch] }
+
+      error_message = "Automerge map contains duplicate target branches for source branch '#{key}'"
+      raise error_message unless target_branches == target_branches.uniq
+
+      size_with_initiation = value.reject { |target_branch_element| target_branch_element[:initiation_type].nil? }.size
+      initiation_type_error_message = 'Not all automerge map entries have initiation types'
+      raise initiation_type_error_message unless value.size == size_with_initiation
+    end
+
+    detect_cycles(@automerge_map, cycle_check_initiation_type_allow_list)
+  end
+
+  # Detect branch cycles anywhere in the automerge map. For each top level
+  # branch traverse all their child paths. Only follow branch paths that
+  # have the same initiation_types
+  def detect_cycles(automerge_map, cycle_check_initiation_type_allow_list)
+    automerge_map.each do |key, value|
+      initiation_types_covered = Set.new
+      value.each do |branch_target|
+        initiation_type = branch_target[:initiation_type]
+        next if initiation_types_covered.include?(initiation_type) ||
+                cycle_check_initiation_type_allow_list.include?(initiation_type)
+
+        cycle_detected_message = "Automerge map cycle detected for branch '#{key}' with " \
+                                 "initiation_type '#{initiation_type}'"
+        raise cycle_detected_message if cycle_detection_dfs(automerge_map, initiation_type, key)
+
+        initiation_types_covered.add(initiation_type)
+      end
+    end
+  end
+
+  # Perform a DFS on the automerge map starting from a specified branch.
+  # Only follow branch paths that have the specified initiation_type
+  def cycle_detection_dfs(automerge_map, initiation_type, starting_branch)
+    seen = Set.new
+    stack = [starting_branch]
+    until stack.empty?
+      branch = stack.pop
+      return true if seen.include?(branch)
+
+      downstream_branch_targets = automerge_map[branch] || []
+      downstream_branch_targets.each do |branch_target|
+        stack << branch_target[:branch] if branch_target[:initiation_type] == initiation_type
+      end
+      seen.add(branch) unless downstream_branch_targets.empty?
+    end
+    false
+  end
+
+  # Check to see if the source/target branch combination specifies static_version  == true
+  # in the automerge map.
+  def should_enforce_static_version?(source_branch, target_branch)
+    elements = @automerge_map.fetch(source_branch, []).select do |target_branch_element|
+      target_branch_element[:branch] == target_branch && target_branch_element[:static_version] == true
+    end
+    !elements.empty?
+  end
+
+  # Retrieve the merge_options for the given source/target branch combination from
+  # the automerge map.
+  def merge_options(source_branch, target_branch)
+    elements = @automerge_map.fetch(source_branch, []).select do |target_branch_element|
+      target_branch_element[:branch] == target_branch
+    end
+    return '' if elements.empty?
+
+    elements[0].fetch(:merge_options, '')
+  end
+
+  def target_branches(branch_name, initiation_type)
+    target_branch_list = @automerge_map[branch_name]
+    return [] if target_branch_list.nil?
+
+    target_branch_list.select do |target_branch_element|
+      target_branch_element[:initiation_type] == initiation_type
+    end.map do |target_branch_element|
+      target_branch_element[:branch]
+    end
+  end
+
+  def clean_merge_error_message(error_message)
+    if @git_merge_error_message_cleaner.nil?
+      error_message
+    else
+      @git_merge_error_message_cleaner.clean_message(error_message)
+    end
+  end
+
+  # Replace slashes in branch names with underscores to makes automerge/ branches singly nested.
+  # Otherwise there is potential that creation of automerge branches would fail due to conflicting
+  # naming because branches are stored in git as file system paths and path segments can only
+  # be directories or files and not both. For example: if a branch named my_branch exists then
+  # attempting to create my_branch/fix will fail.
+  def generate_automerge_branch_name(source_branch, target_branch)
+    "#{AUTOMERGE_BRANCH_PREFIX}#{source_branch.tr('/', '_')}_to_#{target_branch.tr('/', '_')}"
+  end
+
+  def original_source_branch(target_branch, automerge_branch_name)
+    @automerge_map.each do |branch_key, target_branch_list|
+      includes_target_branch = target_branch_list.map do |target_branch_element|
+        target_branch_element[:branch]
+      end.include?(target_branch)
+      if includes_target_branch && generate_automerge_branch_name(branch_key, target_branch) == automerge_branch_name
+        return branch_key
+      end
+    end
+    nil
+  end
+end

data/lib/standard_automation_library/util/bundler.rb

@@ -0,0 +1,18 @@
+require_relative 'shell_helper'
+
+# module for working with bundle commands
+module Bundler
+  def self.bundle(arg_string)
+    ShellHelper.run("bundle #{arg_string}")
+  end
+
+  def self.install(arg_string)
+    bundle("install #{arg_string}")
+  end
+
+  def self.safe_install(arg_string)
+    install(arg_string)
+  rescue StandardError => e
+    e.message
+  end
+end

data/lib/standard_automation_library/util/datetime_helper.rb

@@ -0,0 +1,23 @@
+require 'active_support/core_ext/time'
+require 'date'
+require 'time'
+
+# Module for help datetime related functions
+module DateTimeHelper
+  # Finds a tuesday some number of weeks into the future and returns a Time
+  # on that tuesday at the given hour of day. If this function is called on
+  # a tuesday that current tuesday will not be counted.
+  def self.future_tuesday(number_of_weeks_in_future, hour_of_day = 17)
+    future_tuesday = Date.parse('Tuesday') + (number_of_weeks_in_future * 7)
+    Time.parse(future_tuesday.to_s) + (hour_of_day * 3600)
+  end
+
+  # returns a time on the optionally given date at the hour specified
+  # in the optionally specified time zone
+  def self.time_at_hour(hour, time_zone: nil, date: Date.today)
+    time = Time.utc(date.year, date.month, date.day, hour, 0, 0)
+    time = time.in_time_zone(time_zone) if time_zone
+    utc_offset = time.utc_offset
+    time - utc_offset
+  end
+end

data/lib/standard_automation_library/util/file_content.rb

@@ -0,0 +1,15 @@
+require_relative 'git'
+
+# Module for finding and manipulating file content
+module FileContent
+  def self.find_content_in_file(file_path, regex, git_ref = nil)
+    file_text = Git.file_content(file_path, git_ref)
+    file_text.scan(regex).flatten
+  end
+
+  def self.find_and_replace_content_in_file(file_path, regex, replacement_string)
+    file_text = Git.file_content(file_path)
+    new_file_text = file_text.gsub(regex, replacement_string)
+    File.open(File.join(Git.repo_root_path, file_path), 'w') { |file| file.puts new_file_text }
+  end
+end