shipit-engine 0.15.0 → 0.16.0

data/app/controllers/shipit/webhooks_controller.rb

@@ -27,8 +27,7 @@ module Shipit
       end
     end
     def state
-      if params.branches.map(&:name).include?(stack.branch)
-        commit = stack.commits.find_by_sha!(params.sha)
+      if commit = stack.commits.find_by_sha(params.sha)
         commit.create_status_from_github!(params)
       end
       head :ok

data/app/helpers/shipit/github_url_helper.rb

@@ -40,8 +40,14 @@ module Shipit
       github_repo_url(commit.stack.repo_owner, commit.stack.repo_name, 'commit', commit.sha)
     end
 
-    def github_pull_request_url(commit)
-      github_repo_url(commit.stack.repo_owner, commit.stack.repo_name, 'pull', commit.pull_request_number)
+    def github_pull_request_url(pull_request_or_commit)
+      stack = pull_request_or_commit.stack
+      number = if pull_request_or_commit.respond_to?(:pull_request_number)
+        pull_request_or_commit.pull_request_number
+      else
+        pull_request_or_commit.number
+      end
+      github_repo_url(stack.repo_owner, stack.repo_name, 'pull', number)
     end
 
     def link_to_github_deploy(deploy)

data/app/helpers/shipit/shipit_helper.rb

@@ -1,5 +1,14 @@
 module Shipit
   module ShipitHelper
+    def subscribe(url, *selectors)
+      content_for(:update_subscription) do
+        [
+          tag('meta', name: 'subscription-channel', content: url),
+          *selectors.map { |s| tag('meta', name: 'subscription-selector', content: s) },
+        ].join("\n").html_safe
+      end
+    end
+
     def emojify(content)
       h(content).to_str.gsub(/:([\w+-]+):/) do |match|
         if emoji = Emoji.find_by_alias($1)

data/app/helpers/shipit/stacks_helper.rb

@@ -33,16 +33,26 @@ module Shipit
     end
 
     def github_change_url(commit)
-      commit.pull_request_url || github_commit_url(commit)
+      if commit.pull_request?
+        github_pull_request_url(commit)
+      else
+        github_commit_url(commit)
+      end
     end
 
-    def render_commit_message(commit)
-      message = commit.pull_request_title || commit.message
-      content_tag(:span, emojify(message.truncate(COMMIT_TITLE_LENGTH)), class: 'event-message')
+    def render_commit_message(pull_request_or_commit)
+      message = pull_request_or_commit.title.to_s.truncate(COMMIT_TITLE_LENGTH)
+      content_tag(:span, emojify(message), class: 'event-message')
+    end
+
+    def render_pull_request_title_with_link(pull_request)
+      message = render_commit_message(pull_request)
+      link_to(message, github_pull_request_url(pull_request), target: '_blank')
     end
 
     def render_commit_message_with_link(commit)
-      link_to(render_commit_message(commit), github_change_url(commit), target: '_blank')
+      message = render_commit_message(commit)
+      link_to(message, github_change_url(commit), target: '_blank')
     end
 
     def render_commit_id_link(commit)
@@ -53,8 +63,13 @@ module Shipit
       end
     end
 
-    def pull_request_link(commit)
-      link_to("##{commit.pull_request_number}", commit.pull_request_url, target: '_blank', class: 'number')
+    def pull_request_link(pull_request_or_commit)
+      number = if pull_request_or_commit.respond_to?(:pull_request_number)
+        pull_request_or_commit.pull_request_number
+      else
+        pull_request_or_commit.number
+      end
+      link_to("##{number}", github_pull_request_url(pull_request_or_commit), target: '_blank', class: 'number')
     end
 
     def render_raw_commit_id_link(commit)

data/app/jobs/shipit/background_job/unique.rb

@@ -2,12 +2,12 @@ module Shipit
   class BackgroundJob
     module Unique
       extend ActiveSupport::Concern
-
       DEFAULT_TIMEOUT = 10
 
       included do
         around_perform { |job, block| job.acquire_lock(&block) }
         cattr_accessor :lock_timeout
+        on_duplicate :retry
       end
 
       def acquire_lock(&block)
