shipit-engine 0.31.0 → 0.35.0

data/app/models/shipit/commit.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module Shipit
-  class Commit < ActiveRecord::Base
+  class Commit < Record
     include DeferredTouch
 
     RECENT_COMMIT_THRESHOLD = 10.seconds
@@ -7,42 +8,53 @@ module Shipit
     AmbiguousRevision = Class.new(StandardError)
 
     belongs_to :stack
-    has_many :deploys
     has_many :statuses, -> { order(created_at: :desc) }, dependent: :destroy, inverse_of: :commit
     has_many :check_runs, -> { order(created_at: :desc) }, dependent: :destroy, inverse_of: :commit
     has_many :commit_deployments, dependent: :destroy
     has_many :release_statuses, dependent: :destroy
-    belongs_to :pull_request, inverse_of: :merge_commit, optional: true
+    belongs_to :merge_request, inverse_of: :merge_commit, optional: true
 
     deferred_touch stack: :updated_at
 
-    before_create :identify_pull_request
+    before_create :identify_merge_request
     after_commit { broadcast_update }
     after_create { stack.update_undeployed_commits_count }
 
     after_commit :schedule_refresh_statuses!, :schedule_refresh_check_runs!, :schedule_fetch_stats!,
-                 :schedule_continuous_delivery, on: :create
+      :schedule_continuous_delivery, on: :create
 
-    belongs_to :author, class_name: 'User', inverse_of: :authored_commits
-    belongs_to :committer, class_name: 'User', inverse_of: :commits
-    belongs_to :lock_author, class_name: :User, optional: true, inverse_of: false
+    belongs_to :author, class_name: 'User', optional: true, inverse_of: :authored_commits
+    belongs_to :committer, class_name: 'User', optional: true, inverse_of: :commits
+    belongs_to :lock_author, class_name: 'User', optional: true, inverse_of: false
 
     def author
       super || AnonymousUser.new
     end
 
+    def author=(user)
+      super(user.presence)
+    end
+
     def committer
       super || AnonymousUser.new
     end
 
+    def committer=(user)
+      super(user.presence)
+    end
+
     def lock_author
       super || AnonymousUser.new
     end
 
+    def lock_author=(user)
+      super(user.presence)
+    end
+
     scope :reachable, -> { where(detached: false) }
 
     delegate :broadcast_update, :github_repo_name, :hidden_statuses, :required_statuses, :blocking_statuses,
-             :soft_failing_statuses, to: :stack
+      :soft_failing_statuses, to: :stack
 
     def self.newer_than(commit)
       return all unless commit
@@ -92,7 +104,7 @@ module Shipit
       committer = User.find_or_create_committer_from_github_commit(commit)
       committer ||= Anonymous.new
 