@@ -18,11 +18,29 @@ module Shipit
           timeout: self.class.lock_timeout || 0,
         )
         mutex.lock(&block)
+      rescue Redis::Lock::LockTimeout
+        raise unless self.class.drop_duplicate_jobs?
       end
 
       def lock_key(*args)
         ActiveJob::Arguments.serialize([self.class.name] + args).join('-')
       end
+
+      module ClassMethods
+        ACTIONS = %i(retry drop).freeze
+        ACTIONS_LIST = ACTIONS.map(&:inspect).join(', ').freeze
+        def on_duplicate(action)
+          unless ACTIONS.include?(action)
+            raise ArgumentsError, "invalid action: #{action.inspect}, should be one of #{ACTIONS_LIST}"
+          end
+
+          @on_duplicate = action
+        end
+
+        def drop_duplicate_jobs?
+          @on_duplicate == :drop
+        end
+      end
     end
   end
 end

data/app/jobs/shipit/cache_deploy_spec_job.rb

@@ -6,7 +6,7 @@ module Shipit
       return if stack.inaccessible?
 
       commands = Commands.for(stack)
-      commands.with_temporary_working_directory(commit: stack.commits.last) do |path|
+      commands.with_temporary_working_directory(commit: stack.commits.reachable.last) do |path|
         stack.update!(cached_deploy_spec: DeploySpec::FileSystem.new(path, stack.environment))
       end
     end

data/app/jobs/shipit/merge_pull_requests_job.rb

@@ -0,0 +1,26 @@
+module Shipit
+  class MergePullRequestsJob < BackgroundJob
+    include BackgroundJob::Unique
+    on_duplicate :drop
+
+    def perform(stack)
+      pull_requests = stack.pull_requests.to_be_merged.to_a
+      pull_requests.each do |pull_request|
+        pull_request.refresh!
+        pull_request.reject_unless_mergeable!
+      end
+
+      return false unless stack.allows_merges?
+
+      pull_requests.select(&:pending?).each do |pull_request|
+        pull_request.refresh!
+        begin
+          pull_request.merge!
+        rescue PullRequest::NotReady
+          MergePullRequestsJob.set(wait: 10.seconds).perform_later(stack)
+          return false
+        end
+      end
+    end
+  end
+end

data/app/jobs/shipit/perform_task_job.rb

@@ -52,7 +52,7 @@ module Shipit
     end
 
     def perform_task
-      Bundler.with_original_env do
+      Bundler.with_clean_env do
         capture_all! @commands.install_dependencies
         capture_all! @commands.perform
       end

data/app/jobs/shipit/refresh_pull_request_job.rb

@@ -0,0 +1,8 @@
+module Shipit
+  class RefreshPullRequestJob < BackgroundJob
+    def perform(pull_request)
+      pull_request.refresh!
+      MergePullRequestsJob.perform_later(pull_request.stack)
+    end
+  end
+end

data/app/models/concerns/shipit/deferred_touch.rb

@@ -77,7 +77,12 @@ module Shipit
 
     def schedule_touches
       return unless self.class.deferred_touches
-      touches = self.class.deferred_touches.map { |m, fk, a| [m, self[fk], a].join('|') }
+      deferred_touches = self.class.deferred_touches.reject do |m, _fk, _a|
+        ActiveRecord::NoTouching.applied_to?(m.constantize)
+      end
+      return if deferred_touches.empty?
+
+      touches = deferred_touches.map { |m, fk, a| [m, self[fk], a].join('|') }
       Shipit.redis.sadd(SET_KEY, touches)
       if DeferredTouch.enabled
         Rails.cache.fetch(CACHE_KEY, expires_in: THROTTLE_TTL) do

data/app/models/shipit/anonymous_user.rb

@@ -1,5 +1,9 @@
 module Shipit
   class AnonymousUser
+    def present?
+      false
+    end
+
     def email
       'anonymous@example.com'
     end

data/app/models/shipit/application_record.rb

@@ -0,0 +1,5 @@
+module Shipit
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/shipit/commit.rb

@@ -8,9 +8,11 @@ module Shipit
     has_many :deploys
     has_many :statuses, -> { order(created_at: :desc) }, dependent: :destroy
     has_many :commit_deployments, dependent: :destroy