-      new(
+      record = new(
         sha: commit.sha,
         message: commit.commit.message,
         author:  author,
@@ -102,12 +114,18 @@ module Shipit
         additions: commit.stats&.additions,
         deletions: commit.stats&.deletions,
       )
+
+      if record.pull_request?
+        record.pull_request_head_sha = commit.parents.last.sha
+      end
+
+      record
     end
 
     def message=(message)
       limit = self.class.columns_hash['message'].limit
-      if limit && message && message.size > limit
-        message = message.slice(0, limit)
+      if limit && message && message.bytesize > limit
+        message = message.truncate_bytes(limit)
       end
       super(message)
     end
@@ -137,7 +155,7 @@ module Shipit
 
     def refresh_statuses!
       github_statuses = stack.handle_github_redirections do
-        Shipit.github.api.statuses(github_repo_name, sha, per_page: 100)
+        stack.github_api.statuses(github_repo_name, sha, per_page: 100)
       end
       github_statuses.each do |status|
         create_status_from_github!(status)
@@ -152,7 +170,7 @@ module Shipit
 
     def refresh_check_runs!
       response = stack.handle_github_redirections do
-        Shipit.github.api.check_runs(github_repo_name, sha)
+        stack.github_api.check_runs(github_repo_name, sha)
       end
       response.check_runs.each do |check_run|
         create_or_update_check_run_from_github!(check_run)
@@ -254,7 +272,7 @@ module Shipit
     end
 
     def github_commit
-      @github_commit ||= Shipit.github.api.commit(github_repo_name, sha)
+      @github_commit ||= stack.github_api.commit(github_repo_name, sha)
     end
 
     def schedule_fetch_stats!
@@ -280,13 +298,13 @@ module Shipit
       stack.deploys.unsuccessful.where(until_commit_id: id).any?
     end
 
-    def identify_pull_request
+    def identify_merge_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
+      if merge_request = stack.merge_requests.find_by(number: message_parser.pull_request_number)
+        self.merge_request = merge_request
+        self.pull_request_number = merge_request.number
+        self.pull_request_title = merge_request.title
+        self.author = merge_request.merge_requested_by if merge_request.merge_requested_by
       end
 
       self.pull_request_number = message_parser.pull_request_number unless self[:pull_request_number]
@@ -294,8 +312,8 @@ module Shipit
     end
 
     def deploy_requested_at
-      if pull_request&.merged?
-        pull_request.merge_requested_at
+      if merge_request&.merged?
+        merge_request.merge_requested_at
       else
         created_at
       end
@@ -338,7 +356,7 @@ module Shipit
       new_status = status
 
       unless already_deployed
-        payload = {commit: self, stack: stack, status: new_status.state}
+        payload = { commit: self, stack: stack, status: new_status.state }
         if previous_status != new_status
           Hook.emit(:commit_status, stack, payload.merge(commit_status: new_status))
         end

data/app/models/shipit/commit_checks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Shipit
   class CommitChecks < EphemeralCommitChecks
     OUTPUT_TTL = 10.minutes.to_i
@@ -5,17 +6,18 @@ module Shipit
 
     def initialize(commit)
       @commit = commit
+      super(commit)
     end
 
     def synchronize(&block)
-      @lock ||= Redis::Lock.new('lock', redis, expiration: 1, timeout: 2)
+      @lock ||= Redis::Lock.new(key('lock'), Shipit.redis, expiration: 1, timeout: 2)
       @lock.lock(&block)
     end
 
     def schedule
-      return false if redis.get('status').present?
+      return false if Shipit.redis.get(key('status')).present?
       synchronize do
-        return false if redis.get('status').present?
+        return false if Shipit.redis.get(key('status')).present?
 
         initialize_redis_state
       end
@@ -24,34 +26,34 @@ module Shipit
     end
 
     def initialize_redis_state
-      redis.pipelined do
-        redis.set('output', '', ex: OUTPUT_TTL)
-        redis.set('status', 'scheduled', ex: OUTPUT_TTL)
-      end
+      Shipit.redis.set(key('status'), 'scheduled', ex: OUTPUT_TTL)
       @status = 'scheduled'
     end
 
     def status
-      @status ||= redis.get('status')
+      @status ||= Shipit.redis.get(key('status'))
     end
 
     def status=(status)
-      redis.set('status', status)
+      Shipit.redis.set(key('status'), status)
       @status = status
     end
 
     def output(since: 0)
-      redis.getrange('output', since, -1)
+      Shipit.redis.getrange(key('output'), since, -1)
     end
 
     def write(output)
-      redis.append('output', output)
+      Shipit.redis.pipelined do
+        Shipit.redis.append(key('output'), output)
+        Shipit.redis.expire(key('output'), OUTPUT_TTL)
+      end
     end
 
     private
 
-    def redis
-      @redis ||= Shipit.redis("commit:#{commit.id}:checks")
+    def key(key)
+      "commit:#{commit.id}:checks:#{key}"
     end
   end
 end

data/app/models/shipit/commit_deployment.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module Shipit
-  class CommitDeployment < ActiveRecord::Base
+  class CommitDeployment < Record
     belongs_to :task
     has_many :statuses, dependent: :destroy, class_name: 'CommitDeploymentStatus'
 
@@ -19,15 +20,15 @@ module Shipit
       return if github_id?
 
       response = begin
-        create_deployment_on_github(author.github_api)
+        create_deployment_on_github(stack.github_api)
       rescue Octokit::ClientError
-        raise if Shipit.github.api == author.github_api
+        raise if Shipit.github(organization: stack.repository.owner).api == stack.github_api
         # If the deploy author didn't gave us the permission to create the deployment we falback the the main shipit
         # user.
         #
         # Octokit currently raise NotFound, but I'm convinced it should be Forbidden if the user can see the repository.
         # So to be future proof I catch boths.
-        create_deployment_on_github(Shipit.github.api)
+        create_deployment_on_github(stack.github_api)
       end
       update!(github_id: response.id, api_url: response.url)
     end
@@ -56,7 +57,7 @@ module Shipit
             from_sha: task.since_commit.sha,
             to_sha: task.until_commit.sha,
           },