+    belongs_to :pull_request, inverse_of: :merge_commit
 
     deferred_touch stack: :updated_at
 
+    before_create :identify_pull_request
     after_commit { broadcast_update }
     after_create { stack.update_undeployed_commits_count }
 
@@ -21,7 +23,8 @@ module Shipit
 
     scope :reachable, -> { where(detached: false) }
 
-    delegate :broadcast_update, :github_repo_name, to: :stack
+    delegate :broadcast_update, :github_repo_name, :hidden_statuses, :required_statuses,
+             :soft_failing_statuses, to: :stack
 
     def self.newer_than(commit)
       return all unless commit
@@ -69,12 +72,14 @@ module Shipit
     end
 
     def reload(*)
-      @last_statuses = nil
+      @status = nil
       super
     end
 
-    def self.create_from_github!(commit)
-      from_github(commit).save!
+    def self.create_from_github!(commit, extra_attributes = {})
+      record = from_github(commit)
+      record.update!(extra_attributes)
+      record
     end
 
     def schedule_refresh_statuses!
@@ -112,30 +117,26 @@ module Shipit
       children.detach!
     end
 
-    def pull_request_url
-      parsed && Shipit.github_url("/#{stack.repo_owner}/#{stack.repo_name}/pull/#{pull_request_number}")
+    def pull_request?
+      pull_request_number.present?
     end
 
-    def pull_request_number
-      parsed && parsed['pr_id'].to_i
+    def pull_request_number # TODO: remove in a few versions when it is assumed the commits table was backfilled
+      super || message_parser.pull_request_number
     end
 
-    def pull_request_title
-      parsed && parsed['pr_title']
+    def title
+      pull_request_title || message
     end
 
-    def pull_request?
-      !!parsed
+    def pull_request_title # TODO: remove in a few versions when it is assumed the commits table was backfilled
+      super || message_parser.pull_request_title
     end
 
     def short_sha
       sha[0..9]
     end
 
-    def parsed
-      @parsed ||= message.match(/\AMerge pull request #(?<pr_id>\d+) from [\w\-.\/]+\n\n(?<pr_title>.*)/)
-    end
-
     def schedule_continuous_delivery
       return unless deployable? && stack.continuous_deployment? && stack.deployable?
       ContinuousDeliveryJob.perform_later(stack)
@@ -156,30 +157,8 @@ module Shipit
       )
     end
 
-    def visible_statuses
-      stack.filter_visible_statuses(last_statuses).presence || [UnknownStatus.new(self)]
-    end
-
-    def meaningful_statuses
-      stack.filter_meaningful_statuses(last_statuses).presence || [UnknownStatus.new(self)]
-    end
-
-    def last_statuses
-      @last_statuses ||= statuses.to_a.uniq(&:context).sort_by(&:context).presence || [UnknownStatus.new(self)]
-    end
-
     def status
-      visibles = visible_statuses
-      status = visibles.size > 1 ? StatusGroup.new(significant_status, visibles) : visibles.first
-      missing_statuses.empty? ? status : MissingStatus.new(status, missing_statuses)
-    end
-
-    def significant_status
-      statuses = meaningful_statuses
-      return UnknownStatus.new(self) if statuses.empty?
-      return statuses.first if statuses.all?(&:success?)
-      non_success_statuses = statuses.reject(&:success?)
-      non_success_statuses.reject(&:pending?).first || non_success_statuses.first || UnknownStatus.new(self)
+      @status ||= Status::Group.compact(self, statuses)
     end
 
     def deployed?
@@ -190,24 +169,47 @@ module Shipit
       stack.deploys.unsuccessful.where(until_commit_id: id).any?
     end
 
+    def identify_pull_request
+      return unless message_parser.pull_request?
+      if pull_request = stack.pull_requests.find_by_number(message_parser.pull_request_number)
+        self.pull_request = pull_request
+        self.pull_request_number = pull_request.number
+        self.pull_request_title = pull_request.title
+        self.author = pull_request.merge_requested_by if pull_request.merge_requested_by
+      end
+
+      self.pull_request_number = message_parser.pull_request_number unless self[:pull_request_number]
+      self.pull_request_title = message_parser.pull_request_title unless self[:pull_request_title]
+    end
+
     private
 