-        },
+        }.to_json,
       )
     end
   end

data/app/models/shipit/commit_deployment_status.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module Shipit
-  class CommitDeploymentStatus < ActiveRecord::Base
+  class CommitDeploymentStatus < Record
     DESCRIPTION_CHARACTER_LIMIT_ON_GITHUB = 140
 
     belongs_to :commit_deployment
@@ -11,15 +12,15 @@ module Shipit
     def create_on_github!
       return if github_id?
       response = begin
-        create_status_on_github(author.github_api)
+        create_status_on_github(stack.github_api)
       rescue Octokit::ClientError
-        raise if Shipit.github.api == author.github_api
+        raise if Shipit.github(organization: stack.repository.owner).api == stack.github_api
         # If the deploy author didn't gave us the permission to create the deployment we falback the the main shipit
         # user.
         #
         # Octokit currently raise NotFound, but I'm convinced it should be Forbidden if the user can see the repository.
         # So to be future proof I catch boths.
-        create_status_on_github(Shipit.github.api)
+        create_status_on_github(stack.github_api)
       end
       update!(github_id: response.id, api_url: response.url)
     end

data/app/models/shipit/commit_message.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Shipit
   class CommitMessage
     GITHUB_MERGE_COMMIT_PATTERN = /\AMerge pull request #(?<pr_id>\d+) from \S+\n\n(?<pr_title>.*)/

data/app/models/shipit/delivery.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
 module Shipit
-  class Delivery < ActiveRecord::Base
+  class Delivery < Record
     STATUSES = %w(pending scheduled sent).freeze
     enum status: STATUSES.zip(STATUSES).to_h
 
     belongs_to :hook
 
-    validates :url, presence: true, url: {no_local: true, allow_blank: true}
+    validates :url, presence: true, url: { no_local: true, allow_blank: true }
     validates :content_type, presence: true
 
     serialize :response_headers, JSON
@@ -36,7 +37,7 @@ module Shipit
     def http
       Faraday::Connection.new do |connection|
         connection.headers = headers
-        connection.adapter Faraday.default_adapter
+        connection.adapter(Faraday.default_adapter)
       end
     end
 

data/app/models/shipit/deploy.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'fileutils'
 
 module Shipit
@@ -14,8 +15,8 @@ module Shipit
       after_transition any => any, do: :update_last_deploy_time
     end
 
-    belongs_to :until_commit, class_name: 'Commit', required: true, inverse_of: :deploys
-    belongs_to :since_commit, class_name: 'Commit', required: true, inverse_of: :deploys
+    belongs_to :until_commit, class_name: 'Commit', required: true
+    belongs_to :since_commit, class_name: 'Commit', required: true
     has_many :commit_deployments, dependent: :destroy, inverse_of: :task, foreign_key: :task_id do
       GITHUB_STATUSES = {
         'pending' => 'pending',
@@ -91,25 +92,28 @@ module Shipit
         env: env&.to_h || {},
         allow_concurrency: force,
         ignored_safeties: force,
+        max_retries: stack.retries_on_rollback,
       )
     end
 
     # Rolls the stack back to this deploy
-    def trigger_rollback(user = AnonymousUser.new, env: nil, force: false)
+    def trigger_rollback(user = AnonymousUser.new, env: nil, force: false, lock: true)
       rollback = build_rollback(user, env: env, force: force)
       rollback.save!
       rollback.enqueue
 
-      lock_reason = "A rollback for #{rollback.since_commit.sha} has been triggered. " \
-        "Please make sure the reason for the rollback has been addressed before deploying again."
-      stack.update!(lock_reason: lock_reason, lock_author_id: user.id)
+      if lock
+        lock_reason = "A rollback for #{rollback.since_commit.sha} has been triggered. " \
+          "Please make sure the reason for the rollback has been addressed before deploying again."
+        stack.update!(lock_reason: lock_reason, lock_author_id: user.id)
+      end
 
       rollback
     end
 
     # Rolls the stack back to the most recent **previous** successful deploy
-    def trigger_revert(force: false)
-      previous_successful_commit = commit_to_rollback_to
+    def trigger_revert(force: false, rollback_to: nil)
+      previous_successful_commit = rollback_to&.until_commit || commit_to_rollback_to
 
       rollback = Rollback.create!(
         user_id: user_id,
@@ -207,7 +211,7 @@ module Shipit
     end
 
     def report_complete!
-      if stack.release_status? && stack.release_status_delay.positive?
+      if stack.release_status? && !stack.release_status_delay.zero?
         enter_validation!
       else
         super
@@ -248,24 +252,12 @@ module Shipit
 
       # Create one for each pull request in the batch, to give feedback on the PR timeline
       commits.select(&:pull_request?).each do |commit|
-        if (pull_request_head = pull_request_head_for_commit(commit))
-          commit_deployments.create!(sha: pull_request_head)
-        end
+        next if commit.pull_request_head_sha.blank? # This attribute was not always populated
+        commit_deployments.create!(sha: commit.pull_request_head_sha)
       end
 
       # Immediately update to publish the status to the commit deployments
       update_commit_deployments
-    rescue Octokit::ClientError => error
-      Rails.logger.warn("Got #{error.class.name} (#{error.message}) when creating CommitDeployments for Deploy##{id}")
-    end
-
-    def pull_request_head_for_commit(commit)
-      pull_request = Shipit.github.api.pull_request(commit.stack.github_repo_name, commit.pull_request_number)
-      pull_request.head.sha
-    rescue Octokit::ClientError => error
-      pr_ref = "#{commit.stack.github_repo_name}##{commit.pull_request_number}"
-      Rails.logger.warn("Got #{error.class.name} (#{error.message}) when loading pull request #{pr_ref}")
-      nil
     end
 
     def update_release_status
@@ -279,10 +271,13 @@ module Shipit
       when 'aborted', 'aborting'
         append_release_status('failure', "The deploy on #{stack.environment} was canceled")
       when 'validating'
-        if stack.release_status_delay.positive?
-          append_release_status('pending', "The deploy on #{stack.environment} succeeded")
-          MarkDeployHealthyJob.set(wait: stack.release_status_delay).perform_later(self)
-        end
+        append_release_status(
+          'pending',
+          "The deploy on #{stack.environment} succeeded"
+        ) unless stack.release_status_delay.zero?
+
+        MarkDeployHealthyJob.set(wait: stack.release_status_delay)
+          .perform_later(self) if stack.release_status_delay.positive?
       when 'success'
         if stack.release_status_delay.zero?
           append_release_status('success', "The deploy on #{stack.environment} succeeded")
@@ -293,7 +288,7 @@ module Shipit
     def trigger_revert_if_required
       return unless rollback_once_aborted?
       return unless supports_rollback?
-      trigger_revert
+      trigger_revert(rollback_to: rollback_once_aborted_to)
     end
 
     def default_since_commit_id

data/app/models/shipit/deploy_spec/bundler_discovery.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Shipit
   class DeploySpec
     module BundlerDiscovery

data/app/models/shipit/deploy_spec/capistrano_discovery.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Shipit
   class DeploySpec
     module CapistranoDiscovery