+    def message_parser
+      @message_parser ||= CommitMessage.new(message)
+    end
+
     def add_status
-      previous_status = significant_status
+      already_deployed = deployed?
+
+      previous_status = status
       yield
       reload # to get the statuses into the right order (since sorted :desc)
-      new_status = significant_status
+      new_status = status
 
-      payload = {commit: self, stack: stack, status: new_status.state}
-      Hook.emit(:commit_status, stack, payload.merge(commit_status: new_status)) if previous_status != new_status
-      if previous_status.simple_state != new_status.simple_state && (!new_status.pending? || previous_status.unknown?)
-        Hook.emit(:deployable_status, stack, payload.merge(deployable_status: new_status))
+      unless already_deployed
+        payload = {commit: self, stack: stack, status: new_status.state}
+        Hook.emit(:commit_status, stack, payload.merge(commit_status: new_status)) if previous_status != new_status
       end
-      new_status
-    end
 
-    def missing_statuses
-      stack.required_statuses - last_statuses.map(&:context)
+      if previous_status.simple_state != new_status.simple_state
+        if !already_deployed && (!new_status.pending? || previous_status.unknown?)
+          Hook.emit(:deployable_status, stack, payload.merge(deployable_status: new_status))
+        end
+        if new_status.pending? || new_status.success?
+          stack.schedule_merges
+        end
+      end
+      new_status
     end
   end
 end

data/app/models/shipit/commit_message.rb

@@ -0,0 +1,32 @@
+module Shipit
+  class CommitMessage
+    GITHUB_MERGE_COMMIT_PATTERN = %r{\AMerge pull request #(?<pr_id>\d+) from [\w\-./]+\n\n(?<pr_title>.*)}
+
+    def initialize(text)
+      @text = text
+    end
+
+    def pull_request?
+      !!parsed
+    end
+
+    def pull_request_number
+      parsed && parsed['pr_id'].to_i
+    end
+
+    def pull_request_title
+      parsed && parsed['pr_title']
+    end
+
+    def to_s
+      @text
+    end
+
+    private
+
+    def parsed
+      return @parsed if defined?(@parsed)
+      @parsed = to_s.match(GITHUB_MERGE_COMMIT_PATTERN)
+    end
+  end
+end

data/app/models/shipit/deploy.rb

@@ -6,6 +6,7 @@ module Shipit
 
     state_machine :status do
       after_transition to: :success, do: :schedule_continuous_delivery
+      after_transition to: :success, do: :schedule_merges
       after_transition to: :success, do: :update_undeployed_commits_count
       after_transition to: :aborted, do: :trigger_revert_if_required
       after_transition any => any, do: :update_commit_deployments
@@ -163,6 +164,10 @@ module Shipit
       self.deletions = commits.map(&:deletions).compact.sum
     end
 
+    def schedule_merges
+      stack.schedule_merges
+    end
+
     def schedule_continuous_delivery
       return unless stack.continuous_deployment?
       ContinuousDeliveryJob.perform_later(stack)

data/app/models/shipit/deploy_spec.rb

@@ -64,7 +64,7 @@ module Shipit
     alias_method :dependencies_steps!, :dependencies_steps
 
     def maximum_commits_per_deploy
-      config('deploy', 'max_commits')
+      config('deploy', 'max_commits') { 8 }
     end
 
     def pause_between_deploys
@@ -143,6 +143,31 @@ module Shipit
       Array.wrap(config('ci', 'allow_failures'))
     end
 
+    def pull_request_required_statuses
+      if config('merge', 'require') || config('merge', 'ignore')
+        Array.wrap(config('merge', 'require'))
+      else
+        required_statuses
+      end
+    end
+
+    def pull_request_ignored_statuses
+      if config('merge', 'require') || config('merge', 'ignore')
+        Array.wrap(config('merge', 'ignore'))
+      else
+        soft_failing_statuses | hidden_statuses
+      end
+    end
+
+    def revalidate_pull_requests_after
+      if timeout = config('merge', 'revalidate_after')
+        begin
+          Duration.parse(timeout)
+        rescue Duration::ParseError
+        end
+      end
+    end
+
     def review_checks
       config('review', 'checks') || []
     end